centersl/docker-docs
1
0
Fork 0
mirror of https://github.com/docker/docs.git synced 2026-03-27 14:28:47 +07:00
Code Issues Packages Projects Releases Wiki Activity

mcp: profiles and custom catalogs

Browse Source 
Signed-off-by: David Karlsson <35727626+dvdksn@users.noreply.github.com>
This commit is contained in:
David Karlsson
2026-02-09 09:05:07 +00:00
parent 2db1ffab56
commit b7b8ea4f5f
11 changed files with 887 additions and 522 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
content/manuals/ai/mcp-catalog-and-toolkit/_index.md
View File

@@ -19,12 +19,16 @@ grid:
description: Browse Docker's curated collection of verified MCP servers
icon: hub
link: /ai/mcp-catalog-and-toolkit/catalog/
- title: MCP Profiles
description: Organize servers into profiles for different projects and share configurations
icon: folder
link: /ai/mcp-catalog-and-toolkit/profiles/
- title: MCP Toolkit
description: Learn about the MCP Toolkit to manage MCP servers and clients
description: Use Docker Desktop's UI to discover, configure, and manage MCP servers
icon: /icons/toolkit.svg
link: /ai/mcp-catalog-and-toolkit/toolkit/
- title: MCP Gateway
description: Learn about the underlying technology that powers the MCP Toolkit
description: Use the CLI and Gateway to run MCP servers with custom configurations
icon: developer_board
link: /ai/mcp-catalog-and-toolkit/mcp-gateway/
- title: Dynamic MCP
@@ -62,32 +66,30 @@ time you manage credentials, permissions, and environment setup.
## Docker MCP features
Docker solves these challenges by packaging MCP servers as containers and
providing tools to manage them centrally. Docker provides three integrated
components: the [MCP Catalog](/ai/mcp-catalog-and-toolkit/catalog/) for
discovering servers, the [MCP Gateway](/ai/mcp-catalog-and-toolkit/mcp-gateway/)
for running them, and the [MCP Toolkit](/ai/mcp-catalog-and-toolkit/toolkit/)
for managing everything through Docker Desktop.
The [MCP Toolkit](/ai/mcp-catalog-and-toolkit/toolkit/) and [MCP
Gateway](/ai/mcp-catalog-and-toolkit/mcp-gateway/) solve these challenges
through centralized management. Instead of configuring each server for every AI
application separately, you set things up once and connect all your clients to
it. The workflow centers on three concepts: catalogs, profiles, and clients.
The [MCP Catalog](/ai/mcp-catalog-and-toolkit/catalog/) is where you find
servers. Docker maintains 300+ verified servers, packaged as container images
with versioning, provenance, and security updates. Servers run isolated in
containers rather than directly on your machine. Organizations can create
[custom catalogs](/ai/mcp-catalog-and-toolkit/catalog/#custom-catalogs) with
approved servers for their teams.
![MCP overview](./images/mcp_toolkit.avif)
The [MCP Gateway](/ai/mcp-catalog-and-toolkit/mcp-gateway/) runs your servers
and routes requests from AI applications to the right server. It handles
containerized servers, remote servers, authentication, and lifecycle
management. Every AI application connects to the Gateway, which means you
configure credentials and permissions once instead of per-application.
[Catalogs](/ai/mcp-catalog-and-toolkit/catalog/) are curated collections of
MCP servers. The Docker MCP Catalog provides 300+ verified servers packaged as
container images with versioning, provenance, and security updates. Organizations
can create [custom
catalogs](/ai/mcp-catalog-and-toolkit/catalog/#custom-catalogs) with approved
servers for their teams.
The [MCP Toolkit](/ai/mcp-catalog-and-toolkit/toolkit/) provides a graphical
interface in Docker Desktop for browsing catalogs, enabling servers, and
connecting clients. You can also use the `docker mcp` CLI to manage everything
from the terminal.
[Profiles](/ai/mcp-catalog-and-toolkit/profiles/) organize servers into named
collections for different projects. Your "web-dev" profile might use GitHub and
Playwright; your "backend" profile, database tools. Profiles support both
containerized servers from catalogs and remote MCP servers. Configure a profile
once, then share it across clients or with your team.
![MCP overview](./images/mcp-overview.svg)
Clients are the AI applications that connect to your profiles. Claude Code,
Cursor, Zed, and others connect through the MCP Gateway, which routes requests
to the right server and handles authentication and lifecycle management.
## Learn more

219
content/manuals/ai/mcp-catalog-and-toolkit/catalog.md
View File

@@ -1,8 +1,8 @@
---
title: Docker MCP Catalog
linkTitle: Catalog
description: Learn about the benefits of the MCP Catalog, how you can use it, and how you can contribute
keywords: docker hub, mcp, mcp servers, ai agents, catalog, docker
description: Browse Docker's curated collection of verified MCP servers, and create custom catalogs for your team or organization.
keywords: docker hub, mcp, mcp servers, ai agents, catalog, custom catalog, docker
weight: 20
---
@@ -13,14 +13,15 @@ verified MCP servers, packaged as Docker images and distributed through Docker
Hub. It solves common challenges with running MCP servers locally: environment
conflicts, setup complexity, and security concerns.
The catalog serves as the source of available MCP servers. Each server runs as
an isolated container, making it portable and consistent across different
environments.
The catalog serves as the source of available MCP servers. When you add servers
to your [profiles](/manuals/ai/mcp-catalog-and-toolkit/profiles.md), you select
them from the catalog. Each server runs as an isolated container, making it
portable and consistent across different environments.
> [!NOTE]
> E2B sandboxes now include direct access to the Docker MCP Catalog, giving developers
> access to over 200 tools and services to seamlessly build and run AI agents. For
> more information, see [E2B Sandboxes](sandboxes.md).
> E2B sandboxes now include direct access to the Docker MCP Catalog, giving
> developers access to over 200 tools and services to seamlessly build and run
> AI agents. For more information, see [E2B Sandboxes](e2b-sandboxes.md).
## What's in the catalog
@@ -35,9 +36,6 @@ The Docker MCP Catalog includes:
- Remote services: Cloud-hosted servers that connect to external services like
GitHub, Notion, and Linear
You can browse the catalog at [hub.docker.com/mcp](https://hub.docker.com/mcp)
or through the **Catalog** tab in Docker Desktop's MCP Toolkit.
### Local versus remote servers
The catalog contains two types of servers based on where they run:
@@ -50,22 +48,81 @@ Remote servers run on the provider's infrastructure and connect to external
services. Many remote servers use OAuth authentication, which the MCP Toolkit
handles automatically through your browser.
## Using servers from the catalog
## Browse the catalog
To start using MCP servers from the catalog:
Browse available MCP servers at [hub.docker.com/mcp](https://hub.docker.com/mcp)
or directly in Docker Desktop:
1. Browse servers in the [MCP Catalog](https://hub.docker.com/mcp) or in Docker
Desktop
2. Enable servers through the MCP Toolkit
3. Configure any required authentication (OAuth is handled automatically)
4. Connect your AI applications to use the servers
1. In Docker Desktop, select **MCP Toolkit**.
2. Select the **Catalog** tab to browse available servers.
3. Select a server to view its description, tools, and configuration options.
For detailed step-by-step instructions, see:
## Add servers to a profile
- [Get started with MCP Toolkit](/ai/mcp-catalog-and-toolkit/get-started/) -
Quick start guide
- [MCP Toolkit](/ai/mcp-catalog-and-toolkit/toolkit/) - Detailed usage
instructions
To add a server from the catalog to a profile:
1. In the **Catalog** tab, select the checkbox next to a server.
2. Choose the profile to add it to from the drop-down.
For step-by-step instructions and client connection, see
[Get started with MCP Toolkit](get-started.md) or
[MCP Profiles](profiles.md).
## Custom catalogs
Custom catalogs let you curate focused collections of servers for your team or
organization. Instead of exposing all 300+ servers in the Docker catalog, you
define exactly which servers are available.
Common use cases:
- Restrict which servers your organization approves for use
- Add your organization's private MCP servers alongside public ones
- Control which server versions your team uses
- Define the server set available to AI agents using [Dynamic MCP](dynamic-mcp.md)
### Custom catalogs with Dynamic MCP
Custom catalogs work particularly well with
[Dynamic MCP](/ai/mcp-catalog-and-toolkit/dynamic-mcp/), where agents discover
and add MCP servers on-demand during conversations. When you run the gateway
with a custom catalog, the `mcp-find` tool searches only within that catalog.
If your catalog contains 20 servers instead of 300+, agents work within that
focused set, discovering and enabling tools as needed without manual
configuration each time.
### Import a custom catalog
If someone on your team has created and published a catalog, you can import it
using its OCI registry reference.
In Docker Desktop:
1. Select **MCP Toolkit** and select the **Catalog** tab.
2. Select **Import catalog**.
3. Enter the OCI reference for the catalog (for example,
`registry.example.com/mcp/team-catalog:latest`).
4. Select **Import**.
Using the CLI:
```console
$ docker mcp catalog pull <oci-reference>
```
Once imported, the catalog appears alongside the Docker catalog and you can add
its servers to your profiles.
### Create and manage custom catalogs
Creating and managing custom catalogs requires the CLI. See
[Custom catalogs](/manuals/ai/mcp-catalog-and-toolkit/cli.md#custom-catalogs)
in the CLI how-to for step-by-step instructions, including:
- Curating a subset of the Docker catalog
- Adding private servers to a catalog
- Building a focused catalog from scratch
- Pushing a catalog to a registry for your team to import
## Contribute an MCP server to the catalog
@@ -80,119 +137,3 @@ within 24 hours on:
- The [Docker MCP Catalog](https://hub.docker.com/mcp).
- The [Docker Hub](https://hub.docker.com/u/mcp) `mcp` namespace (for MCP
servers built by Docker).
## Custom catalogs
Custom catalogs let you curate focused collections of recommended servers. You
can package custom server implementations alongside public servers, distribute
curated lists to your team, and define what agents can discover when using
Dynamic MCP.
Common use cases:
- Curate a subset of servers from the Docker MCP Catalog that your organization
approves
- Include community registry servers that aren't in the Docker catalog
- Add your organization's private MCP servers
- Control which versions of servers your team uses
### Custom catalogs with Dynamic MCP
Custom catalogs work particularly well with
[Dynamic MCP](/ai/mcp-catalog-and-toolkit/dynamic-mcp/), where agents
discover and add MCP servers on-demand during conversations. When you specify a
custom catalog with the gateway, the `mcp-find` tool searches only within your
curated catalog. If your catalog contains 20 servers instead of 300+, agents
work within that focused set and can dynamically add servers as needed without
manual configuration each time.
This gives agents the autonomy to discover and use tools while keeping their
options within boundaries your team defines.
### Create and curate a catalog
The most practical way to create a custom catalog is to fork the Docker catalog
and then curate which servers to keep:
```console
$ docker mcp catalog fork docker-mcp my-catalog
```
This creates a copy of the Docker catalog with all available servers. Export it
to a file where you can edit which servers to include:
```console
$ docker mcp catalog export my-catalog ./my-catalog.yaml
```
Edit `my-catalog.yaml` to remove servers you don't want, keeping only the ones
your team needs. Each server is listed in the `registry` section. Import the
edited catalog back:
```console
$ docker mcp catalog import ./my-catalog.yaml
```
View your curated catalog:
```console
$ docker mcp catalog show my-catalog
```
#### Alternative: Build incrementally
You can also build a catalog from scratch. Start with an empty catalog or a
template:
```console
$ docker mcp catalog create my-catalog
```
Or create a starter template with example servers:
```console
$ docker mcp catalog bootstrap ./starter-catalog.yaml
```
Add servers from other catalog files:
```console
$ docker mcp catalog add my-catalog notion ./other-catalog.yaml
```
### Use a custom catalog
Use your custom catalog when running the MCP gateway. For static server
configuration, specify which servers to enable:
```console
$ docker mcp gateway run --catalog my-catalog.yaml --servers notion,brave
```
For Dynamic MCP, where agents discover and add servers during conversations,
specify just the catalog:
```console
$ docker mcp gateway run --catalog my-catalog.yaml
```
Agents can then use `mcp-find` to search for servers within your catalog and
`mcp-add` to enable them dynamically.
The `--catalog` flag points to a catalog file in `~/.docker/mcp/catalogs/`.
### Share your catalog
Share your catalog with your team by distributing the YAML file or hosting it
at a URL:
```console
$ docker mcp catalog export my-catalog ./team-catalog.yaml
```
Team members can import it:
```console
$ docker mcp catalog import ./team-catalog.yaml
$ docker mcp catalog import https://example.com/team-catalog.yaml
```

368
content/manuals/ai/mcp-catalog-and-toolkit/cli.md Normal file
View File

@@ -0,0 +1,368 @@
---
title: Use MCP Toolkit from the CLI
linkTitle: Use with CLI
description: Manage MCP profiles, servers, and catalogs using the Docker MCP CLI.
keywords: docker mcp, cli, profiles, servers, catalog, gateway
weight: 35
---
{{< summary-bar feature_name="Docker MCP Toolkit" >}}
> [!NOTE]
> The `docker mcp` commands documented here are available in Docker Desktop
> 4.62 and later. Earlier versions may not support all commands shown.
The `docker mcp` commands let you manage MCP profiles, servers, OAuth
credentials, and catalogs from the terminal. Use the CLI for scripting,
automation, and headless environments.
## Profiles
### Create a profile
```console
$ docker mcp profile create --name <profile-id>
```
The profile ID is used to reference the profile in subsequent commands:
```console
$ docker mcp profile create --name web-dev
```
### List profiles
```console
$ docker mcp profile list
```
### View a profile
```console
$ docker mcp profile show <profile-id>
```
### Remove a profile
```console
$ docker mcp profile remove <profile-id>
```
> [!CAUTION]
> Removing a profile deletes all its server configurations and settings. This
> action can't be undone.
## Servers
### Browse the catalog
List available servers and their IDs:
```console
$ docker mcp catalog server ls mcp/docker-mcp-catalog
```
The output lists each server by name. The name (for example, `playwright` or
`github-official`) is the server ID to use in `catalog://` URIs.
To look up a server ID in Docker Desktop, open **MCP Toolkit** > **Catalog**,
select a server, and check the **Server ID** field.
### Add servers to a profile
Servers are referenced by URI. The URI format depends on where the server
comes from:
| Format | Source |
| --- | --- |
| `catalog://<catalog-ref>/<server-id>` | An OCI catalog |
| `docker://<image>:<tag>` | A Docker image |
| `https://<url>/v0/servers/<uuid>` | The MCP community registry |
| `file://<path>` | A local YAML or JSON file |
The most common format is `catalog://`, where `<catalog-ref>` matches the
**Catalog** field and `<server-id>` matches the **Server ID** field shown in
Docker Desktop or in the `catalog server ls` output:
```console
$ docker mcp profile server add <profile-id> \
--server catalog://<catalog-ref>/<server-id>
```
Add multiple servers in one command:
```console
$ docker mcp profile server add web-dev \
--server catalog://mcp/docker-mcp-catalog/github-official \
--server catalog://mcp/docker-mcp-catalog/playwright
```
To add a server defined in a local YAML file:
```console
$ docker mcp profile server add my-profile \
--server file://./my-server.yaml
```
The YAML file defines the server image and configuration:
```yaml
name: my-server
title: My Server
type: server
image: myimage:latest
description: Description of the server
```
If the server requires OAuth authentication, authorize it in Docker Desktop
after adding. See [OAuth authentication](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md#oauth-authentication).
### List servers
List all servers across all profiles:
```console
$ docker mcp profile server ls
```
Filter by profile:
```console
$ docker mcp profile server ls --filter profile=web-dev
```
### Remove a server
```console
$ docker mcp profile server remove <profile-id> --name <server-name>
```
Remove multiple servers at once:
```console
$ docker mcp profile server remove web-dev \
--name github-official \
--name playwright
```
### Configure server settings
Set and retrieve configuration values for servers in a profile:
```console
$ docker mcp profile config <profile-id> --set <server-id>.<key>=<value>
$ docker mcp profile config <profile-id> --get-all
$ docker mcp profile config <profile-id> --del <server-id>.<key>
```
Server configuration keys and their expected values are defined by each server.
Check the server's documentation or its entry in Docker Desktop under
**MCP Toolkit** > **Catalog** > **Configuration**.
## Gateway
Run the MCP Gateway with a specific profile:
```console
$ docker mcp gateway run --profile <profile-id>
```
Omit `--profile` to use the default profile.
### Connect a client manually
To connect any client that isn't listed in Docker Desktop, configure it to run
the gateway over `stdio`. For example, in a JSON-based client configuration:
```json
{
"servers": {
"MCP_DOCKER": {
"command": "docker",
"args": ["mcp", "gateway", "run", "--profile", "web-dev"],
"type": "stdio"
}
}
}
```
For Claude Desktop, the format is:
```json
{
"mcpServers": {
"MCP_DOCKER": {
"command": "docker",
"args": ["mcp", "gateway", "run", "--profile", "web-dev"]
}
}
}
```
### Connect a named client
Connect a supported client to a profile:
```console
$ docker mcp client connect <client> --profile <profile-id>
```
For example, to connect VS Code to a project-specific profile:
```console
$ docker mcp client connect vscode --profile my-project
```
This creates a `.vscode/mcp.json` file in the current directory. Because this
is a user-specific file, add it to `.gitignore`:
```console
$ echo ".vscode/mcp.json" >> .gitignore
```
## Share profiles
Profiles are shared as OCI artifacts via any OCI-compatible registry.
Credentials are not included for security reasons. Team members configure
OAuth separately after pulling.
### Push a profile
```console
$ docker mcp profile push <profile-id> <registry-reference>
```
For example:
```console
$ docker mcp profile push web-dev registry.example.com/profiles/web-dev:v1
```
### Pull a profile
```console
$ docker mcp profile pull <registry-reference>
```
For example:
```console
$ docker mcp profile pull registry.example.com/profiles/team-standard:latest
```
## Custom catalogs
Custom catalogs let you curate a focused collection of servers for your team or
organization. For an overview of what custom catalogs are and when to use them,
see [Custom catalogs](/manuals/ai/mcp-catalog-and-toolkit/catalog.md#custom-catalogs).
Catalogs are referenced by OCI reference, for example
`registry.example.com/mcp/my-catalog:latest`. Servers within a catalog use
the same URI schemes as when
[adding servers to a profile](#add-servers-to-a-profile).
### Customize the Docker catalog
Use the Docker catalog as a base, then add or remove servers to fit your
organization's needs. Copy it first:
```console
$ docker mcp catalog tag mcp/docker-mcp-catalog registry.example.com/mcp/company-tools:latest
```
List the servers it contains:
```console
$ docker mcp catalog server ls registry.example.com/mcp/company-tools:latest
```
Remove servers your organization doesn't approve:
```console
$ docker mcp catalog server remove registry.example.com/mcp/company-tools:latest \
--name <server-name>
```
Add your own private servers, packaged as Docker images:
```console
$ docker mcp catalog server add registry.example.com/mcp/company-tools:latest \
--server docker://registry.example.com/mcp/internal-api:latest \
--server docker://registry.example.com/mcp/data-pipeline:latest
```
Push when ready:
```console
$ docker mcp catalog push registry.example.com/mcp/company-tools:latest
```
### Build a catalog from scratch
To include exactly what you choose and nothing else, create a catalog from
scratch. You can include servers from the Docker catalog, your own private
images, or both.
Create a catalog and specify which servers to include:
```console
$ docker mcp catalog create registry.example.com/mcp/data-tools:latest \
--title "Data Analysis Tools" \
--server catalog://mcp/docker-mcp-catalog/postgres \
--server catalog://mcp/docker-mcp-catalog/brave-search \
--server docker://registry.example.com/mcp/analytics:latest
```
View the result:
```console
$ docker mcp catalog show registry.example.com/mcp/data-tools:latest
```
Push to distribute:
```console
$ docker mcp catalog push registry.example.com/mcp/data-tools:latest
```
### Distribute a catalog
Push your catalog so team members can import it:
```console
$ docker mcp catalog push <oci-reference>
```
Team members can pull it using the CLI:
```console
$ docker mcp catalog pull <oci-reference>
```
Or import it using Docker Desktop: select **MCP Toolkit** > **Catalog** >
**Import catalog** and enter the OCI reference.
### Use a custom catalog with the gateway
Run the gateway with your catalog instead of the default Docker catalog:
```console
$ docker mcp gateway run --catalog <oci-reference>
```
For [Dynamic MCP](/manuals/ai/mcp-catalog-and-toolkit/dynamic-mcp.md), where
agents discover and add servers during conversations, this limits what agents
can find to your curated set.
To enable specific servers from your catalog without using a profile:
```console
$ docker mcp gateway run --catalog <oci-reference> --servers <name1> --servers <name2>
```
## Further reading
- [Get started with MCP Toolkit](/manuals/ai/mcp-catalog-and-toolkit/get-started.md)
- [MCP Profiles](/manuals/ai/mcp-catalog-and-toolkit/profiles.md)
- [MCP Catalog](/manuals/ai/mcp-catalog-and-toolkit/catalog.md)
- [MCP Gateway](/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md)

12
content/manuals/ai/mcp-catalog-and-toolkit/dynamic-mcp.md
View File

@@ -1,9 +1,9 @@
---
title: Dynamic MCP
linkTitle: Dynamic MCP
linkTitle: Dynamic discovery
description: Discover and add MCP servers on-demand using natural language with Dynamic MCP servers
keywords: dynamic mcps, mcp discovery, mcp-find, mcp-add, code-mode, ai agents, model context protocol
weight: 35
weight: 40
params:
sidebar:
badge:
@@ -36,7 +36,7 @@ general questions and feature requests.
## How it works
When you connect a client to the MCP Gateway, the gateway exposes a small set
of management tools alongside any MCP servers you've already enabled. These
of management tools alongside any MCP servers in your active profile. These
management tools let agents interact with the gateway's configuration:
| Tool | Description |
@@ -53,8 +53,10 @@ handle authentication, and use newly added tools directly without requiring a
restart or manual configuration.
Dynamically added servers and tools are associated with your _current session
only_. When you start a new session, previously added servers are not
automatically included.
only_. They're not persisted to your profile. When you start a new session,
only servers you've added to your profile through the
[MCP Toolkit](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md) or
[Profiles](/manuals/ai/mcp-catalog-and-toolkit/profiles.md) are available.
## Prerequisites

46
content/manuals/ai/mcp-catalog-and-toolkit/faqs.md
View File

@@ -1,6 +1,6 @@
---
title: Security FAQs
linkTitle: Security FAQs
title: MCP Toolkit FAQs
linkTitle: FAQs
description: Frequently asked questions related to MCP Catalog and Toolkit security
keywords: MCP, Toolkit, MCP server, MCP client, security, faq
tags: [FAQ]
@@ -23,7 +23,7 @@ Currently, a majority of the servers in the catalog are built directly by Docker
> [!NOTE]
> When using the images with [Docker MCP gateway](/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md),
> you can verify attestations at runtime using the `docker mcp gateway run
> --verify-signatures` CLI command.
--verify-signatures` CLI command.
In addition to Docker-built servers, the catalog includes select servers from trusted registries such as GitHub and HashiCorp. Each third-party server undergoes a verification process that includes:
@@ -68,6 +68,46 @@ $ docker mcp catalog update
After the update completes, refresh the **Catalog** tab in Docker Desktop.
### What's the difference between profiles and the catalog?
The [catalog](/manuals/ai/mcp-catalog-and-toolkit/catalog.md) is the source of
available MCP servers - a library of tools you can choose from.
[Profiles](/manuals/ai/mcp-catalog-and-toolkit/profiles.md) are collections of
servers you've added to organize your work. Think of the catalog as a library,
and profiles as your personal bookshelves containing the books you've selected
for different purposes.
### Can I share profiles with my team?
Yes. Profiles can be pushed to OCI-compliant registries using
`docker mcp profile push my-profile registry.example.com/profiles/my-profile:v1`.
Team members can pull your profile with
`docker mcp profile pull registry.example.com/profiles/my-profile:v1`. Note
that credentials aren't included in shared profiles for security reasons - team
members need to configure OAuth and other credentials separately.
### Do I need to create a profile to use MCP Toolkit?
Yes, MCP Toolkit requires a profile to run servers. If you're upgrading from a
version before profiles were introduced, a default profile is automatically
created for you with your existing server configurations. You can create
additional named profiles to organize servers for different projects or
environments.
### What happens to servers when I switch profiles?
Each profile contains its own set of servers and configurations. When you run
the gateway with `--profile profile-name`, only servers in that profile are
available to clients. The default profile is used when no profile is specified.
Switching between profiles changes which servers your AI applications can
access.
### Can I use the same server in multiple profiles?
Yes. You can add the same MCP server to multiple profiles, each with different
configurations if needed. This is useful when you need the same server with
different settings for different projects or environments.
## Related pages
- [Get started with MCP Toolkit](/manuals/ai/mcp-catalog-and-toolkit/get-started.md)

128
content/manuals/ai/mcp-catalog-and-toolkit/get-started.md
View File

@@ -3,18 +3,23 @@ title: Get started with Docker MCP Toolkit
linkTitle: Get started
description: Learn how to quickly install and use the MCP Toolkit to set up servers and clients.
keywords: Docker MCP Toolkit, MCP server, MCP client, AI agents
weight: 10
weight: 5
params:
test_prompt: Use the GitHub MCP server to show me my open pull requests
---
{{< summary-bar feature_name="Docker MCP Toolkit" >}}
> [!NOTE]
> This page describes the MCP Toolkit interface in Docker Desktop 4.62 and
> later. Earlier versions have a different UI. Upgrade to follow these
> instructions exactly.
The Docker MCP Toolkit makes it easy to set up, manage, and run containerized
Model Context Protocol (MCP) servers, and connect them to AI agents. It
provides secure defaults and support for a growing ecosystem of LLM-based
clients. This page shows you how to get started quickly with the Docker MCP
Toolkit.
Model Context Protocol (MCP) servers in profiles, and connect them to AI
agents. It provides secure defaults and support for a growing ecosystem of
LLM-based clients. This page shows you how to get started quickly with the
Docker MCP Toolkit.
## Setup
@@ -27,65 +32,53 @@ Before you begin, make sure you meet the following requirements to get started w
The **Learning center** in Docker Desktop provides walkthroughs and resources
to help you get started with Docker products and features. On the **MCP
Toolkit** page, the **Get started** walkthrough that guides you through
installing an MCP server, connecting a client, and testing your setup.
Toolkit** page, the **Get started** walkthrough guides you through installing
an MCP server, connecting a client, and testing your setup.
Alternatively, follow the step-by-step instructions on this page to:
Alternatively, follow the step-by-step instructions on this page:
- [Install MCP servers](#install-mcp-servers)
- [Connect clients](#connect-clients)
- [Verify connections](#verify-connections)
- [Create a profile](#create-a-profile) - Your workspace for organizing servers
- [Add MCP servers to your profile](#add-mcp-servers) - Select tools from the catalog
- [Connect clients](#connect-clients) - Link AI applications to your profile
- [Verify connections](#verify-connections) - Test that everything works
## Install MCP servers
Once configured, your AI applications can use all the servers in your profile.
{{< tabs >}}
{{< tab name="Docker Desktop">}}
> [!TIP]
> Prefer working from the terminal? See [Use MCP Toolkit from the CLI](cli.md)
> for instructions on using the `docker mcp` commands.
## Create a profile
Profiles organize your MCP servers into collections. Create a profile for your
work:
> [!NOTE]
> If you're upgrading from a previous version of MCP Toolkit, your existing
> server configurations are already in a `default` profile. You can continue
> using the default profile or create new profiles for different projects.
1. In Docker Desktop, select **MCP Toolkit** and select the **Profiles** tab.
2. Select **Create profile**.
3. Enter a name for your profile (e.g., "Frontend development").
4. Optionally, add servers and clients now, or add them later.
5. Select **Create**.
Your new profile appears in the profiles list.
## Add MCP servers
1. In Docker Desktop, select **MCP Toolkit** and select the **Catalog** tab.
2. Search for the **GitHub Official** server from the catalog and then select the plus icon to add it.
3. In the **GitHub Official** server page, select the **Configuration** tab and select **OAuth**.
2. Browse the catalog and select the servers you want to add.
3. Select the **Add to** button and choose whether you want to add the servers
to an existing profile, or create a new profile.
> [!NOTE]
>
> The type of configuration required depends on the server you select. For the GitHub Official server, you must authenticate using OAuth.
If a server requires configuration, a **Configuration Required** badge appears
next to the server's name. You must complete the mandatory configuration before
you can use the server.
Your browser opens the GitHub authorization page. Follow the on-screen instructions to [authenticate via OAuth](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md#authenticate-via-oauth).
4. Return to Docker Desktop when the authentication process is complete.
5. Search for the **Playwright** server from the catalog and add it.
{{< /tab >}}
{{< tab name="CLI">}}
1. Add the GitHub Official MCP server. Run:
```console
$ docker mcp server enable github-official
```
2. Authenticate the server by running the following command:
```console
$ docker mcp oauth authorize github
```
> [!NOTE]
>
> The type of configuration required depends on the server you select. For the GitHub Official server, you must authenticate using OAuth.
Your browser opens the GitHub authorization page. Follow the on-screen instructions to [authenticate via OAuth](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md#authenticate-via-oauth).
3. Add the **Playwright** server. Run:
```console
$ docker mcp server enable playwright
```
{{< /tab >}}
{{< /tabs >}}
You’ve now successfully added an MCP server. Next, connect an MCP client to use
the MCP Toolkit in an AI application.
You've now successfully added MCP servers to your profile. Next, connect an MCP
client to use the servers in your profile.
## Connect clients
@@ -96,10 +89,10 @@ To connect a client to MCP Toolkit:
3. Select **Connect** to configure the client.
If your client isn't listed, you can connect the MCP Toolkit manually over
`stdio` by configuring your client to run the following command:
`stdio` by configuring your client to run the gateway with your profile:
```plaintext
docker mcp gateway run
docker mcp gateway run --profile my_profile
```
For example, if your client uses a JSON file to configure MCP servers, you may
@@ -110,7 +103,7 @@ add an entry like:
"servers": {
"MCP_DOCKER": {
"command": "docker",
"args": ["mcp", "gateway", "run"],
"args": ["mcp", "gateway", "run", "--profile", "my_profile"],
"type": "stdio"
}
}
@@ -132,7 +125,6 @@ is working:
- [Cursor](#cursor)
- [Gemini](#gemini)
- [Goose](#goose)
- [Gordon](#gordon)
- [LM Studio](#lm-studio)
- [OpenCode](#opencode)
- [Sema4.ai](#sema4)
@@ -296,21 +288,6 @@ MCP servers:
{{% param "test_prompt" %}}
```
### Gordon
Open the **Ask Gordon** view in Docker Desktop and select the toolbox icon in
the chat input area. The **MCP Toolkit** tab shows whether MCP Toolkit is
enabled and displays all the provided tools:
![MCP Toolkit in the Ask Gordon UI](images/ask-gordon.avif)
Test the connection by submitting a prompt that invokes one of your installed
MCP servers, either directly in Docker Desktop or using the CLI:
```console
$ docker ai "{{% param "test_prompt" %}}"
```
### LM Studio
Restart LM Studio and start a new chat. Open the integrations menu and look for
@@ -405,6 +382,7 @@ MCP servers:
## Further reading
- [MCP Profiles](/manuals/ai/mcp-catalog-and-toolkit/profiles.md)
- [MCP Toolkit](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md)
- [MCP Catalog](/manuals/ai/mcp-catalog-and-toolkit/catalog.md)
- [MCP Gateway](/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md)

156
content/manuals/ai/mcp-catalog-and-toolkit/images/mcp-overview.svg
View File

File diff suppressed because one or more lines are too long
Side by Side

Before

Width:  |  Height:  |  Size: 223 KiB

BIN
content/manuals/ai/mcp-catalog-and-toolkit/images/mcp_toolkit.avif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 57 KiB

49
content/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md
View File

@@ -1,6 +1,7 @@
---
title: MCP Gateway
description: "Docker's MCP Gateway provides secure, centralized, and scalable orchestration of AI tools through containerized MCP servers—empowering developers, operators, and security teams."
linkTitle: Gateway
description: "Docker's MCP Gateway provides secure, centralized, and scalable orchestration of AI tools through containerized MCP servers, empowering developers, operators, and security teams."
keywords: MCP Gateway
weight: 40
aliases:
@@ -14,7 +15,8 @@ and servers, managing configuration, credentials, and access control.
When using MCP servers without the MCP Gateway, you need to configure
applications individually for each AI application. With the MCP Gateway, you
configure applications to connect to the Gateway. The Gateway then handles
server lifecycle, routing, and authentication across all your servers.
server lifecycle, routing, and authentication across all servers in your
[profiles](/manuals/ai/mcp-catalog-and-toolkit/profiles.md).
> [!NOTE]
> If you use Docker Desktop with MCP Toolkit enabled, the Gateway runs
@@ -48,47 +50,16 @@ with installation, dependencies, updates, and security risks. By running them
as containers managed by the Gateway, you get isolation, consistent
environments, and centralized control.
The Gateway works with profiles to determine which servers are available. When
you run the Gateway, you specify which profile to use with the `--profile` flag
to determine which servers are made available to clients.
## Usage
To use the MCP Gateway, you'll need Docker Desktop with MCP Toolkit enabled.
Follow the [MCP Toolkit guide](toolkit.md) to enable and configure servers
through the graphical interface.
### Manage the MCP Gateway from the CLI
With MCP Toolkit enabled, you can also interact with the MCP Gateway using the
CLI. The `docker mcp` suite of commands lets you manage servers and tools
directly from your terminal. You can also manually run Gateways with custom
configurations, including security restrictions, server catalogs, and more.
To run an MCP Gateway manually, with customized parameters, use the `docker
mcp` suite of commands.
1. Browse the [MCP Catalog](https://hub.docker.com/mcp) for a server that you
want to use, and copy the install command from the **Manual installation**
section.
For example, run this command in your terminal to install the `duckduckgo`
MCP server:
```console
docker mcp server enable duckduckgo
```
2. Connect a client, like Claude Code:
```console
docker mcp client connect claude-code
```
3. Run the gateway:
```console
docker mcp gateway run
```
Now your MCP gateway is running and you can leverage all the servers set up
behind it from Claude Code.
through the Docker Desktop interface, or see
[Use MCP Toolkit from the CLI](cli.md) for terminal-based workflows.
### Install the MCP Gateway manually

267
content/manuals/ai/mcp-catalog-and-toolkit/profiles.md Normal file
View File

@@ -0,0 +1,267 @@
---
title: MCP Profiles
linkTitle: Profiles
description: Organize MCP servers into profiles for different projects and environments
keywords: Docker MCP, profiles, MCP servers, configuration, sharing
weight: 25
---
{{< summary-bar feature_name="Docker MCP Toolkit" >}}
> [!NOTE]
> This page describes the MCP Toolkit interface in Docker Desktop 4.62 and
> later. Earlier versions have a different UI. Upgrade to follow these
> instructions exactly.
Profiles organize your MCP servers into named collections. Without profiles,
you'd configure servers separately for every AI application you use. Each time
you want to change which servers are available, you'd update Claude Desktop, VS
Code, Cursor, and other tools individually. Profiles solve this by centralizing
your server configurations.
## What profiles do
A profile is a named collection of MCP servers with their configurations and
settings. You select servers from the [MCP
Catalog](/manuals/ai/mcp-catalog-and-toolkit/catalog.md) (the source of
available servers) and add them to your profiles (your configured server
collections for specific work). Think of the catalog as a library of tools, and
profiles as your toolboxes organized for different jobs.
Your "web-dev" profile might include GitHub, Playwright, and database servers.
Your "data-analysis" profile might include spreadsheet, API, and visualization
servers. Connect different AI clients to different profiles, or switch between
profiles as you change tasks.
When you run the MCP Gateway or connect a client without specifying a profile,
Docker MCP uses your default profile. If you're upgrading from a previous
version of MCP Toolkit, your existing server configurations are already in the
default profile.
## Profile capabilities
Each profile maintains its own isolated collection of servers and
configurations. Your "web-dev" profile might include GitHub, Playwright, and
database servers, while your "data-analysis" profile includes spreadsheet, API,
and visualization servers. Create as many profiles as you need, each containing
only the servers relevant to that context.
You can connect different AI applications to different profiles. When you
connect a client, you specify which profile it should use. This means Claude
Desktop and VS Code can have access to different server collections if needed.
Profiles can be shared with your team. Push a profile to your registry, and
team members can pull it to get the exact same server collection and
configuration you use.
## Creating and managing profiles
### Create a profile
1. In Docker Desktop, select **MCP Toolkit** and select the **Profiles** tab.
2. Select **Create profile**.
3. Enter a name for your profile (e.g., "web-dev").
4. Optionally, search and add servers to your profile now, or add them later.
5. Optionally, search and add clients to connect to your profile.
6. Select **Create**.
Your new profile appears in the profiles list.
### View profile details
Select a profile in the **Profiles** tab to view its details. The profile view
has two tabs:
- **Overview**: Shows the servers in your profile, secrets configuration, and
connected clients. Use the **+** buttons to add more servers or clients.
- **Tools**: Lists all available tools from your profile's servers. You can
enable or disable individual tools.
### Remove a profile
1. In the **Profiles** tab, find the profile you want to remove.
2. Select ⋮ next to the profile name, and then **Delete**.
3. Confirm the removal.
> [!CAUTION]
> Removing a profile deletes all its server configurations and settings, and
> updates the client configuration (removes MCP Toolkit). This action can't be
> undone.
### Default profile
When you run the MCP Gateway or use MCP Toolkit without specifying a profile,
Docker MCP uses a profile named `default`, or an empty configuration if a
`default` profile does not exist.
If you're upgrading from a previous version of MCP Toolkit, your existing
server configurations automatically migrate to the `default` profile. You don't
need to manually recreate your setup - everything continues to work as before.
You can always specify a different profile using the `--profile` flag with the
gateway command:
```console
$ docker mcp gateway run --profile web-dev
```
## Adding servers to profiles
Profiles contain the MCP servers you select from the catalog. Add servers to
organize your tools for specific workflows.
### Add a server
You can add servers to a profile in two ways.
From the Catalog tab:
1. Select the **Catalog** tab.
2. Select the checkbox next to servers you want to add to see which profile to
add them to.
3. Choose your profile from the drop-down.
From within a profile:
1. Select the **Profiles** tab and select your profile.
2. In the **Servers** section, select the **+** button.
3. Search for and select servers to add.
If a server requires OAuth authentication, you're prompted to authorize it. See
[OAuth authentication](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md#oauth-authentication)
for details.
### List servers in a profile
Select a profile in the **Profiles** tab to see all servers it contains.
### Remove a server
1. Select the **Profiles** tab and select your profile.
2. In the **Servers** section, find the server you want to remove.
3. Select the delete icon next to the server.
## Configuring profiles
### Server configuration
Some servers require configuration beyond authentication. Configure server
settings within your profile.
1. Select the **Profiles** tab and select your profile.
2. In the **Servers** section, select the configure icon next to the server.
3. Adjust the server's configuration settings as needed.
### OAuth credentials
OAuth credentials are shared across all profiles. When you authorize access to
a service like GitHub or Notion, that authorization is available to any server
in any profile that needs it.
This means all profiles use the same OAuth credentials for a given service. If
you need to use different accounts for different projects, you'll need to
revoke and re-authorize between switching profiles.
See [OAuth authentication](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md#oauth-authentication)
for details on authorizing servers.
### Configuration persistence
Profile configurations persist in your Docker installation. When you restart
Docker Desktop or your system, your profiles, servers, and configurations
remain intact.
## Sharing profiles
Profiles can be shared with your team by pushing them to OCI-compliant
registries as artifacts. This is useful for distributing standardized MCP
setups across your organization. Credentials are not included in shared
profiles for security reasons. Team members configure OAuth separately after
pulling.
### Push a profile
1. Select the profile you want to share in the **Profiles** tab.
2. Select **Push to Registry**.
3. Enter the registry destination (e.g., `registry.example.com/profiles/web-dev:v1`).
4. Complete authentication if required.
### Pull a profile
1. Select **Pull from Registry** in the **Profiles** tab.
2. Enter the registry reference (e.g., `registry.example.com/profiles/team-standard:latest`).
3. Complete authentication if required.
The profile is downloaded and added to your profiles list. Configure any
required OAuth credentials separately.
### Team collaboration workflow
A typical workflow for sharing profiles across a team:
1. Create and configure a profile with the servers your team needs.
2. Test the profile to ensure it works as expected.
3. Push the profile to your team's registry with a version tag (e.g.,
`registry.example.com/profiles/team-dev:v1`).
4. Share the registry reference with your team.
5. Team members pull the profile and configure any required OAuth credentials.
This ensures everyone uses the same server collection and configuration,
reducing setup time and inconsistencies.
## Using profiles with clients
When you connect an AI client to the MCP Gateway, you specify which profile's
servers the client can access.
### Run the gateway with a profile
Connect clients to your profile through the **Clients** section in the MCP
Toolkit. You can add clients when creating a profile or add them to existing
profiles later.
### Configure clients for specific profiles
When setting up a client manually, you can specify which profile the client
uses. This lets different clients connect to different profiles.
For example, your Claude Desktop configuration might use:
```json
{
"mcpServers": {
"MCP_DOCKER": {
"command": "docker",
"args": ["mcp", "gateway", "run", "--profile", "claude-work"]
}
}
}
```
While your VS Code configuration uses a different profile:
```json
{
"mcp": {
"servers": {
"MCP_DOCKER": {
"command": "docker",
"args": ["mcp", "gateway", "run", "--profile", "vscode-dev"],
"type": "stdio"
}
}
}
}
```
### Switching between profiles
To switch the profile your clients use, update the client configuration to
specify a different `--profile` value in the gateway command arguments.
## Further reading
- [Get started with MCP Toolkit](/manuals/ai/mcp-catalog-and-toolkit/get-started.md)
- [Use MCP Toolkit from the CLI](/manuals/ai/mcp-catalog-and-toolkit/cli.md)
- [MCP Catalog](/manuals/ai/mcp-catalog-and-toolkit/catalog.md)
- [MCP Toolkit](/manuals/ai/mcp-catalog-and-toolkit/toolkit.md)

114
content/manuals/ai/mcp-catalog-and-toolkit/toolkit.md
View File

@@ -1,6 +1,6 @@
---
title: Docker MCP Toolkit
linkTitle: MCP Toolkit
linkTitle: Toolkit UI
description: Use the MCP Toolkit to set up MCP servers and MCP clients.
keywords: Docker MCP Toolkit, MCP server, MCP client, AI agents
weight: 30
@@ -11,18 +11,24 @@ aliases:
{{< summary-bar feature_name="Docker MCP Toolkit" >}}
> [!NOTE]
> This page describes the MCP Toolkit interface in Docker Desktop 4.62 and
> later. Earlier versions have a different UI. Upgrade to follow these
> instructions exactly.
The Docker MCP Toolkit is a management interface integrated into Docker Desktop
that lets you set up, manage, and run containerized MCP servers and connect
them to AI agents. It removes friction from tool usage by offering secure
defaults, easy setup, and support for a growing ecosystem of LLM-based clients.
It is the fastest way from MCP tool discovery to local execution.
that lets you set up, manage, and run containerized MCP servers in profiles and
connect them to AI agents. It removes friction from tool usage by offering
secure defaults, easy setup, and support for a growing ecosystem of LLM-based
clients. It is the fastest way from MCP tool discovery to local execution.
## Key features
- Cross-LLM compatibility: Works with Claude, Cursor, and other MCP clients.
- Integrated tool discovery: Browse and launch MCP servers from the Docker MCP Catalog directly in Docker Desktop.
- Zero manual setup: No dependency management, runtime configuration, or setup required.
- Functions as both an MCP server aggregator and a gateway for clients to access installed MCP servers.
- Profile-based organization: Create separate server collections for different projects or environments.
- Organizes MCP servers into profiles, acting as a gateway for clients to access the servers in each profile.
> [!TIP]
> The MCP Toolkit includes [Dynamic MCP](/manuals/ai/mcp-catalog-and-toolkit/dynamic-mcp.md),
@@ -48,6 +54,11 @@ runtimes.
Depending on the MCP server, the tools it provides might run within the same
container as the server or in dedicated containers for better isolation.
The MCP Toolkit organizes servers into profiles: named collections of servers
with their configurations. This lets you maintain different server setups for
different projects or environments. When you connect a client, you specify
which profile it should use.
## Security
The Docker MCP Toolkit combines passive and active measures to reduce attack
@@ -90,9 +101,6 @@ configure authentication for each service.
#### Authorize a server with OAuth
{{< tabs >}}
{{< tab name="Docker Desktop">}}
1. In Docker Desktop, go to **MCP Toolkit** and select the **Catalog** tab.
2. Find and add an MCP server that requires OAuth.
3. In the server's **Configuration** tab, select the **OAuth** authentication
@@ -104,74 +112,16 @@ configure authentication for each service.
View all authorized services in the **OAuth** tab. To revoke access, select
**Revoke** next to the service you want to disconnect.
{{< /tab >}}
{{< tab name="CLI">}}
Enable an MCP server:
```console
$ docker mcp server enable github-official
```
If the server requires OAuth, authorize the connection:
```console
$ docker mcp oauth authorize github
```
Your browser opens the authorization page. Complete the authentication process,
then return to your terminal.
View authorized services:
```console
$ docker mcp oauth ls
```
Revoke access to a service:
```console
$ docker mcp oauth revoke github
```
{{< /tab >}}
{{< /tabs >}}
## Usage examples
### Example: Use the GitHub Official MCP server with Ask Gordon
To illustrate how the MCP Toolkit works, here's how to enable the GitHub
Official MCP server and use [Ask Gordon](/manuals/ai/gordon/_index.md) to
interact with your GitHub account:
1. From the **MCP Toolkit** menu in Docker Desktop, select the **Catalog** tab
and find the **GitHub Official** server and add it.
2. In the server's **Configuration** tab, authenticate via OAuth.
3. In the **Clients** tab, ensure Gordon is connected.
4. From the **Ask Gordon** menu, you can now send requests related to your
GitHub account, in accordance to the tools provided by the GitHub Official
server. To test it, ask Gordon:
```text
What's my GitHub handle?
```
Make sure to allow Gordon to interact with GitHub by selecting **Always
allow** in Gordon's answer.
> [!TIP]
> The Gordon client is enabled by default,
> which means Gordon can automatically interact with your MCP servers.
### Example: Use Claude Desktop as a client
Imagine you have Claude Desktop installed, and you want to use the GitHub MCP server,
and the Puppeteer MCP server, you do not have to install the servers in Claude Desktop.
You can simply install these 2 MCP servers in the MCP Toolkit,
and add Claude Desktop as a client:
Imagine you have Claude Desktop installed, and you want to use the GitHub MCP
server and the Puppeteer MCP server. You do not have to install the servers in
Claude Desktop. You can add these 2 MCP servers to your profile in the MCP
Toolkit and connect Claude Desktop as a client:
1. From the **MCP Toolkit** menu, select the **Catalog** tab and find the **Puppeteer** server and add it.
1. From the **MCP Toolkit** menu, select the **Catalog** tab and find the **Puppeteer** server and add it to your profile.
1. Repeat for the **GitHub Official** server.
1. From the **Clients** tab, select **Connect** next to **Claude Desktop**. Restart
Claude Desktop if it's running, and it can now access all the servers in the MCP Toolkit.
@@ -189,7 +139,6 @@ You can interact with all your installed MCP servers in Visual Studio Code:
{{< tabs group="" >}}
{{< tab name="Enable globally">}}
1. Insert the following in your Visual Studio Code's User `mcp.json`:
```json
@@ -200,7 +149,9 @@ You can interact with all your installed MCP servers in Visual Studio Code:
"args": [
"mcp",
"gateway",
"run"
"run",
"--profile",
"my_profile"
],
"type": "stdio"
}
@@ -210,25 +161,25 @@ You can interact with all your installed MCP servers in Visual Studio Code:
{{< /tab >}}
{{< tab name="Enable for a given project">}}
1. In your terminal, navigate to your project's folder.
1. Run:
```bash
docker mcp client connect vscode
docker mcp client connect vscode --profile my_profile
```
> [!NOTE]
> This command creates a `.vscode/mcp.json` file in the current
> directory. As this is a user-specific file, add it to your `.gitignore`
> file to prevent it from being committed to the repository.
> This command creates a `.vscode/mcp.json` file in the current directory
> that connects VSCode to your profile. As this is a user-specific file,
> add it to your `.gitignore` file to prevent it from being committed to
> the repository.
>
> ```console
> echo ".vscode/mcp.json" >> .gitignore
> ```
{{< /tab >}}
{{</tabs >}}
{{< /tab >}}
{{</tabs >}}
1. In Visual Studio Code, open a new Chat and select the **Agent** mode:
@@ -243,5 +194,6 @@ For more information about the Agent mode, see the
## Further reading
- [Use MCP Toolkit from the CLI](/manuals/ai/mcp-catalog-and-toolkit/cli.md)
- [MCP Catalog](/manuals/ai/mcp-catalog-and-toolkit/catalog.md)
- [MCP Gateway](/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md)