Discover Awesome MCP Servers
Extend your agent with 84,517 capabilities via MCP servers.
- All84,517
- Developer Tools3,867
- Search1,714
- Research & Data1,557
- AI Integration Systems229
- Cloud Platforms219
- Data & App Analysis181
- Database Interaction177
- Remote Shell Execution165
- Browser Automation147
- Databases145
- Communication137
- AI Content Generation127
- OS Automation120
- Programming Docs Access109
- Content Fetching108
- Note Taking97
- File Systems96
- Version Control93
- Finance91
- Knowledge & Memory90
- Monitoring79
- Security71
- Image & Video Processing69
- Digital Note Management66
- AI Memory Systems62
- Advanced AI Reasoning59
- Git Management Tools58
- Cloud Storage51
- Entertainment & Media43
- Virtualization42
- Location Services35
- Web Automation & Stealth32
- Media Content Processing32
- Calendar Management26
- Ecommerce & Retail18
- Speech Processing18
- Customer Data Platforms16
- Travel & Transportation14
- Education & Learning Tools13
- Home Automation & IoT13
- Web Search Integration12
- Health & Wellness10
- Customer Support10
- Marketing9
- Games & Gamification8
- Google Cloud Integrations7
- Art & Culture4
- Language Translation3
- Legal & Compliance2
MikroMCP
Production-grade MCP server for MikroTik RouterOS with secure AI-native network automation.
AgentHotspot MCP Server
Enables AI agents to search and discover over 6,000 curated MCP connectors from the AgentHotspot marketplace using natural language. It provides a lightweight tool for builders to find and integrate diverse OSS connectors into their agentic workflows.
cobble-mcp
Enables AI assistants to connect to Minecraft servers as a bot, allowing cooperative building, movement, combat, and chat in the same world.
MCP Booking
Enables AI agents to search hotels, check availability, manage reservations, and book rooms on Booking.com via browser automation.
CatoBot autoexperiment MCP Server
A domain-agnostic MCP server for autonomous experimentation, generalizing Karpathy's autoresearch pattern into a reusable server that any AI agent can drive, pointed at any domain defined by a JSON configuration.
sketchbord-mcp
Enables AI agents to visualize tasks on a collaborative Sketchbord whiteboard by composing content into diagrams, editing them incrementally, and reading back the board including user-drawn additions.
GeminiCLI MCP Antigravity Server
A local MCP server for code analysis and investigation, providing tools like code search, file read, and symbol hint via SSE for integration with Gemini CLI and Antigravity.
RishiAI MCP Server
A Vedic astrology MCP server providing tools for natal charts, transits, compatibility, muhurtha, and career analysis using the DashaFlow engine.
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 is a somewhat abstract concept, I'll make some assumptions about how you want to structure the communication. This example focuses on a simple text-based echo service. **Assumptions:** * **Communication Channel:** I'll use TCP sockets for the communication channel. This is a common and relatively straightforward approach. You could adapt this to use other channels (e.g., named pipes, message queues) if needed. * **Message Format:** I'll assume a simple text-based message format. The server receives a text string and sends the same string back. You can easily extend this to use JSON, Protocol Buffers, or other serialization formats if you need more complex data structures. * **Error Handling:** Basic error handling is included, but you'll likely want to add more robust error handling in a production environment. * **MCP Abstraction:** This example doesn't implement a full-blown MCP framework. It focuses on the core concept of receiving a request and sending a response within a defined context (the socket connection). A true MCP implementation might involve more sophisticated context management, request routing, and service discovery. **Code Example (.NET Core Console Application):** ```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 number IPAddress ipAddress = IPAddress.Any; // Listen on all available network interfaces TcpListener listener = new TcpListener(ipAddress, port); try { listener.Start(); Console.WriteLine($"Server started, listening on port {port}"); while (true) { TcpClient client = await listener.AcceptTcpClientAsync(); Console.WriteLine("Client connected."); _ = HandleClientAsync(client); // Fire and forget } } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); } finally { listener.Stop(); } } static async Task HandleClientAsync(TcpClient client) { try { NetworkStream stream = client.GetStream(); byte[] buffer = new byte[1024]; int bytesRead; while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0) { string receivedMessage = Encoding.UTF8.GetString(buffer, 0, bytesRead); Console.WriteLine($"Received: {receivedMessage}"); // Echo the message back byte[] responseBytes = Encoding.UTF8.GetBytes(receivedMessage); await stream.WriteAsync(responseBytes, 0, responseBytes.Length); Console.WriteLine($"Sent: {receivedMessage}"); } } catch (Exception ex) { Console.WriteLine($"Error handling client: {ex.Message}"); } finally { client.Close(); Console.WriteLine("Client disconnected."); } } } } ``` **Explanation:** 1. **`Main` Method:** * Creates a `TcpListener` to listen for incoming connections on a specified port. * Starts the listener. * Enters an infinite loop to accept incoming client connections using `AcceptTcpClientAsync`. * For each accepted client, it calls `HandleClientAsync` to handle the communication in a separate task (using `_ = ...` to "fire and forget"). This allows the server to handle multiple clients concurrently. * Includes a `try-catch-finally` block for basic error handling and to ensure the listener is stopped when the application exits. 2. **`HandleClientAsync` Method:** * Gets the `NetworkStream` from the `TcpClient`. This stream is used for reading and writing data. * Reads data from the stream in a loop using `stream.ReadAsync`. * Converts the received bytes to a string using `Encoding.UTF8.GetString`. * Prints the received message to the console. * Creates a byte array from the received message (to echo it back). * Writes the response bytes back to the stream using `stream.WriteAsync`. * Prints the sent message to the console. * Includes a `try-catch-finally` block for error handling and to ensure the client connection is closed when the communication is finished or an error occurs. **How to Run:** 1. **Create a .NET Core Console Application:** Use the .NET CLI or Visual Studio to create a new console application project. 2. **Replace the `Program.cs` content:** Copy and paste the code above into your `Program.cs` file. 3. **Run the application:** Build and run the application from the command line (`dotnet run`) or from Visual Studio. **Testing (using `netcat` or a simple client):** You can test the server using `netcat` (if you have it installed) or by creating a simple client application. **Using `netcat`:** 1. Open a terminal or command prompt. 2. Type: `nc localhost 12345` (replace `12345` with the port you used). 3. Type a message and press Enter. You should see the same message echoed back to you. 4. Press Ctrl+C to exit `netcat`. **Simple Client Example (C#):** ```csharp using System; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace MCPEchoClient { class Program { static async Task Main(string[] args) { string serverAddress = "localhost"; int port = 12345; try { TcpClient client = new TcpClient(); await client.ConnectAsync(serverAddress, port); NetworkStream stream = client.GetStream(); Console.WriteLine("Connected to server. Enter messages to send (or 'exit' to quit):"); string message; while (true) { Console.Write("> "); message = Console.ReadLine(); if (message.ToLower() == "exit") { break; } byte[] messageBytes = Encoding.UTF8.GetBytes(message); await stream.WriteAsync(messageBytes, 0, messageBytes.Length); byte[] buffer = new byte[1024]; int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length); string receivedMessage = Encoding.UTF8.GetString(buffer, 0, bytesRead); Console.WriteLine($"Received: {receivedMessage}"); } client.Close(); Console.WriteLine("Disconnected from server."); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); } } } } ``` **Key Improvements and Considerations:** * **Asynchronous Operations:** The code uses `async` and `await` for non-blocking I/O operations. This is crucial for scalability, as it prevents the server from blocking while waiting for data to be read or written. * **Multi-threading:** The `HandleClientAsync` method is called in a separate task for each client. This allows the server to handle multiple clients concurrently. * **Error Handling:** Basic error handling is included, but you should add more robust error handling in a production environment. Consider logging errors, handling specific exceptions, and implementing retry mechanisms. * **Message Framing:** The current example assumes that each message is sent as a single chunk of data. In a real-world application, you might need to implement message framing to handle messages that are larger than the buffer size or that are split across multiple packets. Common framing techniques include: * **Length-prefixing:** Include the length of the message at the beginning of the message. * **Delimiter-based:** Use a special character (e.g., newline) to mark the end of a message. * **Serialization:** For more complex data structures, use a serialization format like JSON or Protocol Buffers. This will allow you to easily convert objects to and from byte streams. * **Dependency Injection:** For larger applications, consider using dependency injection to manage dependencies and make the code more testable. * **Configuration:** Externalize configuration settings (e.g., port number, IP address) to a configuration file. * **Logging:** Implement a logging framework (e.g., Serilog, NLog) to record events and errors. * **Security:** If you're handling sensitive data, consider using encryption and authentication to protect the communication channel. TLS/SSL is a common choice. * **MCP Framework (Advanced):** For a more complete MCP implementation, you would need to define: * **Context Management:** How to manage the context associated with each request (e.g., user identity, session information). * **Request Routing:** How to route requests to the appropriate service or handler. * **Service Discovery:** How clients can discover available services. * **Interceptors/Middleware:** Mechanisms for adding cross-cutting concerns (e.g., logging, authentication, authorization) to the request processing pipeline. **Japanese Translation of Key Concepts:** * **Model Context Protocol (MCP):** モデルコンテキストプロトコル (Moderu Kontekusuto Purotokoru) * **Echo Service:** エコーサービス (Ekō Sābisu) * **Server:** サーバー (Sābā) * **Client:** クライアント (Kurainto) * **TCP Socket:** TCPソケット (TCP Soketto) * **Message:** メッセージ (Messēji) * **Request:** リクエスト (Rikuesuto) * **Response:** レスポンス (Resuponsu) * **Port:** ポート (Pōto) * **IP Address:** IPアドレス (IP Adoresu) * **Asynchronous:** 非同期 (Hisynki) * **Multi-threading:** マルチスレッド (Maruchi Sureddo) * **Serialization:** シリアライズ (Shiriaraizu) / シリアル化 (Shiriaruka) * **Dependency Injection:** 依存性注入 (Izonsei Chūnyū) * **Configuration:** 構成 (Kōsei) / 設定 (Settei) * **Logging:** ロギング (Rogingu) / ログ記録 (Rogu Kiroku) * **Security:** セキュリティ (Sekyuriti) / 安全性 (Anzensei) * **Context Management:** コンテキスト管理 (Kontekusuto Kanri) * **Request Routing:** リクエストルーティング (Rikuesuto Rūtingu) * **Service Discovery:** サービスディスカバリー (Sābisu Disukabarī) This example provides a starting point for building an MCP-like echo service in .NET Core. Remember to adapt it to your specific requirements and consider the key improvements and considerations mentioned above. Good luck!
Ableton MCP
Enables full control of Ableton Live from AI assistants, including transport, tracks, clips, devices, and scene management through 143 tools.
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.
Banrisul MCP
Connects Banrisul bank accounts to AI assistants via Open Finance Brazil, enabling read-only queries on balances, statements, credit cards, and investments.
Spira MCP
Read-only MCP for retrieving daily Spira incident digests and filter options using the Inflectra Spira API.
Narad GitHub Agent
Enables AI-powered GitHub interactions including repository analysis, code search, PR reviews, and more through the MCP protocol.
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.
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.
Agent Analytics MCP Server
Tracks and analyzes AI agent tool calls with event logging, dashboard, per-tool and per-agent analytics, and error monitoring.
Edgee MCP Server
MCP Server for the Edgee API, enabling organization management, project operations, component management, and user administration through the Model Context Protocol.
aptible-mcp
Enables interaction with the Aptible API for managing Aptible resources such as accounts, apps, and databases through natural language.
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.
ContextBridge
Local-first code retrieval for AI agents — cuts codebase context from thousands of tokens to a few hundred, with zero hallucinated file paths.
Featurebase MCP Server
Enables interaction with Featurebase API to manage feature requests, feedback posts, comments, and upvotes. Supports creating, updating, and organizing customer feedback through natural language commands.
Metaso MCP Server
Provides AI-powered web search, full-page content extraction, and search-enhanced Q\&A capabilities via the Metaso AI search engine. It enables large language models to access diverse information across web, academic, and multimedia sources with structured Markdown or JSON output.
Gallica/BnF MCP Server
Enables access to the Gallica digital library of the Bibliothèque nationale de France (BnF) with search capabilities across titles, authors, subjects, and dates, plus retrieval of document metadata, IIIF images, and OCR text content.
@avidian/mcp-jira
MCP server for Jira Cloud — gives AI agents full context and control over Jira issues, projects, sprints, and workflows.
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.
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.
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.
Meta Ads MCP Server
Provides read-only access to Meta Ads API, enabling campaign management, creative analysis, targeting research, and performance analytics via 39 tools.
Tidewave Phoenix
Better agentic Elixir Phoenix development, runtime-level tools for your agent to talk to your running app.