Discover Awesome MCP Servers

Prometheus MCP

Servidor MCP para conectar LLMs com a API HTTP do Prometheus.

Advanced Reasoning MCP Server

An MCP server that enhances sequential thinking with meta-cognitive capabilities including confidence tracking, hypothesis testing, and organized memory storage through graph-based libraries and structured JSON documents.

Agentic Shopping MCP

Enables AI agents to perform e-commerce operations including product search, budget-constrained shopping recommendations, and sustainability analysis. Includes a secure HTTP bridge with OAuth integration and observability features for production deployment.

Confluence MCP Server

A universal, production-ready MCP server that provides AI assistants like Claude with direct access to Confluence Cloud functionality for creating, reading, updating, and managing content through multiple transport protocols.

Navidrome-MCP

Analyze listening patterns, create custom playlists, discover missing albums, validate radio streams, and provide personalized recommendations through natural language.

itemit-mcp

An MCP server that enables asset tracking by providing a bridge between the itemit asset management API and the Model Context Protocol ecosystem, allowing users to search, create, and manage assets programmatically.

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.

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.

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.

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.

Jina AI Remote MCP Server

Provides access to Jina AI's suite of tools including web search, URL reading, image search, embeddings, and reranking capabilities. Enables users to extract web content as markdown, search academic papers, capture screenshots, and perform semantic operations through natural language.

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

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.

S/MCP - Stern Model Context Protocol

An MCP server that provides access to Stern, a philosophical AI mentor combining rationalist thinking with stoic philosophy to guide users through personalized mentorship and smart contract accountability on Solana.

MCP Link - Convert Any OpenAPI V3 API to MCP Server

Convertendo qualquer API OpenAPI V3 para um Servidor MCP

Google Places MCP Server

Integrates with Google Places API to allow searching, retrieving details, and finding nearby places through an MCP server interface.

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.

DART-mcp-server

Um servidor MCP que utiliza a API do Sistema de Divulgação Eletrônica da Coreia (DART).

Weather MCP Server

Provides weather information for cities through a protected MCP interface with Nevermined payment integration. Demonstrates both high-level and low-level MCP server implementations with paywall protection for tools, resources, and prompts.

Serverless VPC Access MCP Server

An auto-generated MCP server for Google's Serverless VPC Access API, enabling communication with Google Cloud VPC networks through natural language interactions.

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.

Dumpling AI MCP Server

Integra-se com o Dumpling AI para fornecer recursos de extração de dados, processamento de conteúdo, gerenciamento de conhecimento e execução de código por meio de ferramentas para interações na web, manipulação de documentos e serviços de IA.

PAELLADOC

A Model Context Protocol (MCP) server that implements AI-First Development framework principles, allowing LLMs to interact with context-first documentation tools and workflows for preserving knowledge and intent alongside code.

Apktool MCP Server

An MCP server that integrates with Apktool to provide live reverse engineering support for Android applications using Claude and other LLMs through the Model Context Protocol.

MCP-DayOne

A Message Control Protocol server that enables Claude Desktop and other applications to interact with Day One journals, allowing automated journal entry creation through a simple API.

Remote MCP Server

A Cloudflare Workers-based implementation of a Model Context Protocol server that enables AI assistants like Claude to access external tools through OAuth authentication.

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.