diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/_index.md b/content/manuals/ai/mcp-catalog-and-toolkit/_index.md index 51e69902a0..02b2940e64 100644 --- a/content/manuals/ai/mcp-catalog-and-toolkit/_index.md +++ b/content/manuals/ai/mcp-catalog-and-toolkit/_index.md @@ -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 diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/catalog.md b/content/manuals/ai/mcp-catalog-and-toolkit/catalog.md index 95e37335ab..284d4198b3 100644 --- a/content/manuals/ai/mcp-catalog-and-toolkit/catalog.md +++ b/content/manuals/ai/mcp-catalog-and-toolkit/catalog.md @@ -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 +``` + +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 -``` diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/cli.md b/content/manuals/ai/mcp-catalog-and-toolkit/cli.md new file mode 100644 index 0000000000..d4bbcb6871 --- /dev/null +++ b/content/manuals/ai/mcp-catalog-and-toolkit/cli.md @@ -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 +``` + +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 +``` + +### Remove a profile + +```console +$ docker mcp profile remove +``` + +> [!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:///` | An OCI catalog | +| `docker://:` | A Docker image | +| `https:///v0/servers/` | The MCP community registry | +| `file://` | A local YAML or JSON file | + +The most common format is `catalog://`, where `` matches the +**Catalog** field and `` matches the **Server ID** field shown in +Docker Desktop or in the `catalog server ls` output: + +```console +$ docker mcp profile server add \ + --server catalog:/// +``` + +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 --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 --set .= +$ docker mcp profile config --get-all +$ docker mcp profile config --del . +``` + +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 +``` + +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 --profile +``` + +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 +``` + +For example: + +```console +$ docker mcp profile push web-dev registry.example.com/profiles/web-dev:v1 +``` + +### Pull a profile + +```console +$ docker mcp profile pull +``` + +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 +``` + +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 +``` + +Team members can pull it using the CLI: + +```console +$ docker mcp catalog pull +``` + +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 +``` + +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 --servers --servers +``` + +## 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) diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/dynamic-mcp.md b/content/manuals/ai/mcp-catalog-and-toolkit/dynamic-mcp.md index ce9f000213..9e28e61af1 100644 --- a/content/manuals/ai/mcp-catalog-and-toolkit/dynamic-mcp.md +++ b/content/manuals/ai/mcp-catalog-and-toolkit/dynamic-mcp.md @@ -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 diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/faqs.md b/content/manuals/ai/mcp-catalog-and-toolkit/faqs.md index 3debffe054..6d803b1c97 100644 --- a/content/manuals/ai/mcp-catalog-and-toolkit/faqs.md +++ b/content/manuals/ai/mcp-catalog-and-toolkit/faqs.md @@ -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) diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/get-started.md b/content/manuals/ai/mcp-catalog-and-toolkit/get-started.md index 7746bdcbe5..4c2f8e8e69 100644 --- a/content/manuals/ai/mcp-catalog-and-toolkit/get-started.md +++ b/content/manuals/ai/mcp-catalog-and-toolkit/get-started.md @@ -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) diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/images/mcp-overview.svg b/content/manuals/ai/mcp-catalog-and-toolkit/images/mcp-overview.svg deleted file mode 100644 index f35a1b9156..0000000000 --- a/content/manuals/ai/mcp-catalog-and-toolkit/images/mcp-overview.svg +++ /dev/null @@ -1,156 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/images/mcp_toolkit.avif b/content/manuals/ai/mcp-catalog-and-toolkit/images/mcp_toolkit.avif new file mode 100644 index 0000000000..2b33fe6731 Binary files /dev/null and b/content/manuals/ai/mcp-catalog-and-toolkit/images/mcp_toolkit.avif differ diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md b/content/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md index 3042dbe3a8..f88d16e2b7 100644 --- a/content/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md +++ b/content/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md @@ -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 diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/profiles.md b/content/manuals/ai/mcp-catalog-and-toolkit/profiles.md new file mode 100644 index 0000000000..9231489d9b --- /dev/null +++ b/content/manuals/ai/mcp-catalog-and-toolkit/profiles.md @@ -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) diff --git a/content/manuals/ai/mcp-catalog-and-toolkit/toolkit.md b/content/manuals/ai/mcp-catalog-and-toolkit/toolkit.md index 06b3a8f7db..7a851c17ef 100644 --- a/content/manuals/ai/mcp-catalog-and-toolkit/toolkit.md +++ b/content/manuals/ai/mcp-catalog-and-toolkit/toolkit.md @@ -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 >}} - {{}} +{{< /tab >}} +{{}} 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)