Discover Awesome MCP Servers

Celigo MCP Server

Enables interaction with Celigo integrator.io API to manage integrations, flows, connections, and data operations. Supports integration lifecycle management, flow execution, and connection configuration through natural language commands.

C++ MCP Server

An MCP server that provides semantic understanding of C++ codebases using libclang, allowing Claude to instantly find classes, functions, and their relationships without having to grep through thousands of files.

Python Weather MCP Server

Enables AI agents to fetch real-time weather data for any location using the OpenWeatherMap API. Demonstrates how to build a simple MCP server that exposes weather information as a tool for LLMs.

Flux Cloudflare MCP

Un servidor MCP que permite a los asistentes de IA generar imágenes utilizando el modelo Flux de Black Forest Labs a través de Cloudflare Workers.

Nikola TEST MCP Server

Provides AI agents and LLMs access to the Nikola TEST MCP API through standardized MCP tools for seamless integration and interaction.

Emlog MCP Server

Enables AI assistants to interact with Emlog blog systems through a standardized Model Context Protocol interface, supporting content management operations like creating/updating articles, managing comments, uploading files, and accessing blog resources.

ChuckNorris MCP Server

Una puerta de enlace MCP experimental que proporciona prompts de mejora de LLM especializados basados en el repositorio L1B3RT4S, destinada principalmente a mejorar las capacidades de los modelos más débiles.

Meeting Automation MCP Server

Orchestrates Fireflies, Asana, and Notion MCP servers to automate end-to-end meeting workflows. Enables users to search meetings, extract action items, create tasks, and generate meeting documentation through natural language commands.

Spreadsheet Remote MCP Server

Enables interaction with Google Spreadsheets through OAuth 2.0 authentication, supporting reading, writing, and creating spreadsheets via a remote MCP server using SSE.

Curl MCP Server

An MCP server that enables AI assistants to make HTTP requests and download files using curl, allowing them to interact with web APIs and content.

Snowflake Server

Integración con Snowflake que implementa operaciones de lectura y (opcionalmente) escritura, así como el seguimiento de información valiosa.

MCP Weather Server

A lightweight server that exposes weather-related tools (get_coordinates and get_forecast) using the Modular Command Protocol, designed for integration with AI agents and LLMs.

Knowledge Graph MCP Server

Enables fast code analysis and navigation through hybrid semantic search, graph-based relationship tracking, and structure exploration across multiple programming languages with optimized indexing for large codebases.

Colombia MCP Server

Provides access to geographical and tourism information about Colombia, including regions, departments, cities, and tourist attractions through the API Colombia service.

HTML to PDF MCP Server

Converts HTML files or HTML content to PDF using Puppeteer's browser rendering engine with support for CSS, JavaScript, custom page formats, margins, and header/footer templates.

Pokemon Showdown MCP Server

Provides Pokemon Showdown competitive battle data to AI assistants, enabling lookup of Pokemon stats, moves, abilities, items, type matchups, and strategic information through natural language queries.

Cvent MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Cvent (beta): https://www.cdata.com/download/download.aspx?sku=TVZK-V&type=beta

mcp-figma

Un servidor de Protocolo de Contexto de Modelo que proporciona acceso a la funcionalidad de la API de Figma, permitiendo que asistentes de IA como Claude interactúen con archivos, comentarios, componentes y recursos de equipo de Figma.

file-system-mcp-server

Un servidor MCP (Protocolo de Contexto del Modelo) integral para operaciones del sistema de archivos, que proporciona a Claude y otros asistentes de IA acceso a archivos y directorios locales.

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