Discover Awesome MCP Servers

Slack Admin MCP Server

Servidor MCP para la administración de canales de Slack (crear, renombrar, archivar)

AIStor MCP server

Espejo de

Agent Jobs MCP Server

Allows AI agents to query and manage asynchronous jobs in the Agent Jobs system of the AI Connect platform, supporting operations like listing, creating, and canceling jobs.

Pearch

Best people search engine that reduces the time spent on talent discovery

Beatport MCP Server

Un servidor de Protocolo de Contexto de Modelo (MCP) que proporciona acceso a la API de Desarrolladores de Beatport, permitiendo a Claude interactuar con datos musicales del catálogo de música electrónica de Beatport.

MindMesh MCP Server

Claude 3.7 Swarm con Coherencia de Campo: Un servidor de Protocolo de Contexto de Modelo (MCP) que orquesta múltiples instancias especializadas de Claude 3.7 Sonnet en un enjambre de inspiración cuántica. Crea un efecto de coherencia de campo a través de especialistas en reconocimiento de patrones, teoría de la información y razonamiento para producir respuestas óptimamente coherentes a partir de la inteligencia de conjunto.

Internetsearch-mcp-server

Espejo de

NPM Sentinel MCP

A Model Context Protocol server providing utility tools for development and testing, offering functionalities like personalized greetings, random card drawing, and datetime formatting with an extensible architecture.

Gospel Library MCP

Enables access to LDS Gospel Library content and scriptures through the Model Context Protocol. Provides tools for searching and retrieving religious texts and study materials from the Church of Jesus Christ of Latter-day Saints.

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

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.

⚡️ mcpo

Un servidor proxy MCP a OpenAPI sencillo y seguro.

Datadog MCP Server

Mirror of

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.

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'.

Image Extractor

Un servidor de Protocolo de Contexto de Modelo que extrae imágenes de URLs o datos base64 y las convierte a un formato adecuado para el análisis de LLM, permitiendo que los modelos de IA procesen y comprendan contenido visual.

mcp-init

Okay, here's a basic outline and code snippets to get you started with creating a new Minecraft Protocol (MCP) server in TypeScript, with some common "batteries included" features. This is a simplified example and will require further development to be a fully functional server. **Conceptual Outline** 1. **Project Setup:** Initialize a TypeScript project with necessary dependencies. 2. **Networking:** Set up a TCP server to listen for incoming Minecraft client connections. 3. **Protocol Handling:** Implement the Minecraft protocol (MCP) for handshake, status, login, and play phases. This involves reading and writing packets in the correct format. 4. **Player Management:** Track connected players, their data (username, UUID, etc.), and their game state. 5. **World Management (Basic):** Implement a very basic world representation (e.g., a simple array of blocks) or load a chunk from a file. 6. **Game Loop (Basic):** Implement a basic game loop to process player actions, update the world, and send updates to clients. 7. **Command Handling (Basic):** Implement a simple command system for server administration. 8. **Logging:** Use a logging library for debugging and monitoring. **Code Snippets (TypeScript)** **1. Project Setup** ```bash mkdir minecraft-server cd minecraft-server npm init -y npm install typescript ts-node ws uuid npm install --save-dev @types/node @types/ws tsc --init ``` **2. `tsconfig.json` (Example)** ```json { "compilerOptions": { "target": "es2020", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` **3. `src/index.ts` (Main Server File)** ```typescript import * as net from 'net'; import { v4 as uuidv4 } from 'uuid'; import { WebSocketServer, WebSocket } from 'ws'; const serverPort = 25565; // Default Minecraft port const wssPort = 8080; // Port for WebSocket server interface Player { id: string; username: string; socket: net.Socket; x: number; y: number; z: number; } const players: { [id: string]: Player } = {}; // Basic World (Example) const worldWidth = 16; const worldHeight = 16; const worldDepth = 16; const world: number[][][] = []; function initializeWorld() { for (let x = 0; x < worldWidth; x++) { world[x] = []; for (let y = 0; y < worldHeight; y++) { world[x][y] = []; for (let z = 0; z < worldDepth; z++) { world[x][y][z] = 0; // 0 = Air, 1 = Stone (example) } } } // Example: Add some ground for (let x = 0; x < worldWidth; x++) { for (let z = 0; z < worldDepth; z++) { world[x][0][z] = 1; } } } initializeWorld(); // Function to handle incoming data from a client function handleClientData(socket: net.Socket, data: Buffer) { // TODO: Implement Minecraft protocol parsing here // This is where you'll decode the packets based on the MCP specification. // For example, you'll need to handle handshake, status, login, and play packets. console.log(`Received data from ${socket.remoteAddress}:${socket.remotePort}: ${data.toString('hex')}`); // Example: Echo back the data (for testing) socket.write(data); } // Function to handle a new client connection function handleNewClient(socket: net.Socket) { console.log(`New client connected: ${socket.remoteAddress}:${socket.remotePort}`); // Generate a unique player ID const playerId = uuidv4(); // Create a new player object (initially without username) const player: Player = { id: playerId, username: 'Unknown', // Will be set during login socket: socket, x: 0, y: 1, z: 0, }; players[playerId] = player; // Set up event listeners for the socket socket.on('data', (data) => handleClientData(socket, data)); socket.on('end', () => { console.log(`Client disconnected: ${socket.remoteAddress}:${socket.remotePort}`); delete players[playerId]; }); socket.on('error', (err) => { console.error(`Socket error: ${err}`); delete players[playerId]; }); } // Create the TCP server const server = net.createServer(handleNewClient); // Start listening on the specified port server.listen(serverPort, () => { console.log(`Minecraft server listening on port ${serverPort}`); }); // WebSocket Server for Web Client const wss = new WebSocketServer({ port: wssPort }); wss.on('connection', ws => { console.log('Client connected to WebSocket server'); ws.on('message', message => { console.log(`Received message: ${message}`); ws.send(`Server received: ${message}`); }); ws.on('close', () => { console.log('Client disconnected from WebSocket server'); }); ws.on('error', error => { console.error('WebSocket error:', error); }); }); console.log(`WebSocket server listening on port ${wssPort}`); ``` **4. Building and Running** ```bash npm run build # or tsc node dist/index.js ``` **Explanation and "Batteries Included" Features** * **TypeScript:** Using TypeScript provides static typing, which helps catch errors early and improves code maintainability. * **`net` Module:** The `net` module is used to create a TCP server that listens for incoming Minecraft client connections. * **`uuid`:** The `uuid` library is used to generate unique player IDs. * **Basic World:** The `world` array represents a very simple 3D world. This is a placeholder; you'll need to implement a more robust world management system. * **Player Management:** The `players` object stores information about connected players. * **Error Handling:** Basic error handling is included for socket connections. * **WebSocket Server:** The `ws` library is used to create a WebSocket server, allowing web clients to connect to the server. **Key Areas for Further Development** * **Minecraft Protocol (MCP) Implementation:** This is the most complex part. You'll need to thoroughly understand the MCP specification and implement packet parsing and serialization for all phases (handshake, status, login, play). Libraries exist that can help with this, but you'll still need to understand the protocol. * **World Generation:** Implement more sophisticated world generation algorithms (e.g., using Perlin noise or other techniques). * **Chunk Management:** Divide the world into chunks and load/unload them as players move around. * **Entity Management:** Implement entities (mobs, items, etc.) and their behavior. * **Game Logic:** Implement game rules, physics, and other game mechanics. * **Command System:** Create a more robust command system with permissions and argument parsing. * **Security:** Implement security measures to prevent cheating and attacks. * **Multiplayer Synchronization:** Ensure that the game state is synchronized correctly between all clients. * **Performance Optimization:** Optimize the server for performance, especially when handling many players. * **Logging:** Use a proper logging library (like `winston` or `pino`) for structured logging. **Important Considerations** * **Minecraft Protocol Specification:** Refer to the official Minecraft protocol documentation (if available) or community-maintained resources for the most up-to-date information on the protocol. The protocol changes with each Minecraft version. * **Libraries:** Consider using libraries that can help with MCP parsing and serialization. However, be aware that these libraries may not be fully up-to-date or complete. * **Complexity:** Creating a fully functional Minecraft server is a complex undertaking. Start with a simple implementation and gradually add features. This provides a starting point. Good luck!

MCP Tools

An MCP (Model Context Protocol) server implementation using HTTP SSE (Server-Sent Events) connections with built-in utility tools including echo, time, calculator, and weather query functionality.

MCP Ctl

Un administrador de paquetes para gestionar todos tus servidores MCP en todas las plataformas.

MCP Tool

Un servidor construido sobre mcp-framework que permite la integración con Claude Desktop a través del Protocolo de Contexto del Modelo.

Cloudflare Playwright MCP

Enables AI assistants to control a browser through a set of tools, allowing them to perform web automation tasks like navigation, typing, clicking, and taking screenshots.

MAVLinkMCP

Here are a few options for translating "MCP server for LLM to drone communication via MAVLink," depending on the nuance you want to convey: **Option 1 (Most Direct):** * **Servidor MCP para la comunicación LLM a dron a través de MAVLink** * This is the most literal translation and is perfectly understandable. It keeps the acronyms (MCP and LLM) as they are commonly used in technical contexts. **Option 2 (Slightly More Explanatory):** * **Servidor MCP para la comunicación entre un LLM y un dron usando MAVLink** * This adds "entre" (between) to clarify the communication is *between* the LLM and the drone. It also uses "usando" (using) instead of "a través de" (through) which can sometimes sound more natural. **Option 3 (More Descriptive, if needed):** * **Servidor MCP para facilitar la comunicación entre un modelo de lenguaje grande (LLM) y un dron mediante MAVLink** * This spells out "LLM" as "modelo de lenguaje grande" (large language model) for clarity, especially if the audience might not be familiar with the acronym. It also uses "facilitar" (to facilitate) which implies the MCP server is helping to enable the communication. **Which option is best depends on your audience:** * If your audience is technically savvy and familiar with the acronyms, **Option 1** is fine. * If you want to be a little clearer, **Option 2** is a good choice. * If you need to be very explicit and ensure everyone understands, **Option 3** is the most descriptive. In summary, I recommend **Option 1** or **Option 2** as the most common and natural translations.

Azure Java SDK MCP Server

A Model Context Protocol server that provides Azure Java SDK documentation to AI assistants, allowing them to access readme files with introductions, key concepts, and code samples.

Node.js MCP Weather Server

An MCP server that provides weather information like forecasts and alerts for US locations using the National Weather Service API.

Atlassian MCP Server

Proporciona integración con los productos de Atlassian a través del Protocolo de Contexto de Modelo, permitiendo a los usuarios interactuar con tickets de JIRA y páginas de Confluence.

Finance MCP Server

Provides real-time financial data from Yahoo Finance to Large Language Models through the Model Context Protocol, enabling AI models to access stock prices, historical data, and company information.