Context7 MCP

The score is weighted around Context7's central promise: current, accurate, version-aware documentation retrieval. Ease of installation matters, but freshness, source resolution, coverage and external-content safety matter more because they determine whether the retrieved context is actually trustworthy.

Context7 MCP is a documentation-retrieval MCP server from Upstash. It gives AI coding agents access to current library, framework, SDK, API, CLI and cloud-service documentation instead of forcing the model to answer only from its training data.

Context7 solves a specific coding problem: software documentation changes faster than model training data. An AI model can remember an old Next.js API, deprecated Prisma syntax, an earlier Stripe SDK method or configuration from the wrong framework version. Context7 retrieves documentation during the current coding session and adds the relevant material to the model's working context.

It is therefore a documentation source for an AI agent, not a general autonomous coding server. The normal retrieval surface does not edit project files, execute shell commands, create GitHub commits or modify infrastructure.

Official project: github.com/upstash/context7 ↗

Context7 MCP performs two core operations: it identifies the correct library or documentation source with resolve-library-id, then retrieves documentation and code examples for a specific question with query-docs.

A known Context7 library ID removes the first resolution step. Context7 recommends supplying an exact ID when available and selecting an explicit version when version-specific documentation matters.

MCP package and workflow: official repository ↗

Context7 uses a two-stage retrieval process: source resolution first, documentation retrieval second. The agent identifies the most appropriate library source, then asks a focused question against that source.

Library resolution

Context7 can rank candidates using signals such as exact name match, description relevance, snippet count, source reputation and benchmark score. When a user requests a specific version, version-specific library IDs should take priority.

Focused documentation retrieval

query-docs works best with one specific concept at a time. A query such as Next.js middleware authentication is more useful than mixing authentication, routing, caching, images and databases into one broad request.

Why resolution accuracy matters

A retrieval system can return accurate passages from the wrong project, community mirror, repository, version or documentation source. Excellent retrieval against the wrong source still produces the wrong answer. MCPVerdict therefore treats source selection and version selection as part of Context7's accuracy rather than as a trivial preprocessing step.

Context7 documentation is freshness-managed rather than universally real-time. Automatic refresh thresholds vary by library popularity.

When a stale library is requested, Context7 can trigger a background refresh. The important limitation is that the request that triggers the refresh can still receive the existing indexed documentation while the newer material is prepared for later requests.

That changes the meaning of “up to date.” Popular libraries can be refreshed on a one-day threshold, while long-tail projects may legitimately lag upstream documentation for weeks.

Version selection improves reliability when several documentation generations coexist. Asking for “Next.js 14 middleware” gives Context7 a more precise target than asking for “Next.js middleware.”

Freshness rules: Context7 library updates documentation ↗

The simplest setup uses npx ctx7 setup. Context7 can configure supported coding agents automatically, while manual MCP clients can connect to the hosted endpoint at https://mcp.context7.com/mcp.

npx ctx7 setup

The setup flow can choose MCP mode or CLI + Skills mode. Context7 also supports local stdio execution through the @upstash/context7-mcp package.

Hosted MCP URL

https://mcp.context7.com/mcp

Local stdio package

npx -y @upstash/context7-mcp

The packaged MCP bundle currently requires Node.js 20.18.1 or later. Remote HTTP avoids the need to run the Node MCP process locally.

Verify the connection

1. Confirm Context7 appears in the client's MCP/tool list.
2. Ask the agent to resolve a well-known library.
3. Run one specific documentation query.
4. Check that the returned version/source matches the intended library.
5. Only then rely on automatic retrieval for more complex work.

Setup resources: Context7 install guide ↗

An API key is not required for every basic documentation lookup. Anonymous access is supported at lower limits, while authentication provides higher limits and access to account-specific features such as private repositories.

Context7 API keys use the ctx7sk-... format. Keys can be individually named and revoked from the dashboard.

Local stdio authentication

A local MCP process can receive the credential through CONTEXT7_API_KEY or an --api-key argument.

Remote authentication

Remote clients can use bearer authentication, and OAuth is increasingly supported by current client/setup flows.

The key does not control the user's GitHub account, filesystem or cloud infrastructure. Its blast radius is primarily Context7 quota and private Context7/teamspace access where enabled.

API-key documentation: Context7 API keys ↗

Context7 works with MCP-compatible coding clients and publishes configurations for Claude Code, Cursor, Codex, OpenCode, Google Antigravity, VS Code, JetBrains-based environments and other clients.

The selected LLM does not itself control the MCP connection. Claude Code, Codex, Cursor and other clients connect to Context7 as a tool source; the active model receives the retrieved documentation through that client.

Client reference: all supported client configurations ↗

Claude Code can install Context7 with npx ctx7 setup --claude. The current Context7 setup supports MCP or CLI-based documentation workflows and can use OAuth during guided configuration.

npx ctx7 setup --claude

Context7 also publishes a Claude Code plugin:

claude plugin marketplace add upstash/context7
claude plugin install context7@context7-marketplace

An API key can be supplied through CONTEXT7_API_KEY; supported anonymous access uses lower limits.

Context7 has the highest value in Claude Code when the task depends on an external library version: Next.js routing changes, current SDK methods, migrations between major package versions or configuration syntax that may have changed after model training.

Claude Code setup: Context7 for Claude Code ↗

Codex can use Context7 through its plugin system, a local MCP process or a remote MCP server configuration. The remote option points to the hosted Context7 endpoint, while the local option starts @upstash/context7-mcp through npx.

Context7's current Codex plugin commands are:

codex plugin marketplace add upstash/context7
codex plugin add context7@context7-marketplace

Local MCP execution can use:

npx -y @upstash/context7-mcp

Remote configuration points to:

https://mcp.context7.com/mcp

The remote path removes the need to run the MCP package locally. The local path retains a local MCP process but still uses Context7's documentation service unless an Enterprise on-premise deployment is configured.

Cursor, Google Antigravity and OpenCode can all connect to Context7. Cursor and OpenCode have dedicated setup flows, while Antigravity supports standard remote HTTP or local stdio MCP configuration.

Context7 with Cursor

npx ctx7 setup --cursor

Context7 can then retrieve documentation from Cursor when library-specific information is required. Cursor supports project-level and global MCP configurations.

Context7 with Google Antigravity

Antigravity can connect to the hosted Context7 endpoint with appropriate authentication or launch the package locally through npx.

Context7 with OpenCode

npx ctx7 setup --opencode

Context7 also provides an OpenCode plugin and OAuth authentication flow.

Cursor: setup guide ↗ · OpenCode: setup guide ↗

Context7 MCP exposes native MCP tools to the coding agent, while Context7 CLI + Skills teaches the agent to retrieve documentation through ctx7 commands without requiring MCP. Both access Context7 documentation, but the integration mechanisms are different.

MCP mode is appropriate when the client already handles MCP tools well. CLI + Skills removes the MCP requirement and can reduce permanent MCP tool exposure, although the agent still performs documentation retrieval when the skill is invoked.

CLI + Skills: Context7 CLI documentation ↗

Context7 now offers a full on-premise deployment for Enterprise customers. Running the public MCP package locally is not the same as self-hosting the complete Context7 documentation platform.

The open-source MCP package can run locally, but Context7's public API backend, parsing engine and crawling engine are separate from the public repository.

The Enterprise on-premise product is different. It can provide parsing and indexing, vector storage, MCP server, web interface, REST API and private GitHub/GitLab repository ingestion inside the organization's own infrastructure.

On-premise documentation: Context7 Enterprise on-premise ↗

Context7 has a $0 Free plan with 1,000 API calls per month. Pro costs $10 per seat per month and includes 5,000 API calls per seat; additional Pro usage costs $10 per 1,000 calls. Enterprise pricing is custom.

Private repositories are a paid feature. Context7 currently lists private-repository parsing at $5 per 1 million tokens on Pro.

The Context7 service price and the AI model's token cost are separate expenses.

Current plans: Context7 pricing ↗

Context7 has low permanent MCP overhead because it exposes only two core tools. MCPVerdict estimates approximately 1,000–2,000 tokens for tool schemas and instructions, while a typical documentation result can add roughly 2,000–8,000 input tokens.

1. Tool-schema and instruction overhead

Estimated at ~1K–2K tokens, depending on client serialization and current server instructions.

2. Retrieved documentation overhead

A typical docs result may add approximately ~2K–8K input tokens. Multiple concepts should normally be separate retrievals, so broad coding sessions can accumulate considerably more context.

3. Representative combined input range

One ordinary retrieval therefore adds roughly 3K–10K tokens when the estimated MCP footprint and retrieved documentation are considered together. This is a planning range, not a universal measured token count.

These figures calculate uncached input only for the estimated 3K–10K Context7-related input range. They exclude model output, repeated retrievals, long-context multipliers, caching, tool-specific charges and the Context7 API plan itself.

The dominant Context7 cost is usually the retrieved documentation rather than its tool schema. Automatic invocation is therefore not free simply because the MCP surface is small.

Illustrative evaluation workload

The MCPVerdict evaluation estimated a 10-question test at approximately 20 Context7 calls, 35K retrieved/model input tokens and 6K model output tokens. At the checked pricing snapshot, that was approximately $0.13 on Claude Sonnet 5 and $0.26 on GPT-5.6 Sol, while Context7 itself remained $0 within the included Free allowance. If all 20 calls were Pro overage, Context7 overage would be about $0.20.

Context7 has a relatively limited direct-action surface because its two core tools retrieve documentation rather than modifying files or infrastructure. Its main security risks come from untrusted retrieved content, prompt injection, API credentials, private-document handling and reliance on an external retrieval service.

MCPVerdict assigns Scan Grade C. The grade reflects executable Node/TypeScript code, external network access, API authentication, a hosted backend dependency and telemetry/observability. It does not indicate destructive local tools.

Real prompt-injection evidence

A May 2026 GitHub issue reported assistant-directed prompt-injection content appended to a query-docs result for HubSpot developer documentation. The reported content attempted to influence the calling assistant.

Context7 itself could not execute a shell command through its two documentation tools. Risk increases when the same agent also has access to GitHub, filesystem, shell, browser-control or other write-capable tools because malicious documentation can become a cross-tool prompt-injection pathway.

Context7 also warns that community-contributed projects are not guaranteed to be accurate, complete or secure. Retrieved documentation should therefore be treated as external evidence, not as trusted instructions.

Prompt-injection report: GitHub issue #2673 ↗

Context7 states that the MCP client sends a generated documentation query and library information rather than the user's complete original prompt, full conversation history or source code. Its tool descriptions also instruct clients to remove secrets and proprietary information from retrieval queries.

The privacy boundary changes for private repositories. Public-library retrieval mainly sends documentation lookup information; private-library use adds trust in Context7's repository ingestion, indexing and hosted infrastructure unless the organization uses Enterprise on-premise deployment.

API keys also carry a narrower blast radius than credentials such as a GitHub personal access token or a cloud-administrator secret. A Context7 key primarily controls Context7 access, quota and associated private Context7 resources.

Privacy documentation: Context7 data privacy ↗

Yes. Context7 MCP 4.1.0 added bounded OpenTelemetry metrics for MCP requests, tool calls, authentication and upstream API operations. The separate ctx7 CLI also collects anonymous usage telemetry and supports CTX7_TELEMETRY_DISABLED=1 as an opt-out.

These are separate systems:

• MCP server observability: operational metrics for requests, tools, authentication and upstream API activity.
• CLI telemetry: anonymous product usage telemetry with an opt-out.

Integration tests indicate that metric labels are bounded and avoid exporting values such as API keys, client IPs, library IDs, queries and session IDs as metric labels.

Any older Context7 review saying the current MCP has no telemetry is outdated.

MCP changelog: Context7 MCP changelog ↗

The main limitations are freshness lag, wrong library resolution, incomplete coverage, community-source quality, prompt-injection exposure, external-service dependency, retrieval token cost and unnecessary calls when equivalent authoritative documentation is already available.

Context7's own rules also set useful scope boundaries. It is intended for library APIs, configuration, migration, library-specific debugging and setup. It is not intended for general refactoring, business-logic debugging, code review or generic programming concepts.

The “use Context7 for everything” problem

Current default guidance encourages Context7 retrieval for library, framework, SDK, API, CLI and cloud-service questions even when the model believes it knows the answer. That protects against stale training knowledge, but it can become redundant when authoritative version-specific documentation is already in context.

A more efficient operating rule is: Use Context7 when current or version-specific external documentation is required and equivalent authoritative documentation is not already available in the active context.

Context7 fits coding workflows where correctness depends on current external documentation. Its strongest cases are version-specific framework work, changed SDK methods, migrations, current configuration, deprecated APIs and code generation that depends on a library's present interface.

Developers gain less from Context7 when authoritative documentation already exists in the active context, when the task is independent of an external library, or when retrieval adds more latency and tokens than new information.

Context7 should be a targeted current-documentation layer rather than an automatic tax on every coding prompt. The most sensible policy is to call it when current or version-specific external evidence is required and not already available.

Context7 alternatives include direct official documentation, AI-agent web search, Context7 CLI + Skills and repository-oriented documentation systems. The better choice depends on whether the task requires library API documentation, broader web information or deeper understanding of a specific repository.

These options can be complementary rather than mutually exclusive. Context7 is best understood as a current documentation layer, not a replacement for every research or code-understanding tool.

Context7 is actively maintained, but the recent evidence also shows why its reliability score is below its efficiency and maintainability scores.

Context7 is one of the strongest examples of an MCP doing one narrow job instead of becoming a large agent control plane. Two tools are enough to resolve a library and retrieve relevant documentation, which keeps schema overhead unusually low.

Its strongest value appears when libraries move faster than model training: current framework configuration, changed SDK methods, migrations, version-specific syntax and deprecated APIs.

The qualification is that retrieval does not automatically equal truth. Context7 libraries can lag upstream sources, obscure libraries may refresh only every several weeks, first requests can receive stale content while a background refresh runs, and community-contributed documentation may be inaccurate or unsafe. A real prompt-injection report also shows that documentation retrieval must be treated as untrusted external context.

Why it scores well

• solves a genuine stale-documentation problem;
• only two core MCP tools;
• strong version-specific retrieval design;
• broad coding-client support;
• simple hosted setup;
• anonymous/basic access available before creating another credential;
• active maintenance and quick regression fixes;
• modern MCP 2026-07-28 adoption.

Why it does not score higher

• freshness is not real-time for every library;
• wrong library/source resolution can ground an answer in the wrong evidence;
• coverage can be incomplete;
• community-contributed documentation is not guaranteed safe or correct;
• a real prompt-injection incident has been reported;
• automatic retrieval can consume quota, latency and context unnecessarily;
• private repositories materially increase the trust boundary.

Bottom line

Context7 works best as a current documentation layer, not an unquestionable source of truth.

Its efficiency is exceptional: only two MCP tools. The larger question is whether the source selected for a particular library/version is actually current, correct and complete.