Discover Awesome MCP Servers

Theagora MCP Server

Enables AI agents to participate in a marketplace for buying, selling, and trading services with atomic escrow and cryptographic verification. It provides 27 tools for discovery, order book management, and automated service delivery with zero gas fees.

MCP WaliChat WhatsApp API Connector

Enables AI assistants to manage WhatsApp communications by sending messages, managing groups, and analyzing conversation patterns via the WaliChat API. It supports tasks like message scheduling, contact management, and automated business workflows through natural language commands.

MCP-Ambari-API

Manage and monitor Hadoop clusters via Apache Ambari API, enabling service operations, configuration changes, status checks, and request tracking through a unified MCP interface for simplified administration. * Guide: https://call518.medium.com/llm-based-ambari-control-via-mcp-8668a2b5ffb9

ETHID MCP Server

Provides comprehensive access to the Ethereum Follow Protocol (EFP) API, enabling social graph queries, follower/following management, ENS resolution, and profile data retrieval for Ethereum addresses and ENS names.

focMCP SDK

Fornece ferramentas e infraestrutura para construir servidores do Protocolo Minecraft totalmente on-chain, permitindo que desenvolvedores criem experiências de jogos descentralizadas usando a tecnologia blockchain.

MCP Server Collection

Agregação de serviços MCP

MCP Platform

A scalable execution platform that enables users to interact with HR, ERP, and DevOps domains through a chat interface powered by LlamaIndex and the Model Context Protocol. It provides a configuration-driven architecture for orchestrating LLM-suggested actions with authoritative tool execution and domain isolation.

Path of Exile 2 Build Optimizer MCP

Enables AI-powered Path of Exile 2 character optimization through natural language queries, providing intelligent build recommendations, gear upgrades, and passive tree optimization using the official PoE API and comprehensive game database.

Antigravity PDF MCP Server

Enables intelligent ingestion and querying of PDF, Markdown, and text files using hybrid search that combines keyword matching and semantic embeddings with citations.

MCP GraphQL Query Generator

Automatically discovers GraphQL APIs through introspection and generates table-formatted queries with pagination, filters, and sorting. Supports multiple authentication types and provides both CLI and REST API interfaces for seamless integration.

Accounting MCP

A personal financial management tool that enables AI assistants to record transactions, check balances, and provide monthly financial summaries via the Model Context Protocol. It allows users to manage their expenses and income through natural language interactions using standardized MCP tools and resources.

Solana MCP Wallet Agent API

Provides complete wallet management functionality for Solana blockchain, enabling users to create wallets, transfer SOL, and work with SPL tokens through a RESTful API.

Echo MCP Server

Um servidor de Protocolo de Contexto de Modelo (MCP) implementando um serviço de eco usando .NET Core.

Tempo Filler MCP Server

A Model Context Protocol server enabling AI assistants to interact with Tempo's time tracking system in JIRA for worklog retrieval, creation, and management.

Zerodha Trading MCP

A Model Context Protocol server that enables AI models to interact with the Zerodha trading platform, allowing users to execute trades, view portfolio holdings, and manage positions through a standardized interface.

mcp-pandoc-md2pptx

Enables conversion of Markdown content into PowerPoint presentations using pandoc. Supports custom templates for consistent branding and can process both direct markdown text and files.

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.

Pinecone Economic Books

Enables semantic search through a Pinecone vector database containing economic books and academic papers using natural language queries. Provides 10 specialized search tools with metadata filtering for precise discovery of economic theories, concepts, and research by author, subject, or book.

ChatGPT Apps SDK Next.js Starter

A minimal starter for building OpenAI Apps SDK compatible MCP servers that support native widget rendering within ChatGPT. It demonstrates how to integrate Next.js tools and resources into the ChatGPT interface using the Model Context Protocol.

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.

Zephyr MCP Server

A lightweight server that simplifies building and flashing Zephyr RTOS projects through a REST API, allowing remote control of the microcontroller programming workflow.

Better Telegram MCP

Production-grade MCP server for Telegram with dual-mode Bot API and MTProto. 6 composite tools covering messages, chats, media, contacts management with 3-tier token optimization.

Sugar CRM MCP Server by CData

This read-only MCP Server allows you to connect to Sugar CRM data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

PromptBoard

A shared whiteboard server that enables users to provide visual context to AI agents by pasting screenshots and drawing annotations. It allows agents to analyze images, sketches, and marked-up details directly through the Model Context Protocol.

ZeroChan MCP

MCP server for the Zerochan anime image board API. Browse the global feed, search by tags, and retrieve full entry metadata — directly from any MCP-compatible AI assistant.

FeedbackBasket MCP Server

Model Context Protocol server that enables AI assistants to query and analyze project feedback and bug reports from FeedbackBasket projects, with filtering by category, status, sentiment, and search capabilities.

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.

Spider MCP Server

Enables crawling and extracting clean content from documentation websites with optional LLM-powered analysis for intelligent summaries, code example extraction, and content classification.

MCP-Server-and-client-Implementation-on-Linux

Implementar um servidor e cliente MCP no Linux (em vez de usar o Claude Desktop)