Client compatibility

This page shows which AI clients work with ToolHive and how they connect to MCP servers.

Supported clients

We've tested ToolHive with these clients:

Client	Supported	Auto-configuration	Skills support	Notes
GitHub Copilot (VS Code)	✅	✅	✅	v1.102+ or Insiders version (see note)
GitHub Copilot CLI	✅	✅	❌
Claude Code	✅	✅	✅	v1.0.27+
Cursor	✅	✅	✅	v0.50.0+
Cline (VS Code)	✅	✅	✅	v3.17.10+
Continue (VS Code)	✅	✅	❌	v1.0.14+
Continue (JetBrains)	✅	✅	❌	v1.0.23+
Factory.ai (Droid)	✅	✅	❌
Gemini CLI	✅	✅	✅
Google Antigravity	✅	✅	✅
Goose	✅	✅	✅
Kimi Code CLI	✅	✅	❌
Kiro	✅	✅	✅	v0.5.0+
LM Studio	✅	✅	❌	v0.3.17+
Mistral Vibe	✅	✅	✅
OpenAI Codex	✅	✅	✅
OpenCode	✅	✅	✅
Roo Code (VS Code)	✅	✅	✅	v3.19.2+
Sourcegraph Amp CLI	✅	✅	✅
Sourcegraph Amp (VS Code)	✅	✅	❌
Sourcegraph Amp (Cursor)	✅	✅	❌
Sourcegraph Amp (Windsurf)	✅	✅	❌
Trae IDE	✅	✅	✅	v1.4.1+
VS Code Server	✅	✅	❌
Windsurf IDE	✅	✅	✅
Windsurf (JetBrains)	✅	✅	❌
Zed	✅	✅	❌	v0.214.5+
ChatGPT Desktop	✅	❌	❌	See ChatGPT Desktop configuration
Claude Desktop	✅	❌	❌	See STDIO-only client configuration
GitHub Copilot (JetBrains)	✅	❌	❌	v1.5.47+
PydanticAI	✅	❌	❌	v0.2.18+

The minimum versions listed are the earliest versions that support the Streamable HTTP transport protocol.

You can also use other clients and development libraries that support the SSE and/or Streamable HTTP protocol, but you'll need to configure them manually.

Client requirements

To work with ToolHive, your client needs to:

1. Support the Model Context Protocol (MCP)
2. Connect to MCP servers using the server-sent events (SSE) or Streamable HTTP transport protocol
3. Have the correct MCP server URL configured

Automatic configuration support

ToolHive can automatically configure supported clients to connect to MCP servers. See the UI client configuration or CLI client configuration guide for more details.

Check the table above to see which clients support automatic configuration.

For other clients, you'll need to set up the MCP server URL yourself.

Configuration locations

ToolHive manages client configurations in their standard locations.

VS Code with Copilot

GitHub Copilot in VS Code stores its global MCP configuration in your VS Code user settings file.

note

VS Code versions prior to v1.102 stored MCP server settings in the main settings.json file. As of v1.102, this has moved to a dedicated mcp.json file.

ToolHive v0.2.0 and works with VS Code 1.102+ and updates the mcp.json file when you run an MCP server.

If you're using an older version of either ToolHive or VS Code, automatic client configuration will not work as expected and you will need to manually update your configurations. We recommend upgrading both for the best experience.

Standard version:

• macOS: ~/Library/Application Support/Code/User/mcp.json
• Linux: ~/.config/Code/User/mcp.json

Insiders edition:

• macOS: ~/Library/Application Support/Code - Insiders/User/mcp.json
• Linux: ~/.config/Code - Insiders/User/mcp.json

Example configuration:

{
  "servers": {
    "github": { "url": "http://localhost:19046/mcp", "type": "http" },
    "fetch": { "url": "http://localhost:43832/mcp", "type": "http" },
    "sqlite": { "url": "http://localhost:51712/sse#sqlite", "type": "sse" }
  }
}

When you register VS Code as a client, ToolHive automatically updates the global MCP configuration file whenever you run an MCP server. You can also configure project-specific MCP servers by creating a .vscode/mcp.json file in your project directory.

VS Code Server

VS Code Server is the server-side component that enables remote development with Visual Studio Code. It stores its global MCP configuration in a JSON file on the remote server.

• All platforms: ~/.vscode-server/data/User/mcp.json

Example configuration:

{
  "servers": {
    "github": { "url": "http://localhost:19046/mcp", "type": "http" },
    "fetch": { "url": "http://localhost:43832/mcp", "type": "http" },
    "sqlite": { "url": "http://localhost:51712/sse#sqlite", "type": "sse" }
  }
}

When you register VS Code Server as a client, ToolHive automatically updates the global MCP configuration file whenever you run an MCP server.

Cursor

Cursor stores its global MCP configuration in a JSON file in your home directory.

• All platforms: ~/.cursor/mcp.json

Example configuration:

{
  "mcpServers": {
    "github": { "url": "http://localhost:19046/mcp" },
    "fetch": { "url": "http://localhost:43832/mcp" },
    "sqlite": { "url": "http://localhost:51712/sse#sqlite" }
  }
}

Cursor automatically detects the transport mode for HTTP MCP servers.

When you register Cursor as a client, ToolHive automatically updates the global MCP configuration file whenever you run an MCP server. You can also configure project-specific MCP servers by creating a .cursor/mcp.json file in your project directory.

Claude Code

Claude Code stores its global (user scope) MCP configuration in a JSON file in your home directory.

• All platforms: ~/.claude.json

Example configuration:

{
  // Other Claude Code settings...

  "mcpServers": {
    "github": { "url": "http://localhost:19046/mcp", "type": "http" },
    "fetch": { "url": "http://localhost:43832/mcp", "type": "http" },
    "sqlite": { "url": "http://localhost:51712/sse#sqlite", "type": "sse" }
  }
}

When you register Claude Code as a client, ToolHive automatically updates the global MCP configuration file whenever you run an MCP server. You can also configure project-specific MCP servers by creating a .mcp.json file in your project directory, or add servers using the claude CLI:

claude mcp add --scope <user|project> --transport http fetch http://localhost:43832/mcp

Roo Code and Cline

Roo Code (previously Roo Cline) and Cline store their global MCP configuration in their VS Code extension settings directory. Both use the same configuration format.

Roo Code:

• macOS: ~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json
• Linux: ~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json

Cline:

• macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
• Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Example configuration:

{
  "mcpServers": {
    "github": {
      "url": "http://localhost:19046/mcp",
      "type": "streamable-http"
    },
    "fetch": { "url": "http://localhost:43832/mcp", "type": "streamable-http" },
    "sqlite": { "url": "http://localhost:51712/sse#sqlite", "type": "sse" }
    // Note: Cline uses "streamableHttp" instead of "streamable-http"
  }
}

When you register Roo Code or Cline as a client, ToolHive automatically updates the global MCP configuration file whenever you run an MCP server. With Roo Code, you can also configure project-specific MCP servers by creating a .roo/mcp.json file in your project directory.

Continue

The Continue extension stores its global MCP configuration in a JSON file in your home directory. This file is used by both the VS Code and JetBrains versions of Continue.

• All platforms: ~/.continue/config.yaml

Example configuration:

mcpServers:
  - name: github
    type: streamable-http
    url: http://localhost:19046/mcp
  - name: fetch
    type: streamable-http
    url: http://localhost:43832/mcp
  - name: sqlite
    type: sse
    url: http://localhost:51712/sse#sqlite

Continue supports SSE (type: sse) and Streamable HTTP (type: streamable-http) transports.

When you register Continue as a client, ToolHive automatically updates the global MCP configuration file whenever you run an MCP server. You can also configure project-specific MCP servers by creating a .continue/mcpServers/<name>.yaml file in your project directory.

GitHub Copilot CLI

The GitHub Copilot CLI stores its MCP configuration in a JSON file in your home directory.

• All platforms: ~/.copilot/mcp-config.json

Example configuration:

{
  "mcpServers": {
    "github": { "url": "http://localhost:19046/mcp", "type": "http" },
    "fetch": { "url": "http://localhost:43832/mcp", "type": "http" },
    "sqlite": { "url": "http://localhost:51712/sse#sqlite", "type": "sse" }
  }
}

When you register the Copilot CLI as a client, ToolHive automatically updates this file whenever you run an MCP server.

Manual configuration

If your client doesn't support automatic configuration, you'll need to set up the MCP server URL manually.

Example: PydanticAI

For PydanticAI, set the MCP server URL in your code:

from pydantic_ai.mcp import MCPServerSSE
from pydantic_ai.mcp import MCPServerStreamableHTTP

# For Streamable HTTP
server = MCPServerStreamableHTTP(url='http://localhost:43832/mcp')

# For Server-Sent Events (SSE)
server = MCPServerSSE(url='http://localhost:51712/sse#sqlite')

Example: Copilot for JetBrains IDEs

For the GitHub Copilot plugin in JetBrains IDEs (IntelliJ, Pydantic, etc.), edit your ~/.config/github-copilot/mcp.json file to include the MCP server URL:

{
  "servers": {
    "github": { "url": "http://localhost:43832/mcp", "type": "http" },
    "sqlite": { "url": "http://localhost:51712/sse#sqlite", "type": "sse" }
  }
}

Copilot for JetBrains supports SSE ("type": "sse") and Streamable HTTP ("type": "streamable-http") transports.

STDIO-only client configuration

Some MCP clients, like Claude Desktop, only support MCP servers that communicate via STDIO transport. ToolHive's thv proxy stdio command wraps any running ToolHive workload as a STDIO process so these clients can connect to it.

Run an MCP server with ToolHive as usual, for example:

thv run osv

Then configure your client to launch thv proxy stdio <WORKLOAD_NAME>. For Claude Desktop, edit your configuration file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "osv": {
      "command": "thv",
      "args": ["proxy", "stdio", "osv"]
    }
  }
}

tip

The workload name you pass to thv proxy stdio (in this case, osv) must match the name you used when running the server with thv run.

After restarting your client, the MCP server's tools are available for use.

For more details, see the thv proxy stdio CLI reference.

ChatGPT Desktop configuration

ChatGPT Desktop only accepts MCP servers over HTTPS, with no equivalent of Claude Desktop's command-based configuration. For personal experimentation with public, unauthenticated MCP servers, you can use thv proxy tunnel to expose your local ToolHive workload through an ngrok HTTPS tunnel.

Scope: personal local use only

This workaround creates a public ngrok URL pointing at a workload running on your machine. Before using it, consider:

• The tunnel is unauthenticated by default. Anyone who guesses or learns the ngrok URL can reach your MCP server.
• The workload runs with your credentials. Tunneling an auth-backed server (GitHub, Notion, Slack, and similar) means anyone who reaches the URL acts with your access.
• Workspace connectors share one tunnel. On Business, Enterprise, or Edu workspaces, every member who uses the connector hits your tunnel and acts as you, not as themselves.

For shared, multi-user, or credentialed setups, use a Virtual MCP Server (vMCP), which fronts MCP servers with proper authentication, per-user OAuth, and policy enforcement.

You'll need:

• An ngrok account and auth token
• A static ngrok domain (recommended, so the connector URL stays stable across restarts)

Run an MCP server with ToolHive as usual, for example:

thv run osv

Then start the ngrok tunnel, using the workload name as the target:

thv proxy tunnel osv osv-tunnel \
  --tunnel-provider ngrok \
  --provider-args '{"auth-token": "<YOUR_NGROK_TOKEN>", "url": "https://<YOUR_NGROK_DOMAIN>", "pooling": true}'

Then create a custom connector in ChatGPT. The setup happens on the web; the connector then works in both ChatGPT on the web and ChatGPT Desktop.

1. Open ChatGPT on the web and navigate to Settings → Apps.
2. Turn on Developer mode (this may require an admin to enable on Business, Enterprise, or Edu workspaces).
3. Click Create and fill in the app details, including the URL: your ngrok domain plus the MCP endpoint path, typically /mcp for Streamable HTTP servers (for example, https://<YOUR_NGROK_DOMAIN>/mcp).
4. Check the I trust this application box and click Save.

After saving, ChatGPT lists the tools your MCP server exposes. You can add them to a conversation by clicking + near the message composer and selecting your app.

tip

The url field in --provider-args sets a static ngrok domain. If you omit it, ngrok assigns a temporary random URL each time, which means updating the connector in ChatGPT on every restart.

For more details, see the thv proxy tunnel CLI reference.

Related information

• Client configuration
• Run MCP servers