Discover Awesome MCP Servers

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.

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.

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.

MCP-ChatBot

Here's a simple example of an MCP (Minecraft Communications Protocol) client-server setup in Python. This is a very basic illustration and doesn't cover all the complexities of a real Minecraft server interaction. It focuses on establishing a connection and sending/receiving simple messages. **Important Considerations:** * **MCP is Complex:** The actual Minecraft protocol is significantly more complex than this example. This is a *simplified* demonstration. For real Minecraft interaction, you'd need a proper Minecraft library (like `mcstatus` or `nbt`). * **Security:** This example is *not* secure. Do not use it in a production environment. Real Minecraft servers use encryption and authentication. * **Error Handling:** This example has minimal error handling. A robust implementation would need much more. * **Purpose:** This is for educational purposes to illustrate the basic client-server concept. **Server (server.py):** ```python import socket import threading HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 25565 # Port to listen on (non-privileged ports are > 1023) def handle_client(conn, addr): print(f"Connected by {addr}") while True: try: data = conn.recv(1024) # Receive data from the client if not data: break # Client disconnected message = data.decode('utf-8') print(f"Received from {addr}: {message}") response = f"Server received: {message}".encode('utf-8') conn.sendall(response) # Echo the message back to the client except ConnectionResetError: print(f"Client {addr} disconnected abruptly.") break except Exception as e: print(f"Error handling client {addr}: {e}") break conn.close() print(f"Connection with {addr} closed") def start_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() # Accept incoming connections thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() print(f"Active Connections: {threading.active_count() - 1}") # Subtract 1 for the main thread if __name__ == "__main__": start_server() ``` **Client (client.py):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 25565 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) print(f"Connected to {HOST}:{PORT}") while True: message = input("Enter message to send (or 'exit'): ") if message.lower() == 'exit': break s.sendall(message.encode('utf-8')) data = s.recv(1024) print(f"Received: {data.decode('utf-8')}") except ConnectionRefusedError: print("Connection refused. Make sure the server is running.") except Exception as e: print(f"An error occurred: {e}") print("Client exiting.") ``` **How to Run:** 1. **Save:** Save the code as `server.py` and `client.py`. 2. **Run the Server:** Open a terminal or command prompt and run `python server.py`. The server will start listening for connections. 3. **Run the Client:** Open another terminal or command prompt and run `python client.py`. 4. **Interact:** The client will prompt you to enter a message. Type a message and press Enter. The client will send the message to the server, and the server will echo it back. 5. **Exit:** Type `exit` in the client to close the connection. **Explanation:** * **Server:** * Creates a socket and binds it to a specific IP address and port. * Listens for incoming connections. * When a client connects, it accepts the connection and spawns a new thread to handle the client. This allows the server to handle multiple clients concurrently. * The `handle_client` function receives data from the client, decodes it, prints it to the console, and then sends the same data back to the client as a response. * Includes basic error handling for client disconnections. * **Client:** * Creates a socket and connects to the server's IP address and port. * Prompts the user to enter a message. * Encodes the message and sends it to the server. * Receives the response from the server and prints it to the console. * Includes basic error handling for connection refused. **Important Notes:** * **Firewall:** Make sure your firewall isn't blocking the port you're using (25565 in this example). * **Real Minecraft Protocol:** This is *not* the real Minecraft protocol. The real protocol involves handshaking, encryption, data compression, and specific packet formats. You'll need a library like `mcstatus` or `nbt` to interact with a real Minecraft server. * **Threading:** The server uses threading to handle multiple clients concurrently. This is a common pattern for network servers. **Translation to Portuguese:** Aqui está um exemplo simples de uma configuração cliente-servidor MCP (Minecraft Communications Protocol) em Python. Esta é uma ilustração muito básica e não cobre todas as complexidades de uma interação real com um servidor Minecraft. Ele se concentra em estabelecer uma conexão e enviar/receber mensagens simples. **Considerações Importantes:** * **MCP é Complexo:** O protocolo Minecraft real é significativamente mais complexo do que este exemplo. Esta é uma demonstração *simplificada*. Para uma interação real com o Minecraft, você precisaria de uma biblioteca Minecraft adequada (como `mcstatus` ou `nbt`). * **Segurança:** Este exemplo *não* é seguro. Não o utilize em um ambiente de produção. Servidores Minecraft reais usam criptografia e autenticação. * **Tratamento de Erros:** Este exemplo tem um tratamento de erros mínimo. Uma implementação robusta precisaria de muito mais. * **Propósito:** Isto é para fins educacionais para ilustrar o conceito básico de cliente-servidor. **Servidor (server.py):** ```python import socket import threading HOST = '127.0.0.1' # Endereço de interface de loopback padrão (localhost) PORT = 25565 # Porta para escutar (portas não privilegiadas são > 1023) def handle_client(conn, addr): print(f"Conectado por {addr}") while True: try: data = conn.recv(1024) # Recebe dados do cliente if not data: break # Cliente desconectado message = data.decode('utf-8') print(f"Recebido de {addr}: {message}") response = f"Servidor recebeu: {message}".encode('utf-8') conn.sendall(response) # Ecoa a mensagem de volta para o cliente except ConnectionResetError: print(f"Cliente {addr} desconectado abruptamente.") break except Exception as e: print(f"Erro ao lidar com o cliente {addr}: {e}") break conn.close() print(f"Conexão com {addr} fechada") def start_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Servidor escutando em {HOST}:{PORT}") while True: conn, addr = s.accept() # Aceita conexões de entrada thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() print(f"Conexões Ativas: {threading.active_count() - 1}") # Subtrai 1 para a thread principal if __name__ == "__main__": start_server() ``` **Cliente (client.py):** ```python import socket HOST = '127.0.0.1' # O nome do host ou endereço IP do servidor PORT = 25565 # A porta usada pelo servidor with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) print(f"Conectado a {HOST}:{PORT}") while True: message = input("Digite a mensagem para enviar (ou 'exit'): ") if message.lower() == 'exit': break s.sendall(message.encode('utf-8')) data = s.recv(1024) print(f"Recebido: {data.decode('utf-8')}") except ConnectionRefusedError: print("Conexão recusada. Certifique-se de que o servidor está em execução.") except Exception as e: print(f"Ocorreu um erro: {e}") print("Cliente saindo.") ``` **Como Executar:** 1. **Salvar:** Salve o código como `server.py` e `client.py`. 2. **Executar o Servidor:** Abra um terminal ou prompt de comando e execute `python server.py`. O servidor começará a escutar as conexões. 3. **Executar o Cliente:** Abra outro terminal ou prompt de comando e execute `python client.py`. 4. **Interagir:** O cliente solicitará que você digite uma mensagem. Digite uma mensagem e pressione Enter. O cliente enviará a mensagem para o servidor, e o servidor a ecoará de volta. 5. **Sair:** Digite `exit` no cliente para fechar a conexão. **Explicação:** * **Servidor:** * Cria um socket e o vincula a um endereço IP e porta específicos. * Escuta as conexões de entrada. * Quando um cliente se conecta, ele aceita a conexão e gera uma nova thread para lidar com o cliente. Isso permite que o servidor lide com vários clientes simultaneamente. * A função `handle_client` recebe dados do cliente, os decodifica, os imprime no console e, em seguida, envia os mesmos dados de volta ao cliente como uma resposta. * Inclui tratamento de erros básico para desconexões de clientes. * **Cliente:** * Cria um socket e se conecta ao endereço IP e porta do servidor. * Solicita ao usuário que digite uma mensagem. * Codifica a mensagem e a envia para o servidor. * Recebe a resposta do servidor e a imprime no console. * Inclui tratamento de erros básico para conexão recusada. **Notas Importantes:** * **Firewall:** Certifique-se de que seu firewall não está bloqueando a porta que você está usando (25565 neste exemplo). * **Protocolo Minecraft Real:** Este *não* é o protocolo Minecraft real. O protocolo real envolve handshaking, criptografia, compressão de dados e formatos de pacotes específicos. Você precisará de uma biblioteca como `mcstatus` ou `nbt` para interagir com um servidor Minecraft real. * **Threading:** O servidor usa threading para lidar com vários clientes simultaneamente. Este é um padrão comum para servidores de rede.

partiful-mcp

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

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.

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.

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.

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.

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.

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.

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.

synergieloc — French Real-Estate Legal Calculations

Exact French real-estate legal calculations for AI agents: IRL rent revision, service-charge reconciliation, compliant rent receipts — legal basis included in every answer.

TradePilot MCP Server

A production-grade MCP server that integrates Polygon.io market data with an 18-layer technical analysis engine to generate actionable options trading signals and high-probability playbooks.

Finviz MCP

Enables users to fetch real-time stock fundamentals, news, price history, and perform screener searches using Finviz and Yahoo Finance data without API keys. Note: screener functionality works only locally due to IP restrictions.

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.