Best MCP Servers for Goose (2026)

The best MCP servers for Goose are the few that earn their tool budget: GitHub's official server, a docs server that grounds the model, and one data server for whatever you actually query. Goose calls MCP servers "extensions," and because it's a real agent that plans and executes, extra half-useful tools hurt more here than in a chat client — the model picks the wrong one and burns a turn. So the question isn't "which extensions exist," it's "which three or four are worth the slots."

This is the opinionated shortlist for Block's open-source Goose, with the exact config path, honest trade-offs, and what to skip. Every server here is real and linked, and every one runs cleanly as a Goose extension over stdio or a remote URL.

Where Goose reads MCP config (do this first)

Goose stores extensions in ~/.config/goose/config.yaml (on Windows, %APPDATA%\Block\goose\config\config.yaml). Each MCP server is an entry under the extensions: key. Goose supports three transports: stdio for local servers, and sse or streamable_http for remote ones — so you can mix a local Docker server and a hosted URL in the same file.

The cleanest way to add one is goose configure → Add Extension, which prompts for the command and any environment variables. If you'd rather edit by hand, a minimal local (stdio) entry looks like this:

extensions:
  github:
    name: GitHub
    type: stdio
    cmd: docker
    args: [run, -i, --rm, -e, GITHUB_PERSONAL_ACCESS_TOKEN, ghcr.io/github/github-mcp-server]
    envs:
      GITHUB_PERSONAL_ACCESS_TOKEN: ghp_...
    enabled: true
    timeout: 300

A remote server is simpler — type: sse (or streamable_http), a url, and optional headers for an auth token. Goose's own built-in tools use type: builtin; leave those alone. The general steps are in how to add an MCP server, and you can generate a valid block with the config generator.

The tool budget: why three servers, not thirty

Agents degrade past roughly 40 active tools, and the average MCP server exposes about 12 — so you hit the wall at three or four extensions, not fifty. Past that, Goose has too many near-identical tools and starts calling the wrong one, which reads like the model got dumber but is really a config problem. The tool-limit math is written for Cursor, but the arithmetic is the same for any agent, Goose included.

So treat slots as scarce. Every server below does one job the others don't, and most run locally over stdio — as ≈90% of MCP servers do — which keeps latency low and your code off someone else's logs. When in doubt, fewer focused extensions beat one do-everything pile.

The shortlist: MCP servers worth adding to Goose

Start with a code server, a context server, and one data server. Add a fourth only if you'll use it weekly.

Server	Best for	Transport in Goose	Add it if
GitHub MCP Server	Repos, issues, PRs, Actions	stdio (Docker) or remote	You do PR/issue work from Goose
GitMCP	Live docs for any repo	sse (remote, free)	You want fewer hallucinated APIs
Octocode	Deep code research (FS + LSP)	stdio	You investigate large codebases
Package Registry MCP	NPM/PyPI/crates versions + advisories	stdio	You get burned by stale package data
Anyquery	SQL over files, DBs, 40+ apps	stdio	You query structured data often
Graphlit MCP Server	RAG over Slack/Drive/Jira/Linear	remote	Your context lives across SaaS tools

The one everyone should have: GitHub

The GitHub MCP Server is GitHub's official server, and "official" earns its slot — it tracks the API and won't quietly break the way abandoned community forks do. It covers repos, issues, PRs, and Actions, running locally in Docker or as a hosted remote. The trade-off: it's tool-heavy, so it eats a real chunk of your budget. If you only read issues, scope the PAT tightly and don't enable every toolset — Goose lets you disable an extension without deleting it, so trim it down.

Cut hallucinations: GitMCP

GitMCP turns any GitHub repo into a live documentation source, which is the cheapest fix for Goose inventing method signatures. It's a free remote server, so there's nothing to install — add it as an sse extension with the URL and you're done. I reach for this over pasting a whole SDK into context: it grounds Goose on the actual repo docs instead of the model's stale memory. Skip it only if you already run a broader RAG server.

Go deep on code: Octocode

Octocode is the pick when search isn't enough and you need to trace how code actually works. It wires GitHub, the local filesystem, and LSP intelligence into Goose, so the agent can follow definitions and references like a staff engineer reading unfamiliar code. It overlaps with the GitHub server, so run both only if you do heavy investigation — otherwise this replaces it.

Stop trusting stale package data: Package Registry

The Package Registry MCP Server searches NPM, PyPI, crates.io, NuGet, and Go registries — plus GitHub Security Advisories — for current versions. The model's training data is months old; this makes "what's the latest and is it vulnerable" a live lookup instead of a guess. It's small on tools, so it's an easy fourth slot that won't blow your budget.

One data server, chosen by your workflow

Pick exactly one. Anyquery runs SQL over files, databases, and 40+ apps (GitHub, Notion, Chrome, Todoist) and exposes them to Goose over MCP — reach for it if you think in queries. Graphlit MCP Server is the RAG option: ingest and search across Slack, Discord, Google Drive, Jira, and Linear when your real context is scattered across SaaS. Running both is how you blow the budget.

What to skip

Skip the kitchen-sink bundles. Extensions that expose 30+ tools each will swallow your entire budget in two installs and tank Goose's tool selection — the exact failure the tool math predicts.

Skip duplicate coverage. GitHub plus Octocode plus a third code server means three overlapping tool sets competing for the same call. Pick the one that matches how you work, and disable the rest.

Skip community forks of things that have an official server. When an official option exists, the maintenance and security story is simply better — check the official-vs-community badge before adding anything. For ranked options by category, the best MCP servers list and best servers for coding agents do the sorting.

My default Goose stack

For most engineers: GitHub (official) + GitMCP (docs) + Package Registry (versions) + one data server. That's four extensions, comfortably under the ~40-tool ceiling, each doing a distinct job. Swap Octocode in for the GitHub server if your day is code archaeology rather than PR work. Add nothing else until you hit a real gap — then disable one extension before you enable the next.