MCP Clients

Run this command. See Claude Code MCP docs for more info.

Local Server Connection#

claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp --api-key YOUR_API_KEY

Remote Server Connection#

claude mcp add --scope user --header "Authorization: Bearer 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 for more info.

Since Cursor 1.0, you can click the install button below for instant one-click installation.

Remote Server Connection#

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

Local Server Connection#

{  "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 for more info.

Remote Server Connection#

"mcp": {  "context7": {    "type": "remote",    "url": "https://mcp.context7.com/mcp",    "headers": {      "Authorization": "Bearer YOUR_API_KEY"    },    "enabled": true  }}

Local Server Connection#

{  "mcp": {    "context7": {      "type": "local",      "command": ["npx", "-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],      "enabled": true    }  }}

Built-in MCP#

We recommend built-in MCP because the Context7 MCP server receives updates more frequently than the Pi extension.

Pi has built-in MCP support from version 0.99.0. Run pi update to update Pi, then choose one connection method below. See the Pi guide for usage examples and Pi’s MCP documentation for configuration details.

OAuth

pi mcp add context7 --url https://mcp.context7.com/mcp --exposure directpi mcp login context7

Approve access in your browser. Pi stores and refreshes the OAuth tokens.

Remote server with an API key

Create a key in the Context7 dashboard and export it before starting Pi:

export CONTEXT7_API_KEY="YOUR_API_KEY"pi mcp add context7 --url https://mcp.context7.com/mcp \  --bearer-token-env-var CONTEXT7_API_KEY --exposure direct

Local server connection

With Node.js and npx installed, run:

export CONTEXT7_API_KEY="YOUR_API_KEY"pi mcp add context7 --exposure direct \  --env CONTEXT7_API_KEY='${CONTEXT7_API_KEY}' \  -- npx -y @upstash/context7-mcp

These commands save the server in ~/.pi/agent/mcp.json. Add --local to pi mcp add to use .pi/mcp.json for a trusted project. The --exposure direct option makes Context7’s tools visible to the model immediately.

Run pi mcp list to check the connection. In an open Pi session, run /reload, then use /mcp to inspect the server. Ask Pi to use Context7 for a library documentation question.

Context7 extension#

The official Context7 extension is an alternative. It includes a documentation skill and the /c7-docs prompt. It calls the hosted Context7 HTTP API directly, without using the remote MCP server:

pi install npm:@upstash/context7-pi

Run /reload or start a new Pi session, then ask a documentation question or use /c7-docs next.js Cache Components. It supports anonymous access and the CONTEXT7_API_KEY environment variable. Choose either the extension or the MCP setup above to avoid duplicate tools.

Add the hosted Context7 server with OpenClaw’s MCP client registry. See the OpenClaw MCP documentation for more details.

OAuth (Recommended)#

Register the Context7 OAuth endpoint, then sign in through your browser:

openclaw mcp add context7 \  --url https://mcp.context7.com/mcp/oauth \  --transport streamable-http \  --auth oauthopenclaw mcp login context7

OpenClaw also provides a code-based login fallback for headless or remote environments. See Set Up OAuth for more details.

API Key#

To connect with an API key, register the standard endpoint:

openclaw mcp add context7 \  --url https://mcp.context7.com/mcp \  --transport streamable-http \  --header "Authorization: Bearer YOUR_API_KEY"

Verify that OpenClaw can connect and discover the Context7 tools:

openclaw mcp doctor context7 --probe

See OpenAI Codex MCP docs 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.

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

Start a new Codex thread after installation so Codex can load the plugin.

Using CLI#

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).

[mcp_servers.context7]command = "npx"args = ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]startup_timeout_sec = 20

Remote Server Connection#

[mcp_servers.context7]url = "https://mcp.context7.com/mcp"http_headers = { "Authorization" = "Bearer YOUR_API_KEY" }

Add this to your Antigravity MCP config file. See Antigravity MCP docs for more info.

Remote Server Connection#

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

Local Server Connection#

{  "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, which registers the server automatically and supports an API key via the context7.apiKey setting. See VS Code for details. For manual configuration, use the options below.

Add this to your VS Code MCP config file (.vscode/mcp.json). See VS Code MCP docs for more info.

Remote Server Connection#

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

Local Server Connection#

{  "servers": {    "context7": {      "type": "stdio",      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

See Kiro Model Context Protocol Documentation for details.

1. Navigate Kiro > MCP Servers
2. Add a new MCP server by clicking the + Add button.
3. Paste the configuration:

Remote Server Connection#

{  "mcpServers": {    "context7": {      "url": "https://mcp.context7.com/mcp"    }  }}

To use an API key in Kiro, add:

"headers": {  "Authorization": "Bearer YOUR_API_KEY"}

See the API keys guide for how to create one.

Local Server Connection#

{  "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 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#

{  "mcp": {    "context7": {      "type": "remote",      "url": "https://mcp.context7.com/mcp",      "headers": {        "Authorization": "Bearer YOUR_API_KEY"      },      "enabled": true    }  }}

Local Server Connection#

{  "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 for more info.

Remote Server Connection#

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

Local Server Connection#

{  "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 for more info.

Remote Server Connection#

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

Local Server Connection#

{  "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 for more info.

{  "mcpServers": {    "context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

Add Context7 to ChatGPT on the web as a custom MCP server plugin. See Add custom MCP server in the OpenAI docs. Workspace permissions can block custom MCP servers.

1. Add the MCP server#

Go to ChatGPT Plugins → select the plus button → Add custom MCP server, and fill in the following:

Select I understand and want to continue, then Create as a plugin.

2. Install the plugin#

Find Context7 in your plugins, install it, and complete the one-time OAuth authorization.

3. Use in a conversation#

Start a new chat, type @ in the prompt box, and select Context7.

Use the Add manually feature and fill in the JSON configuration. See Trae documentation for more details.

Remote Server Connection#

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

Local Server Connection#

{  "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 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:

{  "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 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):

{  "mcpServers": {    "context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

See Gemini CLI Configuration for details.

1. Open the Gemini CLI settings file at ~/.gemini/settings.json
2. Add the following to the mcpServers object:

{  "mcpServers": {    "context7": {      "httpUrl": "https://mcp.context7.com/mcp",      "headers": {        "Authorization": "Bearer YOUR_API_KEY",        "Accept": "application/json, text/event-stream"      }    }  }}

Or, for a local server:

{  "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 for more info.

Remote Server Connection (API Key)#

Add this to your Hermes config file (~/.hermes/config.yaml).

mcp_servers:  context7:    url: "https://mcp.context7.com/mcp"    headers:      Authorization: "Bearer YOUR_API_KEY"

Remote Server Connection (OAuth)#

mcp_servers:  context7:    url: "https://mcp.context7.com/mcp/oauth"    auth: oauth

Using CLI (OAuth)#

hermes mcp add context7 --url https://mcp.context7.com/mcp/oauth --auth oauth

Local Server Connection#

mcp_servers:  context7:    command: "npx"    args: ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]

Use these alternatives to run the local Context7 MCP server with other runtimes.

Bun#

{  "mcpServers": {    "context7": {      "command": "bunx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

Deno#

{  "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:

{  "mcpServers": {    "context7": {      "type": "http",      "url": "https://mcp.context7.com/mcp",      "headers": {        "Authorization": "Bearer $COPILOT_MCP_CONTEXT7_API_KEY"      },      "tools": ["query-docs", "resolve-library-id"]    }  }}

See the official GitHub documentation 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. For manual configuration, open ~/.copilot/mcp-config.json and add:

{  "mcpServers": {    "context7": {      "type": "http",      "url": "https://mcp.context7.com/mcp",      "headers": {        "Authorization": "Bearer YOUR_API_KEY"      },      "tools": ["query-docs", "resolve-library-id"]    }  }}

Or, for a local server:

{  "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 for more details.

{  "mcpServers": {    "context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

See Warp Model Context Protocol Documentation for details.

1. Navigate Settings > Agents > MCP servers.
2. Add a new MCP server by clicking the + Add button.
3. Paste the configuration:

{  "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 for more info.

With OAuth#

amp mcp add context7 https://mcp.context7.com/mcp/oauth

With API Key (Higher Rate Limits & Private Repos)#

amp mcp add context7 --header "Authorization=Bearer YOUR_API_KEY" https://mcp.context7.com/mcp

It can be installed via Zed Extensions or you can add this to your Zed settings.json. See Zed MCP docs for more info.

{  "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:

npx -y @smithery/cli@latest install @upstash/context7-mcp --client <CLIENT_NAME>

See the Context7 server page on Smithery for more details.

See JetBrains AI Assistant Documentation 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#

{  "mcpServers": {    "context7": {      "url": "https://mcp.context7.com/mcp"    }  }}

Local Server Connection#

{  "mcpServers": {    "context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

See Qwen Code MCP Configuration 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#

qwen mcp add --transport http context7 https://mcp.context7.com/mcp \  --header "Authorization: Bearer YOUR_API_KEY" \  --header "Accept: application/json, text/event-stream"

Local Server Connection#

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#

{  "mcpServers": {    "context7": {      "httpUrl": "https://mcp.context7.com/mcp",      "headers": {        "Authorization": "Bearer YOUR_API_KEY",        "Accept": "application/json, text/event-stream"      }    }  }}

Local Server Connection#

{  "mcpServers": {    "context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

1. Create a Dockerfile:

FROM node:22-alpineWORKDIR /appRUN npm install -g @upstash/context7-mcpCMD ["context7-mcp", "--transport", "stdio"]

2. Build the image:

docker build -t context7-mcp .

3. Configure your MCP client:

{  "mcpServers": {    "context7": {      "command": "docker",      "args": ["run", "-i", "--rm", "context7-mcp"],      "transportType": "stdio"    }  }}

Context7 is available in the Docker MCP Catalog 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. In the server’s Config tab, set your free Context7 API key (CONTEXT7_API_KEY).
3. Connect your MCP client to Docker’s MCP gateway. Either run docker mcp client connect <client> (for example vscode, cursor, or claude-desktop), or add the gateway to your client config manually:

{  "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:

{  "mcpServers": {    "context7": {      "command": "cmd",      "args": ["/c", "npx", "-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],      "disabled": false,      "autoApprove": []    }  }}

See LM Studio MCP docs for more information.

One-click install:#

Manual set-up:#

1. Navigate to Program (right side) > Install > Edit mcp.json.
2. Paste the configuration:

{  "mcpServers": {    "Context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

3. Click Save.

See Visual Studio MCP Servers documentation for details.

{  "inputs": [],  "servers": {    "context7": {      "type": "http",      "url": "https://mcp.context7.com/mcp",      "headers": {        "Authorization": "Bearer YOUR_API_KEY"      }    }  }}

Or, for a local server:

{  "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 for more info.

Remote Server Connection#

{  "$schema": "https://charm.land/crush.json",  "mcp": {    "context7": {      "type": "http",      "url": "https://mcp.context7.com/mcp",      "headers": {        "Authorization": "Bearer YOUR_API_KEY"      }    }  }}

Local Server Connection#

{  "$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:

{  "mcpServers": {    "context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

See BoltAI’s Documentation for more info.

Edit your Rovo Dev CLI MCP config:

acli rovodev mcp

Remote Server Connection#

{  "mcpServers": {    "context7": {      "url": "https://mcp.context7.com/mcp"    }  }}

Local Server Connection#

{  "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:

{  "command": "npx",  "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]}

5. Click Install.

See Qodo Gen docs 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#

{  "mcpServers": {    "context7": {      "command": "npx",      "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]    }  }}

Remote Server Connection#

{  "mcpServers": {    "context7": {      "url": "https://mcp.context7.com/mcp"    }  }}

See 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:

{  "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"],  "command": "npx",  "env": {}}

7. Click Save.

Manus includes a built-in Context7 connector:

1. Navigate Settings > Connectors.
2. In the Apps tab, search for Context7.
3. Click Context7 to enable it.

Alternatively, add it as a custom MCP connection with your API key:

1. Navigate Settings > Connectors > Custom MCP.
2. Fill in the configuration:

3. Click Save.

Factory’s droid supports MCP servers through its CLI. See Factory MCP docs for more info.

Remote Server Connection#

droid mcp add context7 https://mcp.context7.com/mcp --type http --header "Authorization: Bearer YOUR_API_KEY"

Local Server Connection#

droid mcp add context7 "npx -y @upstash/context7-mcp" --env CONTEXT7_API_KEY=YOUR_API_KEY

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 authenticate with OAuth, or provide your CONTEXT7_API_KEY when the selected agent does not support OAuth. 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 for more information.

Install the context7.mcpb file and add it to your client. See MCP bundles docs for more info.

FLUJO connects to Context7 through its remote-server setup.

1. Open Connected Apps and select Connect App → I have connection details → At a remote URL.
2. Enter https://mcp.context7.com/mcp as the Server URL and click Connect.
3. Select Continue to setup if prompted. In Configure & Test, confirm that Streamable HTTP is selected.
4. Under Custom HTTP headers, add an Authorization header with the value Bearer YOUR_API_KEY and select Secret to mask it. Leave the optional OAuth client credentials blank for this endpoint.
5. Run 3) Test run if the connection test has not started automatically. After the test passes, click Update server to save.
6. Open the connected server’s Tools tab. Select resolve-library-id, provide a library name and a documentation query, and click Test tool. Use a returned library ID with query-docs to retrieve documentation.

AnythingLLM supports MCP Servers through GUI.

1. Navigate AnythingLLM > Agents Skills
2. Select MCP Servers.
3. Click Edit MCP config.
4. Paste.
5. Click to “Refresh” button.

Remote Connection#

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