### Install EverArt MCP Server

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/everart/README.md

Installs the EverArt MCP Server using npm and sets the EVERART_API_KEY environment variable. This is the initial setup step before configuring the server.

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

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

### Install GitLab Server with NPX

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/gitlab/README.md

Installs the GitLab server component of the Model Context Protocol using NPX. Requires a GitLab personal access token and optionally a GitLab API URL. This command ensures the latest version is installed.

```bash
npx -y @modelcontextprotocol/server-gitlab --env GITLAB_PERSONAL_ACCESS_TOKEN=<YOUR_TOKEN> --env GITLAB_API_URL=https://gitlab.com/api/v4
```

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

### Install mcp-server-git with Pip

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Installs the mcp-server-git package using pip. This is an alternative installation method if uv is not used.

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

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

### Install Slack Server with NPX in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/slack/README.md

This snippet shows how to install the Slack server using NPX directly within VS Code. It requires a Slack bot token and team ID, which are provided as inputs during the installation process. The configuration specifies the command to run and environment variables to set.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "slack_bot_token",
        "description": "Slack Bot Token (starts with xoxb-)",
        "password": true
      },
      {
        "type": "promptString",
        "id": "slack_team_id",
        "description": "Slack Team ID (starts with T)"
      }
    ],
    "servers": {
      "slack": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-slack"],
        "env": {
          "SLACK_BOT_TOKEN": "${input:slack_bot_token}",
          "SLACK_TEAM_ID": "${input:slack_team_id}"
        }
      }
    }
  }
}
```

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

### Install Sentry MCP Server with UV in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sentry/README.md

Provides a one-click installation link for the Sentry MCP server using UV in VS Code. Requires a Sentry Auth Token.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "auth_token",
        "description": "Sentry Auth Token",
        "password": true
      }
    ],
    "servers": {
      "sentry": {
        "command": "uvx",
        "args": ["mcp-server-sentry"],
        "env": {
          "SENTRY_AUTH_TOKEN": "${input:auth_token}"
        }
      }
    }
  }
}
```

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

### Install gdrive server with NPX in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/gdrive/README.md

This snippet shows the JSON configuration for installing the gdrive server using NPX within VS Code. It specifies the command, arguments, and environment variables required for the installation.

```json
{
  "mcp": {
    "servers": {
      "gdrive": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-gdrive"
        ],
        "env": {
          "GDRIVE_CREDENTIALS_PATH": "/path/to/.gdrive-server-credentials.json"
        }
      }
    }
  }
}
```

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

### Configure GitHub Server with NPX

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

This configuration snippet demonstrates how to set up the ModelContextProtocol GitHub server using NPX. It includes the command to execute, arguments for installing and running the package, and the environment variable for the GitHub Personal Access Token.

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

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

### Install Puppeteer Server via NPX in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/puppeteer/README.md

Provides the JSON configuration for installing the Puppeteer server using NPX within VS Code. This method is suitable for quick setup and utilizes the command line interface.

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

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

### Install Slack Server with Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/slack/README.md

This snippet demonstrates how to install the Slack server using Docker within VS Code. Similar to the NPX method, it requires a Slack bot token and team ID. The configuration specifies the Docker command to run the Slack server image and sets the necessary environment variables.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "slack_bot_token",
        "description": "Slack Bot Token (starts with xoxb-)",
        "password": true
      },
      {
        "type": "promptString",
        "id": "slack_team_id",
        "description": "Slack Team ID (starts with T)"
      }
    ],
    "servers": {
      "slack": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "mcp/slack"],
        "env": {
          "SLACK_BOT_TOKEN": "${input:slack_bot_token}",
          "SLACK_TEAM_ID": "${input:slack_team_id}"
        }
      }
    }
  }
}
```

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

### Configure Claude Desktop with Pip Installation

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Configuration for Claude Desktop to use mcp-server-git when installed via pip. This specifies the command to run the Python module and the repository path argument.

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

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

### Install Sentry MCP Server with Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sentry/README.md

Provides a one-click installation link for the Sentry MCP server using Docker in VS Code. Requires a Sentry Auth Token.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "auth_token",
        "description": "Sentry Auth Token",
        "password": true
      }
    ],
    "servers": {
      "sentry": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "mcp/sentry"],
        "env": {
          "SENTRY_AUTH_TOKEN": "${input:auth_token}"
        }
      }
    }
  }
}
```

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

### Install MCP Server via VS Code Settings (JSON)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/aws-kb-retrieval-server/README.md

This JSON configuration block is added to the VS Code User Settings (JSON) file to manually install and configure an MCP server, specifically the AWS KB retrieval server. It defines inputs for AWS credentials and region, and specifies the command to run the server.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "aws_access_key",
        "description": "AWS Access Key ID",
        "password": true
      },
      {
        "type": "promptString",
        "id": "aws_secret_key",
        "description": "AWS Secret Access Key",
        "password": true
      },
      {
        "type": "promptString",
        "id": "aws_region",
        "description": "AWS Region"
      }
    ],
    "servers": {
      "aws-kb-retrieval": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-aws-kb-retrieval"],
        "env": {
          "AWS_ACCESS_KEY_ID": "${input:aws_access_key}",
          "AWS_SECRET_ACCESS_KEY": "${input:aws_secret_key}",
          "AWS_REGION": "${input:aws_region}"
        }
      }
    }
  }
}
```

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

### Sample Image Generation Call

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/everart/README.md

Demonstrates how to call the 'generate_image' tool with specific arguments, including the image prompt, desired model ID, and the number of images to generate. This example uses a JavaScript client to interact with the tool.

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

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

### NPX Configuration for GitLab Server

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/gitlab/README.md

JSON configuration for installing the GitLab server component using NPX. Specifies the command, arguments, and environment variables including the GitLab personal access token and 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
      }
    }
  }
}
```

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

### Install MCP Redis Server via NPX in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/redis/README.md

This snippet shows how to configure VS Code to install the MCP Redis server using NPX. It requires a Redis URL as input and specifies the command and arguments for installation.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "redis_url",
        "description": "Redis URL (e.g. redis://localhost:6379)"
      }
    ],
    "servers": {
      "redis": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-redis"],
        "env": {
          "REDIS_URL": "${input:redis_url}"
        }
      }
    }
  }
}
```

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

### Install AWS KB Retrieval Server with NPX in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/aws-kb-retrieval-server/README.md

Installs the AWS KB Retrieval server using NPX within VS Code. Requires AWS Access Key ID, Secret Access Key, and Region as inputs, which are configured as environment variables.

```bash
npx -y @modelcontextprotocol/server-aws-kb-retrieval --aws_access_key "$AWS_ACCESS_KEY_ID" --aws_secret_key "$AWS_SECRET_ACCESS_KEY" --aws_region "$AWS_REGION"
```

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

### Setup Google Maps MCP Server with NPX

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

Configuration for running the Google Maps MCP Server using NPX. This method involves specifying the command to execute the NPX package and setting environment variables, including the Google Maps API key.

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

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

### Configure Brave Search Server with NPX

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/brave-search/README.md

This JSON configuration sets up the Brave Search MCP Server using NPX. It specifies the command to install and run the server package and environment variables, including the Brave API key.

```json
{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}
```

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

### Install MCP Redis Server via Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/redis/README.md

This snippet demonstrates the VS Code configuration for installing the MCP Redis server using Docker. It prompts for a Redis URL and defines the Docker command and arguments for running the Redis server.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "redis_url",
        "description": "Redis URL (e.g. redis://host.docker.internal:6379)"
      }
    ],
    "servers": {
      "redis": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "mcp/redis"],
        "env": {
          "REDIS_URL": "${input:redis_url}"
        }
      }
    }
  }
}
```

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

### Run GitLab Server with NPX

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/gitlab/README.md

This snippet demonstrates how to run the MCP GitLab server using NPX. It also requires a GitLab Personal Access Token and an optional GitLab API URL. The server is installed via the '@modelcontextprotocol/server-gitlab' package.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "gitlab_token",
        "description": "GitLab Personal Access Token",
        "password": true
      },
      {
        "type": "promptString",
        "id": "gitlab_url",
        "description": "GitLab API URL (optional)",
        "default": "https://gitlab.com/api/v4"
      }
    ],
    "servers": {
      "gitlab": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-gitlab"
        ],
        "env": {
          "GITLAB_PERSONAL_ACCESS_TOKEN": "${input:gitlab_token}",
          "GITLAB_API_URL": "${input:gitlab_url}"
        }
      }
    }
  }
}
```

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

### Setup Google Maps MCP Server with Docker

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

Configuration for running the Google Maps MCP Server using Docker. This involves specifying the command to run the Docker container and setting environment variables, including the Google Maps API key.

```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>"
      }
    }
  }
}
```

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

### Install gdrive server with Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/gdrive/README.md

This snippet details the JSON configuration for installing the gdrive server using Docker within VS Code. It includes the Docker command, arguments for running the container, volume mounts, and environment variables.

```json
{
  "mcp": {
    "servers": {
      "gdrive": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "-v",
          "mcp-gdrive:/gdrive-server",
          "-e",
          "GDRIVE_CREDENTIALS_PATH=/gdrive-server/credentials.json",
          "mcp/gdrive"
        ]
      }
    }
  }
}
```

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

### Install AWS KB Retrieval Server with Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/aws-kb-retrieval-server/README.md

Installs the AWS KB Retrieval server using Docker within VS Code. Requires AWS Access Key ID, Secret Access Key, and Region as inputs, which are configured as environment variables.

```bash
docker run -i --rm mcp/aws-kb-retrieval-server -e AWS_ACCESS_KEY_ID="$AWS_ACCESS_KEY_ID" -e AWS_SECRET_ACCESS_KEY="$AWS_SECRET_ACCESS_KEY" -e AWS_REGION="$AWS_REGION"
```

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

### Install AWS KB Retrieval Server with NPX in VS Code Insiders

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/aws-kb-retrieval-server/README.md

Installs the AWS KB Retrieval server using NPX within VS Code Insiders. Requires AWS Access Key ID, Secret Access Key, and Region as inputs, which are configured as environment variables.

```bash
npx -y @modelcontextprotocol/server-aws-kb-retrieval --aws_access_key "$AWS_ACCESS_KEY_ID" --aws_secret_key "$AWS_SECRET_ACCESS_KEY" --aws_region "$AWS_REGION"
```

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

### Run mcp-server-git as a Script

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Executes the mcp-server-git server as a Python module after installation via pip.

```bash
python -m mcp_server_git
```

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

### Configure MCP SQLite Server with Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sqlite/README.md

This JSON configuration enables the setup of the MCP SQLite server using Docker within VS Code. It includes a prompt for the database path within the container and specifies the Docker command and arguments for running the server.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "db_path",
        "description": "SQLite Database Path (within container)",
        "default": "/mcp/db.sqlite"
      }
    ],
    "servers": {
      "sqlite": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "-v",
          "mcp-sqlite:/mcp",
          "mcp/sqlite",
          "--db-path",
          "${input:db_path}"
        ]
      }
    }
  }
}
```

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

### MCP Inspector Debugging (UV)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Command to use the MCP inspector for debugging a UV installation of the mcp-server-git.

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

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

### Configure AWS KB Retrieval Server with npx

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/aws-kb-retrieval-server/README.md

Configuration for running the AWS Knowledge Base Retrieval MCP Server using npx. It specifies the command to install and run the server package and sets environment variables for AWS credentials.

```json
{
  "mcpServers": {
    "aws-kb-retrieval": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-aws-kb-retrieval"],
      "env": {
        "AWS_ACCESS_KEY_ID": "YOUR_ACCESS_KEY_HERE",
        "AWS_SECRET_ACCESS_KEY": "YOUR_SECRET_ACCESS_KEY_HERE",
        "AWS_REGION": "YOUR_AWS_REGION_HERE"
      }
    }
  }
}
```

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

### Configure MCP Slack Server with Docker

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/slack/README.md

This JSON configuration defines the inputs and server setup for the MCP Slack server. It specifies required inputs like the Slack Bot Token and Team ID, and configures the Docker run command with environment variables mapped from these inputs.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "slack_bot_token",
        "description": "Slack Bot Token (starts with xoxb-)",
        "password": true
      },
      {
        "type": "promptString",
        "id": "slack_team_id",
        "description": "Slack Team ID (starts with T)"
      }
    ],
    "servers": {
      "slack": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "mcp/slack"],
        "env": {
          "SLACK_BOT_TOKEN": "${input:slack_bot_token}",
          "SLACK_TEAM_ID": "${input:slack_team_id}"
        }
      }
    }
  }
}
```

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

### Create New GitHub Repository

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

Allows for the creation of a new GitHub repository. Key parameters include the repository name, an optional description, and flags for privacy and auto-initialization with a README file.

```shell
create_repository(name: str, description: Optional[str] = None, private: Optional[bool] = None, autoInit: Optional[bool] = None)
```

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

### Install mcp-server-sentry using pip

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sentry/README.md

Installs the mcp-server-sentry package using pip. After installation, it can be run as a script.

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

```bash
python -m mcp_server_sentry
```

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

### Configure Claude Desktop with uvx

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Configuration for Claude Desktop to use mcp-server-git via uvx. This specifies the command and arguments for running the server, including the path to the Git repository.

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

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

### Configure GitHub Server with Docker

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

This configuration snippet shows how to set up the ModelContextProtocol GitHub server using Docker. It specifies the command to run, arguments including environment variables, and the necessary 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>"
      }
    }
  }
}
```

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

### Install MCP Server via Docker (JSON)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/aws-kb-retrieval-server/README.md

This JSON configuration is used for installing an MCP server via Docker. It specifies the Docker image to run and sets environment variables for AWS credentials and region, similar to the VS Code installation.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "aws_access_key",
        "description": "AWS Access Key ID",
        "password": true
      },
      {
        "type": "promptString",
        "id": "aws_secret_key",
        "description": "AWS Secret Access Key",
        "password": true
      },
      {
        "type": "promptString",
        "id": "aws_region",
        "description": "AWS Region"
      }
    ],
    "servers": {
      "aws-kb-retrieval": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "mcp/aws-kb-retrieval-server"],
        "env": {
          "AWS_ACCESS_KEY_ID": "${input:aws_access_key}",
          "AWS_SECRET_ACCESS_KEY": "${input:aws_secret_key}",
          "AWS_REGION": "${input:aws_region}"
        }
      }
    }
  }
}
```

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

### VS Code Configuration for Google Maps (NPX)

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

This JSON configuration block is for setting up the Google Maps server within VS Code using NPX. It defines input prompts for the Google Maps API key and specifies the command and arguments for running the server, along with environment variables.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "maps_api_key",
        "description": "Google Maps API Key",
        "password": true
      }
    ],
    "servers": {
      "google-maps": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-google-maps"],
        "env": {
          "GOOGLE_MAPS_API_KEY": "${input:maps_api_key}"
        }
      }
    }
  }
}
```

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

### Install Puppeteer Server via Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/puppeteer/README.md

Provides the JSON configuration for installing the Puppeteer server using Docker within VS Code. This method leverages Docker for running the server in a containerized environment, ensuring headless Chromium execution.

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

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

### Configure MCP GitHub Server with NPX in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

This JSON configuration block is used to set up the Model Context Protocol GitHub server within VS Code using NPX. It defines inputs for a GitHub Personal Access Token and specifies the NPX command and environment variables for running the server.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "github_token",
        "description": "GitHub Personal Access Token",
        "password": true
      }
    ],
    "servers": {
      "github": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-github"
        ],
        "env": {
          "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"
        }
      }
    }
  }
}
```

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

### Configure Claude Desktop with Docker

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Configuration for Claude Desktop to use mcp-server-git via Docker. This includes running the Docker container, mounting a local directory, and specifying the image.

```json
{
  "mcpServers": {
    "git": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "--mount", "type=bind,src=/Users/username,dst=/Users/username", "mcp/git"]
    }
  }
}
```

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

### Configure MCP SQLite Server with UV in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sqlite/README.md

This JSON configuration is for setting up the MCP SQLite server using UV within VS Code. It defines an input prompt for the SQLite database path and specifies the command and arguments to run the server.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "db_path",
        "description": "SQLite Database Path",
        "default": "${workspaceFolder}/db.sqlite"
      }
    ],
    "servers": {
      "sqlite": {
        "command": "uvx",
        "args": [
          "mcp-server-sqlite",
          "--db-path",
          "${input:db_path}"
        ]
      }
    }
  }
}
```

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

### Install AWS KB Retrieval Server with Docker in VS Code Insiders

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/aws-kb-retrieval-server/README.md

Installs the AWS KB Retrieval server using Docker within VS Code Insiders. Requires AWS Access Key ID, Secret Access Key, and Region as inputs, which are configured as environment variables.

```bash
docker run -i --rm mcp/aws-kb-retrieval-server -e AWS_ACCESS_KEY_ID="$AWS_ACCESS_KEY_ID" -e AWS_SECRET_ACCESS_KEY="$AWS_SECRET_ACCESS_KEY" -e AWS_REGION="$AWS_REGION"
```

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

### VS Code Configuration for Google Maps (Docker)

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

This JSON configuration block is for setting up the Google Maps server within VS Code using Docker. It defines input prompts for the Google Maps API key and specifies the Docker command and arguments for running the server, along with environment variables.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "maps_api_key",
        "description": "Google Maps API Key",
        "password": true
      }
    ],
    "servers": {
      "google-maps": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "mcp/google-maps"],
        "env": {
          "GOOGLE_MAPS_API_KEY": "${input:maps_api_key}"
        }
      }
    }
  }
}
```

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

### Get Pull Request Review Comments

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

Retrieves all review comments made on a specific pull request.

```bash
curl -H "Authorization: token YOUR_GITHUB_TOKEN" "https://api.github.com/repos/owner/repo/pulls/456/comments"
```

```python
from github import Github
github = Github("YOUR_GITHUB_TOKEN")
repo = github.get_user("owner").get_repo("repo")
pull_request = repo.get_pull(456)
comments = pull_request.get_review_comments()
for comment in comments:
    print(comment.body)
```

```javascript
const { Octokit } = require("@octokit/core");
const octokit = new Octokit({ auth: "YOUR_GITHUB_TOKEN" });

octokit.request('GET /repos/{owner}/{repo}/pulls/{pull_number}/comments', {
  owner: 'owner',
  repo: 'repo',
  pull_number: 456
}).then(response => {
  response.data.forEach(comment => {
    console.log(comment.body);
  });
});
```

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

### Get Pull Request Status

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

Fetches the combined status of all checks and statuses for a given pull request.

```bash
curl -H "Authorization: token YOUR_GITHUB_TOKEN" "https://api.github.com/repos/owner/repo/pulls/456/status"
```

```python
from github import Github
github = Github("YOUR_GITHUB_TOKEN")
repo = github.get_user("owner").get_repo("repo")
pull_request = repo.get_pull(456)
status = pull_request.get_combined_status()
print(status.state)
```

```javascript
const { Octokit } = require("@octokit/core");
const octokit = new Octokit({ auth: "YOUR_GITHUB_TOKEN" });

octokit.request('GET /repos/{owner}/{repo}/pulls/{pull_number}/status', {
  owner: 'owner',
  repo: 'repo',
  pull_number: 456
}).then(response => {
  console.log(response.data.state);
});
```

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

### Get Pull Request Files

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

Retrieves a list of all files that were changed in a specific pull request, including their status and patch.

```bash
curl -H "Authorization: token YOUR_GITHUB_TOKEN" "https://api.github.com/repos/owner/repo/pulls/456/files"
```

```python
from github import Github
github = Github("YOUR_GITHUB_TOKEN")
repo = github.get_user("owner").get_repo("repo")
pull_request = repo.get_pull(456)
files = pull_request.get_files()
for file in files:
    print(file.filename)
```

```javascript
const { Octokit } = require("@octokit/core");
const octokit = new Octokit({ auth: "YOUR_GITHUB_TOKEN" });

octokit.request('GET /repos/{owner}/{repo}/pulls/{pull_number}/files', {
  owner: 'owner',
  repo: 'repo',
  pull_number: 456
}).then(response => {
  response.data.forEach(file => {
    console.log(file.filename);
  });
});
```

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

### Configure EverArt MCP Server with NPX for Claude Desktop

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/everart/README.md

Configuration for using the EverArt MCP Server with Claude Desktop via NPX. It specifies the command to run the server using npx and sets the EVERART_API_KEY environment variable.

```json
{
  "mcpServers": {
    "everart": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-everart"],
      "env": {
        "EVERART_API_KEY": "your_key_here"
      }
    }
  }
}
```

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

### Get Specific Issue Details

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

Fetches the complete details of a specific issue within a repository, including comments and metadata.

```bash
curl -H "Authorization: token YOUR_GITHUB_TOKEN" "https://api.github.com/repos/owner/repo/issues/123"
```

```python
from github import Github
github = Github("YOUR_GITHUB_TOKEN")
repo = github.get_user("owner").get_repo("repo")
issue = repo.get_issue(123)
print(issue.title)
```

```javascript
const { Octokit } = require("@octokit/core");
const octokit = new Octokit({ auth: "YOUR_GITHUB_TOKEN" });

octokit.request('GET /repos/{owner}/{repo}/issues/{issue_number}', {
  owner: 'owner',
  repo: 'repo',
  issue_number: 123
}).then(response => {
  console.log(response.data.title);
});
```

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

### Configure GitLab MCP Server with Docker

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/gitlab/README.md

This configuration snippet shows how to set up the GitLab MCP Server using Docker. It specifies the command to run the Docker container, environment variables for authentication (GITLAB_PERSONAL_ACCESS_TOKEN) and API URL (GITLAB_API_URL), and includes placeholders for user-specific token and API endpoint.

```JSON
{
  "mcpServers": {
    "gitlab": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "GITLAB_PERSONAL_ACCESS_TOKEN",
        "-e",
        "GITLAB_API_URL",
        "mcp/gitlab"
      ],
      "env": {
        "GITLAB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>",
        "GITLAB_API_URL": "https://gitlab.com/api/v4" // Optional, for self-hosted instances
      }
    }
  }
}
```

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

### Configure Slack MCP Server with NPX

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/slack/README.md

This JSON configuration demonstrates how to set up the Slack MCP Server using NPX for integration with Claude Desktop. It specifies the command to run, arguments, and environment variables including the Slack Bot Token, Team ID, and channel IDs.

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

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

### Get Pull Request Details

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

Retrieves detailed information about a specific pull request, including its diff status and review information.

```bash
curl -H "Authorization: token YOUR_GITHUB_TOKEN" "https://api.github.com/repos/owner/repo/pulls/456"
```

```python
from github import Github
github = Github("YOUR_GITHUB_TOKEN")
repo = github.get_user("owner").get_repo("repo")
pull_request = repo.get_pull(456)
print(pull_request.title)
```

```javascript
const { Octokit } = require("@octokit/core");
const octokit = new Octokit({ auth: "YOUR_GITHUB_TOKEN" });

octokit.request('GET /repos/{owner}/{repo}/pulls/{pull_number}', {
  owner: 'owner',
  repo: 'repo',
  pull_number: 456
}).then(response => {
  console.log(response.data.title);
});
```

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

### Build MCP Slack Docker Image

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/slack/README.md

This bash command builds the Docker image for the MCP Slack server. It tags the image as 'mcp/slack' and uses the Dockerfile located in the 'src/slack' directory, building from the current directory.

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

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

### Configure MCP GitHub Server with Docker in VS Code

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

This JSON configuration block is used to set up the Model Context Protocol GitHub server within VS Code using Docker. It defines inputs for a GitHub Personal Access Token and specifies the Docker command and environment variables for running the server.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "github_token",
        "description": "GitHub Personal Access Token",
        "password": true
      }
    ],
    "servers": {
      "github": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "mcp/github"],
        "env": {
          "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"
        }
      }
    }
  }
}
```

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

### Configure EverArt MCP Server with Docker for Claude Desktop

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/everart/README.md

Configuration for using the EverArt MCP Server with Claude Desktop via Docker. It specifies the command to run the Docker container and sets the EVERART_API_KEY environment variable.

```json
{
  "mcpServers": {
    "everart": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "EVERART_API_KEY", "mcp/everart"],
      "env": {
        "EVERART_API_KEY": "your_key_here"
      }
    }
  }
}
```

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

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

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sentry/README.md

Configuration for using mcp-server-sentry with Claude Desktop via pip installation. Requires a Sentry authentication token.

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

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

### Get Contents of GitHub Repository File or Directory

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

Retrieves the contents of a file or directory from a GitHub repository. Requires repository owner, name, and the path to the file or directory. An optional branch can be specified.

```shell
get_file_contents(owner: str, repo: str, path: str, branch: Optional[str] = None)
```

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

### Build MCP GitHub Docker Image

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/github/README.md

This bash command builds the Docker image for the MCP GitHub server. It tags the image as 'mcp/github' and uses the Dockerfile located in the 'src/github' directory.

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

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

### Run Puppeteer Server with NPX

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/puppeteer/README.md

Configuration to run the Puppeteer MCP server using NPX. This command installs and runs the server package, typically opening a browser window for interaction.

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

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

### Configure SQLite MCP Server with uv

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sqlite/README.md

This snippet shows how to add the SQLite MCP server configuration to your 'claude_desktop_config.json' file using the 'uv' command. It specifies the directory for the server and the path to the SQLite database file.

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

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

### Debug Sentry MCP Server with MCP Inspector (uvx)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sentry/README.md

Command to debug the Sentry MCP server using the MCP inspector when installed via uvx. Requires the Sentry Auth Token.

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

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

### Debug Sentry MCP Server with MCP Inspector (local)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sentry/README.md

Command to debug the Sentry MCP server when installed locally or in a development environment using the MCP inspector. Requires the Sentry Auth Token.

```bash
cd path/to/servers/src/sentry
npx @modelcontextprotocol/inspector uv run mcp-server-sentry --auth-token YOUR_SENTRY_TOKEN
```

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

### Configure Sentry MCP Server in Zed using pip

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sentry/README.md

Configuration for the Sentry MCP server within Zed editor settings using pip installation. Requires manual input of the Sentry token.

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

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

### Run Brave Search Server with NPX

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/brave-search/README.md

This snippet demonstrates how to run the Brave Search server using NPX. It also requires a Brave Search API key and sets the corresponding environment variable.

```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "brave_api_key",
        "description": "Brave Search API Key",
        "password": true
      }
    ],
    "servers": {
      "brave-search": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-brave-search"],
        "env": {
          "BRAVE_API_KEY": "${input:brave_api_key}"
        }
      }
    }
  }
}
```

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

### Zed Editor MCP Git Server Configuration (UV)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Configure the MCP Git server in the Zed editor using 'uvx'. This JSON snippet is added to Zed's settings.json under 'context_servers'.

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

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

### Zed Editor MCP Git Server Configuration (Pip)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Configure the MCP Git server in the Zed editor using a Python pip installation. This JSON snippet is added to Zed's settings.json under 'context_servers'.

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

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

### Test MCP Inspector with SQLite Server

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/sqlite/README.md

These bash commands are used to test the MCP inspector with the SQLite server. First, it adds the 'mcp[cli]' package, then it starts the MCP development server for the SQLite implementation.

```bash
uv add "mcp[cli]"
mcp dev src/mcp_server_sqlite/server.py:wrapper
```

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

### Configure Slack MCP Server with Docker

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/slack/README.md

This JSON configuration illustrates how to set up the Slack MCP Server using Docker for integration with Claude Desktop. It defines the command to run, arguments including environment variable flags, and the Docker image, along with essential environment variables like Slack Bot Token, Team ID, and channel IDs.

```json
{
  "mcpServers": {
    "slack": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "SLACK_BOT_TOKEN",
        "-e",
        "SLACK_TEAM_ID",
        "-e",
        "SLACK_CHANNEL_IDS",
        "mcp/slack"
      ],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-bot-token",
        "SLACK_TEAM_ID": "T01234567",
        "SLACK_CHANNEL_IDS": "C01234567, C76543210"
      }
    }
  }
}
```

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

### Claude Desktop App MCP Server Configuration (UVX)

Source: https://github.com/modelcontextprotocol/servers-archived/blob/main/src/git/README.md

Configuration for the Claude desktop app to use the MCP Git server via UVX. This specifies the directory containing the server source code.

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