Model Context Protocol

What Model Context Protocol? Link to heading

Model Context Protocol (MCP) is an open, vendor-neutral protocol for connecting AI applications to tools and data using a small set of well-defined capabilities: tools, resources, prompts, roots, and a few transport options (stdio and HTTP/SSE). In practice, an MCP server is any process that exposes one or more of these capabilities; an MCP client (your IDE agent, chat app, or API runtime) discovers them and uses them safely with explicit user consent. Think of MCP as a USB-C port for AI: a common connector that lets models talk to the outside world without bespoke adapters for every integration.

MCP was introduced publicly by Anthropic and is now developed in the open with a formal specification and versioning scheme. Spec versions are date-stamped (e.g., 2025-06-18) and evolve compatibly, so clients and servers can keep working as the ecosystem iterates.

Who is behind MCP and Who supports it Link to heading

Anthropic proposed and stewarded the spec and documentation, but MCP’s traction now spans multiple major platforms and vendors. JetBrains integrated an MCP server directly into IntelliJ-based IDEs (2025.2+), so external clients like Claude Desktop, Cursor, and VS Code can drive IDE actions through the protocol.

Docker offers an integration out of the box and a marketplace of MCP servers. One of the first MCP servers is the official Filesystem server, which lets you browse and edit files on your local machine.

Microsoft added MCP support in VS Code (starting with 1.102) via Copilot Chat, with first-class UX for installing, trusting, and using servers from your workspace or user profile.

OpenAI added support for remote MCP servers in the Responses API and its Agents SDK, which means MCP tools and prompts can participate in agent workflows alongside code execution.

Finally, the platform story is broadening. Microsoft announced MCP support as part of its Windows AI strategy, positioning MCP as the “USB-C of AI apps” for first-party and third-party integrations.

What MCP Can Do for You Link to heading

MCP puts a stable contract between agents and tools, you integrate once with MCP and reuse everywhere. A Git server, file-system server, database server, or test-runner server becomes portable context and capability. Reference servers include Filesystem, Git, Fetch, and much more.

Capabilities aren’t limited to imperative tools:

Resources let a client attach structured context on demand (e.g., a schema or log slice) without pasting walls of text.
Prompts are reusable parameterized templates hosted by the server.
Roots scope what the server can see.

These primitives keep prompts smaller, interactions faster, and compliance boundaries crisp.

Security is explicit.

VS Code requires trust and shows the tool invocation. IntelliJ provides an optional “brave mode” for non-interactive execution, but switches off by default.

General rule of thumb: treat servers like any code with OS access: review publishers, pin versions, scope roots, vendor dependencies, and keep secrets out of config.

Installing and using MCP with IntelliJ IDEA Link to heading

On IntelliJ IDEA 2025.2+ the MCP server is built in. Enable it at Settings → Tools → MCP Server. From there you can autoconfigure known clients—Claude Desktop, Cursor, VS Code, and others—so their JSON configs point back to your IDE. Restart the client to take effect. This gives your agent controlled access to IDE features via server tools such as search in files, reformat file, execute terminal command, or run configuration. Note that they have deprecated the MCP server plugin in favor of the built-in server.

If you prefer manual setup, use the Manual Client Configuration section to copy either SSE or stdio config and paste it into the client’s MCP settings. Only enable Run shell commands or run configurations without confirmation if you fully understand the risk model. It would remove confirmation prompts for terminal commands and run configs to streamline loops like “build → test → fix.”.

Under the hood, IntelliJ’s server exposes a catalog of tools—for example search_in_files_content, reformat_file, execute_terminal_command, get_project_dependencies, and run_configuration – so your client can invoke editor actions, inspect project structure, and orchestrate workflows without brittle UI automation.

Installing and using MCP with VS Code Link to heading

VS Code’s MCP support was put into general availability a bit before it happened with IntelliJ IDEA. It is enabled by default and can be toggled via chat.mcp.enabled. You manage servers either globally (user profile) or per-workspace through a mcp.json. VS Code also discovers servers from other tools (e.g., Claude Desktop) if chat.mcp.discovery.enabled is set.

To add a remote server for one repository, create .vscode/mcp.json and let VS Code scaffold a template from **MCP: Add Server **. A minimal example for a remote HTTP server (GitHub) looks like this:

{
  "servers": {
    "github-mcp": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp"
    }
  }
}

You can also register an stdio server that you install locally. For example, to run the official Filesystem server via uvx:

{
  "servers": {
    "filesystem": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "-q",
        "mcp-server-filesystem",
        "--root",
        "${workspaceFolder}"
      ]
    }
  },
  "inputs": [
    {
      "name": "token",
      "description": "API token",
      "default": ""
    }
  ]
}

Once added, open Copilot Chat, switch to Agent mode, and pick tools from your installed MCP servers. VS Code shows a trust prompt the first time a server starts, and it logs invocations for review. You can also add MCP servers to dev-containers via devcontainer.json so your CI and teammates share the same tool set.

A curated directory and in-product UX (“Browse MCP Servers”) make discovery straightforward. Many vendors and open-source projects provide one-click installation links that write the JSON for you.

Running MCP servers locally with Docker Link to heading

You can run an MCP server in a container and wire it into VS Code via stdio. This keeps setup reproducible and avoids local toolchain installs.

Example: GitHub MCP server via Docker. Add a server to .vscode/mcp.json that executes Docker and pipes stdio:

{
  "servers": {
    "github-mcp": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_pat}"
      }
    }
  },
  "inputs": [
    {
      "name": "github_pat",
      "description": "GitHub Personal Access Token with repo:read (or as required)",
      "default": ""
    }
  ]
}

In Copilot Chat, switch to Agent mode and start the server. VS Code will prompt for the PAT and then expose the server’s tools.

Discover containerized servers Link to heading

Several MCP servers are published as Docker images (e.g., via Docker Hub’s MCP catalog). You can pull and adapt their env/volume settings to your needs, then register them as shown above.