Plugging Your AI Clients into Docker MCP: Claude, VS Code, and Cursor

So far we’ve gotten Docker MCP set up and played with the CLI. Now let’s look at something very practical: connecting AI “clients” like Claude, VS Code, or Cursor to those MCP tools you’ve launched. This step is what lets your AI helpers (whether a chat app or a coding assistant) actually use the tools. Docker calls this “client management,” and it’s designed to be easy.

Docker MCP Set up

What’s an MCP client?

In this context, a client is an AI application or developer tool that can communicate with MCP servers. Examples include:

Claude Desktop: A local version of Anthropic’s Claude chat AI.

VS Code (with an AI assistant extension): Your code editor using an AI extension.

Cursor: A browser-based AI coding assistant.

Docker’s AI Agent or others like continue.dev or Goose. The Docker MCP Toolkit supports all of these out of the box.

Connecting a client is like handing it the address of the Docker gateway server so it can reach any tool you start. Let’s walk through some examples.

Example 1. Connecting Claude Desktop

Say you have Claude Desktop running on your computer, and you want it to use MCP tools. After launching your MCP servers (like a database or API container), open a terminal and type:

docker mcp client connect -g claude-desktop

Here, -g means “global” – it configures Claude for your whole machine, not just the current project directory. You’ll see output like:

=== System-wide MCP Configurations ===
 ● claude-desktop: connected
    [SomeTool]: docker run --rm -i mcp/sometool (stdio)
 ● other-client: disconnected

This tells you Claude is now connected to Docker’s MCP gateway. The CLI might also say “You might have to restart ‘claude-desktop’.” Indeed, you should restart the Claude app so it picks up the new settings.

Here’s a manual way of connecting the clients to Docker.

Manual way of connecting the clients to Docker

Once done, Claude’s configuration file (JSON) will have a new entry (MCP_DOCKER) pointing at the Docker gateway. Under the hood, Docker uses a little helper (like socat in a container) to pipe Claude’s input/output to the gateway’s port. In plain language, Claude now “speaks” MCP. That means it can send requests to any MCP tool you run. For example, if you launched a GitHub tool, Claude could ask it to create a repository.

"Once this configuration is added, Claude Desktop will be able to access any MCP tools you’ve set up in Docker… This allows Claude to perform actions like accessing databases, calling APIs, and using other external tools through the MCP protocol.”. In short, by doing the connect step, you’ve given Claude new superpowers safely and simply.

Example 2. Connecting VS Code

Next, let’s connect Visual Studio Code (with an AI extension, e.g. Copilot or similar). The process is similar, but usually done without -g for a local project, unless you want system-wide.

Inside your project folder, run:

docker mcp client connect vscode

You should see something like:

=== Project-wide MCP Configurations (/path/to/your/project) ===
 ● vscode: connected
    MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)
 ● cursor: no mcp configured

This tells us VS Code is now connected to Docker’s MCP gateway. The output might also remind you to restart VS Code. The next time your AI extension in VS Code runs, it will use Docker MCP.

What does that look like? Well, a snippet from Docker’s docs says:

You’ve successfully connected the Docker MCP Catalog to VS Code. The output shows: ‘VS Code is now connected to Docker MCP Catalog. It’s using the Docker MCP Catalog gateway server via stdio (standard input/output)’. Cursor is still not configured.

In everyday terms, this means the VS Code AI assistant will forward any tool-related requests to Docker. For example, if your code needs to run an SQL query, the AI can send that query to a database tool container via MCP, instead of you having to set it up manually. It’s all through one channel.

If you check again with:

docker mcp client ls

=== Project-wide MCP Configurations (/Users/ajeetsraina/hpe/genai-app-demo) ===
 ● cursor: no mcp configured
 ● vscode: connected
   MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)

you’ll see “vscode: connected” listed along with the gateway info. This quick check reassures you that VS Code is hooked up.

Example 3. Connecting the MCP Catalog to Cursor

Let’s do the same for Cursor (an AI coding assistant that runs as a client). In a terminal:

docker mcp client connect -g cursor

Again, -g for system-wide. You’ll see something like:

=== System-wide MCP Configurations ===
 ● cursor: connected
    MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)
 ● claude-desktop: connected
    sequentialthinking: docker run --rm -i mcp/sequentialthinking (stdio)

This shows Cursor is now connected to the gateway too. You might need to restart your browser or Cursor extension for changes to take effect.

With Cursor connected, any time it tries to run a tool action (say, “Explain code using Wikipedia”), it will route through Docker. The configuration output (MCP_DOCKER lines) is a success message in text form – in the background, Docker has set up the connection so Cursor’s requests go to port 8811 of the local MCP server.

Example 4. Connecting the MCP Catalog to Gordon

docker mcp client connect -g gordon

=== System-wide MCP Configurations ===
 ● cursor: connected
    MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)
 ● claude-desktop: connected
    MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)
 ● gordon: connected
    MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)
You might have to restart 'gordon'.

Docker MCP Toolkit

What Happens After Connecting?

Once you’ve connected a client and restarted it, that client can transparently use your Docker MCP tools. For example:

If Claude is connected, you could tell it in a conversation: “Use the GitHub tool to create a new repository.” Claude will go through Docker MCP rather than giving you a link to do it manually.
If VS Code is connected, an AI code completion plugin might, under the hood, call a Dockerized tool. You might not even realize it’s happening – the experience is integrated.

Docker’s approach is that you don’t have to handle credentials or setup for each client separately. They all use the same Docker-managed gateway, keeping things secure. And because Docker handles the low-level piping (with containers like socat), you don’t have to understand it; you just get to use powerful tools seamlessly.

Quick Checklist for Client Connections

Ensure the client application (Claude, VS Code, Cursor) is installed on your system.
Run docker mcp client connect [client-name] (often with -g for global).
Restart the client application as prompted.
Run docker mcp client ls to confirm it shows up as “connected”.
Now try using the AI features – they should have access to the MCP tools.

If you ever need to undo it:

docker mcp client disconnect vscode

and VS Code will no longer route through Docker.

Other MCP Clients

The Docker MCP CLI currently supports these names for client connect (as of now):

claude-desktop, continue, cursor, gordon, vscode. Other platforms (like Docker AI Agent, Goose, or windsor) might have one-click buttons or their own instructions to connect.

If you have an MCP-capable client that’s not listed, Docker suggests a manual method: you can run a tool like socat yourself to link STDIO of your app to the gateway port. This is more advanced and usually not needed for the mainstream clients.

Bringing It All Together

Connecting clients is the final step in making your AI tools work. Once this is done, any AI assistant on your machine can automatically use the full suite of MCP tools running in Docker. It feels a bit magical – as if your chatbots and editors suddenly got an upgrade.

For instance, after connecting, Docker notes that Claude can now “access any MCP tools you’ve set up in Docker, just like VS Code can now”. In practice, this means if you asked Claude (post-connection) to “query the database for X” or “call the weather API,” it would do it through the tools you enabled.

Wrapping Up

To recap:

Use docker mcp client connect to link an AI client (Claude, VS Code, Cursor, etc.) to Docker’s MCP gateway.
The CLI will report success and remind you to restart the client.
After restarting, your AI assistant can “see” all the MCP servers (tools) you’ve launched.
This setup is secure and managed by Docker, so your clients never get your raw credentials – they just send requests to Docker, which handles the rest.

Thanks to the MCP Toolkit, connecting these clients is now straightforward. It’s like plugging in a power cord: once connected, the client is energized with new capabilities. Now you can enjoy your AI assistants doing real work, powered by the Docker-managed tools you’ve set up.