Discover Awesome MCP Servers

DataForSEO MCP Server

Um servidor baseado em stdio que permite a interação com a API DataForSEO através do Protocolo de Contexto de Modelo, permitindo aos usuários buscar dados de SEO, incluindo resultados de pesquisa, dados de palavras-chave, backlinks, análise on-page e muito mais.

Microsoft Excel MCP Server by CData

Microsoft Excel MCP Server by CData

MCP Server Demo

A Python-based Model Context Protocol server with Streamlit chat interface that allows users to manage a PostgreSQL database through both web UI and MCP tools, powered by Ollama for local LLM integration.

Horse Racing News

Retrieves and displays the latest horse racing news stories from Thoroughbred Daily News RSS feed, including titles, content, and links.

GitLab MCP Server

Connects AI assistants to GitLab, enabling natural language queries to view merge requests, review discussions, test reports, pipeline status, and respond to comments directly from chat.

SkillPort

A management toolkit for AI agent skills that provides an MCP server for search-first skill discovery and on-demand loading. It enables users to validate, organize, and serve standardized skills to MCP-compatible clients like Cursor and GitHub Copilot.

College Football MCP

Provides real-time college football game scores, betting odds, player statistics, and team performance data through integration with The Odds API and CollegeFootballData API.

macuse

Connect AI with any macOS app. Deep integration with native apps like Calendar, Mail, Notes, plus UI control for all applications. Works with Claude, Cursor, Raycast, and any MCP-compatible AI.

OpenRouter Search MCP Server

Servidor MCP para funcionalidade de pesquisa OpenRouter.

mcp-server-for-local

Olá a todos! Sou o MCP, um serviço rico em funcionalidades, projetado para quebrar as barreiras entre dispositivos e serviços, proporcionando uma experiência conveniente para os usuários. A ferramenta de clima se conecta com plataformas meteorológicas para fornecer rapidamente aos usuários informações meteorológicas globais em tempo real, ajudando a planejar viagens. A ferramenta de controle do navegador simula operações manuais, pesquisando e navegando automaticamente em páginas da web, economizando muito tempo. A ferramenta de câmera chama a câmera local para tirar fotos e gravar vídeos, implementando o reconhecimento facial para garantir a segurança doméstica. Para permitir a colaboração entre as ferramentas, construí uma estrutura estável, e os desenvolvedores podem expandir com base nos serviços existentes.

Furikake

A local CLI & API for MCP management that allows users to download, install, manage, and interact with MCPs from GitHub, featuring process state management, port allocation, and HTTP API routes.

Knowledge Graph Memory Server

Provides persistent memory for Claude by implementing a local knowledge graph to store and retrieve entities, relations, and observations. This enables long-term information retention and personalization across different chat sessions.

Android Debug Bridge MCP

Enables control of Android devices via ADB for automation and testing. Supports app management, screen capture, UI analysis, and input simulation through natural language commands.

AiryLark MCP Translation Server

Um servidor ModelContextProtocol que oferece serviços de tradução de alta qualidade com um fluxo de trabalho de tradução em três etapas (análise, tradução segmentada, revisão de texto completo) que suporta vários idiomas e se integra com modelos compatíveis com Claude e OpenAI.

fund-mcp

A fund knowledge base server based on Model Context Protocol (MCP), providing query and retrieval functions of fund-related knowledge, and supporting multiple deployment modes and protocols.

Remote MCP Server with WorkOS AuthKit

An example MCP server that allows remote clients to connect and authenticate using WorkOS AuthKit, providing organization-centric authentication with permission-based access control for tools.

Nara Market FastMCP Server

Provides access to South Korean government procurement (G2B) and Nara Market shopping mall data, enabling users to search bid announcements, procurement statistics, product catalogs, and contract information through 15 specialized tools.

MCP client-server

Okay, I can help you understand the concepts and provide a basic outline for creating a simple client-server application using the Minecraft Communication Protocol (MCP). However, keep in mind that MCP is a complex protocol, and a full implementation is a significant undertaking. This will be a simplified example to illustrate the core ideas. **Important Considerations:** * **MCP is Obsolete:** MCP is largely obsolete. Modern Minecraft uses different protocols. This example is for educational purposes only, to understand the general principles of client-server communication. If you want to interact with modern Minecraft servers, you'll need to use the current protocol (which is more complex and involves encryption). * **Complexity:** A real MCP implementation involves handling many different packets, data types, and states. This example will focus on a very basic handshake and a simple message exchange. * **Security:** This example will *not* include any security measures. Real-world applications *must* use encryption and authentication. **Conceptual Outline** Here's a breakdown of the steps involved and a basic code outline (in Python, as it's relatively easy to read and prototype with): **1. Understanding the Basics of Client-Server Communication** * **Server:** The server listens for incoming connections on a specific port. When a client connects, the server accepts the connection and creates a new socket to communicate with that client. * **Client:** The client initiates a connection to the server's IP address and port. Once the connection is established, the client can send data to the server and receive data from the server. * **Sockets:** Sockets are the endpoints of a two-way communication link between two programs running on the network. They provide a low-level interface for sending and receiving data. * **Packets:** Data is typically exchanged in the form of packets. Each packet has a specific format, including an ID that identifies the type of packet and the data it contains. **2. Simplified MCP Packet Structure (Example)** For this example, let's define a very simple packet structure: * **Packet ID (1 byte):** Identifies the type of packet. * **Data Length (1 byte):** Indicates the length of the data payload. * **Data (variable length):** The actual data being transmitted. **3. Python Code Outline** ```python import socket import struct # --- Server --- def server(): host = '127.0.0.1' # Localhost port = 25565 # Example port (choose an unused one) server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((host, port)) server_socket.listen(1) # Listen for one connection print(f"Server listening on {host}:{port}") client_socket, addr = server_socket.accept() print(f"Client connected from {addr}") try: while True: # Receive packet packet_id_bytes = client_socket.recv(1) if not packet_id_bytes: break # Connection closed packet_id = struct.unpack("!B", packet_id_bytes)[0] # Unpack as unsigned byte data_length_bytes = client_socket.recv(1) data_length = struct.unpack("!B", data_length_bytes)[0] data = client_socket.recv(data_length) print(f"Received packet ID: {packet_id}, Data: {data.decode()}") # Example: Echo back the message response_data = f"Server received: {data.decode()}".encode() response_packet = struct.pack("!BB", 2, len(response_data)) + response_data # Packet ID 2 for response client_socket.sendall(response_packet) except ConnectionResetError: print("Client disconnected unexpectedly.") finally: client_socket.close() server_socket.close() print("Server closed.") # --- Client --- def client(): host = '127.0.0.1' port = 25565 client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client_socket.connect((host, port)) print(f"Connected to server on {host}:{port}") # Send a message message = "Hello from the client!" message_bytes = message.encode() packet = struct.pack("!BB", 1, len(message_bytes)) + message_bytes # Packet ID 1 for message client_socket.sendall(packet) # Receive response packet_id_bytes = client_socket.recv(1) packet_id = struct.unpack("!B", packet_id_bytes)[0] data_length_bytes = client_socket.recv(1) data_length = struct.unpack("!B", data_length_bytes)[0] data = client_socket.recv(data_length) print(f"Received response: {data.decode()}") except ConnectionRefusedError: print("Connection refused. Make sure the server is running.") finally: client_socket.close() print("Client closed.") if __name__ == "__main__": import threading server_thread = threading.Thread(target=server) server_thread.daemon = True # Exit when the main thread exits server_thread.start() # Give the server a moment to start import time time.sleep(0.1) client() ``` **Explanation:** * **`socket` module:** Used for creating and managing sockets. * **`struct` module:** Used for packing and unpacking data into binary formats (e.g., converting integers to bytes). The `!` in `struct.pack("!B", ...)` specifies network byte order (big-endian), which is important for network communication. * **`server()` function:** * Creates a socket, binds it to an address and port, and listens for connections. * Accepts a client connection. * Receives data from the client, unpacks the packet ID and data length, and reads the data. * Prints the received data. * Sends a response back to the client. * Closes the connection. * **`client()` function:** * Creates a socket and connects to the server. * Sends a message to the server, packing the packet ID and data length. * Receives the response from the server, unpacks the packet ID and data length, and reads the data. * Prints the received response. * Closes the connection. * **`if __name__ == "__main__":` block:** * Starts the server in a separate thread so that the client can connect to it. * Waits briefly for the server to start. * Runs the client. **How to Run:** 1. Save the code as a Python file (e.g., `mcp_example.py`). 2. Run the file from your terminal: `python mcp_example.py` You should see output from both the server and the client, indicating that the connection was established, the message was sent, and the response was received. **Important Notes and Next Steps:** * **Error Handling:** The code includes basic `try...except` blocks for connection errors, but you'll need to add more robust error handling for production code. * **Packet Definitions:** You'll need to define a more complete set of packet IDs and their corresponding data structures. Refer to the MCP documentation (if you can find it) or existing MCP implementations for guidance. * **State Management:** The server and client need to maintain state to track the connection status and handle different phases of the protocol (e.g., handshake, login, game data exchange). * **Data Serialization:** You'll need to serialize and deserialize data into binary formats for transmission over the network. The `struct` module is useful for simple data types, but you might need more advanced serialization techniques for complex objects. * **Threading/Asynchronous Programming:** For a real-world server, you'll need to use threading or asynchronous programming to handle multiple client connections concurrently. * **Security:** Implement encryption (e.g., TLS/SSL) and authentication to protect the communication from eavesdropping and tampering. **Disclaimer:** This is a very basic example and is not a complete or secure MCP implementation. It is intended for educational purposes only. Do not use this code in a production environment without thoroughly understanding the security implications and implementing appropriate security measures. As mentioned before, MCP is outdated, and you should consider using the current Minecraft protocol if you want to interact with modern Minecraft servers. That protocol is significantly more complex.

MedixHub Model Context Protocol (MCP) Server

MedixHub - Um servidor de Protocolo de Contexto de Modelo (MCP) com uma coleção de APIs e ferramentas médicas e de saúde.

LinkedIn MCP Server

Enables Claude to access and analyze LinkedIn profile data through the Model Context Protocol, allowing users to query their LinkedIn information directly within Claude Desktop.

YNAB MCP Server

Enables interaction with You Need A Budget (YNAB) through their API, allowing users to manage budgets, accounts, categories, transactions, payees, and scheduled transactions through natural language.

Modular MCP Server & Client

A modular and extensible tool server built on FastMCP that supports multiple tools organized across files and communicates via MCP protocol.

MalwareAnalyzerMCP

A specialized MCP server for Claude Desktop that allows executing terminal commands for malware analysis with support for common analysis tools like file, strings, hexdump, objdump, and xxd.

MCP Scheduler

A robust task scheduler server built with Model Context Protocol for scheduling and managing various types of automated tasks including shell commands, API calls, AI tasks, and reminders.

OPNsense MCP Server

OPNsense MCP Server

MCP Bitpanda Server

Enables programmatic access to Bitpanda cryptocurrency exchange features including trades, wallets, and transactions via the Model Context Protocol.

Azure DevOps MCP Server

Enables AI assistants to interact with Azure DevOps repositories and pull requests, including listing PRs, fetching diffs, adding comments, and performing automated code reviews.

Postman MCP Generator

A Model Context Provider (MCP) server that exposes your automated API tools to MCP-compatible clients like Claude Desktop, allowing you to interact with APIs using natural language.