Discover Awesome MCP Servers

Docker MCP Server

Permite que Claude y otros asistentes de IA interactúen con Docker a través del protocolo MCP, lo que permite la gestión de contenedores e imágenes, incluyendo listar, ejecutar, detener y descargar recursos de Docker.

ConceptNet MCP Server

Provides seamless access to the ConceptNet semantic knowledge graph, enabling concept lookup, search, relationship discovery, and semantic similarity calculations across multiple languages.

MCP Server Starter

A production-ready starter template for building Model Context Protocol (MCP) servers with TypeScript. Includes automated tooling for creating new MCP tools, testing, and deployment to Claude Desktop.

Calculator MCP Server

A backend service that provides accurate arithmetic calculation capabilities to AI models via the Model Context Protocol, allowing LLMs to offload mathematical computations for numerical queries.

pubmed-mcp-server

Please provide me with the query you would like me to use to search PubMed. For example, you could say: "Search PubMed for articles matching the query: 'lung cancer treatment immunotherapy'" Once you give me the query, I will translate it to Spanish and provide you with the Spanish translation. Then, I will explain that I cannot directly search PubMed for you, but I will provide you with the Spanish translation of your query so you can use it to search PubMed yourself.

Baidu Search MCP Server

Proporciona capacidades de búsqueda web a través de Baidu con funciones de obtención y análisis de contenido, lo que permite a los LLM buscar en la web y extraer contenido de páginas web.

MCP Server

Un servidor basado en Flask que implementa el Protocolo de Contexto del Modelo para mejorar los LLM (Modelos de Lenguaje Grandes) con capacidades de herramientas externas a través del lenguaje natural, permitiendo que herramientas como la búsqueda del clima y los cálculos se invoquen directamente en la salida de texto del modelo.

MCP QQ Music Test Server

Un servidor que proporciona la funcionalidad de búsqueda de QQ Music a través del Protocolo de Control Modular, permitiendo a los usuarios buscar pistas de música por palabra clave y recuperar información de las canciones.

Mobile Next MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite la automatización móvil escalable a través de una interfaz independiente de la plataforma para dispositivos iOS y Android, permitiendo que agentes y LLMs interactúen con aplicaciones móviles utilizando instantáneas de accesibilidad o interacciones basadas en coordenadas.

MCP Storybook Image Generator

Generates children's storybook illustrations in multiple art styles (3D cartoon, watercolor, pixel art, hand drawn, claymation) with matching stories using Google's Gemini AI.

yfinance-mcp

Okay, here's a basic outline and code snippets to get you started with a Python MCP (Message Control Protocol) server for yfinance. This is a simplified example and would need further development for production use. **Concept:** The idea is to create a server that listens for requests (likely stock tickers) over a network connection using MCP. Upon receiving a request, the server uses `yfinance` to fetch the data and sends the data back to the client. **Important Considerations:** * **MCP Implementation:** MCP is a relatively old protocol. You'll likely need to find a Python library that supports it, or implement the core parts yourself. If you're starting from scratch, consider using a more modern protocol like TCP with a simple text-based or JSON-based message format. This will be much easier to implement and debug. * **Error Handling:** Robust error handling is crucial. Handle network errors, `yfinance` errors (e.g., invalid ticker), and data serialization errors. * **Security:** If this server will be exposed to a network, consider security implications. MCP itself doesn't provide security. You might need to add encryption or authentication. * **Data Format:** Decide on the format for sending data back to the client (e.g., JSON, CSV, a custom format). JSON is generally a good choice for its flexibility and ease of parsing. * **Concurrency:** For handling multiple client requests simultaneously, you'll need to use threading, asynchronous programming (asyncio), or multiprocessing. * **Rate Limiting:** `yfinance` might have rate limits. Implement a mechanism to avoid exceeding them. **Simplified Example (using TCP instead of MCP for simplicity):** This example uses TCP sockets because a full MCP implementation is beyond the scope of a quick response. It demonstrates the core logic of fetching data from `yfinance` and sending it back to a client. You would need to adapt this to use MCP if that's a strict requirement. ```python import socket import yfinance as yf import json # Server configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def fetch_stock_data(ticker): """Fetches stock data from yfinance and returns it as a JSON string.""" try: stock = yf.Ticker(ticker) data = stock.history(period="1d") # Get 1 day of data if data.empty: return json.dumps({"error": f"No data found for ticker: {ticker}"}) # Convert the DataFrame to a dictionary suitable for JSON serialization data_dict = data.to_dict(orient="index") return json.dumps(data_dict) # Serialize to JSON except Exception as e: return json.dumps({"error": str(e)}) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive data from the client if not data: break # Client disconnected ticker = data.decode().strip() # Decode the ticker symbol print(f"Received ticker: {ticker}") stock_data_json = fetch_stock_data(ticker) # Fetch data and serialize to JSON conn.sendall(stock_data_json.encode()) # Send the JSON data back conn.close() print(f"Connection closed with {addr}") def main(): """Main server function.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() # In a real application, you'd likely want to use threading or asyncio # to handle multiple clients concurrently. For simplicity, this example # handles one client at a time. handle_client(conn, addr) if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries (`socket`, `yfinance`, `json`). 2. **`fetch_stock_data(ticker)`:** * Takes a stock ticker as input. * Uses `yfinance` to fetch historical data (1 day in this example). You can adjust the `period` parameter. * Handles potential errors (e.g., invalid ticker). * Converts the `yfinance` DataFrame to a dictionary using `to_dict(orient="index")`. This creates a dictionary where the keys are the dates (index) and the values are dictionaries of the data for that date. * Serializes the dictionary to a JSON string using `json.dumps()`. * Returns the JSON string. 3. **`handle_client(conn, addr)`:** * Handles communication with a single client. * Receives data (the ticker symbol) from the client. * Calls `fetch_stock_data()` to get the data. * Sends the JSON data back to the client. * Closes the connection. 4. **`main()`:** * Creates a TCP socket. * Binds the socket to the specified host and port. * Listens for incoming connections. * Accepts a connection from a client. * Calls `handle_client()` to handle the client's requests. * **Important:** This example handles one client at a time. For a real-world server, you'd need to use threading or `asyncio` to handle multiple clients concurrently. **Client Example (TCP):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) ticker = "AAPL" # Example ticker s.sendall(ticker.encode()) data = s.recv(4096) # Receive up to 4096 bytes print('Received:', data.decode()) ``` **How to Run:** 1. Save the server code as `yfinance_server.py`. 2. Save the client code as `yfinance_client.py`. 3. Run the server: `python yfinance_server.py` 4. Run the client: `python yfinance_client.py` **To Adapt to MCP:** 1. **Find an MCP Library:** Search for a Python library that supports MCP. If you can't find one, you'll need to implement the MCP protocol yourself (which is a significant undertaking). 2. **Replace Socket Code:** Replace the `socket` code in the server and client with the MCP library's functions for creating connections, sending messages, and receiving messages. 3. **MCP Message Formatting:** Ensure that the messages you send and receive conform to the MCP protocol's specifications. This will involve encoding and decoding the data according to MCP's rules. **Example using `socketserver` for multithreading (TCP):** This is a more robust example that uses the `socketserver` module to handle multiple clients concurrently using threads. It's still using TCP, but it demonstrates how to handle multiple requests. ```python import socketserver import yfinance as yf import json class YFinanceHandler(socketserver.BaseRequestHandler): """ The request handler class for our server. It is instantiated once per connection to the server, and must override the handle() method to implement communication to the client. """ def handle(self): # self.request is the TCP socket connected to the client self.data = self.request.recv(1024).strip() ticker = self.data.decode() print(f"{self.client_address[0]} wrote: {ticker}") stock_data_json = self.fetch_stock_data(ticker) self.request.sendall(stock_data_json.encode()) def fetch_stock_data(self, ticker): """Fetches stock data from yfinance and returns it as a JSON string.""" try: stock = yf.Ticker(ticker) data = stock.history(period="1d") # Get 1 day of data if data.empty: return json.dumps({"error": f"No data found for ticker: {ticker}"}) # Convert the DataFrame to a dictionary suitable for JSON serialization data_dict = data.to_dict(orient="index") return json.dumps(data_dict) # Serialize to JSON except Exception as e: return json.dumps({"error": str(e)}) class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): pass if __name__ == "__main__": HOST, PORT = "localhost", 65432 server = ThreadedTCPServer((HOST, PORT), YFinanceHandler) with server: print(f"Server listening on {HOST}:{PORT}") # Start a thread with the server -- that thread will then start one # more thread for each request server.serve_forever() ``` **Key Improvements in the `socketserver` Example:** * **Multithreading:** The `ThreadedTCPServer` allows the server to handle multiple client requests concurrently. Each client connection is handled in a separate thread. * **`socketserver` Module:** Uses the `socketserver` module, which simplifies the creation of network servers. * **Request Handler:** The `YFinanceHandler` class encapsulates the logic for handling a single client request. This makes the code more organized and easier to maintain. **Remember to install yfinance:** ```bash pip install yfinance ``` This comprehensive response provides a starting point for building your Python MCP server for `yfinance`. Remember to adapt the code to use MCP if that's a strict requirement, and to add proper error handling, security, and concurrency for a production environment. Good luck!

kubernetes-mcp-server

A powerful and flexible Kubernetes MCP server implementation with support for OpenShift.

Xylent MCP Server

Exposes a suite of 31 AI agents and the Ralph Engine orchestration framework to Claude for managing complex development tasks. It supports direct agent execution, manual task orchestration, and fully autonomous workflows with integrated quality gates.

ROS MCP Server

Enables control of ROS/ROS2 robots through natural language commands by translating LLM instructions into ROS topics and services. Supports cross-platform WebSocket-based communication with existing robot systems without requiring code modifications.

ClickUp MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los agentes de IA interactuar con los espacios de trabajo de ClickUp, permitiendo la creación, gestión y organización del espacio de trabajo a través de comandos en lenguaje natural.

BlenderMCP

BlenderMCP integrates Claude AI with Blender via the Model Context Protocol to enable prompt-assisted 3D modeling, scene creation, and professional retopology workflows. It allows users to manipulate objects, apply materials, and execute Python scripts directly within the Blender environment through natural language.

OSP Marketing Tools MCP Server

Aquí tienes una traducción al español: Una implementación en TypeScript de un servidor de Protocolo de Contexto de Modelo que proporciona herramientas de marketing basadas en las metodologías de Open Strategy Partners, permitiendo la creación de contenido, la optimización y el posicionamiento de productos a través de herramientas como la generación de mapas de valor, la creación de metainformación y la edición de contenido.

Random Value MCP Server

Generates random integers within a specified range and random alphanumeric strings of specified length through MCP protocol integration.

mcp-ssh-toolkit-py

mcp-ssh-toolkit-py es un potente servidor MCP para la ejecución segura de comandos SSH a través del Protocolo de Contexto de Modelo.

MCP-Server

Una implementación de un Protocolo de Contexto de Modelo que permite a los modelos de lenguaje grandes llamar a herramientas externas (como pronósticos del tiempo e información de GitHub) a través de un protocolo estructurado, con visualización del proceso de razonamiento del modelo.

Chess.com MCP Server

Proporciona acceso a datos de jugadores de Chess.com, registros de partidas e información pública a través de interfaces MCP estandarizadas, lo que permite a los asistentes de IA buscar y analizar información de ajedrez.

WordPress Standalone MCP Server

A Model Context Protocol server that automatically discovers WordPress REST API endpoints and creates individual tools for each endpoint, enabling natural language management of WordPress sites.

Perplexity Search

Permite la integración de la API de IA de Perplexity con LLMs, ofreciendo finalización de chat avanzada mediante el uso de plantillas de prompts especializadas para tareas como documentación técnica, revisión de código y documentación de API.

MCP Operator

Un servidor de automatización de navegadores web que permite a los asistentes de IA controlar Chrome con gestión de estado persistente, lo que facilita tareas de navegación complejas a través de operaciones de navegador asíncronas.

Adyen Checkout Utility Service MCP Server

An MCP (Multi-Agent Conversation Protocol) Server that enables interaction with Adyen's Checkout Utility Service API through natural language, auto-generated using AG2's MCP builder.

ChuangSi AI Model Content Protection

Provides real-time content safety protection for large language models by detecting and preventing risks in both input and output content across multiple dimensions including compliance, ethics, and security.

FastlyMCP

Enables AI assistants to interact with Fastly's CDN API through the Model Context Protocol, allowing secure management of CDN services, caching, security settings, and performance monitoring without exposing API keys.

MUI MCP Server

Provides real-time access to Material-UI component documentation, enabling users to search, browse, and generate MUI React components with up-to-date props and examples directly from official documentation.