Discover Awesome MCP Servers

Backlogr MCP Server

Enables AI assistants to create and manage development projects with structured backlogs, including tasks, requirements, and progress tracking. Provides a bridge between AI development assistants and project management workflows through standardized MCP tools.

TMB Bus Arrival Times

Provides real-time bus arrival information for TMB (Transports Metropolitans de Barcelona) bus stops, showing when buses will arrive in minutes with line numbers, destinations, and directions.

Excel MCP Server

Enables AI assistants to read, write, format, and analyze Excel files with 34 tools, including real-time editing on macOS with Microsoft Excel.

Git Conflict MCP

Enables detection and resolution of Git merge conflicts in repositories through MCP, providing tools to identify conflicting files and assist with conflict resolution workflows.

mcp-linux-desktop

Enables full Linux desktop control including windows, mouse, keyboard, clipboard, audio, screenshots, OCR, accessibility, and system management through MCP-compatible AI agents.

Zendesk MCP Server

Enables AI agents to audit and analyze Zendesk instances through a read-only MCP interface, providing tools for triggers, automations, analytics, and cross-reference queries.

partiful-mcp

Enables AI agents to view Partiful events, RSVPs, hosted events, mutual connections, and user profiles via a community-built MCP server.

@jurislm/entire-mcp

MCP server providing 19 tools to manage AI agent checkpoints and sessions via the Entire CLI.

liuren

Enables 大六壬 divination by computing the chart (三傳, 四課, etc.) and generating a 天地盤 PNG from a given datetime.

web-scout

A reconnaissance MCP server that discovers web data sources by monitoring network requests and extracting API structures, enabling AI to understand data location and format without full crawling.

MSSQL MCP Server

A Model Context Protocol server that enables LLMs like Claude to interact with Microsoft SQL Server databases through natural language, supporting queries, data manipulation, and table management.

MCP-ChatBot

Okay, here's a simple example of a client-server setup using the Minecraft Communications Protocol (MCP), along with explanations to help you understand the code. Keep in mind that this is a *very* basic example and doesn't implement any actual Minecraft functionality. It's just meant to demonstrate the fundamental client-server interaction. **Important Considerations:** * **MCP is Complex:** The full MCP is extremely complex and reverse-engineered. This example *does not* use the real MCP mappings or protocol. It's a simplified illustration. * **Real Minecraft Communication:** Communicating with a real Minecraft server requires understanding the Minecraft protocol, which is constantly updated. Libraries like `minecraft-protocol` (Node.js) or `mcstatus` (Python) are generally used for that. * **This Example's Purpose:** This example is for educational purposes to show the basic structure of a client-server interaction. It's *not* a drop-in solution for interacting with a Minecraft server. **Conceptual Overview:** 1. **Server:** * Listens for incoming connections on a specific port. * When a client connects, it accepts the connection. * Receives data from the client. * Processes the data (in this example, it just echoes it back). * Sends a response back to the client. * Closes the connection (or keeps it open for further communication). 2. **Client:** * Connects to the server's IP address and port. * Sends data to the server. * Receives a response from the server. * Closes the connection. **Python Example (using `socket`):** **Server (server.py):** ```python import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break decoded_data = data.decode('utf-8') print(f"Received: {decoded_data}") conn.sendall(data) # Echo back to the client print(f"Sent: {decoded_data}") ``` **Client (client.py):** ```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)) message = "Hello, Server!" s.sendall(message.encode('utf-8')) print(f"Sent: {message}") data = s.recv(1024) print(f"Received: {data.decode('utf-8')}") ``` **How to Run:** 1. Save the server code as `server.py` and the client code as `client.py`. 2. Open two terminal windows. 3. In the first terminal, run the server: `python server.py` 4. In the second terminal, run the client: `python client.py` **Explanation:** * **`socket.socket(socket.AF_INET, socket.SOCK_STREAM)`:** Creates a socket object. * `AF_INET`: Specifies the IPv4 address family. * `SOCK_STREAM`: Specifies a TCP socket (reliable, connection-oriented). * **`s.bind((HOST, PORT))` (Server):** Binds the socket to a specific address and port. This tells the operating system that the server will listen for connections on that address and port. * **`s.listen()` (Server):** Enables the server to accept connections. * **`conn, addr = s.accept()` (Server):** Accepts an incoming connection. `conn` is a new socket object representing the connection to the client. `addr` is the address of the client. * **`s.connect((HOST, PORT))` (Client):** Connects the client socket to the server's address and port. * **`conn.recv(1024)` (Server) / `s.recv(1024)` (Client):** Receives data from the socket. `1024` is the maximum number of bytes to receive at once. * **`conn.sendall(data)` (Server) / `s.sendall(data)` (Client):** Sends data to the socket. `sendall` ensures that all data is sent. * **`data.decode('utf-8')`:** Decodes the received bytes into a string (assuming UTF-8 encoding). * **`message.encode('utf-8')`:** Encodes the string into bytes using UTF-8 encoding. **Important Notes and Improvements:** * **Error Handling:** The code lacks proper error handling (e.g., `try...except` blocks). You should add error handling to make it more robust. * **Closing Connections:** The server in this example closes the connection after receiving one message. You might want to keep the connection open for multiple messages. * **Threading/Asynchronous:** For a real server, you'd typically use threads or asynchronous programming (e.g., `asyncio` in Python) to handle multiple clients concurrently. The current example only handles one client at a time. * **Data Serialization:** For more complex data, you'll need to use a serialization format like JSON or Protocol Buffers to convert data structures into a byte stream for transmission. * **Minecraft Protocol:** To interact with a real Minecraft server, you *must* implement the Minecraft protocol. This involves understanding the packet structure, compression, encryption, and authentication. Use a library like `minecraft-protocol` (Node.js) or `mcstatus` (Python) to simplify this. **Spanish Translation:** Aquí tienes un ejemplo sencillo de una configuración cliente-servidor utilizando el Protocolo de Comunicaciones de Minecraft (MCP), junto con explicaciones para ayudarte a entender el código. Ten en cuenta que este es un ejemplo *muy* básico y no implementa ninguna funcionalidad real de Minecraft. Está destinado únicamente a demostrar la interacción fundamental cliente-servidor. **Consideraciones Importantes:** * **MCP es Complejo:** El MCP completo es extremadamente complejo y de ingeniería inversa. Este ejemplo *no* utiliza los mapeos o el protocolo MCP reales. Es una ilustración simplificada. * **Comunicación Real de Minecraft:** Comunicarse con un servidor real de Minecraft requiere comprender el protocolo de Minecraft, que se actualiza constantemente. Generalmente se utilizan bibliotecas como `minecraft-protocol` (Node.js) o `mcstatus` (Python) para eso. * **Propósito de este Ejemplo:** Este ejemplo tiene fines educativos para mostrar la estructura básica de una interacción cliente-servidor. *No* es una solución lista para usar para interactuar con un servidor de Minecraft. **Descripción General Conceptual:** 1. **Servidor:** * Escucha las conexiones entrantes en un puerto específico. * Cuando un cliente se conecta, acepta la conexión. * Recibe datos del cliente. * Procesa los datos (en este ejemplo, simplemente los devuelve). * Envía una respuesta al cliente. * Cierra la conexión (o la mantiene abierta para una mayor comunicación). 2. **Cliente:** * Se conecta a la dirección IP y al puerto del servidor. * Envía datos al servidor. * Recibe una respuesta del servidor. * Cierra la conexión. **Ejemplo en Python (usando `socket`):** **Servidor (server.py):** ```python import socket HOST = '127.0.0.1' # Dirección de interfaz de bucle invertido estándar (localhost) PORT = 65432 # Puerto para escuchar (los puertos no privilegiados son > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Servidor escuchando en {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Conectado por {addr}") while True: data = conn.recv(1024) if not data: break decoded_data = data.decode('utf-8') print(f"Recibido: {decoded_data}") conn.sendall(data) # Devuelve al cliente (eco) print(f"Enviado: {decoded_data}") ``` **Cliente (client.py):** ```python import socket HOST = '127.0.0.1' # El nombre de host o la dirección IP del servidor PORT = 65432 # El puerto utilizado por el servidor with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) message = "¡Hola, Servidor!" s.sendall(message.encode('utf-8')) print(f"Enviado: {message}") data = s.recv(1024) print(f"Recibido: {data.decode('utf-8')}") ``` **Cómo Ejecutar:** 1. Guarda el código del servidor como `server.py` y el código del cliente como `client.py`. 2. Abre dos ventanas de terminal. 3. En la primera terminal, ejecuta el servidor: `python server.py` 4. En la segunda terminal, ejecuta el cliente: `python client.py` **Explicación:** * **`socket.socket(socket.AF_INET, socket.SOCK_STREAM)`:** Crea un objeto socket. * `AF_INET`: Especifica la familia de direcciones IPv4. * `SOCK_STREAM`: Especifica un socket TCP (confiable, orientado a la conexión). * **`s.bind((HOST, PORT))` (Servidor):** Vincula el socket a una dirección y puerto específicos. Esto le dice al sistema operativo que el servidor escuchará las conexiones en esa dirección y puerto. * **`s.listen()` (Servidor):** Permite que el servidor acepte conexiones. * **`conn, addr = s.accept()` (Servidor):** Acepta una conexión entrante. `conn` es un nuevo objeto socket que representa la conexión al cliente. `addr` es la dirección del cliente. * **`s.connect((HOST, PORT))` (Cliente):** Conecta el socket del cliente a la dirección y el puerto del servidor. * **`conn.recv(1024)` (Servidor) / `s.recv(1024)` (Cliente):** Recibe datos del socket. `1024` es el número máximo de bytes que se recibirán a la vez. * **`conn.sendall(data)` (Servidor) / `s.sendall(data)` (Cliente):** Envía datos al socket. `sendall` asegura que se envíen todos los datos. * **`data.decode('utf-8')`:** Decodifica los bytes recibidos en una cadena (asumiendo la codificación UTF-8). * **`message.encode('utf-8')`:** Codifica la cadena en bytes usando la codificación UTF-8. **Notas Importantes y Mejoras:** * **Manejo de Errores:** El código carece de un manejo de errores adecuado (por ejemplo, bloques `try...except`). Deberías agregar el manejo de errores para hacerlo más robusto. * **Cerrar Conexiones:** El servidor en este ejemplo cierra la conexión después de recibir un mensaje. Es posible que desees mantener la conexión abierta para varios mensajes. * **Hilos/Asíncrono:** Para un servidor real, normalmente usarías hilos o programación asíncrona (por ejemplo, `asyncio` en Python) para manejar varios clientes simultáneamente. El ejemplo actual solo maneja un cliente a la vez. * **Serialización de Datos:** Para datos más complejos, deberás utilizar un formato de serialización como JSON o Protocol Buffers para convertir las estructuras de datos en un flujo de bytes para la transmisión. * **Protocolo de Minecraft:** Para interactuar con un servidor real de Minecraft, *debes* implementar el protocolo de Minecraft. Esto implica comprender la estructura de los paquetes, la compresión, el cifrado y la autenticación. Utiliza una biblioteca como `minecraft-protocol` (Node.js) o `mcstatus` (Python) para simplificar esto. I hope this helps! Let me know if you have any other questions.

godot-docs-mcp

Query Godot Engine documentation with full-text search across classes, methods, properties, and inheritance.

ddg--mcp6

A basic MCP server template with example tools for echoing messages and retrieving server information. Built with FastMCP framework and supports both stdio and HTTP transports for integration with various clients.

token-scout

Discovers LLM models in real time from cloud providers and local Ollama instances, returning compatibility profiles and live pricing so AI agents can route tasks to the cheapest viable model without breaking tool calls or context clipping.

MCP-BPMN Server

Enables AI agents to create, manipulate, and manage BPMN 2.0 diagrams programmatically, with support for Mermaid conversion, auto-layout, and file persistence.

tgfmcp

MCP server that enables Telegram bot interaction via Telegraf, providing tools for sending, replying, reacting, editing, deleting, forwarding messages, and receiving Telegram events over an optional notification channel.

Geo MCP Server

Enables building, querying, and publishing structured knowledge to the decentralized Geo knowledge graph using GRC-20, with tools for graph operations, DAO governance, and file ingestion.

Knowledge MCP Service

Enables AI-powered document analysis and querying for project documentation using vector embeddings stored in Redis. Supports document upload, context-aware Q\&A, automatic test case generation, and requirements traceability through OpenAI integration.

MCP Data Analyst

Enables natural language querying of SQL databases using AI, supporting multiple database types and automatic schema discovery.

silentwatch-mcp

An MCP server that surfaces scheduled-job state and detects silent failures (exit 0 but no useful output) for cron, systemd timers, and OpenClaw schedulers, enabling AI agents to query job health and overdue status directly.

mcp_slack

fetch the latest channels messages chat

MCP Declarative Server

A utility module for creating Model Context Protocol servers declaratively, allowing developers to easily define tools, prompts, and resources with a simplified syntax.

Instagram MCP Server

Enables AI applications to interact with Instagram Business accounts programmatically via the Graph API, supporting profile info, media posting, insights, and DMs.

Brazilian Law Research MCP Server

A MCP server for agent-driven research on Brazilian law using official sources

Orange Juice Online Judge MCP Server

Provides tools for AI agents to interact with the Orange Juice Online Judge API by managing problems and code submissions. Users can list problems, retrieve detailed descriptions, submit source code, and track submission status through natural language.

mcp-impresario

MCP server for Claude Code to execute commands on any remote server over SSH. Provides tools for remote execution, file operations, and connection info.

EDA Tools MCP Server

A comprehensive Model Context Protocol server that connects AI assistants to Electronic Design Automation tools, enabling Verilog synthesis, simulation, ASIC design flows, and waveform analysis through natural language interaction.

Microsoft Planner MCP

Enables interaction with Microsoft Planner tasks through natural language using Azure CLI authentication. Supports listing plans, creating/updating/deleting tasks, managing buckets, and integrating GitHub links without complex OAuth setup.

Netdetective MCP Server

An MCP server that provides access to the Netdetective API for querying information about IP addresses. It enables users to retrieve metadata for a specified IP address or the connecting client's default IP address.