Discover Awesome MCP Servers

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.

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.

ynab-mcp

A Model Context Protocol (MCP) server for interacting with YNAB (You Need A Budget). Provides tools for accessing budget data through MCP-enabled clients like Claude Desktop.

Agent5ive MCP Server

Enables MCP-compatible clients to interact with deployed Agent5ive agents as tools. Allows users to query agent purposes and send messages to leverage Agent5ive capabilities through natural language.

Vextra MCP Server

A server based on Model Context Protocol that processes and parses design files (Vextra/Figma/Sketch/SVG), enabling AI assistants to access and manipulate design content.

Zaifer-MCP

Enables LLM assistants like Claude to interact with Zaif cryptocurrency exchange through natural language, supporting market information retrieval, chart data, trading, and account management for BTC/JPY, ETH/JPY, and XYM/JPY pairs.

OpenSCAD MCP Server

Provides OpenSCAD rendering capabilities through a Model Context Protocol interface, allowing users to generate PNG images from OpenSCAD code without a GUI.

Wealthfolio MCP Server

Integrates with Wealthfolio to provide real-time portfolio data, valuations, account management, and historical performance analytics through a Model Context Protocol interface compatible with OpenWebUI and automation tools.

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.

AURA MCP Server

Enables Claude and ChatGPT to interact with AURA API for real-time DeFi portfolio analysis, swap execution, yield opportunities, and automated trading strategies across 200+ blockchain networks. Includes natural language swap parsing, cross-chain portfolio tracking, AI strategy automation, and risk management through guard engines.

example-mcp-server-streamable-http-stateless

example-mcp-server-streamable-http-stateless

Godot MCP Documentation Server

Provides AI assistants with direct access to the complete Godot Engine documentation, including classes, tutorials, and features. It enables developers to retrieve and analyze official documentation through natural language interfaces using the Model Context Protocol.

IoT Realm MCP Server 🌐🔌

🌐🔌 An MCP server that exposes real-time sensor data from IoT Realm devices—such as ESP32-based DHT11 clients—to LLMs via the Model Context Protocol. This enables AI agents to access, analyze, and act upon live environmental data.

Meraki MCP Server

This MCP (Model Context Protocol) Server provides a communication interface for the Meraki Dashboard API, auto-generated using AG2's MCP builder from the Meraki OpenAPI specification.

Artsy Analytics MCP Server

A Model Context Protocol server that provides Artsy partner analytics tools for Claude Desktop, allowing users to query gallery metrics, sales data, audience insights, and content performance through natural language.

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.

SSH MCP Server

Provides tools to manage SSH targets and generate one-time WebShell terminal sessions through an integrated gateway. It enables AI agents to facilitate remote server access by creating and managing secure, browser-based terminal links.

SearXNG MCP Server

Enables AI agents to perform privacy-respecting web searches through SearXNG, with support for multiple search engines, categories, and advanced filtering options.

IBM DB2 MCP Server by CData

IBM DB2 MCP Server by CData

GitLab Pipeline MCP Server

Enables AI clients to manage GitLab pipelines through natural language commands. Supports triggering pipelines, checking status, listing pipelines, viewing jobs, and canceling pipelines across multiple GitLab instances.

VibeTide MCP Server

Enables AI-assisted creation, editing, and visualization of VibeTide 2D platformer levels with tools for tile manipulation, level metadata management, and web-based gameplay.

PTO MCP Server

Exposes PTOAi user context to Agent Builder by connecting to a Supabase database. It allows agents to retrieve user profiles, intake and follow-up data, and manage weekly plans.

FiveM MCP Server

A TypeScript-based server that provides debugging and management capabilities for FiveM plugin development, allowing developers to control plugins, monitor server logs, and execute RCON commands.

DuckDuckGo MCP Server

A Model Context Protocol server that enables AI applications like Claude Desktop and Cursor IDE to perform web searches via DuckDuckGo's search engine.

Apple Health MCP Server

An MCP server that allows users to query and analyze their Apple Health data using SQL and natural language, utilizing DuckDB for fast and efficient health data analysis.

Local Search MCP Server

Enables completely offline Wikipedia search through locally-indexed content using BM25 algorithm, allowing AI assistants to query Wikipedia without internet connectivity or external API calls.

Github Copilot VScode MCP Server

A server that likely facilitates integration between GitHub Copilot and Visual Studio Code, though the README lacks specific details about its functionality.

Shiprocket MCP Integration

Enables interaction with Shiprocket shipping services to check courier rates and delivery times, create and manage orders, ship packages, track shipments, and schedule pickups through natural language commands.

MCP CRUD Tools

Enables interaction with Users and Products through a CRUD service REST API, providing tools for listing, creating, reading, updating, and deleting records via HTTP transport.