Discover Awesome MCP Servers

MCP NanoBanana

Enables AI image generation and editing using Google's Nano Banana model via the AceDataCloud API. It supports creating images from text prompts, virtual try-ons, and product placement directly within MCP-compatible clients.

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.

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

Browser-use-claude-mcp

Um servidor MCP de automação de navegador para modelos de IA como Claude e Gemini 2.5, permitindo capacidades de navegação na web através de linguagem natural.

Google MCP

Esta é uma coleção de ferramentas nativas do Google (por exemplo, Gmail, Agenda) para o protocolo MCP, projetadas para se integrarem perfeitamente com clientes de IA como Claude ou Cursor.

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.

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.

Limitless AI MCP Server

Connects AI assistants to your Limitless AI lifelog data, enabling them to search, retrieve, and analyze your recorded conversations and daily activities from your Limitless pendant.

Envoi MCP

Provides AI agents with a real email address to send, receive, and manage emails via the Envoi.work platform. It enables seamless email communication, including inbox management and threaded replies, directly within MCP-compatible clients.

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

Plugin para JADX para integrar o servidor MCP.

Random.org MCP Server

A Model Context Protocol server that provides access to api.random.org for generating true random numbers, strings, UUIDs, and more.

TMB Bus Arrival Times

Provides real-time bus arrival information for TMB (Transports Metropolitans de Barcelona) bus stops, showing when buses will arrive in minutes with line numbers, destinations, and directions.

Agent5ive MCP Server

Enables MCP-compatible clients to interact with deployed Agent5ive agents as tools. Allows users to query agent purposes and send messages to leverage Agent5ive capabilities through natural language.

Vextra MCP Server

A server based on Model Context Protocol that processes and parses design files (Vextra/Figma/Sketch/SVG), enabling AI assistants to access and manipulate design content.

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.

Code Mode Bridge

An MCP server that aggregates multiple upstream MCP tools into a single 'codemode' tool for unified orchestration and execution. It enables agents to run generated code in an isolated sandbox to interact with various connected services through a single interface.

Wealthfolio MCP Server

Integrates with Wealthfolio to provide real-time portfolio data, valuations, account management, and historical performance analytics through a Model Context Protocol interface compatible with OpenWebUI and automation tools.

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.

xiaozhi-mcp

A framework for extending AI capabilities through remote control, calculations, and email operations using the Model Context Protocol. It provides a configuration-driven interface supporting multiple transport types including stdio, SSE, and HTTP.

Brazilian Law Research MCP Server

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

Orange Juice Online Judge MCP Server

Provides tools for AI agents to interact with the Orange Juice Online Judge API by managing problems and code submissions. Users can list problems, retrieve detailed descriptions, submit source code, and track submission status through natural language.

Mind Map MCP

Automatically generates mind map images from text content using Coze API workflow. Returns accessible image links that can be used in MCP-compatible tools like CodeBuddy, Cursor, and Qoder.

MCP Serp

An MCP server that provides structured Google Search capabilities including web, images, news, videos, maps, and local places via the AceDataCloud SERP API. It enables AI clients to perform localized searches and retrieve detailed information from the Google Knowledge Graph.