Awesome Codex MCP Servers

Translations: English · 简体中文 · 繁體中文 · 日本語 · 한국어 · Español · Français · Deutsch · Português · add yours →

A curated, hype-free catalog of Model Context Protocol (MCP) servers that give OpenAI Codex hands and eyes — across the Codex CLI, the IDE extension, and Codex cloud.

Browse the searchable directory → — search, filter by category, language, and hosting, and grab a config snippet in one click.

The Model Context Protocol is an open standard for connecting AI apps to external tools, data, and services. Codex is the client (host); each server below exposes tools, resources, or prompts that Codex can call. Because MCP is a standard, most of these servers also work in Cursor, Claude, and other clients — the only thing that changes is the config format. If you're on Claude, see the sibling list: awesome-claude-mcp-servers.

This list favors signal over volume: servers that people actually run, that are maintained, and that do one thing well. Every entry is tagged so you can scan by language, where it runs, and who stands behind it.

Contents

• How to read this list
• Getting started with Codex
• Starter kits
• Safety and good hygiene
• Aggregators and gateways
• Developer tools and version control
• Browser automation
• Web search and scraping
• Databases and data warehouses
• Knowledge and memory
• Files and document handling
• Cloud, infrastructure and devops
• Monitoring and observability
• Security
• Communication
• Productivity and project management
• Finance and payments
• Design and creative
• AI, data and analytics
• Maps and location
• Media and entertainment
• Science and research
• Everything else
• Related lists
• Contributing

How to read this list

Every entry looks like this:

- [Name](link) - What it does, in one plain sentence. `Lang` `runs` `source`

The trailing tags are the fast-scan metadata:

Language — TS TypeScript · Py Python · Go Go · Rust Rust · C# C# · Java Java · JS JavaScript · Ruby Ruby

Runs — local runs on your machine as a subprocess over stdio · remote a hosted HTTP endpoint you point Codex at · local/remote ships both

Source — reference an official reference server from the MCP project · official maintained by the product's own vendor · archived an archived reference server, still usable but no longer maintained. Entries with no source tag are community-maintained.

No stars, no install counts — those go stale the day you write them. Popularity lives in the Starter kits instead.

Getting started with Codex

MCP servers connect over two transports: stdio (a local subprocess) and streamable HTTP (a remote endpoint, optionally behind OAuth). Codex keeps both in one file — ~/.codex/config.toml — and the CLI and IDE extension share it.

Add a server from the CLI

Add a local (stdio) server. Everything after -- is the command Codex will launch:

codex mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem ~/Projects

Add a remote (streamable HTTP) server with a bearer token read from an env var:

codex mcp add github --url https://api.githubcopilot.com/mcp/ \
  --bearer-token-env-var GITHUB_PAT

Manage them with codex mcp list, codex mcp get <name>, and codex mcp remove <name>. Inside the Codex TUI, /mcp lists configured servers. Run codex mcp --help to confirm the exact subcommands on your version.

Or edit ~/.codex/config.toml directly

A local (stdio) server is a [mcp_servers.<name>] table:

[mcp_servers.context7]
command = "npx"
args = ["-y", "@upstash/context7-mcp"]

# Optional: forward specific environment variables to the server
[mcp_servers.context7.env]
CONTEXT7_API_KEY = "your-token"

A remote (streamable HTTP) server uses url plus the name of an env var holding the token:

[mcp_servers.figma]
url = "https://mcp.figma.com/mcp"
bearer_token_env_var = "FIGM…[redacted]"

Useful per-server knobs:

| Field | Default | What it does | |-------|---------|--------------| | startup_timeout_sec | 10 | How long to wait for the server to initialize. Raise it for slow first-time npx/uvx downloads. | | tool_timeout_sec | 60 | Per-tool execution timeout. | | enabled | true | Turn a server off without deleting its config. | | enabled_tools / disabled_tools | — | Allowlist or denylist tool names to keep the surface small. |

Enabling streamable HTTP

Remote MCP support in Codex rides on an experimental Rust MCP client that has been stabilizing across releases. If a url-based server won't connect — or its OAuth login fails — enable the client explicitly, then re-check codex --version:

# Newer builds:
[features]
rmcp_client = true

# Older builds used a top-level flag instead:
# experimental_use_rmcp_client = true

Streamable HTTP on Windows is the roughest edge right now; stdio servers are the most reliable path there.

Same config, CLI and IDE

The Codex IDE extension reads the same ~/.codex/config.toml, so a server you add once works in both. A project-scoped .codex/config.toml overrides it, but only loads once you've marked the project as trusted.

Starter kits

You do not want thirty servers. Every server's tool definitions are spent from the same context window as your actual work, and Codex gets worse at picking the right tool as the count climbs — keep it lean and use enabled_tools/disabled_tools to trim noisy ones. Install a small set that matches what you're doing.

The coding stack — the high-leverage set for Codex CLI:

• Context7 - up-to-date, version-pinned library docs so Codex stops guessing APIs.
• GitHub - issues, PRs, code search, and Actions, so Codex participates in the repo.
• Playwright - drive and verify a browser for UI work and end-to-end checks.
• Serena - symbol-level code navigation and edits for large codebases.
• Sentry - pull real production errors and stack traces while you fix them.

The first launch of an npx/uvx server downloads the package, which can blow past the default 10-second startup window. If a server flaps on first run, raise startup_timeout_sec before assuming it's broken.

The knowledge stack — for research, writing, and automation:

• Fetch - turn any URL into clean markdown.
• Brave Search - real-time web grounding.
• Filesystem - let Codex read and write local files.
• Memory - persist facts across sessions.
• Notion or Obsidian - connect your knowledge base.

Safety and good hygiene

MCP hands a model real capabilities. Treat every server like a dependency you're installing with credentials attached.

• Install servers you trust. A malicious server can hide instructions inside its tool descriptions (tool poisoning) and can change them after you approve it. Prefer reference and official servers, or read the source.
• Scope credentials down. Give database and API servers read-only access to anything production, and use fine-grained, least-privilege tokens. A GitHub PAT for an agent should not be able to force-push.
• Prompt injection is real. A server that reads external content — a GitHub issue, a web page, an email — can carry instructions that try to hijack the agent. Keep write-capable and content-reading servers separate where you can.
• Mind the token budget. Each server's tool definitions cost context before any work happens; some large servers cost tens of thousands of tokens. Fewer, sharper servers beat a kitchen sink.
• Pin versions. Pin npx/uvx package versions for anything sensitive, and bind local HTTP servers to 127.0.0.1.

Aggregators and gateways

Run and manage many servers behind one endpoint — routing, auth, tool filtering, and namespacing.

• MetaMCP - Aggregate MCP servers into namespaced endpoints with middleware, auth, and a GUI. TS local/remote
• Docker MCP Gateway - Run and manage MCP servers as isolated, signed Docker containers. Go local/remote official
• mcp-proxy - Bridge stdio and SSE/streamable-HTTP so any server reaches any client. Py local
• MCP Context Forge - Federate REST, MCP, and A2A tools behind a single gateway. Py remote
• agentgateway - Data-plane proxy for agents and MCP with security and governance controls. Rust remote
• Klavis - Hosted or self-hosted platform that serves and manages MCP integrations at scale. Py local/remote
• Unla - Lightweight gateway that turns existing MCP servers into managed endpoints. Go remote
• MCP Router - Desktop app that routes, manages, and aggregates local MCP servers. TS local
• MCPJungle - Self-hosted MCP registry and proxy for enterprise agent fleets. Go remote
• Nexus - Gateway that aggregates MCP servers and LLM providers behind one API. Rust remote
• 1MCP - Aggregate multiple MCP servers into a single unified endpoint. TS local/remote
• Magg - Meta-MCP hub for autonomous discovery, install, and orchestration of servers. Py local
• mcgravity - Proxy that composes many MCP servers into one load-balanced endpoint. TS local
• pluggedin-mcp - Unify servers with tool and resource discovery plus a playground. TS local

Developer tools and version control

• GitHub - Manage repositories, issues, pull requests, code search, and Actions. Go local/remote official
• Git - Read, search, and manipulate local Git repositories. Py local reference
• Serena - Symbol-level code retrieval and editing powered by