MyMCPTools
Guides7 min read

Best MCP Servers for Ruby Developers in 2026

Top MCP servers for Ruby and Rails developers: GitHub for code review, PostgreSQL for database work, Redis for caching, Docker for containers, Brave Search for documentation, and more.

By MyMCPTools Team·

Ruby developers — and especially Rails developers — work across a rich ecosystem: GitHub for code collaboration, PostgreSQL or MySQL for databases, Redis for caching and background jobs, Docker for containerization, and Sentry for error tracking. The context switching between these systems and your AI assistant costs real time. MCP servers eliminate that friction by giving your AI direct access to the tools already in your stack.

Here are the best MCP servers for Ruby and Rails developers building AI-augmented workflows.

1. GitHub MCP Server — Code Review and Repository Intelligence

GitHub is the center of gravity for most Ruby development: pull requests, code review, issue tracking, Actions workflows, and repository navigation all live there. The GitHub MCP server gives your AI direct access to your repositories — enabling code-aware assistance without copy-pasting files into your chat window.

Key capabilities:

  • Read file contents and directory structure from any branch
  • Search code across your repositories by symbol, pattern, or file type
  • Access pull request diffs, comments, and review threads
  • Read issue details, labels, and linked PRs
  • Check GitHub Actions workflow runs and failure logs

Best for: Pull request review and debugging. Ask "read the diff for PR #412, look at the test file changes, and identify any edge cases in the new billing logic that aren't covered by the test suite" — getting substantive code review help without manually describing what changed.

2. PostgreSQL MCP Server — Rails Database Introspection

Rails developers spend significant time reasoning about database schema: writing migrations, optimizing queries, debugging N+1s, and understanding how ActiveRecord translates to SQL. The PostgreSQL MCP server gives your AI direct access to your actual database schema and query execution — making database work dramatically faster.

Key capabilities:

  • Full schema introspection including tables, columns, indexes, and foreign keys
  • Read-only query execution to explore data and test queries
  • EXPLAIN plan analysis for query optimization
  • Constraint and trigger inspection

Best for: Migration and query work. Ask "look at the schema for the users and subscriptions tables, then write a migration to add a composite index on (account_id, status, created_at) for the subscriptions table that will optimize this query I keep seeing in slow query logs" — getting schema-aware migration help that accounts for your actual data model.

3. Redis MCP Server — Cache and Background Job Debugging

Redis is everywhere in Rails applications: Action Cable, Sidekiq queues, Rails cache, rate limiting, and session storage all commonly use it. When something goes wrong with background jobs or caching behavior, debugging requires poking around in Redis directly. The Redis MCP server gives your AI access to your Redis instance — making cache and queue debugging conversational.

Key capabilities:

  • Key inspection and value retrieval for any Redis data type
  • Pattern-based key scanning to explore namespaces
  • TTL inspection for cache debugging
  • Queue depth and job inspection for Sidekiq debugging

Best for: Sidekiq queue debugging. Ask "scan all keys in the Sidekiq namespace, show me the depth of each queue, identify any jobs that have been in the retry queue for more than 24 hours, and pull the error details from the first three failed jobs" — diagnosing background job failures without opening a Redis CLI and manually navigating key namespaces.

4. Docker MCP Server — Container and Environment Management

Modern Rails development typically involves Docker Compose for local services: the app container, PostgreSQL, Redis, Sidekiq, and potentially Elasticsearch or Kafka. The Docker MCP server gives your AI visibility into your container environment — useful for debugging environment issues and understanding service connectivity problems.

Key capabilities:

  • List running containers with status, ports, and resource usage
  • Read container logs for any service
  • Inspect container environment variables and volume mounts
  • Check network configuration and service connectivity

Best for: Local environment debugging. Ask "check all my running Docker containers, look at the logs from the Rails app container and the PostgreSQL container from the last 10 minutes, and identify what's causing the connection refused error I'm getting when the app tries to query the database" — diagnosing service connectivity issues without manually reading logs from multiple containers.

5. Sentry MCP Server — Error Tracking and Production Debugging

Sentry is the standard for error tracking in production Rails apps. When you get paged about an error spike, the debugging loop starts with Sentry: what's the error, what's the stack trace, what's the frequency, has it happened before? The Sentry MCP server gives your AI direct access to your error data — compressing that debugging loop significantly.

Key capabilities:

  • Query issues by project, status, level, and date range
  • Read full stack traces and exception details
  • Access breadcrumbs and request context for individual events
  • Check issue frequency trends and first/last seen timestamps

Best for: Production incident triage. Ask "pull all new Sentry errors that appeared in the last 2 hours in the production environment, filter to anything with more than 10 occurrences, and for the top three by frequency show me the full stack trace and the request parameters from the most recent event" — triaging an error spike without clicking through Sentry's UI for each issue.

6. Brave Search MCP Server — Documentation and Gem Research

Ruby developers frequently search for gem documentation, ActiveRecord behavior edge cases, Rails version upgrade guides, and community discussions on specific patterns. The Brave Search MCP server gives your AI web search capabilities — enabling research workflows that surface current documentation without browser tab switching.

Key capabilities:

  • Web search with full snippet extraction and source URLs
  • News search for recent gem releases, Rails announcements, and security advisories
  • Privacy-focused — important for searching on sensitive codebase patterns

Best for: Gem evaluation and upgrade research. Ask "search for the current status of the paper_trail gem for Rails 8 compatibility, any known issues with the latest version, and alternative audit logging gems in case paper_trail isn't maintained" — getting a current picture of a gem's health without reading through GitHub issues and changelog entries manually.

7. Filesystem MCP Server — Local Codebase Access

While GitHub MCP covers remote repositories, the Filesystem MCP server gives your AI access to your local working directory — including uncommitted changes, local config files, and generated files that don't live in version control.

Key capabilities:

  • Read and write files in your local project directory
  • Directory traversal for exploring unfamiliar codebases
  • Access local config files including database.yml, credentials, and environment files
  • Read Gemfile.lock for exact dependency resolution

Best for: Local debugging and refactoring. Ask "read the Gemfile.lock, identify all gems with known security vulnerabilities or that are more than two major versions behind current, and then read the initializers directory to find any gems that have custom initialization code that might break during an upgrade" — getting upgrade impact analysis grounded in your actual dependency tree.

Recommended Stacks for Ruby Developers

  • Rails API stack: GitHub + PostgreSQL + Redis + Sentry (code + database + cache/jobs + error tracking)
  • Full-stack Rails stack: GitHub + PostgreSQL + Redis + Docker + Filesystem (code + data + cache + containers + local files)
  • Production debugging stack: Sentry + PostgreSQL + Redis + Brave Search (errors + database queries + job queues + documentation)
  • Complete Ruby developer stack: GitHub + PostgreSQL + Redis + Docker + Sentry + Brave Search + Filesystem — full coverage from code to data to infrastructure to errors

Browse all Coding MCP servers and Database MCP servers on MyMCPTools. For related guides, see Best MCP Servers for Backend Developers and Best MCP Servers for Python Developers.

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

💻

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📘✓
🗄️

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📘✓
🗄️

Redis MCP Server

The Redis MCP Server (redis/mcp-redis) is Redis's own natural-language interface for agentic applications, letting an AI client read and write Redis data over the Model Context Protocol. Note which one you install: the server most tutorials still point at is Anthropic's reference implementation, which now lives in modelcontextprotocol/servers-archived, and its npm package @modelcontextprotocol/server-redis is explicitly marked "Package no longer supported" with a last publish of 2025-04-25. The maintained server is a Python package instead, run with uvx --from redis-mcp-server@latest, and it covers far more of Redis than the reference one did: string, hash, list, set and sorted-set tools; JSON document tools; pub/sub with stateful channel and pattern subscriptions; Streams tools including consumer-group create, read, acknowledge and destroy; vector index management and vector search through the query engine; a docs search tool; and a server-management tool for database info. Connection is a redis:// or rediss:// URL passed as --url, or the REDIS_HOST/REDIS_PORT/REDIS_PWD/REDIS_SSL environment variables, with Redis Cluster mode behind REDIS_CLUSTER_MODE and EntraID service-principal, managed-identity and default-credential auth flows for Azure Managed Redis. There is no --read-only flag: the documented way to stop an agent writing is a Redis ACL user (ACL SETUSER readonlyuser on >pw ~* +@read -@write). Ships as a PyPI package, a GitHub install via uvx, and an official mcp/redis Docker image; stdio transport only.

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📘
🔍

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✓
📁

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✓
🔧

Sentry MCP Server

The Sentry MCP Server is Sentry's official Model Context Protocol integration, purpose-built for human-in-the-loop coding agents like Claude Code, Cursor, and Windsurf. Rather than exposing every Sentry API endpoint, it focuses tightly on developer debugging workflows: searching and triaging issues, pulling stack traces and event details, inspecting performance traces, and querying project/team/org metadata in natural language. The primary deployment is a hosted remote MCP server at mcp.sentry.dev, built on Cloudflare's remote-MCP infrastructure, so most users connect with zero local setup — just add the remote URL to their client. For self-hosted Sentry instances or local development, a stdio transport is also available via npx @sentry/mcp-server, authenticated with a Sentry User Auth Token scoped to org:read, project:read, project:write, team:read, team:write, and event:write. AI-powered search tools (search_events, search_issues) translate natural-language queries into Sentry's query syntax, but require a configured LLM provider (OpenAI, Azure OpenAI, Anthropic, or OpenRouter) — all other tools work without one. Claude Code users can also install it as a plugin (claude plugin install sentry-mcp@sentry-mcp) for automatic subagent delegation whenever a conversation touches Sentry errors, issues, or traces. This turns "why did this deploy break in production" into a direct conversational debugging session instead of tab-switching into the Sentry dashboard.

Auth required📘✓
🔍

Elasticsearch MCP Server

The Elasticsearch MCP Server (elastic/mcp-server-elasticsearch) is Elastic's official server for connecting AI agents to Elasticsearch data over the Model Context Protocol, enabling natural-language querying, analysis, and retrieval across your indices without building custom APIs. Once connected, an assistant can list available indices, inspect field mappings, and run searches or ES|QL queries described in plain English — "show me the top error messages from the last 24 hours" — against an Elasticsearch 8.x or 9.x cluster. Five tools ship in 0.4.x: list_indices, get_mappings, search, esql and get_shards. Important status note: the README now carries a deprecation caution — the standalone server receives only critical security updates going forward, and Elastic has superseded it with the Elastic Agent Builder MCP endpoint at {KIBANA_URL}/api/agent_builder/mcp, available in Elastic 9.2.0+ and Elasticsearch Serverless projects, which is the recommended path for new integrations. The install route also changed at 0.4.0 and this is the trap: 0.3.1 and earlier were published to npm as @elastic/mcp-server-elasticsearch, that package is now marked deprecated on the npm registry and frozen at 0.3.1 (published 2025-07-01), and 0.4.0 onwards ships only as the Docker image docker.elastic.co/mcp/elasticsearch — so every `npx -y @elastic/mcp-server-elasticsearch` config still circulating installs a version two releases behind with no esql tool. The container supports stdio and streamable-HTTP transports (SSE is deprecated); in HTTP mode it listens on :8080 with the MCP endpoint at /mcp and a health check at /ping. Configure it with the `ES_URL` environment variable pointing at your cluster plus either an `ES_API_KEY` or an `ES_USERNAME`/`ES_PASSWORD` pair for authentication; an optional `ES_SSL_SKIP_VERIFY=true` is available for development-only TLS bypass. Run in stdio mode with `docker run -i --rm -e ES_URL -e ES_API_KEY docker.elastic.co/mcp/elasticsearch stdio` and add the equivalent block to your Claude Desktop, Cursor, or VS Code MCP config.

Local📘✓

📚 More from the Blog

Guides

Best MCP Servers for Developers in 2026: The Complete Guide

Discover the top MCP servers that every developer should know about. From filesystem access to database queries, these Model Context Protocol servers supercharge your AI coding workflow.

8 min readGuides

Best MCP Servers for Data Engineering: Database, ETL & Analytics

Top MCP servers for data engineers and analysts. Connect your AI to PostgreSQL, BigQuery, Snowflake, and more for AI-powered data workflows.

7 min readTutorials

Getting Started with MCP: A Beginner's Guide to Model Context Protocol

New to MCP? Learn what Model Context Protocol is, how it works, and how to set up your first MCP server in under 5 minutes. Complete beginner's guide.

10 min read