MCP Servers

Discover Awesome MCP Servers

Extend your agent with 65,640 capabilities via MCP servers.

All65,640

Anki MCP Server

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

MCP Prompt Server

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

LlamaCloud MCP Server

鏡 (Kagami)

beeper_mcp MCP server

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

File Merger MCP Server

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

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

テスト (Tesuto)

piapi-mcp-server

鏡 (Kagami)

MCP Server Giphy

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

MCP Server MetaTool

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.