### Claude Desktop Configuration: NPX Setup

Source: https://github.com/docker/mcp-servers/blob/main/src/filesystem/README.md

Example JSON configuration for integrating the Filesystem MCP Server with Claude Desktop using NPX.

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/path/to/other/allowed/dir"
      ]
    }
  }
}
```

--------------------------------

### Claude Desktop Configuration: Docker Setup

Source: https://github.com/docker/mcp-servers/blob/main/src/filesystem/README.md

Example JSON configuration for integrating the Filesystem MCP Server with Claude Desktop using Docker.

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--mount", "type=bind,src=/Users/username/Desktop,dst=/projects/Desktop",
        "--mount", "type=bind,src=/path/to/other/allowed/dir,dst=/projects/other/allowed/dir,ro",
        "--mount", "type=bind,src=/path/to/file.txt,dst=/projects/path/to/file.txt",
        "mcp/filesystem",
        "/projects"
      ]
    }
  }
}
```

--------------------------------

### MCP Client Configuration - Multiple Servers

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Example JSON configurations for an MCP client connecting to Filesystem, Git, GitHub, and Postgres MCP servers, demonstrating various command, arguments, and environment variable setups.

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git", "--repository", "path/to/git/repo"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    }
  }
}
```

--------------------------------

### Install mcp-server-fetch using pip

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

Provides the command to install the mcp-server-fetch package using pip, a Python package installer.

```bash
pip install mcp-server-fetch
```

--------------------------------

### MCP Installer Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Installs other MCP servers.

```APIDOC
MCP Installer Server:
  Purpose: Install other MCP servers.
  Features: MCP server installation automation.
```

--------------------------------

### Run mcp-server-fetch using python module

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

Shows how to run the mcp-server-fetch as a script after installation using the python -m command.

```bash
python -m mcp_server_fetch
```

--------------------------------

### Install EverArt MCP Server

Source: https://github.com/docker/mcp-servers/blob/main/src/everart/README.md

Installs the EverArt MCP Server using npm and sets the EVERART_API_KEY environment variable.

```bash
npm install
export EVERART_API_KEY=your_key_here
```

--------------------------------

### Install MCP GitLab Server using NPX

Source: https://github.com/docker/mcp-servers/blob/main/src/gitlab/README.md

Installs the MCP GitLab server package using NPX. Requires a GitLab personal access token and optionally a custom API URL.

```json
{
  "mcpServers": {
    "gitlab": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-gitlab"
      ],
      "env": {
        "GITLAB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>",
        "GITLAB_API_URL": "https://gitlab.com/api/v4" // Optional, for self-hosted instances
      }
    }
  }
}
```

--------------------------------

### Claude Desktop Config: NPX Setup with Custom Settings

Source: https://github.com/docker/mcp-servers/blob/main/src/memory/README.md

Example of configuring the memory server via NPX with a custom memory file path using environment variables.

```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ],
      "env": {
        "MEMORY_FILE_PATH": "/path/to/custom/memory.json"
      }
    }
  }
}
```

--------------------------------

### NPX Setup for MCP GitHub Server

Source: https://github.com/docker/mcp-servers/blob/main/src/github/README.md

Configuration for running the MCP GitHub server using NPX. This specifies the command, arguments, and environment variables, including the necessary GITHUB_PERSONAL_ACCESS_TOKEN.

```json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}
```

--------------------------------

### Running Typescript MCP Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Starts the Memory MCP server using `npx`. This command downloads and runs the server without requiring a local installation.

```sh
npx -y @modelcontextprotocol/server-memory
```

--------------------------------

### MCP-Framework CLI for Project Creation

Source: https://github.com/docker/mcp-servers/blob/main/README.md

A TypeScript-based framework for building elegant and fast MCP servers. It includes a Command Line Interface (CLI) tool to scaffold new projects, enabling users to start their first server in under 5 minutes.

```bash
mcp create app
```

```APIDOC
MCP-Framework:
  description: Build MCP servers with elegance and speed.
  language: TypeScript
  features:
    - CLI for project creation (`mcp create app`)
    - Dual transport options
    - Extensible structure
  getting_started: Create your first server in under 5 minutes.
```

--------------------------------

### Docker Setup for MCP GitHub Server

Source: https://github.com/docker/mcp-servers/blob/main/src/github/README.md

Configuration for running the MCP GitHub server using Docker. This includes the command to execute, arguments, and environment variables, specifically highlighting the GITHUB_PERSONAL_ACCESS_TOKEN.

```json
{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "mcp/github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}
```

--------------------------------

### Puppeteer Server Configuration

Source: https://github.com/docker/mcp-servers/blob/main/src/puppeteer/README.md

Configuration examples for integrating the Puppeteer MCP server with Claude Desktop via Docker or NPX.

```json
{
  "mcpServers": {
    "puppeteer": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--init", "-e", "DOCKER_CONTAINER=true", "mcp/puppeteer"]
    }
  }
}
```

```json
{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}
```

--------------------------------

### Install mcp-server-time with pip

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

Installs the mcp-server-time package using pip, allowing it to be run as a script.

```bash
pip install mcp-server-time
```

--------------------------------

### GOAT MCP Examples

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Run more than +200 on-chain actions on any blockchain including Ethereum, Solana and Base using the GOAT SDK.

```TypeScript
import { GOAT } from '@goat-sdk/core';

async function runOnchainAction() {
  const goat = new GOAT();
  // Example: Get balance on Ethereum
  // const balance = await goat.ethereum.getBalance('0x...');
  // console.log(balance);
}
```

--------------------------------

### Run mcp-server-sentry

Source: https://github.com/docker/mcp-servers/blob/main/src/sentry/README.md

This snippet demonstrates how to run the mcp-server-sentry as a Python module after installation. This command initiates the server process.

```bash
python -m mcp_server_sentry
```

--------------------------------

### Claude Desktop Configuration - NPX

Source: https://github.com/docker/mcp-servers/blob/main/src/redis/README.md

Configuration example for integrating the MCP Redis server with Claude Desktop using NPX. It specifies the command and arguments to launch the Redis server via npm.

```json
{
  "mcpServers": {
    "redis": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-redis",
        "redis://localhost:6379"
      ]
    }
  }
}
```

--------------------------------

### Running Python MCP Server with pip

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Starts the Git MCP server using `pip`. This involves installing the package and then running it as a module.

```sh
pip install mcp-server-git
python -m mcp_server_git
```

--------------------------------

### Debug Fetch Server with uvx

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

Command to debug the fetch server when installed using uvx, utilizing the MCP inspector.

```bash
npx @modelcontextprotocol/inspector uvx mcp-server-fetch
```

--------------------------------

### Fetch Tool Arguments

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

Defines the arguments for the 'fetch' tool, used to retrieve and process web content. It specifies parameters for URL, content length, starting index, and raw content retrieval.

```APIDOC
fetch:
  description: Fetches a URL from the internet and extracts its contents as markdown.
  arguments:
    url (string, required): URL to fetch
    max_length (integer, optional): Maximum number of characters to return (default: 5000)
    start_index (integer, optional): Start content from this character index (default: 0)
    raw (boolean, optional): Get raw content without markdown conversion (default: false)
```

--------------------------------

### Install with PIP

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Installs the mcp-server-git package using pip. This command can be run directly after installation.

```bash
pip install mcp-server-git
```

```bash
python -m mcp_server_git
```

--------------------------------

### Claude Desktop Config: NPX Setup

Source: https://github.com/docker/mcp-servers/blob/main/src/memory/README.md

Configuration snippet for integrating the knowledge graph memory server using NPX within Claude Desktop.

```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

--------------------------------

### MCP Server Configuration (NPX)

Source: https://github.com/docker/mcp-servers/blob/main/src/gdrive/README.md

Configuration for integrating the Google Drive MCP server into a desktop application using NPX. This specifies the command to install and run the server package directly.

```json
{
  "mcpServers": {
    "gdrive": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-gdrive"
      ]
    }
  }
}
```

--------------------------------

### Observation Structure Example

Source: https://github.com/docker/mcp-servers/blob/main/src/memory/README.md

Shows the format for adding or managing observations associated with specific entities in the knowledge graph.

```json
{
  "entityName": "John_Smith",
  "observations": [
    "Speaks fluent Spanish",
    "Graduated in 2019",
    "Prefers morning meetings"
  ]
}
```

--------------------------------

### GitHub Search Query Syntax

Source: https://github.com/docker/mcp-servers/blob/main/src/github/README.md

Demonstrates the syntax for performing advanced searches on GitHub, covering code, issues, and user accounts. Examples include filtering by language, repository, path, issue state, labels, and user attributes like followers and location.

```APIDOC
Code Search:
  language:javascript: Search by programming language
  repo:owner/name: Search in specific repository
  path:app/src: Search in specific path
  extension:js: Search by file extension
  Example: q: "import express" language:typescript path:src/

Issues Search:
  is:issue or is:pr: Filter by type
  is:open or is:closed: Filter by state
  label:bug: Search by label
  author:username: Search by author
  Example: q: "memory leak" is:issue is:open label:bug

Users Search:
  type:user or type:org: Filter by account type
  followers:>1000: Filter by followers
  location:London: Search by location
  Example: q: "fullstack developer" location:London followers:>100

For detailed search syntax, see [GitHub's searching documentation](https://docs.github.com/en/search-github/searching-on-github).
```

--------------------------------

### Run mcp-server-time script

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

Executes the mcp-server-time server as a Python module after installation.

```bash
python -m mcp_server_time
```

--------------------------------

### Claude Desktop Configuration - Docker

Source: https://github.com/docker/mcp-servers/blob/main/src/redis/README.md

Configuration example for integrating the MCP Redis server with Claude Desktop when running Docker on macOS. It specifies the command and arguments to launch the Redis server.

```json
{
  "mcpServers": {
    "redis": {
      "command": "docker",
      "args": [
        "run", 
        "-i", 
        "--rm", 
        "mcp/redis", 
        "redis://host.docker.internal:6379"]
    }
  }
}
```

--------------------------------

### Claude Desktop Config: Docker Setup

Source: https://github.com/docker/mcp-servers/blob/main/src/memory/README.md

Configuration snippet for integrating the knowledge graph memory server using Docker within Claude Desktop.

```json
{
  "mcpServers": {
    "memory": {
      "command": "docker",
      "args": ["run", "-i", "-v", "claude-memory:/app/dist", "--rm", "mcp/memory"]
    }
  }
}
```

--------------------------------

### Configure Fetch Server with pip installation

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

JSON configuration snippet for setting up the fetch server to use a pip-installed package, specifying the python command and module.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "python",
      "args": ["-m", "mcp_server_fetch"]
    }
  }
}
```

--------------------------------

### Running Python MCP Server with uvx

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Starts the Git MCP server using `uvx`. `uvx` is a tool for managing Python environments and running packages, recommended for ease of use.

```sh
uvx mcp-server-git
```

--------------------------------

### MCP Client Configuration - Memory Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Example JSON configuration for an MCP client (Claude Desktop) to connect to the Memory MCP server.

```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}
```

--------------------------------

### Relation Structure Example

Source: https://github.com/docker/mcp-servers/blob/main/src/memory/README.md

Illustrates the structure for defining relations between entities in the knowledge graph, specifying source, target, and relation type.

```json
{
  "from": "John_Smith",
  "to": "Anthropic",
  "relationType": "works_at"
}
```

--------------------------------

### Debug MCP Time Server with Inspector

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

Commands to debug the mcp-server-time using the Model Context Protocol inspector, for both uvx and local development setups.

```bash
npx @modelcontextprotocol/inspector uvx mcp-server-time
```

```bash
cd path/to/servers/src/time
npx @modelcontextprotocol/inspector uv run mcp-server-time
```

--------------------------------

### AgentQL MCP Server Integration

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Integration to enable AI agents to get structured data from unstructured web content using AgentQL.

```github
https://github.com/tinyfish-io/agentql-mcp
```

--------------------------------

### Gmail Headless MCP Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Remote hostable MCP server that can get and send Gmail messages without local credential or file system setup.

```Python
from mcp import MCPClient

client = MCPClient()

# Example: Send an email
# response = client.call('gmail_headless', 'send_email', {
#     'to': 'recipient@example.com',
#     'subject': 'Test Email',
#     'body': 'This is a test email.'
# })
# print(response)
```

--------------------------------

### Install mcp-server-sentry with PIP

Source: https://github.com/docker/mcp-servers/blob/main/src/sentry/README.md

This snippet shows the command to install the mcp-server-sentry package using pip, the standard Python package installer. It's a straightforward installation process.

```bash
pip install mcp-server-sentry
```

--------------------------------

### Clone and Set Up Repository

Source: https://github.com/docker/mcp-servers/blob/main/CONTRIBUTING.md

Steps to clone the MCP Servers repository, add the upstream remote, and create a new branch for development.

```bash
git clone https://github.com/your-username/servers.git
git remote add upstream https://github.com/modelcontextprotocol/servers.git
git checkout -b my-feature
```

--------------------------------

### MCP Server Prompts API Documentation

Source: https://github.com/docker/mcp-servers/blob/main/src/everything/README.md

Describes the available prompts within the MCP Server Everything, including simple and complex prompt structures, argument handling, and expected return values.

```APIDOC
Prompt: simple_prompt
  Description: Basic prompt without arguments.
  Returns: Single message exchange

Prompt: complex_prompt
  Description: Advanced prompt demonstrating argument handling.
  Required Arguments:
    temperature (number): Temperature setting
  Optional Arguments:
    style (string): Output style preference
  Returns: Multi-turn conversation with images
```

--------------------------------

### Configure Fetch Server with uvx

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

JSON configuration snippet for setting up the fetch server to use 'uvx' as the command, typically for running mcp-server-fetch.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    }
  }
}
```

--------------------------------

### Everything Server (Python)

Source: https://github.com/docker/mcp-servers/blob/main/README.md

A reference and test server with prompts, resources, and tools for demonstrating MCP features. This Python version serves as a testing ground.

```python
from mcp_sdk import MCP

server = MCP.Server({
    # Server configuration
})

server.start()
```

--------------------------------

### Git Init Tool

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Initializes a new Git repository in the specified directory. Requires the path to the directory.

```APIDOC
git_init:
  description: Initializes a Git repository
  inputs:
    repo_path (string): Path to directory to initialize git repo
  returns: Confirmation of repository initialization
```

--------------------------------

### Configure mcp-server-time for Zed (pip)

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

Configuration snippet for Zed to use the mcp-server-time installed via pip.

```json
{
  "context_servers": {
    "mcp-server-time": {
      "command": "python",
      "args": ["-m", "mcp_server_time"]
    }
  }
}
```

--------------------------------

### Configure mcp-server-time for Claude.app (pip)

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

Configuration snippet for Claude.app to use the mcp-server-time installed via pip.

```json
{
  "mcpServers": {
    "time": {
      "command": "python",
      "args": ["-m", "mcp_server_time"]
    }
  }
}
```

--------------------------------

### Sample Usage for generate_image Tool

Source: https://github.com/docker/mcp-servers/blob/main/src/everart/README.md

Demonstrates how to use the 'generate_image' tool with specific arguments for prompt, model, and image count. The tool opens the generated image in the default browser and returns its URL.

```javascript
const result = await client.callTool({
  name: "generate_image",
  arguments: {
    prompt: "A cat sitting elegantly",
    model: "7000",
    image_count: 1
  }
});
```

--------------------------------

### VolcEngine TOS MCP Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

A sample MCP server for VolcEngine TOS that flexibly gets objects from TOS.

```Python
from sample_mcp_server_tos import VolcEngineTOSMCP

# Initialize the VolcEngine TOS MCP server
tos_server = VolcEngineTOSMCP()

# Example usage (assuming you have VolcEngine credentials configured)
# object_content = tos_server.get_object(bucket_name='my-bucket', object_key='my-file.txt')
# object_list = tos_server.list_objects(bucket_name='my-bucket')

```

--------------------------------

### Configure Fetch Server with Docker

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

JSON configuration snippet for setting up the fetch server to use Docker, specifying the image and arguments for running the container.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "mcp/fetch"]
    }
  }
}
```

--------------------------------

### Override System Timezone

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

Example configuration to override the default system timezone detection with a specific IANA timezone name.

```json
{
  "command": "python",
  "args": ["-m", "mcp_server_time", "--local-timezone=America/New_York"]
}
```

--------------------------------

### Everything Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

A reference and test server that includes prompts, resources, and tools for demonstrating MCP features. It serves as a versatile testing ground.

```typescript
import { MCP } from "@modelcontextprotocol/typescript-sdk";

const server = new MCP.Server({
  // Server configuration
});

server.start();
```

--------------------------------

### Entity Structure Example

Source: https://github.com/docker/mcp-servers/blob/main/src/memory/README.md

Defines the structure of an entity within the knowledge graph, including its unique name, type, and associated observations.

```json
{
  "name": "John_Smith",
  "entityType": "person",
  "observations": ["Speaks fluent Spanish"]
}
```

--------------------------------

### Zed Settings (uvx)

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Configuration for Zed editor to use mcp-server-git via uvx. Defines the command path and arguments for the context server.

```json
"context_servers": [
  "mcp-server-git": {
    "command": {
      "path": "uvx",
      "args": ["mcp-server-git"]
    }
  }
]
```

--------------------------------

### GitHub Repository Management API

Source: https://github.com/docker/mcp-servers/blob/main/src/github/README.md

Enables the creation, forking, and searching of GitHub repositories. Includes functionality to initialize repositories with a README file.

```APIDOC
search_repositories:
  description: Search for GitHub repositories
  inputs:
    query (string): Search query
    page (optional number): Page number for pagination
    perPage (optional number): Results per page (max 100)
  returns: Repository search results

create_repository:
  description: Create a new GitHub repository
  inputs:
    name (string): Repository name
    description (optional string): Repository description
    private (optional boolean): Whether repo should be private
    autoInit (optional boolean): Initialize with README
  returns: Created repository details

fork_repository:
  description: Fork a repository
  inputs:
    owner (string): Repository owner
    repo (string): Repository name
    organization (optional string): Organization to fork to
  returns: Forked repository details
```

--------------------------------

### Debug Fetch Server during development

Source: https://github.com/docker/mcp-servers/blob/main/src/fetch/README.md

Command to debug the fetch server when developing locally or if installed in a specific directory, using the MCP inspector.

```bash
cd path/to/servers/src/fetch
npx @modelcontextprotocol/inspector uv run mcp-server-fetch
```

--------------------------------

### Build MCP Time Server Docker Image

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

Builds the Docker image for the mcp-server-time project.

```bash
cd src/time
docker build -t mcp/time .

```

--------------------------------

### Claude Desktop Configuration (pip)

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Configuration for Claude Desktop to use mcp-server-git installed via pip. Specifies the Python command and module to run.

```json
"mcpServers": {
  "git": {
    "command": "python",
    "args": ["-m", "mcp_server_git", "--repository", "path/to/git/repo"]
  }
}
```

--------------------------------

### Claude Desktop Configuration for MCP Server

Source: https://github.com/docker/mcp-servers/blob/main/src/everything/README.md

Provides the JSON configuration snippet required to add the MCP Server Everything to Claude Desktop.

```json
{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-everything"
      ]
    }
  }
}
```

--------------------------------

### Claude Desktop Configuration (npx)

Source: https://github.com/docker/mcp-servers/blob/main/src/slack/README.md

Configuration for using the Slack MCP Server with Claude Desktop via npx. This includes the command to run, arguments, and environment variables for authentication.

```json
{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-slack"
      ],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-bot-token",
        "SLACK_TEAM_ID": "T01234567"
      }
    }
  }
}
```

--------------------------------

### MCP Server Resources API Documentation

Source: https://github.com/docker/mcp-servers/blob/main/src/everything/README.md

Details the structure and features of resources provided by the MCP Server Everything. It covers resource formats, URI patterns, pagination, subscriptions, and auto-updates.

```APIDOC
Resource Structure:
  - Even numbered resources: Plaintext format
    URI Pattern: test://static/resource/{even_number}
    Content: Simple text description
  - Odd numbered resources: Binary blob format
    URI Pattern: test://static/resource/{odd_number}
    Content: Base64 encoded binary data

Resource Features:
  - Pagination: Supports 10 items per page.
  - Subscriptions: Allows subscribing to resource updates.
  - Templates: Demonstrates resource templates.
  - Auto-updates: Subscribed resources update every 5 seconds.
```

--------------------------------

### Zed Settings (pip)

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Configuration for Zed editor to use mcp-server-git installed via pip. Defines the Python command path and module for the context server.

```json
"context_servers": {
  "mcp-server-git": {
    "command": {
      "path": "python",
      "args": ["-m", "mcp_server_git"]
    }
  }
}
```

--------------------------------

### Git Create Branch Tool

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Creates a new branch in the Git repository. Requires the repository path and the new branch name, with an optional starting point.

```APIDOC
git_create_branch:
  description: Creates a new branch
  inputs:
    repo_path (string): Path to Git repository
    branch_name (string): Name of the new branch
    start_point (string, optional): Starting point for the new branch
  returns: Confirmation of branch creation
```

--------------------------------

### Home Assistant MCP Server (voska)

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Docker-ready MCP server for Home Assistant with entity management, domain summaries, automation support, and guided conversations.

```Python
import hass_mcp

# Example usage:
# hass_server = hass_mcp.HassServer(host='localhost', token='YOUR_TOKEN')
# summary = hass_server.get_domain_summary('light')
# hass_server.trigger_automation('morning_routine')
```

--------------------------------

### Fingertip MCP Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

MCP server for Fingertip.com to search and create new sites.

```Python
from mcp import MCPClient

client = MCPClient()

# Example: Search for sites
# response = client.call('fingertip', 'search_sites', {'query': 'technology blogs'})
# print(response)
```

--------------------------------

### Redis Tools API Documentation

Source: https://github.com/docker/mcp-servers/blob/main/src/redis/README.md

Defines the API for interacting with Redis through the MCP server, including set, get, delete, and list operations with their respective inputs and optional parameters.

```APIDOC
Redis Tools:

set:
  description: Set a Redis key-value pair with optional expiration
  input:
    key (string): Redis key
    value (string): Value to store
    expireSeconds (number, optional): Expiration time in seconds

get:
  description: Get value by key from Redis
  input:
    key (string): Redis key to retrieve

delete:
  description: Delete one or more keys from Redis
  input:
    key (string | string[]): Key or array of keys to delete

list:
  description: List Redis keys matching a pattern
  input:
    pattern (string, optional): Pattern to match keys (default: *)

```

--------------------------------

### Claude Desktop Configuration (uvx)

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Configuration for Claude Desktop to use mcp-server-git via uvx. Specifies the command and arguments for running the server.

```json
"mcpServers": {
  "git": {
    "command": "uvx",
    "args": ["mcp-server-git", "--repository", "path/to/git/repo"]
  }
}
```

--------------------------------

### Claude Desktop Configuration for NPX

Source: https://github.com/docker/mcp-servers/blob/main/src/google-maps/README.md

Configuration for setting up the Google Maps MCP Server using NPX within Claude Desktop. This specifies the command to run the NPX package and environment variables.

```json
{
  "mcpServers": {
    "google-maps": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-google-maps"
      ],
      "env": {
        "GOOGLE_MAPS_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}
```

--------------------------------

### Debug MCP Server with Inspector (UVX)

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Command to debug an MCP server installation using the inspector tool in a UVX environment. This is useful for identifying and resolving issues during server operation.

```bash
npx @modelcontextprotocol/inspector uvx mcp-server-git
```

--------------------------------

### Claude Desktop Configuration (npx)

Source: https://github.com/docker/mcp-servers/blob/main/src/sequentialthinking/README.md

Configuration for the Sequential Thinking MCP Server using npx within Claude Desktop. This specifies the command and arguments to run the server.

```json
{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sequential-thinking"
      ]
    }
  }
}
```

--------------------------------

### Hologres MCP Server Integration

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Connect to a Hologres instance, get table metadata, query and analyze data. This integration allows AI agents to interact with Hologres for data analysis.

```Hologres
import 'package:hologres_mcp/hologres_mcp.dart';

// Example usage:
void main() async {
  var client = HologresMcpClient();
  // Query and analyze data in Hologres
  // ...
}
```

--------------------------------

### Notion API Integration (Suekou)

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Interact with the Notion API to manage pages, including searching, reading, updating, and creating content.

```Python
import mcp_notion_server

# Example usage:
# notion_client = mcp_notion_server.NotionClient(api_key='YOUR_NOTION_API_KEY')
# pages = notion_client.search_pages('Meeting Notes')
# print(pages)
```

--------------------------------

### Aiven MCP Server Integration

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Integration for navigating Aiven projects and interacting with PostgreSQL, Apache Kafka, ClickHouse, and OpenSearch services.

```github
https://github.com/Aiven-Open/mcp-aiven
```

--------------------------------

### llm-context.py MCP Tool

Source: https://github.com/docker/mcp-servers/blob/main/README.md

A repo-packing MCP tool with configurable profiles that specify file inclusion/exclusion patterns and optional prompts.

```APIDOC
llm-context.py MCP Tool:
  Purpose: Repo-packing MCP tool.
  Features:
    - Configurable profiles
    - File inclusion/exclusion patterns
    - Optional prompts
```

--------------------------------

### Debug mcp-server-sentry with MCP Inspector (uvx)

Source: https://github.com/docker/mcp-servers/blob/main/src/sentry/README.md

This command uses the MCP Inspector to debug the mcp-server-sentry when installed via uvx. It requires the Sentry authentication token for accessing Sentry data.

```bash
npx @modelcontextprotocol/inspector uvx mcp-server-sentry --auth-token YOUR_SENTRY_TOKEN
```

--------------------------------

### MCP Server Tools API Documentation

Source: https://github.com/docker/mcp-servers/blob/main/src/everything/README.md

Defines the API for various tools available in the MCP Server Everything. Each tool has specific inputs, outputs, and functionalities, including demonstrations of sampling, progress notifications, and message annotations.

```APIDOC
Tool: echo
  Description: Simple tool to echo back input messages.
  Input:
    message (string): Message to echo back
  Returns: Text content with echoed message

Tool: add
  Description: Adds two numbers together.
  Inputs:
    a (number): First number
    b (number): Second number
  Returns: Text result of the addition

Tool: longRunningOperation
  Description: Demonstrates progress notifications for long operations.
  Inputs:
    duration (number, default: 10): Duration in seconds
    steps (number, default: 5): Number of progress steps
  Returns: Completion message with duration and steps
  Notifications: Sends progress notifications during execution

Tool: sampleLLM
  Description: Demonstrates LLM sampling capability using MCP sampling feature.
  Inputs:
    prompt (string): The prompt to send to the LLM
    maxTokens (number, default: 100): Maximum tokens to generate
  Returns: Generated LLM response

Tool: getTinyImage
  Description: Returns a small test image.
  Inputs: None
  Returns: Base64 encoded PNG image data

Tool: printEnv
  Description: Prints all environment variables. Useful for debugging MCP server configuration.
  Inputs: None
  Returns: JSON string of all environment variables

Tool: annotatedMessage
  Description: Demonstrates how annotations can be used to provide metadata about content.
  Inputs:
    messageType (enum: "error" | "success" | "debug"): Type of message to demonstrate different annotation patterns
    includeImage (boolean, default: false): Whether to include an example image
  Returns: Content with varying annotations:
    - Error messages: High priority (1.0), visible to both user and assistant
    - Success messages: Medium priority (0.7), user-focused
    - Debug messages: Low priority (0.3), assistant-focused
    - Optional image: Medium priority (0.5), user-focused
  Example Annotations:
    {
      "priority": 1.0,
      "audience": ["user", "assistant"]
    }
```

--------------------------------

### UnifAI Network MCP Server

Source: https://github.com/docker/mcp-servers/blob/main/README.md

Dynamically search and call tools using the UnifAI Network.

```Python
from unifai_mcp import UnifAIClient

client = UnifAIClient(api_key='YOUR_UNIF_AI_API_KEY')
result = client.search_and_call(query='find the weather in London', tool_name='weather_tool')
print(result)
```

--------------------------------

### MCP Time Server API - Get Current Time

Source: https://github.com/docker/mcp-servers/blob/main/src/time/README.md

API call to retrieve the current time in a specified IANA timezone. If no timezone is provided, the system's default timezone is used.

```APIDOC
APIDOC:
  Method: get_current_time
  Description: Get current time in a specific timezone or system timezone.
  Arguments:
    timezone (string): IANA timezone name (e.g., 'America/New_York', 'Europe/London')
  Example Request:
    {
      "name": "get_current_time",
      "arguments": {
        "timezone": "Europe/Warsaw"
      }
    }
  Example Response:
    {
      "timezone": "Europe/Warsaw",
      "datetime": "2024-01-01T13:00:00+01:00",
      "is_dst": false
    }
```

--------------------------------

### Configure MCP Server for UVX Development

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

JSON configuration snippet for the Claude desktop app to enable local development of MCP servers within a UVX environment. It defines the command and arguments to run the server, specifying the source directory for the project.

```json
{
"mcpServers": {
  "git": {
    "command": "uv",
    "args": [
      "--directory",
      "/<path to mcp-servers>/mcp-servers/src/git",
      "run",
      "mcp-server-git"
    ]
  }
}
}
```

--------------------------------

### Configure mcp-server-sentry with Claude Desktop (pip)

Source: https://github.com/docker/mcp-servers/blob/main/src/sentry/README.md

This JSON configuration is for integrating mcp-server-sentry with Claude Desktop when installed via pip. It specifies running the server as a Python module with the necessary authentication token.

```json
"mcpServers": {
  "sentry": {
    "command": "python",
    "args": ["-m", "mcp_server_sentry", "--auth-token", "YOUR_SENTRY_TOKEN"]
  }
}
```

--------------------------------

### Claude Desktop Configuration for Docker

Source: https://github.com/docker/mcp-servers/blob/main/src/google-maps/README.md

Configuration for setting up the Google Maps MCP Server using Docker within Claude Desktop. This includes the command to run the Docker container and environment variables.

```json
{
  "mcpServers": {
    "google-maps": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GOOGLE_MAPS_API_KEY",
        "mcp/google-maps"
      ],
      "env": {
        "GOOGLE_MAPS_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}
```

--------------------------------

### Configure mcp-server-sentry with Zed (pip)

Source: https://github.com/docker/mcp-servers/blob/main/src/sentry/README.md

This JSON configuration is for integrating mcp-server-sentry with Zed editor when installed via pip. It specifies the command to run the server as a Python module, including the Sentry authentication token.

```json
"context_servers": {
  "mcp-server-sentry": {
    "command": "python",
    "args": ["-m", "mcp_server_sentry", "--auth-token", "YOUR_SENTRY_TOKEN"]
  }
}
```

--------------------------------

### Debug MCP Server with Inspector (Local Development)

Source: https://github.com/docker/mcp-servers/blob/main/src/git/README.md

Command to debug an MCP server when working on local installations or developing directly from a specific directory. It allows direct interaction with the server's source code.

```bash
cd path/to/servers/src/git
npx @modelcontextprotocol/inspector uv run mcp-server-git
```

--------------------------------

### Foxy Contexts for Golang MCP Servers

Source: https://github.com/docker/mcp-servers/blob/main/README.md

A library for building MCP servers in Golang. It provides the necessary tools and abstractions to efficiently develop and deploy MCP-compliant servers using the Go programming language.

```APIDOC
Foxy Contexts:
  description: Library to build MCP servers.
  language: Golang
  features:
    - Efficient development of MCP servers.
    - Built for the Golang ecosystem.
```

--------------------------------

### Get Pull Request Reviews

Source: https://github.com/docker/mcp-servers/blob/main/src/github/README.md

Retrieves all reviews for a given pull request, including the reviewer and the review's state (e.g., APPROVED, CHANGES_REQUESTED). Requires repository owner, name, and pull request number.

```APIDOC
get_pull_request_reviews:
  description: Get the reviews on a pull request
  inputs:
    owner (string): Repository owner
    repo (string): Repository name
    pull_number (number): Pull request number
  returns: Array of pull request reviews with details like the review state (APPROVED, CHANGES_REQUESTED, etc.), reviewer, and review body
```

--------------------------------

### MCP Server Configuration for Claude Desktop (uv)

Source: https://github.com/docker/mcp-servers/blob/main/src/sqlite/README.md

Configuration snippet for adding the SQLite MCP server to Claude Desktop using the 'uv' command. This allows direct execution of the server within a specified directory.

```json
{
  "mcpServers": {
    "sqlite": {
      "command": "uv",
      "args": [
        "--directory",
        "parent_of_servers_repo/servers/src/sqlite",
        "run",
        "mcp-server-sqlite",
        "--db-path",
        "~/test.db"
      ]
    }
  }
}
```

--------------------------------

### Docker Build Command

Source: https://github.com/docker/mcp-servers/blob/main/src/filesystem/README.md

Command to build the Docker image for the Filesystem MCP Server.

```bash
docker build -t mcp/filesystem -f src/filesystem/Dockerfile .
```

--------------------------------

### System Prompt for Chat Personalization

Source: https://github.com/docker/mcp-servers/blob/main/src/memory/README.md

This prompt guides the AI in managing user memory for chat personalization. It details steps for user identification, memory retrieval, categories of information to remember, and memory update procedures.

```text
Follow these steps for each interaction:

1. User Identification:
   - You should assume that you are interacting with default_user
   - If you have not identified default_user, proactively try to do so.

2. Memory Retrieval:
   - Always begin your chat by saying only "Remembering..." and retrieve all relevant information from your knowledge graph
   - Always refer to your knowledge graph as your "memory"

3. Memory
   - While conversing with the user, be attentive to any new information that falls into these categories:
     a) Basic Identity (age, gender, location, job title, education level, etc.)
     b) Behaviors (interests, habits, etc.)
     c) Preferences (communication style, preferred language, etc.)
     d) Goals (goals, targets, aspirations, etc.)
     e) Relationships (personal and professional relationships up to 3 degrees of separation)

4. Memory Update:
   - If any new information was gathered during the interaction, update your memory as follows:
     a) Create entities for recurring organizations, people, and significant events
     b) Connect them to the current entities using relations
     b) Store facts about them as observations
```

--------------------------------

### Filesystem MCP Server API Documentation

Source: https://github.com/docker/mcp-servers/blob/main/src/filesystem/README.md

Defines the API for interacting with the Filesystem MCP Server, covering file and directory operations.

```APIDOC
Resources:
  file://system: File system operations interface

Tools:
read_file:
  Description: Read complete contents of a file
  Input: path (string)
  Details: Reads complete file contents with UTF-8 encoding

read_multiple_files:
  Description: Read multiple files simultaneously
  Input: paths (string[])
  Details: Failed reads won't stop the entire operation

write_file:
  Description: Create new file or overwrite existing (exercise caution with this)
  Inputs:
    path (string): File location
    content (string): File content

edit_file:
  Description: Make selective edits using advanced pattern matching and formatting
  Features:
    - Line-based and multi-line content matching
    - Whitespace normalization with indentation preservation
    - Fuzzy matching with confidence scoring
    - Multiple simultaneous edits with correct positioning
    - Indentation style detection and preservation
    - Git-style diff output with context
    - Preview changes with dry run mode
    - Failed match debugging with confidence scores
  Inputs:
    path (string): File to edit
    edits (array): List of edit operations
      - oldText (string): Text to search for (can be substring)
      - newText (string): Text to replace with
    dryRun (boolean): Preview changes without applying (default: false)
    options (object): Optional formatting settings
      - preserveIndentation (boolean): Keep existing indentation (default: true)
      - normalizeWhitespace (boolean): Normalize spaces while preserving structure (default: true)
      - partialMatch (boolean): Enable fuzzy matching (default: true)
  Returns: Detailed diff and match information for dry runs, otherwise applies changes
  Best Practice: Always use dryRun first to preview changes before applying them

create_directory:
  Description: Create new directory or ensure it exists
  Input: path (string)
  Details: Creates parent directories if needed. Succeeds silently if directory exists.

list_directory:
  Description: List directory contents with [FILE] or [DIR] prefixes
  Input: path (string)

move_file:
  Description: Move or rename files and directories
  Inputs:
    source (string)
    destination (string)
  Details: Fails if destination exists

search_files:
  Description: Recursively search for files/directories
  Inputs:
    path (string): Starting directory
    pattern (string): Search pattern
    excludePatterns (string[]): Exclude any patterns. Glob formats are supported.
  Details: Case-insensitive matching. Returns full paths to matches.

get_file_info:
  Description: Get detailed file/directory metadata
  Input: path (string)
  Returns:
    - Size
    - Creation time
    - Modified time
    - Access time
    - Type (file/directory)
    - Permissions

list_allowed_directories:
  Description: List all directories the server is allowed to access
  No input required
  Returns:
    - Directories that this server can read/write from
```

--------------------------------

### Get Pull Request Review Comments

Source: https://github.com/docker/mcp-servers/blob/main/src/github/README.md

Fetches all review comments associated with a pull request. This includes the comment text, author, and its specific location within the code diff. Requires repository owner, name, and pull request number.

```APIDOC
get_pull_request_review_comments:
  description: Get the review comments on a pull request
  inputs:
    owner (string): Repository owner
    repo (string): Repository name
    pull_number (number): Pull request number
  returns: Array of pull request review comments with details like the comment text, author, and location in the diff
```