Discover Awesome MCP Servers

mcp-server-for-local

皆さん、こんにちは！私は機能豊富なMCPサービスで、デバイスとサービスの隔たりをなくし、ユーザーに便利な体験をもたらすことを目指しています。天気ツールは気象プラットフォームと連携し、グローバルなリアルタイム天気を迅速にユーザーにプッシュし、皆様の外出計画をサポートします。ブラウザ制御ツールは、手動操作をシミュレートし、自動的に検索やウェブページの閲覧を行い、時間を大幅に節約します。カメラツールは、ローカルカメラを呼び出して写真撮影や録画を行い、顔認識を実現し、家庭の安全を確保します。ツールの連携を実現するために、安定したフレームワークを構築しました。開発者は既存のサービスに基づいて拡張できます。

Knowledge Graph Memory Server

Provides persistent memory for Claude by implementing a local knowledge graph to store and retrieve entities, relations, and observations. This enables long-term information retention and personalization across different chat sessions.

Android Debug Bridge MCP

Enables control of Android devices via ADB for automation and testing. Supports app management, screen capture, UI analysis, and input simulation through natural language commands.

AiryLark MCP Translation Server

高品質な翻訳サービスを提供するModelContextProtocolサーバー。分析、分割翻訳、全文レビューの3段階翻訳ワークフローを採用し、多言語をサポート、ClaudeおよびOpenAI互換モデルと統合。

SkillPort

A management toolkit for AI agent skills that provides an MCP server for search-first skill discovery and on-demand loading. It enables users to validate, organize, and serve standardized skills to MCP-compatible clients like Cursor and GitHub Copilot.

College Football MCP

Provides real-time college football game scores, betting odds, player statistics, and team performance data through integration with The Odds API and CollegeFootballData API.

MedixHub Model Context Protocol (MCP) Server

MedixHub - 医療およびヘルスケアAPIとツールを集めた、モデルコンテキストプロトコル（MCP）サーバー。

LinkedIn MCP Server

Enables Claude to access and analyze LinkedIn profile data through the Model Context Protocol, allowing users to query their LinkedIn information directly within Claude Desktop.

YNAB MCP Server

Enables interaction with You Need A Budget (YNAB) through their API, allowing users to manage budgets, accounts, categories, transactions, payees, and scheduled transactions through natural language.

MalwareAnalyzerMCP

A specialized MCP server for Claude Desktop that allows executing terminal commands for malware analysis with support for common analysis tools like file, strings, hexdump, objdump, and xxd.

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.

MCP Scheduler

A robust task scheduler server built with Model Context Protocol for scheduling and managing various types of automated tasks including shell commands, API calls, AI tasks, and reminders.

MCP (Model Context Protocol) 介紹

MCP天気サーバーのデモプロジェクト。

OPNsense MCP Server

OPNsense MCP Server

MCP Bitpanda Server

Enables programmatic access to Bitpanda cryptocurrency exchange features including trades, wallets, and transactions via the Model Context Protocol.

MCP Server Collection

MCP サービス集約 (MCP sābisu shūgyō)

Pythagraph RED MCP Server

Enables retrieval and analysis of graph data from the Pythagraph RED API. Provides detailed graph statistics, node/edge distributions, and formatted table outputs for data visualization and analysis.

Formula1 MCP Server

Model Context Protocolを通じて、リアルタイムおよび過去のF1レースデータを提供します。タイミングデータ、ドライバーの統計、レース結果、テレメトリーなどにアクセスできます。

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.

Spryker Search Tool MCP Server

Provides natural language search capabilities for Spryker GitHub repositories, packages, and public documentation. It enables code-level searches across Spryker organizations to help developers find relevant modules and technical information.

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 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!

Berlin Transport MCP Server

Provides access to Berlin's public transport data through the VBB API, enabling users to search stops, get departures, and plan journeys across Berlin-Brandenburg.

Github Mcp Server Review Tools

GitHub MCPサーバーを拡張し、プルリクエストのレビューコメント機能を追加するツール

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.

figma-mcp-flutter-test

Figma MCP Server を使用して Figma デザインを Flutter で再現する実験的なプロジェクト