Guides7 min read

Best MCP Servers for Ruby on Rails Developers in 2026

The top MCP servers for Rails development. Ship features faster with AI assistants that understand your models, schema migrations, and Rails conventions.

By MyMCPTools Team·

Ruby on Rails remains one of the most productive web frameworks ever built — convention over configuration, ActiveRecord, and a mature ecosystem that lets small teams ship ambitious products. MCP servers extend this productivity advantage to your AI assistant, giving it the database schema, code history, and framework context it needs to generate Rails code that actually works.

Here are the MCP servers that matter most for Rails development in 2026.

1. Filesystem MCP Server — Navigate Rails' Convention-Heavy Structure

Rails apps follow strict directory conventions — models, controllers, services, jobs, mailers, and a growing number of concerns. The Filesystem MCP server gives your AI direct access to your app structure so it generates code that follows your existing patterns rather than Rails defaults that may not match your project's conventions.

Key use cases for Rails developers:

  • Read existing ActiveRecord model definitions before generating new ones with the right associations, scopes, and validations
  • Inspect controller patterns before adding new actions — strong params structure, before_action chains, respond_to blocks
  • Browse service objects and concerns to understand how your team wraps complex business logic
  • Navigate config/routes.rb to correctly extend routing when adding resources or namespaces

Best for: All Rails developers — the foundational MCP server for any Rails codebase.

2. PostgreSQL MCP Server — Live Schema Access for ActiveRecord Code

ActiveRecord migrations are Rails' core data layer, but your AI can't see what's actually in your database without direct access. The PostgreSQL MCP server lets your AI inspect your live schema and generate migrations, queries, and model code that matches your actual tables rather than guessed column names.

Key use cases for Rails developers:

  • Generate ActiveRecord migrations that reference actual column types and constraints in your live database
  • Write named scopes and where clauses with correct column names without checking schema.rb manually
  • Debug has_many :through and polymorphic association issues by inspecting actual join table structure
  • Generate complex SQL for ActiveRecord.find_by_sql from live schema inspection rather than guessing

Best for: Rails developers who want AI assistance on schema-dependent queries, migrations, and ActiveRecord associations.

3. Git MCP Server — Track Rails Migration History and Design Decisions

Rails codebases accumulate years of migration decisions — column renames, polymorphic refactors, counter cache additions, and security-driven changes. The Git MCP server gives your AI the history it needs to understand why your schema and code look the way they do, without you explaining every architectural decision.

Key use cases for Rails developers:

  • Review migration history to understand why a column is named a certain way before generating code that references it
  • Inspect STI or polymorphic association commits to understand the original modeling intent
  • Check blame on authentication logic when debugging Devise or custom auth middleware
  • Review Rails version upgrade commits to understand what deprecated APIs were replaced

Best for: Rails teams maintaining long-running applications through multiple Rails major versions.

4. GitHub MCP Server — Rails and Gem Issue Access

The Rails ecosystem — Devise, Sidekiq, Pundit, Active Storage, Action Cable — ships updates and breaking changes regularly. The GitHub MCP server lets your AI pull issue discussions and changelogs directly from gem repos, keeping its suggestions current with what's actually in your Gemfile.lock.

Key use cases for Rails developers:

  • Search Devise GitHub issues for known bugs before debugging authentication edge cases
  • Pull Rails 7.x migration guides when upgrading from 6.x to understand breaking API changes
  • Review Sidekiq GitHub discussions when debugging job retry and error handling behavior
  • Find Active Storage configuration examples from official Rails repo discussions

Best for: Rails developers navigating gem upgrades, Rails version migrations, and Rails API deprecation cycles.

5. Docker MCP Server — Rails Container Debugging

Modern Rails development uses Docker for local parity with production — Rails app + PostgreSQL + Redis + Sidekiq. The Docker MCP server gives your AI visibility into running containers, useful for debugging database connection pool exhaustion, background job failures, and environment-specific configuration issues.

Key use cases for Rails developers:

  • Inspect Rails application container logs to correlate database timeouts with specific controller actions
  • Debug multi-container compose setups — Rails app, PostgreSQL, Redis, Sidekiq worker
  • Check environment variable injection for Rails credentials and secret_key_base in production-like containers
  • Review Sidekiq worker container logs alongside Rails app logs for background job debugging

Best for: Rails developers using Docker Compose for local development with multiple dependent services.

6. Brave Search MCP Server — Current Rails and Gem Documentation

Rails evolves fast — Hotwire/Turbo replacing Turbolinks, Rails 8 authentication generator, import maps replacing Webpacker. Brave Search lets your AI find current Rails documentation and solutions rather than suggesting patterns from outdated versions.

Key use cases for Rails developers:

  • Look up current Rails 7 and 8 Hotwire and Turbo Stream syntax for real-time features
  • Find current Stimulus controller patterns when migrating from jQuery or older JavaScript approaches
  • Research Rails 8 authentication generator syntax vs older Devise-based patterns
  • Check current Active Job adapter configuration for Sidekiq vs GoodJob vs Solid Queue

Best for: Rails developers keeping up with Rails 7/8 changes, Hotwire, and the evolving JavaScript layer.

Recommended MCP Stack for Rails Developers

  • Always active: Filesystem, PostgreSQL, Git
  • Gem and framework questions: GitHub, Brave Search
  • Docker-based local dev: Docker

Rails' biggest AI friction point is schema context — your AI doesn't know what your tables look like, what associations exist, or what your migration history implies. PostgreSQL gives it your live schema. Filesystem gives it your code conventions. Git gives it the history of why things are the way they are. That combination turns Rails AI assistance from generic template generation into actual pair programming on your codebase.

Related guides:

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

📁

Filesystem MCP Server

sandboxed read, write, edit, move and search access to an explicit whitelist of local directories, and it is the reference implementation most other filesystem MCP servers are modelled on. Shipped by Anthropic in the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it is a Node.js server published to npm as @modelcontextprotocol/server-filesystem. The part worth understanding before you install is the access-control model, because there are now two ways to grant directories and they do not compose. Method one is command-line arguments: `npx -y @modelcontextprotocol/server-filesystem /path/one /path/two`. Method two, and the one the maintainers recommend, is MCP Roots — a client that supports the roots protocol sends its roots at initialization, and those roots COMPLETELY REPLACE any directories passed on the command line, then get replaced again on every `notifications/roots/list_changed`. That means allowed directories can change at runtime without restarting the server, but it also means a roots-capable client silently overrides your CLI arguments. If the server starts with no arguments and the client either does not support roots or sends an empty list, initialization throws an error. The tool surface is broad: `read_text_file` (with mutually exclusive `head`/`tail` line windows), `read_media_file` returning base64 image/audio content blocks, `read_multiple_files` which keeps going when individual reads fail, `write_file`, `edit_file`, `create_directory`, `list_directory`, `list_directory_with_sizes`, `move_file`, `search_files`, `directory_tree`, `get_file_info` and `list_allowed_directories`. `edit_file` is the one to learn — it does line-based and multi-line pattern matching with indentation detection and preservation, returns a git-style diff with context, and supports `dryRun: true` so you can preview a change before applying it; the maintainers recommend always running a dry run first. Every operation is refused outside the allowed set, and `list_allowed_directories` is the fastest way to confirm what the server actually believes it can touch.

Local
💻

GitHub MCP Server

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

Auth required📘
💻

Git

Tools to read, search, and manipulate Git repositories. Full Git operations support.

Local
🗄️

PostgreSQL MCP Server

The PostgreSQL MCP server was the Model Context Protocol reference server for Postgres, and it is retired: the source now sits in modelcontextprotocol/servers-archived — a repository GitHub reports as archived, described as "Reference MCP servers that are no longer maintained" — and the npm package @modelcontextprotocol/server-postgres carries a deprecation notice reading "Package no longer supported." It still installs and still runs, which is why most third-party setup articles have not caught up. What it provides is deliberately small: a single tool, query, which executes read-only SQL inside a READ ONLY transaction, plus per-table schema information exposed as MCP resources at postgres://<host>/<table>/schema, with column names and data types discovered from database metadata. There is no index advice, no health check, no separate schema-listing tool, and no write mode. Install is npx @modelcontextprotocol/server-postgres with a postgres:// connection string as the argument. For active work against Postgres, the maintained alternative is Postgres MCP Pro (crystaldba/postgres-mcp), which exposes nine tools including index tuning against hypothetical indexes and a database health check, and has an explicit restricted access mode; if your database is hosted on Supabase or Neon, their platform servers add branching and logs that a raw Postgres connection cannot see. Reach for this archived server only when you want the smallest possible surface — one process, one read-only query tool, nothing else.

Local📘
🔍

Brave Search MCP Server

The Brave Search MCP Server is the official server from Brave that gives AI assistants privacy-first web search through the independent Brave Search API — no tracking, no profiling, and results drawn from Brave's own web index rather than Google or Bing. It exposes five distinct tools that map directly to the Brave Search API endpoints: brave_web_search for general queries with pagination, freshness filters, and safe-search controls; brave_local_search for businesses, restaurants, and points of interest with automatic location filtering; brave_news_search for recent articles and current events; brave_image_search for image discovery; and brave_video_search for finding videos across the web. Authentication uses a single BRAVE_API_KEY (free tier available at brave.com/search/api) or a mounted BRAVE_API_KEY_FILE for Docker-secret setups. Install in Claude Desktop, Cursor, Windsurf, or VS Code with one npx command and choose stdio or streamable-HTTP transport. Because Brave operates its own crawler and index, the Brave Search MCP server is a strong choice for developers who want an alternative to Google-dependent search tools, need reproducible non-personalized results, or care about data privacy in agent workflows — Claude can pull fresh web context, verify facts, and research topics without leaking queries to ad-tech pipelines.

Local
🔧

Docker MCP Server

The Docker MCP server (ckreiling/mcp-server-docker) gives an AI assistant direct control of a Docker daemon over the Model Context Protocol: containers, images, networks and volumes, as tools rather than shell commands. It is the community server most people mean by "Docker MCP" — distinct from Docker’s own Docker MCP Gateway, which does not manage your containers at all but runs *other* MCP servers inside containers. If you want to ask Claude why the postgres container keeps restarting, you want this one; if you want a single secure endpoint in front of twenty catalog servers, you want the gateway. The tool surface is explicit and small enough to reason about: list_containers, create_container, run_container, recreate_container, start_container, fetch_container_logs, stop_container and remove_container for containers; list_images, pull_image, push_image, build_image and remove_image for images; list_networks / create_network / remove_network and list_volumes / create_volume / remove_volume for the rest. Two resource templates, docker://containers/{id}/logs and docker://containers/{id}/stats, let a client read logs and live stats by container ID or name without a tool call. It also ships a docker_compose prompt that puts the model into a plan-then-apply loop — you describe the containers you want under a project name, the model proposes a concise plan, and nothing runs until you approve it; reopening the prompt with the same project name re-reads the state of everything created under it, which is how you clean up after a lost chat. It runs on the Python Docker SDK’s from_env, so DOCKER_HOST applies: set ssh://user@host and the same server administers a remote engine. Two limits are deliberate and stated by the project — privileged options like --privileged and --cap-add/--cap-drop are not supported, and container configuration passes through the model, so no secrets belong in it.

Local📘

📚 More from the Blog