Model Context Protocol on Producthunt daily

mcp

Sat, 08 Nov 2025 15:26:30 +0800

awslabs/mcp

AWS MCP Servers

A suite of specialized MCP servers that help you get the most out of AWS, wherever you use MCP.

AWS MCP Servers

What is the Model Context Protocol (MCP) and how does it work with AWS MCP Servers?

The Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether you’re building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need.

— Model Context Protocol README

An MCP Server is a lightweight program that exposes specific capabilities through the standardized Model Context Protocol. Host applications (such as chatbots, IDEs, and other AI tools) have MCP clients that maintain 1:1 connections with MCP servers. Common MCP clients include agentic AI coding assistants (like Q Developer, Cline, Cursor, Windsurf) as well as chatbot applications like Claude Desktop, with more clients coming soon. MCP servers can access local data sources and remote services to provide additional context that improves the generated outputs from the models.

AWS MCP Servers use this protocol to provide AI applications access to AWS documentation, contextual guidance, and best practices. Through the standardized MCP client-server architecture, AWS capabilities become an intelligent extension of your development environment or AI application.

AWS MCP servers enable enhanced cloud-native development, infrastructure management, and development workflows—making AI-assisted cloud computing more accessible and efficient.

The Model Context Protocol is an open source project run by Anthropic, PBC. and open to contributions from the entire community. For more information on MCP, you can find further documentation here

AWS MCP Servers Transport Mechanisms

Supported transport mechanisms

The MCP protocol currently defines two standard transport mechanisms for client-server communication:

stdio, communication over standard in and standard out
streamable HTTP

These AWS MCP Servers are designed to support stdio only.

You are responsible for ensuring that your use of these servers comply with the terms governing them, and any laws, rules, regulations, policies, or standards that apply to you.

Server Sent Events Support Removal

Important Notice: On May 26th, 2025, Server Sent Events (SSE) support was removed from all MCP servers in their latest major versions. This change aligns with the Model Context Protocol specification’s backwards compatibility guidelines.

We are actively working towards supporting Streamable HTTP, which will provide improved transport capabilities for future versions.

For applications still requiring SSE support, please use the previous major version of the respective MCP server until you can migrate to alternative transport methods.

Why AWS MCP Servers?

MCP servers enhance the capabilities of foundation models (FMs) in several key ways:

Improved Output Quality: By providing relevant information directly in the model’s context, MCP servers significantly improve model responses for specialized domains like AWS services. This approach reduces hallucinations, provides more accurate technical details, enables more precise code generation, and ensures recommendations align with current AWS best practices and service capabilities.
Access to Latest Documentation: FMs may not have knowledge of recent releases, APIs, or SDKs. MCP servers bridge this gap by pulling in up-to-date documentation, ensuring your AI assistant always works with the latest AWS capabilities.
Workflow Automation: MCP servers convert common workflows into tools that foundation models can use directly. Whether it’s CDK, Terraform, or other AWS-specific workflows, these tools enable AI assistants to perform complex tasks with greater accuracy and efficiency.
Specialized Domain Knowledge: MCP servers provide deep, contextual knowledge about AWS services that might not be fully represented in foundation models’ training data, enabling more accurate and helpful responses for cloud development tasks.

Available MCP Servers: Quick Installation

Get started quickly with one-click installation buttons for popular MCP clients. Click the buttons below to install servers directly in Cursor or VS Code:

🚀 Getting Started with AWS

For general AWS interactions and comprehensive API support, we recommend starting with:

Server Name	Description	Install
AWS API MCP Server	Start here for general AWS interactions! Comprehensive AWS API support with command validation, security controls, and access to all AWS services. Perfect for managing infrastructure, exploring resources, and executing AWS operations through natural language.
AWS Knowledge MCP Server	A remote, fully-managed MCP server hosted by AWS that provides access to the latest AWS docs, API references, What’s New Posts, Getting Started information, Builder Center, Blog posts, Architectural references, and Well-Architected guidance.

Browse by What You’re Building

📚 Real-time access to official AWS documentation

Server Name	Description	Install
AWS Knowledge MCP Server	A remote, fully-managed MCP server hosted by AWS that provides access to the latest AWS docs, API references, What’s New Posts, Getting Started information, Builder Center, Blog posts, Architectural references, and Well-Architected guidance.
AWS Documentation MCP Server	Get latest AWS docs and API references

🏗️ Infrastructure & Deployment

Build, deploy, and manage cloud infrastructure with Infrastructure as Code best practices.

Server Name	Description	Install
AWS Cloud Control API MCP Server	Direct AWS resource management with security scanning and best practices
AWS CDK MCP Server	AWS CDK development with security compliance and best practices
AWS Terraform MCP Server	Terraform workflows with integrated security scanning
AWS CloudFormation MCP Server	Direct CloudFormation resource management via Cloud Control API

Container Platforms

Server Name	Description	Install
Amazon EKS MCP Server	Kubernetes cluster management and application deployment
Amazon ECS MCP Server	Container orchestration and ECS application deployment
Finch MCP Server	Local container building with ECR integration

Serverless & Functions

Server Name	Description	Install
AWS Serverless MCP Server	Complete serverless application lifecycle with SAM CLI
AWS Lambda Tool MCP Server	Execute Lambda functions as AI tools for private resource access

Support

Server Name	Description	Install
AWS Support MCP Server	Help users create and manage AWS Support cases

🤖 AI & Machine Learning

Enhance AI applications with knowledge retrieval, content generation, and ML capabilities

Server Name	Description	Install
Amazon Bedrock Knowledge Bases Retrieval MCP Server	Query enterprise knowledge bases with citation support
Amazon Kendra Index MCP Server	Enterprise search and RAG enhancement
Amazon Q Business MCP Server	AI assistant for your ingested content with anonymous access
Amazon Q Index MCP Server	Data accessors to search through enterprise’s Q index
Nova Canvas MCP Server	AI image generation using Amazon Nova Canvas
AWS Bedrock Data Automation MCP Server	Analyze documents, images, videos, and audio files
AWS Bedrock Custom Model Import MCP Server	Manage custom models in Bedrock for on-demand inference
AWS Bedrock AgentCore MCP Server	Provides comprehensive documentation access on AgentCore platform services, APIs, and best practices

📊 Data & Analytics

Work with databases, caching systems, and data processing workflows.

SQL & NoSQL Databases

Server Name	Description	Install
Amazon DynamoDB MCP Server	Complete DynamoDB operations and table management
Amazon Aurora PostgreSQL MCP Server	PostgreSQL database operations via RDS Data API
Amazon Aurora MySQL MCP Server	MySQL database operations via RDS Data API
Amazon Aurora DSQL MCP Server	Distributed SQL with PostgreSQL compatibility
Amazon DocumentDB MCP Server	MongoDB-compatible document database operations
Amazon Neptune MCP Server	Graph database queries with openCypher and Gremlin
Amazon Keyspaces MCP Server	Apache Cassandra-compatible operations
Amazon Timestream for InfluxDB MCP Server	Time-series database operations and InfluxDB compatibility
Amazon MSK MCP Server	Managed Kafka cluster operations and streaming
AWS S3 Tables MCP Server	Manage S3 Tables for optimized analytics
Amazon Redshift MCP Server	Data warehouse operations and analytics queries
AWS IoT SiteWise MCP Server	Industrial IoT asset management, data ingestion, and analytics

Search & Analytics

Amazon OpenSearch MCP Server - OpenSearch powered search, Analytics, and Observability

Backend API Providers

Server Name	Description	Install
AWS AppSync MCP Server	Manage and Interact with application backends powered by AWS AppSync

Caching & Performance

Server Name	Description	Install
Amazon ElastiCache MCP Server	Complete ElastiCache control plane operations
Amazon ElastiCache / MemoryDB for Valkey MCP Server	Advanced data structures and caching with Valkey
Amazon ElastiCache for Memcached MCP Server	High-speed caching with Memcached protocol

🛠️ Developer Tools & Support

Accelerate development with code analysis, documentation, and testing utilities.

Server Name	Description	Install
AWS IAM MCP Server	Comprehensive IAM user, role, group, and policy management with security best practices
Git Repo Research MCP Server	Semantic code search and repository analysis
Code Documentation Generator MCP Server	Automated documentation from code analysis
AWS Diagram MCP Server	Generate architecture diagrams and technical illustrations
Frontend MCP Server	React and modern web development guidance
Synthetic Data MCP Server	Generate realistic test data for development and ML
OpenAPI MCP Server	Dynamic API integration through OpenAPI specifications

📡 Integration & Messaging

Connect systems with messaging, workflows, and location services.

Server Name	Description	Install
Amazon SNS / SQS MCP Server	Event-driven messaging and queue management
Amazon MQ MCP Server	Message broker management for RabbitMQ and ActiveMQ
AWS MSK MCP Server	Managed Kafka cluster operations and streaming
AWS Step Functions Tool MCP Server	Execute complex workflows and business processes
Amazon Location Service MCP Server	Place search, geocoding, and route optimization
OpenAPI MCP Server	Dynamic API integration through OpenAPI specifications

💰 Cost & Operations

Monitor, optimize, and manage your AWS infrastructure and costs.

Server Name	Description	Install
AWS Pricing MCP Server	AWS service pricing and cost estimates
AWS Cost Explorer MCP Server	Detailed cost analysis and reporting
Amazon CloudWatch MCP Server	Metrics, Alarms, and Logs analysis and operational troubleshooting
AWS Managed Prometheus MCP Server	Prometheus-compatible operations
AWS Billing and Cost Management MCP Server	Billing and cost management

🧬 Healthcare & Lifesciences

Interact with AWS HealthAI services.

Server Name	Description	Install
AWS HealthOmics MCP Server	Generate, run, debug and optimize lifescience workflows
AWS HealthLake MCP Server	Create, manage, search, and optimize FHIR healthcare data workflows with comprehensive AWS HealthLake integration, featuring automated resource discovery, advanced search capabilities, patient record management, and seamless import/export operations.

Browse by How You’re Working

👨‍💻 Vibe Coding & Development

AI coding assistants like Amazon Q Developer CLI, Cline, Cursor, and Claude Code helping you build faster

Core Development Workflow

Server Name	Description	Install
AWS API MCP Server	Start here for general AWS interactions! Comprehensive AWS API support with command validation, security controls, and access to all AWS services. Perfect for managing infrastructure, exploring resources, and executing AWS operations through natural language.
Core MCP Server	Start here: intelligent planning and MCP server orchestration
AWS Knowledge MCP Server	A remote, fully-managed MCP server hosted by AWS that provides access to the latest AWS docs, API references, What’s New Posts, Getting Started information, Builder Center, Blog posts, Architectural references, and Well-Architected guidance.
AWS Documentation MCP Server	Get latest AWS docs and API references
Git Repo Research MCP Server	Semantic search through codebases and repositories

Infrastructure as Code

Server Name	Description	Install
AWS CDK MCP Server	CDK development with security best practices and compliance
AWS Terraform MCP Server	Terraform with integrated security scanning and best practices
AWS CloudFormation MCP Server	Direct AWS resource management through Cloud Control API
AWS Cloud Control API MCP Server	Direct AWS resource management with security scanning and best practices

Application Development

Server Name	Description	Install
Frontend MCP Server	React and modern web development patterns with AWS integration
AWS Diagram MCP Server	Generate architecture diagrams as you design
Code Documentation Generation MCP Server	Auto-generate docs from your codebase
OpenAPI MCP Server	Dynamic API integration through OpenAPI specifications

Container & Serverless Development

Server Name	Description	Install
Amazon EKS MCP Server	Kubernetes cluster management and app deployment
Amazon ECS MCP Server	Containerize and deploy applications to ECS
Finch MCP Server	Local container building with ECR push
AWS Serverless MCP Server	Full serverless app lifecycle with SAM CLI

Testing & Data

Server Name	Description	Install
Synthetic Data MCP Server	Generate realistic test data for development and ML

Lifesciences Workflow Development

Server Name	Description	Install
AWS HealthOmics MCP Server	Generate, run, debug and optimize lifescience workflows

Healthcare Data Management

Server Name	Description	Install
AWS HealthLake MCP Server	Create, manage, search, and optimize FHIR healthcare data workflows with comprehensive AWS HealthLake integration, featuring automated resource discovery, advanced search capabilities, patient record management, and seamless import/export operations.

💬 Conversational Assistants

Customer-facing chatbots, business agents, and interactive Q&A systems

Knowledge & Search

Server Name	Description	Install
Amazon Bedrock Knowledge Bases Retrieval MCP Server	Query enterprise knowledge bases with citation support
Amazon Kendra Index MCP Server	Enterprise search and RAG enhancement
Amazon Q Business MCP Server	AI assistant for your ingested content with anonymous access
Amazon Q Index MCP Server	Data accessors to search through enterprise’s Q index
AWS Documentation MCP Server	Get latest AWS docs and API references

Content Processing & Generation

Server Name	Description	Install
Amazon Nova Canvas MCP Server	Generate images from text descriptions and color palettes
Amazon Bedrock Data Automation MCP Server	Analyze uploaded documents, images, and media

Business Services

Server Name	Description	Install
Amazon Location Service MCP Server	Location search, geocoding, and business hours
AWS Pricing MCP Server	AWS service pricing and cost estimates
AWS Cost Explorer MCP Server	Detailed cost analysis and spend reports

🤖 Autonomous Background Agents

Headless automation, ETL pipelines, and operational systems

Data Operations & ETL

Server Name	Description	Install
AWS Data Processing MCP Server	Comprehensive data processing tools and real-time pipeline visibility across AWS Glue and Amazon EMR-EC2
Amazon DynamoDB MCP Server	Complete DynamoDB operations and table management
Amazon Aurora PostgreSQL MCP Server	PostgreSQL database operations via RDS Data API
Amazon Aurora MySQL MCP Server	MySQL database operations via RDS Data API
Amazon Aurora DSQL MCP Server	Distributed SQL with PostgreSQL compatibility
Amazon DocumentDB MCP Server	MongoDB-compatible document database operations
Amazon Neptune MCP Server	Graph database queries with openCypher and Gremlin
Amazon Keyspaces MCP Server	Apache Cassandra-compatible operations
Amazon Timestream for InfluxDB MCP Server	Time-series database operations and InfluxDB compatibility
Amazon MSK MCP Server	Managed Kafka cluster operations and streaming

Caching & Performance

Server Name	Description	Install
Amazon ElastiCache / MemoryDB for Valkey MCP Server	Advanced data structures and caching with Valkey
Amazon ElastiCache for Memcached MCP Server	High-speed caching with Memcached protocol

Workflow & Integration

Server Name	Description	Install
AWS Lambda Tool MCP Server	Execute Lambda functions as AI tools for private resource access
AWS Step Functions Tool MCP Server	Execute complex workflows and business processes
Amazon SNS/SQS MCP Server	Event-driven messaging and queue management
Amazon MQ MCP Server	Message broker management for RabbitMQ and ActiveMQ
AWS MSK MCP Server	Managed Kafka cluster operations and streaming

Operations & Monitoring

Server Name	Description	Install
Amazon CloudWatch MCP Server	Metrics, Alarms, and Logs analysis and operational troubleshooting
Amazon CloudWatch Application Signals MCP Server	Application monitoring and performance insights
AWS Cost Explorer MCP Server	Detailed cost analysis and reporting
AWS Managed Prometheus MCP Server	Prometheus-compatible operations and monitoring
AWS Well-Architected Security Assessment Tool MCP Server	Assess AWS environments against the Well-Architected Framework Security Pillar
AWS CloudTrail MCP Server	CloudTrail events querying and analysis

MCP AWS Lambda Handler Module

A Python library for creating serverless HTTP handlers for the Model Context Protocol (MCP) using AWS Lambda. This module provides a flexible framework for building MCP HTTP endpoints with pluggable session management, including built-in DynamoDB support.

Features:

Easy serverless MCP HTTP handler creation using AWS Lambda
Pluggable session management system
Built-in DynamoDB session backend support
Customizable authentication and authorization
Example implementations and tests

See src/mcp-lambda-handler/README.md for full usage, installation, and development instructions.

When to use Local vs Remote MCP Servers?

AWS MCP servers can be run either locally on your development machine or remotely on the cloud. Here’s when to use each approach:

Local MCP Servers

Development & Testing: Perfect for local development, testing, and debugging
Offline Work: Continue working when internet connectivity is limited
Data Privacy: Keep sensitive data and credentials on your local machine
Low Latency: Minimal network overhead for faster response times
Resource Control: Direct control over server resources and configuration

Remote MCP Servers

Team Collaboration: Share consistent server configurations across your team
Resource Intensive Tasks: Offload heavy processing to dedicated cloud resources
Always Available: Access your MCP servers from anywhere, any device
Automatic Updates: Get the latest features and security patches automatically
Scalability: Easily handle varying workloads without local resource constraints

Note: Some MCP servers, like AWS Knowledge MCP, are provided as fully managed services by AWS. These AWS-managed remote servers require no setup or infrastructure management on your part - just connect and start using them.

Use Cases for the Servers

For example, you can use the AWS Documentation MCP Server to help your AI assistant research and generate up-to-date code for any AWS service, like Amazon Bedrock Inline agents. Alternatively, you could use the CDK MCP Server or the Terraform MCP Server to have your AI assistant create infrastructure-as-code implementations that use the latest APIs and follow AWS best practices. With the AWS Pricing MCP Server, you could ask “What would be the estimated monthly cost for this CDK project before I deploy it?” or “Can you help me understand the potential AWS service expenses for this infrastructure design?” and receive detailed cost estimations and budget planning insights. The Valkey MCP Server enables natural language interaction with Valkey data stores, allowing AI assistants to efficiently manage data operations through a simple conversational interface.

Installation and Setup

Each server has specific installation instructions with one-click installs for Cursor and VSCode. Generally, you can:

Install uv from Astral
Install Python using uv python install 3.10
Configure AWS credentials with access to required services
Add the server to your MCP client configuration

Example configuration for Amazon Q CLI MCP (~/.aws/amazonq/mcp.json):

For macOS/Linux

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.core-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

See individual server READMEs for specific requirements and configuration options.

For Windows

When configuring MCP servers on Windows, you’ll need to use a slightly different configuration format:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

If you have problems with MCP configuration or want to check if the appropriate parameters are in place, you can try the following:

# Run MCP server manually with timeout 15s
$ timeout 15s uv tool run <MCP Name> <args> 2>&1 || echo "Command completed or timed out"

# Example (Aurora MySQL MCP Server)
$ timeout 15s uv tool run awslabs.mysql-mcp-server --resource_arn <Your Resource ARN> --secret_arn <Your Secret ARN> ... 2>&1 || echo "Command completed or timed out"

# If the arguments are not set appropriately, you may see the following message:
usage: awslabs.mysql-mcp-server [-h] --resource_arn RESOURCE_ARN --secret_arn SECRET_ARN --database DATABASE
                                --region REGION --readonly READONLY
awslabs.mysql-mcp-server: error: the following arguments are required: --resource_arn, --secret_arn, --database, --region, --readonly

Note about performance when using uvx "@latest" suffix:

Using the "@latest" suffix checks and downloads the latest MCP server package from pypi every time you start your MCP clients, but it comes with a cost of increased initial load times. If you want to minimize the initial load time, remove "@latest" and manage your uv cache yourself using one of these approaches:

uv cache clean <tool>: where {tool} is the mcp server you want to delete from cache and install again (e.g.: “awslabs.lambda-tool-mcp-server”) (remember to remove the ‘<>’).
uvx <tool>@latest: this will refresh the tool with the latest version and add it to the uv cache.

Running MCP servers in containers

Docker images for each MCP server are published to the public AWS ECR registry.

This example uses docker with the “awslabs.nova-canvas-mcp-server and can be repeated for each MCP server

Optionally save sensitive environmental variables in a file:

# contents of a .env file with fictitious AWS temporary credentials
AWS_ACCESS_KEY_ID=ASIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
AWS_SESSION_TOKEN=AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk

Use the docker options: --env, --env-file, and --volume as needed because the "env": {} are not available within the container.

{
  "mcpServers": {
    "awslabs.nova-canvas-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "--interactive",
        "--env",
        "FASTMCP_LOG_LEVEL=ERROR",
        "--env",
        "AWS_REGION=us-east-1",
        "--env-file",
        "/full/path/to/.env",
        "--volume",
        "/full/path/to/.aws:/app/.aws",
        "public.ecr.aws/awslabs-mcp/awslabs/nova-canvas-mcp-server:latest"
      ],
      "env": {}
    }
  }
}

For testing local changes you can build and tag the image. You have to update the MCP configuration to use this tag instead of the ECR image.
1 2

cd src/nova-canvas-mcp-server docker build -t awslabs/nova-canvas-mcp-server .

Getting Started with Amazon Q Developer CLI

Install in Amazon Q Developer CLI

See Amazon Q Developer CLI documentation for details.

Access MCP Settings
- Open the Q Developer panel and open the Chat panel.
- Choose the tools icon to access to MCP configuration.
Add MCP Servers
- Choose the plus (+) symbol.
- Select the scope: global or local. If you select global scope, the MCP server configuration is stored in ~/.aws/amazonq/mcp.json and available across all your projects. If you select local scope, the configuration is stored in .amazonq/mcp.json within your current project.
- Fill in values as applicable.
Manual Configuration
- You can also manually edit the MCP configuration file located at ~/.aws/amazonq/mcp.json globally or .amazonq/mcp.json locally.

`~/.aws/amazonq/mcp.json`

For macOS/Linux:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

For Windows:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

Getting Started with Kiro

Install in Kiro

See Kiro Model Context Protocol Documentation for details.

Navigate Kiro > MCP Servers
Add a new MCP server by clicking the + Add button.
Paste the configuration given below:

`kiro_mcp_settings.json`

For macOS/Linux:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

For Windows:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

Getting Started with Cline and Amazon Bedrock

IMPORTANT: Following these instructions may incur costs and are subject to the Amazon Bedrock Pricing. You are responsible for any associated costs. In addition to selecting the desired model in the Cline settings, ensure you have your selected model (e.g. anthropic.claude-3-7-sonnet) also enabled in Amazon Bedrock. For more information on this, see these AWS docs on enabling model access to Amazon Bedrock Foundation Models (FMs).

Follow the steps above in the Installation and Setup section to install uv from Astral, install Python, and configure AWS credentials with the required services.
If using Visual Studio Code, install the Cline VS Code Extension (or equivalent extension for your preferred IDE). Once installed, click the extension to open it. When prompted, select the tier that you wish. In this case, we will be using Amazon Bedrock, so the free tier of Cline is fine as we will be sending requests using the Amazon Bedrock API instead of the Cline API.

Select the MCP Servers button.

Select the Installed tab, then click Configure MCP Servers to open the cline_mcp_settings.json file.

In the cline_mcp_settings.json file, add your desired MCP servers in the mcpServers object. See the following example that will use some of the current AWS MCP servers that are available in this repository. Ensure you save the file to install the MCP servers.

`cline_mcp_settings.json`

For macOS/Linux:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    }
   }
 }

For Windows:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    }
  }
}

Once installed, you should see a list of your MCP Servers under the MCP Server Installed tab, and they should have a green slider to show that they are enabled. See the following for an example with two of the possible AWS MCP Servers. Click Done when finished. You should now see the Cline chat interface.

By default, Cline will be set as the API provider, which has limits for the free tier. Next, let’s update the API provider to be AWS Bedrock, so we can use the LLMs through Bedrock, which would have billing go through your connected AWS account.
Click the settings gear to open up the Cline settings. Then under API Provider, switch this from Cline to AWS Bedrock and select AWS Profile for the authentication type. As a note, the AWS Credentials option works as well, however it uses a static credentials (Access Key ID and Secret Access Key) instead of temporary credentials that are automatically redistributed when the token expires, so the temporary credentials with an AWS Profile is the more secure and recommended method.

Fill out the configuration based on the existing AWS Profile you wish to use, select the desired AWS Region, and enable cross-region inference.

Next, scroll down on the settings page until you reach the text box that says Custom Instructions. Paste in the following snippet to ensure the mcp-core server is used as the starting point for every prompt:

`1`	`For every new project, always look at your MCP servers and use mcp-core as the starting point every time. Also after a task completion include the list of MCP servers used in the operation.`

Once the custom prompt is pasted in, click Done to return to the chat interface.
Now you can begin asking questions and testing out the functionality of your installed AWS MCP Servers. The default option in the chat interface is is Plan which will provide the output for you to take manual action on (e.g. providing you a sample configuration that you copy and paste into a file). However, you can optionally toggle this to Act which will allow Cline to act on your behalf (e.g. searching for content using a web browser, cloning a repository, executing code, etc). You can optionally toggle on the “Auto-approve” section to avoid having to click to approve the suggestions, however we recommend leaving this off during testing, especially if you have the Act toggle selected.

Note: For the best results, please prompt Cline to use the desired AWS MCP Server you wish to use. For example, Using the Terraform MCP Server, do...

Getting Started with Cursor

Follow the steps above in the Installation and Setup section to install uv from Astral, install Python, and configure AWS credentials with the required services.
You can place MCP configuration in two locations, depending on your use case:

A. Project Configuration - For tools specific to a project, create a .cursor/mcp.json file in your project directory. - This allows you to define MCP servers that are only available within that specific project.

B. Global Configuration - For tools that you want to use across all projects, create a ~/.cursor/mcp.json file in your home directory. - This makes MCP servers available in all your Cursor workspaces.

`.cursor/mcp.json`

For macOS/Linux:

 {
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

For Windows:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

Using MCP in Chat The Composer Agent will automatically use any MCP tools that are listed under Available Tools on the MCP settings page if it determines them to be relevant. To prompt tool usage intentionally, please prompt Cursor to use the desired AWS MCP Server you wish to use. For example, Using the Terraform MCP Server, do...
Tool Approval By default, when Agent wants to use an MCP tool, it will display a message asking for your approval. You can use the arrow next to the tool name to expand the message and see what arguments the Agent is calling the tool with.

Getting Started with Windsurf

Follow the steps above in the Installation and Setup section to install uv from Astral, install Python, and configure AWS credentials with the required services.
Access MCP Settings
- Navigate to Windsurf - Settings > Advanced Settings or use the Command Palette > Open Windsurf Settings Page
- Look for the “Model Context Protocol (MCP) Servers” section
Add MCP Servers
- Click “Add Server” to add a new MCP server
- You can choose from available templates like GitHub, Puppeteer, PostgreSQL, etc.
- Alternatively, click “Add custom server” to configure your own server
Manual Configuration
- You can also manually edit the MCP configuration file located at ~/.codeium/windsurf/mcp_config.json

`~/.codeium/windsurf/mcp_config.json`

For macOS/Linux:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    }
   }
 }

For Windows:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    }
  }
}

Getting Started with VS Code

Install in VS Code

Configure MCP servers in VS Code settings or in .vscode/mcp.json (see VS Code MCP docs for more info.):

`.vscode/mcp.json`

For macOS/Linux:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

For Windows:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

Getting Started with Claude Code

Install in Claude Code

Configure MCP servers in Claude Code through the CLI or in .mcp.json

Follow the steps above in the Installation and Setup section to install uv from Astral, install Python, and configure AWS credentials with the required services.

Using Claude Code CLI Commands

Claude Code CLI commands to add MCP servers:

# Add core AWS services
claude mcp add aws-api uvx awslabs.aws-api-mcp-server@latest
claude mcp add aws-cdk uvx awslabs.cdk-mcp-server@latest
claude mcp add aws-docs uvx awslabs.aws-documentation-mcp-server@latest
claude mcp add aws-support uvx awslabs.aws-support-mcp-server@latest
claude mcp add aws-pricing uvx awslabs.aws-pricing-mcp-server@latest

# Add AI/ML and Bedrock services
claude mcp add bedrock-kb uvx awslabs.bedrock-kb-retrieval-mcp-server@latest
claude mcp add nova-canvas uvx awslabs.nova-canvas-mcp-server@latest
claude mcp add synthetic-data uvx awslabs.syntheticdata-mcp-server@latest

# Add data and analytics services
claude mcp add aws-dataprocessing uvx awslabs.aws-dataprocessing-mcp-server@latest
claude mcp add aurora-dsql uvx awslabs.aurora-dsql-mcp-server@latest
claude mcp add valkey uvx awslabs.valkey-mcp-server@latest

# List installed servers
claude mcp list

Manual Configuration (Alternative)

You can also manually configure MCP servers by creating a .mcp.json file in your project root:

`.mcp.json`

For macOS/Linux:

{
  "mcpServers": {
    "awslabs.cdk-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cdk-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.aws-documentation-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "AWS_DOCUMENTATION_PARTITION": "aws"
      }
    }
  }
}

Samples

Ready-to-use examples of AWS MCP Servers in action are available in the samples directory. These samples provide working code and step-by-step guides to help you get started with each MCP server.

Vibe coding

You can use these MCP servers with your AI coding assistant to vibe code. For tips and tricks on how to improve your vibe coding experience, please refer to our guide.

Additional Resources

Security

See CONTRIBUTING for more information.

Contributing

Big shout out to our awesome contributors! Thank you for making this project better!

Contributions of all kinds are welcome! Check out our contributor guide for more information.

Developer guide

If you want to add a new MCP Server to the library, check out our development guide and be sure to follow our design guidelines.

License

This project is licensed under the Apache-2.0 License.

Disclaimer

Before using an MCP Server, you should consider conducting your own independent assessment to ensure that your use would comply with your own specific security and quality control practices and standards, as well as the laws, rules, and regulations that govern you and your content.

mcp-context-forge

Wed, 27 Aug 2025 15:29:01 +0800

IBM/mcp-context-forge

MCP Gateway

Model Context Protocol gateway & proxy - unify REST, MCP, and A2A with federation, virtual servers, retries, security, and an optional admin UI.

ContextForge MCP Gateway is a feature-rich gateway, proxy and MCP Registry that federates MCP and REST services - unifying discovery, auth, rate-limiting, observability, virtual servers, multi-transport protocols, and an optional Admin UI into one clean endpoint for your AI clients. It runs as a fully compliant MCP server, deployable via PyPI or Docker, and scales to multi-cluster environments on Kubernetes with Redis-backed federation and caching.

1. Table of Contents
1. 🚀 Overview & Goals
1. Quick Start - PyPI
- 3.1. 1 - Install & run (copy-paste friendly)
1. Quick Start - Containers
- 4.1. 🐳 Docker
  - 4.1.1. 1 - Minimum viable run
  - 4.1.2. 2 - Persist the SQLite database
  - 4.1.3. 3 - Local tool discovery (host network)
- 4.2. 🦭 Podman (rootless-friendly)
  - 4.2.1. 1 - Basic run
  - 4.2.2. 2 - Persist SQLite
  - 4.2.3. 3 - Host networking (rootless)
1. Testing mcpgateway.wrapper by hand
- 5.1. 🧩 Running from an MCP Client (mcpgateway.wrapper)
  - 5.1.1. 1 - Install uv (uvx is an alias it provides)
  - 5.1.2. 2 - Create an on-the-spot venv & run the wrapper
  - 5.1.3. Claude Desktop JSON (runs through uvx)
- 5.2. 🚀 Using with Claude Desktop (or any GUI MCP client)
1. 🚀 Quick Start: VS Code Dev Container
- 6.1. 1 - Clone & Open
- 6.2. 2 - First-Time Build (Automatic)
1. Quick Start (manual install)
- 7.1. Prerequisites
- 7.2. One-liner (dev)
- 7.3. Containerized (self-signed TLS)
- 7.4. Smoke-test the API
1. Installation
- 8.1. Via Make
- 8.2. UV (alternative)
- 8.3. pip (alternative)
- 8.4. Optional (PostgreSQL adapter)
  - 8.4.1. Quick Postgres container
1. Configuration (.env or env vars)
- 9.1. Basic
- 9.2. Authentication
- 9.3. UI Features
- 9.4. Security
- 9.5. Logging
- 9.6. Transport
- 9.7. Federation
- 9.8. Resources
- 9.9. Tools
- 9.10. Prompts
- 9.11. Health Checks
- 9.12. Database
- 9.13. Cache Backend
- 9.14. Development
1. Running
- 10.1. Makefile
- 10.2. Script helper
- 10.3. Manual (Uvicorn)
1. Authentication examples
1. ☁️ AWS / Azure / OpenShift
1. ☁️ IBM Cloud Code Engine Deployment
- 13.1. 🔧 Prerequisites
- 13.2. 📦 Environment Variables
- 13.3. 🚀 Make Targets
- 13.4. 📝 Example Workflow
1. API Endpoints
1. Testing
1. Project Structure
1. API Documentation
1. Makefile targets
1. 🔍 Troubleshooting
- 19.1. Diagnose the listener
- 19.2. Why localhost fails on Windows
  - 19.2.1. Fix (Podman rootless)
  - 19.2.2. Fix (Docker Desktop > 4.19)
1. Contributing
1. Changelog
1. License
1. Core Authors and Maintainers
1. Star History and Project Activity

🚀 Overview & Goals

ContextForge MCP Gateway is a gateway, registry, and proxy that sits in front of any Model Context Protocol (MCP) server or REST API-exposing a unified endpoint for all your AI clients.

⚠️ Caution: The current release (0.6.0) is considered alpha / early beta. It is not production-ready and should only be used for local development, testing, or experimentation. Features, APIs, and behaviors are subject to change without notice. Do not deploy in production environments without thorough security review, validation and additional security mechanisms. Many of the features required for secure, large-scale, or multi-tenant production deployments are still on the project roadmap - which is itself evolving.

It currently supports:

Federation across multiple MCP and REST services
A2A (Agent-to-Agent) integration for external AI agents (OpenAI, Anthropic, custom)
Virtualization of legacy APIs as MCP-compliant tools and servers
Transport over HTTP, JSON-RPC, WebSocket, SSE (with configurable keepalive), stdio and streamable-HTTP
An Admin UI for real-time management, configuration, and log monitoring
Built-in auth, retries, and rate-limiting
OpenTelemetry observability with Phoenix, Jaeger, Zipkin, and other OTLP backends
Scalable deployments via Docker or PyPI, Redis-backed caching, and multi-cluster federation

For a list of upcoming features, check out the ContextForge MCP Gateway Roadmap

⚠️ Important: MCP Gateway is not a standalone product - it is an open source component with NO OFFICIAL SUPPORT from IBM or its affiliates that can be integrated into your own solution architecture. If you choose to use it, you are responsible for evaluating its fit, securing the deployment, and managing its lifecycle. See SECURITY.md for more details.

🔌 Gateway Layer with Protocol Flexibility

Sits in front of any MCP server or REST API
Lets you choose your MCP protocol version (e.g., 2025-03-26)
Exposes a single, unified interface for diverse backends

🌐 Federation of Peer Gateways (MCP Registry)

Auto-discovers or configures peer gateways (via mDNS or manual)
Performs health checks and merges remote registries transparently
Supports Redis-backed syncing and fail-over

🧩 Virtualization of REST/gRPC Services

Wraps non-MCP services as virtual MCP servers
Registers tools, prompts, and resources with minimal configuration

🔁 REST-to-MCP Tool Adapter

Adapts REST APIs into tools with:
- Automatic JSON Schema extraction
- Support for headers, tokens, and custom auth
- Retry, timeout, and rate-limit policies

🧠 Unified Registries

Prompts: Jinja2 templates, multimodal support, rollback/versioning
Resources: URI-based access, MIME detection, caching, SSE updates
Tools: Native or adapted, with input validation and concurrency controls

📈 Admin UI, Observability & Dev Experience

Admin UI built with HTMX + Alpine.js
Real-time log viewer with filtering, search, and export capabilities
Auth: Basic, JWT, or custom schemes
Structured logs, health endpoints, metrics
400+ tests, Makefile targets, live reload, pre-commit hooks

🔍 OpenTelemetry Observability

Vendor-agnostic tracing with OpenTelemetry (OTLP) protocol support
Multiple backend support: Phoenix (LLM-focused), Jaeger, Zipkin, Tempo, DataDog, New Relic
Distributed tracing across federated gateways and services
Automatic instrumentation of tools, prompts, resources, and gateway operations
LLM-specific metrics: Token usage, costs, model performance
Zero-overhead when disabled with graceful degradation
Easy configuration via environment variables

Quick start with Phoenix (LLM observability):

# Start Phoenix
docker run -p 6006:6006 -p 4317:4317 arizephoenix/phoenix:latest

# Configure gateway
export OTEL_ENABLE_OBSERVABILITY=true
export OTEL_TRACES_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

# Run gateway - traces automatically sent to Phoenix
mcpgateway

See Observability Documentation for detailed setup with other backends.

Quick Start - PyPI

MCP Gateway is published on PyPI as mcp-contextforge-gateway.

TLDR;: (single command using uv)

BASIC_AUTH_PASSWORD=pass \
MCPGATEWAY_UI_ENABLED=true \
MCPGATEWAY_ADMIN_API_ENABLED=true \
uvx --from mcp-contextforge-gateway mcpgateway --host 0.0.0.0 --port 4444

📋 Prerequisites

Python ≥ 3.10 (3.11 recommended)
curl + jq - only for the last smoke-test step

1 - Install & run (copy-paste friendly)

# 1️⃣  Isolated env + install from pypi
mkdir mcpgateway && cd mcpgateway
python3 -m venv .venv && source .venv/bin/activate
pip install --upgrade pip
pip install mcp-contextforge-gateway

# 2️⃣  Launch on all interfaces with custom creds & secret key
# Enable the Admin API endpoints (true/false) - disabled by default
export MCPGATEWAY_UI_ENABLED=true
export MCPGATEWAY_ADMIN_API_ENABLED=true

BASIC_AUTH_PASSWORD=pass JWT_SECRET_KEY=my-test-key \
  mcpgateway --host 0.0.0.0 --port 4444 &   # admin/pass

# 3️⃣  Generate a bearer token & smoke-test the API
export MCPGATEWAY_BEARER_TOKEN=$(python3 -m mcpgateway.utils.create_jwt_token \
    --username admin --exp 10080 --secret my-test-key)

curl -s -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://127.0.0.1:4444/version | jq

Windows (PowerShell) quick-start

# 1️⃣  Isolated env + install from PyPI
mkdir mcpgateway ; cd mcpgateway
python3 -m venv .venv ; .\.venv\Scripts\Activate.ps1
pip install --upgrade pip
pip install mcp-contextforge-gateway

# 2️⃣  Environment variables (session-only)
$Env:MCPGATEWAY_UI_ENABLED        = "true"
$Env:MCPGATEWAY_ADMIN_API_ENABLED = "true"
$Env:BASIC_AUTH_PASSWORD          = "changeme"      # admin/changeme
$Env:JWT_SECRET_KEY               = "my-test-key"

# 3️⃣  Launch the gateway
mcpgateway.exe --host 0.0.0.0 --port 4444

#   Optional: background it
# Start-Process -FilePath "mcpgateway.exe" -ArgumentList "--host 0.0.0.0 --port 4444"

# 4️⃣  Bearer token and smoke-test
$Env:MCPGATEWAY_BEARER_TOKEN = python3 -m mcpgateway.utils.create_jwt_token `
    --username admin --exp 10080 --secret my-test-key

curl -s -H "Authorization: Bearer $Env:MCPGATEWAY_BEARER_TOKEN" `
     http://127.0.0.1:4444/version | jq

More configuration

Copy .env.example to .env and tweak any of the settings (or use them as env variables).

🚀 End-to-end demo (register a local MCP server)

# 1️⃣  Spin up the sample GO MCP time server using mcpgateway.translate & docker
python3 -m mcpgateway.translate \
     --stdio "docker run --rm -i -p 8888:8080 ghcr.io/ibm/fast-time-server:latest -transport=stdio" \
     --expose-sse \
     --port 8003

# Or using the official mcp-server-git using uvx:
pip install uv # to install uvx, if not already installed
python3 -m mcpgateway.translate --stdio "uvx mcp-server-git" --expose-sse --port 9000

# Alternative: running the local binary
# cd mcp-servers/go/fast-time-server; make build
# python3 -m mcpgateway.translate --stdio "./dist/fast-time-server -transport=stdio" --expose-sse --port 8002

# NEW: Expose via multiple protocols simultaneously!
python3 -m mcpgateway.translate \
     --stdio "uvx mcp-server-git" \
     --expose-sse \
     --expose-streamable-http \
     --port 9000
# Now accessible via both /sse (SSE) and /mcp (streamable HTTP) endpoints

# 2️⃣  Register it with the gateway
curl -s -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"name":"fast_time","url":"http://localhost:9000/sse"}' \
     http://localhost:4444/gateways

# 3️⃣  Verify tool catalog
curl -s -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/tools | jq

# 4️⃣  Create a *virtual server* bundling those tools. Use the ID of tools from the tool catalog (Step #3) and pass them in the associatedTools list.
curl -s -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"name":"time_server","description":"Fast time tools","associatedTools":[<ID_OF_TOOLS>]}' \
     http://localhost:4444/servers | jq

# Example curl
curl -s -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN"
     -H "Content-Type: application/json"
     -d '{"name":"time_server","description":"Fast time tools","associatedTools":["6018ca46d32a4ac6b4c054c13a1726a2"]}' \
     http://localhost:4444/servers | jq

# 5️⃣  List servers (should now include the UUID of the newly created virtual server)
curl -s -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/servers | jq

# 6️⃣  Client SSE endpoint. Inspect it interactively with the MCP Inspector CLI (or use any MCP client)
npx -y @modelcontextprotocol/inspector
# Transport Type: SSE, URL: http://localhost:4444/servers/UUID_OF_SERVER_1/sse,  Header Name: "Authorization", Bearer Token

🖧 Using the stdio wrapper (mcpgateway-wrapper)

1
2
3

export MCP_AUTH=$MCPGATEWAY_BEARER_TOKEN
export MCP_SERVER_URL=http://localhost:4444/servers/UUID_OF_SERVER_1/mcp
python3 -m mcpgateway.wrapper  # Ctrl-C to exit

You can also run it with uv or inside Docker/Podman - see the Containers section above.

In MCP Inspector, define MCP_AUTH and MCP_SERVER_URL env variables, and select python3 as the Command, and -m mcpgateway.wrapper as Arguments.

echo $PWD/.venv/bin/python3 # Using the Python3 full path ensures you have a working venv
export MCP_SERVER_URL='http://localhost:4444/servers/UUID_OF_SERVER_1/mcp'
export MCP_AUTH=${MCPGATEWAY_BEARER_TOKEN}
npx -y @modelcontextprotocol/inspector

Pass the url and auth as arguments (no need to set environment variables)

1
2
3

npx -y @modelcontextprotocol/inspector
command as `python`
Arguments as `-m mcpgateway.wrapper --url "http://localhost:4444/servers/UUID_OF_SERVER_1/mcp" --auth "Bearer <your token>"`

When using a MCP Client such as Claude with stdio:

{
  "mcpServers": {
    "mcpgateway-wrapper": {
      "command": "python",
      "args": ["-m", "mcpgateway.wrapper"],
      "env": {
        "MCP_AUTH": "your-token-here",
        "MCP_SERVER_URL": "http://localhost:4444/servers/UUID_OF_SERVER_1",
        "MCP_TOOL_CALL_TIMEOUT": "120"
      }
    }
  }
}

Quick Start - Containers

Use the official OCI image from GHCR with Docker or Podman.

🐳 Docker

1 - Minimum viable run

docker run -d --name mcpgateway \
  -p 4444:4444 \
  -e MCPGATEWAY_UI_ENABLED=true \
  -e MCPGATEWAY_ADMIN_API_ENABLED=true \
  -e HOST=0.0.0.0 \
  -e JWT_SECRET_KEY=my-test-key \
  -e BASIC_AUTH_USER=admin \
  -e BASIC_AUTH_PASSWORD=changeme \
  -e AUTH_REQUIRED=true \
  -e DATABASE_URL=sqlite:///./mcp.db \
  ghcr.io/ibm/mcp-context-forge:0.6.0

# Tail logs (Ctrl+C to quit)
docker logs -f mcpgateway

# Generating an API key
docker run --rm -it ghcr.io/ibm/mcp-context-forge:0.6.0 \
  python3 -m mcpgateway.utils.create_jwt_token --username admin --exp 0 --secret my-test-key

Browse to http://localhost:4444/admin (user admin / pass changeme).

2 - Persist the SQLite database

mkdir -p $(pwd)/data

touch $(pwd)/data/mcp.db

sudo chown -R :docker $(pwd)/data

chmod 777 $(pwd)/data

docker run -d --name mcpgateway \
  --restart unless-stopped \
  -p 4444:4444 \
  -v $(pwd)/data:/data \
  -e MCPGATEWAY_UI_ENABLED=true \
  -e MCPGATEWAY_ADMIN_API_ENABLED=true \
  -e DATABASE_URL=sqlite:////data/mcp.db \
  -e HOST=0.0.0.0 \
  -e JWT_SECRET_KEY=my-test-key \
  -e BASIC_AUTH_USER=admin \
  -e BASIC_AUTH_PASSWORD=changeme \
  ghcr.io/ibm/mcp-context-forge:0.6.0

SQLite now lives on the host at ./data/mcp.db.

3 - Local tool discovery (host network)

mkdir -p $(pwd)/data

touch $(pwd)/data/mcp.db

sudo chown -R :docker $(pwd)/data

chmod 777 $(pwd)/data

docker run -d --name mcpgateway \
  --network=host \
  -e MCPGATEWAY_UI_ENABLED=true \
  -e MCPGATEWAY_ADMIN_API_ENABLED=true \
  -e HOST=0.0.0.0 \
  -e PORT=4444 \
  -e DATABASE_URL=sqlite:////data/mcp.db \
  -v $(pwd)/data:/data \
  ghcr.io/ibm/mcp-context-forge:0.6.0

Using --network=host allows Docker to access the local network, allowing you to add MCP servers running on your host. See Docker Host network driver documentation for more details.

🦭 Podman (rootless-friendly)

1 - Basic run

podman run -d --name mcpgateway \
  -p 4444:4444 \
  -e HOST=0.0.0.0 \
  -e DATABASE_URL=sqlite:///./mcp.db \
  ghcr.io/ibm/mcp-context-forge:0.6.0

2 - Persist SQLite

mkdir -p $(pwd)/data

touch $(pwd)/data/mcp.db

sudo chown -R :docker $(pwd)/data

chmod 777 $(pwd)/data

podman run -d --name mcpgateway \
  --restart=on-failure \
  -p 4444:4444 \
  -v $(pwd)/data:/data \
  -e DATABASE_URL=sqlite:////data/mcp.db \
  ghcr.io/ibm/mcp-context-forge:0.6.0

3 - Host networking (rootless)

mkdir -p $(pwd)/data

touch $(pwd)/data/mcp.db

sudo chown -R :docker $(pwd)/data

chmod 777 $(pwd)/data

podman run -d --name mcpgateway \
  --network=host \
  -v $(pwd)/data:/data \
  -e DATABASE_URL=sqlite:////data/mcp.db \
  ghcr.io/ibm/mcp-context-forge:0.6.0

✏️ Docker/Podman tips

.env files - Put all the -e FOO= lines into a file and replace them with --env-file .env. See the provided .env.example for reference.
Pinned tags - Use an explicit version (e.g. v0.6.0) instead of latest for reproducible builds.

JWT tokens - Generate one in the running container:

`1`	`docker exec mcpgateway python3 -m mcpgateway.utils.create_jwt_token -u admin -e 10080 --secret my-test-key`

Upgrades - Stop, remove, and rerun with the same -v $(pwd)/data:/data mount; your DB and config stay intact.

🚑 Smoke-test the running container

curl -s -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/health | jq
curl -s -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/tools | jq
curl -s -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/version | jq

🖧 Running the MCP Gateway stdio wrapper

The mcpgateway.wrapper lets you connect to the gateway over stdio while keeping JWT authentication. You should run this from the MCP Client. The example below is just for testing.

# Set environment variables
export MCPGATEWAY_BEARER_TOKEN=$(python3 -m mcpgateway.utils.create_jwt_token --username admin --exp 10080 --secret my-test-key)
export MCP_AUTH=${MCPGATEWAY_BEARER_TOKEN}
export MCP_SERVER_URL='http://localhost:4444/servers/UUID_OF_SERVER_1/mcp'
export MCP_TOOL_CALL_TIMEOUT=120
export MCP_WRAPPER_LOG_LEVEL=DEBUG  # or OFF to disable logging

docker run --rm -i \
  -e MCP_AUTH=$MCPGATEWAY_BEARER_TOKEN \
  -e MCP_SERVER_URL=http://host.docker.internal:4444/servers/UUID_OF_SERVER_1/mcp \
  -e MCP_TOOL_CALL_TIMEOUT=120 \
  -e MCP_WRAPPER_LOG_LEVEL=DEBUG \
  ghcr.io/ibm/mcp-context-forge:0.6.0 \
  python3 -m mcpgateway.wrapper

Testing `mcpgateway.wrapper` by hand:

Because the wrapper speaks JSON-RPC over stdin/stdout, you can interact with it using nothing more than a terminal or pipes.

# Start the MCP Gateway Wrapper
export MCP_AUTH=${MCPGATEWAY_BEARER_TOKEN}
export MCP_SERVER_URL=http://localhost:4444/servers/YOUR_SERVER_UUID
python3 -m mcpgateway.wrapper

Initialize the protocol

# Initialize the protocol
{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"demo","version":"0.0.1"}}}

# Then after the reply:
{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}

# Get prompts
{"jsonrpc":"2.0","id":4,"method":"prompts/list"}
{"jsonrpc":"2.0","id":5,"method":"prompts/get","params":{"name":"greeting","arguments":{"user":"Bob"}}}

# Get resources
{"jsonrpc":"2.0","id":6,"method":"resources/list"}
{"jsonrpc":"2.0","id":7,"method":"resources/read","params":{"uri":"https://example.com/some.txt"}}

# Get / call tools
{"jsonrpc":"2.0","id":2,"method":"tools/list"}
{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_system_time","arguments":{"timezone":"Europe/Dublin"}}}

Expected responses from mcpgateway.wrapper

{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-03-26","capabilities":{"experimental":{},"prompts":{"listChanged":false},"resources":{"subscribe":false,"listChanged":false},"tools":{"listChanged":false}},"serverInfo":{"name":"mcpgateway-wrapper","version":"0.6.0"}}}

# When there's no tools
{"jsonrpc":"2.0","id":2,"result":{"tools":[]}}

# After you add some tools and create a virtual server
{"jsonrpc":"2.0","id":2,"result":{"tools":[{"annotations":{"readOnlyHint":false,"destructiveHint":true,"idempotentHint":false,"openWorldHint":true},"description":"Convert time between different timezones","inputSchema":{"properties":{"source_timezone":{"description":"Source IANA timezone name","type":"string"},"target_timezone":{"description":"Target IANA timezone name","type":"string"},"time":{"description":"Time to convert in RFC3339 format or common formats like '2006-01-02 15:04:05'","type":"string"}},"required":["time","source_timezone","target_timezone"],"type":"object"},"name":"convert_time"},{"annotations":{"readOnlyHint":false,"destructiveHint":true,"idempotentHint":false,"openWorldHint":true},"description":"Get current system time in specified timezone","inputSchema":{"properties":{"timezone":{"description":"IANA timezone name (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC","type":"string"}},"type":"object"},"name":"get_system_time"}]}}

# Running the time tool:
{"jsonrpc":"2.0","id":3,"result":{"content":[{"type":"text","text":"2025-07-09T00:09:45+01:00"}]}}

🧩 Running from an MCP Client (`mcpgateway.wrapper`)

The mcpgateway.wrapper exposes everything your Gateway knows about over stdio, so any MCP client that can’t (or shouldn’t) open an authenticated SSE stream still gets full tool-calling power.

Remember to substitute your real Gateway URL (and server ID) for http://localhost:4444/servers/UUID_OF_SERVER_1/mcp. When inside Docker/Podman, that often becomes http://host.docker.internal:4444/servers/UUID_OF_SERVER_1/mcp (macOS/Windows) or the gateway container’s hostname (Linux).

🐳 Docker / Podman

docker run -i --rm \
  --network=host \
  -e MCP_SERVER_URL=http://localhost:4444/servers/UUID_OF_SERVER_1/mcp \
  -e MCP_AUTH=${MCPGATEWAY_BEARER_TOKEN} \
  -e MCP_TOOL_CALL_TIMEOUT=120 \
  ghcr.io/ibm/mcp-context-forge:0.6.0 \
  python3 -m mcpgateway.wrapper

📦 pipx (one-liner install & run)

# Install gateway package in its own isolated venv
pipx install --include-deps mcp-contextforge-gateway

# Run the stdio wrapper
MCP_AUTH=${MCPGATEWAY_BEARER_TOKEN} \
MCP_SERVER_URL=http://localhost:4444/servers/UUID_OF_SERVER_1/mcp \
python3 -m mcpgateway.wrapper
# Alternatively with uv
uv run --directory . -m mcpgateway.wrapper

Claude Desktop JSON (uses the host Python that pipx injected):

{
  "mcpServers": {
    "mcpgateway-wrapper": {
      "command": "python3",
      "args": ["-m", "mcpgateway.wrapper"],
      "env": {
        "MCP_AUTH": "<your-token>",
        "MCP_SERVER_URL": "http://localhost:4444/servers/UUID_OF_SERVER_1/mcp",
        "MCP_TOOL_CALL_TIMEOUT": "120"
      }
    }
  }
}

⚡ uv / uvx (light-speed venvs)

1 - Install `uv` (`uvx` is an alias it provides)

# (a) official one-liner
curl -Ls https://astral.sh/uv/install.sh | sh

# (b) or via pipx
pipx install uv

2 - Create an on-the-spot venv & run the wrapper

# Create venv in ~/.venv/mcpgateway (or current dir if you prefer)
uv venv ~/.venv/mcpgateway
source ~/.venv/mcpgateway/bin/activate

# Install the gateway package using uv
uv pip install mcp-contextforge-gateway

# Launch wrapper
MCP_AUTH=${MCPGATEWAY_BEARER_TOKEN} \
MCP_SERVER_URL=http://localhost:4444/servers/UUID_OF_SERVER_1/mcp \
uv run --directory . -m mcpgateway.wrapper # Use this just for testing, as the Client will run the uv command

Claude Desktop JSON (runs through uvx)

{
  "mcpServers": {
    "mcpgateway-wrapper": {
      "command": "uvx",
      "args": [
        "run",
        "--",
        "python",
        "-m",
        "mcpgateway.wrapper"
      ],
      "env": {
        "MCP_AUTH": "<your-token>",
        "MCP_SERVER_URL": "http://localhost:4444/servers/UUID_OF_SERVER_1/mcp"
    }
  }
}

🚀 Using with Claude Desktop (or any GUI MCP client)

Edit Config → File ▸ Settings ▸ Developer ▸ Edit Config
Paste one of the JSON blocks above (Docker / pipx / uvx).
Restart the app so the new stdio server is spawned.
Open logs in the same menu to verify mcpgateway-wrapper started and listed your tools.

Need help? See:

MCP Debugging Guide - https://modelcontextprotocol.io/docs/tools/debugging

🚀 Quick Start: VS Code Dev Container

Spin up a fully-loaded dev environment (Python 3.11, Docker/Podman CLI, all project dependencies) in just two clicks.

📋 Prerequisites

VS Code with the Dev Containers extension
Docker or Podman installed and running locally

🧰 Setup Instructions

1 - Clone & Open

1
2
3

git clone https://github.com/ibm/mcp-context-forge.git
cd mcp-context-forge
code .

VS Code will detect the .devcontainer and prompt: “Reopen in Container” or manually run: Ctrl/Cmd ⇧ P → Dev Containers: Reopen in Container

2 - First-Time Build (Automatic)

The container build will:

Install system packages & Python 3.11
Run make install-dev to pull all dependencies
Execute tests to verify the toolchain

You’ll land in /workspace ready to develop.

🛠️ Daily Developer Workflow

Common tasks inside the container:

# Start dev server (hot reload)
make dev            # http://localhost:4444

# Run tests & linters
make test
make lint

Optional:

make bash - drop into an interactive shell
make clean - clear build artefacts & caches
Port forwarding is automatic (customize via .devcontainer/devcontainer.json)

☁️ GitHub Codespaces: 1-Click Cloud IDE

No local Docker? Use Codespaces:

Go to the repo → Code ▸ Codespaces ▸ Create codespace on main
Wait for the container image to build in the cloud
Develop using the same workflow above

Quick Start (manual install)

Prerequisites

Python ≥ 3.10
GNU Make (optional, but all common workflows are available as Make targets)
Optional: Docker / Podman for containerized runs

One-liner (dev)

`1`	`make venv install serve`

What it does:

Creates / activates a .venv in your home folder ~/.venv/mcpgateway
Installs the gateway and necessary dependencies
Launches Gunicorn (Uvicorn workers) on http://localhost:4444

For development, you can use:

1
2

make install-dev # Install development dependencies, ex: linters and test harness
make lint          # optional: run style checks (ruff, mypy, etc.)

Containerized (self-signed TLS)

Container Runtime Support

This project supports both Docker and Podman. The Makefile automatically detects which runtime is available and handles image naming differences.

Auto-detection

make container-build  # Uses podman if available, otherwise docker

> You can use docker or podman, ex:

```bash
make podman            # build production image
make podman-run-ssl    # run at https://localhost:4444
# or listen on port 4444 on your host directly, adds --network=host to podman
make podman-run-ssl-host

Smoke-test the API

1
2
3

curl -k -sX GET \
     -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     https://localhost:4444/tools | jq

You should receive [] until you register a tool.

Installation

Via Make

1
2

make venv install          # create .venv + install deps
make serve                 # gunicorn on :4444

UV (alternative)

1
2

uv venv && source .venv/bin/activate
uv pip install -e '.[dev]' # IMPORTANT: in zsh, quote to disable glob expansion!

pip (alternative)

1
2

python3 -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"

Optional (PostgreSQL adapter)

You can configure the gateway with SQLite, PostgreSQL (or any other compatible database) in .env.

When using PostgreSQL, you need to install psycopg2 driver.

1
2
3

uv pip install psycopg2-binary   # dev convenience
# or
uv pip install psycopg2          # production build

Quick Postgres container

docker run --name mcp-postgres \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_DB=mcp \
  -p 5432:5432 -d postgres

A make compose-up target is provided along with a docker-compose.yml file to make this process simpler.

Configuration (`.env` or env vars)

⚠️ If any required .env variable is missing or invalid, the gateway will fail fast at startup with a validation error via Pydantic.

You can get started by copying the provided .env.example to .env and making the necessary edits to fit your environment.

🔧 Environment Configuration Variables

Basic

Setting	Description	Default	Options
`APP_NAME`	Gateway / OpenAPI title	`MCP Gateway`	string
`HOST`	Bind address for the app	`127.0.0.1`	IPv4/IPv6
`PORT`	Port the server listens on	`4444`	1-65535
`DATABASE_URL`	SQLAlchemy connection URL	`sqlite:///./mcp.db`	any SQLAlchemy dialect
`APP_ROOT_PATH`	Subpath prefix for app (e.g. `/gateway`)	(empty)	string
`TEMPLATES_DIR`	Path to Jinja2 templates	`mcpgateway/templates`	path
`STATIC_DIR`	Path to static files	`mcpgateway/static`	path

💡 Use APP_ROOT_PATH=/foo if reverse-proxying under a subpath like https://host.com/foo/.

Authentication

Setting	Description	Default	Options
`BASIC_AUTH_USER`	Username for Admin UI login and HTTP Basic authentication	`admin`	string
`BASIC_AUTH_PASSWORD`	Password for Admin UI login and HTTP Basic authentication	`changeme`	string
`AUTH_REQUIRED`	Require authentication for all API routes	`true`	bool
`JWT_SECRET_KEY`	Secret key used to sign JWT tokens for API access	`my-test-key`	string
`JWT_ALGORITHM`	Algorithm used to sign the JWTs (`HS256` is default, HMAC-based)	`HS256`	PyJWT algs
`TOKEN_EXPIRY`	Expiry of generated JWTs in minutes	`10080`	int > 0
`AUTH_ENCRYPTION_SECRET`	Passphrase used to derive AES key for encrypting tool auth headers	`my-test-salt`	string

🔐 BASIC_AUTH_USER/PASSWORD are used for:

Logging into the web-based Admin UI

Accessing APIs via Basic Auth (curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN")

🔑 JWT_SECRET_KEY is used to:
Sign JSON Web Tokens (Authorization: Bearer <token>)
Generate tokens via:
1
2
export MCPGATEWAY_BEARER_TOKEN=$(python3 -m mcpgateway.utils.create_jwt_token --username admin --exp 0 --secret my-test-key)
echo $MCPGATEWAY_BEARER_TOKEN
Tokens allow non-interactive API clients to authenticate securely.
🧪 Set AUTH_REQUIRED=false during development if you want to disable all authentication (e.g. for local testing or open APIs) or clients that don’t support SSE authentication. In production, you should use the SSE to stdio mcpgateway-wrapper for such tools that don’t support authenticated SSE, while still ensuring the gateway uses authentication.

🔐 AUTH_ENCRYPTION_SECRET is used to encrypt and decrypt tool authentication credentials (auth_value). You must set the same value across environments to decode previously stored encrypted auth values. Recommended: use a long, random string.

UI Features

Setting	Description	Default	Options
`MCPGATEWAY_UI_ENABLED`	Enable the interactive Admin dashboard	`false`	bool
`MCPGATEWAY_ADMIN_API_ENABLED`	Enable API endpoints for admin ops	`false`	bool
`MCPGATEWAY_BULK_IMPORT_ENABLED`	Enable bulk import endpoint for tools	`true`	bool

🖥️ Set both UI and Admin API to false to disable management UI and APIs in production. 📥 The bulk import endpoint allows importing up to 200 tools in a single request via /admin/tools/import.

A2A (Agent-to-Agent) Features

Setting	Description	Default	Options
`MCPGATEWAY_A2A_ENABLED`	Enable A2A agent features	`true`	bool
`MCPGATEWAY_A2A_MAX_AGENTS`	Maximum number of A2A agents allowed	`100`	int
`MCPGATEWAY_A2A_DEFAULT_TIMEOUT`	Default timeout for A2A HTTP requests (seconds)	`30`	int
`MCPGATEWAY_A2A_MAX_RETRIES`	Maximum retry attempts for A2A calls	`3`	int
`MCPGATEWAY_A2A_METRICS_ENABLED`	Enable A2A agent metrics collection	`true`	bool

🤖 A2A Integration: Register external AI agents (OpenAI, Anthropic, custom) and expose them as MCP tools 📊 Metrics: Track agent performance, success rates, and response times 🔒 Security: Encrypted credential storage and configurable authentication 🎛️ Admin UI: Dedicated tab for agent management with test functionality

A2A Configuration Effects:

MCPGATEWAY_A2A_ENABLED=false: Completely disables A2A features (API endpoints return 404, admin tab hidden)
MCPGATEWAY_A2A_METRICS_ENABLED=false: Disables metrics collection while keeping functionality

Security

Setting	Description	Default	Options
`SKIP_SSL_VERIFY`	Skip upstream TLS verification	`false`	bool
`ENVIRONMENT`	Deployment environment (affects security defaults)	`development`	`development`/`production`
`APP_DOMAIN`	Domain for production CORS origins	`localhost`	string
`ALLOWED_ORIGINS`	CORS allow-list	Auto-configured by environment	JSON array
`CORS_ENABLED`	Enable CORS	`true`	bool
`CORS_ALLOW_CREDENTIALS`	Allow credentials in CORS	`true`	bool
`SECURE_COOKIES`	Force secure cookie flags	`true`	bool
`COOKIE_SAMESITE`	Cookie SameSite attribute	`lax`	`strict`/`lax`/`none`
`SECURITY_HEADERS_ENABLED`	Enable security headers middleware	`true`	bool
`X_FRAME_OPTIONS`	X-Frame-Options header value	`DENY`	`DENY`/`SAMEORIGIN`
`HSTS_ENABLED`	Enable HSTS header	`true`	bool
`HSTS_MAX_AGE`	HSTS max age in seconds	`31536000`	int
`REMOVE_SERVER_HEADERS`	Remove server identification	`true`	bool
`DOCS_ALLOW_BASIC_AUTH`	Allow Basic Auth for docs (in addition to JWT)	`false`	bool

CORS Configuration: When ENVIRONMENT=development, CORS origins are automatically configured for common development ports (3000, 8080, gateway port). In production, origins are constructed from APP_DOMAIN (e.g., https://yourdomain.com, https://app.yourdomain.com). You can override this by explicitly setting ALLOWED_ORIGINS.

Security Headers: The gateway automatically adds configurable security headers to all responses including CSP, X-Frame-Options, X-Content-Type-Options, X-Download-Options, and HSTS (on HTTPS). All headers can be individually enabled/disabled. Sensitive server headers are removed.

iframe Embedding: By default, X-Frame-Options: DENY prevents iframe embedding for security. To allow embedding, set X_FRAME_OPTIONS=SAMEORIGIN (same domain) or disable with X_FRAME_OPTIONS="". Also update CSP frame-ancestors directive if needed.

Cookie Security: Authentication cookies are automatically configured with HttpOnly, Secure (in production), and SameSite attributes for CSRF protection.

Note: do not quote the ALLOWED_ORIGINS values, this needs to be valid JSON, such as: ALLOWED_ORIGINS=[“http://localhost”, “http://localhost:4444”]

Documentation endpoints (/docs, /redoc, /openapi.json) are always protected by authentication. By default, they require Bearer token authentication. Setting DOCS_ALLOW_BASIC_AUTH=true enables HTTP Basic Authentication as an additional method using the same credentials as BASIC_AUTH_USER and BASIC_AUTH_PASSWORD.

Logging

MCP Gateway provides flexible logging with stdout/stderr output by default and optional file-based logging. When file logging is enabled, it provides JSON formatting for structured logs and text formatting for console output.

Setting	Description	Default	Options
`LOG_LEVEL`	Minimum log level	`INFO`	`DEBUG`…`CRITICAL`
`LOG_FORMAT`	Console log format	`json`	`json`, `text`
`LOG_TO_FILE`	Enable file logging	`false`	`true`, `false`
`LOG_FILE`	Log filename (when enabled)	`null`	`mcpgateway.log`
`LOG_FOLDER`	Directory for log files	`null`	`logs`, `/var/log/gateway`
`LOG_FILEMODE`	File write mode	`a+`	`a+` (append), `w` (overwrite)
`LOG_ROTATION_ENABLED`	Enable log file rotation	`false`	`true`, `false`
`LOG_MAX_SIZE_MB`	Max file size before rotation (MB)	`1`	Any positive integer
`LOG_BACKUP_COUNT`	Number of backup files to keep	`5`	Any non-negative integer

Logging Behavior:

Default: Logs only to stdout/stderr with human-readable text format
File Logging: When LOG_TO_FILE=true, logs to both file (JSON format) and console (text format)
Log Rotation: When LOG_ROTATION_ENABLED=true, files rotate at LOG_MAX_SIZE_MB with LOG_BACKUP_COUNT backup files (e.g., .log.1, .log.2)
Directory Creation: Log folder is automatically created if it doesn’t exist
Centralized Service: All modules use the unified LoggingService for consistent formatting

Example Configurations:

# Default: stdout/stderr only (recommended for containers)
LOG_LEVEL=INFO
# No additional config needed - logs to stdout/stderr

# Optional: Enable file logging (no rotation)
LOG_TO_FILE=true
LOG_FOLDER=/var/log/mcpgateway
LOG_FILE=gateway.log
LOG_FILEMODE=a+

# Optional: Enable file logging with rotation
LOG_TO_FILE=true
LOG_ROTATION_ENABLED=true
LOG_MAX_SIZE_MB=10
LOG_BACKUP_COUNT=3
LOG_FOLDER=/var/log/mcpgateway
LOG_FILE=gateway.log

Default Behavior:

Logs are written only to stdout/stderr in human-readable text format
File logging is disabled by default (no files created)
Set LOG_TO_FILE=true to enable optional file logging with JSON format

Observability (OpenTelemetry)

MCP Gateway includes vendor-agnostic OpenTelemetry support for distributed tracing. Works with Phoenix, Jaeger, Zipkin, Tempo, DataDog, New Relic, and any OTLP-compatible backend.

Setting	Description	Default	Options
`OTEL_ENABLE_OBSERVABILITY`	Master switch for observability	`true`	`true`, `false`
`OTEL_SERVICE_NAME`	Service identifier in traces	`mcp-gateway`	string
`OTEL_SERVICE_VERSION`	Service version in traces	`0.6.0`	string
`OTEL_DEPLOYMENT_ENVIRONMENT`	Environment tag (dev/staging/prod)	`development`	string
`OTEL_TRACES_EXPORTER`	Trace exporter backend	`otlp`	`otlp`, `jaeger`, `zipkin`, `console`, `none`
`OTEL_RESOURCE_ATTRIBUTES`	Custom resource attributes	(empty)	`key=value,key2=value2`

OTLP Configuration (for Phoenix, Tempo, DataDog, etc.):

Setting	Description	Default	Options
`OTEL_EXPORTER_OTLP_ENDPOINT`	OTLP collector endpoint	(none)	`http://localhost:4317`
`OTEL_EXPORTER_OTLP_PROTOCOL`	OTLP protocol	`grpc`	`grpc`, `http/protobuf`
`OTEL_EXPORTER_OTLP_HEADERS`	Authentication headers	(empty)	`api-key=secret,x-auth=token`
`OTEL_EXPORTER_OTLP_INSECURE`	Skip TLS verification	`true`	`true`, `false`

Alternative Backends (optional):

Setting	Description	Default	Options
`OTEL_EXPORTER_JAEGER_ENDPOINT`	Jaeger collector endpoint	`http://localhost:14268/api/traces`	URL
`OTEL_EXPORTER_ZIPKIN_ENDPOINT`	Zipkin collector endpoint	`http://localhost:9411/api/v2/spans`	URL

Performance Tuning:

Setting	Description	Default	Options
`OTEL_TRACES_SAMPLER`	Sampling strategy	`parentbased_traceidratio`	`always_on`, `always_off`, `traceidratio`
`OTEL_TRACES_SAMPLER_ARG`	Sample rate (0.0-1.0)	`0.1`	float (0.1 = 10% sampling)
`OTEL_BSP_MAX_QUEUE_SIZE`	Max queued spans	`2048`	int > 0
`OTEL_BSP_MAX_EXPORT_BATCH_SIZE`	Max batch size for export	`512`	int > 0
`OTEL_BSP_SCHEDULE_DELAY`	Export interval (ms)	`5000`	int > 0

Quick Start with Phoenix:

# Start Phoenix for LLM observability
docker run -p 6006:6006 -p 4317:4317 arizephoenix/phoenix:latest

# Configure gateway
export OTEL_ENABLE_OBSERVABILITY=true
export OTEL_TRACES_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

# Run gateway - traces automatically sent to Phoenix
mcpgateway

🔍 What Gets Traced: Tool invocations, prompt rendering, resource fetching, gateway federation, health checks, plugin execution (if enabled)

🚀 Zero Overhead: When OTEL_ENABLE_OBSERVABILITY=false, all tracing is disabled with no performance impact

📊 View Traces: Phoenix UI at http://localhost:6006, Jaeger at http://localhost:16686, or your configured backend

Transport

Setting	Description	Default	Options
`TRANSPORT_TYPE`	Enabled transports	`all`	`http`,`ws`,`sse`,`stdio`,`all`
`WEBSOCKET_PING_INTERVAL`	WebSocket ping (secs)	`30`	int > 0
`SSE_RETRY_TIMEOUT`	SSE retry timeout (ms)	`5000`	int > 0
`SSE_KEEPALIVE_ENABLED`	Enable SSE keepalive events	`true`	bool
`SSE_KEEPALIVE_INTERVAL`	SSE keepalive interval (secs)	`30`	int > 0
`USE_STATEFUL_SESSIONS`	streamable http config	`false`	bool
`JSON_RESPONSE_ENABLED`	json/sse streams (streamable http)	`true`	bool

💡 SSE Keepalive Events: The gateway sends periodic keepalive events to prevent connection timeouts with proxies and load balancers. Disable with SSE_KEEPALIVE_ENABLED=false if your client doesn’t handle unknown event types. Common intervals: 30s (default), 60s (AWS ALB), 240s (Azure).

Federation

Setting	Description	Default	Options
`FEDERATION_ENABLED`	Enable federation	`true`	bool
`FEDERATION_DISCOVERY`	Auto-discover peers	`false`	bool
`FEDERATION_PEERS`	Comma-sep peer URLs	`[]`	JSON array
`FEDERATION_TIMEOUT`	Gateway timeout (secs)	`30`	int > 0
`FEDERATION_SYNC_INTERVAL`	Sync interval (secs)	`300`	int > 0

Resources

Setting	Description	Default	Options
`RESOURCE_CACHE_SIZE`	LRU cache size	`1000`	int > 0
`RESOURCE_CACHE_TTL`	Cache TTL (seconds)	`3600`	int > 0
`MAX_RESOURCE_SIZE`	Max resource bytes	`10485760`	int > 0
`ALLOWED_MIME_TYPES`	Acceptable MIME types	see code	JSON array

Tools

Setting	Description	Default	Options
`TOOL_TIMEOUT`	Tool invocation timeout (secs)	`60`	int > 0
`MAX_TOOL_RETRIES`	Max retry attempts	`3`	int ≥ 0
`TOOL_RATE_LIMIT`	Tool calls per minute	`100`	int > 0
`TOOL_CONCURRENT_LIMIT`	Concurrent tool invocations	`10`	int > 0

Prompts

Setting	Description	Default	Options
`PROMPT_CACHE_SIZE`	Cached prompt templates	`100`	int > 0
`MAX_PROMPT_SIZE`	Max prompt template size (bytes)	`102400`	int > 0
`PROMPT_RENDER_TIMEOUT`	Jinja render timeout (secs)	`10`	int > 0

Health Checks

Setting	Description	Default	Options
`HEALTH_CHECK_INTERVAL`	Health poll interval (secs)	`60`	int > 0
`HEALTH_CHECK_TIMEOUT`	Health request timeout (secs)	`10`	int > 0
`UNHEALTHY_THRESHOLD`	Fail-count before peer deactivation,	`3`	int > 0
	Set to -1 if deactivation is not needed.

Database

Setting	Description	Default	Options
`DB_POOL_SIZE` .	SQLAlchemy connection pool size	`200`	int > 0
`DB_MAX_OVERFLOW`.	Extra connections beyond pool	`10`	int ≥ 0
`DB_POOL_TIMEOUT`.	Wait for connection (secs)	`30`	int > 0
`DB_POOL_RECYCLE`.	Recycle connections (secs)	`3600`	int > 0
`DB_MAX_RETRIES` .	Max Retry Attempts	`3`	int > 0
`DB_RETRY_INTERVAL_MS`	Retry Interval (ms)	`2000`	int > 0

Cache Backend

Setting	Description	Default	Options
`CACHE_TYPE`	Backend (`memory`/`redis`)	`memory`	`none`, `memory`,`redis`
`REDIS_URL`	Redis connection URL	(none)	string or empty
`CACHE_PREFIX`	Key prefix	`mcpgw:`	string
`REDIS_MAX_RETRIES`	Max Retry Attempts	`3`	int > 0
`REDIS_RETRY_INTERVAL_MS`	Retry Interval (ms)	`2000`	int > 0

🧠 none disables caching entirely. Use memory for dev, database for persistence, or redis for distributed caching.

Database Management

MCP Gateway uses Alembic for database migrations. Common commands:

make db-current - Show current database version
make db-upgrade - Apply pending migrations
make db-migrate - Create new migration
make db-history - Show migration history
make db-status - Detailed migration status

Troubleshooting

Common Issues:

“No ‘script_location’ key found”: Ensure you’re running from the project root directory.
“Unknown SSE event: keepalive” warnings: Some MCP clients don’t recognize keepalive events. These warnings are harmless and don’t affect functionality. To disable: SSE_KEEPALIVE_ENABLED=false
Connection timeouts with proxies/load balancers: If experiencing timeouts, adjust keepalive interval to match your infrastructure: SSE_KEEPALIVE_INTERVAL=60 (AWS ALB) or 240 (Azure).

Development

Setting	Description	Default	Options
`DEV_MODE`	Enable dev mode	`false`	bool
`RELOAD`	Auto-reload on changes	`false`	bool
`DEBUG`	Debug logging	`false`	bool

Running

Makefile

1
2

 make serve               # Run production Gunicorn server on
 make serve-ssl           # Run Gunicorn behind HTTPS on :4444 (uses ./certs)

Script helper

To run the development (uvicorn) server:

1
2
3

make dev
# or
./run.sh --reload --log debug --workers 2

run.sh is a wrapper around uvicorn that loads .env, supports reload, and passes arguments to the server.

Key flags:

Flag	Purpose	Example
`-e, --env FILE`	load env-file	`--env prod.env`
`-H, --host`	bind address	`--host 127.0.0.1`
`-p, --port`	listen port	`--port 8080`
`-w, --workers`	gunicorn workers	`--workers 4`
`-r, --reload`	auto-reload	`--reload`

Manual (Uvicorn)

`1`	`uvicorn mcpgateway.main:app --host 0.0.0.0 --port 4444 --workers 4`

Authentication examples

# Generate a JWT token using JWT_SECRET_KEY and export it as MCPGATEWAY_BEARER_TOKEN
# Note that the module needs to be installed. If running locally use:
export MCPGATEWAY_BEARER_TOKEN=$(JWT_SECRET_KEY=my-test-key python3 -m mcpgateway.utils.create_jwt_token)

# Use the JWT token in an API call
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/tools

☁️ AWS / Azure / OpenShift

Deployment details can be found in the GitHub Pages.

☁️ IBM Cloud Code Engine Deployment

This project supports deployment to IBM Cloud Code Engine using the ibmcloud CLI and the IBM Container Registry.

☁️ IBM Cloud Code Engine Deployment

🔧 Prerequisites

Podman or Docker installed locally
IBM Cloud CLI (use make ibmcloud-cli-install to install)
An IBM Cloud API key with access to Code Engine & Container Registry
Code Engine and Container Registry services enabled in your IBM Cloud account

📦 Environment Variables

Create a .env file (or export the variables in your shell). The first block is required; the second provides tunable defaults you can override:

# ── Required ─────────────────────────────────────────────
IBMCLOUD_REGION=us-south
IBMCLOUD_RESOURCE_GROUP=default
IBMCLOUD_PROJECT=my-codeengine-project
IBMCLOUD_CODE_ENGINE_APP=mcpgateway
IBMCLOUD_IMAGE_NAME=us.icr.io/myspace/mcpgateway:latest
IBMCLOUD_IMG_PROD=mcpgateway/mcpgateway
IBMCLOUD_API_KEY=your_api_key_here   # Optional - omit to use interactive `ibmcloud login --sso`

# ── Optional overrides (sensible defaults provided) ──────
IBMCLOUD_CPU=1                       # vCPUs for the app
IBMCLOUD_MEMORY=4G                   # Memory allocation
IBMCLOUD_REGISTRY_SECRET=my-regcred  # Name of the Container Registry secret

✅ Quick check: make ibmcloud-check-env

🚀 Make Targets

Target	Purpose
`make ibmcloud-cli-install`	Install IBM Cloud CLI and required plugins
`make ibmcloud-login`	Log in to IBM Cloud (API key or SSO)
`make ibmcloud-ce-login`	Select the Code Engine project & region
`make ibmcloud-tag`	Tag the local container image
`make ibmcloud-push`	Push the image to IBM Container Registry
`make ibmcloud-deploy`	Create or update the Code Engine application (uses CPU/memory/secret)
`make ibmcloud-ce-status`	Show current deployment status
`make ibmcloud-ce-logs`	Stream logs from the running app
`make ibmcloud-ce-rm`	Delete the Code Engine application

📝 Example Workflow

make ibmcloud-check-env
make ibmcloud-cli-install
make ibmcloud-login
make ibmcloud-ce-login
make ibmcloud-tag
make ibmcloud-push
make ibmcloud-deploy
make ibmcloud-ce-status
make ibmcloud-ce-logs

API Endpoints

You can test the API endpoints through curl, or Swagger UI, and check detailed documentation on ReDoc:

Swagger UI → http://localhost:4444/docs
ReDoc → http://localhost:4444/redoc

Generate an API Bearer token, and test the various API endpoints.

🔐 Authentication & Health Checks

# Generate a bearer token using the configured secret key (use the same as your .env)
export MCPGATEWAY_BEARER_TOKEN=$(python3 -m mcpgateway.utils.create_jwt_token -u admin --secret my-test-key)
echo ${MCPGATEWAY_BEARER_TOKEN}

# Quickly confirm that authentication works and the gateway is healthy
curl -s -k -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" https://localhost:4444/health
# {"status":"healthy"}

# Quickly confirm the gateway version & DB connectivity
curl -s -k -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" https://localhost:4444/version | jq

🧱 Protocol APIs (MCP) /protocol

# Initialize MCP session
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "protocol_version":"2025-03-26",
           "capabilities":{},
           "client_info":{"name":"MyClient","version":"1.0.0"}
         }' \
     http://localhost:4444/protocol/initialize

# Ping (JSON-RPC style)
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"jsonrpc":"2.0","id":1,"method":"ping"}' \
     http://localhost:4444/protocol/ping

# Completion for prompt/resource arguments (not implemented)
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "ref":{"type":"ref/prompt","name":"example_prompt"},
           "argument":{"name":"topic","value":"py"}
         }' \
     http://localhost:4444/protocol/completion/complete

# Sampling (streaming) (not implemented)
curl -N -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "messages":[{"role":"user","content":{"type":"text","text":"Hello"}}],
           "maxTokens":16
         }' \
     http://localhost:4444/protocol/sampling/createMessage

🧠 JSON-RPC Utility /rpc

# Generic JSON-RPC calls (tools, gateways, roots, etc.)
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"jsonrpc":"2.0","id":1,"method":"list_tools"}' \
     http://localhost:4444/rpc

Handles any method name: list_tools, list_gateways, prompts/get, or invokes a tool if method matches a registered tool name .

🔧 Tool Management /tools

# Register a new tool
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "name":"clock_tool",
           "url":"http://localhost:9000/rpc",
           "description":"Returns current time",
           "input_schema":{
             "type":"object",
             "properties":{"timezone":{"type":"string"}},
             "required":[]
           }
         }' \
     http://localhost:4444/tools

# List tools
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/tools

# Get tool by ID
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/tools/1

# Update tool
curl -X PUT -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{ "description":"Updated desc" }' \
     http://localhost:4444/tools/1

# Toggle active status
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/tools/1/toggle?activate=false
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/tools/1/toggle?activate=true

# Delete tool
curl -X DELETE -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/tools/1

🤖 A2A Agent Management /a2a

# Register a new A2A agent
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "name":"hello_world_agent",
           "endpoint_url":"http://localhost:9999/",
           "agent_type":"jsonrpc",
           "description":"External AI agent for hello world functionality",
           "auth_type":"api_key",
           "auth_value":"your-api-key",
           "tags":["ai", "hello-world"]
         }' \
     http://localhost:4444/a2a

# List A2A agents
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/a2a

# Get agent by ID
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/a2a/agent-id

# Update agent
curl -X PUT -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{ "description":"Updated description" }' \
     http://localhost:4444/a2a/agent-id

# Test agent (direct invocation)
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "parameters": {
             "method": "message/send",
             "params": {
               "message": {
                 "messageId": "test-123",
                 "role": "user",
                 "parts": [{"type": "text", "text": "Hello!"}]
               }
             }
           },
           "interaction_type": "test"
         }' \
     http://localhost:4444/a2a/agent-name/invoke

# Toggle agent status
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/a2a/agent-id/toggle?activate=false

# Delete agent
curl -X DELETE -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/a2a/agent-id

# Associate agent with virtual server (agents become available as MCP tools)
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "name":"AI Assistant Server",
           "description":"Virtual server with AI agents",
           "associated_a2a_agents":["agent-id"]
         }' \
     http://localhost:4444/servers

🤖 A2A Integration: A2A agents are external AI agents that can be registered and exposed as MCP tools 🔄 Protocol Detection: Gateway automatically detects JSONRPC vs custom A2A protocols 📊 Testing: Built-in test functionality via Admin UI or /a2a/{agent_id}/test endpoint 🎛️ Virtual Servers: Associate agents with servers to expose them as standard MCP tools

🌐 Gateway Management /gateways

# Register an MCP server as a new gateway provider
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"name":"peer_gateway","url":"http://peer:4444"}' \
     http://localhost:4444/gateways

# List gateways
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/gateways

# Get gateway by ID
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/gateways/1

# Update gateway
curl -X PUT -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"description":"New description"}' \
     http://localhost:4444/gateways/1

# Toggle active status
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/gateways/1/toggle?activate=false

# Delete gateway
curl -X DELETE -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/gateways/1

📁 Resource Management /resources

# Register resource
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "uri":"config://app/settings",
           "name":"App Settings",
           "content":"key=value"
         }' \
     http://localhost:4444/resources

# List resources
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/resources

# Read a resource
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/resources/config://app/settings

# Update resource
curl -X PUT -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"content":"new=value"}' \
     http://localhost:4444/resources/config://app/settings

# Delete resource
curl -X DELETE -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/resources/config://app/settings

# Subscribe to updates (SSE)
curl -N -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/resources/subscribe/config://app/settings

📝 Prompt Management /prompts

# Create prompt template
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "name":"greet",
           "template":"Hello, {{ user }}!",
           "argument_schema":{
             "type":"object",
             "properties":{"user":{"type":"string"}},
             "required":["user"]
           }
         }' \
     http://localhost:4444/prompts

# List prompts
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/prompts

# Get prompt (with args)
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"user":"Alice"}' \
     http://localhost:4444/prompts/greet

# Get prompt (no args)
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/prompts/greet

# Update prompt
curl -X PUT -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"template":"Hi, {{ user }}!"}' \
     http://localhost:4444/prompts/greet

# Toggle active
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/prompts/5/toggle?activate=false

# Delete prompt
curl -X DELETE -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/prompts/greet

🌲 Root Management /roots

# List roots
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/roots

# Add root
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"uri":"/data","name":"Data Root"}' \
     http://localhost:4444/roots

# Remove root
curl -X DELETE -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/roots/%2Fdata

# Subscribe to root changes (SSE)
curl -N -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/roots/changes

🖥️ Server Management /servers

# List servers
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/servers

# Get server
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/servers/UUID_OF_SERVER_1

# Create server
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"name":"db","description":"Database","associatedTools": ["1","2","3"]}' \
     http://localhost:4444/servers

# Update server
curl -X PUT -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"description":"Updated"}' \
     http://localhost:4444/servers/UUID_OF_SERVER_1

# Toggle active
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" \
     http://localhost:4444/servers/UUID_OF_SERVER_1/toggle?activate=false

📊 Metrics /metrics

# Get aggregated metrics
curl -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/metrics

# Reset metrics (all or per-entity)
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/metrics/reset
curl -X POST -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/metrics/reset?entity=tool&id=1

📡 Events & Health

# SSE: all events
curl -N -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" http://localhost:4444/events

# WebSocket
wscat -c ws://localhost:4444/ws \
      -H "Authorization: Basic $(echo -n admin:changeme|base64)"

# Health check
curl http://localhost:4444/health

Full Swagger UI at /docs.

🛠️ Sample Tool

`1`	`uvicorn sample_tool.clock_tool:app --host 0.0.0.0 --port 9000`

1
2
3

curl -X POST -H "Content-Type: application/json" \
     -d '{"jsonrpc":"2.0","id":1,"method":"get_time","params":{"timezone":"UTC"}}' \
     http://localhost:9000/rpc

Testing

1
2

make test            # Run unit tests
make lint            # Run lint tools

Doctest Coverage

MCP Context Forge implements comprehensive doctest coverage to ensure all code examples in documentation are tested and verified:

make doctest         # Run all doctests
make doctest-verbose # Run with detailed output
make doctest-coverage # Generate coverage report
make doctest-check   # Check coverage percentage

Coverage Status:

✅ Transport Modules: 100% (base, stdio, SSE, WebSocket, streamable HTTP)
✅ Utility Functions: 100% (slug generation, JWT tokens, validation)
✅ Configuration: 100% (settings, environment variables)
🔄 Service Classes: ~60% (in progress)
🔄 Complex Classes: ~40% (in progress)

Benefits:

All documented examples are automatically tested
Documentation stays accurate and up-to-date
Developers can run examples directly from docstrings
Regression prevention through automated verification

For detailed information, see the Doctest Coverage Guide.

Project Structure

📁 Directory and file structure for mcpgateway

# ────────── CI / Quality & Meta-files ──────────
├── .bumpversion.cfg                # Automated semantic-version bumps
├── .coveragerc                     # Coverage.py settings
├── .darglint                       # Doc-string linter rules
├── .dockerignore                   # Context exclusions for image builds
├── .editorconfig                   # Consistent IDE / editor behaviour
├── .env                            # Local runtime variables (git-ignored)
├── .env.ce                         # IBM Code Engine runtime env (ignored)
├── .env.ce.example                 # Sample env for IBM Code Engine
├── .env.example                    # Generic sample env file
├── .env.gcr                        # Google Cloud Run runtime env (ignored)
├── .eslintrc.json                  # ESLint rules for JS / TS assets
├── .flake8                         # Flake-8 configuration
├── .gitattributes                  # Git attributes (e.g. EOL normalisation)
├── .github                         # GitHub settings, CI/CD workflows & templates
│   ├── CODEOWNERS                  # Default reviewers
│   └── workflows/                  # Bandit, Docker, CodeQL, Python Package, Container Deployment, etc.
├── .gitignore                      # Git exclusion rules
├── .hadolint.yaml                  # Hadolint rules for Dockerfiles
├── .htmlhintrc                     # HTMLHint rules
├── .markdownlint.json              # Markdown-lint rules
├── .pre-commit-config.yaml         # Pre-commit hooks (ruff, black, mypy, ...)
├── .pycodestyle                    # PEP-8 checker settings
├── .pylintrc                       # Pylint configuration
├── .pyspelling.yml                 # Spell-checker dictionary & filters
├── .ruff.toml                      # Ruff linter / formatter settings
├── .spellcheck-en.txt              # Extra dictionary entries
├── .stylelintrc.json               # Stylelint rules for CSS
├── .travis.yml                     # Legacy Travis CI config (reference)
├── .whitesource                    # WhiteSource security-scanning config
├── .yamllint                       # yamllint ruleset

# ────────── Documentation & Guidance ──────────
├── CHANGELOG.md                    # Version-by-version change log
├── CODE_OF_CONDUCT.md              # Community behaviour guidelines
├── CONTRIBUTING.md                 # How to file issues & send PRs
├── DEVELOPING.md                   # Contributor workflows & style guide
├── LICENSE                         # Apache License 2.0
├── README.md                       # Project overview & quick-start
├── SECURITY.md                     # Security policy & CVE disclosure process
├── TESTING.md                      # Testing strategy, fixtures & guidelines

# ────────── Containerisation & Runtime ──────────
├── Containerfile                   # OCI image build (Docker / Podman)
├── Containerfile.lite              # FROM scratch UBI-Micro production build
├── docker-compose.yml              # Local multi-service stack
├── podman-compose-sonarqube.yaml   # One-liner SonarQube stack
├── run-gunicorn.sh                 # Opinionated Gunicorn startup script
├── run.sh                          # Uvicorn shortcut with arg parsing

# ────────── Build / Packaging / Tooling ──────────
├── MANIFEST.in                     # sdist inclusion rules
├── Makefile                        # Dev & deployment targets
├── package-lock.json               # Deterministic npm lock-file
├── package.json                    # Front-end / docs tooling deps
├── pyproject.toml                  # Poetry / PDM config & lint rules
├── sonar-code.properties           # SonarQube analysis settings
├── uv.lock                         # UV resolver lock-file

# ────────── Kubernetes & Helm Assets ──────────
├── charts                          # Helm chart(s) for K8s / OpenShift
│   ├── mcp-stack                   # Umbrella chart
│   │   ├── Chart.yaml              # Chart metadata
│   │   ├── templates/...             # Manifest templates
│   │   └── values.yaml             # Default values
│   └── README.md                   # Install / upgrade guide
├── k8s                             # Raw (non-Helm) K8s manifests
│   └── *.yaml                      # Deployment, Service, PVC resources

# ────────── Documentation Source ──────────
├── docs                            # MkDocs site source
│   ├── base.yml                    # MkDocs "base" configuration snippet (do not modify)
│   ├── mkdocs.yml                  # Site configuration (requires base.yml)
│   ├── requirements.txt            # Python dependencies for the MkDocs site
│   ├── Makefile                    # Make targets for building/serving the docs
│   └── theme                       # Custom MkDocs theme assets
│       └── logo.png                # Logo for the documentation theme
│   └── docs                        # Markdown documentation
│       ├── architecture/           # ADRs for the project
│       ├── articles/               # Long-form writeups
│       ├── blog/                   # Blog posts
│       ├── deployment/             # Deployment guides (AWS, Azure, etc.)
│       ├── development/            # Development workflows & CI docs
│       ├── images/                 # Diagrams & screenshots
│       ├── index.md                # Top-level docs landing page
│       ├── manage/                 # Management topics (backup, logging, tuning, upgrade)
│       ├── overview/               # Feature overviews & UI documentation
│       ├── security/               # Security guidance & policies
│       ├── testing/                # Testing strategy & fixtures
│       └── using/                  # User-facing usage guides (agents, clients, etc.)
│       ├── media/                  # Social media, press coverage, videos & testimonials
│       │   ├── press/              # Press articles and blog posts
│       │   ├── social/             # Tweets, LinkedIn posts, YouTube embeds
│       │   ├── testimonials/       # Customer quotes & community feedback
│       │   └── kit/                # Media kit & logos for bloggers & press
├── dictionary.dic                  # Custom dictionary for spell-checker (make spellcheck)

# ────────── Application & Libraries ──────────
├── agent_runtimes                  # Configurable agentic frameworks converted to MCP Servers
├── mcpgateway                      # ← main application package
│   ├── __init__.py                 # Package metadata & version constant
│   ├── admin.py                    # FastAPI routers for Admin UI
│   ├── cache
│   │   ├── __init__.py
│   │   ├── resource_cache.py       # LRU+TTL cache implementation
│   │   └── session_registry.py     # Session ↔ cache mapping
│   ├── config.py                   # Pydantic settings loader
│   ├── db.py                       # SQLAlchemy models & engine setup
│   ├── federation
│   │   ├── __init__.py
│   │   ├── discovery.py            # Peer-gateway discovery
│   │   ├── forward.py              # RPC forwarding
│   ├── handlers
│   │   ├── __init__.py
│   │   └── sampling.py             # Streaming sampling handler
│   ├── main.py                     # FastAPI app factory & startup events
│   ├── mcp.db                      # SQLite fixture for tests
│   ├── py.typed                    # PEP 561 marker (ships type hints)
│   ├── schemas.py                  # Shared Pydantic DTOs
│   ├── services
│   │   ├── __init__.py
│   │   ├── completion_service.py   # Prompt / argument completion
│   │   ├── gateway_service.py      # Peer-gateway registry
│   │   ├── logging_service.py      # Central logging helpers
│   │   ├── prompt_service.py       # Prompt CRUD & rendering
│   │   ├── resource_service.py     # Resource registration & retrieval
│   │   ├── root_service.py         # File-system root registry
│   │   ├── server_service.py       # Server registry & monitoring
│   │   └── tool_service.py         # Tool registry & invocation
│   ├── static
│   │   ├── admin.css               # Styles for Admin UI
│   │   └── admin.js                # Behaviour for Admin UI
│   ├── templates
│   │   └── admin.html              # HTMX/Alpine Admin UI template
│   ├── transports
│   │   ├── __init__.py
│   │   ├── base.py                 # Abstract transport interface
│   │   ├── sse_transport.py        # Server-Sent Events transport
│   │   ├── stdio_transport.py      # stdio transport for embedding
│   │   └── websocket_transport.py  # WS transport with ping/pong
│   ├── models.py                   # Core enums / type aliases
│   ├── utils
│   │   ├── create_jwt_token.py     # CLI & library for JWT generation
│   │   ├── services_auth.py        # Service-to-service auth dependency
│   │   └── verify_credentials.py   # Basic / JWT auth helpers
│   ├── validation
│   │   ├── __init__.py
│   │   └── jsonrpc.py              # JSON-RPC 2.0 validation
│   └── version.py                  # Library version helper
├── mcpgateway-wrapper              # Stdio client wrapper (PyPI)
│   ├── pyproject.toml
│   ├── README.md
│   └── src/mcpgateway_wrapper/
│       ├── __init__.py
│       └── server.py               # Wrapper entry-point
├── mcp-servers                     # Sample downstream MCP servers
├── mcp.db                          # Default SQLite DB (auto-created)
├── mcpgrid                         # Experimental grid client / PoC
├── os_deps.sh                      # Installs system-level deps for CI

# ────────── Tests & QA Assets ──────────
├── test_readme.py                  # Guard: README stays in sync
├── tests
│   ├── conftest.py                 # Shared fixtures
│   ├── e2e/...                       # End-to-end scenarios
│   ├── hey/...                       # Load-test logs & helper script
│   ├── integration/...               # API-level integration tests
│   └── unit/...                      # Pure unit tests for business logic

API Documentation

Swagger UI → http://localhost:4444/docs
ReDoc → http://localhost:4444/redoc
Admin Panel → http://localhost:4444/admin

Makefile targets

This project offer the following Makefile targets. Type make in the project root to show all targets.

🔧 Available Makefile targets

🐍 MCP CONTEXT FORGE  (An enterprise-ready Model Context Protocol Gateway)
🔧 SYSTEM-LEVEL DEPENDENCIES (DEV BUILD ONLY)
os-deps              - Install Graphviz, Pandoc, Trivy, SCC used for dev docs generation and security scan
🌱 VIRTUAL ENVIRONMENT & INSTALLATION
venv                 - Create a fresh virtual environment with uv & friends
activate             - Activate the virtual environment in the current shell
install              - Install project into the venv
install-dev          - Install project (incl. dev deps) into the venv
install-db           - Install project (incl. postgres and redis) into venv
update               - Update all installed deps inside the venv
check-env            - Verify all required env vars in .env are present
▶️ SERVE & TESTING
serve                - Run production Gunicorn server on :4444
certs                - Generate self-signed TLS cert & key in ./certs (won't overwrite)
serve-ssl            - Run Gunicorn behind HTTPS on :4444 (uses ./certs)
dev                  - Run fast-reload dev server (uvicorn)
run                  - Execute helper script ./run.sh
test                 - Run unit tests with pytest
test-curl            - Smoke-test API endpoints with curl script
pytest-examples      - Run README / examples through pytest-examples
clean                - Remove caches, build artefacts, virtualenv, docs, certs, coverage, SBOM, etc.
📊 COVERAGE & METRICS
coverage             - Run tests with coverage, emit md/HTML/XML + badge
pip-licenses         - Produce dependency license inventory (markdown)
scc                  - Quick LoC/complexity snapshot with scc
scc-report           - Generate HTML LoC & per-file metrics with scc
📚 DOCUMENTATION & SBOM
docs                 - Build docs (graphviz + handsdown + images + SBOM)
images               - Generate architecture & dependency diagrams
🔍 LINTING & STATIC ANALYSIS
lint                 - Run the full linting suite (see targets below)
black                - Reformat code with black
autoflake            - Remove unused imports / variables with autoflake
isort                - Organise & sort imports with isort
flake8               - PEP-8 style & logical errors
pylint               - Pylint static analysis
markdownlint         - Lint Markdown files with markdownlint (requires markdownlint-cli)
mypy                 - Static type-checking with mypy
bandit               - Security scan with bandit
pydocstyle           - Docstring style checker
pycodestyle          - Simple PEP-8 checker
pre-commit           - Run all configured pre-commit hooks
ruff                 - Ruff linter + formatter
ty                   - Ty type checker from astral
pyright              - Static type-checking with Pyright
radon                - Code complexity & maintainability metrics
pyroma               - Validate packaging metadata
importchecker        - Detect orphaned imports
spellcheck           - Spell-check the codebase
fawltydeps           - Detect undeclared / unused deps
wily                 - Maintainability report
pyre                 - Static analysis with Facebook Pyre
depend               - List dependencies in ≈requirements format
snakeviz             - Profile & visualise with snakeviz
pstats               - Generate PNG call-graph from cProfile stats
spellcheck-sort      - Sort local spellcheck dictionary
tox                  - Run tox across multi-Python versions
sbom                 - Produce a CycloneDX SBOM and vulnerability scan
pytype               - Flow-sensitive type checker
check-manifest       - Verify sdist/wheel completeness
yamllint            - Lint YAML files (uses .yamllint)
jsonlint            - Validate every *.json file with jq (--exit-status)
tomllint            - Validate *.toml files with tomlcheck
🕸️  WEBPAGE LINTERS & STATIC ANALYSIS (HTML/CSS/JS lint + security scans + formatting)
install-web-linters  - Install HTMLHint, Stylelint, ESLint, Retire.js & Prettier via npm
lint-web             - Run HTMLHint, Stylelint, ESLint, Retire.js and npm audit
format-web           - Format HTML, CSS & JS files with Prettier
osv-install          - Install/upgrade osv-scanner (Go)
osv-scan-source      - Scan source & lockfiles for CVEs
osv-scan-image       - Scan the built container image for CVEs
osv-scan             - Run all osv-scanner checks (source, image, licence)
📡 SONARQUBE ANALYSIS
sonar-deps-podman    - Install podman-compose + supporting tools
sonar-deps-docker    - Install docker-compose + supporting tools
sonar-up-podman      - Launch SonarQube with podman-compose
sonar-up-docker      - Launch SonarQube with docker-compose
sonar-submit-docker  - Run containerized Sonar Scanner CLI with Docker
sonar-submit-podman  - Run containerized Sonar Scanner CLI with Podman
pysonar-scanner      - Run scan with Python wrapper (pysonar-scanner)
sonar-info           - How to create a token & which env vars to export
🛡️ SECURITY & PACKAGE SCANNING
trivy                - Scan container image for CVEs (HIGH/CRIT). Needs podman socket enabled
grype-scan           - Scan container for security audit and vulnerability scanning
dockle               - Lint the built container image via tarball (no daemon/socket needed)
hadolint             - Lint Containerfile/Dockerfile(s) with hadolint
pip-audit            - Audit Python dependencies for published CVEs
📦 DEPENDENCY MANAGEMENT
deps-update          - Run update-deps.py to update all dependencies in pyproject.toml and docs/requirements.txt
containerfile-update - Update base image in Containerfile to latest tag
📦 PACKAGING & PUBLISHING
dist                 - Clean-build wheel *and* sdist into ./dist
wheel                - Build wheel only
sdist                - Build source distribution only
verify               - Build + twine + check-manifest + pyroma (no upload)
publish              - Verify, then upload to PyPI (needs TWINE_* creds)
🦭 PODMAN CONTAINER BUILD & RUN
podman-dev           - Build development container image
podman               - Build container image
podman-prod          - Build production container image (using ubi-micro → scratch). Not supported on macOS.
podman-run           - Run the container on HTTP  (port 4444)
podman-run-shell     - Run the container on HTTP  (port 4444) and start a shell
podman-run-ssl       - Run the container on HTTPS (port 4444, self-signed)
podman-run-ssl-host  - Run the container on HTTPS with --network=host (port 4444, self-signed)
podman-stop          - Stop & remove the container
podman-test          - Quick curl smoke-test against the container
podman-logs          - Follow container logs (⌃C to quit)
podman-stats         - Show container resource stats (if supported)
podman-top           - Show live top-level process info in container
podman-shell         - Open an interactive shell inside the Podman container
🐋 DOCKER BUILD & RUN
docker-dev           - Build development Docker image
docker               - Build production Docker image
docker-prod          - Build production container image (using ubi-micro → scratch). Not supported on macOS.
docker-run           - Run the container on HTTP  (port 4444)
docker-run-ssl       - Run the container on HTTPS (port 4444, self-signed)
docker-stop          - Stop & remove the container
docker-test          - Quick curl smoke-test against the container
docker-logs          - Follow container logs (⌃C to quit)
docker-stats         - Show container resource usage stats (non-streaming)
docker-top           - Show top-level process info in Docker container
docker-shell         - Open an interactive shell inside the Docker container
🛠️ COMPOSE STACK     - Build / start / stop the multi-service stack
compose-up           - Bring the whole stack up (detached)
compose-restart      - Recreate changed containers, pulling / building as needed
compose-build        - Build (or rebuild) images defined in the compose file
compose-pull         - Pull the latest images only
compose-logs         - Tail logs from all services (Ctrl-C to exit)
compose-ps           - Show container status table
compose-shell        - Open an interactive shell in the "gateway" container
compose-stop         - Gracefully stop the stack (keep containers)
compose-down         - Stop & remove containers (keep named volumes)
compose-rm           - Remove *stopped* containers
compose-clean        - ✨ Down **and** delete named volumes (data-loss ⚠)
☁️ IBM CLOUD CODE ENGINE
ibmcloud-check-env          - Verify all required IBM Cloud env vars are set
ibmcloud-cli-install        - Auto-install IBM Cloud CLI + required plugins (OS auto-detected)
ibmcloud-login              - Login to IBM Cloud CLI using IBMCLOUD_API_KEY (--sso)
ibmcloud-ce-login           - Set Code Engine target project and region
ibmcloud-list-containers    - List deployed Code Engine apps
ibmcloud-tag                - Tag container image for IBM Container Registry
ibmcloud-push               - Push image to IBM Container Registry
ibmcloud-deploy             - Deploy (or update) container image in Code Engine
ibmcloud-ce-logs            - Stream logs for the deployed application
ibmcloud-ce-status          - Get deployment status
ibmcloud-ce-rm              - Delete the Code Engine application
🧪 MINIKUBE LOCAL CLUSTER
minikube-install      - Install Minikube (macOS, Linux, or Windows via choco)
helm-install          - Install Helm CLI (macOS, Linux, or Windows)
minikube-start        - Start local Minikube cluster with Ingress + DNS + metrics-server
minikube-stop         - Stop the Minikube cluster
minikube-delete       - Delete the Minikube cluster
minikube-image-load   - Build and load ghcr.io/ibm/mcp-context-forge:latest into Minikube
minikube-k8s-apply    - Apply Kubernetes manifests from deployment/k8s/
minikube-status       - Show status of Minikube and ingress pods
🛠️ HELM CHART TASKS
helm-lint            - Lint the Helm chart (static analysis)
helm-package         - Package the chart into dist/ as mcp-stack-<ver>.tgz
helm-deploy          - Upgrade/Install chart into Minikube (profile mcpgw)
helm-delete          - Uninstall the chart release from Minikube
🏠 LOCAL PYPI SERVER
local-pypi-install   - Install pypiserver for local testing
local-pypi-start     - Start local PyPI server on :8084 (no auth)
local-pypi-start-auth - Start local PyPI server with basic auth (admin/admin)
local-pypi-stop      - Stop local PyPI server
local-pypi-upload    - Upload existing package to local PyPI (no auth)
local-pypi-upload-auth - Upload existing package to local PyPI (with auth)
local-pypi-test      - Install package from local PyPI
local-pypi-clean     - Full cycle: build → upload → install locally
🏠 LOCAL DEVPI SERVER
devpi-install        - Install devpi server and client
devpi-init           - Initialize devpi server (first time only)
devpi-start          - Start devpi server
devpi-stop           - Stop devpi server
devpi-setup-user     - Create user and dev index
devpi-upload         - Upload existing package to devpi
devpi-test           - Install package from devpi
devpi-clean          - Full cycle: build → upload → install locally
devpi-status         - Show devpi server status
devpi-web            - Open devpi web interface

🔍 Troubleshooting

Port publishing on WSL2 (rootless Podman & Docker Desktop)

Diagnose the listener

1
2
3

# Inside your WSL distro
ss -tlnp | grep 4444        # Use ss
netstat -anp | grep 4444    # or netstat

Seeing :::4444 LISTEN rootlessport is normal - the IPv6 wildcard socket (::) also accepts IPv4 traffic when net.ipv6.bindv6only = 0 (default on Linux).

Why localhost fails on Windows

WSL 2’s NAT layer rewrites only the IPv6 side of the dual-stack listener. From Windows, http://127.0.0.1:4444 (or Docker Desktop’s “localhost”) therefore times-out.

Fix (Podman rootless)

1
2
3

# Inside the WSL distro
echo "wsl" | sudo tee /etc/containers/podman-machine
systemctl --user restart podman.socket

ss should now show 0.0.0.0:4444 instead of :::4444, and the service becomes reachable from Windows and the LAN.

Fix (Docker Desktop > 4.19)

Docker Desktop adds a “WSL integration” switch per-distro. Turn it on for your distro, restart Docker Desktop, then restart the container:

`1`	`docker restart mcpgateway`

Gateway starts but immediately exits ("Failed to read DATABASE_URL")

Copy .env.example to .env first:

`1`	`cp .env.example .env`

Then edit DATABASE_URL, JWT_SECRET_KEY, BASIC_AUTH_PASSWORD, etc. Missing or empty required vars cause a fast-fail at startup.

Contributing

Fork the repo, create a feature branch.
Run make lint and fix any issues.
Keep make test green and 100% coverage.
Open a PR - describe your changes clearly.

See CONTRIBUTING.md for more details.

Changelog

A complete changelog can be found here: CHANGELOG.md

License

Licensed under the Apache License 2.0 - see LICENSE

Core Authors and Maintainers

Mihai Criveti - Distinguished Engineer, Agentic AI

Special thanks to our contributors for helping us improve ContextForge MCP Gateway:

Star History and Project Activity

fastapi_mcp

Sat, 16 Aug 2025 15:26:52 +0800

tadata-org/fastapi_mcp

Built by Tadata

FastAPI-MCP

Expose your FastAPI endpoints as Model Context Protocol (MCP) tools, with Auth!

Features

Authentication built in, using your existing FastAPI dependencies!
FastAPI-native: Not just another OpenAPI -> MCP converter
Zero/Minimal configuration required - just point it at your FastAPI app and it works
Preserving schemas of your request models and response models
Preserve documentation of all your endpoints, just as it is in Swagger
Flexible deployment - Mount your MCP server to the same app, or deploy separately
ASGI transport - Uses FastAPI’s ASGI interface directly for efficient communication

Hosted Solution

If you prefer a managed hosted solution check out tadata.com.

Installation

We recommend using uv, a fast Python package installer:

`1`	`uv add fastapi-mcp`

Alternatively, you can install with pip:

`1`	`pip install fastapi-mcp`

Basic Usage

The simplest way to use FastAPI-MCP is to add an MCP server directly to your FastAPI application:

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

app = FastAPI()

mcp = FastApiMCP(app)

# Mount the MCP server directly to your FastAPI app
mcp.mount()

That’s it! Your auto-generated MCP server is now available at https://app.base.url/mcp.

Documentation, Examples and Advanced Usage

FastAPI-MCP provides comprehensive documentation. Additionaly, check out the examples directory for code samples demonstrating these features in action.

FastAPI-first Approach

FastAPI-MCP is designed as a native extension of FastAPI, not just a converter that generates MCP tools from your API. This approach offers several key advantages:

Native dependencies: Secure your MCP endpoints using familiar FastAPI Depends() for authentication and authorization
ASGI transport: Communicates directly with your FastAPI app using its ASGI interface, eliminating the need for HTTP calls from the MCP to your API
Unified infrastructure: Your FastAPI app doesn’t need to run separately from the MCP server (though separate deployment is also supported)

This design philosophy ensures minimum friction when adding MCP capabilities to your existing FastAPI services.

Development and Contributing

Thank you for considering contributing to FastAPI-MCP! We encourage the community to post Issues and create Pull Requests.

Before you get started, please see our Contribution Guide.

Community

Join MCParty Slack community to connect with other MCP enthusiasts, ask questions, and share your experiences with FastAPI-MCP.

Requirements

Python 3.10+ (Recommended 3.12)
uv

License

mcp-for-beginners

Wed, 06 Aug 2025 15:36:21 +0800

microsoft/mcp-for-beginners

Follow these steps to get started using these resources:

Fork the Repository: Click
Clone the Repository: git clone https://github.com/microsoft/mcp-for-beginners.git
Join The Azure AI Foundry Discord and meet experts and fellow developers

🌐 Multi-Language Support

Supported via GitHub Action (Automated & Always Up-to-Date)

🚀 Model Context Protocol (MCP) Curriculum for Beginners

Learn MCP with Hands-on Code Examples in C#, Java, JavaScript, Python, and TypeScript

🧠 Overview of the Model Context Protocol Curriculum

The Model Context Protocol (MCP) is a cutting-edge framework designed to standardize interactions between AI models and client applications. This open-source curriculum offers a structured learning path, complete with practical coding examples and real-world use cases, across popular programming languages including C#, Java, JavaScript, TypeScript, and Python.

Whether you’re an AI developer, system architect, or software engineer, this guide is your comprehensive resource for mastering MCP fundamentals and implementation strategies.

🔗 Official MCP Resources

📘 MCP Documentation – Detailed tutorials and user guides
📜 MCP Specification – Protocol architecture and technical references
📜 Original MCP Specification – Legacy technical references (may contain additional details)
🧑‍💻 MCP GitHub Repository – Open-source SDKs, tools, and code samples
🌐 MCP Community – Join discussions and contribute to the community

Join us for MCP Dev Days 29-30th July 2025

Get ready for two days of deep technical insight, community connection, and hands-on learning at MCP Dev Days, a virtual event dedicated to the Model Context Protocol (MCP) — the emerging standard that bridges AI models and the tools they rely on.

➡️ Register for MCP Dev Days

You can watch MCP Dev Days by registering on our event page: https://aka.ms/mcpdevdays. From there, you’ll be able to join a live stream on YouTube or Twitch. All of the content is recorded and will be available afterwards on the Microsoft Developer YouTube channel. Source code for the demos will be available on GitHub too.

Event Details

Dates: July 29 (Day 1) & July 30 (Day 2)
Time: 9:00 AM PST daily
Where: Online – join from anywhere!

Day 1: MCP Productivity, DevTools, & Community:

Is all about empowering developers to use MCP in their developer workflow and celebrating the amazing MCP community. We’ll be joined with community members and partners such as Arcade, Block, Okta, and Neon to see how they are collaborating with Microsoft to shape an open, extensible MCP ecosystem. Real-world demos across VS Code, Visual Studio, GitHub Copilot, and popular community tools Practical, context-driven dev workflows Community-led sessions and insights Whether you’re just getting started with MCP or already building with it, Day 1 will set the stage with inspiration and actionable takeaways.

Day 2: Build MCP Servers with Confidence

Is for MCP builders. We’ll go deep into implementation strategies and best practices for creating MCP servers and integrating MCP into your AI workflows.

Topics include:

Building MCP Servers and integrating them into agent experiences
Prompt-driven development
Security best practices
Using building blocks like Functions, ACA, and API Management
Registry alignment and tooling (1P + 3P)

If you’re a developer, tool builder, or AI product strategist, this day is packed with the insights you need to build scalable, secure, and future-ready MCP solutions.

🧭 MCP Curriculum Overview

📚 Complete Curriculum Structure

Module	Topic	Description	Link
Module 1-3: Fundamentals
00	Introduction to MCP	Overview of the Model Context Protocol and its significance in AI pipelines	Read more
01	Core Concepts Explained	In-depth exploration of core MCP concepts	Read more
02	Security in MCP	Security threats and best practices	Read more
03	Getting Started with MCP	Environment setup, basic servers/clients, integration	Read more
Module 3: Building Your First Server & Client
3.1	First Server	Create your first MCP server	Guide
3.2	First Client	Develop a basic MCP client	Guide
3.3	Client with LLM	Integrate large language models	Guide
3.4	VS Code Integration	Consume MCP servers in VS Code	Guide
3.5	SSE Server	Create servers using Server-Sent Events	Guide
3.6	HTTP Streaming	Implement HTTP streaming in MCP	Guide
3.7	AI Toolkit	Use AI Toolkit with MCP	Guide
3.8	Testing	Test your MCP server implementation	Guide
3.9	Deployment	Deploy MCP servers to production	Guide
Module 4-5: Practical & Advanced
04	Practical Implementation	SDKs, debugging, testing, reusable prompt templates	Read more
05	Advanced Topics in MCP	Multi-modal AI, scaling, enterprise use	Read more
5.1	Azure Integration	MCP Integration with Azure	Guide
5.2	Multi-modality	Working with multiple modalities	Guide
5.3	OAuth2 Demo	Implement OAuth2 authentication	Guide
5.4	Root Contexts	Understand and implement root contexts	Guide
5.5	Routing	MCP routing strategies	Guide
5.6	Sampling	Sampling techniques in MCP	Guide
5.7	Scaling	Scale MCP implementations	Guide
5.8	Security	Advanced security considerations	Guide
5.9	Web Search	Implement web search capabilities	Guide
5.10	Realtime Streaming	Build realtime streaming functionality	Guide
5.11	Realtime Search	Implement realtime search	Guide
5.12	Entra ID Auth	Authentication with Microsoft Entra ID	Guide
5.13	Foundry Integration	Integrate with Azure AI Foundry	Guide
5.14	Context Engineering	Techniques for effective context engineering	Guide
Module 6-10: Community & Best Practices
06	Community Contributions	How to contribute to the MCP ecosystem	Guide
07	Insights from Early Adoption	Real-world implementation stories	Guide
08	Best Practices for MCP	Performance, fault-tolerance, resilience	Guide
09	MCP Case Studies	Practical implementation examples	Guide
10	Hands-on Workshop	Building an MCP Server with AI Toolkit	Lab

💻 Sample Code Projects

Basic MCP Calculator Samples

Language	Description	Link
C#	MCP Server Example	View Code
Java	MCP Calculator	View Code
JavaScript	MCP Demo	View Code
Python	MCP Server	View Code
TypeScript	MCP Example	View Code

Advanced MCP Implementations

Language	Description	Link
C#	Advanced Sample	View Code
Java	Container App Example	View Code
JavaScript	Advanced Sample	View Code
Python	Complex Implementation	View Code
TypeScript	Container Sample	View Code

🎯 Prerequisites for Learning MCP

To get the most out of this curriculum, you should have:

Basic knowledge of programming in at least one of the following languages: C#, Java, JavaScript, Python, or TypeScript
Understanding of client-server model and APIs
Familiarity with REST and HTTP concepts
(Optional) Background in AI/ML concepts
Joining our community discussions for support

📚 Study Guide & Resources

This repository includes several resources to help you navigate and learn effectively:

Study Guide

A comprehensive Study Guide is available to help you navigate this repository effectively. The guide includes:

A visual curriculum map showing all topics covered
Detailed breakdown of each repository section
Guidance on how to use sample projects
Recommended learning paths for different skill levels
Additional resources to complement your learning journey

Changelog

We maintain a detailed Changelog that tracks all significant updates to the curriculum materials, including:

New content additions
Structural changes
Feature improvements
Documentation updates

🛠️ How to Use This Curriculum Effectively

Each lesson in this guide includes:

Clear explanations of MCP concepts
Live code examples in multiple languages
Exercises to build real MCP applications
Extra resources for advanced learners

🌟 Community Thanks

Thanks to Microsoft Valued Professional Shivam Goyal for contributing important code samples.

📜 License Information

This content is licensed under the MIT License. For terms and conditions, see the LICENSE.

🤝 Contribution Guidelines

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.

When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

📂 Repository Structure

The repository is organized as follows:

Core Curriculum (00-10): The main content organized in ten sequential modules
images/: Diagrams and illustrations used throughout the curriculum
translations/: Multi-language support with automated translations
translated_images/: Localized versions of diagrams and illustrations
study_guide.md: Comprehensive guide to navigating the repository
changelog.md: Record of all significant changes to the curriculum materials
mcp.json: Configuration file for MCP specification
CODE_OF_CONDUCT.md, LICENSE, SECURITY.md, SUPPORT.md: Project governance documents

🎒 Other Courses

Our team produces other courses! Check out:

™️ Trademark Notice

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft’s Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos is subject to those third-parties’ policies.

awesome-claude-code

Wed, 23 Jul 2025 15:36:28 +0800

hesreallyhim/awesome-claude-code

 █████┐ ██┐    ██┐███████┐███████┐ ██████┐ ███┐   ███┐███████┐
██┌──██┐██│    ██│██┌────┘██┌────┘██┌───██┐████┐ ████│██┌────┘
███████│██│ █┐ ██│█████┐  ███████┐██│   ██│██┌████┌██│█████┐
██┌──██│██│███┐██│██┌──┘  └────██│██│   ██│██│└██┌┘██│██┌──┘
██│  ██│└███┌███┌┘███████┐███████│└██████┌┘██│ └─┘ ██│███████┐
└─┘  └─┘ └──┘└──┘ └──────┘└──────┘ └─────┘ └─┘     └─┘└──────┘

 ────────────────────────────────────────────────────────────────────────────────────

 ██████┐██┐      █████┐ ██┐   ██┐██████┐ ███████┐     ██████┐ ██████┐ ██████┐ ███████┐
██┌────┘██│     ██┌──██┐██│   ██│██┌──██┐██┌────┘    ██┌────┘██┌───██┐██┌──██┐██┌────┘
██│     ██│     ███████│██│   ██│██│  ██│█████┐      ██│     ██│   ██│██│  ██│█████┐
██│     ██│     ██┌──██│██│   ██│██│  ██│██┌──┘      ██│     ██│   ██│██│  ██│██┌──┘
└██████┐███████┐██│  ██│└██████┌┘██████┌┘███████┐    └██████┐└██████┌┘██████┌┘███████┐
 └─────┘└──────┘└─┘  └─┘ └─────┘ └─────┘ └──────┘     └─────┘ └─────┘ └─────┘ └──────┘

This is a curated list of slash-commands, CLAUDE.md files, CLI tools, and other resources and guides for enhancing your Claude Code workflow, productivity, and vibes.

Claude Code is a cutting-edge CLI-based coding assistant and agent that you can access in your terminal or IDE. It is a rapidly evolving tool that offers a number of powerful capabilities, and allows for a lot of configuration, in a lot of different ways. Users are actively working out best practices and workflows. It is the hope that this repo will help the community share knowledge and understand how to get the most out of Claude Code.

Announcements

2025-07-18 - I ended up over-engineering the submission workflow, but I think it’s done, I just have to smoke test it and update the docs. For anyone with existing PR’s, don’t worry about updating them (for formatting purposes, that is), I can take care of it myself. For anoyne with new PR’s, you should be able to run make submit from the root directory of your fork for an interactive experience (as I said, needs smoke testing) - alternatively, add your entry to the bottom of THE_RESOURCES_TABLE and run make generate to automatically update the README.md based on the information you filled in. If it’s not working, just open a PR with the relevant information and I’ll deal with it, I created this mess anyway 😃.

▪     Workflows & Knowledge Guides
▪     Tooling
          ▫     IDE Integrations
▪     Hooks
▪     Slash-Commands
          ▫     Version Control & Git
          ▫     Code Analysis & Testing
          ▫     Context Loading & Priming
          ▫     Documentation & Changelogs
          ▫     CI / Deployment
          ▫     Project & Task Management
          ▫     Miscellaneous
▪     CLAUDE.md Files
          ▫     Language-Specific
          ▫     Domain-Specific
          ▫     Project Scaffolding & MCP
▪     Official Documentation

Workflows & Knowledge Guides 🧠

A workflow is a tightly coupled set of Claude Code-native resources that facilitate specific projects

Blogging Platform Instructions by cloudartisan ⚖️ CC-BY-SA-4.0
Provides a well-structured set of commands for publishing and maintaining a blogging platform, including commands for creating posts, managing categories, and handling media files.

ClaudeLog by InventorBlack
A comprehensive knowledge repository that features detailed breakdowns of advanced Claude Code mechanics including CLAUDE.md best practices, practical technique guides like plan mode, and a configuration guide.

Context Priming by disler
Provides a systematic approach to priming Claude Code with comprehensive project context through specialized commands for different project scenarios and development contexts.

n8n_agent by kingler
Amazing comprehensive set of comments for code analysis, QA, design, documentation, project structure, project management, optimization, and many more.

Project Bootstrapping and Task Management by steadycursor
Provides a structured set of commands for bootstrapping and managing a new project, including meta-commands for creating and editing custom slash-commands.

Project Management, Implementation, Planning, and Release by scopecraft
Really comprehensive set of commands for all aspects of SDLC.

Project Workflow System by harperreed
A set of commands that provide a comprehensive workflow system for managing projects, including task management, code review, and deployment processes.

Shipping Real Code w/ Claude by Diwank
A detailed blog post explaining the author’s process for shipping a product with Claude Code, including CLAUDE.md files and other interesting resources.

Simone by Helmi ⚖️ MIT
A broader project management workflow for Claude Code that encompasses not just a set of commands, but a system of documents, guidelines, and processes to facilitate project planning and execution.

Slash-commands megalist by wcygan
A pretty stunning list (88 at the time of this post!) of slash-commands ranging from agent orchestration, code review, project management, security, documentation, self-assessment, almost anything you can dream of.

Tooling 🧰

Tooling denotes applications that are built on top of Claude Code and consist of more components than slash-commands and CLAUDE.md files

CC Usage by ryoppippi ⚖️ MIT
Handy CLI tool for managing and analyzing Claude Code usage, based on analyzing local Claude Code logs. Presents a nice dashboard regarding cost information, token consumption, etc.

ccexp by nyatinte ⚖️ MIT
Interactive CLI tool for discovering and managing Claude Code configuration files and slash commands with a beautiful terminal UI.

Claude Code Flow by ruvnet ⚖️ MIT
This mode serves as a code-first orchestration layer, enabling Claude to write, edit, test, and optimize code autonomously across recursive agent cycles.

Claude Composer by Mike Bannister ⚖️ Unlicense
A tool that adds small enhancements to Claude Code.

Claude Hub by Claude Did This
A webhook service that connects Claude Code to GitHub repositories, enabling AI-powered code assistance directly through pull requests and issues. This integration allows Claude to analyze repositories, answer technical questions, and help developers understand and improve their codebase through simple @mentions.

Claude Squad by smtg-ai ⚖️ AGPL-3.0
Claude Squad is a terminal app that manages multiple Claude Code, Codex (and other local agents including Aider) in separate workspaces, allowing you to work on multiple tasks simultaneously.

Claude Swarm by parruda ⚖️ MIT
Launch Claude Code session that is connected to a swarm of Claude Code Agents.

Claude Task Master by eyaltoledano ⚖️ NOASSERTION
A task management system for AI-driven development with Claude, designed to work seamlessly with Cursor AI.

Claude Task Runner by grahama1970
A specialized tool to manage context isolation and focused task execution with Claude Code, solving the critical challenge of context length limitations and task focus when working with Claude on complex, multi-step projects.

Container Use by dagger ⚖️ Apache-2.0
Development environments for coding agents. Enable multiple agents to work safely and independently with your preferred stack.

IDE Integrations

claude-code.el by stevemolitor ⚖️ Apache-2.0
An Emacs interface for Claude Code CLI.

claude-code.nvim by greggh ⚖️ MIT
A seamless integration between Claude Code AI assistant and Neovim.

crystal by stravu ⚖️ MIT
A full-fledged desktop application for orchestrating, monitoring, and interacting with Claude Code agents.

Hooks 🪝

Hooks are a brand new API for Claude Code that allows users to activate commands and run scripts at different points in Claude’s agentic lifecycle.

[Experimental] - The resources listed in this section have not been fully vetted and may not work as expected, given the bleeding-edge nature of Claude Code hooks. Nevertheless, I wished to include them at least as a source of inspiration and to explore this unknown terrain. YMMV!

claude-code-hooks-sdk by beyondcode ⚖️ MIT
A Laravel-inspired PHP SDK for building Claude Code hook responses with a clean, fluent API. This SDK makes it easy to create structured JSON responses for Claude Code hooks using an expressive, chainable interface.

claude-hooks by John Lindquist ⚖️ MIT
A TypeScript-based system for configuring and customizing Claude Code hooks with a powerful and flexible interface.

Linting, testing, and notifications (in go) by Josh Symonds ⚖️ MIT
Nice set of hooks for enforcing code quality (linting, testing, notifications), with a nice configuration setup as well.

TDD Guard by Nizar Selander ⚖️ MIT
A hooks-driven system that monitors file operations in real-time and blocks changes that violate TDD principles.

Slash-Commands 🔪

Version Control & Git

/bug-fix by danielscholl
Streamlines bug fixing by creating a GitHub issue first, then a feature branch for implementing and thoroughly testing the solution before merging.

/commit by evmts ⚖️ MIT
Creates git commits using conventional commit format with appropriate emojis, following project standards and creating descriptive messages that explain the purpose of changes.

/commit-fast by steadycursor
Automates git commit process by selecting the first suggested message, generating structured commits with consistent formatting while skipping manual confirmation and removing Claude co-Contributorship footer

/create-pr by toyamarinyon ⚖️ Apache-2.0
Streamlines pull request creation by handling the entire workflow: creating a new branch, committing changes, formatting modified files with Biome, and submitting the PR.

/create-pull-request by liam-hq ⚖️ Apache-2.0
Provides comprehensive PR creation guidance with GitHub CLI, enforcing title conventions, following template structure, and offering concrete command examples with best practices.

/create-worktrees by evmts ⚖️ MIT
Creates git worktrees for all open PRs or specific branches, handling branches with slashes, cleaning up stale worktrees, and supporting custom branch creation for development.

/fix-github-issue by jeremymailen ⚖️ Apache-2.0
Analyzes and fixes GitHub issues using a structured approach with GitHub CLI for issue details, implementing necessary code changes, running tests, and creating proper commit messages.

/fix-issue by metabase ⚖️ NOASSERTION
Addresses GitHub issues by taking issue number as parameter, analyzing context, implementing solution, and testing/validating the fix for proper integration.

/fix-pr by metabase ⚖️ NOASSERTION
Fetches and fixes unresolved PR comments by automatically retrieving feedback, addressing reviewer concerns, making targeted code improvements, and streamlining the review process.

/husky by evmts ⚖️ MIT
Sets up and manages Husky Git hooks by configuring pre-commit hooks, establishing commit message standards, integrating with linting tools, and ensuring code quality on commits.

/pr-review by arkavo-org ⚖️ MIT
Reviews pull request changes to provide feedback, check for issues, and suggest improvements before merging into the main codebase.

/update-branch-name by giselles-ai ⚖️ Apache-2.0
Updates branch names with proper prefixes and formats, enforcing naming conventions, supporting semantic prefixes, and managing remote branch updates.

Code Analysis & Testing

/check by rygwdn
Performs comprehensive code quality and security checks, featuring static analysis integration, security vulnerability scanning, code style enforcement, and detailed reporting.

/clean by Graphlet-AI ⚖️ Apache-2.0
Addresses code formatting and quality issues by fixing black formatting problems, organizing imports with isort, resolving flake8 linting issues, and correcting mypy type errors.

/code_analysis by kingler
Provides a menu of advanced code analysis commands for deep inspection, including knowledge graph generation, optimization suggestions, and quality evaluation.

/optimize by to4iki ⚖️ MIT
Analyzes code performance to identify bottlenecks, proposing concrete optimizations with implementation guidance for improved application performance.

/repro-issue by rzykov ⚖️ NOASSERTION
Creates reproducible test cases for GitHub issues, ensuring tests fail reliably and documenting clear reproduction steps for developers.

/tdd by zscott
Guides development using Test-Driven Development principles, enforcing Red-Green-Refactor discipline, integrating with git workflow, and managing PR creation.

Context Loading & Priming

/context-prime by elizaOS ⚖️ MIT
Primes Claude with comprehensive project understanding by loading repository structure, setting development context, establishing project goals, and defining collaboration parameters.

/initref by okuvshynov ⚖️ MIT
Initializes reference documentation structure with standard doc templates, API reference setup, documentation conventions, and placeholder content generation.

/load-llms-txt by ethpandaops ⚖️ MIT
Loads LLM configuration files to context, importing specific terminology, model configurations, and establishing baseline terminology for AI discussions.

/load_coo_context by Mjvolk3
References specific files for sparse matrix operations, explains transform usage, compares with previous approaches, and sets data formatting context for development.

/load_dango_pipeline by Mjvolk3
Sets context for model training by referencing pipeline files, establishing working context, and preparing for pipeline work with relevant documentation.

/prime by yzyydev
Sets up initial project context by viewing directory structure and reading key files, creating standardized context with directory visualization and key documentation focus.

/rsi by ddisisto
Reads all commands and key project files to optimize AI-assisted development by streamlining the process, loading command context, and setting up for better development workflow.

Documentation & Changelogs

/add-to-changelog by berrydev-ai ⚖️ MIT
Adds new entries to changelog files while maintaining format consistency, properly documenting changes, and following established project standards for version tracking.

/create-docs by jerseycheese ⚖️ MIT
Analyzes code structure and purpose to create comprehensive documentation detailing inputs/outputs, behavior, user interaction flows, and edge cases with error handling.

/docs by slunsford
Generates comprehensive documentation that follows project structure, documenting APIs and usage patterns with consistent formatting for better user understanding.

/explain-issue-fix by hackdays-io
Documents solution approaches for GitHub issues, explaining technical decisions, detailing challenges overcome, and providing implementation context for better understanding.

/update-docs by Consiliency ⚖️ MIT
Reviews current documentation status, updates implementation progress, reviews phase documents, and maintains documentation consistency across the project.

CI / Deployment

/release by kelp ⚖️ MIT
Manages software releases by updating changelogs, reviewing README changes, evaluating version increments, and documenting release changes for better version tracking.

/run-ci by hackdays-io
Activates virtual environments, runs CI-compatible check scripts, iteratively fixes errors, and ensures all tests pass before completion.

Project & Task Management

/create-command by scopecraft
Guides Claude through creating new custom commands with proper structure by analyzing requirements, templating commands by category, enforcing command standards, and creating supporting documentation.

/create-jtbd by taddyorg ⚖️ AGPL-3.0
Creates Jobs-to-be-Done frameworks that outline user needs with structured format, focusing on specific user problems and organizing by job categories for product development.

/create-prd by taddyorg ⚖️ AGPL-3.0
Generates comprehensive product requirement documents outlining detailed specifications, requirements, and features following standardized document structure and format.

/create-prp by Wirasm ⚖️ MIT
Creates product requirement plans by reading PRP methodology, following template structure, creating comprehensive requirements, and structuring product definitions for development.

/project_hello_w_name by disler
Creates customizable greeting components with name input, demonstrating argument passing, component reusability, state management, and user input handling.

/todo by chrisleyva ⚖️ MIT
A convenient command to quickly manage project todo items without leaving the Claude Code interface, featuring due dates, sorting, task prioritization, and comprehensive todo list management.

Miscellaneous

/five by TuckerTucker
Applies the “five whys” methodology to perform root cause analysis, identify underlying issues, and create solution approaches for complex problems.

/fixing_go_in_graph by Mjvolk3
Focuses on Gene Ontology annotation integration in graph databases, handling multiple data sources, addressing graph representation issues, and ensuring correct data incorporation.

/mermaid by GaloyMoney ⚖️ NOASSERTION
Generates Mermaid diagrams from SQL schema files, creating entity relationship diagrams with table properties, validating diagram compilation, and ensuring complete entity coverage.

/review_dcell_model by Mjvolk3
Reviews old Dcell implementation files, comparing with newer Dango model, noting changes over time, and analyzing refactoring approaches for better code organization.

/use-stepper by zuplo
Reformats documentation to use React Stepper component, transforming heading formats, applying proper indentation, and maintaining markdown compatibility with admonition formatting.

CLAUDE.md Files 📂

CLAUDE.md files are files that contain important guidelines and context-specfic information or instructions that help Claude Code to better understand your project and your coding standards

Language-Specific

AI IntelliJ Plugin by didalgolab ⚖️ Apache-2.0
Provides comprehensive Gradle commands for IntelliJ plugin development with platform-specific coding patterns, detailed package structure guidelines, and clear internationalization standards.

AWS MCP Server by alexei-led ⚖️ MIT
Features multiple Python environment setup options with detailed code style guidelines, comprehensive error handling recommendations, and security considerations for AWS CLI interactions.

DroidconKotlin by touchlab ⚖️ Apache-2.0
Delivers comprehensive Gradle commands for cross-platform Kotlin Multiplatform development with clear module structure and practical guidance for dependency injection.

EDSL by expectedparrot ⚖️ MIT
Offers detailed build and test commands with strict code style enforcement, comprehensive testing requirements, and standardized development workflow using Black and mypy.

Giselle by giselles-ai ⚖️ Apache-2.0
Provides detailed build and test commands using pnpm and Vitest with strict code formatting requirements and comprehensive naming conventions for code consistency.

HASH by hashintel ⚖️ NOASSERTION
Features comprehensive repository structure breakdown with strong emphasis on coding standards, detailed Rust documentation guidelines, and systematic PR review process.

Inkline by inkline ⚖️ NOASSERTION
Structures development workflow using pnpm with emphasis on TypeScript and Vue 3 Composition API, detailed component creation process, and comprehensive testing recommendations.

JSBeeb by mattgodbolt ⚖️ GPL-3.0
Provides development guide for JavaScript BBC Micro emulator with build and testing instructions, architecture documentation, and debugging workflows.

Lamoom Python by LamoomAI ⚖️ Apache-2.0
Serves as reference for production prompt engineering library with load balancing of AI Models, API documentation, and usage patterns with examples.

LangGraphJS by langchain-ai ⚖️ MIT
Offers comprehensive build and test commands with detailed TypeScript style guidelines, layered library architecture, and monorepo structure using yarn workspaces.

Metabase by metabase ⚖️ NOASSERTION
Details workflow for REPL-driven development in Clojure/ClojureScript with emphasis on incremental development, testing, and step-by-step approach for feature implementation.

SG Cars Trends Backend by sgcarstrends
Provides comprehensive structure for TypeScript monorepo projects with detailed commands for development, testing, deployment, and AWS/Cloudflare integration.

SPy by spylang ⚖️ MIT
Enforces strict coding conventions with comprehensive testing guidelines, multiple code compilation options, and backend-specific test decorators for targeted filtering.

TPL by KarpelesLab ⚖️ MIT
Details Go project conventions with comprehensive error handling recommendations, table-driven testing approach guidelines, and modernization suggestions for latest Go features.

Domain-Specific

AVS Vibe Developer Guide by Layr-Labs ⚖️ MIT
Structures AI-assisted EigenLayer AVS development workflow with consistent naming conventions for prompt files and established terminology standards for blockchain concepts.

Comm by CommE2E ⚖️ BSD-3-Clause
Serves as a development reference for E2E-encrypted messaging applications with code organization architecture, security implementation details, and testing procedures.

Course Builder by badass-courses ⚖️ MIT
Enables real-time multiplayer capabilities for collaborative course creation with diverse tech stack integration and monorepo architecture using Turborepo.

Cursor Tools by eastlondoner ⚖️ MIT
Creates a versatile AI command interface supporting multiple providers and models with flexible command options and browser automation through “Stagehand” feature.

Guitar by soramimi ⚖️ GPL-2.0
Serves as development guide for Guitar Git GUI Client with build commands for various platforms, code style guidelines for contributing, and project structure explanation.

Network Chronicles by Fimeg ⚖️ MIT
Presents detailed implementation plan for AI-driven game characters with technical specifications for LLM integration, character guidelines, and service discovery mechanics.

Note Companion by different-ai ⚖️ MIT
Provides detailed styling isolation techniques for Obsidian plugins using Tailwind with custom prefix to prevent style conflicts and practical troubleshooting steps.

Pareto Mac by ParetoSecurity ⚖️ GPL-3.0
Serves as development guide for Mac security audit tool with build instructions, contribution guidelines, testing procedures, and workflow documentation.

SteadyStart by steadycursor
Clear and direct instructives about style, permissions, Claude’s “role”, communications, and documentation of Claude Code sessions for other team members to stay abreast.

Project Scaffolding & MCP

Basic Memory by basicmachines-co ⚖️ AGPL-3.0
Presents an innovative AI-human collaboration framework with Model Context Protocol for bidirectional LLM-markdown communication and flexible knowledge structure for complex projects.

claude-code-mcp-enhanced by grahama1970 ⚖️ MIT
Provides detailed and emphatic instructions for Claude to follow as a coding agent, with testing guidance, code examples, and compliance checks.

Perplexity MCP by Family-IT-Guy ⚖️ ISC
Offers clear step-by-step installation instructions with multiple configuration options, detailed troubleshooting guidance, and concise architecture overview of the MCP protocol.

Official Documentation 🏛️

Links to some of Anthropic’s terrific documentation and resources regarding Claude Code

Anthropic Documentation by Anthropic ⚖️ ©
The official documentation for Claude Code, including installation instructions, usage guidelines, API references, tutorials, examples, loads of information that I won’t list individually. Like Claude Code, the documentation is frequently updated.

Anthropic Quickstarts by Anthropic ⚖️ MIT
Offers comprehensive development guides for three distinct AI-powered demo projects with standardized workflows, strict code style guidelines, and containerization instructions.

Contributing 🌻

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Regarding content, we especially welcome:

Proven, effective resources that follow best practices and may even be in use in production.
Innovative, creative, or experimental workflows that perhaps are still being iterated upon, but have high potential value, and push the boundaries of Claude Code’s documented capabilities and use cases.
Additional libraries and tooling that are built on top of Claude Code and offer enhanced functionality.
Applications of Claude Code outside of the traditional “coding assistant” context, e.g., CI/CD integration, testing, documentation, dev-ops, etc.

See CONTRIBUTING.md for more information on how to contribute to this project. Or, fire up Claude Code and invoke the /project:add-new-resource command and let Claude walk you through it!

If you have any suggestions or thoughts on how to improve the repo, or how to best organize the list, feel free to start a Discussion topic. This is meant to be for the Claude Code community, and in general I prefer not to act on sole authority.

A note about licenses

Because simply listing a hyperlink does not qualify as redistribution, the license of the original source is not relevant to its inclusion. However, for posterity and convenience, we do host copies of all resources whose license permits it. Therefore, please include information about the resource’s license. Additionally, take note: if you do not include a LICENSE in your GitHub repo, then by default it is fully copyrighted and redistribution is not allowed. So, if you are intending to make an open source project, it’s critical to pick from one of the many available open source licenses. This is just a reminder that without a LICENSE, your project is not open source (it’s merely source-code-available) - it may of course still be included on this list, but this notice is to inform readers about the default rules regarding GitHub and LICENSE files. See here for more details.

servers

Wed, 11 Jun 2025 15:30:18 +0800

modelcontextprotocol/servers

Model Context Protocol servers

This repository is a collection of reference implementations for the Model Context Protocol (MCP), as well as references to community built servers and additional resources.

The servers in this repository showcase the versatility and extensibility of MCP, demonstrating how it can be used to give Large Language Models (LLMs) secure, controlled access to tools and data sources. Each MCP server is implemented with either the Typescript MCP SDK or Python MCP SDK.

Note: Lists in this README are maintained in alphabetical order to minimize merge conflicts when adding new items.

🌟 Reference Servers

These servers aim to demonstrate MCP features and the TypeScript and Python SDKs.

Everything - Reference / test server with prompts, resources, and tools
Fetch - Web content fetching and conversion for efficient LLM usage
Filesystem - Secure file operations with configurable access controls
Git - Tools to read, search, and manipulate Git repositories
Memory - Knowledge graph-based persistent memory system
Sequential Thinking - Dynamic and reflective problem-solving through thought sequences
Time - Time and timezone conversion capabilities

Archived

The following reference servers are now archived and can be found at servers-archived.

AWS KB Retrieval - Retrieval from AWS Knowledge Base using Bedrock Agent Runtime
Brave Search - Web and local search using Brave’s Search API
EverArt - AI image generation using various models
GitHub - Repository management, file operations, and GitHub API integration
GitLab - GitLab API, enabling project management
Google Drive - File access and search capabilities for Google Drive
Google Maps - Location services, directions, and place details
PostgreSQL - Read-only database access with schema inspection
Puppeteer - Browser automation and web scraping
Redis - Interact with Redis key-value stores
Sentry - Retrieving and analyzing issues from Sentry.io
Slack - Channel management and messaging capabilities
Sqlite - Database interaction and business intelligence capabilities

🤝 Third-Party Servers

🎖️ Official Integrations

Official integrations are maintained by companies building production ready MCP servers for their platforms.

21st.dev Magic - Create crafted UI components inspired by the best 21st.dev design engineers.
Adfin - The only platform you need to get paid - all payments in one place, invoicing and accounting reconciliations with Adfin.
AgentQL - Enable AI agents to get structured data from unstructured web with AgentQL.
AgentRPC - Connect to any function, any language, across network boundaries using AgentRPC.
Aiven - Navigate your Aiven projects and interact with the PostgreSQL®, Apache Kafka®, ClickHouse® and OpenSearch® services
Alation - Unlock the power of the enterprise Data Catalog by harnessing tools provided by the Alation MCP server.
Algolia MCP Algolia MCP Server exposes a natural language interface to query, inspect, and manage Algolia indices and configs. Useful for monitoring, debugging and optimizing search performance within your agentic workflows. See demo.
Alibaba Cloud RDS - An MCP server designed to interact with the Alibaba Cloud RDS OpenAPI, enabling programmatic management of RDS resources via an LLM.
Alibaba Cloud AnalyticDB for MySQL - Connect to a AnalyticDB for MySQL cluster for getting database or table metadata, querying and analyzing data.It will be supported to add the openapi for cluster operation in the future.
Alibaba Cloud OPS - Manage the lifecycle of your Alibaba Cloud resources with CloudOps Orchestration Service and Alibaba Cloud OpenAPI.
Alibaba Cloud OpenSearch - This MCP server equips AI Agents with tools to interact with OpenSearch through a standardized and extensible interface.
Apache IoTDB - MCP Server for Apache IoTDB database and its tools
Apify - Actors MCP Server: Use 3,000+ pre-built cloud tools to extract data from websites, e-commerce, social media, search engines, maps, and more
APIMatic MCP - APIMatic MCP Server is used to validate OpenAPI specifications using APIMatic. The server processes OpenAPI files and returns validation summaries by leveraging APIMatic’s API.
Apollo MCP Server - Connect your GraphQL APIs to AI agents
Arize Phoenix - Inspect traces, manage prompts, curate datasets, and run experiments using Arize Phoenix, an open-source AI and LLM observability tool.
Asgardeo - MCP server to interact with your Asgardeo organization through LLM tools.
Astra DB - Comprehensive tools for managing collections and documents in a DataStax Astra DB NoSQL database with a full range of operations such as create, update, delete, find, and associated bulk actions.
Atlan - The Atlan Model Context Protocol server allows you to interact with the Atlan services through multiple tools.
Audiense Insights - Marketing insights and audience analysis from Audiense reports, covering demographic, cultural, influencer, and content engagement analysis.
AWS - Specialized MCP servers that bring AWS best practices directly to your development workflow.
Axiom - Query and analyze your Axiom logs, traces, and all other event data in natural language
Azure - The Azure MCP Server gives MCP Clients access to key Azure services and tools like Azure Storage, Cosmos DB, the Azure CLI, and more.
Bankless Onchain - Query Onchain data, like ERC20 tokens, transaction history, smart contract state.
BICScan - Risk score / asset holdings of EVM blockchain address (EOA, CA, ENS) and even domain names.
Bitrise - Chat with your builds, CI, and more.
Box - Interact with the Intelligent Content Management platform through Box AI.
Browserbase - Automate browser interactions in the cloud (e.g. web navigation, data extraction, form filling, and more)
BrowserStack - Access BrowserStack’s Test Platform to debug, write and fix tests, do accessibility testing and more.
Burp Suite - MCP Server extension allowing AI clients to connect to Burp Suite
Cartesia - Connect to the Cartesia voice platform to perform text-to-speech, voice cloning etc.
Chargebee - MCP Server that connects AI agents to Chargebee platform.
Chiki StudIO - Create your own configurable MCP servers purely via configuration (no code), with instructions, prompts, and tools support.
Chroma - Embeddings, vector search, document storage, and full-text search with the open-source AI application database
Chronulus AI - Predict anything with Chronulus AI forecasting and prediction agents.
CircleCI - Enable AI Agents to fix build failures from CircleCI.
ClickHouse - Query your ClickHouse database server.
Cloudflare - Deploy, configure & interrogate your resources on the Cloudflare developer platform (e.g. Workers/KV/R2/D1)
Codacy - Interact with Codacy API to query code quality issues, vulnerabilities, and coverage insights about your code.
CodeLogic - Interact with CodeLogic, a Software Intelligence platform that graphs complex code and data architecture dependencies, to boost AI accuracy and insight.
Comet Opik - Query and analyze your Opik logs, traces, prompts and all other telemtry data from your LLMs in natural language.
Confluent - Interact with Confluent Kafka and Confluent Cloud REST APIs.
Convex - Introspect and query your apps deployed to Convex.
Couchbase - Interact with the data stored in Couchbase clusters.
CRIC Wuye AI - Interact with capabilities of the CRIC Wuye AI platform, an intelligent assistant specifically for the property management industry.
Dart - Interact with task, doc, and project data in Dart, an AI-native project management tool
DataHub - Search your data assets, traverse data lineage, write SQL queries, and more using DataHub metadata.
DexPaprika (CoinPaprika) - Access real-time DEX data, liquidity pools, token information, and trading analytics across multiple blockchain networks with DexPaprika by CoinPaprika.
DevHub - Manage and utilize website content within the DevHub CMS platform
DevRev - An MCP server to integrate with DevRev APIs to search through your DevRev Knowledge Graph where objects can be imported from diff. Sources listed here.
Dynatrace - Manage and interact with the Dynatrace Platform for real-time observability and monitoring.
E2B - Run code in secure sandboxes hosted by E2B
Edgee - Deploy and manage Edgee components and projects
EduBase - Interact with EduBase, a comprehensive e-learning platform with advanced quizzing, exam management, and content organization capabilities
Elasticsearch - Query your data in Elasticsearch
eSignatures - Contract and template management for drafting, reviewing, and sending binding contracts.
Exa - Search Engine made for AIs by Exa
Fewsats - Enable AI Agents to purchase anything in a secure way using Fewsats
Fibery - Perform queries and entity operations in your Fibery workspace.
Financial Datasets - Stock market API made for AI agents
Firecrawl - Extract web data with Firecrawl
Fireproof - Immutable ledger database with live synchronization
Github - GitHub’s official MCP Server
GibsonAI - AI-Powered Cloud databases: Build, migrate, and deploy database instances with AI
Gitea - Interact with Gitea instances with MCP.
Gitee - Gitee API integration, repository, issue, and pull request management, and more.
Glean - Enterprise search and chat using Glean’s API.
Gyazo - Search, fetch, upload, and interact with Gyazo images, including metadata and OCR data.
gotoHuman - Human-in-the-loop platform - Allow AI agents and automations to send requests for approval to your gotoHuman inbox.
Grafana - Search dashboards, investigate incidents and query datasources in your Grafana instance
Grafbase - Turn your GraphQL API into an efficient MCP server with schema intelligence in a single command.
Graphlit - Ingest anything from Slack to Gmail to podcast feeds, in addition to web crawling, into a searchable Graphlit project.
GreptimeDB - Provides AI assistants with a secure and structured way to explore and analyze data in GreptimeDB.
Heroku - Interact with the Heroku Platform through LLM-driven tools for managing apps, add-ons, dynos, databases, and more.
Hologres - Connect to a Hologres instance, get table metadata, query and analyze data.
Honeycomb Allows Honeycomb Enterprise customers to query and analyze their data, alerts, dashboards, and more; and cross-reference production behavior with the codebase.
HubSpot - Connect, manage, and interact with HubSpot CRM data
Hyperbrowser - Hyperbrowser is the next-generation platform empowering AI agents and enabling effortless, scalable browser automation.
IBM wxflows - Tool platform by IBM to build, test and deploy tools for any data source
ForeverVM - Run Python in a code sandbox.
Inbox Zero - AI personal assistant for email Inbox Zero
Inkeep - RAG Search over your content powered by Inkeep
Integration App - Interact with any other SaaS applications on behalf of your customers.
JetBrains – Work on your code with JetBrains IDEs
Kagi Search - Search the web using Kagi’s search API
Keboola - Build robust data workflows, integrations, and analytics on a single intuitive platform.
Klavis ReportGen - Create professional reports from a simple user query.
KWDB - Reading, writing, querying, modifying data, and performing DDL operations with data in your KWDB Database.
Lara Translate - MCP Server for Lara Translate API, enabling powerful translation capabilities with support for language detection and context-aware translations.
Logfire - Provides access to OpenTelemetry traces and metrics through Logfire.
Langfuse Prompt Management - Open-source tool for collaborative editing, versioning, evaluating, and releasing prompts.
LaunchDarkly - LaunchDarkly is a continuous delivery platform that provides feature flags as a service and allows developers to iterate quickly and safely.
Linear - Search, create, and update Linear issues, projects, and comments.
Lingo.dev - Make your AI agent speak every language on the planet, using Lingo.dev Localization Engine.
Litmus.io - Official MCP server for configuring Litmus Edge for Industrial Data Collection, Edge Analytics & Industrial AI.
Mailgun - Interact with Mailgun API.
Make - Turn your Make scenarios into callable tools for AI assistants.
MCP Toolbox for Databases - Open source MCP server specializing in easy, fast, and secure tools for Databases. Supports AlloyDB, BigQuery, Bigtable, Cloud SQL, Dgraph, MySQL, Neo4j, Postgres, Spanner, and more.
Meilisearch - Interact & query with Meilisearch (Full-text & semantic search API)
Memgraph - Query your data in Memgraph graph database.
Metoro - Query and interact with kubernetes environments monitored by Metoro
Mercado Pago - Mercado Pago’s official MCP server.
Microsoft Clarity - Official MCP Server to get your behavioral analytics data and insights from Clarity
Microsoft Dataverse - Chat over your business data using NL - Discover tables, run queries, retrieve data, insert or update records, and execute custom prompts grounded in business knowledge and context.
Milvus - Search, Query and interact with data in your Milvus Vector Database.
Momento - Momento Cache lets you quickly improve your performance, reduce costs, and handle load at any scale.
MongoDB - Both MongoDB Community Server and MongoDB Atlas are supported.
MotherDuck - Query and analyze data with MotherDuck and local DuckDB
Needle - Production-ready RAG out of the box to search and retrieve data from your own documents.
Neo4j - Neo4j graph database server (schema + read/write-cypher) and separate graph database backed memory
Neon - Interact with the Neon serverless Postgres platform
Netlify - Create, build, deploy, and manage your websites with Netlify web platform.
Notion - This project implements an MCP server for the Notion API.
OceanBase - MCP Server for OceanBase database and its tools
Octagon - Deliver real-time investment research with extensive private and public market data.
OlaMaps - Official Ola Maps MCP Server for services like geocode, directions, place details and many more.
OP.GG - Access real-time gaming data across popular titles like League of Legends, TFT, and Valorant, offering champion analytics, esports schedules, meta compositions, and character statistics.
OpsLevel - Official MCP Server for OpsLevel.
Oxylabs - Scrape websites with Oxylabs Web API, supporting dynamic rendering and parsing for structured data extraction.
Paddle - Interact with the Paddle API. Manage product catalog, billing and subscriptions, and reports.
Pagos - Interact with the Pagos API. Query Credit Card BIN Data with more to come.
PayPal - PayPal’s official MCP server.
Perplexity - An MCP server that connects to Perplexity’s Sonar API, enabling real-time web-wide research in conversational AI.
Pinecone - Pinecone’s developer MCP Server assist developers in searching documentation and managing data within their development environment.
Pinecone Assistant - Retrieves context from your Pinecone Assistant knowledge base.
Prisma - Create and manage Prisma Postgres databases
Pulumi - Deploy and manage cloud infrastructure using Pulumi.
Pure.md - Reliably access web content in markdown format with pure.md (bot detection avoidance, proxy rotation, and headless JS rendering built in).
Put.io - Interact with your Put.io account to download torrents.
Ragie - Retrieve context from your Ragie (RAG) knowledge base connected to integrations like Google Drive, Notion, JIRA and more.
Redis - The Redis official MCP Server offers an interface to manage and search data in Redis.
Redis Cloud API - The Redis Cloud API MCP Server allows you to manage your Redis Cloud resources using natural language.
Snyk - Enhance security posture by embedding Snyk vulnerability scanning directly into agentic workflows.
Qdrant - Implement semantic memory layer on top of the Qdrant vector search engine
Ramp - Interact with Ramp’s Developer API to run analysis on your spend and gain insights leveraging LLMs
Raygun - Interact with your crash reporting and real using monitoring data on your Raygun account
Rember - Create spaced repetition flashcards in Rember to remember anything you learn in your chats
Riza - Arbitrary code execution and tool-use platform for LLMs by Riza
Root Signals - Improve and quality control your outputs with evaluations using LLM-as-Judge
Search1API - One API for Search, Crawling, and Sitemaps
ScreenshotOne - Render website screenshots with ScreenshotOne
Semgrep - Enable AI agents to secure code with Semgrep.
SingleStore - Interact with the SingleStore database platform
StarRocks - Interact with StarRocks
Stripe - Interact with Stripe API
Tavily - Search engine for AI agents (search + extract) powered by Tavily
Terraform - Seamlessly integrate with Terraform ecosystem, enabling advanced automation and interaction capabilities for Infrastructure as Code (IaC) development powered by Terraform
Thirdweb - Read/write to over 2k blockchains, enabling data querying, contract analysis/deployment, and transaction execution, powered by Thirdweb
Tianji - Interact with Tianji platform whatever selfhosted or cloud platform, powered by Tianji.
TiDB - MCP Server to interact with TiDB database platform.
Tinybird - Interact with Tinybird serverless ClickHouse platform
Tldv - Connect your AI agents to Google-Meet, Zoom & Microsoft Teams through tl;dv
UnifAI - Dynamically search and call tools using UnifAI Network
Unstructured - Set up and interact with your unstructured data processing workflows in Unstructured Platform
Upstash - Manage Redis databases and run Redis commands on Upstash with natural language.
Vectorize - Vectorize MCP server for advanced retrieval, Private Deep Research, Anything-to-Markdown file extraction and text chunking.
Verbwire - Deploy smart contracts, mint NFTs, manage IPFS storage, and more through the Verbwire API
Verodat - Interact with Verodat AI Ready Data platform
VeyraX - Single tool to control all 100+ API integrations, and UI components
WayStation - Universal MCP server to connect to popular productivity tools such as Notion, Monday, AirTable, and many more
WaveSpeed - WaveSpeed MCP server providing AI agents with image and video generation capabilities.
Xero - Interact with the accounting data in your business using our official MCP server
YugabyteDB - MCP Server to interact with your YugabyteDB database
Zapier - Connect your AI Agents to 8,000 apps instantly.
ZenML - Interact with your MLOps and LLMOps pipelines through your ZenML MCP server

🌎 Community Servers

A growing set of community-developed and maintained servers demonstrates various applications of MCP across different domains.

Note: Community servers are untested and should be used at your own risk. They are not affiliated with or endorsed by Anthropic.

1Panel - MCP server implementation that provides 1Panel interaction.
A2A - An MCP server that bridges the Model Context Protocol (MCP) with the Agent-to-Agent (A2A) protocol, enabling MCP-compatible AI assistants (like Claude) to seamlessly interact with A2A agents.
Ableton Live - an MCP server to control Ableton Live.
Ableton Live (by ahujasid) - Ableton integration allowing prompt enabled music creation.
Actor Critic Thinking - Actor-critic thinking for performance evaluation
Agentset - RAG for your knowledge base connected to Agentset.
AI Agent Marketplace Index - MCP server to search more than 5000+ AI agents and tools of various categories from AI Agent Marketplace Index and monitor traffic of AI Agents.
Airbnb - Provides tools to search Airbnb and get listing details.
Airflow - A MCP Server that connects to Apache Airflow using official python client.
Airtable - Read and write access to Airtable databases, with schema inspection.
Airtable - Airtable Model Context Protocol Server.
Algorand - A comprehensive MCP server for tooling interactions (40+) and resource accessibility (60+) plus many useful prompts for interacting with the Algorand blockchain.
AlphaVantage - MCP server for stock market data API AlphaVantage
Amadeus (by donghyun-chae) - An MCP server to access, explore, and interact with Amadeus Flight Offers Search API for retrieving detailed flight options, including airline, times, duration, and pricing data.
Amazon Ads - MCP Server that provides interaction capabilities with Amazon Advertising through MarketplaceAdPros/
Anki - An MCP server for interacting with your Anki decks and cards.
AntV Chart - A Model Context Protocol server for generating 15+ visual charts using AntV.
Any Chat Completions - Interact with any OpenAI SDK Compatible Chat Completions API like OpenAI, Perplexity, Groq, xAI and many more.
Apache Gravitino(incubating) - Allow LLMs to explore metadata of structured data and unstructured data with Gravitino, and perform data governance tasks including tagging/classification.
APIWeaver - An MCP server that dynamically creates MCP servers from web API configurations. This allows you to easily integrate any REST API, GraphQL endpoint, or web service into an MCP-compatible tool that can be used by AI assistants like Claude.
Apple Books - Interact with your library on Apple Books, manage your book collection, summarize highlights, notes, and much more.
Apple Calendar - An MCP server that allows you to interact with your MacOS Calendar through natural language, including features such as event creation, modification, schedule listing, finding free time slots etc.
Apple Script - MCP server that lets LLM run AppleScript code to to fully control anything on Mac, no setup needed.
Aranet4 - MCP Server to manage your Aranet4 CO2 sensor. Fetch data and store in a local SQLite. Ask questions about historical data.
ArangoDB - MCP Server that provides database interaction capabilities through ArangoDB.
Arduino - MCP Server that enables AI-powered robotics using Claude AI and Arduino (ESP32) for real-world automation and interaction with robots.
arXiv API - An MCP server that enables interacting with the arXiv API using natural language.
arxiv-latex-mcp - MCP server that fetches and processes arXiv LaTeX sources for precise interpretation of mathematical expressions in papers.
Atlassian - Interact with Atlassian Cloud products (Confluence and Jira) including searching/reading Confluence spaces/pages, accessing Jira issues, and project metadata.
Atlassian Server (by phuc-nt) - An MCP server that connects AI agents (Cline, Claude Desktop, Cursor, etc.) to Atlassian Jira & Confluence, enabling data queries and actions through the Model Context Protocol.
Attestable MCP - An MCP server running inside a trusted execution environment (TEE) via Gramine, showcasing remote attestation using RA-TLS. This allows an MCP client to verify the server before conencting.
Audius - Audius + AI = Atris. Interact with fans, stream music, tip your favorite artists, and more on Audius: all through Claude.
AWS - Perform operations on your AWS resources using an LLM.
AWS Athena - A MCP server for AWS Athena to run SQL queries on Glue Catalog.
AWS Cognito - A MCP server that connects to AWS Cognito for authentication and user management.
AWS Cost Explorer - Optimize your AWS spend (including Amazon Bedrock spend) with this MCP server by examining spend across regions, services, instance types and foundation models (demo video).
AWS Resources Operations - Run generated python code to securely query or modify any AWS resources supported by boto3.
AWS S3 - A sample MCP server for AWS S3 that flexibly fetches objects from S3 such as PDF documents.
Azure ADX - Query and analyze Azure Data Explorer databases.
Azure DevOps - An MCP server that provides a bridge to Azure DevOps services, enabling AI assistants to query and manage work items.
Azure MCP Hub - A curated list of all MCP servers and related resources for Azure developers by Arun Sekhar
Azure OpenAI DALL-E 3 MCP Server - A MCP server for Azure OpenAI DALL-E 3 service to generate image from text.
Azure Wiki Search - An MCP that enables AI to query the wiki hosted on Azure Devops Wiki.
Baidu AI Search - Web search with Baidu Cloud’s AI Search
BambooHR MCP - An MCP server that interfaces with the BambooHR APIs, providing access to employee data, time tracking, and HR management features.
Base Free USDC Transfer - Send USDC on Base for free using Claude AI! Built with Coinbase CDP.
Basic Memory - Local-first knowledge management system that builds a semantic graph from Markdown files, enabling persistent memory across conversations with LLMs.
BigQuery (by LucasHild) - This server enables LLMs to inspect database schemas and execute queries on BigQuery.
BigQuery (by ergut) - Server implementation for Google BigQuery integration that enables direct BigQuery database access and querying capabilities
Bilibili - This MCP server provides tools to fetch Bilibili user profiles, video metadata, search videos, and more.
Bing Web Search API (by hanchunglee) - Server implementation for Microsoft Bing Web Search API.
Bitable MCP (by lloydzhou) - MCP server provides access to Lark Bitable through the Model Context Protocol. It allows users to interact with Bitable tables using predefined tools.
Blender (by ahujasid) - Blender integration allowing prompt enabled 3D scene creation, modeling and manipulation.
BreakoutRoom - Agents accomplishing goals together in p2p rooms
browser-use (by co-browser) - browser-use MCP server with dockerized playwright + chromium + vnc. supports stdio & resumable http.
BrowserLoop - An MCP server for taking screenshots of web pages using Playwright. Supports high-quality capture with configurable formats, viewport sizes, cookie-based authentication, and both full page and element-specific screenshots.
Bsc-mcp The first MCP server that serves as the bridge between AI and BNB Chain, enabling AI agents to execute complex on-chain operations through seamless integration with the BNB Chain, including transfer, swap, launch, security check on any token and even more.
BVG MCP Server - (Unofficial) - Unofficial MCP server for Berliner Verkehrsbetriebe Api.
Calculator - This server enables LLMs to use calculator for precise numerical calculations.
Calendly - Calendly MCP server from agentr that provides support for managing events and scheduling via Calendly.
CCTV VMS MCP - A Model Context Protocol (MCP) server designed to connect to a CCTV recording program (VMS) to retrieve recorded and live video streams. It also provides tools to control the VMS software, such as showing live or playback dialogs for specific channels at specified times.
CFBD API - An MCP server for the College Football Data API.
ChatMCP – An Open Source Cross-platform GUI Desktop application compatible with Linux, macOS, and Windows, enabling seamless interaction with MCP servers across dynamically selectable LLMs, by AIQL
ChatSum - Query and Summarize chat messages with LLM. by mcpso
Chess.com - Access Chess.com player data, game records, and other public information through standardized MCP interfaces, allowing AI assistants to search and analyze chess information.
ChessPal Chess Engine (stockfish) - A Stockfish-powered chess engine exposed as an MCP server. Calculates best moves and supports both HTTP/SSE and stdio transports.
Chroma - Vector database server for semantic document search and metadata filtering, built on Chroma
Claude Thread Continuity - Persistent memory system enabling Claude Desktop conversations to resume with full context across sessions. Maintains conversation history, project states, and user preferences for seamless multi-session workflows.
ClaudePost - ClaudePost enables seamless email management for Gmail, offering secure features like email search, reading, and sending.
ClickUp - MCP server for ClickUp task management, supporting task creation, updates, bulk operations, and markdown descriptions.
Cloudinary - Cloudinary Model Context Protocol Server to upload media to Cloudinary and get back the media link and details.
Coda - Coda.io MCP server from agentr that provides support for reading and writing data to Coda docs and tables.
code-assistant - A coding assistant MCP server that allows to explore a code-base and make changes to code. Should be used with trusted repos only (insufficient protection against prompt injections).
code-executor - An MCP server that allows LLMs to execute Python code within a specified Conda environment.
code-sandbox-mcp - An MCP server to create secure code sandbox environment for executing code within Docker containers.
cognee-mcp - GraphRAG memory server with customizable ingestion, data processing and search
coin_api_mcp - Provides access to coinmarketcap cryptocurrency data.
CoinMarketCap - Implements the complete CoinMarketCap API for accessing cryptocurrency market data, exchange information, and other blockchain-related metrics.
commands - Run commands and scripts. Just like in a terminal.
Computer-Use - Remote MacOS Use - Open-source out-of-the-box alternative to OpenAI Operator, providing a full desktop experience and optimized for using remote macOS machines as autonomous AI agents.
consul-mcp - A consul MCP server for service management, health check and Key-Value Store
Contentful-mcp - Read, update, delete, publish content in your Contentful space(s) from this MCP Server.
context-portal - Context Portal (ConPort) is a memory bank database system that effectively builds a project-specific knowledge graph, capturing entities like decisions, progress, and architecture, along with their relationships. This serves as a powerful backend for Retrieval Augmented Generation (RAG), enabling AI assistants to access precise, up-to-date project information.
CreateveAI Nexus - Open-Source Bridge Between AI Agents and Enterprise Systems, with simple custom API plug-in capabilities (including close compatibility with ComfyUI nodes), support for Copilot Studio’s MCP agent integations, and support for Azure deployment in secure environments with secrets stored in Azure Key Vault, as well as straightforward on-premises deployment.
Creatify - MCP Server that exposes Creatify AI API capabilities for AI video generation, including avatar videos, URL-to-video conversion, text-to-speech, and AI-powered editing tools.
Cronlytic - Create CRUD operations for serverless cron jobs through Cronlytic MCP Server
crypto-feargreed-mcp - Providing real-time and historical Crypto Fear & Greed Index data.
crypto-indicators-mcp - An MCP server providing a range of cryptocurrency technical analysis indicators and strategies.
crypto-sentiment-mcp - An MCP server that delivers cryptocurrency sentiment analysis to AI agents.
cryptopanic-mcp-server - Providing latest cryptocurrency news to AI agents, powered by CryptoPanic.
Cursor MCP Installer - A tool to easily install and configure other MCP servers within Cursor IDE, with support for npm packages, local directories, and Git repositories.
Dappier - Connect LLMs to real-time, rights-cleared, proprietary data from trusted sources. Access specialized models for Real-Time Web Search, News, Sports, Financial Data, Crypto, and premium publisher content. Explore data models at marketplace.dappier.com.
Data Exploration - MCP server for autonomous data exploration on .csv-based datasets, providing intelligent insights with minimal effort. NOTE: Will execute arbitrary Python code on your machine, please use with caution!
Databricks - Allows LLMs to run SQL queries, list and get details of jobs executions in a Databricks account.
Databricks Genie - A server that connects to the Databricks Genie, allowing LLMs to ask natural language questions, run SQL queries, and interact with Databricks conversational agents.
Databricks Smart SQL - Leveraging Databricks Unity Catalog metadata, perform smart efficient SQL queries to solve Ad-hoc queries and explore data.
Datadog - Datadog MCP Server for application tracing, monitoring, dashboard, incidents queries built on official datadog api.
Dataset Viewer - Browse and analyze Hugging Face datasets with features like search, filtering, statistics, and data export
DataWorks - A Model Context Protocol (MCP) server that provides tools for AI, allowing it to interact with the DataWorks Open API through a standardized interface. This implementation is based on the Alibaba Cloud Open API and enables AI agents to perform cloud resources operations seamlessly.
DaVinci Resolve - MCP server integration for DaVinci Resolve providing powerful tools for video editing, color grading, media management, and project control.
DBHub - Universal database MCP server connecting to MySQL, PostgreSQL, SQLite, DuckDB and etc.
Deebo – Agentic debugging MCP server that helps AI coding agents delegate and fix hard bugs through isolated multi-agent hypothesis testing.
Deep Research - Lightweight MCP server offering Grok/OpenAI/Gemini/Perplexity-style automated deep research exploration and structured reporting.
DeepSeek MCP Server - Model Context Protocol server integrating DeepSeek’s advanced language models, in addition to other useful API endpoints
deepseek-thinker-mcp - A MCP (Model Context Protocol) provider Deepseek reasoning content to MCP-enabled AI Clients, like Claude Desktop. Supports access to Deepseek’s thought processes from the Deepseek API service or from a local Ollama server.
Deepseek_R1 - A Model Context Protocol (MCP) server implementation connecting Claude Desktop with DeepSeek’s language models (R1/V3)
Descope - An MCP server to integrate with Descope to search audit logs, manage users, and more.
DesktopCommander - Let AI edit and manage files on your computer, run terminal commands, and connect to remote servers via SSH - all powered by one of the most popular local MCP servers.
DevDb - An MCP server that runs right inside the IDE, for connecting to MySQL, Postgres, SQLite, and MSSQL databases.
Dicom - An MCP server to query and retrieve medical images and for parsing and reading dicom-encapsulated documents (pdf etc.).
Dify - A simple implementation of an MCP server for dify workflows.
Discogs - A MCP server that connects to the Discogs API for interacting with your music collection.
Discord - A MCP server to connect to Discord guilds through a bot and read and write messages in channels
Discord - A MCP server, which connects to Discord through a bot, and provides comprehensive integration with Discord.
Discord - For Discord API integration by Klavis AI
Discourse - A MCP server to search Discourse posts on a Discourse forum.
Docker - Integrate with Docker to manage containers, images, volumes, and networks.
Docs - Enable documentation access for the AI agent, supporting llms.txt and other remote or local files.
Dodo Payments - Enables AI agents to securely perform payment operations via a lightweight, serverless-compatible interface to the Dodo Payments API.
DPLP - Searches the DBLP computer science bibliography database.
Drupal - Server for interacting with Drupal using STDIO transport layer.
dune-analytics-mcp - A mcp server that bridges Dune Analytics data to AI agents.
DynamoDB-Toolbox - Leverages your Schemas and Access Patterns to interact with your DynamoDB Database using natural language.
eBook-mcp - A lightweight MCP server that allows LLMs to read and interact with your personal PDF and EPUB ebooks. Ideal for building AI reading assistants or chat-based ebook interfaces.
EdgeOne Pages MCP - An MCP service for deploying HTML content to EdgeOne Pages and obtaining a publicly accessible URL.
Edwin - MCP server for edwin SDK - enabling AI agents to interact with DeFi protocols across EVM, Solana and other blockchains.
eechat - An open-source, cross-platform desktop application that seamlessly connects with MCP servers, across Linux, macOS, and Windows.
Elasticsearch - MCP server implementation that provides Elasticsearch interaction.
ElevenLabs - A server that integrates with ElevenLabs text-to-speech API capable of generating full voiceovers with multiple voices.
Email - This server enables users to send emails through various email providers, including Gmail, Outlook, Yahoo, Sina, Sohu, 126, 163, and QQ Mail. It also supports attaching files from specified directories, making it easy to upload attachments along with the email content.
Email SMTP - A simple MCP server that lets your AI agent send emails and attach files through SMTP.
Enhance Prompt - An MCP service for enhance you prompt.
Ergo Blockchain MCP -An MCP server to integrate Ergo Blockchain Node and Explorer APIs for checking address balances, analyzing transactions, viewing transaction history, performing forensic analysis of addresses, searching for tokens, and monitoring network status.
Eunomia - Extension of the Eunomia framework that connects Eunomia instruments with MCP servers
Everything Search - Fast file searching capabilities across Windows (using Everything SDK), macOS (using mdfind command), and Linux (using locate/plocate command).
EVM MCP Server - Comprehensive blockchain services for 30+ EVM networks, supporting native tokens, ERC20, NFTs, smart contracts, transactions, and ENS resolution.
Excel - Excel manipulation including data reading/writing, worksheet management, formatting, charts, and pivot table.
Fabric MCP - Microsoft Fabric MCP server to accelerate working in your Fabric Tenant with the help of your favorite LLM models.
fabric-mcp-server - The fabric-mcp-server is an MCP server that integrates Fabric patterns with Cline, exposing them as tools for AI-driven task execution and enhancing Cline’s capabilities.
Facebook Ads - MCP server acting as an interface to the Facebook Ads, enabling programmatic access to Facebook Ads data and management features.
Fantasy PL - Give your coding agent direct access to up-to date Fantasy Premier League data
fastn.ai – Unified API MCP Server - A remote, dynamic MCP server with a unified API that connects to 1,000+ tools, actions, and workflows, featuring built-in authentication and monitoring.
FDIC BankFind MCP Server - (Unofficial) - The is a MCPserver that brings the power of FDIC BankFind APIs straight to your AI tools and workflows. Structured U.S. banking data, delivered with maximum vibes. 😎📊
Federal Reserve Economic Data (FRED) (by Stefano Amorelli) - Community developed MCP server to interact with the Federal Reserve Economic Data.
Fetch - A server that flexibly fetches HTML, JSON, Markdown, or plaintext.
Figma - Give your coding agent direct access to Figma file data, helping it one-shot design implementation.
Fingertip - MCP server for Fingertip.com to search and create new sites.
Firebase - Server to interact with Firebase services including Firebase Authentication, Firestore, and Firebase Storage.
FireCrawl - Advanced web scraping with JavaScript rendering, PDF support, and smart rate limiting
FitBit MCP Server - An MCP server that connects to FitBit API using a token obtained from OAuth flow.
FlightRadar24 - A Claude Desktop MCP server that helps you track flights in real-time using Flightradar24 data.
Flyworks Avatar - Fast and free zeroshot lipsync MCP server.
Foursquare - Enable your agent to recommend places around the world with the Foursquare Places API
freqtrade-mcp - An MCP server that integrates with the Freqtrade cryptocurrency trading bot.
GDB - A GDB/MI protocol server based on the MCP protocol, providing remote application debugging capabilities with AI assistants.
Ghost - A Model Context Protocol (MCP) server for interacting with Ghost CMS through LLM interfaces like Claude.
Git - Allows LLM to interact with a local git repository, incl. optional push support.
Github Actions - A Model Context Protocol (MCP) server for interacting with Github Actions.
GitHub Enterprise MCP - A Model Context Protocol (MCP) server for interacting with GitHub Enterprise.
GitMCP - gitmcp.io is a generic remote MCP server to connect to ANY GitHub repository or project documentation effortlessly
Glean - A server that uses Glean API to search and chat.
Gmail - A Model Context Protocol (MCP) server for Gmail integration in Claude Desktop with auto authentication support.
Gmail Headless - Remote hostable MCP server that can get and send Gmail messages without local credential or file system setup.
Gnuradio - An MCP server for GNU Radio that enables LLMs to autonomously create and modify RF .grc flowcharts.
Goal Story - a Goal Tracker and Visualization Tool for personal and professional development.
GOAT - Run more than +200 onchain actions on any blockchain including Ethereum, Solana and Base.
Godot - A MCP server providing comprehensive Godot engine integration for project editing, debugging, and scene management.
Golang Filesystem Server - Secure file operations with configurable access controls built with Go!
Goodnews - A simple MCP server that delivers curated positive and uplifting news stories.
Google Analytics - Google Analytics MCP Server to bring data across 200+ dimensions & metrics for LLMs to analyse.
Google Calendar - Integration with Google Calendar to check schedules, find time, and add/delete events
Google Calendar - Google Calendar MCP Server for managing Google calendar events. Also supports searching for events by attributes like title and location.
Google Custom Search - Provides Google Search results via the Google Custom Search API
Google Sheets - Access and editing data to your Google Sheets.
Google Sheets - A MCP Server written in TypeScript to access and edit data in your Google Sheets.
Google Tasks - Google Tasks API Model Context Protocol Server.
Google Vertex AI Search - Provides Google Vertex AI Search results by grounding a Gemini model with your own private data
Google Workspace - Comprehensive Google Workspace MCP with full support for Calendar, Drive, Gmail, and Docs using Streamable HTTP or SSE transport.
GraphQL - Comprehensive GraphQL API integration that automatically exposes each GraphQL query as a separate tool.
GraphQL Schema - Allow LLMs to explore large GraphQL schemas without bloating the context.
Hashing MCP Server - MCP Server with cryptographic hashing functions e.g. SHA256, MD5, etc.
HDW LinkedIn - Access to profile data and management of user account with HorizonDataWave.ai.
Helm Chart CLI - Helm MCP provides a bridge between AI assistants and the Helm package manager for Kubernetes. It allows AI assistants to interact with Helm through natural language requests, executing commands like installing charts, managing repositories, and more.
Heurist Mesh Agent - Access specialized web3 AI agents for blockchain analysis, smart contract security, token metrics, and blockchain interactions through the Heurist Mesh network.
Holaspirit - Interact with Holaspirit.
Home Assistant - Interact with Home Assistant including viewing and controlling lights, switches, sensors, and all other Home Assistant entities.
Home Assistant - Docker-ready MCP server for Home Assistant with entity management, domain summaries, automation support, and guided conversations. Includes pre-built container images for easy installation.
HubSpot - HubSpot CRM integration for managing contacts and companies. Create and retrieve CRM data directly through Claude chat.
HuggingFace Spaces - Server for using HuggingFace Spaces, supporting Open Source Image, Audio, Text Models and more. Claude Desktop mode for easy integration.
Human-In-the-Loop - A powerful MCP Server that enables AI assistants like Claude to interact with humans through intuitive GUI dialogs. This server bridges the gap between automated AI processes and human decision-making by providing real-time user input tools, choices, confirmations, and feedback mechanisms.
Human-use - Instant human feedback through an MCP, have your AI interact with humans around the world. Powered by Rapidata
Hyperliquid - An MCP server implementation that integrates the Hyperliquid SDK for exchange data.
hyprmcp (by Stefano Amorelli) - Lightweight MCP server for hyprland.
iFlytek SparkAgent Platform - This is a simple example of using MCP Server to invoke the task chain of the iFlytek SparkAgent Platform.
iFlytek Workflow - Connect to iFlytek Workflow via the MCP server and run your own Agent.
Image Generation - This MCP server provides image generation capabilities using the Replicate Flux model.
iMCP - A macOS app that provides an MCP server for your iMessage, Reminders, and other Apple services.
InfluxDB - Run queries against InfluxDB OSS API v2.
Inoyu - Interact with an Apache Unomi CDP customer data platform to retrieve and update customer profiles
interactive-mcp - Enables interactive LLM workflows by adding local user prompts and chat capabilities directly into the MCP loop.
Intercom - An MCP-compliant server for retrieving customer support tickets from Intercom. This tool enables AI assistants like Claude Desktop and Cline to access and analyze your Intercom support tickets.
iOS Simulator - A Model Context Protocol (MCP) server that enables LLMs to interact with iOS simulators (iPhone, iPad, etc.) through natural language commands.
iTerm MCP - Integration with iTerm2 terminal emulator for macOS, enabling LLMs to execute and monitor terminal commands.
iTerm MCP Server - A Model Context Protocol (MCP) server implementation for iTerm2 terminal integration. Able to manage multiple iTerm Sessions.
Java Decompiler - Decompile Java bytecode into readable source code from .class files, package names, or JAR archives using CFR decompiler
JavaFX - Make drawings using a JavaFX canvas
JavaFX - Make drawings using a JavaFX canvas
JDBC - Connect to any JDBC-compatible database and query, insert, update, delete, and more. Supports MySQL, PostgreSQL, Oracle, SQL Server, sqllite and more.
JMeter - Run load testing using Apache JMeter via MCP-compliant tools.
Job Searcher - A FastMCP server that provides tools for retrieving and filtering job listings based on time period, keywords, and remote work preferences.
jobswithgpt - Job search MCP using jobswithgpt which indexes 500K+ public job listings and refreshed continously.
JSON - JSON handling and processing server with advanced query capabilities using JSONPath syntax and support for array, string, numeric, and date operations.
JSON2Video MCP - A Model Context Protocol (MCP) server implementation for programmatically generating videos using the json2video API. This server exposes powerful video generation and status-checking tools for use with LLMs, agents, or any MCP-compatible client.
jupiter-mcp - An MCP server for executing token swaps on the Solana blockchain using Jupiter’s new Ultra API.
Jupyter Notebook - connects Jupyter Notebook to Claude AI, allowing Claude to directly interact with and control Jupyter Notebooks. This integration enables AI-assisted code execution, data analysis, visualization, and more.
k8s-multicluster-mcp - An MCP server for interact with multiple Kubernetes clusters simultaneously using multiple kubeconfig files.
Keycloak MCP - This MCP server enables natural language interaction with Keycloak for user and realm management including creating, deleting, and listing users and realms.
Kibana MCP (by TocharianOU) - A community-maintained MCP server implementation that allows any MCP-compatible client to access and manage Kibana instances through natural language or programmatic requests.
Kibela (by kiwamizamurai) - Interact with Kibela API.
KiCad MCP - MCP server for KiCad on Mac, Windows, and Linux.
kintone - Manage records and apps in kintone through LLM tools.
Kokoro TTS - Use Kokoro text to speech to convert text to MP3s with optional autoupload to S3.
Kong Konnect - A Model Context Protocol (MCP) server for interacting with Kong Konnect APIs, allowing AI assistants to query and analyze Kong Gateway configurations, traffic, and analytics.
Kubernetes - Connect to Kubernetes cluster and manage pods, deployments, and services.
Kubernetes and OpenShift - A powerful Kubernetes MCP server with additional support for OpenShift. Besides providing CRUD operations for any Kubernetes resource, this server provides specialized tools to interact with your cluster.
KubeSphere - The KubeSphere MCP Server is a Model Context Protocol(MCP) server that provides integration with KubeSphere APIs, enabling to get resources from KubeSphere. Divided into four tools modules: Workspace Management, Cluster Management, User and Roles, Extensions Center.
Langflow-DOC-QA-SERVER - A Model Context Protocol server for document Q&A powered by Langflow. It demonstrates core MCP concepts by providing a simple interface to query documents through a Langflow backend.
Lark(Feishu) - A Model Context Protocol(MCP) server for Lark(Feishu) sheet, message, doc and etc.
lean-lsp-mcp - Interact with the Lean theorem prover via the Language Server Protocol.
Lightdash - Interact with Lightdash, a BI tool.
LINE (by amornpan) - Implementation for LINE Bot integration that enables Language Models to read and analyze LINE conversations through a standardized interface. Features asynchronous operation, comprehensive logging, webhook event handling, and support for various message types.
Linear - Interact with Linear project management system.
Linear - Allows LLM to interact with Linear’s API for project management, including searching, creating, and updating issues.
Linear (Go) - Allows LLM to interact with Linear’s API via a single static binary.
Linear MCP - Full blown implementation of the Linear SDK to support comprehensive Linear management of projects, initiatives, issues, users, teams and states.
LlamaCloud (by marcusschiesser) - Integrate the data stored in a managed index on LlamaCloud
lldb-mcp - A Model Context Protocol server for LLDB that provides LLM-driven debugging.
llm-context - Provides a repo-packing MCP tool with configurable profiles that specify file inclusion/exclusion patterns and optional prompts.
Loki - Golang based MCP Server to query logs from Grafana Loki.
LottieFiles - Searching and retrieving Lottie animations from LottieFiles
lsp-mcp - Interact with Language Servers usint the Language Server Protocol to provide additional context information via hover, code actions and completions.
Lspace - Turn scattered ChatGPT/Claude/Cursor conversations into persistent, searchable knowledge.
lucene-mcp-server - spring boot server using Lucene for fast document search and management.
mac-messages-mcp - An MCP server that securely interfaces with your iMessage database via the Model Context Protocol (MCP), allowing LLMs to query and analyze iMessage conversations. It includes robust phone number validation, attachment processing, contact management, group chat handling, and full support for sending and receiving messages.
Maestro MCP - An MCP server for interacting with Bitcoin via the Maestro RPC API.
MalwareBazaar_MCP (by Kevin Thomas) - An AI-driven MCP server that autonomously interfaces with MalwareBazaar, delivering real-time threat intel and sample metadata for authorized cybersecurity research workflows.
MariaDB - MariaDB database integration with configurable access controls in Python.
Markdown2doc - Convert between various file formats using Pandoc
Markdownify - MCP to convert almost anything to Markdown (PPTX, HTML, PDF, Youtube Transcripts and more)
Markitdown - Convert files to Markdown
MasterGo - The server designed to connect MasterGo design tools with AI models. It enables AI models to directly retrieve DSL data from MasterGo design files.
Matlab-MCP-Tools - An MCP to write and execute MATLAB scripts, maintain workspace context between MCP calls, visualize plots, and perform section-by-section analysis of MATLAB code with full access to MATLAB’s computational capabilities.
Maton - Connect to your SaaS tools like HubSpot, Salesforce, and more.
MCP Compass - Suggest the right MCP server for your needs
MCP Create - A dynamic MCP server management service that creates, runs, and manages Model Context Protocol servers on-the-fly.
MCP Installer - This server is a server that installs other MCP servers for you.
MCP Proxy Server - An MCP proxy server that aggregates and serves multiple MCP resource servers through a single HTTP server.
MCP Server Creator - A powerful Model Context Protocol (MCP) server that creates other MCP servers! This meta-server provides tools for dynamically generating FastMCP server configurations and Python code.
MCP STDIO to Streamable HTTP Adapter - Connect to Streamable HTTP MCP Servers even if the MCP Client only supports STDIO.
mcp-containerd - The containerd MCP implemented by Rust supports the operation of the CRI interface.
MCP-Database-Server - Fastest way to interact with your Database such as SQL Server, SQLite and PostgreSQL
mcp-grep - Python-based MCP server that brings grep functionality to LLMs. Supports common grep features including pattern searching, case-insensitive matching, context lines, and recursive directory searches.
mcp-k8s-go - Golang-based Kubernetes server for MCP to browse pods and their logs, events, namespaces and more. Built to be extensible.
mcp-local-rag - “primitive” RAG-like web search model context protocol (MCP) server that runs locally using Google’s MediaPipe Text Embedder and DuckDuckGo Search.
mcp-meme-sticky - Make memes or stickers using MCP server for WhatsApp or Telegram.
MCP-NixOS - A Model Context Protocol server that provides AI assistants with accurate, real-time information about NixOS packages, system options, Home Manager settings, and nix-darwin macOS configurations.
mcp-open-library - A Model Context Protocol (MCP) server for the Open Library API that enables AI assistants to search for book and author information.
mcp-proxy - Connect to MCP servers that run on SSE transport, or expose stdio servers as an SSE server.
mcp-salesforce - MCP server with basic demonstration of interactions with your Salesforce instance
mcp-sanctions - Screen individuals and organizations against global sanctions lists (OFAC, SDN, UN, etc). Query by prompt or document upload.
mcp-server-leetcode - Practice and retrieve problems from LeetCode. Automate problem retrieval, solutions, and insights for coding practice and competitions.
mcp-vision - A MCP server exposing HuggingFace computer vision models such as zero-shot object detection as tools, enhancing the vision capabilities of large language or vision-language models.
mcp-weather - Accurate weather forecasts via the AccuWeather API (free tier available).
mcp_weather - Get weather information from https://api.open-meteo.com API.
MCPIgnore Filesytem - A Data Security First filesystem MCP server that implements .mcpignore to prevent MCP clients from accessing sensitive data.
MediaWiki MCP adapter - A custom Model Context Protocol adapter for MediaWiki and WikiBase APIs
mem0-mcp - A Model Context Protocol server for Mem0, which helps with managing coding preferences.
Membase - Save and query your agent memory in distributed way by Membase.
MetaTrader MCP - Enable AI LLMs to execute trades using MetaTrader 5 platform.
Metricool MCP - A Model Context Protocol server that integrates with Metricool’s social media analytics platform to retrieve performance metrics and schedule content across networks like Instagram, Facebook, Twitter, LinkedIn, TikTok and YouTube.
Microsoft 365 - (by Merill) A Model Context Protocol (MCP) server for Microsoft 365. Includes support for all services including Teams, SharePoint, Exchange, OneDrive, Entra, Intune and more. See Lokka for more details.
Microsoft 365 - MCP server that connects to Microsoft Office and the whole Microsoft 365 suite using Graph API (including Outlook/mail, files, Excel, calendar)
Microsoft Teams - MCP server that integrates Microsoft Teams messaging (read, post, mention, list members and threads)
Mifos X - A MCP server for the Mifos X Open Source Banking useful for managing clients, loans, savings, shares, financial transactions and generating financial reports.
Mikrotik - Mikrotik MCP server which cover networking operations (IP, DHCP, Firewall, etc)
Mindmap (by YuChenSSR) - A server that generates mindmaps from input containing markdown code.
Minima - MCP server for RAG on local files
Mobile MCP (by Mobile Next) - MCP server for Mobile(iOS/Android) automation, app scraping and development using physical devices or simulators/emulators.
Monday.com - MCP Server to interact with Monday.com boards and items.
MongoDB - A Model Context Protocol Server for MongoDB.
MongoDB & Mongoose - MongoDB MCP Server with Mongoose Schema and Validation.
MongoDB Lens - Full Featured MCP Server for MongoDB Databases.
Monzo - Access and manage your Monzo bank accounts through natural language, including balance checking, pot management, transaction listing, and transaction annotation across multiple account types (personal, joint, flex).
Morningstar - MCP Server to interact with Morningstar Research, Editorial and Datapoints
MSSQL - MSSQL database integration with configurable access controls and schema inspection
MSSQL (by jexin) - MCP Server for MSSQL database in Python
MSSQL-MCP (by daobataotie) - MSSQL MCP that refer to the official website’s SQLite MCP for modifications to adapt to MSSQL
MSSQL-Python (by amornpan) - A read-only Python implementation for MSSQL database access with enhanced security features, configurable access controls, and schema inspection capabilities. Focuses on safe database interaction through Python ecosystem.
Multi-Model Advisor - A Model Context Protocol (MCP) server that orchestrates queries across multiple Ollama models, synthesizing their insights to deliver a comprehensive and multifaceted AI perspective on any given query.
Multicluster-MCP-Sever - The gateway for GenAI systems to interact with multiple Kubernetes clusters.
MySQL (by benborla) - MySQL database integration in NodeJS with configurable access controls and schema inspection
MySQL (by DesignComputer) - MySQL database integration in Python with configurable access controls and schema inspection
n8n - This MCP server provides tools and resources for AI assistants to manage n8n workflows and executions, including listing, creating, updating, and deleting workflows, as well as monitoring their execution status.
Nacos MCP Router - This MCP(Model Context Protocol) Server provides tools to search, install, proxy other MCP servers.
NASA (by ProgramComputer) - Access to a unified gateway of NASA’s data sources including but not limited to APOD, NEO, EPIC, GIBS.
Nasdaq Data Link (by stefanoamorelli) - An MCP server to access, explore, and interact with Nasdaq Data Link’s extensive and valuable financial and economic datasets.
National Parks - The server provides latest information of park details, alerts, visitor centers, campgrounds, hiking trails, and events for U.S. National Parks.
NAVER (by pfldy2850) - This MCP server provides tools to interact with various Naver services, such as searching blogs, news, books, and more.
NBA - This MCP server provides tools to fetch recent and historical NBA games including basic and advanced statistics.
Neo4j - A community built server that interacts with Neo4j Graph Database.
Neovim - An MCP Server for your Neovim session.
Netbird - List and analyze Netbird network peers, groups, policies, and more.
NocoDB - Read and write access to NocoDB database.
nomad-mcp - A server that provides a set of tools for managing Nomad clusters through the MCP.
Notion (by suekou) - Interact with Notion API.
Notion (by v-3) - Notion MCP integration. Search, Read, Update, and Create pages through Claude chat.
NS Travel Information - Access Dutch Railways (NS) real-time train travel information and disruptions through the official NS API.
ntfy-mcp (by teddyzxcv) - The MCP server that keeps you informed by sending the notification on phone using ntfy
ntfy-me-mcp (by gitmotion) - An ntfy MCP server for sending/fetching ntfy notifications to your self-hosted ntfy server from AI Agents 📤 (supports secure token auth & more - use with npx or docker!)
oatpp-mcp - C++ MCP integration for Oat++. Use Oat++ to build MCP servers.
Obsidian Markdown Notes - Read and search through your Obsidian vault or any directory containing Markdown notes
obsidian-mcp - (by Steven Stavrakis) An MCP server for Obsidian.md with tools for searching, reading, writing, and organizing notes.
OceanBase - (by yuanoOo) A Model Context Protocol (MCP) server that enables secure interaction with OceanBase databases.
Office-PowerPoint-MCP-Server - A Model Context Protocol (MCP) server for creating, reading, and manipulating Microsoft PowerPoint documents.
Office-Visio-MCP-Server - A Model Context Protocol (MCP) server for creating, reading, and manipulating Microsoft Visio documents.
Office-Word-MCP-Server - A Model Context Protocol (MCP) server for creating, reading, and manipulating Microsoft Word documents.
Okta - Interact with Okta API.
OneNote - (by Rajesh Vijay) An MCP server that connects to Microsoft OneNote using the Microsoft Graph API. Reading notebooks, sections, and pages from OneNote,Creating new notebooks, sections, and pages in OneNote.
Open Strategy Partners Marketing Tools - Content editing codes, value map, and positioning tools for product marketing.
OpenAI WebSearch MCP - This is a Python-based MCP server that provides OpenAI web_search build-in tool.
OpenAPI - Interact with OpenAPI APIs.
OpenAPI AnyApi - Interact with large OpenAPI docs using built-in semantic search for endpoints. Allows for customizing the MCP server prefix.
OpenAPI Schema - Allow LLMs to explore large OpenAPI schemas without bloating the context.
OpenAPI Schema Explorer - Token-efficient access to local or remote OpenAPI/Swagger specs via MCP Resources.
OpenCTI - Interact with OpenCTI platform to retrieve threat intelligence data including reports, indicators, malware and threat actors.
OpenCV - A MCP server providing OpenCV computer vision capabilities. This allows AI assistants and language models to access powerful computer vision tools.
OpenDota - Interact with OpenDota API to retrieve Dota 2 match data, player statistics, and more.
OpenRPC - Interact with and discover JSON-RPC APIs via OpenRPC.
OpenWeather - Interact with the free openweathermap API to get the current and forecast weather for a location.
Oura Ring (by Rajesh Vijay) - MCP Server to access and analyze your Oura Ring data. It provides a structured way to fetch and understand your health metrics.
Outline - MCP Server to interact with Outline knowledge base to search, read, create, and manage documents and their content, access collections, add comments, and manage document backlinks.
pancakeswap-poolspy-mcp - An MCP server that tracks newly created liquidity pools on Pancake Swap.
Pandoc - MCP server for seamless document format conversion using Pandoc, supporting Markdown, HTML, PDF, DOCX (.docx), csv and more.
Paradex MCP - MCP native server for interacting with Paradex platform, including fully features trading.
Peacock for VS Code - MCP Server for the Peacock extension for VS Code, coloring your world, one Code editor at a time. The main goal of the project is to show how an MCP server can be used to interact with APIs.
Phone MCP - 📱 A powerful plugin that lets you control your Android phone. Enables AI agents to perform complex tasks like automatically playing music based on weather or making calls and sending texts.
PIF - A Personal Intelligence Framework (PIF), providing tools for file operations, structured reasoning, and journal-based documentation to support continuity and evolving human-AI collaboration across sessions.
Pinecone - MCP server for searching and uploading records to Pinecone. Allows for simple RAG features, leveraging Pinecone’s Inference API.
Pinner MCP - A MCP server for pinning GitHub Actions and container base images to their immutable SHA hashes to prevent supply chain attacks.
Placid.app - Generate image and video creatives using Placid.app templates
Plane - This MCP Server will help you to manage projects and issues through Plane’s API
Playwright - This MCP Server will help you run browser automation and webscraping using Playwright
Postman - MCP server for running Postman Collections locally via Newman. Allows for simple execution of Postman Server and returns the results of whether the collection passed all the tests.
Prefect - MCP Server for workflow orchestration and ELT/ETL with Prefect Server, and Prefect Cloud [https://www.prefect.io/] using the prefect python client.
Productboard - Integrate the Productboard API into agentic workflows via MCP.
Prometheus - Query and analyze Prometheus - open-source monitoring system.
PubChem - extract drug information from pubchem API.
Pulumi - MCP Server to Interact with Pulumi API, creates and lists Stacks
Puppeteer vision - Use Puppeteer to browse a webpage and return a high quality Markdown. Use AI vision capabilities to handle cookies, captchas, and other interactive elements automatically.
Pushover - Send instant notifications to your devices using Pushover.net
pydantic/pydantic-ai/mcp-run-python - Run Python code in a secure sandbox via MCP tool calls, powered by Deno and Pyodide
QGIS - connects QGIS to Claude AI through the MCP. This integration enables prompt-assisted project creation, layer loading, code execution, and more.
Qiniu MCP Server - The Model Context Protocol (MCP) Server built on Qiniu Cloud products supports users in accessing Qiniu Cloud Storage, intelligent multimedia services, and more through this MCP Server within the context of AI large model clients.
Quarkus - MCP servers for the Quarkus Java framework.
QuickChart - A Model Context Protocol server for generating charts using QuickChart.io
Qwen_Max - A Model Context Protocol (MCP) server implementation for the Qwen models.
RabbitMQ - The MCP server that interacts with RabbitMQ to publish and consume messages.
RAG Local - This MCP server for storing and retrieving text passages locally based on their semantic meaning.
RAG Web Browser An MCP server for Apify’s open-source RAG Web Browser Actor to perform web searches, scrape URLs, and return content in Markdown.
Raindrop.io - An integration that allows LLMs to interact with Raindrop.io bookmarks using the Model Context Protocol (MCP).
Reaper - Interact with your Reaper (Digital Audio Workstation) projects.
Redis - Redis database operations and caching microservice server with support for key-value operations, expiration management, and pattern-based key listing.
Redis MCP server to interact with Redis Server, AWS Memory DB, etc for caching or other use-cases where in-memory and key-value based storage is appropriate
RedNote MCP - MCP server for accessing RedNote(XiaoHongShu, xhs) content
Reed Jobs - Search and retrieve job listings from Reed.co.uk.
Rememberizer AI - An MCP server designed for interacting with the Rememberizer data source, facilitating enhanced knowledge retrieval.
Replicate - Search, run and manage machine learning models on Replicate through a simple tool-based interface. Browse models, create predictions, track their status, and handle generated images.
Resend - Send email using Resend services
Rijksmuseum - Interface with the Rijksmuseum API to search artworks, retrieve artwork details, access image tiles, and explore user collections.
Riot Games - MCP server for League of Legends – fetch player info, ranks, champion stats, and match history via Riot API.
Rquest - An MCP server providing realistic browser-like HTTP request capabilities with accurate TLS/JA3/JA4 fingerprints for bypassing anti-bot measures.
Rust MCP Filesystem - Fast, asynchronous MCP server for efficient handling of various filesystem operations built with the power of Rust.
Salesforce MCP - Salesforce MCP server. Supports cloud version Salesforce-mcp.com and allows both data & metadata functions.
Salesforce MCP - Interact with Salesforce Data and Metadata
Salesforce MCP Server - Comprehensive Salesforce integration with tools for querying records, executing Apex, managing fields/objects, and handling debug logs
Scholarly - A MCP server to search for scholarly and academic articles.
scrapling-fetch - Access text content from bot-protected websites. Fetches HTML/markdown from sites with anti-automation measures using Scrapling.
SearXNG - A Model Context Protocol Server for SearXNG
SearXNG - A MCP server provide web searching via SearXNG & retrieve url as makrdown.
SearXNG Public - A Model Context Protocol Server for retrieving data from public SearXNG instances, with fallback support
SEC EDGAR - (by Stefano Amorelli) A community Model Context Protocol Server to access financial filings and data through the U.S. Securities and Exchange Commission (SEC) Electronic Data Gathering, Analysis, and Retrieval (EDGAR) database
Serper - An MCP server that performs Google searches using Serper.
ServiceNow - A MCP server to interact with a ServiceNow instance
ShaderToy - This MCP server lets LLMs to interact with the ShaderToy API, allowing LLMs to learn from compute shaders examples and enabling them to create complex GLSL shaders that they are previously not capable of.
Shodan MCP - MCP server to interact with Shodan
Shopify - MCP to interact with Shopify API including order, product, customers and so on.
Simple Loki MCP - A simple MCP server to query Loki logs using logcli.
Siri Shortcuts - MCP to interact with Siri Shortcuts on macOS. Exposes all Shortcuts as MCP tools.
Skyvern - MCP to let Claude / Windsurf / Cursor / your LLM control the browser
Slack - The most powerful MCP server for Slack Workspaces. This integration supports both Stdio and SSE transports, proxy settings and does not require any permissions or bots being created or approved by Workspace admins 😏.
Slidespeak - Create PowerPoint presentations using the Slidespeak API.
Smartlead - MCP to connect to Smartlead. Additional, tooling, functionality, and connection to workflow automation platforms also available.
Snowflake - This MCP server enables LLMs to interact with Snowflake databases, allowing for secure and controlled data operations.
SoccerDataAPI - This MCP server provides real-time football match data based on the SoccerDataAPI.
Solana Agent Kit - This MCP server enables LLMs to interact with the Solana blockchain with help of Solana Agent Kit by SendAI, allowing for 40+ protcool actions and growing
Solr MCP - This MCP server offers a basic functionality to perform a search on Solr servers.
Solver - Solves constraint satisfaction and optimization problems .
Splunk - Golang MCP server for Splunk (lists saved searches, alerts, indexes, macros…). Supports SSE and STDIO.
Spotify - This MCP allows an LLM to play and use Spotify.
Spring Initializr - This MCP allows an LLM to create Spring Boot projects with custom configurations. Instead of manually visiting start.spring.io, you can now ask your AI assistant to generate projects with specific dependencies, Java versions, and project structures.
SSH - Agent for managing and controlling SSH connections.
SSH - An MCP server that can execute SSH commands remotely, upload files, download files, and so on.
Standard Korean Dictionary - Search the dictionary using API
Star Wars -MCP Server for the SWAPI Star Wars API. The main goal of the project is to show how an MCP server can be used to interact with APIs.
Starknet MCP Server - A comprehensive MCP server for interacting with the Starknet blockchain, providing tools for querying blockchain data, resolving StarknetIDs, and performing token transfers.
Starwind UI - This MCP provides relevant commands, documentation, and other information to allow LLMs to take full advantage of Starwind UI’s open source Astro components.
Stitch AI - Knowledge management system for AI agents with memory space creation and retrieval capabilities.
Strava - Connect to the Strava API to access activity data, athlete profiles, segments, and routes, enabling fitness tracking and analysis with Claude.
Stripe - This MCP allows integration with Stripe for handling payments, customers, and refunds.
Substack/Medium - Connect Claude to your Substack/Medium writing, enabling semantic search and analysis of your published content.
System Health - The MCP (Multi-Channel Protocol) System Health Monitoring is a robust, real-time monitoring solution designed to provide comprehensive health metrics and alerts for remote Linux servers.
Talk To Figma - This MCP server enables LLMs to interact with Figma, allowing them to read and modify designs programmatically.
Tavily search - An MCP server for Tavily’s search & news API, with explicit site inclusions/exclusions
TeamRetro - This MCP server allows LLMs to interact with TeamRetro, allowing LLMs to manage user, team, team member, retrospective, health check, action, agreement and fetch the reports.
Telegram - An MCP server that provides paginated chat reading, message retrieval, and message sending capabilities for Telegram through Telethon integration.
Telegram-Client - A Telegram API bridge that manages user data, dialogs, messages, drafts, read status, and more for seamless interactions.
Tempo - An MCP server to query traces/spans from Grafana Tempo.
Teradata - his MCP server enables LLMs to interact with Teradata databases. This MCP Server support tools and prompts for multi task data analytics
Terminal-Control - A MCP server that enables secure terminal command execution, directory navigation, and file system operations through a standardized interface.
Terraform-Cloud - An MCP server that integrates AI assistants with the Terraform Cloud API, allowing you to manage your infrastructure through natural conversation.
TFT-Match-Analyzer - MCP server for teamfight tactics match history & match details fetching, providing user the detailed context for every match.
thegraph-mcp - An MCP server that powers AI agents with indexed blockchain data from The Graph.
Things3 MCP - Things3 task management integration for macOS with comprehensive TODO, project, and tag management.
Think MCP - Enhances any agent’s reasoning capabilities by integrating the think-tools, as described in Anthropic’s article.
Ticketmaster - Search for events, venues, and attractions through the Ticketmaster Discovery API
TickTick - A Model Context Protocol (MCP) server designed to integrate with the TickTick task management platform, enabling intelligent context-aware task operations and automation.
TMDB - This MCP server integrates with The Movie Database (TMDB) API to provide movie information, search capabilities, and recommendations.
Todoist - Interact with Todoist to manage your tasks.
Todos - A practical todo list manager to use with your favourite chatbot.
token-minter-mcp - An MCP server providing tools for AI agents to mint ERC-20 tokens across multiple blockchains.
token-revoke-mcp - An MCP server for checking and revoking ERC-20 token allowances across multiple blockchains.
Ton Blockchain MCP - An MCP server for interacting with Ton Blockchain.
TouchDesigner - An MCP server for TouchDesigner, enabling interaction with TouchDesigner projects, nodes, and parameters.
Travel Planner - Travel planning and itinerary management server integrating with Google Maps API for location search, place details, and route calculations.
Trello MCP Server - An MCP server that interact with user Trello boards, modifying them with prompting.
Tripadvisor - A MCP server that enables LLMs to interact with Tripadvisor API, supporting location data, reviews, and photos through standardized MCP interfaces
Tsuki-Mcp-Filesystem-Server - A simple, fast, and fully MCP-compliant server for listing local filesystem files. Built with Python + FastAPI. Designed for OpenAI’s Agent SDK via resources/list.
Tyk API Management - Chat with all of your organization’s managed APIs and perform other API lifecycle operations, managing tokens, users, analytics, and more.
Typesense - A Model Context Protocol (MCP) server implementation that provides AI models with access to Typesense search capabilities. This server enables LLMs to discover, search, and analyze data stored in Typesense collections.
uniswap-poolspy-mcp - An MCP server that tracks newly created liquidity pools on Uniswap across nine blockchain networks.
uniswap-trader-mcp -An MCP server for AI agents to automate token swaps on Uniswap DEX across multiple blockchains.
Unity Catalog - An MCP server that enables LLMs to interact with Unity Catalog AI, supporting CRUD operations on Unity Catalog Functions and executing them as MCP tools.
Unity Integration (Advanced) - Advanced Unity3d Game Engine MCP which supports ,Execution of Any Editor Related Code Directly Inside of Unity, Fetch Logs, Get Editor State and Allow File Access of the Project making it much more useful in Script Editing or asset creation.
Unity3d Game Engine - An MCP server that enables LLMs to interact with Unity3d Game Engine, supporting access to a variety of the Unit’s Editor engine tools (e.g. Console Logs, Test Runner logs, Editor functions, hierarchy state, etc) and executing them as MCP tools or gather them as resources.
Unleash Integration (Feature Toggle) - A Model Context Protocol (MCP) server implementation that integrates with Unleash Feature Toggle system. Provide a bridge between LLM applications and Unleash feature flag system
User Feedback - Simple MCP Server to enable a human-in-the-loop workflow in tools like Cline and Cursor.
USPTO - MCP server for accessing United States Patent & Trademark Office data through its Open Data Protocol (ODP) API.
Vectara - Query Vectara’s trusted RAG-as-a-service platform.
Vega-Lite - Generate visualizations from fetched data using the VegaLite format and renderer.
Vertica - Vertica database integration in Python with configurable access controls and schema inspection
Vibe Check - An MCP server leveraging an external oversight layer to “vibe check” agents, and also self-improve accuracy & user alignment over time. Prevents scope creep, code bloat, misalignment, misinterpretation, tunnel vision, and overcomplication.
Video Editor - A Model Context Protocol Server to add, edit, and search videos with Video Jungle.
Video Still Capture - 📷 Capture video stills from an OpenCV-compatible webcam or other video source.
Virtual location (Google Street View,etc.) - Integrates Google Map, Google Street View, PixAI, Stability.ai, ComfyUI API and Bluesky to provide a virtual location simulation in LLM (written in Effect.ts)
VolcEngine TOS - A sample MCP server for VolcEngine TOS that flexibly get objects from TOS.
Voyp - VOYP MCP server for making calls using Artificial Intelligence.
Wanaku MCP Router - The Wanaku MCP Router is a SSE-based MCP server that provides an extensible routing engine that allows integrating your enterprise systems with AI agents.
weather-mcp-server - Get real-time weather data for any location using weatherapi.
Webflow - Interfact with the Webflow APIs
whale-tracker-mcp - A mcp server for tracking cryptocurrency whale transactions.
WhatsApp MCP Server - MCP server for your personal WhatsApp handling individuals, groups, searching and sending.
Whois MCP - MCP server that performs whois lookup against domain, IP, ASN and TLD.
Wikidata MCP - Wikidata MCP server that interact with Wikidata, by searching identifiers, extracting metadata, and executing sparql query.
WildFly MCP - WildFly MCP server that enables LLM to interact with running WildFly servers (retrieve metrics, logs, invoke operations, …).
Windows CLI - MCP server for secure command-line interactions on Windows systems, enabling controlled access to PowerShell, CMD, and Git Bash shells.
Workflowy - A server that interacts with workflowy.
World Bank data API - A server that fetches data indicators available with the World Bank as part of their data API
Wren Engine - The Semantic Engine for Model Context Protocol(MCP) Clients and AI Agents
X (Twitter) (by EnesCinr) - Interact with twitter API. Post tweets and search for tweets by query.
X (Twitter) (by vidhupv) - Create, manage and publish X/Twitter posts directly through Claude chat.
Xcode - MCP server that brings AI to your Xcode projects, enabling intelligent code assistance, file operations, project management, and automated development tasks.
xcodebuild - 🍎 Build iOS Xcode workspace/project and feed back errors to llm.
Xero-mcp-server - Enabling clients to interact with Xero system for streamlined accounting, invoicing, and business operations.
XiYan - 🗄️ An MCP server that supports fetching data from a database using natural language queries, powered by XiyanSQL as the text-to-SQL LLM.
XMind - Read and search through your XMind directory containing XMind files.
yfinance -💹The MCP YFinance Stock Server provides real-time and historical stock data in a standard format, powering dashboards, AI agents,and research tools with seamless financial insights.
YNAB - A Model Context Protocol (MCP) server for integrating with YNAB (You Need A Budget), allowing AI assistants to securely access and analyze your financial data.
YouTube - Extract Youtube video information (with proxies support).
YouTube - Comprehensive YouTube API integration for video management, Shorts creation, and analytics.
YouTube Video Summarizer - Summarize lengthy youtube videos.
Zoom - Create, update, read and delete your zoom meetings.

📚 Frameworks

These are high-level frameworks that make it easier to build MCP servers or clients.

For servers

EasyMCP (TypeScript)

FastAPI to MCP auto generator – A zero-configuration tool for automatically exposing FastAPI endpoints as MCP tools by Tadata

FastMCP (TypeScript)
Foxy Contexts – A library to build MCP servers in Golang by strowk
Higress MCP Server Hosting - A solution for hosting MCP Servers by extending the API Gateway (based on Envoy) with wasm plugins.
MCP-Framework Build MCP servers with elegance and speed in Typescript. Comes with a CLI to create your project with mcp create app. Get started with your first server in under 5 minutes by Alex Andru
Quarkus MCP Server SDK (Java)
Spring AI MCP Server - Provides auto-configuration for setting up an MCP server in Spring Boot applications.
Template MCP Server - A CLI tool to create a new Model Context Protocol server project with TypeScript support, dual transport options, and an extensible structure

For clients

codemirror-mcp - CodeMirror extension that implements the Model Context Protocol (MCP) for resource mentions and prompt commands
Spring AI MCP Client - Provides auto-configuration for MCP client functionality in Spring Boot applications.

📚 Resources

Additional resources on MCP.

AiMCP - A collection of MCP clients&servers to find the right mcp tools by Hekmon
Awesome Crypto MCP Servers by badkk - A curated list of MCP servers by Luke Fan
Awesome MCP Servers by appcypher - A curated list of MCP servers by Stephen Akinyemi
Awesome MCP Servers by punkpeye (website) - A curated list of MCP servers by Frank Fiegel
Awesome MCP Servers by wong2 (website) - A curated list of MCP servers by wong2
Awesome Remote MCP Servers by JAW9C - A curated list of remote MCP servers, including thier authentication support by JAW9C
Discord Server – A community discord server dedicated to MCP by Frank Fiegel
Discord Server (ModelContextProtocol) – Connect with developers, share insights, and collaborate on projects in an active Discord community dedicated to the Model Context Protocol by Alex Andru
Klavis AI - Open Source MCP Infra. Hosted MCP servers and MCP clients on Slack and Discord.
MCP Badges – Quickly highlight your MCP project with clear, eye-catching badges, by Ironben
mcp-cli - A CLI inspector for the Model Context Protocol by wong2
mcp-dockmaster - An Open-Sourced UI to install and manage MCP servers for Windows, Linux and MacOS.
mcp-get - Command line tool for installing and managing MCP servers by Michael Latman
mcp-guardian - GUI application + tools for proxying / managing control of MCP servers by EQTY Lab
MCP Linker - A cross-platform Tauri GUI tool for one-click setup and management of MCP servers, supporting Claude Desktop, Cursor, Windsurf, VS Code, Cline, and Neovim.
mcp-manager - Simple Web UI to install and manage MCP servers for Claude Desktop by Zue
MCP Marketplace Web Plugin MCP Marketplace is a small Web UX plugin to integrate with AI applications, Support various MCP Server API Endpoint (e.g pulsemcp.com/deepnlp.org and more). Allowing user to browse, paginate and select various MCP servers by different categories. Pypi | Maintainer | Website
mcp.natoma.id – A Hosted MCP Platform to discover, install, manage and deploy MCP servers by Natoma Labs
mcp.run - A hosted registry and control plane to install & run secure + portable MCP Servers.
MCP Router – Free Windows and macOS app that simplifies MCP management while providing seamless app authentication and powerful log visualization by MCP Router
MCP Servers Hub (website) - A curated list of MCP servers by apappascs
MCP Servers Rating and User Reviews - Website to rate MCP servers, write authentic user reviews, and search engine for agent & mcp
MCP X Community – A X community for MCP by Xiaoyi
MCPHub – An Open Source macOS & Windows GUI Desktop app for discovering, installing and managing MCP servers by Jeamee
mcpm (website) - MCP Manager (MCPM) is a Homebrew-like service for managing Model Context Protocol (MCP) servers across clients by Pathintegral
MCPVerse - A portal for creating & hosting authenticated MCP servers and connecting to them securely.
MCPWatch - A comprehensive security scanner for Model Context Protocol (MCP) servers that detects vulnerabilities and security issues in your MCP server implementations.
mkinf - An Open Source registry of hosted MCP Servers to accelerate AI agent workflows.
Open-Sourced MCP Servers Directory - A curated list of MCP servers by mcpso
OpenTools - An open registry for finding, installing, and building with MCP servers by opentoolsteam
PulseMCP (API) - Community hub & weekly newsletter for discovering MCP servers, clients, articles, and news by Tadas Antanavicius, Mike Coughlin, and Ravina Patel
r/mcp – A Reddit community dedicated to MCP by Frank Fiegel
r/modelcontextprotocol – A Model Context Protocol community Reddit page - discuss ideas, get answers to your questions, network with like-minded people, and showcase your projects! by Alex Andru
Smithery - A registry of MCP servers to find the right tools for your LLM agents by Henry Mao
Toolbase - Desktop application that manages tools and MCP servers with just a few clicks - no coding required by gching
ToolHive - A lightweight utility designed to simplify the deployment and management of MCP servers, ensuring ease of use, consistency, and security through containerization by StacklokLabs

🚀 Getting Started

Using MCP Servers in this Repository

Typescript-based servers in this repository can be used directly with npx.

For example, this will start the Memory server:

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

Python-based servers in this repository can be used directly with uvx or pip. uvx is recommended for ease of use and setup.

For example, this will start the Git server:

# With uvx
uvx mcp-server-git

# With pip
pip install mcp-server-git
python -m mcp_server_git

Follow these instructions to install uv / uvx and these to install pip.

Using an MCP Client

However, running a server on its own isn’t very useful, and should instead be configured into an MCP client. For example, here’s the Claude Desktop configuration to use the above server:

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

Additional examples of using the Claude Desktop as an MCP client might look like:

{
  "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"]
    }
  }
}

🛠️ Creating Your Own Server

Interested in creating your own MCP server? Visit the official documentation at modelcontextprotocol.io for comprehensive guides, best practices, and technical details on implementing MCP servers.

🤝 Contributing

See CONTRIBUTING.md for information about contributing to this repository.

🔒 Security

See SECURITY.md for reporting security vulnerabilities.

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

💬 Community

GitHub Discussions

⭐ Support

If you find MCP servers useful, please consider starring the repository and contributing new servers or improvements!

Managed by Anthropic, but built together with the community. The Model Context Protocol is open source and we encourage everyone to contribute their own servers and improvements!

ruby-sdk

Fri, 06 Jun 2025 15:29:47 +0800

modelcontextprotocol/ruby-sdk

MCP Ruby SDK

The official Ruby SDK for Model Context Protocol servers and clients.

Installation

Add this line to your application’s Gemfile:

`1`	`gem 'mcp'`

And then execute:

`1`	`$ bundle install`

Or install it yourself as:

`1`	`$ gem install mcp`

MCP Server

The MCP::Server class is the core component that handles JSON-RPC requests and responses. It implements the Model Context Protocol specification, handling model context requests and responses.

Key Features

Implements JSON-RPC 2.0 message handling
Supports protocol initialization and capability negotiation
Manages tool registration and invocation
Supports prompt registration and execution
Supports resource registration and retrieval

Supported Methods

initialize - Initializes the protocol and returns server capabilities
ping - Simple health check
tools/list - Lists all registered tools and their schemas
tools/call - Invokes a specific tool with provided arguments
prompts/list - Lists all registered prompts and their schemas
prompts/get - Retrieves a specific prompt by name
resources/list - Lists all registered resources and their schemas
resources/read - Retrieves a specific resource by name
resources/templates/list - Lists all registered resource templates and their schemas

Unsupported Features ( to be implemented in future versions )

Notifications
Log Level
Resource subscriptions
Completions
Complete StreamableHTTP implementation with streaming responses

Usage

Rails Controller

When added to a Rails controller on a route that handles POST requests, your server will be compliant with non-streaming StreamableHTTP transport requests.

You can use the Server#handle_json method to handle requests.

class ApplicationController < ActionController::Base

  def index
    server = MCP::Server.new(
      name: "my_server",
      version: "1.0.0",
      tools: [SomeTool, AnotherTool],
      prompts: [MyPrompt],
      server_context: { user_id: current_user.id },
    )
    render(json: server.handle_json(request.body.read))
  end
end

Stdio Transport

If you want to build a local command-line application, you can use the stdio transport:

#!/usr/bin/env ruby
require "mcp"
require "mcp/server/transports/stdio_transport"

# Create a simple tool
class ExampleTool < MCP::Tool
  description "A simple example tool that echoes back its arguments"
  input_schema(
    properties: {
      message: { type: "string" },
    },
    required: ["message"]
  )

  class << self
    def call(message:, server_context:)
      MCP::Tool::Response.new([{
        type: "text",
        text: "Hello from example tool! Message: #{message}",
      }])
    end
  end
end

# Set up the server
server = MCP::Server.new(
  name: "example_server",
  tools: [ExampleTool],
)

# Create and start the transport
transport = MCP::Server::Transports::StdioTransport.new(server)
transport.open

You can run this script and then type in requests to the server at the command line.

1
2
3

$ ./examples/stdio_server.rb
{"jsonrpc":"2.0","id":"1","method":"ping"}
{"jsonrpc":"2.0","id":"2","method":"tools/list"}

Configuration

The gem can be configured using the MCP.configure block:

MCP.configure do |config|
  config.exception_reporter = ->(exception, server_context) {
    # Your exception reporting logic here
    # For example with Bugsnag:
    Bugsnag.notify(exception) do |report|
      report.add_metadata(:model_context_protocol, server_context)
    end
  }

  config.instrumentation_callback = ->(data) {
    puts "Got instrumentation data #{data.inspect}"
  }
end

or by creating an explicit configuration and passing it into the server. This is useful for systems where an application hosts more than one MCP server but they might require different instrumentation callbacks.

configuration = MCP::Configuration.new
configuration.exception_reporter = ->(exception, server_context) {
  # Your exception reporting logic here
  # For example with Bugsnag:
  Bugsnag.notify(exception) do |report|
    report.add_metadata(:model_context_protocol, server_context)
  end
}

configuration.instrumentation_callback = ->(data) {
  puts "Got instrumentation data #{data.inspect}"
}

server = MCP::Server.new(
  # ... all other options
  configuration:,
)

Server Context and Configuration Block Data

`server_context`

The server_context is a user-defined hash that is passed into the server instance and made available to tools, prompts, and exception/instrumentation callbacks. It can be used to provide contextual information such as authentication state, user IDs, or request-specific data.

Type:

`1`	`server_context: { [String, Symbol] => Any }`

Example:

server = MCP::Server.new(
  name: "my_server",
  server_context: { user_id: current_user.id, request_id: request.uuid }
)

This hash is then passed as the server_context argument to tool and prompt calls, and is included in exception and instrumentation callbacks.

Configuration Block Data

Exception Reporter

The exception reporter receives:

exception: The Ruby exception object that was raised
server_context: The context hash provided to the server

Signature:

`1`	`exception_reporter = ->(exception, server_context) { ... }`

Instrumentation Callback

The instrumentation callback receives a hash with the following possible keys:

method: (String) The protocol method called (e.g., “ping”, “tools/list”)
tool_name: (String, optional) The name of the tool called
prompt_name: (String, optional) The name of the prompt called
resource_uri: (String, optional) The URI of the resource called
error: (String, optional) Error code if a lookup failed
duration: (Float) Duration of the call in seconds

Type:

1
2

instrumentation_callback = ->(data) { ... }
# where data is a Hash with keys as described above

Example:

1
2
3

config.instrumentation_callback = ->(data) {
  puts "Instrumentation: #{data.inspect}"
}

Server Protocol Version

The server’s protocol version can be overridden using the protocol_version class method:

`1`	`MCP::Server.protocol_version = "2024-11-05"`

This will make all new server instances use the specified protocol version instead of the default version. The protocol version can be reset to the default by setting it to nil:

`1`	`MCP::Server.protocol_version = nil`

Be sure to check the MCP spec for the protocol version to understand the supported features for the version being set.

Exception Reporting

The exception reporter receives two arguments:

exception: The Ruby exception object that was raised
server_context: A hash containing contextual information about where the error occurred

The server_context hash includes:

For tool calls: { tool_name: "name", arguments: { ... } }
For general request handling: { request: { ... } }

When an exception occurs:

The exception is reported via the configured reporter
For tool calls, a generic error response is returned to the client: { error: "Internal error occurred", isError: true }
For other requests, the exception is re-raised after reporting

If no exception reporter is configured, a default no-op reporter is used that silently ignores exceptions.

Tools

MCP spec includes Tools which provide functionality to LLM apps.

This gem provides a MCP::Tool class that can be used to create tools in two ways:

As a class definition:

class MyTool < MCP::Tool
  description "This tool performs specific functionality..."
  input_schema(
    properties: {
      message: { type: "string" },
    },
    required: ["message"]
  )
  annotations(
    title: "My Tool",
    read_only_hint: true,
    destructive_hint: false,
    idempotent_hint: true,
    open_world_hint: false
  )

  def self.call(message:, server_context:)
    MCP::Tool::Response.new([{ type: "text", text: "OK" }])
  end
end

tool = MyTool

By using the MCP::Tool.define method with a block:

tool = MCP::Tool.define(
  name: "my_tool",
  description: "This tool performs specific functionality...",
  annotations: {
    title: "My Tool",
    read_only_hint: true
  }
) do |args, server_context|
  Tool::Response.new([{ type: "text", text: "OK" }])
end

The server_context parameter is the server_context passed into the server and can be used to pass per request information, e.g. around authentication state.

Tool Annotations

Tools can include annotations that provide additional metadata about their behavior. The following annotations are supported:

title: A human-readable title for the tool
read_only_hint: Indicates if the tool only reads data (doesn’t modify state)
destructive_hint: Indicates if the tool performs destructive operations
idempotent_hint: Indicates if the tool’s operations are idempotent
open_world_hint: Indicates if the tool operates in an open world context

Annotations can be set either through the class definition using the annotations class method or when defining a tool using the define method.

Prompts

MCP spec includes Prompts, which enable servers to define reusable prompt templates and workflows that clients can easily surface to users and LLMs.

The MCP::Prompt class provides two ways to create prompts:

As a class definition with metadata:

class MyPrompt < MCP::Prompt
  prompt_name "my_prompt"  # Optional - defaults to underscored class name
  description "This prompt performs specific functionality..."
  arguments [
    Prompt::Argument.new(
      name: "message",
      description: "Input message",
      required: true
    )
  ]

  class << self
    def template(args, server_context:)
      Prompt::Result.new(
        description: "Response description",
        messages: [
          Prompt::Message.new(
            role: "user",
            content: Content::Text.new("User message")
          ),
          Prompt::Message.new(
            role: "assistant",
            content: Content::Text.new(args["message"])
          )
        ]
      )
    end
  end
end

prompt = MyPrompt

Using the MCP::Prompt.define method:

prompt = MCP::Prompt.define(
  name: "my_prompt",
  description: "This prompt performs specific functionality...",
  arguments: [
    Prompt::Argument.new(
      name: "message",
      description: "Input message",
      required: true
    )
  ]
) do |args, server_context:|
  Prompt::Result.new(
    description: "Response description",
    messages: [
      Prompt::Message.new(
        role: "user",
        content: Content::Text.new("User message")
      ),
      Prompt::Message.new(
        role: "assistant",
        content: Content::Text.new(args["message"])
      )
    ]
  )
end

The server_context parameter is the server_context passed into the server and can be used to pass per request information, e.g. around authentication state or user preferences.

Key Components

Prompt::Argument - Defines input parameters for the prompt template
Prompt::Message - Represents a message in the conversation with a role and content
Prompt::Result - The output of a prompt template containing description and messages
Content::Text - Text content for messages

Usage

server = MCP::Server.new(
  name: "my_server",
  prompts: [MyPrompt],
  server_context: { user_id: current_user.id },
)

The server will handle prompt listing and execution through the MCP protocol methods:

prompts/list - Lists all registered prompts and their schemas
prompts/get - Retrieves and executes a specific prompt with arguments

Instrumentation

The server allows registering a callback to receive information about instrumentation. To register a handler pass a proc/lambda to as instrumentation_callback into the server constructor.

MCP.configure do |config|
  config.instrumentation_callback = ->(data) {
    puts "Got instrumentation data #{data.inspect}"
  }
end

The data contains the following keys: method: the metod called, e.g. ping, tools/list, tools/call etc tool_name: the name of the tool called prompt_name: the name of the prompt called resource_uri: the uri of the resource called error: if looking up tools/prompts etc failed, e.g. tool_not_found duration: the duration of the call in seconds

tool_name, prompt_name and resource_uri are only populated if a matching handler is registered. This is to avoid potential issues with metric cardinality

Resources

MCP spec includes Resources

The MCP::Resource class provides a way to register resources with the server.

resource = MCP::Resource.new(
  uri: "example.com/my_resource",
  mime_type: "text/plain",
  text: "Lorem ipsum dolor sit amet"
)

server = MCP::Server.new(
  name: "my_server",
  resources: [resource],
)

The server must register a handler for the resources/read method to retrieve a resource dynamically.

server.resources_read_handler do |params|
  [{
    uri: params[:uri],
    mimeType: "text/plain",
    text: "Hello, world!",
  }]
end

otherwise ‘resources/read’ requests will be a no-op.

Releases

This gem is published to RubyGems.org

Releases are triggered by PRs to the main branch updating the version number in lib/mcp/version.rb.

Update the version number in lib/mcp/version.rb, following semver
Create A PR and get approval from a maintainer
Merge your PR to the main branch - This will automatically trigger the release workflow via GitHub Actions

When changes are merged to the main branch, the GitHub Actions workflow (.github/workflows/release.yml) is triggered and the gem is published to RubyGems.

mcp-server-cloudflare

Mon, 05 May 2025 15:29:19 +0800

cloudflare/mcp-server-cloudflare

Cloudflare MCP Server

Model Context Protocol (MCP) is a new, standardized protocol for managing context between large language models (LLMs) and external systems. In this repository, you can find several MCP servers allowing you to connect to Cloudflare’s service from an MCP client (e.g. Cursor, Claude) and use natural language to accomplish tasks through your Cloudflare account.

These MCP servers allow your MCP Client to read configurations from your account, process information, make suggestions based on data, and even make those suggested changes for you. All of these actions can happen across cloudflare’s many services including application development, security and performance.

The following servers are included in this repository:

Server Name	Description	Server URL
Documentation server	Get up to date reference information on Cloudflare	`https://docs.mcp.cloudflare.com/sse`
Workers Bindings server	Build Workers applications with storage, AI, and compute primitives	`https://bindings.mcp.cloudflare.com/sse`
Observability server	Debug and get insight into your application’s logs and analytics	`https://observability.mcp.cloudflare.com/sse`
Radar server	Get global Internet traffic insights, trends, URL scans, and other utilities	`https://radar.mcp.cloudflare.com/sse`
Container server	Spin up a sandbox development environment	`https://containers.mcp.cloudflare.com/sse`
Browser rendering server	Fetch web pages, convert them to markdown and take screenshots	`https://browser.mcp.cloudflare.com/sse`
Logpush server	Get quick summaries for Logpush job health	`https://logs.mcp.cloudflare.com/sse`
AI Gateway server	Search your logs, get details about the prompts and responses	`https://ai-gateway.mcp.cloudflare.com/sse`
AutoRAG server	List and search documents on your AutoRAGs	`https://autorag.mcp.cloudflare.com/sse`
Audit Logs server	Query audit logs and generate reports for review	`https://auditlogs.mcp.cloudflare.com/sse`
DNS Analytics server	Optimize DNS performance and debug issues based on current set up	`https://dns-analytics.mcp.cloudflare.com/sse`
Digital Experience Monitoring server	Get quick insight on critical applications for your organization	`https://dex.mcp.cloudflare.com/sse`
Cloudflare One CASB server	Quickly identify any security misconfigurations for SaaS applications to safeguard users & data	`https://casb.mcp.cloudflare.com/sse`

Access the remote MCP server from any MCP client

If your MCP client has first class support for remote MCP servers, the client will provide a way to accept the server URL directly within its interface (e.g. Cloudflare AI Playground)

If your client does not yet support remote MCP servers, you will need to set up its resepective configuration file using mcp-remote (https://www.npmjs.com/package/mcp-remote) to specify which servers your client can access.

{
	"mcpServers": {
		"cloudflare-observability": {
			"command": "npx",
			"args": ["mcp-remote", "https://observability.mcp.cloudflare.com/sse"]
		},
		"cloudflare-bindings": {
			"command": "npx",
			"args": ["mcp-remote", "https://bindings.mcp.cloudflare.com/sse"]
		}
	}
}

Need access to more Cloudflare tools?

We’re continuing to add more functionality to this remote MCP server repo. If you’d like to leave feedback, file a bug or provide a feature request, please open an issue on this repository

Troubleshooting

“Claude’s response was interrupted … "

If you see this message, Claude likely hit its context-length limit and stopped mid-reply. This happens most often on servers that trigger many chained tool calls such as the observability server.

To reduce the chance of running in to this issue:

Try to be specific, keep your queries concise.
If a single request calls multiple tools, try to to break it into several smaller tool calls to keep the responses short.

Paid Features

Some features may require a paid Cloudflare Workers plan. Ensure your Cloudflare account has the necessary subscription level for the features you intend to use.

Contributing

Interested in contributing, and running this server locally? See CONTRIBUTING.md to get started.

DesktopCommanderMCP

Sat, 03 May 2025 15:26:01 +0800

wonderwhy-er/DesktopCommanderMCP

Desktop Commander MCP

Search, update, manage files and run terminal commands with AI

Work with code and text, run processes, and automate tasks, going far beyond other AI editors - without API token costs.

All of your AI development tools in one place. Desktop Commander puts all dev tools in one chat. Execute long-running terminal commands on your computer and manage processes through Model Context Protocol (MCP). Built on top of MCP Filesystem Server to provide additional search and replace file editing capabilities.

Features

Execute terminal commands with output streaming
Command timeout and background execution support
Process management (list and kill processes)
Session management for long-running commands
Server configuration management:
- Get/set configuration values
- Update multiple settings at once
- Dynamic configuration changes without server restart
Full filesystem operations:
- Read/write files
- Create/list directories
- Move files/directories
- Search files
- Get file metadata
Code editing capabilities:
- Surgical text replacements for small changes
- Full file rewrites for major changes
- Multiple file support
- Pattern-based replacements
- vscode-ripgrep based recursive code or text search in folders

Installation

First, ensure you’ve downloaded and installed the Claude Desktop app and you have npm installed.

Option 1: Install through npx

Just run this in terminal:

`1`	`npx @wonderwhy-er/desktop-commander@latest setup`

For debugging mode (allows Node.js inspector connection):

`1`	`npx @wonderwhy-er/desktop-commander@latest setup --debug`

Restart Claude if running.

Option 2: Using bash script installer (macOS)

For macOS users, you can use our automated bash installer which will check your Node.js version, install it if needed, and automatically configure Desktop Commander:

`1`	`curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install.sh \| bash`

This script handles all dependencies and configuration automatically for a seamless setup experience.

Option 3: Installing via Smithery

To install Desktop Commander for Claude Desktop automatically via Smithery:

`1`	`npx -y @smithery/cli install @wonderwhy-er/desktop-commander --client claude`

Option 4: Add to claude_desktop_config manually

Add this entry to your claude_desktop_config.json:

On Mac: ~/Library/Application\ Support/Claude/claude_desktop_config.json
On Windows: %APPDATA%\Claude\claude_desktop_config.json
On Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": [
        "-y",
        "@wonderwhy-er/desktop-commander"
      ]
    }
  }
}

Restart Claude if running.

Option 5: Checkout locally

Clone and build:

1
2
3

git clone https://github.com/wonderwhy-er/DesktopCommanderMCP.git
cd DesktopCommanderMCP
npm run setup

Restart Claude if running.

The setup command will:

Install dependencies
Build the server
Configure Claude’s desktop app
Add MCP servers to Claude’s config if needed

Updating Desktop Commander

When installed through npx (Option 1) or Smithery (Option 3), Desktop Commander will automatically update to the latest version whenever you restart Claude. No manual update process is needed.

For manual installations, you can update by running the setup command again.

Usage

The server provides a comprehensive set of tools organized into several categories:

Available Tools

Category	Tool	Description
Configuration	`get_config`	Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories)
	`set_config_value`	Set a specific configuration value by key. Available settings: • `blockedCommands`: Array of shell commands that cannot be executed • `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell) • `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories)
Terminal	`execute_command`	Execute a terminal command with configurable timeout and shell selection
	`read_output`	Read new output from a running terminal session
	`force_terminate`	Force terminate a running terminal session
	`list_sessions`	List all active terminal sessions
	`list_processes`	List all running processes with detailed information
	`kill_process`	Terminate a running process by PID
Filesystem	`read_file`	Read contents from local filesystem or URLs (supports text and images)
	`read_multiple_files`	Read multiple files simultaneously
	`write_file`	Completely replace file contents (best for large changes)
	`create_directory`	Create a new directory or ensure it exists
	`list_directory`	Get detailed listing of files and directories
	`move_file`	Move or rename files and directories
	`search_files`	Find files by name using case-insensitive substring matching
	`search_code`	Search for text/code patterns within file contents using ripgrep
	`get_file_info`	Retrieve detailed metadata about a file or directory
Text Editing	`edit_block`	Apply surgical text replacements (best for changes <20% of file size)

Tool Usage Examples

Search/Replace Block Format:

filepath.ext
<<<<<<< SEARCH
content to find
=======
new content
>>>>>>> REPLACE

Example:

src/main.js
<<<<<<< SEARCH
console.log("old message");
=======
console.log("new message");
>>>>>>> REPLACE

URL Support

read_file can now fetch content from both local files and URLs
Example: read_file with isUrl: true parameter to read from web resources
Handles both text and image content from remote sources
Images (local or from URLs) are displayed visually in Claude’s interface, not as text
Claude can see and analyze the actual image content
Default 30-second timeout for URL requests

Handling Long-Running Commands

For commands that may take a while:

Configuration Management

⚠️ Important Security Warnings

Always change configuration in a separate chat window from where you’re doing your actual work. Claude may sometimes attempt to modify configuration settings (like allowedDirectories) if it encounters filesystem access restrictions.
The allowedDirectories setting currently only restricts filesystem operations, not terminal commands. Terminal commands can still access files outside allowed directories. Full terminal sandboxing is on the roadmap.

Configuration Tools

You can manage server configuration using the provided tools:

// Get the entire config
get_config({})

// Set a specific config value
set_config_value({ "key": "defaultShell", "value": "/bin/zsh" })

// Set multiple config values using separate calls
set_config_value({ "key": "defaultShell", "value": "/bin/bash" })
set_config_value({ "key": "allowedDirectories", "value": ["/Users/username/projects"] })

The configuration is saved to config.json in the server’s working directory and persists between server restarts.

Best Practices

Create a dedicated chat for configuration changes: Make all your config changes in one chat, then start a new chat for your actual work.
Be careful with empty allowedDirectories: Setting this to an empty array ([]) grants access to your entire filesystem for file operations.
Use specific paths: Instead of using broad paths like /, specify exact directories you want to access.
Always verify configuration after changes: Use get_config({}) to confirm your changes were applied correctly.

Using Different Shells

You can specify which shell to use for command execution:

// Using default shell (bash or system default)
execute_command({ "command": "echo $SHELL" })

// Using zsh specifically
execute_command({ "command": "echo $SHELL", "shell": "/bin/zsh" })

// Using bash specifically
execute_command({ "command": "echo $SHELL", "shell": "/bin/bash" })

This allows you to use shell-specific features or maintain consistent environments across commands.

execute_command returns after timeout with initial output
Command continues in background
Use read_output with PID to get new output
Use force_terminate to stop if needed

Debugging

If you need to debug the server, you can install it in debug mode:

# Using npx
npx @wonderwhy-er/desktop-commander@latest setup --debug

# Or if installed locally
npm run setup:debug

This will:

Configure Claude to use a separate “desktop-commander” server
Enable Node.js inspector protocol with --inspect-brk=9229 flag
Pause execution at the start until a debugger connects
Enable additional debugging environment variables

To connect a debugger:

In Chrome, visit chrome://inspect and look for the Node.js instance
In VS Code, use the “Attach to Node Process” debug configuration
Other IDEs/tools may have similar “attach” options for Node.js debugging

Important debugging notes:

The server will pause on startup until a debugger connects (due to the --inspect-brk flag)
If you don’t see activity during debugging, ensure you’re connected to the correct Node.js process
Multiple Node processes may be running; connect to the one on port 9229
The debug server is identified as “desktop-commander-debug” in Claude’s MCP server list

Troubleshooting:

If Claude times out while trying to use the debug server, your debugger might not be properly connected
When properly connected, the process will continue execution after hitting the first breakpoint
You can add additional breakpoints in your IDE once connected

Model Context Protocol Integration

This project extends the MCP Filesystem Server to enable:

Local server support in Claude Desktop
Full system command execution
Process management
File operations
Code editing with search/replace blocks

Created as part of exploring Claude MCPs: https://youtube.com/live/TlbjFDbl5Us

DONE

29-04-2025 Telemetry Opt Out trought configuration - There is now setting to disable telemetry in config, ask in chat
23-04-2025 Enhanced edit functionality - Improved format, added fuzzy search and multi-occurrence replacements, should fail less and use edit block more often
16-04-2025 Better configurations - Improved settings for allowed paths, commands and shell environments
14-04-2025 Windows environment fixes - Resolved issues specific to Windows platforms
14-04-2025 Linux improvements - Enhanced compatibility with various Linux distributions
12-04-2025 Better allowed directories and blocked commands - Improved security and path validation for file read/write and terminal command restrictions. Terminal still can access files ignoring allowed directories.
11-04-2025 Shell configuration - Added ability to configure preferred shell for command execution
07-04-2025 Added URL support - read_file command can now fetch content from URLs
28-03-2025 Fixed “Watching /” JSON error - Implemented custom stdio transport to handle non-JSON messages and prevent server crashes
25-03-2025 Better code search (merged) - Enhanced code exploration with context-aware results

Work in Progress/TODOs/Roadmap

The following features are currently being explored:

Support for WSL - Windows Subsystem for Linux integration
Support for SSH - Remote server command execution
Better file support for formats like CSV/PDF
Terminal sandboxing for Mac/Linux/Windows for better security
File reading modes - For example, allow reading HTML as plain text or markdown
Interactive shell support - ssh, node/python repl
Improve large file reading and writing

❤️ Support Desktop Commander

📢 SUPPORT THIS PROJECT

Desktop Commander MCP is free and open source, but needs your support to thrive!

Our philosophy is simple: we don't want you to pay for it if you're not successful. But if Desktop Commander contributes to your success, please consider contributing to ours.

Ways to support:

🌟 GitHub Sponsors - Recurring support
☕ Buy Me A Coffee - One-time contributions
⭐ Star on GitHub - Help others discover the project

Supporters Hall of Fame

Generous supporters are featured here. Thank you for helping make this project possible!

_{Jon Richards}

_{Matija Stepanic}

Why your support matters

Your support allows us to:

Continue active development and maintenance
Add new features and integrations
Improve compatibility across platforms
Provide better documentation and examples
Build a stronger community around the project

Website

Visit our official website at https://desktopcommander.app/ for the latest information, documentation, and updates.

Media

Learn more about this project through these resources:

Article

Claude with MCPs replaced Cursor & Windsurf. How did that happen? - A detailed exploration of how Claude with Model Context Protocol capabilities is changing developer workflows.

Video

Claude Desktop Commander Video Tutorial - Watch how to set up and use the Commander effectively.

Publication at AnalyticsIndiaMag

This Developer Ditched Windsurf, Cursor Using Claude with MCPs

Community

Join our Discord server to get help, share feedback, and connect with other users.

Testimonials

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyyBt6_ShdDX_rIOad4AaABAg

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgztdHvDMqTb9jiqnf54AaABAg

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyQFTmYLJ4VBwIlmql4AaABAg

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=Ugy4-exy166_Ma7TH-h4AaABAg

https://medium.com/@pharmx/you-sir-are-my-hero-62cff5836a3e

If you find this project useful, please consider giving it a ⭐ star on GitHub! This helps others discover the project and encourages further development.

We welcome contributions from the community! Whether you’ve found a bug, have a feature request, or want to contribute code, here’s how you can help:

Found a bug? Open an issue at github.com/wonderwhy-er/DesktopCommanderMCP/issues
Have a feature idea? Submit a feature request in the issues section
Want to contribute code? Fork the repository, create a branch, and submit a pull request
Questions or discussions? Start a discussion in the GitHub Discussions tab

All contributions, big or small, are greatly appreciated!

If you find this tool valuable for your workflow, please consider supporting the project.

Frequently Asked Questions

Here are answers to some common questions. For a more comprehensive FAQ, see our detailed FAQ document.

What is Desktop Commander?

It’s an MCP tool that enables Claude Desktop to access your file system and terminal, turning Claude into a versatile assistant for coding, automation, codebase exploration, and more.

How is this different from Cursor/Windsurf?

Unlike IDE-focused tools, Claude Desktop Commander provides a solution-centric approach that works with your entire OS, not just within a coding environment. Claude reads files in full rather than chunking them, can work across multiple projects simultaneously, and executes changes in one go rather than requiring constant review.

Do I need to pay for API credits?

No. This tool works with Claude Desktop’s standard Pro subscription ($20/month), not with API calls, so you won’t incur additional costs beyond the subscription fee.

Does Desktop Commander automatically update?

Yes, when installed through npx or Smithery, Desktop Commander automatically updates to the latest version when you restart Claude. No manual update process is needed.

What are the most common use cases?

Exploring and understanding complex codebases
Generating diagrams and documentation
Automating tasks across your system
Working with multiple projects simultaneously
Making surgical code changes with precise control

I’m having trouble installing or using the tool. Where can I get help?

Join our Discord server for community support, check the GitHub issues for known problems, or review the full FAQ for troubleshooting tips. You can also visit our website FAQ section for a more user-friendly experience. If you encounter a new issue, please consider opening a GitHub issue with details about your problem.

Data Collection & Privacy

Desktop Commander collects limited anonymous telemetry data to help improve the tool. No personal information, file contents, file paths, or command arguments are collected.

Telemetry is enabled by default. To opt out:

Open the chat and simply ask: “Disable telemetry”
The chatbot will update your settings automatically.

For complete details about data collection, please see our Privacy Policy.

License

MIT

exa-mcp-server

Mon, 28 Apr 2025 15:56:41 +0800

exa-labs/exa-mcp-server

Exa MCP Server 🔍

A Model Context Protocol (MCP) server lets AI assistants like Claude use the Exa AI Search API for web searches. This setup allows AI models to get real-time web information in a safe and controlled way.

Demo video https://www.loom.com/share/ac676f29664e4c6cb33a2f0a63772038?sid=0e72619f-5bfc-415d-a705-63d326373f60

What is MCP? 🤔

The Model Context Protocol (MCP) is a system that lets AI apps, like Claude Desktop, connect to external tools and data sources. It gives a clear and safe way for AI assistants to work with local services and APIs while keeping the user in control.

What does this server do? 🚀

The Exa MCP server:

Enables AI assistants to perform web searches using Exa’s powerful search API
Provides structured search results including titles, URLs, and content snippets
Caches recent searches as resources for reference
Handles rate limiting and error cases gracefully
Supports real-time web crawling for fresh content

Prerequisites 📋

Before you begin, ensure you have:

Node.js (v18 or higher)
Claude Desktop installed
An Exa API key
Git installed

You can verify your Node.js installation by running:

`1`	`node --version # Should show v18.0.0 or higher`

Installation 🛠️

NPM Installation

`1`	`npm install -g exa-mcp-server`

Using Smithery

To install the Exa MCP server for Claude Desktop automatically via Smithery:

`1`	`npx -y @smithery/cli install exa --client claude`

Manual Installation

Clone the repository:

1
2

git clone https://github.com/exa-labs/exa-mcp-server.git
cd exa-mcp-server

Install dependencies:

`1`	`npm install`

Build the project:

`1`	`npm run build`

Create a global link (this makes the server executable from anywhere):

`1`	`npm link`

Configuration ⚙️

1. Configure Claude Desktop to recognize the Exa MCP server

You can find claude_desktop_config.json inside the settings of Claude Desktop app:

Open the Claude Desktop app and enable Developer Mode from the top-left menu bar.

Once enabled, open Settings (also from the top-left menu bar) and navigate to the Developer Option, where you’ll find the Edit Config button. Clicking it will open the claude_desktop_config.json file, allowing you to make the necessary edits.

OR (if you want to open claude_desktop_config.json from terminal)

For macOS:

Open your Claude Desktop configuration:

`1`	`code ~/Library/Application\ Support/Claude/claude_desktop_config.json`

For Windows:

Open your Claude Desktop configuration:

`1`	`code %APPDATA%\Claude\claude_desktop_config.json`

2. Add the Exa server configuration:

{
  "mcpServers": {
    "exa": {
      "command": "npx",
      "args": ["/path/to/exa-mcp-server/build/index.js"],
      "env": {
        "EXA_API_KEY": "your-api-key-here"
      }
    }
  }
}

Replace your-api-key-here with your actual Exa API key from dashboard.exa.ai/api-keys.

3. Available Tools & Tool Selection

The Exa MCP server includes the following tools:

web_search_exa: Performs real-time web searches with optimized results and content extraction.
research_paper_search: Specialized search focused on academic papers and research content.
twitter_search: Dedicated Twitter/X.com search that finds tweets, profiles, and conversations.
company_research: Comprehensive company research tool that crawls company websites to gather detailed information about businesses.
crawling: Extracts content from specific URLs, useful for reading articles, PDFs, or any web page when you have the exact URL.
competitor_finder: Identifies competitors of a company by searching for businesses offering similar products or services.
linkedin_search: Search LinkedIn for companies and people using Exa AI. Simply include company names, person names, or specific LinkedIn URLs in your query.

You can choose which tools to enable by adding the --tools parameter to your Claude Desktop configuration:

Specify which tools to enable:

{
  "mcpServers": {
    "exa": {
      "command": "npx",
      "args": [
        "/path/to/exa-mcp-server/build/index.js",
        "--tools=web_search_exa,research_paper_search,twitter_search,company_research,crawling,competitor_finder,linkedin_search"
      ],
      "env": {
        "EXA_API_KEY": "your-api-key-here"
      }
    }
  }
}

For enabling multiple tools, use a comma-separated list:

{
  "mcpServers": {
    "exa": {
      "command": "npx",
      "args": [
        "/path/to/exa-mcp-server/build/index.js",
        "--tools=web_search_exa,research_paper_search,twitter_search,company_research,crawling,competitor_finder,linkedin_search"
      ],
      "env": {
        "EXA_API_KEY": "your-api-key-here"
      }
    }
  }
}

If you don’t specify any tools, all tools enabled by default will be used.

4. Restart Claude Desktop

For the changes to take effect:

Completely quit Claude Desktop (not just close the window)
Start Claude Desktop again
Look for the 🔌 icon to verify the Exa server is connected

Using via NPX

If you prefer to run the server directly, you can use npx:

# Run with all tools enabled by default
npx exa-mcp-server

# Enable specific tools only
npx exa-mcp-server --tools=web_search_exa

# Enable multiple tools
npx exa-mcp-server --tools=web_search_exa,research_paper_search

# List all available tools
npx exa-mcp-server --list-tools

Usage 🎯

Once configured, you can ask Claude to perform web searches. Here are some example prompts:

`1`	`Can you search for recent developments in quantum computing?`

`1`	`Find and analyze recent research papers about climate change solutions.`

`1`	`Search Twitter for posts from @elonmusk about SpaceX.`

`1`	`Find tweets from @samaltman that were published in the last week about AI safety.`

`1`	`Research the company exa.ai and find information about their pricing and features.`

`1`	`Extract the content from this research paper: https://arxiv.org/pdf/1706.03762`

`1`	`Find competitors for a company that provides web search API services, excluding exa.ai from the results.`

`1`	`Find the LinkedIn profile for Anthropic company.`

`1`	`Search for data scientists at OpenAI on LinkedIn.`

The server will:

Process the search request
Query the Exa API with optimal settings (including live crawling)
Return formatted results to Claude
Cache the search for future reference

Testing with MCP Inspector 🔍

You can test the server directly using the MCP Inspector:

`1`	`npx @modelcontextprotocol/inspector node ./build/index.js`

This opens an interactive interface where you can explore the server’s capabilities, execute search queries, and view cached search results.

Troubleshooting 🔧

Common Issues

Server Not Found
- Verify the npm link is correctly set up
- Check Claude Desktop configuration syntax
- Ensure Node.js is properly installed
API Key Issues
- Confirm your EXA_API_KEY is valid
- Check the EXA_API_KEY is correctly set in the Claude Desktop config
- Verify no spaces or quotes around the API key

Connection Issues

Restart Claude Desktop completely
Check Claude Desktop logs:

# macOS
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log

# Windows
type "%APPDATA%\Claude\logs\mcp*.log"

Acknowledgments 🙏

Exa AI for their powerful search API
Model Context Protocol for the MCP specification
Anthropic for Claude Desktop

supabase-mcp

Thu, 10 Apr 2025 15:27:28 +0800

supabase-community/supabase-mcp

Supabase MCP Server

Connect your Supabase projects to Cursor, Claude, Windsurf, and other AI assistants.

The Model Context Protocol (MCP) standardizes how Large Language Models (LLMs) talk to external services like Supabase. It connects AI assistants directly with your Supabase project and allows them to perform tasks like managing tables, fetching config, and querying data. See the full list of tools.

Prerequisites

You will need Node.js installed on your machine. You can check this by running:

node -v

If you don’t have Node.js installed, you can download it from nodejs.org.

Setup

1. Personal access token (PAT)

First, go to your Supabase settings and create a personal access token. Give it a name that describes its purpose, like “Cursor MCP Server”.

This will be used to authenticate the MCP server with your Supabase account. Make sure to copy the token, as you won’t be able to see it again.

2. Configure MCP client

Next, configure your MCP client (such as Cursor) to use this server. Most MCP clients store the configuration as JSON in the following format:

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": [
        "-y",
        "@supabase/mcp-server-supabase@latest",
        "--access-token",
        "<personal-access-token>"
      ]
    }
  }
}

Replace <personal-access-token> with the token you created in step 1. Alternatively you can omit --access-token and instead set the SUPABASE_ACCESS_TOKEN environment variable to your personal access token (you will need to restart your MCP client after setting this). This allows you to keep your token out of version control if you plan on committing this configuration to a repository.

If you are on Windows, you will need to prefix the command. If your MCP client doesn’t accept JSON, the direct CLI command is:

`1`	`npx -y @supabase/mcp-server-supabase@latest --access-token=<personal-access-token>`

Note: Do not run this command directly - this is meant to be executed by your MCP client in order to start the server. npx automatically downloads the latest version of the MCP server from npm and runs it in a single command.

Windows

On Windows, you will need to prefix the command with cmd /c:

{
  "mcpServers": {
    "supabase": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@supabase/mcp-server-supabase@latest",
        "--access-token",
        "<personal-access-token>"
      ]
    }
  }
}

or with wsl if you are running Node.js inside WSL:

{
  "mcpServers": {
    "supabase": {
      "command": "wsl",
      "args": [
        "npx",
        "-y",
        "@supabase/mcp-server-supabase@latest",
        "--access-token",
        "<personal-access-token>"
      ]
    }
  }
}

Make sure Node.js is available in your system PATH environment variable. If you are running Node.js natively on Windows, you can set this by running the following commands in your terminal.

Get the path to npm:
1

npm config get prefix
Add the directory to your PATH:
1

setx PATH "%PATH%;<path-to-dir>"
Restart your MCP client.

Tools

Note: This server is pre-1.0, so expect some breaking changes between versions. Since LLMs will automatically adapt to the tools available, this shouldn’t affect most users.

The following Supabase tools are available to the LLM:

Project Management

list_projects: Lists all Supabase projects for the user.
get_project: Gets details for a project.
create_project: Creates a new Supabase project.
pause_project: Pauses a project.
restore_project: Restores a project.
list_organizations: Lists all organizations that the user is a member of.
get_organization: Gets details for an organization.

Database Operations

list_tables: Lists all tables within the specified schemas.
list_extensions: Lists all extensions in the database.
list_migrations: Lists all migrations in the database.
apply_migration: Applies a SQL migration to the database. SQL passed to this tool will be tracked within the database, so LLMs should use this for DDL operations (schema changes).
execute_sql: Executes raw SQL in the database. LLMs should use this for regular queries that don’t change the schema.
get_logs: Gets logs for a Supabase project by service type (api, postgres, edge functions, auth, storage, realtime). LLMs can use this to help with debugging and monitoring service performance.

Project Configuration

get_project_url: Gets the API URL for a project.
get_anon_key: Gets the anonymous API key for a project.

Branching (Experimental, requires a paid plan)

create_branch: Creates a development branch with migrations from production branch.
list_branches: Lists all development branches.
delete_branch: Deletes a development branch.
merge_branch: Merges migrations and edge functions from a development branch to production.
reset_branch: Resets migrations of a development branch to a prior version.
rebase_branch: Rebases development branch on production to handle migration drift.

Development Tools

generate_typescript_types: Generates TypeScript types based on the database schema. LLMs can save this to a file and use it in their code.

Cost Confirmation

get_cost: Gets the cost of a new project or branch for an organization.
confirm_cost: Confirms the user’s understanding of new project or branch costs. This is required to create a new project or branch.

Other MCP servers

`@supabase/mcp-server-postgrest`

The PostgREST MCP server allows you to connect your own users to your app via REST API. See more details on its project README.

Resources

Model Context Protocol: Learn more about MCP and its capabilities.

License

This project is licensed under Apache 2.0. See the LICENSE file for details.

Model Context Protocol on Producthunt daily

mcp

awslabs/mcp

AWS MCP Servers

Table of Contents

What is the Model Context Protocol (MCP) and how does it work with AWS MCP Servers?

AWS MCP Servers Transport Mechanisms

Supported transport mechanisms

Server Sent Events Support Removal

Why AWS MCP Servers?

Available MCP Servers: Quick Installation

🚀 Getting Started with AWS

Browse by What You’re Building

📚 Real-time access to official AWS documentation

🏗️ Infrastructure & Deployment

Container Platforms

Serverless & Functions

Support

🤖 AI & Machine Learning

📊 Data & Analytics

SQL & NoSQL Databases

Search & Analytics

Backend API Providers

Caching & Performance

🛠️ Developer Tools & Support

📡 Integration & Messaging

💰 Cost & Operations

🧬 Healthcare & Lifesciences

Browse by How You’re Working

👨‍💻 Vibe Coding & Development

Core Development Workflow

Infrastructure as Code

Application Development

Container & Serverless Development

Testing & Data

Lifesciences Workflow Development

Healthcare Data Management

💬 Conversational Assistants

Knowledge & Search

Content Processing & Generation

Business Services

🤖 Autonomous Background Agents

Data Operations & ETL

Caching & Performance

Workflow & Integration

Operations & Monitoring

MCP AWS Lambda Handler Module

When to use Local vs Remote MCP Servers?

Local MCP Servers

Remote MCP Servers

Use Cases for the Servers

Installation and Setup

For macOS/Linux

For Windows

Running MCP servers in containers

Getting Started with Amazon Q Developer CLI

~/.aws/amazonq/mcp.json

Getting Started with Kiro

kiro_mcp_settings.json

Getting Started with Cline and Amazon Bedrock

cline_mcp_settings.json

Getting Started with Cursor

.cursor/mcp.json

Getting Started with Windsurf

~/.codeium/windsurf/mcp_config.json

Getting Started with VS Code

.vscode/mcp.json

Getting Started with Claude Code

.mcp.json

Samples

Vibe coding

Additional Resources

Security

Contributing

Developer guide

License

Disclaimer

mcp-context-forge

IBM/mcp-context-forge

MCP Gateway

`~/.aws/amazonq/mcp.json`

`kiro_mcp_settings.json`

`cline_mcp_settings.json`

`.cursor/mcp.json`

`~/.codeium/windsurf/mcp_config.json`

`.vscode/mcp.json`

`.mcp.json`

Testing `mcpgateway.wrapper` by hand:

🧩 Running from an MCP Client (`mcpgateway.wrapper`)

1 - Install `uv` (`uvx` is an alias it provides)

Configuration (`.env` or env vars)