MCP Clients and Hosts: Claude, Cursor, VS Code, ChatGPT, Gemini — What 'Any Client' Actually Means

MCP's JSON-RPC 2.0 wire format is the same everywhere, but "connect any client" is not a one-size answer: hosts differ in which primitives they actually implement, which transports they speak, how they authenticate, how many tools they'll tolerate, and where the config file lives. A server built and tested against Claude Desktop can silently lose features — or fail outright — on another host. This page is the per-host map for the objective's first half: connecting a client to a server on the first attempt.

Claude Desktop and Claude Code: reference implementations

Claude Desktop was among the hosts that shipped MCP support at launch — Anthropic's announcement names Zed, Replit, Codeium, and Sourcegraph as simultaneously developing their own MCP integrations (https://www.anthropic.com/news/model-context-protocol) — and is called out by the official spec docs as the exemplar host in the architecture overview (https://modelcontextprotocol.io/docs/learn/architecture). It implements all four core primitives — tools, resources, prompts, and sampling (letting a server request LLM completions) — described by one comparative source as "the broadest feature set of any platform" (https://buildtolaunch.substack.com/p/mcp-setup-claude-chatgpt-vscode-cursor). All Claude.ai plans can connect MCP servers to Claude Desktop (https://support.anthropic.com/en/articles/10949351-getting-started-with-model-context-protocol-mcp-on-claude-for-desktop).

Claude Code implements full MCP support, including all four core primitives, per the same comparative source (https://buildtolaunch.substack.com/p/mcp-setup-claude-chatgpt-vscode-cursor).

Installation

Anthropic announced Desktop Extensions in June 2025 as the .dxt format for one-click MCP server installation, covering Node.js, Python, and binary servers; the format was renamed to .mcpb in September 2025 (https://www.anthropic.com/engineering/desktop-extensions). Manual JSON configuration remains available alongside it.

IDE integrations: Cursor, VS Code, JetBrains

Cursor supports MCP natively across all plans, including free (https://cursor.com/docs/mcp). It speaks three transports: STDIO for local execution, SSE with OAuth for streaming endpoints, and Streamable HTTP with OAuth for deployed servers. Configuration is either one-click marketplace install, a custom mcp.json file, or an "Add to Cursor" button a server's own docs page can expose with pre-filled config. Cursor also supports resources (read-only data) (https://cursor.com/docs/mcp). Constraint to design around: Cursor has no documented hard limit on the number of tools a server can expose (https://chatforest.com/guides/mcp-setup-ai-coding-tools/), and it is locked to the Cursor editor (https://nimbalyst.com/blog/best-mcp-clients-2026/). The community server registry passed 200 entries by May 2026 per the same source.

VS Code has had native MCP support since v1.102 (July 2025), surfaced through GitHub Copilot Chat, and can act as both a host and a server for external clients (https://modelcontextprotocol.io/docs/learn/architecture). Its configuration uses a "servers" key — not "mcpServers" — which breaks naive copy-paste of config from other hosts (https://chatforest.com/guides/mcp-setup-ai-coding-tools/).

JetBrains IDEs: IntelliJ IDEA 2025.2+ ships an integrated MCP server that exposes IDE-internal tools — code analysis, file modification, configuration execution, debugging, database queries, project search — to external clients such as Claude Code, Claude Desktop, Cursor, and VS Code (https://www.jetbrains.com/help/idea/mcp-server.html). It can auto-configure popular clients via Settings → Tools → MCP Server → Auto-Configure, which writes the client's JSON config directly. Separate JetBrains Marketplace plugins add more surface: MCP Server Plugin, Code Intelligence MCP plugin, IDE Index MCP Server, and Debugger MCP Server — the last gives an AI assistant full debugger control (line/conditional breakpoints, tracepoints, execution control) (https://plugins.jetbrains.com/plugin/26071-mcp-server).

ChatGPT, Google Gemini, Microsoft Copilot

ChatGPT's MCP support is in Developer Mode public beta with full read *and* write action capability (write was previously restricted), available on the web to Pro, Plus, Business, Enterprise, and Education accounts (https://help.openai.com/en/articles/12584461-developer-mode-and-mcp-apps-in-chatgpt). It supports SSE and Streamable HTTP transports, with OAuth, No Authentication, or Mixed Authentication. Architecturally it is described as "remote-first," in contrast to Claude's "local-first" default (https://buildtolaunch.substack.com/p/mcp-setup-claude-chatgpt-vscode-cursor) — relevant when deciding whether to ship stdio or hosted-HTTP first for a server that must reach both.

Google Gemini's MCP support is experimental, available in the Python and JS SDKs (https://docs.cloud.google.com/cloud-assist/configure-mcp). Integration goes through Gemini's own function-calling schema conversion — MCP tools are exposed via FunctionDeclaration, FunctionCall, and FunctionResponse (https://medium.com/google-cloud/model-context-protocol-mcp-with-google-gemini-llm-a-deep-dive-full-code-ea16e3fac9a3). As of March–April 2026, MCP tool calls and Gemini's built-in function calling can be combined in a single request, so a server's tools and Google Search grounding can be active together (https://buildtolaunch.substack.com/p/mcp-setup-claude-chatgpt-vscode-cursor). Gemini currently supports only the tools primitive — resources and prompts are not implemented (https://docs.cloud.google.com/cloud-assist/configure-mcp), so a server that leans on resources/prompts will silently lose that functionality here. Gemini's Managed Agents work adds background execution, remote MCP server integration, custom function calling, and credential refresh across interactions (https://blog.google/innovation-and-ai/technology/developers-tools/expanding-managed-agents-gemini-api/); Cloud Assist's own MCP integration is still in private preview.

Microsoft Copilot Studio reached general availability for MCP on May 29, 2025 (https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/model-context-protocol-mcp-is-now-generally-available-in-microsoft-copilot-studio/). Every tool a connected MCP server publishes is auto-added as a Copilot action, inheriting name, description, inputs, and outputs — no manual re-wiring, and changes on the server side (tools updated or removed) propagate automatically. It supports Streamable transport and ships an activity map that shows which server/tool was invoked at runtime, useful for debugging a server integration live. An onboarding wizard is the documented simplest path to connect an existing server (https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-existing-server-to-agent).

Configuration: same server, different wiring per host

Config key and file location differ by host — this is the first thing to check when a "working" server config from one host doesn't load in another:

- Claude Desktop: .mcpb one-click Desktop Extension, or manual JSON. - Cursor: marketplace one-click, custom mcp.json, or "Add to Cursor" button. - VS Code / GitHub Copilot Chat: "servers" key (not "mcpServers"). - JetBrains: Settings → Tools → MCP Server auto-configure wizard, or manual connection-type copy. - Windsurf: config file at ~/.codeium/windsurf/mcp_config.json (macOS/Linux) or %USERPROFILE%\.codeium\windsurf\mcp_config.json (Windows) (https://docs.windsurf.com/windsurf/cascade/mcp). - ChatGPT: Settings → Apps → Advanced settings → Developer mode, then register the server through the platform UI. - Copilot Studio: guided onboarding wizard.

Most coding IDEs — Cursor, Claude Code, Cline, Windsurf — share the same mcpServers JSON structure, so config is portable between them; VS Code ("servers") and Zed ("context_servers") are the documented outliers (https://chatforest.com/guides/mcp-setup-ai-coding-tools/).

What does NOT work

- Assuming feature parity across hosts. The protocol layer guarantees JSON-RPC 2.0 compliance and a version-negotiation handshake — if client and server can't agree on a compatible protocol version, the connection is terminated (https://modelcontextprotocol.io/docs/learn/architecture) — but that only guarantees the connection opens, not that every primitive your server exposes will be used. Gemini drops resources and prompts entirely; a server relying on them degrades silently there. - Assuming one tool-count budget fits all hosts. Windsurf's Cascade panel caps at 100 tools (https://nimbalyst.com/blog/best-mcp-clients-2026/); Cursor has no documented hard tool-count limit (https://chatforest.com/guides/mcp-setup-ai-coding-tools/) — combining several MCP servers on the same host can still blow a limit that does exist without warning. - Copy-pasting config JSON between hosts unmodified. VS Code's "servers" key and Zed's "context_servers" key both diverge from the mcpServers convention most other hosts share (https://chatforest.com/guides/mcp-setup-ai-coding-tools/); a config that "just works" in Claude Desktop needs the key renamed for VS Code. - Expecting prompts to render the same way everywhere. Claude Code surfaces prompt primitives as slash commands, Cursor as quick actions, Windsurf adds them to the command palette (https://chatforest.com/guides/mcp-setup-ai-coding-tools/) — the primitive is portable, the UX around it is not. - Expecting MCP Apps (server-rendered UI) to work on any host. As of January 2026, only Claude web/desktop, Goose, VS Code Insiders, and ChatGPT support it; several hosts do not (https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/) — see MCP Apps: Server-Rendered UI Extensions — how a tool call returns an interactive interface the host renders inside the conversation, and what keeps that iframe from taking over. - UNVERIFIED: JetBrains' MCP server runs *inside* the IDE to expose IDE tools outward to external clients — the inverse of the typical pattern where a standalone server exposes tools inward to a host. The notes flag this as a plausible interoperability/trust wrinkle but it is not confirmed against a second independent source.

This is the practical reason a server that "works on Claude Desktop" is not yet proven to connect on the first attempt anywhere else: primitive support, transport, auth method, tool-count limits, and config syntax all vary independently per host, and any one of them can be the actual blocker.

Related

- MCP Architecture: Host, Client, Server, and the JSON-RPC 2.0 Wire Format — the host/client/server split and JSON-RPC layer every implementation in this page must honor; explains why the connection *opens* even when host UX and feature support diverge. - MCP Transports: stdio for Local Servers, Streamable HTTP for Remote Ones — the stdio-vs-Streamable-HTTP trade-off behind why Cursor and ChatGPT need OAuth-over-HTTP while Claude Desktop defaults to local stdio. - MCP Core Primitives: Tools, Resources, and Prompts — who is allowed to invoke what, and what a server must declare to offer it — needed to understand *why* Gemini's tools-only support and Claude's full primitive set produce different real capability against the identical server. - Building an MCP Server: SDKs, Tool Schemas, Testing, and Deployment — the practical path from a 15-minute local prototype to a hosted remote server — the build-side counterpart: once you know which host(s) you're targeting from this page, use that page for the actual scaffolding, schema, and deployment steps. - MCP Apps: Server-Rendered UI Extensions — how a tool call returns an interactive interface the host renders inside the conversation, and what keeps that iframe from taking over — forward reference for the UI-extension support gap flagged above. - MCP Limits: Registry Trust and Supply Chain Risks — why 'it's in the registry' is not a safety guarantee before you connect a client — forward reference for the trust questions raised by JetBrains' inverted server-inside-IDE model and by multi-host installation generally.