Discover Awesome MCP Servers

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.

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.

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.

MCP Code Analysis & Quality Server

Provides comprehensive code analysis through three MCP servers: static analysis for code quality and security, dependency analysis for package management and vulnerabilities, and complexity analysis for maintainability assessment across multiple programming languages.

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.

cellrank-mcp

Enables natural language interaction for scRNA-Seq analysis including preprocessing, clustering, and visualization using the CellRank library. It allows users and agents to perform complex genomic data tasks through standard MCP clients and frameworks.

Bitrix24 MCP Server

An integration server that enables AI agents to securely interact with Bitrix24 CRM data like contacts and deals via the Model Context Protocol. It provides standardized tools and resources for searching, retrieving, and updating CRM entities through the Bitrix24 REST API.

NEI MCP Server

Enables interaction with the NEI platform to query project resources such as interfaces and business groups. It provides tools for searching by URI or name and supports manual synchronization to ensure local data is up to date.

Store Screenshot Generator MCP

Generates beautiful App Store and Play Store screenshots by inserting app images into iPhone/iPad mockup frames with customizable text overlays and gradient backgrounds. Supports multiple device types and batch generation with both free and pro subscription tiers.

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.

Trapper Keeper MCP

An MCP server that automatically manages and organizes project documentation using the document reference pattern, keeping CLAUDE.md files clean and under 500 lines while maintaining full context for AI assistants.

WHOOP MCP Server

Connects WHOOP fitness data to Claude Desktop, enabling natural language queries about workouts, recovery, sleep patterns, and physiological cycles with secure OAuth authentication and local data storage.

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.

Hubble MCP Server

A Python-based Model Context Protocol server that integrates with Claude Desktop, allowing users to connect to Hubble API services by configuring the server with their Hubble API key.

arXiv MCP Server

Enables interaction with arXiv.org to search scholarly articles, retrieve metadata, download PDFs, and load article content directly into LLM context for analysis.

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.

Mendix Context Bridge

Enables AI agents to read and understand local Mendix project structure and logic by connecting directly to the .mpr file via MCP. Allows querying microflows, entities, attributes, and modules in read-only mode without requiring cloud access.

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.

Apple MCP Server

Enables interaction with Apple apps like Messages, Notes, and Contacts through the MCP protocol to send messages, search, and open app content using natural language.

MCP Link - Convert Any OpenAPI V3 API to MCP Server

Convertendo qualquer API OpenAPI V3 para um Servidor MCP

Gemini Context MCP Server

Espelho de

Brazilian Law Research MCP Server

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

Real Estate MCP Server

Enables real estate property searches with location and criteria filtering, plus comprehensive mortgage calculations including monthly payments and affordability analysis. Currently uses mock data for property searches but provides full mortgage calculation functionality.

Micro.blog Books MCP Server

Enables management of Micro.blog book collections through natural language, allowing users to organize bookshelves, add/move books, and track reading goals. Built with FastMCP for reliable integration with Claude Desktop.

mcp_slack

fetch the latest channels messages chat