> ## Documentation Index
> Fetch the complete documentation index at: https://context7.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# MCP Clients
> Installation examples for MCP clients
Context7 supports all MCP clients. Below are configuration examples for popular clients. If your client isn't listed, check its documentation for MCP server installation. To configure manually, use the Context7 server URL `https://mcp.context7.com/mcp` with your MCP client and pass your API key via the `CONTEXT7_API_KEY` header.
Looking for the easiest way to get started? Use `npx ctx7 setup` to configure Context7
automatically, and `npx ctx7 remove` to remove the generated setup later. See the [CLI
docs](/clients/cli) for more details.
For detailed guides including rules, skills, agents, and best practices, see
[Cursor](/clients/cursor) for rules and Composer integration tips, and [Claude
Code](/clients/claude-code) for skills, agents, commands, and plugin installation.
## OAuth Authentication
Context7 MCP server supports OAuth 2.0 authentication for MCP clients that implement the [MCP OAuth specification](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization).
To use OAuth, change the endpoint from `/mcp` to `/mcp/oauth` in your client configuration:
```diff theme={null}
- "url": "https://mcp.context7.com/mcp"
+ "url": "https://mcp.context7.com/mcp/oauth"
```
OAuth is only available for remote HTTP connections. For local MCP connections using stdio transport, use API key authentication instead.
Run this command. See [Claude Code MCP docs](https://code.claude.com/docs/en/mcp) for more info.
#### Local Server Connection
```sh theme={null}
claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp --api-key YOUR_API_KEY
```
#### Remote Server Connection
```sh theme={null}
claude mcp add --scope user --header "CONTEXT7_API_KEY: YOUR_API_KEY" --transport http context7 https://mcp.context7.com/mcp
```
Go to: `Cursor Settings` -> `Tools & MCP` -> `New MCP Server`
Pasting the following configuration into your Cursor `~/.cursor/mcp.json` file is the recommended approach. You may also install in a specific project by creating `.cursor/mcp.json` in your project folder. See [Cursor MCP docs](https://cursor.com/docs/context/mcp) for more info.
Since Cursor 1.0, you can click the install button below for instant one-click installation.
#### Remote Server Connection
[](https://cursor.com/en/install-mcp?name=context7\&config=eyJ1cmwiOiJodHRwczovL21jcC5jb250ZXh0Ny5jb20vbWNwIn0%3D)
```json theme={null}
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
#### Local Server Connection
[](https://cursor.com/en/install-mcp?name=context7\&config=eyJjb21tYW5kIjoibnB4IC15IEB1cHN0YXNoL2NvbnRleHQ3LW1jcCJ9)
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
Add this to your Opencode configuration file. See [Opencode MCP docs](https://opencode.ai/docs/mcp-servers) for more info.
#### Remote Server Connection
```json theme={null}
"mcp": {
"context7": {
"type": "remote",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
},
"enabled": true
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcp": {
"context7": {
"type": "local",
"command": ["npx", "-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],
"enabled": true
}
}
}
```
See [OpenAI Codex MCP docs](https://developers.openai.com/codex/mcp) for more info.
#### Context7 Plugin
You can also install Context7 as a Codex plugin. It connects to the hosted MCP server and includes a documentation lookup skill. After installation, a browser window opens so you can log in via OAuth.
```sh theme={null}
codex plugin marketplace add upstash/context7
codex plugin add context7@context7-marketplace
```
Start a new Codex thread after installation so Codex can load the plugin.
#### Using CLI
```sh theme={null}
codex mcp add context7 -- npx -y @upstash/context7-mcp --api-key YOUR_API_KEY
```
#### Local Server Connection
Add this to your Codex configuration file (`~/.codex/config.toml` or `.codex/config.toml`).
```toml theme={null}
[mcp_servers.context7]
command = "npx"
args = ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
startup_timeout_ms = 20_000
```
#### Remote Server Connection
```toml theme={null}
[mcp_servers.context7]
url = "https://mcp.context7.com/mcp"
http_headers = { "CONTEXT7_API_KEY" = "YOUR_API_KEY" }
```
If you see startup timeout errors, try increasing `startup_timeout_ms` to `40_000`.
Add this to your Antigravity MCP config file. See [Antigravity MCP docs](https://antigravity.google/docs/mcp) for more info.
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"serverUrl": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
The easiest way to install is the [Context7 VS Code extension](https://marketplace.visualstudio.com/items?itemName=Upstash.context7-mcp), which registers the server automatically and supports an API key via the `context7.apiKey` setting. See [VS Code](/clients/vscode) for details. For manual configuration, use the options below.
[ 
](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%7B%22name%22%3A%22context7%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40upstash%2Fcontext7-mcp%40latest%22%5D%7D)
[ 
](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%7B%22name%22%3A%22context7%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40upstash%2Fcontext7-mcp%40latest%22%5D%7D)
Add this to your VS Code MCP config file (`.vscode/mcp.json`). See [VS Code MCP docs](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) for more info.
#### Remote Server Connection
```json theme={null}
{
"servers": {
"context7": {
"type": "http",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"servers": {
"context7": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
See [Kiro Model Context Protocol Documentation](https://kiro.dev/docs/mcp/configuration/) for details.
[](https://kiro.dev/launch/mcp/add?name=context7\&config=%7B%22url%22%3A%22https%3A%2F%2Fmcp.context7.com%2Fmcp%22%2C%22disabled%22%3Afalse%2C%22autoApprove%22%3A%5B%5D%7D)
1. Navigate `Kiro` > `MCP Servers`
2. Add a new MCP server by clicking the `+ Add` button.
3. Paste the configuration:
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp"
}
}
}
```
To use an API key in Kiro, add:
```json theme={null}
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
```
See the [API keys guide](/howto/api-keys) for how to create one.
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
4. Click `Save` to apply.
You can configure the Context7 MCP server in **Kilo Code** using either the UI or by editing your config file. See [Kilo Code MCP docs](https://kilo.ai/docs/automate/mcp/using-in-kilo-code) for more info.
Kilo Code stores MCP servers in a `kilo.jsonc` file:
* **Global** — `~/.config/kilo/kilo.jsonc`
* **Project** — `kilo.jsonc` in your project root or `.kilo/kilo.jsonc` (takes precedence)
### Configure via Kilo Code UI
1. Click the **Settings** icon in the sidebar toolbar.
2. Navigate to the **Agent Behaviour** tab.
3. Select the **MCP Servers** sub-tab.
4. Click **Add Server** and choose **Remote (HTTP)** or **Local (stdio)**.
5. Fill in the details and save.
### Manual Configuration
Add Context7 under the `mcp` key in your `kilo.jsonc`.
#### Remote Server Connection
```json theme={null}
{
"mcp": {
"context7": {
"type": "remote",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
},
"enabled": true
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcp": {
"context7": {
"type": "local",
"command": ["npx", "-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],
"enabled": true
}
}
}
```
Add this to your Roo Code MCP configuration file. See [Roo Code MCP docs](https://docs.roocode.com/features/mcp/using-mcp-in-roo) for more info.
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"type": "streamable-http",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
Add this to your Devin Desktop MCP config file. See [Devin Desktop MCP docs](https://docs.devin.ai/desktop/cascade/mcp) for more info.
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"serverUrl": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
#### Remote Server Connection
Open Claude Desktop and navigate to Settings > Connectors > Add Custom Connector. Enter the name as `Context7` and the remote MCP server URL as `https://mcp.context7.com/mcp`.
#### Local Server Connection
Open Claude Desktop developer settings and edit your `claude_desktop_config.json` file. See [Claude Desktop MCP docs](https://modelcontextprotocol.io/quickstart/user) for more info.
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
ChatGPT supports MCP servers through remote connectors via [Developer Mode](https://developers.openai.com/api/docs/guides/developer-mode) (beta). Available for Pro, Plus, Team, Enterprise, and Edu plans.
#### 1. Enable Developer Mode
Go to: `Settings` → `Apps` → `Advanced settings` → Enable `Developer Mode`
#### 2. Create an App
Go to: `Settings` → `Apps` → `Create App`
Fill in the following:
| Field | Value |
| ------------------ | ------------------------------------------------------------------------------------------- |
| **Name** | `Context7` |
| **Description** | `Fetch up-to-date documentation and code examples for any library directly from the source` |
| **MCP Server URL** | `https://mcp.context7.com/mcp/oauth` |
> Accept the security notice and complete the one-time OAuth authorization.
#### 3. Use in a Conversation
Start a new chat → Click the plus icon → Hover over `More` → Select the `Context7` app.
Alternatively, you can say `use context7` in your prompt and ChatGPT will automatically use the `Context7` app.
See [OpenAI MCP docs](https://developers.openai.com/api/docs/mcp) for more info.
The ChatGPT desktop app shares apps configured on the web. Set up the app on [chatgpt.com](https://chatgpt.com) first.
#### 1. Enable Developer Mode (on the Web)
Go to: `Settings` → `Apps` → `Advanced settings` → Enable `Developer Mode`
#### 2. Create an App (on the Web)
Go to: `Settings` → `Apps` → `Create App`
Fill in the following:
| Field | Value |
| ------------------ | ------------------------------------------------------------------------------------------- |
| **Name** | `Context7` |
| **Description** | `Fetch up-to-date documentation and code examples for any library directly from the source` |
| **MCP Server URL** | `https://mcp.context7.com/mcp/oauth` |
> Accept the security notice and complete the one-time OAuth authorization.
#### 3. Use in the Desktop App
Open the ChatGPT desktop app → Start a new chat → ChatGPT will automatically use the `Context7` app when you ask it to.
Apps configured on the web are automatically available in the desktop app.
See [OpenAI MCP docs](https://developers.openai.com/api/docs/mcp) for more info.
Use the Add manually feature and fill in the JSON configuration. See [Trae documentation](https://docs.trae.ai/ide/model-context-protocol?_lang=en) for more details.
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
You can easily install Context7 through the [Cline MCP Server Marketplace](https://cline.bot/mcp-marketplace) by following these instructions:
1. Open **Cline**.
2. Click the hamburger menu icon to enter the **MCP Servers** section.
3. Use the search bar within the **Marketplace** tab to find *Context7*.
4. Click the **Install** button.
Or you can directly edit MCP servers configuration:
1. Open **Cline**.
2. Click the hamburger menu icon to enter the **MCP Servers** section.
3. Choose **Remote Servers** tab.
4. Click the **Edit Configuration** button.
5. Add context7 to `mcpServers`:
```json theme={null}
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}
```
To configure Context7 MCP in Augment Code, you can use either the graphical interface or manual configuration. See [Augment Code MCP docs](https://docs.augmentcode.com/setup-augment/mcp) for more info.
### Using the Augment Code UI
1. Open the options menu in the upper right of the Augment panel.
2. Select **Settings**.
3. Navigate to the **MCP** section.
4. Click the **+** button to add a new server.
5. Enter the name **Context7** and the command:
```
npx -y @upstash/context7-mcp@latest
```
### Manual Configuration
In the **MCP** section, use **Import from JSON** and paste the following (a top-level `mcpServers` object keyed by server name):
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
See [Gemini CLI Configuration](https://google-gemini.github.io/gemini-cli/docs/tools/mcp-server.html) for details.
1. Open the Gemini CLI settings file at `~/.gemini/settings.json`
2. Add the following to the `mcpServers` object:
```json theme={null}
{
"mcpServers": {
"context7": {
"httpUrl": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY",
"Accept": "application/json, text/event-stream"
}
}
}
}
```
Or, for a local server:
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
Use the Hermes CLI or edit `~/.hermes/config.yaml` directly. See the [Hermes CLI docs](https://github.com/nousresearch/hermes-agent/blob/main/website/docs/reference/cli-commands.md) for more info.
#### Remote Server Connection (API Key)
Add this to your Hermes config file (`~/.hermes/config.yaml`).
```yaml theme={null}
mcp_servers:
context7:
url: "https://mcp.context7.com/mcp"
headers:
CONTEXT7_API_KEY: "YOUR_API_KEY"
```
#### Remote Server Connection (OAuth)
```yaml theme={null}
mcp_servers:
context7:
url: "https://mcp.context7.com/mcp/oauth"
auth: oauth
```
#### Using CLI (OAuth)
```sh theme={null}
hermes mcp add context7 --url https://mcp.context7.com/mcp/oauth --auth oauth
```
#### Local Server Connection
```yaml theme={null}
mcp_servers:
context7:
command: "npx"
args: ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
```
Start with the API key method if you want the most direct setup. Hermes also supports OAuth for remote MCP servers via `auth: oauth`. On headless setups, Hermes may print an authorization URL to stdout or logs for you to open manually. If `hermes mcp add ... --auth oauth` drops into the interactive agent without saving the server entry, add the `mcp_servers.context7` config manually, then run `hermes mcp test context7` to trigger the auth flow and verify the connection.
Use these alternatives to run the local Context7 MCP server with other runtimes.
#### Bun
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "bunx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
#### Deno
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "deno",
"args": [
"run",
"--allow-env=NO_DEPRECATION,TRACE_DEPRECATION",
"--allow-net",
"npm:@upstash/context7-mcp"
]
}
}
}
```
Add the following configuration to `Repository` -> `Settings` -> `Code & automation` -> `Copilot` -> `MCP servers`. Only secrets named with the `COPILOT_MCP_` prefix are exposed to the MCP config, so store your key as a `COPILOT_MCP_CONTEXT7_API_KEY` Actions secret and reference it:
```json theme={null}
{
"mcpServers": {
"context7": {
"type": "http",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "$COPILOT_MCP_CONTEXT7_API_KEY"
},
"tools": ["query-docs", "resolve-library-id"]
}
}
}
```
See the [official GitHub documentation](https://docs.github.com/en/copilot/how-tos/agents/copilot-coding-agent/extending-copilot-coding-agent-with-mcp) for more info.
The easiest way is the Context7 plugin, which bundles the MCP server with a skill, an agent, and a command — see [GitHub Copilot CLI](/clients/copilot-cli). For manual configuration, open `~/.copilot/mcp-config.json` and add:
```json theme={null}
{
"mcpServers": {
"context7": {
"type": "http",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
},
"tools": ["query-docs", "resolve-library-id"]
}
}
}
```
Or, for a local server:
```json theme={null}
{
"mcpServers": {
"context7": {
"type": "local",
"command": "npx",
"tools": ["query-docs", "resolve-library-id"],
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
Add this to your Amazon Q Developer CLI configuration file. See [Amazon Q Developer CLI docs](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-configuration.html) for more details.
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
See [Warp Model Context Protocol Documentation](https://docs.warp.dev/knowledge-and-collaboration/mcp#adding-an-mcp-server) for details.
1. Navigate `Settings` > `Agents` > `MCP servers`.
2. Add a new MCP server by clicking the `+ Add` button.
3. Paste the configuration:
```json theme={null}
{
"Context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],
"env": {},
"working_directory": null,
"start_on_launch": true
}
}
```
4. Click `Save`.
Run this command in your terminal. See [Amp MCP docs](https://ampcode.com/manual#mcp) for more info.
#### Without API Key (Basic Usage)
```sh theme={null}
amp mcp add context7 https://mcp.context7.com/mcp
```
#### With API Key (Higher Rate Limits & Private Repos)
```sh theme={null}
amp mcp add context7 --header "CONTEXT7_API_KEY=YOUR_API_KEY" https://mcp.context7.com/mcp
```
It can be installed via [Zed Extensions](https://zed.dev/extensions?query=Context7) or you can add this to your Zed `settings.json`. See [Zed MCP docs](https://zed.dev/docs/ai/mcp) for more info.
```json theme={null}
{
"context_servers": {
"Context7": {
"source": "custom",
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
To install Context7 MCP Server for any client automatically via [Smithery](https://smithery.ai/servers/@upstash/context7-mcp):
```bash theme={null}
npx -y @smithery/cli@latest install @upstash/context7-mcp --client
```
See the [Context7 server page on Smithery](https://smithery.ai/servers/@upstash/context7-mcp) for more details.
See [JetBrains AI Assistant Documentation](https://www.jetbrains.com/help/ai-assistant/configure-an-mcp-server.html) for more details.
1. In JetBrains IDEs, go to `Settings` -> `Tools` -> `AI Assistant` -> `Model Context Protocol (MCP)`
2. Click `+ Add`.
3. Select the **HTTP** or **STDIO** tab and paste the JSON configuration.
4. Click `Apply` to save changes.
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp"
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
See [Qwen Code MCP Configuration](https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/) for details.
### Using CLI Command
By default, configurations are saved to the project scope (`.qwen/settings.json`). Use the `--scope user` flag to save to the user scope (`~/.qwen/settings.json`) instead.
#### Remote Server Connection
```sh theme={null}
qwen mcp add --transport http context7 https://mcp.context7.com/mcp \
--header "CONTEXT7_API_KEY: YOUR_API_KEY" \
--header "Accept: application/json, text/event-stream"
```
#### Local Server Connection
```sh theme={null}
qwen mcp add context7 -- npx -y @upstash/context7-mcp --api-key YOUR_API_KEY
```
### Manual Configuration
1. Open the Qwen Code settings file at `~/.qwen/settings.json` (user scope) or `.qwen/settings.json` (project scope)
2. Add the following to the `mcpServers` object:
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"httpUrl": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY",
"Accept": "application/json, text/event-stream"
}
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
1. Create a `Dockerfile`:
```Dockerfile theme={null}
FROM node:22-alpine
WORKDIR /app
RUN npm install -g @upstash/context7-mcp
CMD ["context7-mcp", "--transport", "stdio"]
```
2. Build the image:
```bash theme={null}
docker build -t context7-mcp .
```
3. Configure your MCP client:
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "docker",
"args": ["run", "-i", "--rm", "context7-mcp"],
"transportType": "stdio"
}
}
}
```
Context7 is available in the [Docker MCP Catalog](https://hub.docker.com/mcp/server/context7/overview) as a **remote** server, so you don't need to build, pull, or run a local image. The MCP Toolkit connects to the hosted endpoint for you.
1. In Docker Desktop, open **MCP Toolkit → Catalog**, search for **Context7**, and enable it.
2. (Optional) In the server's **Config** tab, set your Context7 API key (`CONTEXT7_API_KEY`) for higher rate limits. The server also works without one.
3. Connect your MCP client to Docker's MCP gateway. Either run `docker mcp client connect ` (for example `vscode`, `cursor`, or `claude-desktop`), or add the gateway to your client config manually:
```json theme={null}
{
"mcpServers": {
"MCP_DOCKER": {
"command": "docker",
"args": ["mcp", "gateway", "run"],
"type": "stdio"
}
}
}
```
The gateway exposes every server you've enabled in the MCP Toolkit, including Context7. Tools appear under the `MCP_DOCKER` server in your client.
The configuration on Windows is slightly different. Use `cmd` to run npx:
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "cmd",
"args": ["/c", "npx", "-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],
"disabled": false,
"autoApprove": []
}
}
}
```
See [LM Studio MCP docs](https://lmstudio.ai/docs/app/plugins/mcp) for more information.
#### One-click install:
[](https://lmstudio.ai/install-mcp?name=context7\&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkB1cHN0YXNoL2NvbnRleHQ3LW1jcCJdfQ%3D%3D)
#### Manual set-up:
1. Navigate to `Program` (right side) > `Install` > `Edit mcp.json`.
2. Paste the configuration:
```json theme={null}
{
"mcpServers": {
"Context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
3. Click `Save`.
See [Visual Studio MCP Servers documentation](https://learn.microsoft.com/visualstudio/ide/mcp-servers?view=vs-2022) for details.
```json theme={null}
{
"inputs": [],
"servers": {
"context7": {
"type": "http",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
Or, for a local server:
```json theme={null}
{
"servers": {
"context7": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
Add this to your Crush configuration file. See [Crush MCP docs](https://github.com/charmbracelet/crush#mcps) for more info.
#### Remote Server Connection
```json theme={null}
{
"$schema": "https://charm.land/crush.json",
"mcp": {
"context7": {
"type": "http",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"$schema": "https://charm.land/crush.json",
"mcp": {
"context7": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
Open the "Settings" page, navigate to "Plugins," and enter:
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
See [BoltAI's Documentation](https://docs.boltai.com/docs/plugins/mcp-servers) for more info.
Edit your Rovo Dev CLI MCP config:
```bash theme={null}
acli rovodev mcp
```
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp"
}
}
}
```
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
1. Go to the Zencoder menu (...)
2. Select Agent tools
3. Click on Add custom MCP
4. Add the name and configuration:
```json theme={null}
{
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
```
5. Click Install.
See [Qodo Gen docs](https://docs.qodo.ai/qodo-documentation/qodo-gen/qodo-gen-chat/agentic-mode/agentic-tools-mcps) for more details.
1. Open Qodo Gen chat panel in VSCode or IntelliJ.
2. Click Connect more tools.
3. Click + Add new MCP.
4. Add the configuration:
#### Local Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
}
}
}
```
#### Remote Server Connection
```json theme={null}
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp"
}
}
}
```
See [Local and Remote MCPs for Perplexity](https://www.perplexity.ai/help-center/en/articles/11502712-local-and-remote-mcps-for-perplexity) for more information.
1. Navigate `Perplexity` > `Settings`
2. Select `Connectors`.
3. Click `Add Connector`.
4. Select `Advanced`.
5. Enter Server Name: `Context7`
6. Paste:
```json theme={null}
{
"args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],
"command": "npx",
"env": {}
}
```
7. Click `Save`.
Factory's droid supports MCP servers through its CLI. See [Factory MCP docs](https://docs.factory.ai/cli/configuration/mcp) for more info.
#### Remote Server Connection
```sh theme={null}
droid mcp add context7 https://mcp.context7.com/mcp --type http --header "CONTEXT7_API_KEY: YOUR_API_KEY"
```
#### Local Server Connection
```sh theme={null}
droid mcp add context7 "npx -y @upstash/context7-mcp" --env CONTEXT7_API_KEY=YOUR_API_KEY
```
[Emdash](https://github.com/generalaction/emdash) is an orchestration layer for running multiple coding agents in parallel.
Context7 is available as a built-in entry in Emdash's MCP catalog. Enable it from the MCP view and provide your `CONTEXT7_API_KEY` (optional, for higher rate limits). Emdash adapts and writes the MCP config into your selected coding agent's config (Codex, Claude Code, Cursor, etc.) for you.
See the [Emdash repository](https://github.com/generalaction/emdash) for more information.
Install the [context7.mcpb](https://github.com/upstash/context7/tree/master/packages/mcp/mcpb/context7.mcpb) file and add it to your client. See [MCP bundles docs](https://github.com/modelcontextprotocol/mcpb#mcp-bundles-mcpb) for more info.