Discover Awesome MCP Servers

Brazilian Law Research MCP Server

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

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.

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.

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.

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.

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.

ca-leginfo-mcp

MCP server for California statutes and legislation, enabling verification of current statutory text, tracking pending bills that would amend or repeal sections, and retrieving legislative history from 1993 onward using official legislative bulk data.

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.

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.

AI Web Tester

Enables AI coding agents to autonomously interact with and test web applications in a real browser, providing DOM/Accessibility tree extraction, runtime telemetry, screenshot capture, and Markdown test reports.

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.

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.

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.

weeek-mcp

Local, read-only-by-default MCP server for Weeek that connects AI clients to your workspace over stdio, enabling listing projects, tasks, boards, members, and tags with opt-in write tools for task management.

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.

the-mogiyoon-mcp

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

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.

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-memory

An MCP server that gives an Agent Studio project a memory that outlives a run, using S3 for storage and exposing tools to recall, remember, list, and forget memories.

mcp-ai-slop-checker

Three deterministic MCP tools that score text for AI-writing tells (em-dash density, hedge words, tricolons, boilerplate openers) and grade landing-page copy. No LLM, no network calls, no API key — same input always yields the same score. Published on the official MCP registry as io.github.parweb/ai-slop-checker.

mcp-google-sheets

Enables AI assistants to interact with Google Sheets, allowing CRUD operations, sheet management, and data manipulation through natural language.

Hello Widget Example

A minimal ChatGPT app demonstrating interactive greeting widgets with confetti animations and theme support, built as an MCP server example using Smithery CLI.