Discover Awesome MCP Servers

Snowflake MCP Server

Enables AI assistants to securely connect to Snowflake data warehouses and execute SQL queries through natural language interactions. Supports multiple authentication methods and provides formatted query results with built-in security controls.

CME Prediction Markets MCP Server

Enables verification of natural language claims against CME prediction market data, with tools to query historical trading data, get contract information, and automatically verify claims using NLP-powered parsing.

AQICN MCP Server

Enables querying real-time air quality index (AQI) data for Chinese cities, including PM2.5, PM10, and other pollutant information with health recommendations from the World Air Quality Index Project API.

fec-mcp-server

Query FEC campaign finance data — search candidates, track donations, analyze spending, and monitor Super PAC activity via the OpenFEC API.

Awesome MCP (Model Context Protocol) ⚡

Uma coleção selecionada de ferramentas, servidores e recursos para o Protocolo de Contexto de Modelo (MCP) - o padrão aberto para conectar LLMs com fontes de dados e ferramentas externas.

Chen's AI Copy

A personal digital twin MCP server that manages professional context, including skills, experience, and project learnings. It allows AI assistants to retrieve and update user preferences and career interests across different development environments.

SuricataMCP

SuricataMCP is a Model Context Protocol Server that allows MCP clients to autonomously use suricata for network traffic analysis. It enables programmatic interaction with Suricata through tools like get\_suricata\_version, get\_suricata\_help, and get\_alerts\_from\_pcap\_file.

MCP Remote Server

Enables execution of SSH commands on remote servers and management of Google Cloud Platform (GCE) instances through Cursor IDE.

Context7 MCP Clone

Provides up-to-date, version-specific documentation and code examples for software libraries directly to LLMs, enabling resolution of library identifiers and retrieval of relevant documentation with code snippets.

codecortex

Persistent codebase knowledge layer for AI agents. Pre-digests codebases into structured knowledge (symbols, dependency graphs, co-change patterns, architectural decisions) and serves via MCP. 28 languages, 14 tools, ~85% token reduction.

Copy-Paste MCP

A Model Context Protocol server that provides a tool for extracting specific line ranges from text content while preserving exact formatting and newlines.

Aegis-ZK

On-chain trust verification for AI agent tools. Agents query skill attestations, audit levels, and risk scores before running third-party MCP servers, so you know what's safe before you execute.

Claude-to-Gemini MCP Server

Enables Claude to use Google Gemini as a secondary AI through MCP for large-scale codebase analysis and complex reasoning tasks. Supports both Gemini Flash and Pro models with specialized functions for general queries and comprehensive code analysis.

example-mcp-server-streamable-http

example-mcp-server-streamable-http

A Simple MCP Server and Client

Okay, here's a simple example of a client-server setup using the Minecraft Communications Protocol (MCP) in Python. This is a very basic illustration and doesn't implement the full Minecraft protocol, but it demonstrates the core concept of sending and receiving data. **Important Considerations:** * **MCP is Complex:** The actual Minecraft protocol is significantly more complex than this example. This is a simplified demonstration. * **Libraries:** For real Minecraft interaction, you'll likely want to use a library like `mcpi` (for Raspberry Pi Minecraft) or a more advanced networking library that handles the protocol details. * **Security:** This example is not secure. Do not use it in a production environment. **Code:** ```python import socket import threading # Server Code class MinecraftServer: def __init__(self, host='localhost', port=25565): self.host = host self.port = port self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_socket.bind((self.host, self.port)) self.server_socket.listen(5) # Listen for up to 5 connections self.clients = [] def run(self): print(f"Server listening on {self.host}:{self.port}") while True: client_socket, address = self.server_socket.accept() print(f"Accepted connection from {address}") self.clients.append(client_socket) client_thread = threading.Thread(target=self.handle_client, args=(client_socket,)) client_thread.start() def handle_client(self, client_socket): try: while True: data = client_socket.recv(1024) # Receive up to 1024 bytes if not data: break # Client disconnected message = data.decode('utf-8') print(f"Received from client: {message}") # Echo the message back to the client (simple example) client_socket.sendall(f"Server received: {message}".encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: print("Client disconnected.") self.clients.remove(client_socket) client_socket.close() # Client Code class MinecraftClient: def __init__(self, host='localhost', port=25565): self.host = host self.port = port self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) def connect(self): try: self.client_socket.connect((self.host, self.port)) print(f"Connected to server at {self.host}:{self.port}") except Exception as e: print(f"Connection error: {e}") return False return True def send_message(self, message): try: self.client_socket.sendall(message.encode('utf-8')) data = self.client_socket.recv(1024) print(f"Received from server: {data.decode('utf-8')}") except Exception as e: print(f"Send/Receive error: {e}") def close(self): self.client_socket.close() print("Connection closed.") if __name__ == "__main__": # Start the server in a separate thread server = MinecraftServer() server_thread = threading.Thread(target=server.run) server_thread.daemon = True # Allow the main thread to exit even if the server thread is running server_thread.start() # Create a client and connect client = MinecraftClient() if client.connect(): client.send_message("Hello from the client!") client.send_message("Another message.") client.close() ``` **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_example.py`). 2. **Run:** Execute the file from your terminal: `python mcp_example.py` **Explanation:** * **Server:** * Creates a socket and listens for incoming connections. * When a client connects, it spawns a new thread to handle that client. * The `handle_client` function receives data from the client, prints it, and sends a response back. * **Client:** * Creates a socket and connects to the server. * Sends a message to the server and receives the server's response. * Closes the connection. * **Threading:** The server uses threading so that it can handle multiple clients concurrently. Without threading, the server would only be able to handle one client at a time. * **Encoding:** The code uses UTF-8 encoding to convert strings to bytes for sending over the network and back to strings when receiving. **Important Notes:** * **Error Handling:** The code includes basic error handling (try...except blocks), but you'll want to add more robust error handling in a real application. * **Minecraft Protocol:** This example does *not* implement the actual Minecraft protocol. The real protocol involves specific packet formats, compression, encryption, and authentication. * **Libraries:** For real Minecraft interaction, use a library like `mcpi` (for Raspberry Pi Minecraft) or a more advanced networking library that handles the protocol details. These libraries will handle the complexities of the Minecraft protocol for you. **Translation to Portuguese:** ```python import socket import threading # Código do Servidor class ServidorMinecraft: def __init__(self, host='localhost', port=25565): self.host = host self.port = port self.socket_servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket_servidor.bind((self.host, self.port)) self.socket_servidor.listen(5) # Aguarda até 5 conexões self.clientes = [] def executar(self): print(f"Servidor ouvindo em {self.host}:{self.port}") while True: socket_cliente, endereco = self.socket_servidor.accept() print(f"Conexão aceita de {endereco}") self.clientes.append(socket_cliente) thread_cliente = threading.Thread(target=self.lidar_com_cliente, args=(socket_cliente,)) thread_cliente.start() def lidar_com_cliente(self, socket_cliente): try: while True: data = socket_cliente.recv(1024) # Recebe até 1024 bytes if not data: break # Cliente desconectado mensagem = data.decode('utf-8') print(f"Recebido do cliente: {mensagem}") # Envia a mensagem de volta para o cliente (exemplo simples) socket_cliente.sendall(f"Servidor recebeu: {mensagem}".encode('utf-8')) except Exception as e: print(f"Erro ao lidar com o cliente: {e}") finally: print("Cliente desconectado.") self.clientes.remove(socket_cliente) socket_cliente.close() # Código do Cliente class ClienteMinecraft: def __init__(self, host='localhost', port=25565): self.host = host self.port = port self.socket_cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM) def conectar(self): try: self.socket_cliente.connect((self.host, self.port)) print(f"Conectado ao servidor em {self.host}:{self.port}") except Exception as e: print(f"Erro de conexão: {e}") return False return True def enviar_mensagem(self, mensagem): try: self.socket_cliente.sendall(mensagem.encode('utf-8')) data = self.socket_cliente.recv(1024) print(f"Recebido do servidor: {data.decode('utf-8')}") except Exception as e: print(f"Erro ao enviar/receber: {e}") def fechar(self): self.socket_cliente.close() print("Conexão fechada.") if __name__ == "__main__": # Inicia o servidor em uma thread separada servidor = ServidorMinecraft() thread_servidor = threading.Thread(target=servidor.executar) thread_servidor.daemon = True # Permite que a thread principal termine mesmo que a thread do servidor esteja rodando thread_servidor.start() # Cria um cliente e conecta cliente = ClienteMinecraft() if cliente.conectar(): cliente.enviar_mensagem("Olá do cliente!") cliente.enviar_mensagem("Outra mensagem.") cliente.fechar() ``` **Key Changes in the Portuguese Translation:** * Class names: `MinecraftServer` -> `ServidorMinecraft`, `MinecraftClient` -> `ClienteMinecraft` * Method names: `run` -> `executar`, `handle_client` -> `lidar_com_cliente`, `connect` -> `conectar`, `send_message` -> `enviar_mensagem`, `close` -> `fechar` * Variable names: `server_socket` -> `socket_servidor`, `client_socket` -> `socket_cliente`, `address` -> `endereco`, `message` -> `mensagem` * Print statements: Translated to Portuguese. * Comments: Translated to Portuguese. This translated version should be easier for Portuguese speakers to understand. Remember that the functionality remains the same; only the names and comments have been translated. It's still a simplified example and not a full Minecraft protocol implementation.

MetaTrader 5 MCP Server

Enables comprehensive access to the MetaTrader 5 trading platform for retrieving market data, managing accounts, and executing trading operations. It provides 32 specialized tools for interacting with MT5 functionalities, including historical OHLCV data access, real-time position monitoring, and automated order management.

codeix

Fast semantic code search for AI agents — find symbols, references, and callers across any codebase.

Zerodha MCP Server

Enables trading operations on Zerodha platform through natural language, supporting account management, order placement/modification, portfolio holdings, positions, margins, and stock news retrieval.

nandi-proxmox-mcp

An open-source MCP server for managing Proxmox environments, including nodes, virtual machines, and containers. It enables users to perform inventory checks, status monitoring, and control operations directly through MCP-compatible tools.

Custom Search MCP Server

An MCP (Multi-Agent Conversation Protocol) Server that enables interaction with Google's Custom Search API, allowing agents to perform customized web searches through natural language requests.

MCP Heroku Server

Provides comprehensive Heroku application management through the Heroku Platform API for AI assistants using the Model Context Protocol. It enables users to scale dynos, view deployment history, access logs, and manage environment variables through natural language.

Jokes MCP Server

An MCP server that retrieves jokes from three different sources: Chuck Norris jokes, Dad jokes, and Yo Mama jokes.

ArXiv MCP Server

Enables AI assistants to search arXiv's research repository, download papers, and access their content programmatically. Includes specialized prompts for comprehensive academic paper analysis covering methodology, results, and implications.

WikiJS MCP Server

An MCP server that enables full management of WikiJS instances, supporting operations like page creation, searching, and updating. It also provides tools for knowledge graph exploration, content summarization, and retrieval of wiki statistics.

BigBugAI MCP Server

Enables access to BigBugAI cryptocurrency tools for getting trending tokens and performing token analysis by contract address. Provides production-ready API access with rate limiting and authentication for crypto market intelligence.

Skillz MCP Server

Enables LLMs to dynamically discover and execute tools through a structured skills system. Serves as a documentation hub where skills are defined in directories, allowing progressive loading and interpretation of capabilities.

revenuebase-mcp-server

revenuebase-mcp-server