发现优秀的 MCP 服务器

Uruguay Invoice MCP

Enables AI agents to submit Uruguay DGI e-Factura (CFE) documents to the DGI webservice as a stateless forwarder; signing stays merchant-side, and it supports test, homologation, and production endpoints.

Tidewave Phoenix

Better agentic Elixir Phoenix development, runtime-level tools for your agent to talk to your running app.

Banrisul MCP

Connects Banrisul bank accounts to AI assistants via Open Finance Brazil, enabling read-only queries on balances, statements, credit cards, and investments.

Market Inspector

Multi-asset market intelligence MCP server that monitors cryptocurrency movements, equity data, and ECB foreign-exchange reference rates to produce structured market briefs using Gemini.

ask-starknet

A unified MCP server for Starknet blockchain, routing requests to specialized servers for token management, DeFi operations, wallet management, and smart contract development.

aptible-mcp

Enables interaction with the Aptible API for managing Aptible resources such as accounts, apps, and databases through natural language.

mcp-dart-kr

Enables AI agents to access Korea's DART financial data system for retrieving and analyzing corporate disclosures and financial information through natural language queries.

gdevelop-mcp-server

Provides a local control plane for GDevelop game projects, enabling Codex to open projects, build previews, and serve them over HTTP for debugging.

Caixa Tem MCP

Connects your Caixa Tem account to AI assistants via Open Finance Brasil, enabling read-only queries of balances, statements, credit card bills, and investments in natural language.

React Patterns MCP Server

Provides React design and rendering patterns from patterns.dev as MCP tools and resources for Claude Code.

@avidian/mcp-jira

MCP server for Jira Cloud — gives AI agents full context and control over Jira issues, projects, sprints, and workflows.

visual-browser-agent

Enables AI coding agents to see and interact with real Chrome pages through structured DOM inspection, targeted screenshots, recordings, and human-in-the-loop approvals across major coding-agent hosts.

Skillselion MCP server

Enables AI agents to search a curated directory of Claude Code agent skills, MCP servers, and plugin marketplaces ranked by community signal.

MUXI Framework

一个可扩展的 AI 代理框架 (Yī gè kě kuòzhǎn de AI dàilǐ kuàngjià)

Echo MCP Server

Okay, here's a basic outline and code example for a Model Context Protocol (MCP) server implementing an echo service using .NET Core. Since MCP isn't a widely standardized protocol, I'll make some assumptions about its structure. I'll assume it's a text-based protocol where messages are delimited by a newline character (`\n`). You'll likely need to adapt this to your specific MCP definition. **Conceptual Overview** 1. **Server Setup:** Create a TCP listener to accept incoming connections. 2. **Connection Handling:** For each connection, create a new thread or task to handle it concurrently. 3. **Receive Data:** Read data from the client socket. 4. **Parse MCP Message:** Parse the received data according to your MCP specification. In this simple echo example, we'll just treat the entire line as the message. 5. **Echo Response:** Send the received message back to the client. 6. **Close Connection:** Close the socket when the client disconnects or an error occurs. **Code Example (.NET Core)** ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace McpEchoServer { class Program { private static int _port = 12345; // Change this to your desired port private static IPAddress _ipAddress = IPAddress.Any; // Listen on all interfaces static async Task Main(string[] args) { TcpListener listener = null; try { listener = new TcpListener(_ipAddress, _port); listener.Start(); Console.WriteLine($"MCP Echo Server started on {_ipAddress}:{_port}"); while (true) { TcpClient client = await listener.AcceptTcpClientAsync(); Console.WriteLine($"Accepted new client: {client.Client.RemoteEndPoint}"); _ = HandleClientAsync(client); // Fire and forget - handle client in a separate task } } catch (Exception e) { Console.WriteLine($"An error occurred: {e}"); } finally { listener?.Stop(); } Console.WriteLine("Server stopped."); } static async Task HandleClientAsync(TcpClient client) { try { using (NetworkStream stream = client.GetStream()) using (var reader = new System.IO.StreamReader(stream, Encoding.UTF8)) using (var writer = new System.IO.StreamWriter(stream, Encoding.UTF8) { AutoFlush = true }) // AutoFlush ensures data is sent immediately { string message; while ((message = await reader.ReadLineAsync()) != null) { Console.WriteLine($"Received: {message} from {client.Client.RemoteEndPoint}"); // Echo the message back await writer.WriteLineAsync(message); Console.WriteLine($"Sent: {message} to {client.Client.RemoteEndPoint}"); } Console.WriteLine($"Client disconnected: {client.Client.RemoteEndPoint}"); } } catch (Exception e) { Console.WriteLine($"Error handling client {client.Client.RemoteEndPoint}: {e}"); } finally { client.Close(); } } } } ``` **How to Use:** 1. **Create a new .NET Core Console Application:** In Visual Studio or using the .NET CLI (`dotnet new console`). 2. **Replace the `Program.cs` content:** Paste the code above into your `Program.cs` file. 3. **Adjust the Port:** Change the `_port` variable to the port you want the server to listen on. 4. **Run the Server:** Build and run the application. You should see the "MCP Echo Server started" message. **Client Example (Simple Telnet or Netcat)** You can test this server using a simple Telnet client or Netcat. * **Telnet:** Open a command prompt or terminal and type: `telnet localhost 12345` (replace `12345` with your port). Then type some text and press Enter. You should see the same text echoed back. * **Netcat (nc):** `nc localhost 12345`. Type some text and press Enter. **Explanation:** * **`TcpListener`:** Listens for incoming TCP connections on the specified IP address and port. * **`AcceptTcpClientAsync()`:** Asynchronously accepts a pending connection request. This returns a `TcpClient` object representing the connected client. * **`HandleClientAsync()`:** This `async` method handles the communication with a single client. It's launched as a separate task using `_ = HandleClientAsync(client);` so that the server can handle multiple clients concurrently. * **`NetworkStream`:** Provides access to the underlying network stream of the `TcpClient`. * **`StreamReader` and `StreamWriter`:** Used for reading and writing text data to the stream. `StreamReader.ReadLineAsync()` reads a line of text from the stream asynchronously. `StreamWriter.WriteLineAsync()` writes a line of text to the stream asynchronously. `AutoFlush = true` ensures that data is sent immediately. * **`Encoding.UTF8`:** Specifies the character encoding to use for reading and writing text. * **`client.Close()`:** Closes the connection to the client. * **Error Handling:** The `try...catch...finally` blocks provide basic error handling. **Important Considerations and Improvements:** * **MCP Specification:** This example assumes a very simple MCP protocol. You'll need to adapt the parsing and message handling logic to match your actual MCP specification. This might involve parsing headers, message types, data lengths, etc. * **Error Handling:** The error handling is basic. You should add more robust error handling to catch exceptions and handle them gracefully. Consider logging errors. * **Threading/Task Management:** The `_ = HandleClientAsync(client);` approach is a simple way to launch a task, but for a production server, you might want to use a more sophisticated task management strategy (e.g., using a `TaskScheduler` or a thread pool) to control the number of concurrent tasks. * **Security:** This example is not secure. If you're transmitting sensitive data, you should use TLS/SSL to encrypt the connection. * **Message Framing:** If your MCP protocol doesn't use newline characters as delimiters, you'll need to implement a different message framing mechanism (e.g., using a fixed-length header that specifies the message length). * **Asynchronous Operations:** The use of `async` and `await` makes the server more scalable by allowing it to handle multiple clients concurrently without blocking threads. * **Logging:** Implement a logging mechanism to record server events, errors, and client interactions. This is crucial for debugging and monitoring. * **Configuration:** Externalize configuration settings (e.g., port number, IP address) into a configuration file. **Chinese Translation of Key Concepts:** * **Model Context Protocol (MCP):** 模型上下文协议 (Móxíng shàngxiàwén xiéyì) * **Echo Service:** 回显服务 (Huíxiǎn fúwù) * **.NET Core:** .NET Core * **TCP Listener:** TCP 监听器 (TCP jiāntīng qì) * **Socket:** 套接字 (Tàojiēzì) * **Network Stream:** 网络流 (Wǎngluò liú) * **Asynchronous:** 异步 (Yìbù) * **Thread:** 线程 (Xiànchéng) * **Task:** 任务 (Rènwù) * **Client:** 客户端 (Kèhùduān) * **Server:** 服务器 (Fúwùqì) * **Port:** 端口 (Duānkǒu) * **IP Address:** IP 地址 (IP dìzhǐ) * **Encoding:** 编码 (Biānmǎ) * **Message:** 消息 (Xiāoxī) * **Delimiter:** 分隔符 (Fēngéfú) This comprehensive example should give you a good starting point for building your MCP echo server in .NET Core. Remember to adapt the code to your specific MCP protocol requirements. Good luck!

expense-tracker-postgres-mcp

Persistent expense tracker backed by Neon Postgres with SQL tools for adding, editing, deleting, and analyzing expenses via natural language.

DataForSEO MCP Server

一个基于标准输入输出流（stdio）的服务器，它通过模型上下文协议（Model Context Protocol）实现与 DataForSEO API 的交互，允许用户获取 SEO 数据，包括搜索结果、关键词数据、反向链接、页面优化分析等。

mcp-singstat-sg

Provides access to Singapore's official statistics from the Department of Statistics (SingStat) via MCP tools, allowing users to query data using natural language or direct tool calls.

uniprot-mcp

MCP server that exposes the UniProt REST API to LLM clients, enabling search and retrieval of protein data via tools like search_uniprotkb, get_entry, and map_ids.

ContextBridge

Local-first code retrieval for AI agents — cuts codebase context from thousands of tokens to a few hundred, with zero hallucinated file paths.

API MCP Server

A Model Context Protocol server that provides basic tools for arithmetic operations (addition) and dynamic greeting resources, demonstrating MCP integration patterns for other projects and clients.

Xeams MCP Server

Enables email address validation and outbound email status checking for the Xeams on-premise email server via MCP tools.

browser-mcp

Provides real browser automation with stealth capabilities for screenshots, page fetching, web search, and data extraction using system browsers.

Obsidian Agent Bridge

A secure MCP server that connects ChatGPT/Codex to a local Obsidian Vault, enabling controlled knowledge retrieval, note maintenance, and daily ingest while enforcing path policies, concurrency checks, and audit.

websupport-mcp

An MCP server wrapping the Websupport REST API to expose DNS, FTP, hosting, databases, mailboxes, VPS, and invoice operations as MCP tools with HMAC-SHA1 authentication.

certified-mcp

An MCP server that provides tools for certificate verification, equivalence proving, and pre-registration sealing, enabling AI agents to re-derive verdicts from artifacts rather than trust assertions.

OPNsense MCP Server

OPNsense MCP Server

Agent Analytics MCP Server

Tracks and analyzes AI agent tool calls with event logging, dashboard, per-tool and per-agent analytics, and error monitoring.

magic-api-mcp-server

Enables AI assistants to interact with Magic-API development environment, supporting script syntax query, API management, debugging, and knowledge search for efficient development.

Ableton MCP

Enables full control of Ableton Live from AI assistants, including transport, tracks, clips, devices, and scene management through 143 tools.