Discover Awesome MCP Servers

Calculator MCP Server

A unified mathematical calculator that automatically detects expression types and performs basic arithmetic, statistical calculations, equation solving, and batch computations with 20+ built-in mathematical functions.

FDEP MCP Server

Provides static code analysis for enterprise-scale Haskell codebases with 40+ comprehensive tools for analyzing modules, functions, types, classes, imports, and architectural dependencies through real-time queries.

Z3 Theorem Prover with Functional Programming

Um servidor MCP para o provador de teoremas z3.

Confluence MCP Server

Enables AI assistants to interact with Atlassian Confluence Cloud by providing tools to create, update, search, and delete pages. It facilitates seamless content management within Confluence spaces using Markdown and the Confluence REST API.

Union MCP

Um servidor MCP que permite que os modelos Claude usem tarefas, fluxos de trabalho e aplicativos Union como ferramentas em conversas.

🚀 Re-Stack MCP Server – Bridging Stack Overflow & LLMs

O servidor Re-Stack MCP foi projetado para integrar o Stack Overflow em fluxos de trabalho de codificação baseados em LLM usando a API do Stack Exchange.

Trading MCP Server

Provides a comprehensive suite of 20 tools for cryptocurrency trading and technical analysis across 100+ exchanges like Binance and MEXC via CCXT. It enables users to execute orders, track positions, and scan for market opportunities through Claude Desktop using natural language.

PostgreSQL MCP Server

A Model Context Protocol server that provides read-only access to PostgreSQL databases, enabling LLMs to inspect database schemas and execute read-only queries.

mcp-fetch

A minimal MCP server that enables HTTP requests with any method, headers, and body types, supporting large responses through chunked transfers with disk-backed caching.

MCP Notes Connector

Enables integration with Evernote API to access and manage Evernote resources including notes, notebooks, and tags through the Model Context Protocol.

Azure AI Foundry MCP Server

Enables interaction with Azure AI Foundry services for model exploration, deployment, and performance evaluation. It provides tools for managing knowledge bases via AI Search Service, executing fine-tuning jobs, and orchestrating AI agents through natural language.

Moodle-MCP

Uma implementação de servidor do Protocolo de Contexto de Modelo (MCP) que fornece capacidades para interagir com o LMS Moodle.

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.

Pistachio MCP Server

A remote MCP server built with Node.js and TypeScript that enables tool calls and prompt templates via streamable HTTP transport. It includes example implementations for a calculator and localized greetings, featuring built-in CORS support for web-based clients.

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.

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.

File System MCP Server

Espelho de

Recash1 MCP Server

Enables access to the Recash1 API for searching and retrieving product information from a database, including filtering products and getting all products with their codes.

Granola MCP Server

Provides access to Granola notes, meeting transcripts, calendar events, and document panels through the Granola API, enabling search and retrieval of meeting-related content.

AWS SecurityHub MCP Server

This server implements the Multi-Agent Conversation Protocol for AWS SecurityHub, enabling interaction with AWS SecurityHub API through natural language commands.

MCP-RAG

An MCP-compatible system that handles large files (up to 200MB) with intelligent chunking and multi-format document support for advanced retrieval-augmented generation.

Logo-Analyze

An MCP server for intelligent logo extraction and processing, supporting automatic recognition and extraction of logo icons from website URLs, and providing image processing and vector conversion functions.

MCP Secure Installer

Automatically installs and containerizes MCP servers from GitHub repositories using MCP sampling to analyze repositories and create appropriate Docker images.

Jenkins MCP Server

Enables AI assistants to interact with Jenkins CI/CD systems for build management, job monitoring, console log analysis, and debugging through natural language commands.

MCP Server Template

A production-ready TypeScript template for building MCP servers with dual transport support (stdio/HTTP), OAuth 2.1 foundations, SQLite caching, observability, and security features including PII sanitization and rate limiting.