Discover Awesome MCP Servers

Enkrypt AI MCP Server

Integra análisis de seguridad de la IA, "red-teaming" y auditoría de prompts directamente en clientes compatibles con MCP como Claude Desktop y Cursor IDE, permitiendo el análisis en tiempo real de los prompts y la detección de intentos de "jailbreak".

Discord Notification MCP Server

Enables Claude Code to send notifications to Discord channels via webhooks when tasks complete, errors occur, or user intervention is needed. Deployed serverlessly on Cloudflare Workers with support for rich message formatting and embeds.

Cursor10x Memory System

A comprehensive memory system for Cursor using the Model Context Protocol (MCP) that provides persistent context awareness across sessions by storing conversation history, project milestones, code snippets, and enabling semantic search.

Omnisend MCP Server

A server that enables AI assistants to interact with the Omnisend marketing platform, supporting contact management, product management, and event tracking operations through natural language.

RescueTime MCP Server

Enables comprehensive access to RescueTime productivity data and features through the Model Context Protocol. Supports analytics retrieval, focus session management, highlights creation, and offline time tracking through natural language interactions.

AI Helper MCP Server

A server that allows AI agents to consult multiple large language models (like Grok, Gemini, Claude, GPT-4o) through Model Context Protocol for assistance and information.

台灣中央氣象局 MCP 伺服器

Servidor MCP de la Administración Meteorológica Central de Taiwán (CWA) API

Sefaria Jewish Library

Enables Large Language Models to retrieve Jewish texts and commentaries from the Sefaria library through a standardized interface.

MCP Server for NPM Package Info

Un servidor MCP para herramientas de gestión de paquetes JavaScript de NPM.

ArtifactHub MCP Server

A Model Context Protocol server that enables interaction with Helm charts on Artifacthub, providing tools for retrieving chart information, default values, and templates through natural language queries.

MCP SSH Tools Server

A server based on the MCP framework that provides remote server management capabilities through SSH, supporting features like connection pooling, file transfers, and remote command execution.

StarRocks MCP Server

A TypeScript implementation of a Model Context Protocol server that enables interaction with StarRocks databases, supporting SQL operations like queries, table creation, and data manipulation through standardized MCP tools.

Cairo Coder

The most powerful open-source Cairo code generator.

mcp-server

Here are a few options for what you might be looking for, depending on what "MCP server" means to you. I'll provide the English and Spanish translations: **Option 1: Minecraft Protocol Server (for accessing Minecraft data)** * **English:** If you're referring to a server that uses the Minecraft Protocol (MCP) to access game data, then there isn't a single "MCP server" that provides documentation. Instead, you would typically use a library or framework that implements the Minecraft Protocol. These libraries often have their own documentation. Examples include: * **PrismarineJS:** A JavaScript library for interacting with Minecraft servers. * **Mineflayer:** A Node.js library for creating Minecraft bots. * **Python Minecraft Protocol Libraries:** Several Python libraries exist, such as `mcstatus` or libraries built on `nbt`. You would need to consult the documentation for the specific library you are using. * **Spanish:** Si te refieres a un servidor que utiliza el Protocolo de Minecraft (MCP) para acceder a datos del juego, entonces no existe un único "servidor MCP" que proporcione documentación. En cambio, normalmente usarías una biblioteca o framework que implemente el Protocolo de Minecraft. Estas bibliotecas a menudo tienen su propia documentación. Algunos ejemplos incluyen: * **PrismarineJS:** Una biblioteca de JavaScript para interactuar con servidores de Minecraft. * **Mineflayer:** Una biblioteca de Node.js para crear bots de Minecraft. * **Bibliotecas de Protocolo de Minecraft en Python:** Existen varias bibliotecas de Python, como `mcstatus` o bibliotecas construidas sobre `nbt`. Deberías consultar la documentación de la biblioteca específica que estés utilizando. **Option 2: Mod Coder Pack (MCP) - For decompiling and reobfuscating Minecraft code** * **English:** If you're referring to the Mod Coder Pack (MCP), which is used for decompiling, deobfuscating, and reobfuscating Minecraft's source code to make modding easier, then the official documentation is usually found on their forums or associated websites. However, MCP is largely outdated. Modern modding uses tools like Forge or Fabric, which have their own documentation. * **Spanish:** Si te refieres al Mod Coder Pack (MCP), que se utiliza para descompilar, desobfuscar y reobfuscar el código fuente de Minecraft para facilitar la creación de mods, entonces la documentación oficial generalmente se encuentra en sus foros o sitios web asociados. Sin embargo, MCP está en gran medida desactualizado. La creación de mods moderna utiliza herramientas como Forge o Fabric, que tienen su propia documentación. **Option 3: A Specific Custom Server (Unlikely without more context)** * **English:** It's possible you're referring to a specific custom Minecraft server implementation that uses "MCP" in its name or description. In that case, you'll need to provide more information about the server so I can help you find its documentation. Look for a website, GitHub repository, or forum associated with the server. * **Spanish:** Es posible que te refieras a una implementación de servidor de Minecraft personalizada específica que utiliza "MCP" en su nombre o descripción. En ese caso, deberás proporcionar más información sobre el servidor para que pueda ayudarte a encontrar su documentación. Busca un sitio web, un repositorio de GitHub o un foro asociado con el servidor. **In summary, to help me give you the best answer, please clarify what you mean by "MCP server."**

Cloud Healthcare API Server

An MCP server that enables interaction with Google's Cloud Healthcare API, allowing users to manage healthcare data, FHIR resources, DICOM stores, and healthcare datasets through natural language commands.

Context Optimizer MCP

Un servidor MCP que utiliza Redis y almacenamiento en caché en memoria para optimizar y extender las ventanas de contexto para historiales de chat extensos.

Petstore MCP Server

A comprehensive Model Context Protocol implementation for the Swagger Petstore API that provides 19 tools across pet management, store operations, and user management categories.

FoundryMCP

MCP Server for AI Agents accessing Palantir Foundry

My MCP Server

A customizable Model Context Protocol server built with mcp-framework that enables Claude to access external tools and capabilities through a standardized interface.

aica - AI Code Analyzer

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

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.

Gmail MCP Server

Here are a few ways to translate "Gmail MCP Server using Java and Spring Boot" into Spanish, depending on the nuance you want to convey: **Option 1 (Most Direct):** * **Servidor MCP de Gmail usando Java y Spring Boot** * This is the most literal translation and is perfectly understandable. It keeps the acronym "MCP" as is, assuming the audience understands it. **Option 2 (Slightly More Explanatory):** * **Servidor MCP de Gmail implementado con Java y Spring Boot** * This translates to "Gmail MCP Server implemented with Java and Spring Boot." The word "implementado" (implemented) adds a bit more clarity. **Option 3 (If you want to avoid the acronym, if possible):** * **Servidor de Gmail con funcionalidad MCP, desarrollado con Java y Spring Boot** * This translates to "Gmail Server with MCP functionality, developed with Java and Spring Boot." This avoids the acronym entirely and focuses on the functionality. You would only use this if you're confident the audience doesn't know what "MCP" stands for. You'd need to define what "MCP" means elsewhere. **Which option is best depends on your audience:** * If your audience is technical and familiar with the acronym "MCP," **Option 1** is the most concise and appropriate. * If you want to be slightly more explicit, **Option 2** is a good choice. * If your audience is less technical or unfamiliar with "MCP," **Option 3** is the safest, but requires you to explain what "MCP" is. Therefore, I recommend **Option 1 (Servidor MCP de Gmail usando Java y Spring Boot)** unless you have a specific reason to use one of the others.

Weather MCP Server

A JavaScript ES Modules server that provides weather information including alerts and forecasts for US locations using the National Weather Service API.

MCP Server Example

Una implementación educativa de un servidor de Protocolo de Contexto de Modelo (MCP) que demuestra cómo construir un servidor MCP funcional para integrarse con varios clientes LLM como Claude Desktop.

kospell

한글 MCP (글자 수 세기, 맞춤법 오류, 로만화) Korean lang mcp

Weather Query MCP Server

Una implementación de servidor MCP que permite a los usuarios obtener y mostrar información meteorológica para ciudades específicas, incluyendo temperatura, humedad, velocidad del viento y descripciones del clima.

o3-search MCP

An MCP server that enables web search capabilities using OpenAI's o3 model, allowing AI assistants to perform text-based web searches and return AI-powered results.

Mobile MCP

Un servidor de Protocolo de Contexto de Modelo (MCP) que proporciona capacidades de automatización móvil.