Discover Awesome MCP Servers

Shanghai Disney MCP Server

Provides real-time ticket pricing and availability information for Shanghai Disney Resort through the Model Context Protocol. It enables LLMs to query sales status and specific costs for one-day and two-day passes.

HPE OneView MCP Server

Enables AI agents to manage HPE OneView infrastructure through the REST API, including server hardware operations, power control, profile management, and network/storage configuration.

MSSQL Database MCP Server

Enables AI assistants to securely interact with Microsoft SQL Server databases to query data, inspect schemas, and retrieve metadata with read-only operations by default and optional write capabilities.

mcp-utils

Utilidades de Python para trabajar con servidores MCP

Things MCP Server

Integrates with Things 3 task management app on macOS via URL schemes, enabling creation, updating, deletion of todos and projects, navigation, search, and JSON batch imports.

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

Un servidor basado en stdio que permite la interacción con la API de DataForSEO a través del Protocolo de Contexto de Modelo, permitiendo a los usuarios obtener datos SEO que incluyen resultados de búsqueda, datos de palabras clave, backlinks, análisis on-page y más.

funding-rates-mcp

funding-rates-mcp

mcp-servers

Servidores MCP para dar superpoderes a los LLM.

Trendy Post MCP

Enables users to take screenshots, extract text using OCR, and automatically generate trending Xiaohongshu-style social media posts. Combines image processing with AI-powered content generation to create engaging posts with hashtags and titles.

Google Indexing API MCP Server

An MCP server that enables interacting with Google's Indexing API, allowing agents to submit URLs to Google for indexing or removal from search results through natural language commands.

MCP Document Processor

An intelligent document processing system that automatically classifies, extracts information from, and routes business documents using the Model Context Protocol (MCP).

Model Context Protocol Server

A stateful gateway server for AI applications that solves the memory limitations of Large Language Models by maintaining separate conversation contexts for each user.

MCP Server Collection

The most accurate translation of "mcp服务聚合" depends on the context. Here are a few options: * **If referring to a general aggregation of MCP services:** * **Agregación de servicios MCP** * **If referring to a platform or system that aggregates MCP services:** * **Plataforma de agregación de servicios MCP** * **Sistema de agregación de servicios MCP** * **If referring to the process of aggregating MCP services:** * **Agregación de servicios MCP** (same as the first option, but emphasizes the action) Without more context, "Agregación de servicios MCP" is the safest and most general translation.

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

Okay, here's a basic outline and code example of a Model Context Protocol (MCP) server implementing an echo service using .NET Core. Since MCP is a somewhat abstract concept, I'll make some assumptions about how you want to use it. This example focuses on the core principles of receiving data, processing it (echoing), and sending it back. **Assumptions and Simplifications:** * **Transport:** I'll use TCP sockets as the underlying transport mechanism. MCP doesn't dictate the transport, but TCP is common and relatively straightforward. * **Message Framing:** I'll assume a simple line-based framing. Each message is terminated by a newline character (`\n`). This makes it easy to read and write messages. You might need to adapt this based on your specific MCP requirements. * **Error Handling:** Basic error handling is included, but a production system would need more robust error handling and logging. * **Model Context:** In this simple echo service, the "model context" is essentially the connection itself. More complex MCP implementations might involve associating data or state with each connection. * **.NET Core Version:** This example uses .NET 6 or later. **Code Example (C#):** ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace MCPEchoServer { class Program { static async Task Main(string[] args) { int port = 12345; // Choose a port IPAddress ipAddress = IPAddress.Any; // Listen on all interfaces TcpListener listener = new TcpListener(ipAddress, port); try { listener.Start(); Console.WriteLine($"MCP Echo Server listening on {ipAddress}:{port}"); while (true) { TcpClient client = await listener.AcceptTcpClientAsync(); Console.WriteLine($"Accepted connection from {client.Client.RemoteEndPoint}"); _ = Task.Run(() => HandleClientAsync(client)); // Handle each client in a separate task } } catch (Exception e) { Console.WriteLine($"Error: {e.Message}"); } finally { listener.Stop(); } } static async Task HandleClientAsync(TcpClient client) { try { NetworkStream stream = client.GetStream(); byte[] buffer = new byte[1024]; // Buffer for reading data StringBuilder messageBuilder = new StringBuilder(); while (true) { int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length); if (bytesRead == 0) { // Client disconnected Console.WriteLine($"Client {client.Client.RemoteEndPoint} disconnected."); break; } string receivedData = Encoding.UTF8.GetString(buffer, 0, bytesRead); messageBuilder.Append(receivedData); // Check for newline character (message delimiter) while (messageBuilder.ToString().Contains("\n")) { string message = messageBuilder.ToString().Substring(0, messageBuilder.ToString().IndexOf("\n")); messageBuilder.Remove(0, message.Length + 1); // Remove the message and the newline Console.WriteLine($"Received: {message}"); // Echo the message back to the client string echoMessage = $"{message}\n"; // Add newline back for the response byte[] echoBytes = Encoding.UTF8.GetBytes(echoMessage); await stream.WriteAsync(echoBytes, 0, echoBytes.Length); Console.WriteLine($"Sent: {echoMessage.Trim()}"); //Trim to remove the newline for console output } } } catch (Exception e) { Console.WriteLine($"Error handling client {client.Client.RemoteEndPoint}: {e.Message}"); } finally { client.Close(); } } } } ``` **Explanation:** 1. **`Main` Method:** * Sets up a `TcpListener` to listen for incoming connections on a specified port. * Enters a loop to accept incoming `TcpClient` connections. * For each accepted client, it starts a new `Task` to handle the client connection asynchronously using the `HandleClientAsync` method. This allows the server to handle multiple clients concurrently. 2. **`HandleClientAsync` Method:** * Gets the `NetworkStream` from the `TcpClient`. This stream is used for reading and writing data. * Creates a buffer to read data from the stream. * Enters a loop to continuously read data from the client. * **Reading Data:** `stream.ReadAsync` reads data from the stream into the buffer. * **Client Disconnection:** If `bytesRead` is 0, it means the client has disconnected. * **Message Assembly:** The received data is appended to a `StringBuilder` called `messageBuilder`. This is important because a single `ReadAsync` call might not receive the entire message at once. * **Message Delimiting (Framing):** The code checks if the `messageBuilder` contains a newline character (`\n`). This is how we determine the end of a message. * **Message Extraction:** If a newline is found, the message is extracted from the `messageBuilder`. * **Echoing:** The extracted message is echoed back to the client by writing it to the `NetworkStream`. A newline character is added back to the echoed message. * **Error Handling:** A `try-catch` block handles potential exceptions during the client handling process. * **Closing the Connection:** The `client.Close()` method closes the connection when the client disconnects or an error occurs. **How to Run:** 1. **Save:** Save the code as a `.cs` file (e.g., `MCPEchoServer.cs`). 2. **Create a Project:** Create a new .NET Core console application project. You can do this from the command line: ```bash dotnet new console -o MCPEchoServer cd MCPEchoServer ``` 3. **Replace Contents:** Replace the contents of `Program.cs` with the code above. 4. **Run:** Build and run the application from the command line: ```bash dotnet run ``` **Testing (using `netcat` or a similar tool):** 1. Open a terminal or command prompt. 2. Use `netcat` (or a similar tool like `telnet`) to connect to the server: ```bash nc localhost 12345 ``` 3. Type a message and press Enter. The server should echo the message back to you. For example: ``` Hello, MCP World! Hello, MCP World! ``` 4. Type another message and press Enter. 5. To disconnect, you can usually press `Ctrl+C` or `Ctrl+D`. **Important Considerations and Potential Improvements:** * **Message Framing:** The newline-based framing is simple but might not be suitable for all scenarios. Consider using a more robust framing mechanism, such as: * **Length-Prefix Framing:** Include the length of the message at the beginning of the message. * **Delimited Framing:** Use a special delimiter sequence that is unlikely to appear in the message itself. * **Error Handling:** Implement more comprehensive error handling, including logging errors to a file or database. * **Concurrency:** The current example uses `Task.Run` to handle clients concurrently. For high-performance servers, consider using asynchronous I/O (e.g., `Socket.ReceiveAsync` and `Socket.SendAsync`) directly to avoid blocking threads. The current implementation, while using `ReadAsync` and `WriteAsync`, still blocks a thread per client. True asynchronous I/O would use I/O completion ports and avoid thread blocking. * **Model Context:** Implement a more sophisticated model context management system. This might involve storing data associated with each connection in a dictionary or other data structure. Consider using a dependency injection container to manage the lifecycle of model context objects. * **Security:** If you're transmitting sensitive data, consider using TLS/SSL to encrypt the connection. * **Configuration:** Externalize configuration settings (e.g., port number, IP address) to a configuration file. * **Buffering:** Carefully manage buffer sizes to avoid buffer overflows or other issues. * **Cancellation:** Implement cancellation tokens to allow graceful shutdown of the server. * **MCP Specification:** Refer to the specific MCP specification you are implementing to ensure compliance. The term "Model Context Protocol" is somewhat generic, so understanding the specific requirements is crucial. This example provides a starting point for building an MCP echo server in .NET Core. Remember to adapt it to your specific needs and requirements. If you can provide more details about the specific MCP you're working with, I can provide more tailored guidance.

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.

MLB SportRadar MCP Server

Connects Claude to the SportRadar MLB API to access real-time baseball data including game schedules, live scores, player statistics, team standings, injury reports, and play-by-play information through natural language queries.

cook-tool

A recipe query tool that supports querying recipes and reporting dish names through the command line, suitable for cooking enthusiasts and developers.

MUXI Framework

Un marco de agentes de IA extensible.

World Bank Data360 MCP Server

Enables access to World Bank Data360 API with 1000+ economic and social indicators across 200+ countries and 60+ years of historical data, allowing searches, temporal coverage checks, and filtered data retrieval through natural language queries.