Discover Awesome MCP Servers

WebDAV MCP Server

Enables CRUD operations on WebDAV file systems with authentication support, allowing users to manage files and directories through natural language commands. Includes advanced features like file search, range requests, smart editing with diff preview, and directory tree visualization.

Initialize MCP Server using Cursor IDE

Primera implementación de servidor MCP utilizando la API del clima de EE. UU.

Agent Care MCP Server - Azalea Health Integration

Servidor MCP de Agent Care configurado para la integración de la API FHIR de Azalea Health

MCP JSON-RPC Server

Un servidor JSON-RPC inspirado en MCP, fácil de usar para principiantes, construido con Node.js, que ofrece una interacción básica cliente-servidor a través de un protocolo de enlace de capacidades 'initialize' y una función 'echo'.

iSendPro SMS API Server

MCP Server that enables natural language interaction with iSendPro's SMS messaging platform, allowing users to send and manage SMS communications through conversational commands.

Add API key to .env file

Okay, here's a basic implementation of a simplified MCP (Master-Client-Process) system in Python, including a client and multiple servers. This is a conceptual example and lacks robust error handling, security, and advanced features. It's designed to illustrate the core principles. **Important Considerations:** * **Security:** This code is for demonstration purposes only. Do *not* use it in a production environment without adding proper security measures (authentication, encryption, etc.). * **Error Handling:** The error handling is minimal. A real-world system would need much more robust error handling. * **Scalability:** This is a very basic implementation and won't scale well to a large number of clients or servers. Consider using more advanced technologies like message queues (e.g., RabbitMQ, Kafka) for scalability. * **Threading/Asynchronous:** This example uses basic threading. For more efficient handling of multiple clients, consider using asynchronous programming (e.g., `asyncio`). **Code:** **1. Server (mcp_server.py):** ```python import socket import threading import time SERVER_HOST = '127.0.0.1' # Loopback address SERVER_PORT = 12345 # Choose a port MAX_CONNECTIONS = 5 def handle_client(client_socket, client_address): """Handles communication with a single client.""" print(f"Connection from {client_address}") try: while True: data = client_socket.recv(1024).decode('utf-8') if not data: break # Client disconnected print(f"Received from {client_address}: {data}") # Process the data (very simple example) response = f"Server received: {data.upper()}" client_socket.send(response.encode('utf-8')) except Exception as e: print(f"Error handling client {client_address}: {e}") finally: print(f"Connection closed with {client_address}") client_socket.close() def start_server(): """Starts the server and listens for incoming connections.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((SERVER_HOST, SERVER_PORT)) server_socket.listen(MAX_CONNECTIONS) print(f"Server listening on {SERVER_HOST}:{SERVER_PORT}") try: while True: client_socket, client_address = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address)) client_thread.start() except KeyboardInterrupt: print("Server shutting down...") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **2. Client (mcp_client.py):** ```python import socket SERVER_HOST = '127.0.0.1' SERVER_PORT = 12345 def run_client(): """Connects to the server and sends/receives data.""" client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client_socket.connect((SERVER_HOST, SERVER_PORT)) print(f"Connected to server at {SERVER_HOST}:{SERVER_PORT}") while True: message = input("Enter message to send (or 'exit'): ") if message.lower() == 'exit': break client_socket.send(message.encode('utf-8')) response = client_socket.recv(1024).decode('utf-8') print(f"Received from server: {response}") except Exception as e: print(f"Error: {e}") finally: print("Closing connection.") client_socket.close() if __name__ == "__main__": run_client() ``` **How to Run:** 1. **Save the code:** Save the server code as `mcp_server.py` and the client code as `mcp_client.py`. 2. **Start the server:** Open a terminal or command prompt and run `python mcp_server.py`. The server will start listening for connections. 3. **Start the client(s):** Open one or more other terminals/command prompts and run `python mcp_client.py` in each. Each client will connect to the server. 4. **Interact:** In each client terminal, type a message and press Enter. The message will be sent to the server, processed (in this simple example, converted to uppercase), and the response will be displayed in the client terminal. 5. **Exit:** Type `exit` in a client terminal to disconnect that client. Press Ctrl+C in the server terminal to shut down the server. **Explanation:** * **Server (mcp_server.py):** * Creates a socket and binds it to a specific IP address and port. * Listens for incoming connections using `server_socket.listen()`. * When a client connects (`server_socket.accept()`), it creates a new thread to handle the client's communication. This allows the server to handle multiple clients concurrently. * The `handle_client()` function receives data from the client, processes it (in this example, it just converts the message to uppercase), and sends a response back to the client. * The server continues to listen for new connections until it's interrupted (e.g., by pressing Ctrl+C). * **Client (mcp_client.py):** * Creates a socket and connects to the server's IP address and port. * Prompts the user to enter a message. * Sends the message to the server using `client_socket.send()`. * Receives the response from the server using `client_socket.recv()`. * Prints the response to the console. * The client continues to send and receive messages until the user enters "exit". **Key Concepts:** * **Sockets:** Sockets are the fundamental building blocks for network communication. They provide an endpoint for sending and receiving data. * **TCP (SOCK_STREAM):** TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It's suitable for applications that require guaranteed delivery, such as file transfer and web browsing. * **Threading:** Threading allows the server to handle multiple clients concurrently. Each client connection is handled in a separate thread. * **Encoding/Decoding:** Data is sent over the network as bytes. The `encode()` and `decode()` methods are used to convert strings to bytes and vice versa. UTF-8 is a common encoding that supports a wide range of characters. **Improvements and Extensions:** * **Error Handling:** Add more comprehensive error handling to catch exceptions and handle them gracefully. * **Security:** Implement authentication and encryption to protect the data being transmitted. Consider using TLS/SSL. * **Message Format:** Define a more structured message format (e.g., JSON, Protocol Buffers) to allow for more complex data to be exchanged. * **Asynchronous Programming:** Use `asyncio` for more efficient handling of multiple clients, especially if the server needs to handle a large number of concurrent connections. * **Master/Worker Pattern:** Implement a true master/worker pattern where the master server distributes tasks to worker servers. * **Message Queues:** Use a message queue (e.g., RabbitMQ, Kafka) to decouple the client and server and improve scalability and reliability. * **Configuration:** Use a configuration file to store server settings (e.g., IP address, port). * **Logging:** Implement logging to record server events and errors. This provides a basic foundation for understanding how an MCP system can be implemented in Python. Remember to adapt and extend this code to meet the specific requirements of your application.

sushimcp

sushimcp

⚡️ mcpo

Un servidor proxy MCP a OpenAPI sencillo y seguro.

paperpal

Extensión MCP que brinda a los LLM acceso a artículos de arXiv y Hugging Face, permitiendo a los usuarios discutir artículos, buscar nuevas investigaciones y organizar revisiones de literatura a través de conversaciones naturales.

Datadog MCP Server

Mirror of

subnoto

Subnoto - Electronic Signature MCP server allows to send, receive and sign electronic documents with legally binding signatures. It connects to a confidential computing environment to ensure confidentiality of exchanged documents.

Twist MCP Server

An MCP server that enables interaction with Twist workspaces using the Twist REST API, allowing users to manage their Twist inbox by viewing, archiving, unarchiving, and marking threads as read.

Street View MCP

A server that enables AI models to fetch and display Google Street View imagery, allowing users to create virtual tours by viewing streets and landmarks from anywhere.

mcp-luckyworld

Un servidor MCP para acceder al simulador Lucky World.

ShipEngine API MCP Server

An MCP server that enables interaction with ShipEngine's shipping API, allowing users to manage shipments, labels, carriers, and other shipping operations through natural language commands.

MarkLogic MCP Server

Un servidor de Protocolo de Contexto de Modelo para MarkLogic que permite operaciones CRUD y capacidades de consulta de documentos a través de una interfaz de cliente.

StatFlow

Enables AI assistants to perform statistical analysis on MySQL databases, generating formatted Excel reports with t-tests and effect sizes, and creating thesis-quality Word documents with AI-powered insights.

selenium-mcp

Un servidor MCP para Selenium

Lightning Network MCP Server

Espejo de

Medical MCP Server

Provides comprehensive medical information by querying authoritative sources including FDA drug database, WHO health statistics, PubMed literature, RxNorm nomenclature, Google Scholar, and Australia's PBS API through 22+ specialized tools.

mcp-server-bash

Servidor MCP minimalista escrito en un script de bash.

Alpaca MCP Server

MCP server that exposes Alpaca Market Data & Broker API as tools, enabling access to financial data like stock bars, assets, market days, and news through the Message Control Protocol.

Hardware MCP Server

Enables language models to perform hardware engineering tasks including CAD part design and heat transfer simulations. Provides tool calls for building mechanical components and running thermal analysis through natural language interactions.

mcpmonorepo

Banco de pruebas para servidores MCP en un repositorio Mono.

Self-hosted AI starter kit (by the n8n team)

Okay, here's a translation of "pydantic agent workflow using mcp servers to test out advanced retrieval of linked data" into Spanish, along with some options to capture the nuance depending on the context: **Option 1 (Most Direct):** * **Flujo de trabajo de agente Pydantic utilizando servidores MCP para probar la recuperación avanzada de datos enlazados.** **Option 2 (Slightly More Explanatory):** * **Flujo de trabajo de agente Pydantic que emplea servidores MCP para experimentar con la recuperación avanzada de datos vinculados.** **Option 3 (Focus on Experimentation):** * **Flujo de trabajo de agente Pydantic con servidores MCP para la experimentación con la recuperación avanzada de datos enlazados.** **Explanation of Choices:** * **"Pydantic agent workflow"**: "Flujo de trabajo de agente Pydantic" is a direct and generally accepted translation. * **"using mcp servers"**: "utilizando servidores MCP" is a direct translation. "que emplea servidores MCP" or "con servidores MCP" are alternatives that might sound slightly more natural in some contexts. * **"to test out"**: This is where the nuance comes in. * "para probar" is the most direct translation of "to test". * "para experimentar con" emphasizes the experimental nature of the testing. * **"advanced retrieval of linked data"**: "recuperación avanzada de datos enlazados" or "recuperación avanzada de datos vinculados" are both acceptable. "Enlazados" and "vinculados" both mean "linked". "Avanzada" means "advanced". **Which option to choose depends on the specific context:** * If you're writing technical documentation, **Option 1** is likely the best choice because it's the most direct and concise. * If you want to emphasize the experimental nature of the work, **Option 2 or 3** might be better. I hope this helps! Let me know if you have any other questions.

Multi MCP Server

Multi MCP Server

Simple MCP Tool Server

A server that provides a website fetching tool via SSE transport, allowing users to retrieve content from specified URLs.

Tech News Update Agent

A FastAPI backend that integrates with ElevenLabs MCP to create an AI agent capable of making outbound calls and delivering friendly, jargon-free tech news updates.

Android-MCP

Enables AI agents to control Android devices and emulators through direct UI interaction, allowing app navigation, automated testing, and real-world task execution via ADB without computer vision or scripts.

EPA Envirofacts MCP Server

Provides AI agents with structured access to U.S. EPA environmental data including nearby regulated facilities, chemical releases, water violations, and hazardous waste sites for any U.S. location. Enables comprehensive environmental impact analysis through the EPA Envirofacts API with geocoding support and distance-based filtering.