Discover Awesome MCP Servers

File Search MCP

Enables blazingly fast file and content searching in large codebases using ripgrep, with intelligent filtering, fuzzy finding, and directory tree visualization while respecting .gitignore and avoiding common bloat directories.

Nostr Tools for AI Agents

23 tools for AI agents working with Nostr Open source. No API key. No account. NIP-46 remote signing Publish notes, reply, react, repost Encrypted DMs (NIP-04 + NIP-44) Fetch events, profiles, social graph

No MCP

A satirical MCP server that responds to any query with 'no' and a creative reason, wrapping the NaaS (No as a Service) API for humorous interactions.

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.

PostgreSQL MCP Server

Enables LLMs to interact with PostgreSQL databases by providing tools to inspect table schemas and execute read-only SQL queries. It ensures data safety by running all operations within read-only transactions.

Cloudera Iceberg MCP Server (via Impala)

Servidor MCP do Cloudera Iceberg via Impala

MCP AI Hub

Provides unified access to 100+ AI models from OpenAI, Anthropic, Google, AWS Bedrock and other providers through a single MCP interface. Enables seamless switching between different AI models using LiteLM's unified API without requiring separate integrations for each provider.

Chess MCP

Play interactive chess games through conversation with move validation, Stockfish engine analysis, tactical puzzles, and a visual chess board widget in ChatGPT.

Metabase MCP Server

Enables AI assistants to interact with Metabase analytics platform, allowing them to query databases, manage dashboards and cards, execute SQL queries, and access analytics data through natural language.

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.

mcp-playwright

this is my first mcp

Maya MCP Server

Enables AI assistants to programmatically control Autodesk Maya via natural language using over 30 tools for 3D modeling, lighting, and animation. It connects through Maya's command port to facilitate procedural scene generation and complex production-ready workflows.

MCP GitHub Project Manager

A comprehensive server that provides AI-powered GitHub project management with task generation from requirements and complete traceability from business requirements to implementation.

KiCad MCP Server

Enables natural language search and exploration of KiCad component symbol libraries with fast full-text search across 20,000+ components including metadata like datasheets, footprints, and descriptions.

OpenRouter Search MCP Server

Servidor MCP para funcionalidade de pesquisa OpenRouter.

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.

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.

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.

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.

Edgee MCP Server

MCP Server for the Edgee API, enabling organization management, project operations, component management, and user administration through the Model Context Protocol.

MCP Domain Availability Server

Enables checking domain availability and pricing using the GoDaddy OTE API, supporting multiple TLD suffixes and both fast and full check modes.

ThinMCP

A local MCP gateway that compresses multiple upstream servers into two tools, search and execute, to minimize model context usage. It provides a compact, code-driven interface for discovering and calling tools across various upstream sources on demand.

Brightspace MCP Server

MCP server for Brightspace (D2L): check grades, due dates, announcements, rosters & more using Claude, ChatGPT, Cursor, or any MCP client. Built with TypeScript and the D2L REST API.

OmniSocKit MCP Server

Provides AI models with precise development knowledge and implementation rules for social marketing platforms like WeCom. It enables AI tools to generate accurate, production-ready code by injecting real-world API constraints and best practices without calling external APIs.

Fatture in Cloud MCP Server

Enables integration with Fatture in Cloud to manage Italian electronic invoices through natural conversation, including creating, sending, and tracking invoices and financial data.