Discover Awesome MCP Servers

SAP MCP Gateway

A reference implementation for connecting SAP Business One to MCP-compatible AI clients, enabling read-only SQL analysis and guarded write workflows.

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.

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.

partiful-mcp

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

comfyui-loop-mcp

A loop-aware MCP server for your own ComfyUI that enforces a build-run-look-critique-fix cycle, making the model iterate on pixel quality until the output matches the brief.

Agent Commerce Gateway

Enables AI agents to discover, call, and pay for existing HTTP APIs over MCP with x402 paywalls, non-custodial settlement, and no code changes to the backend.

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.

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.

JADX-AI-MCP

Okay, here's a translation of "Plugin for JADX to integrate MCP server" into Spanish: **Opción 1 (More literal, emphasizes the plugin):** * **Plugin para JADX para integrar un servidor MCP** **Opción 2 (Slightly more natural, emphasizes integration):** * **Plugin para integrar un servidor MCP en JADX** **Opción 3 (Focus on connecting to the server):** * **Plugin para conectar JADX a un servidor MCP** **Explanation of Choices:** * **Plugin:** This word translates directly and is commonly used in Spanish in the context of software. * **JADX:** This is a proper noun (the name of the software) and remains the same. * **to integrate:** "Integrar" is the direct translation and works well. * **MCP server:** "Servidor MCP" is the direct translation. * **"un" vs. no article:** Using "un" (a/an) before "servidor MCP" is grammatically correct and implies any MCP server. Omitting it is also acceptable and can sound slightly more concise. **Recommendation:** I would recommend **Opción 2: Plugin para integrar un servidor MCP en JADX** because it flows well and clearly conveys the purpose of the plugin. However, all three options are understandable.

git-mcp

Provides incremental code storage and GitHub synchronization with 18 tools for repository management, development workflow, version release, audit, test server sync, and code quality checks.

Findle

A fully local MCP server that provides web search via self-hosted SearXNG and page-to-markdown conversion (static and JS-rendered), all aggregated behind a single endpoint for use with AI assistants.

cPanel WordPress MCP

Enables managing cPanel accounts including subdomains, files, and WordPress installations via Softaculous from Claude Code using natural language.

the-mogiyoon-mcp

Enables controlling a game character, drawing on a canvas, and running chemistry experiments via natural language commands to Claude.

Studio MCP Hub

StudioMCPHub is a production MCP server exposing a complete creative AI pipeline and the Alexandria Aeternum art dataset as paid tool calls. Agents connect via Streamable HTTP and pay per call with x402 USDC micropayments on Base L2 — no API keys, no accounts, no sign-up.

Snowflake Chat

Enables natural language querying of Snowflake databases through a read-only MCP server, allowing users to ask questions in plain English and get results as markdown tables.

azure-devops-cli-mcp

A local MCP server that bridges Claude Desktop/Cowork to the Azure DevOps CLI, enabling full use of az devops, az repos, az boards, az pipelines, and az artifacts commands.

starling-bank-mcp

MCP server for Starling Bank API integration, enabling AI agents to manage accounts, view transactions, and send payments via natural language.

MCP Ops Agent

Provides MCP tools for operations desk tasks including calendar availability, customer lookup, quote calculation, and notification sending. Includes an internal agentic orchestrator that consumes the same MCP tools via protocol.

lore-mcp

Architectural memory layer for AI coding. Automatically extracts decisions, detects security gaps, and analyzes git history from your codebase in one command.

Maple

A unified MCP server providing observability, safety control, and behavior evolution for high-agency AI agents through tracing, replaying, and auditing. It features real-time firewall guardrails and ML-driven anomaly detection to monitor, block, or fork agent actions based on risk.

ai-market-intelligence

Enables comparing and recommending AI models based on scenario-specific criteria such as capability, context, relative cost, and self-hosting, with explanations of the scoring weights.

mcp-apps-demo-engine

An extensible MCP server and generative UI engine for hosting interactive B2B enterprise workflows with dynamic styling and stateful simulators.

OrbiAds

173 tools to automate Google Ad Manager — campaigns, creatives, inventory, reporting via natural language

Ghost Browser MCP

Undetectable browser automation server for MCP-compatible AI agents, offering 225 tools across 32 sections to navigate, extract, clone pages, and bypass antibot systems like Cloudflare.

cosense-mcp-worker

A stateless Remote MCP server on Cloudflare Workers for operating a single Cosense (formerly Scrapbox) project. It enables page retrieval, listing, full-text search, and line insertion via natural language, protected by Cloudflare Access Managed OAuth and JWT validation.

Call For Papers MCP

A Smithery MCP server that allows users to search for upcoming academic conferences and events from WikiCFP based on keywords, returning detailed event information including names, descriptions, dates, locations, and submission deadlines.

ChatGPT Bookmark Site MCP Server

Enables users to search, read, and query saved bookmark content via a read-only MCP interface, with full-text and optional semantic search.

my-eli-mcp

MCP server for the Laws of Malaysia Online portal, fetching and citing Malaysian principal Acts with verifiable citations.

Skill Audit MCP

Scans MCP servers, AI agent skills, and plugins for 68+ malicious patterns including credential exfiltration, prompt injection, and code execution.

easy-gg-bedwars-mcp

A local-first Python MCP server for Easy.gg BedWars custom scripting, enabling users to create, edit, and sync Roblox BedWars scripts using official APIs and Code Sync.