Context7 for Cursor and Claude Code: setup and verification

When an agent suggests a library method you have never seen, ask where it came from. The example may look plausible and still belong to a different version of the package, or to no version at all. To check it you need the documentation for the library your project actually uses.

Context7 looks up library documentation and hands the relevant passages to the agent. It connects to both Cursor and Claude Code. What you get is a source for API work. The code built on it still has to be tested in your application.

• Context7 overview

Once it is set up, send the test request below and look in the tool history for an actual documentation lookup. That is how you tell retrieved information from an answer given from memory. We checked these instructions for local clients against the official documentation; we did not connect to your account or test your setup.

When Context7 helps

Context7 earns its place on tasks that depend on a library: router configuration, form handling, an ORM query, a file upload through an SDK. There you need to know which methods exist, what they accept and what behavior the documentation promises.

For a typo, or for your own business logic, an external library search may add nothing. Work out what knowledge is missing first.

Do not ask the agent to “connect all documentation.” Ask the specific question the source should answer.

How documentation lookup works

The MCP connection has two main tools. `resolve-library-id` finds the library identifier, and `query-docs` retrieves material for a question. If you already know the identifier, the first step can be skipped.

• Integration documentation

Task and package version
        ↓
Choose the correct library
        ↓
Find an answer in documentation
        ↓
Compare with project code
        ↓
Make and verify the change

Before you judge the example, check that the agent picked the right library. Then compare the documentation with your project and test the change. A tidy example can still call the wrong API, or break once it is wired into your application.

Prepare before installation

You need Cursor or Claude Code, internet access, and a working Node.js with npm/npx to run the setup command. The ctx7 installer requires Node.js 18 or later. For a new environment, pick an LTS release that is still supported.

• CLI requirements

In a normal terminal:

node --version
npx --version

If either command is missing, sort out Node.js in the environment that will run the setup. That means the terminal you actually use, whether macOS, Windows or WSL.

If Context7 is already connected, look at the existing configuration before you reinstall. Two entries with different authentication methods leave you guessing which one the agent is using.

Connect Claude Code

Run in a terminal:

npx ctx7 setup --claude

The installer walks you through OAuth sign-in and asks how you want to connect. Follow the prompts and finish the authorization in your browser. This is the route the Context7 documentation gives for Claude Code.

• Claude Code

There are two modes, MCP and CLI + Skills. With MCP the agent gets the server's tools. With CLI + Skills it runs ctx7 commands, guided by a skill. Choose MCP for the test request below, so that the tool calls show up under their names. CLI setup is global by default; `--project` limits it to the current project.

• Setup modes

Then open Claude Code and run `/mcp`. It lists the available servers and their status.

• MCP management

If you chose CLI + Skills, look for actual ctx7 commands in the history instead of an MCP server. The two modes reach the documentation by different routes.

Connect Cursor

Cursor has its own terminal command:

npx ctx7 setup --cursor

Complete the authorization and choose MCP if you want to repeat the test request from this guide.

• Cursor instructions

For manual setup, open Cursor's MCP settings. The global configuration lives in `~/.cursor/mcp.json`, the project one in `.cursor/mcp.json`. Context7 documents this HTTP configuration:

{
  "mcpServers": {
    "context7": {
      "url": "https://mcp.context7.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

`YOUR_API_KEY` stands for the key from your account. The snippet matches the official client configuration. If the file already exists, add context7 inside mcpServers and leave the other connections as they are.

• official client configuration

Do not commit a personal key to a shared repository. For a first manual setup, the personal configuration file is the easier place. OAuth has its own endpoint, `https://mcp.context7.com/mcp/oauth`; do not mix the two authentication methods.

• Authentication options

Automatic setup is usually enough. Go manual when you need to inspect the configuration or manage it yourself.

Verify actual Context7 use

Start with a library you know well, because a wrong source is easier to spot there. In a project that uses Zod, ask:

Find the installed Zod version. Use Context7 to determine how that version validates email and returns validation results without throwing. Resolve the library first, then query documentation. Show the identifier, source links and a short example. If the documentation cannot confirm the version, say so. Do not modify files.

This is a practice prompt. We are not showing a captured response from the service. If Zod is not installed, pick a package you know from your project and ask a small question about its API.

Check three levels:

If you supplied the library identifier yourself, the agent has no need to call `resolve-library-id`. What you want to see is a successful query against the correct library. And if the tool returned an error, a confident answer afterward proves nothing about the documentation.

Why the library version matters

Naming a version narrows the request, but you still have to match it against the material that comes back. The Context7 CLI offers versioned identifiers when the search results contain them, so choose from the list it actually returned.

• Libraries and versions

Say your project is on an older major version and the example targets a newer one. Do not rush to migrate everything to fit the example. Find out first whether the installed version supports the operation. Upgrading a dependency is a separate decision, and it reaches further than one task.

A workable order:

1. Identify the installed version from project files.
2. Find the documented operation.
3. Check the example's compatibility.
4. Make a limited change and run a relevant check.

If the version cannot be confirmed, go straight to the official documentation for that release, or to its migration guide. One tool coming back empty does not mean the library has no answer.

Must you always write “use context7”?

Writing `use context7` explicitly is a handy way to test the connection. Automatic setup may also install a documentation skill.

• Invocation options

For day-to-day work, it is more useful to state when the agent should turn to it:

When a solution depends on an external library API, first identify
the installed version and find suitable documentation through Context7.
If the source is unavailable or its version unconfirmed, report that
and check the official documentation directly.

The wording is our suggestion. Put it in CLAUDE.md or in Cursor's project rules. It names a trigger and a fallback, and it does not demand an external search for every change of wording.

• CLAUDE.md

If Context7 does not work

Before you reinstall anything, find the step that failed. Did the client see the server? Did sign-in go through? Did the lookup return documentation for the right library? The table gives a first check for each symptom.

The first four rows are about access. The last two are about the lookup and how its result is applied. For the technical detail, see Troubleshooting.

• Troubleshooting

Cursor Cloud Agents use a separate MCP configuration, so a working local setup tells you nothing about a cloud run. Follow the Cloud Agents instructions.

• Cloud Agents instructions