Documentation MCP Server: Context7 MCP for current library docs

Why your AI assistant writes deprecated code

A model's weights are frozen on a date. Everything it knows about a library is a snapshot taken before that date, blended across every version that existed at the time. Ask it about something stable and that is fine. Ask it about a library that shipped a new major two months ago and the answer arrives with the same confidence and the wrong API.

This is not the model being careless. It has no way to know which version you have installed, and no way to fetch the current docs on its own. So it averages what it saw. That average is often a version you stopped using a year ago.

The symptom people notice first is that Claude keeps using outdated library versions, or that Cursor suggests old API methods that are not on the object they have. The cause is the same in both cases: nothing in the loop has read the current documentation.

What this looks like in practice

If several of these are familiar, the training cutoff is what you are fighting, not prompt wording.

• The generated code calls a method that does not exist on the type you have installed.
• An import path is wrong because the package reorganised its exports in a major you already upgraded to.
• The model writes code for the wrong package version and defends it when challenged.
• You are told to use a helper that was deprecated, then removed.
• Config examples match an older major of the framework, so the app fails at boot rather than at the line you asked about.
• Rewording the prompt changes the tone of the answer but not the version it targets.

What a documentation MCP server is

MCP is the Model Context Protocol: a standard way for an AI coding tool to call an external tool and get text back. A documentation MCP server is an MCP server for library documentation, and nothing more exotic than that.

The editor connects to it once. From then on, when a prompt needs to know how a library actually works, the client can call the server, get the current docs for that library, and hand them to the model before it writes anything. The docs travel in the prompt, so the model is reading rather than recalling.

That is the whole category. An up-to-date docs MCP is not a plugin that rewrites the model's answer after the fact, and it is not a bigger model. It is a retrieval step in front of one.

How it works, concretely

Context7 MCP exposes two tools. A client with the server connected can call them on its own, or you can force the issue by adding use context7 to a prompt.

1. resolve-library-id maps a name you typed, like Next.js, to the library Context7 has indexed.
2. get-library-docs fetches the current documentation for that library, with an optional topic filter and a token limit so you are not pasting a whole manual into the context window.
3. The fetched text is injected into the model's context, and only then does the model answer.

Install it

Claude Code is one command, in the box at the top of this page. It is a remote HTTP server, so there is no package to install and no local process to keep alive. Restart Claude Code afterwards and run claude mcp list to confirm context7 is there.

Other editors take JSON with the same endpoint, https://mcp.context7.com/mcp, and each one wants that JSON in a different file with slightly different keys. The per-client pages have the exact snippet: /cursor, /vscode, /claude, /windsurf. The short version of the install is on /install.

Versus letting the model search the web

Web search and a documentation MCP overlap, and for a quick factual lookup search is fine. They diverge on precision.

Search returns pages about a library: blog posts, Stack Overflow answers, tutorials written against whichever version was current when the author wrote them. That is the same version-blending problem as the training data, only fresher. A documentation MCP returns the library's own documentation, scoped to a library you named, which is a much narrower thing to be wrong about.

Search also costs a round trip through a search engine and whatever the crawler happens to surface that day. The tradeoff runs the other way for anything that is not library documentation: release gossip, comparisons, and pricing are search questions, not docs questions.

Versus building your own RAG over docs

You can scrape the docs you care about, chunk them, embed them, and query that index yourself. People do, and it works. It is also a pipeline you now own: re-crawling when a library ships, noticing when a scrape silently breaks, tuning chunking, and paying for the embeddings.

A hosted documentation MCP is that pipeline as somebody else's problem, in exchange for giving up control of it. Build your own when the corpus is yours and private, or when you need retrieval behaviour you cannot get otherwise. Use a hosted one for public library docs, which are the same for everyone and not worth maintaining separately.

Alternatives, and where each one fits

Context7 is not the only documentation MCP, and the honest answer is that the right one depends on which docs you need.

• Microsoft Learn MCP is Microsoft's own server over Microsoft and Azure documentation. If your stack is .NET or Azure, it is authoritative for that in a way a general index is not. It does not help with the rest of npm.
• A general documentation MCP such as Context7 covers a broad catalog of public libraries and frameworks, which is the case most people hit day to day.
• Framework-specific MCP servers are appearing from individual projects. When one exists for the single library you spend all your time in, it will usually be closer to the source than any aggregator.
• Nothing here reads your private repository. If the question is about your own internal package, none of these categories is the answer.

When you do not need this

Worth saying plainly, because installing it for the wrong reason leads to disappointment.

It does not make the model better at programming. Logic bugs, architecture, and naming are unaffected. It does not know your codebase, so it will not answer questions about your own modules. And for a library that has been stable for years, the training data is probably fine and the extra fetch buys nothing.

The case for it is narrow and common: a library that moves faster than the model's cutoff, and a version you can name.