Discover Awesome MCP Servers

MCP Ayd Server

鏡 (Kagami)

Quantitative Researcher MCP Server

定量的な研究知識グラフを管理するためのツールを提供し、研究プロジェクト、データセット、変数、仮説、統計的検定、モデル、および結果の構造化された表現を可能にします。

Clover MCP (Model Context Protocol) Server

AIエージェントが、セキュアなOAuth認証されたMCPサーバーを通じて、Cloverの加盟店データ、在庫、および注文にアクセスし、操作できるようにします。

Jira MCP Server

大規模言語モデルが自然言語を通じてJiraプロジェクト、ボード、スプリント、および課題とやり取りできるようにする、Jiraとの統合を提供するモデルコンテキストプロトコルサーバー。

File Merger MCP Server

複数のファイルを、シンプルなMCPインターフェースを通して単一のファイルに結合することを可能にします。許可されたディレクトリのみへのアクセスを制限しつつ、ファイルを安全に結合する方法を提供します。

GraphQL MCP Server

Claude AIに、Model Context Protocolを通じてあらゆるGraphQL APIへのシームレスなアクセスを提供するTypeScriptサーバー。

mcp-weather-server

了解しました。LLMに天気データを提供する、Model Context Protocolサーバーの例を以下に示します。 ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel import datetime import random app = FastAPI() class WeatherRequest(BaseModel): city: str date: datetime.date class WeatherResponse(BaseModel): city: str date: datetime.date temperature: float condition: str # 天気データをシミュレートする関数 def get_weather_data(city: str, date: datetime.date): # 簡単なシミュレーション：実際にはAPIを呼び出すか、データベースから取得します temperature = random.uniform(5, 30) # 5〜30度の範囲でランダムな温度 conditions = ["晴れ", "曇り", "雨", "雪"] condition = random.choice(conditions) return WeatherResponse(city=city, date=date, temperature=temperature, condition=condition) @app.post("/weather", response_model=WeatherResponse) async def get_weather(request: WeatherRequest): try: weather_data = get_weather_data(request.city, request.date) return weather_data except Exception as e: raise HTTPException(status_code=500, detail=str(e)) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` **説明:** * **FastAPI:** 軽量で高速なPythonのWebフレームワークを使用しています。 * **Pydantic:** データ検証とシリアライゼーションのためにPydanticを使用しています。 * **`WeatherRequest`:** LLMから受け取るリクエストのデータ構造を定義します。 `city` (都市名) と `date` (日付) を含みます。 * **`WeatherResponse`:** サーバーがLLMに返すレスポンスのデータ構造を定義します。 `city`, `date`, `temperature` (温度), `condition` (天気) を含みます。 * **`get_weather_data`:** 天気データをシミュレートする関数です。 実際には、外部の天気API (OpenWeatherMapなど) を呼び出すか、天気データのデータベースから情報を取得します。 この例では、ランダムな値を生成しています。 * **`/weather` エンドポイント:** `POST` リクエストを受け付け、`WeatherRequest` を解析し、`get_weather_data` を呼び出して天気データを取得し、`WeatherResponse` として返します。 * **エラー処理:** `try...except` ブロックを使用して、エラーが発生した場合に適切なHTTPエラーレスポンスを返します。 * **`uvicorn`:** ASGIサーバーを使用して、FastAPIアプリケーションを実行します。 **使い方:** 1. **必要なライブラリをインストール:** ```bash pip install fastapi uvicorn pydantic ``` 2. **上記のコードを `weather_server.py` などのファイルに保存します。** 3. **サーバーを実行:** ```bash python weather_server.py ``` 4. **LLMからリクエストを送信:** LLMから、以下の形式で `POST` リクエストを `http://localhost:8000/weather` に送信します。 ```json { "city": "東京", "date": "2023-10-27" } ``` 例えば、Pythonの `requests` ライブラリを使用すると、以下のようになります。 ```python import requests import datetime url = "http://localhost:8000/weather" data = { "city": "東京", "date": datetime.date(2023, 10, 27).isoformat() } headers = {'Content-type': 'application/json'} response = requests.post(url, json=data, headers=headers) if response.status_code == 200: print(response.json()) else: print(f"Error: {response.status_code} - {response.text}") ``` **LLMとの統合:** LLMは、このサーバーにリクエストを送信し、天気データを受け取って、その情報を応答に組み込むことができます。 例えば、ユーザーが「明日の東京の天気は？」と尋ねた場合、LLMはまずこのサーバーにリクエストを送信し、天気データを受け取ってから、「明日の東京の天気は晴れで、気温は20度です。」のような応答を生成します。 **重要な考慮事項:** * **認証:** LLMのみがこのサーバーにアクセスできるように、認証メカニズムを追加することを検討してください。 * **レート制限:** サーバーへのリクエスト数を制限して、過負荷を防ぎます。 * **実際の天気データ:** この例では天気データをシミュレートしていますが、実際には信頼できる天気APIを使用する必要があります。 * **エラー処理:** より堅牢なエラー処理を追加して、さまざまなエラーシナリオに対応します。 * **スケーラビリティ:** より多くのリクエストを処理できるように、サーバーをスケーリングすることを検討してください。 この例は、Model Context Protocolサーバーの基本的な実装を示しています。 実際のアプリケーションでは、より複雑な機能やセキュリティ対策が必要になる場合があります。

Wikipedia MCP Image Crawler

Wikipediaの画像検索ツール。クリエイティブ・コモンズ・ライセンスに従って画像を探し、Claude Desktop/Cline経由でプロジェクトで使用します。

Token Minter MCP

AIエージェントが複数のブロックチェーン上でERC-20トークンをミントするためのツールを提供するMCPサーバー。

DVMCP: Data Vending Machine Context Protocol

DVMCPは、Model Context Protocol (MCP) サーバーをNostrのData Vending Machine (DVM) エコシステムに接続するブリッジ実装です。

NextChat with MCP Server Builder

MCPサーバー作成機能とOpenRouter統合を備えたNextChat

BigQuery Analysis MCP Server

Google BigQuery に対して、データの変更や過剰な処理を防ぐ安全機能を備え、SQL クエリの実行と検証を可能にするサーバー。

Unreal Engine Generative AI Support Plugin

UnrealMCPが登場！！AIによるブループリントとシーンの自動生成！！LLM/GenAIモデルとMCP UE5サーバー用のUnreal Engineプラグインです。Claude Desktop AppとCursorをサポートし、OpenAIのGPT4o、DeepseekR1、Claude Sonnet 3.7 APIも搭載。Gemini、Grok 3、オーディオ＆リアルタイムAPIの追加も計画中です。

mcp-flux-schnell MCP Server

TypeScript で構築された MCP (Minecraft Protocol) サーバーで、Cloudflare の Flux Schnell モデル API を利用してテキストから画像を生成できます。

MCP Server Giphy

AIモデルが、コンテンツフィルタリング、複数の検索方法、包括的なメタデータなどの機能を備えたGiphyからGIFを検索、取得、利用できるようにします。

LlamaCloud MCP Server

鏡 (Kagami)

piapi-mcp-server

鏡 (Kagami)

LLMling

YAMLで定義された、簡単なMCP（モデルコンテキストプロトコル）サーバーとAIエージェント。

LiteMCP

MCPサーバーをエレガントに構築するためのTypeScriptフレームワーク

Elixir MCP Server

Okay, here's an example of how you might implement a minimal MCP (Meta-Control Protocol) server using Elixir and Server-Sent Events (SSE) transport. This is a simplified example to illustrate the core concepts. A production-ready implementation would require more robust error handling, security considerations, and potentially more sophisticated state management. **Conceptual Overview** * **MCP (Meta-Control Protocol):** MCP is a protocol for controlling and monitoring applications. It typically involves sending commands to the server and receiving status updates. In this example, we'll define a very simple command set. * **SSE (Server-Sent Events):** SSE is a unidirectional protocol where the server pushes updates to the client over a single HTTP connection. It's well-suited for real-time updates and status notifications. * **Elixir:** We'll use Elixir, a functional and concurrent language built on the Erlang VM, to handle the server-side logic. **Example Code** ```elixir defmodule McpServer do use GenServer defstruct state: %{clients: %{}} # --- API (Client Interface) --- def start_link(opts \\ []) do GenServer.start_link(__MODULE__, :ok, opts) end def subscribe(server) do GenServer.call(server, :subscribe) end def command(server, client_id, command) do GenServer.cast(server, {:command, client_id, command}) end # --- GenServer Callbacks --- @impl true def init(:ok) do {:ok, %__MODULE__{}} end @impl true def handle_call(:subscribe, _from, state) do client_id = UUID.uuid4() {:reply, {:ok, client_id}, %{state | clients: Map.put(state.clients, client_id, self())}} end @impl true def handle_cast({:command, client_id, command}, state) do IO.puts("Received command: #{command} from client: #{client_id}") # Simulate processing the command and generating an update update = "Command '#{command}' processed." send_update(state.clients[client_id], "message", update) {:noreply, state} end # --- Helper Functions --- defp send_update(client_pid, event, data) do # This is a simplified example. In a real application, you'd likely # use a more robust SSE library or framework. message = "event: #{event}\ndata: #{data}\n\n" send(client_pid, {:sse_message, message}) end end defmodule McpWeb.Endpoint do use Phoenix.Endpoint, otp_app: :mcp_web socket "/live", Phoenix.LiveView.Socket, websocket: [connect_info: [session: @session_options]], longpoll: false # Serve at "/" the static files from "priv/static" directory. # # You should configure your server accordingly. plug Plug.Static, at: "/", from: :mcp_web, gzip: false, only: ~w(css fonts images js favicon.ico robots.txt) # Code reloading can be explicitly enabled under the # :code_reloader configuration of your endpoint. if code_reloading? do socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket plug Phoenix.LiveReloader.RequestLogger end plug Plug.RequestId plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint] plug Plug.Head plug Plug.Session, @session_options plug McpWeb.Plugs.EnsureCors plug :router, McpWeb.Router end defmodule McpWeb.Plugs.EnsureCors do import Plug.Conn def init(opts), do: opts def call(conn, _opts) do conn |> put_resp_header("access-control-allow-origin", "*") |> put_resp_header("access-control-allow-methods", "GET, POST, OPTIONS") |> put_resp_header("access-control-allow-headers", "content-type") end end defmodule McpWeb.Router do use McpWeb, :router pipeline :api do plug :accepts, ["json"] end scope "/api", McpWeb do pipe_through :api post "/command", CommandController, :create end scope "/", McpWeb do pipe_through :browser get "/", PageController, :index get "/sse", SseController, :index end # Enables LiveDashboard in development # # If you want to use the LiveDashboard in production, you should ensure # you have the proper strategies for checking user authorization and # authentication. if Mix.env() in [:dev, :test] do import Phoenix.LiveDashboard.Router scope "/" do pipe_through :browser live_dashboard "/dashboard", metrics: McpWeb.Telemetry end end # Enables the Swoosh mailbox preview in development. # # Note that preview only shows emails that were sent by the same # node running the Phoenix server. if Mix.env() == :dev do scope "/dev", McpWeb do pipe_through :browser forward "/mailbox", Plug.Swoosh.MailboxPreview end end end defmodule McpWeb.SseController do use McpWeb, :controller require Logger def index(conn, _params) do conn = conn |> put_resp_header("content-type", "text/event-stream") |> put_resp_header("cache-control", "no-cache") |> send_resp(200, "data: connected\n\n") # Subscribe to the MCP server {:ok, client_id} = McpServer.subscribe(McpServer) # Start a process to listen for SSE messages from the server Task.start(fn -> receive_messages(client_id, conn) end) conn end defp receive_messages(client_id, conn) do receive do {:sse_message, message} -> Logger.info("Sending SSE message: #{message}") {:ok, new_conn} = Plug.Conn.chunk(conn, message) receive_messages(client_id, new_conn) # Continue listening after 60_000 -> # Timeout after 60 seconds of inactivity Logger.warn("SSE connection timed out for client: #{client_id}") Plug.Conn.halt(conn) end end end defmodule McpWeb.CommandController do use McpWeb, :controller def create(conn, %{"command" => command}) do # In a real application, you'd likely authenticate the client # and associate the command with a specific client ID. client_id = UUID.uuid4() # Generate a temporary client ID McpServer.command(McpServer, client_id, command) send_resp(conn, :ok, %{message: "Command received"}) end end defmodule McpWeb.PageController do use McpWeb, :controller def index(conn, _params) do render(conn, "index.html") end end ``` **Explanation and Key Points:** 1. **`McpServer` (GenServer):** * This is the core of the MCP server. It's a `GenServer`, which provides a structured way to manage state and handle concurrent requests. * `start_link/1`: Starts the GenServer. * `subscribe/1`: Allows a client to subscribe to receive updates. It generates a unique `client_id` and stores the client's process ID (`self()`) in the `clients` map. * `command/2`: Receives commands from clients. It simulates processing the command and then sends an update to the client using `send_update/3`. * `init/1`, `handle_call/3`, `handle_cast/2`: Standard `GenServer` callbacks for initialization, handling synchronous requests (`call`), and handling asynchronous requests (`cast`). * `send_update/3`: Formats the update as an SSE message and sends it to the client's process. **Important:** This uses `send/2` to send a message to the client's process. The client process needs to be listening for these messages. 2. **`McpWeb.SseController` (Phoenix Controller):** * This controller handles the SSE endpoint (`/sse`). * `index/2`: * Sets the necessary HTTP headers for SSE (`content-type: text/event-stream`, `cache-control: no-cache`). * Sends an initial "connected" message. * Calls `McpServer.subscribe/1` to get a `client_id`. * Starts a `Task` (a lightweight process) to `receive_messages/2`. This is crucial because the client needs to continuously listen for updates from the `McpServer`. * `receive_messages/2`: * Uses `receive/1` to listen for `{:sse_message, message}` messages sent from the `McpServer`. * When a message is received, it uses `Plug.Conn.chunk/2` to send the SSE message to the client. `Plug.Conn.chunk/2` is the correct way to send data over a streaming connection in Phoenix. * Recursively calls itself (`receive_messages/2`) to continue listening. * Includes a timeout to close the connection if no messages are received for a certain period. 3. **`McpWeb.CommandController` (Phoenix Controller):** * This controller handles the `/api/command` endpoint. * `create/2`: * Extracts the `command` from the request parameters. * Calls `McpServer.command/3` to send the command to the MCP server. * Sends a response to the client. **Note:** In a real application, you'd likely want to authenticate the client and associate the command with a specific client ID. This example generates a temporary UUID. 4. **`McpWeb.Router` (Phoenix Router):** * Defines the routes for the application. * `/sse`: The SSE endpoint handled by `SseController`. * `/api/command`: The command endpoint handled by `CommandController`. 5. **`McpWeb.Plugs.EnsureCors` (Phoenix Plug):** * Adds CORS headers to allow requests from any origin. **Important:** In a production environment, you should configure CORS more restrictively to only allow requests from trusted origins. **To Run This Example:** 1. **Create a new Phoenix project:** ```bash mix phx.new mcp_web --no-ecto cd mcp_web ``` 2. **Replace the contents of the generated files** with the code above. Make sure to replace the contents of `lib/mcp_web/endpoint.ex`, `lib/mcp_web/router.ex`, `lib/mcp_web/controllers/page_controller.ex`, `lib/mcp_web/controllers/sse_controller.ex`, `lib/mcp_web/controllers/command_controller.ex`, `lib/mcp_web/plugs/ensure_cors.ex`, and create a new file `lib/mcp_server.ex`. Also, update `lib/mcp_web.ex` to include `McpServer` in the supervision tree. ```elixir defmodule McpWeb do @moduledoc """ The entrypoint for defining your web interface, such as controllers, views, channels and so on. This can be used throughout your application as a single source of truth for the path, plug and view modules that make up your web. """ use Phoenix.Component binding = [ :controller, :live_component, :live_view, :channel ] @doc """ Used for defining controller, live_view, live_component, and channel modules. When used, dispatch to the appropriate macro depending on the modules being defined. """ defmacro __using__(opts) when is_list(opts) do opts = Keyword.put_new(opts, :layout, {McpWeb.LayoutView, :app}) quote do use Phoenix.Controller, unquote(opts) import Phoenix.HTML import Phoenix.Controller.Helpers import McpWeb.Gettext alias McpWeb.Router.Helpers, as: Routes end end # The root directory for static assets. @doc since: "1.4.0" def static_paths, do: ~w(assets static) @doc """ Returns the list of live views and live components that should be automatically mounted when the app starts. """ def live_components, do: [] @doc """ Returns the list of telemetry metrics that should be reported when the app starts. """ def telemetry_metrics do [ summary("phoenix.endpoint.stop.duration", unit: {:native, :millisecond} ), summary("phoenix.router_dispatch.stop.duration", router: :router, unit: {:native, :millisecond} ), counter("phoenix.endpoint.http.request.count") ] end @doc """ Returns the list of supervisors that should be used to start the application. """ def supervision_tree(extra_applications \\ []) do [ # Start the Telemetry supervisor McpWeb.Telemetry, # Start the PubSub system {Phoenix.PubSub, name: McpWeb.PubSub}, # Start the Endpoint (http/https) McpWeb.Endpoint, # Start the McpServer McpServer # Start a worker by calling: McpWeb.Worker.start_link(arg) # {McpWeb.Worker, arg} ] ++ extra_applications end defp summary(name, opts) do Telemetry.Metrics.summary(name, unit: opts[:unit]) end defp counter(name, opts) do Telemetry.Metrics.counter(name, unit: opts[:unit]) end end ``` 3. **Add dependencies:** Add `:uuid` to your `mix.exs` file's `deps` function: ```elixir def deps do [ {:phoenix, "~> 1.7.7"}, {:phoenix_ecto, "~> 4.4"}, {:telemetry_metrics, "~> 0.6"}, {:telemetry_poller, "~> 1.0"}, {:gettext, "~> 0.11"}, {:jason, "~> 1.2"}, {:plug_cowboy, "~> 2.5"}, {:uuid, "~> 1.1"} # Add this line ] end ``` 4. **Install dependencies:** ```bash mix deps.get ``` 5. **Run the server:** ```bash mix phx.server ``` **Testing:** 1. **Open your browser** and go to `http://localhost:4000/sse`. This will establish the SSE connection. You should see "data: connected" in your browser's developer console (Network tab). 2. **Send a command:** You can use `curl` or a similar tool to send a command to the `/api/command` endpoint: ```bash curl -X POST -H "Content-Type: application/json" -d '{"command": "do_something"}' http://localhost:4000/api/command ``` 3. **Check the SSE stream:** In your browser's developer console (Network tab, SSE connection), you should see the update from the server: ``` event: message data: Command 'do_something' processed. ``` **Important Considerations:** * **Error Handling:** This example has minimal error handling. A production system needs robust error handling and logging. * **Authentication and Authorization:** The example doesn't include authentication or authorization. You'll need to implement these to secure your MCP server. Consider using Phoenix's built-in authentication features or a library like `Pow`. * **Client ID Management:** The example generates a temporary client ID for commands. In a real application, you'll need a more persistent way to associate commands with clients. * **SSE Library:** For more complex SSE requirements, consider using a dedicated SSE library for Elixir. * **Concurrency:** Elixir/Erlang is excellent for concurrency. Make sure your command processing logic is designed to handle concurrent requests efficiently. * **State Management:** For more complex applications, you might need a more sophisticated state management solution (e.g., using ETS tables or a database). * **CORS:** Configure CORS properly for production. Don't use `access-control-allow-origin: *` in production. **Japanese Translation of Key Concepts:** * **MCP (Meta-Control Protocol):** メタコントロールプロトコル * **SSE (Server-Sent Events):** サーバー送信イベント * **Elixir:** Elixir (エリクサー) * **GenServer:** GenServer (ゲンサーバー) * **Phoenix:** Phoenix (フェニックス) * **Client ID:** クライアントID * **Command:** コマンド * **Update:** 更新 (こうしん) * **Subscribe:** 購読 (こうどく) * **Endpoint:** エンドポイント * **Authentication:** 認証 (にんしょう) * **Authorization:** 認可 (にんか) * **Concurrency:** 並行性 (へいこうせい) * **State Management:** 状態管理 (じょうたいかんり) * **CORS (Cross-Origin Resource Sharing):** クロスオリジンリソース共有 This example provides a basic foundation for building an MCP server with Elixir and SSE. Remember to adapt it to your specific requirements and add the necessary features for a production-ready system.

eRegulations MCP Server

eRegulationsデータへの構造化された、AIフレンドリーなアクセスを提供するModel Context Protocolサーバー実装。AIモデルが行政手続きに関するユーザーの質問に答えやすくします。

serverMCprtWhat is serverMCprt?How to use serverMCprt?Key features of serverMCprt?Use cases of serverMCprt?FAQ from serverMCprt?

テスト (Tesuto)

beeper_mcp MCP server

ノートの作成と管理を行うためのシンプルなMCPサーバー。要約機能もサポート。

GitLab MCP Server Tools

GitLab MCP (Multi-Cluster Provisioner) サーバー実装のための構成、アダプター、およびトラブルシューティングツール

Anki MCP Server

LLMがAnkiフラッシュカードソフトウェアと連携し、自然言語を通じてデッキの作成、ノートの追加、カードの検索、フラッシュカードコンテンツの管理などの機能を可能にする、モデルコンテキストプロトコルサーバー。

MCP Prompt Server

Model Context Protocolに基づいたサーバーで、コードレビューやAPIドキュメント生成などのタスク用に定義済みのプロンプトテンプレートを提供し、Cursor/Windsurfエディターでのより効率的なワークフローを可能にします。

Linear MCP Server

大規模言語モデルがLinearの課題管理システムと連携し、課題、プロジェクト、チーム、その他のLinearリソースを管理できるようにする、モデルコンテキストプロトコルサーバー。