Discover Awesome MCP Servers

MCP Gold Price Server

Provides real-time gold prices from Vietnamese and international markets via the vang.today API.

Fast Diff MCP Server

A high-performance Model Context Protocol server that provides text diffing capabilities, enabling LLMs to compare two blocks of text and receive differences in unified diff format.

foglift-mcp

MCP server for website SEO + GEO analysis. Scan any URL to get scores across 5 categories (SEO, GEO, Performance, Security, Accessibility) with actionable fix recommendations. Enables AI coding assistants to audit websites and implement fixes autonomously.

personal-mcp-server

A Model Context Protocol server that exposes personal data tools for Spotify listening history, movie ratings, and GitHub repos, enabling natural language queries from MCP clients.

blockscout-mcp-server

A read-only MCP server that queries multichain EVM on-chain data through Blockscout REST API, providing tools for address info, transactions, logs, and more.

@shuji-bonji/pdf-spec-mcp

An MCP (Model Context Protocol) server that provides structured access to ISO 32000 (PDF) specification documents. Enables LLMs to navigate, search, and analyze PDF specifications through well-defined tools.

MCP Server Scaffold

A production-ready, security-first starting point for building Model Context Protocol servers, enforcing safe defaults like dry-run and tenant isolation.

Cairo Coder

The most powerful open-source Cairo code generator.

DDG Web Search

Enables web search via DuckDuckGo and web content fetching through the Model Context Protocol, allowing AI assistants to search and retrieve web page content.

SQLPrism

An MCP server that indexes SQL codebases into a queryable knowledge graph backed by DuckDB, enabling structural SQL queries instead of grep.

PPTX MCP Server

Enables creating, editing, and reading PowerPoint presentations (PPTX) with security features like ZIP bomb protection, macro detection, and path traversal prevention.

kwrds.ai MCP Server

Model Context Protocol server that enables AI assistants to perform keyword research, SEO analysis, and content planning through natural language queries against kwrds.ai's SEO tools.

being-human

MCP server that analyzes your writing style to generate personal voice rules, scores drafts for AI slop, and verifies authorship, enabling LLMs to write in your specific voice.

@aix/kanbn-mcp

An MCP server that enables AI assistants to interact with Kan boards through the Kanban API, allowing tasks like viewing and managing boards via natural language.

GetMailer MCP Server

Enables sending transactional emails through GetMailer from AI assistants. Supports email operations, template management, domain verification, analytics, suppression lists, and batch email jobs.

Todoist MCP Server

Provides 44 tools to interact with the Todoist API v1, enabling task, project, and label management, with read, write, and destructive operations.

mcp-kubernetes

Enables MCP clients to inspect and operate Kubernetes clusters across multiple contexts, with read-only/read-write/admin access modes and security flags controlling namespaces, contexts, deletes, applies, and exec.

aica - AI Code Analyzer

aica (Analizador de Código con IA) revisa tu código usando IA. Compatible con CLI y Acciones de GitHub.

mcp-server-pdf

An MCP server that downloads PDF files from URLs and converts them to Markdown format. Supports custom file names and directories, with security measures like SSRF protection.

ai-readiness

Generates a complete suite of AI readiness files (llms.txt, ai.txt, schema, RAG indexes) for any website to optimize representation in ChatGPT, Claude, Gemini, and Perplexity.

example-mcp-server

Okay, I can provide you with an example of what an Anthropic MCP (Model Control Plane) server might look like. It's important to understand that Anthropic doesn't publicly release the *exact* code for their internal infrastructure. However, we can create a simplified, illustrative example that demonstrates the core concepts and functionalities. This example will be a Python-based server using a framework like Flask or FastAPI. It will simulate the key aspects of an MCP, such as: * **Model Registry:** Keeping track of available models, their versions, and metadata. * **Request Routing:** Directing incoming requests to the appropriate model. * **Rate Limiting:** Controlling the usage of models to prevent overload. * **Monitoring/Logging:** Tracking requests, errors, and model performance. * **Authentication/Authorization (Simplified):** Checking if a user/application is allowed to access a model. Here's the example code using FastAPI: ```python from fastapi import FastAPI, HTTPException, Depends, Header from pydantic import BaseModel from typing import Optional, Dict import time import logging import os # Configure logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') app = FastAPI() # --- Model Registry (In-Memory for this example) --- models = { "claude-v1": { "versions": ["1.0", "1.1"], "metadata": {"description": "Claude model version 1"}, "rate_limit": 10, # Requests per minute "last_request_time": 0, }, "claude-v2": { "versions": ["2.0"], "metadata": {"description": "Claude model version 2"}, "rate_limit": 5, "last_request_time": 0, }, } # --- Authentication (Simplified - Replace with a real auth system) --- API_KEY = os.environ.get("ANTHROPIC_API_KEY", "YOUR_DEFAULT_API_KEY") # Get API key from environment variable async def verify_api_key(x_api_key: str = Header(...)): """ Dependency to verify the API key. """ if x_api_key != API_KEY: raise HTTPException(status_code=401, detail="Invalid API Key") return True # --- Request/Response Models --- class Request(BaseModel): model_name: str model_version: str prompt: str parameters: Optional[Dict] = {} class Response(BaseModel): model_name: str model_version: str response: str metadata: Dict # --- MCP Endpoints --- @app.post("/generate", response_model=Response, dependencies=[Depends(verify_api_key)]) async def generate_text(request: Request): """ Endpoint for generating text using a specified model. """ model_name = request.model_name model_version = request.model_version if model_name not in models: raise HTTPException(status_code=404, detail="Model not found") if model_version not in models[model_name]["versions"]: raise HTTPException(status_code=404, detail="Model version not found") # --- Rate Limiting --- current_time = time.time() if current_time - models[model_name]["last_request_time"] < (60 / models[model_name]["rate_limit"]): raise HTTPException(status_code=429, detail="Rate limit exceeded") models[model_name]["last_request_time"] = current_time # --- Model Execution (Simulated) --- try: # In a real system, this would call the actual model. # Here, we simulate the model's response. simulated_response = f"Generated text for model {model_name} version {model_version} with prompt: {request.prompt}" logging.info(f"Model {model_name} processed request.") return Response( model_name=model_name, model_version=model_version, response=simulated_response, metadata={"request_parameters": request.parameters}, ) except Exception as e: logging.error(f"Error processing request: {e}") raise HTTPException(status_code=500, detail=f"Model execution error: {e}") @app.get("/models") async def get_models(): """ Endpoint to retrieve the list of available models and their metadata. """ return models # --- Main --- if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` Key improvements and explanations: * **FastAPI:** Uses FastAPI, a modern, high-performance Python framework for building APIs. It's easier to use and more efficient than Flask for this type of application. * **Pydantic Models:** Uses Pydantic for request and response data validation. This ensures that the data coming in and going out of the API is in the correct format. * **Asynchronous Operations:** Uses `async` and `await` for asynchronous operations. This is crucial for handling multiple requests concurrently and improving performance. In a real-world scenario, model inference would likely be an I/O-bound operation, making asynchronous programming essential. * **Model Registry:** The `models` dictionary simulates a model registry. In a real system, this would likely be a database or a more sophisticated service. It stores information about available models, their versions, and metadata. * **Request Routing:** The `/generate` endpoint handles incoming requests and routes them to the appropriate model based on the `model_name` and `model_version` in the request. * **Rate Limiting:** The code includes a basic rate-limiting mechanism. It tracks the last request time for each model and rejects requests that exceed the configured rate limit. This is essential for preventing overload and ensuring fair usage of the models. * **Authentication:** A simplified API key authentication is implemented using a dependency. **Important:** In a production environment, you would need a much more robust authentication and authorization system (e.g., OAuth 2.0, JWT). The API key is now read from an environment variable. * **Error Handling:** The code includes error handling to catch exceptions during model execution and return appropriate HTTP error codes. * **Logging:** Uses the `logging` module to log requests, errors, and model performance. This is essential for monitoring and debugging the system. * **Model Execution (Simulated):** The code simulates the execution of a model. In a real system, this would involve calling the actual model inference code. The simulated response simply returns a string indicating that the model was executed. * **Dependencies:** Uses FastAPI's dependency injection system for authentication. * **Clearer Structure:** The code is organized into logical sections with comments to explain each part. * **`uvicorn`:** Uses `uvicorn` to run the FastAPI application. `uvicorn` is an ASGI server that is designed for high-performance asynchronous applications. **How to Run the Example:** 1. **Install Dependencies:** ```bash pip install fastapi uvicorn python-dotenv ``` 2. **Set API Key (Important):** * **Option 1 (Recommended):** Set the `ANTHROPIC_API_KEY` environment variable: ```bash export ANTHROPIC_API_KEY="your_secret_api_key" ``` * **Option 2 (Less Secure):** Replace `"YOUR_DEFAULT_API_KEY"` in the code with your desired API key. **Do not commit this to a public repository!** 3. **Run the Server:** ```bash python your_file_name.py # Replace your_file_name.py with the actual name of your file ``` 4. **Test the API:** You can use `curl`, `httpie`, or a tool like Postman to test the API. Here's an example using `curl`: ```bash curl -X POST \ http://localhost:8000/generate \ -H "Content-Type: application/json" \ -H "X-API-Key: your_secret_api_key" \ -d '{ "model_name": "claude-v1", "model_version": "1.0", "prompt": "Write a short story about a cat.", "parameters": {"max_tokens": 100} }' ``` **Important Considerations for a Real-World MCP:** * **Model Deployment:** This example doesn't cover model deployment. In a real system, you would need to deploy the models to a serving infrastructure (e.g., Kubernetes, AWS SageMaker, Google Vertex AI). * **Model Scaling:** You would need to implement mechanisms for scaling the models to handle increasing traffic. This might involve using load balancers, auto-scaling groups, and distributed inference. * **Model Monitoring:** You would need to monitor the performance of the models in real-time. This would involve collecting metrics such as latency, throughput, error rate, and resource utilization. * **A/B Testing:** You would need to support A/B testing of different model versions to determine which versions perform best. * **Security:** Security is paramount. You would need to implement robust authentication, authorization, and data encryption mechanisms. Consider using TLS for all communication. * **Observability:** Implement comprehensive logging, tracing, and metrics collection to understand the behavior of the system and troubleshoot issues. * **CI/CD:** Use a CI/CD pipeline to automate the deployment and testing of new model versions. * **Database:** Replace the in-memory `models` dictionary with a proper database (e.g., PostgreSQL, MySQL, MongoDB) to store model metadata and other configuration data. * **Queueing System:** For asynchronous tasks (like model loading or pre-processing), consider using a queueing system like RabbitMQ or Kafka. This example provides a starting point for building an Anthropic MCP server. You would need to adapt and extend it to meet the specific requirements of your application. Remember to prioritize security, scalability, and observability when building a production-ready system. Also, always refer to the official documentation and best practices for the technologies you are using.

mailprotector-mcp

MCP server for Mailprotector — email security management for MSPs, enabling management of customers, domains, users, quarantine, allow/block rules, logs, configuration, and the full long-tail API via a router.

Proofpane

A governance proxy for AI tools — every MCP/agent tool call is policy-gated, secret-redacted, and written to a hash-chained, offline-verifiable audit trail.

mcp-usda-fdc

Provides tools to search and retrieve USDA Food Data Central information, including food items, nutrients, and food groups, enabling AI agents to query food data through natural language.

GNews MCP Server

Enables searching news articles and fetching top headlines via GNews API with filtering options.

legal_scholarship_mcp

Enables searching scholarly literature via the OpenAlex database, with tools for full-text search, work details, citation lookup, and author queries.

Couchbase MCP Server by CData

Couchbase MCP Server by CData

Local Codex Bridge

An MCP control plane for Codex native sessions, translating eight explicit operations with strict security boundaries for authenticated access through OpenAI Secure MCP Tunnel.

ya-direct-mcp

MCP-сервер для управления кампаниями, группами, объявлениями, ключевыми фразами и статистикой Яндекс.Директ через Claude.