Discover Awesome MCP Servers

MCP Server for JIRA

ChatGPTなどのAIアシスタントがJIRA課題と直接やり取りできるようにするモデルコンテキストプロトコルサーバー。現在は課題の詳細を取得する機能を提供しています。

Vibe-Coder MCP Server

LLM (大規模言語モデル) を活用したコーディングのための構造化されたワークフローを実装する MCP サーバー。機能の明確化、ドキュメント生成、段階的な実装、進捗状況の追跡を通じて開発をガイドします。

Maccam912_searxng Mcp Server

鏡 (Kagami)

OpenAI MCP Server

鏡 (Kagami)

mcp-server-zenn: Unofficial MCP server for Zenn (

ZennのAPIを通じて記事や書籍を取得できるようにする、非公式のModel Context Protocolサーバー。

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.

AlphaVantage MCP Server

AlphaVantageの金融データAPIと連携し、株式市場データ、テクニカル指標、および基礎的な財務情報へのアクセスを提供するMCPサーバー。

mcp-server-iris: An InterSystems IRIS MCP server

Okay, I understand. Here's how you can execute SQL queries and perform monitoring/manipulations with Interoperability in InterSystems IRIS, along with examples and explanations: **1. Executing SQL Queries** InterSystems IRIS provides several ways to execute SQL queries: * **SQL Shell (Terminal):** The most direct way. * **Management Portal:** A web-based interface. * **Embedded SQL (ObjectScript):** Within your ObjectScript code. * **JDBC/ODBC:** From external applications. **a) SQL Shell (Terminal)** 1. **Access the Terminal:** Open the InterSystems IRIS terminal. The exact method depends on your installation (e.g., using `iris session` on Linux, or the InterSystems IRIS shortcut on Windows). 2. **Switch to the Namespace:** Use the `ZN` command to switch to the namespace where your data resides. For example: ``` ZN DEMOSPACE ``` 3. **Execute SQL:** Use the `DO $SYSTEM.SQL.Shell()` command to enter the SQL shell. Then, type your SQL queries. ``` DO $SYSTEM.SQL.Shell() SQL> SELECT Name, Age FROM Sample.Person WHERE Age > 30; ``` To exit the SQL shell, type `QUIT`. **b) Management Portal** 1. **Access the Management Portal:** Open your web browser and navigate to the Management Portal (usually `http://localhost:52773/csp/sys/UtilHome.csp`). Replace `52773` with your instance's port if it's different. 2. **Log In:** Log in with a user that has appropriate permissions (e.g., `_SYSTEM` with the password you set during installation). 3. **Navigate to SQL Shell:** Go to **System Explorer > SQL Shell**. 4. **Select Namespace:** Choose the correct namespace from the dropdown. 5. **Enter and Execute SQL:** Type your SQL query in the text area and click **Execute**. **c) Embedded SQL (ObjectScript)** This is the most common way to execute SQL within your applications. ```objectscript ClassMethod ExecuteSQL() As %Status { Set sqlCode = ##class(%SQL.Statement).%New() Set status = sqlCode.%Prepare("SELECT Name, Age FROM Sample.Person WHERE Age > ?") If $$$ISERR(status) { Quit status } Set rs = sqlCode.%Execute(40) // Example: Age > 40 If $$$ISERR(rs.%SQLCODE) { Quit rs.%SQLCODE } While rs.%Next() { Set name = rs.%Get("Name") Set age = rs.%Get("Age") Write "Name: ", name, ", Age: ", age, ! } Quit $$$OK } ``` **Explanation:** * `##class(%SQL.Statement).%New()`: Creates a new SQL statement object. * `%Prepare()`: Prepares the SQL statement for execution. Using prepared statements is crucial for performance and security (prevents SQL injection). The `?` is a placeholder for a parameter. * `%Execute()`: Executes the prepared statement, passing in the parameter value(s). * `rs.%Next()`: Iterates through the result set. * `rs.%Get("Name")`: Retrieves the value of the "Name" column for the current row. * `$$$ISERR()`: A macro that checks for errors. * `$$$OK`: A macro that represents a successful status. **d) JDBC/ODBC** You can connect to InterSystems IRIS from external applications using JDBC or ODBC drivers. The steps involve: 1. **Download the Drivers:** Obtain the JDBC or ODBC driver from the InterSystems website or the Management Portal. 2. **Configure the Driver:** Configure the driver in your application's environment (e.g., set up a JDBC connection pool). 3. **Connect and Execute:** Use the driver's API to connect to the IRIS instance and execute SQL queries. **2. Monitoring and Manipulations with Interoperability** Interoperability in InterSystems IRIS allows you to connect to and interact with external systems. Monitoring and manipulation often involve: * **Monitoring Production Processes:** Tracking the status of business processes, message queues, and other components. * **Error Handling and Alerting:** Detecting and responding to errors in message processing. * **Message Routing and Transformation:** Modifying and directing messages based on their content or other criteria. * **Data Enrichment:** Adding data from external sources to messages. * **Orchestration:** Coordinating multiple services to complete a business transaction. **Key Interoperability Components:** * **Productions:** The central component for defining and managing business processes. * **Business Operations:** Send messages to external systems. * **Business Processes:** Define the logic for processing messages. * **Business Services:** Receive messages from external systems. * **Adapters:** Handle the communication with specific external systems (e.g., file systems, databases, web services). * **Data Transformations:** Convert data between different formats. **a) Monitoring Productions** The Management Portal provides tools for monitoring productions: 1. **Navigate to Production Monitoring:** Go to **System Explorer > Production Monitoring**. 2. **View Production Status:** You can see the overall status of the production (running, stopped, etc.), as well as the status of individual business operations, processes, and services. 3. **Track Message Flow:** You can trace the flow of messages through the production, see which components have processed them, and view any errors that have occurred. 4. **View Message Details:** You can inspect the contents of messages to troubleshoot issues. **b) Manipulating Productions (Programmatically)** You can use ObjectScript to programmatically control and monitor productions. ```objectscript ClassMethod ControlProduction(productionName As %String, action As %String) As %Status { Set production = ##class(Ens.Production).%OpenId(productionName) If '$IsObject(production) { Quit $$$ERROR($$$GeneralError, "Production not found: " _ productionName) } If action = "Start" { Set status = production.Start() } elseif action = "Stop" { Set status = production.Stop() } elseif action = "Restart" { Set status = production.Restart() } else { Quit $$$ERROR($$$GeneralError, "Invalid action: " _ action) } Quit status } ClassMethod GetProductionStatus(productionName As %String) As %String { Set production = ##class(Ens.Production).%OpenId(productionName) If '$IsObject(production) { Quit "Production not found: " _ productionName } Quit production.Status } ``` **Explanation:** * `Ens.Production`: The class that represents a production. * `%OpenId()`: Opens an existing production by its name (ID). * `Start()`, `Stop()`, `Restart()`: Methods to control the production. * `Status`: A property that returns the current status of the production. **c) Error Handling and Alerting** Interoperability provides mechanisms for handling errors: * **Error Handling in Business Processes:** You can define error handlers within your business processes to catch and handle exceptions. * **Alerting:** You can configure alerts to be triggered when errors occur. These alerts can be sent via email, SMS, or other channels. * **Message Retries:** You can configure business operations to automatically retry sending messages that fail. * **Dead Letter Queues:** Messages that cannot be processed are often moved to a dead letter queue for later analysis. **Example: Error Handling in a Business Process** ```objectscript /// This is a simplified example. Real-world error handling is more complex. ClassMethod MyBusinessProcess(request As MyRequestClass) As MyResponseClass { Try { // ... Your main logic here ... Set response = ..CallExternalService(request) } Catch ex { // Handle the exception Write "Error: ", ex.Name, ", ", ex.Message, ! // Optionally, send an alert or log the error. Set response = ##class(MyResponseClass).%New() Set response.Status = "Error" Set response.ErrorMessage = ex.Message } Quit response } ``` **d) Message Routing and Transformation** * **Routing Rules:** Business processes can use routing rules to determine where to send messages based on their content or other criteria. * **Data Transformations:** You can use data transformations to convert messages between different formats (e.g., XML to JSON). InterSystems IRIS provides a graphical data transformation editor. **Example: Routing Based on Message Content** ```objectscript ClassMethod RouteMessage(request As MyRequestClass) As %String { If request.MessageType = "Order" { Quit "OrderProcess" // Route to the OrderProcess business process } elseif request.MessageType = "Invoice" { Quit "InvoiceProcess" // Route to the InvoiceProcess business process } else { Quit "DefaultProcess" // Route to a default process } } ``` **e) Data Enrichment** You can use business operations to retrieve data from external sources and add it to messages. ```objectscript ClassMethod EnrichMessage(request As MyRequestClass) As MyRequestClass { // Example: Retrieve customer data from a database Set customerId = request.CustomerID Set customer = ##class(MyCustomerClass).Get(customerId) If $IsObject(customer) { Set request.CustomerName = customer.Name Set request.CustomerAddress = customer.Address } Quit request } ``` **Important Considerations:** * **Security:** Implement proper security measures to protect your data and systems. Use secure protocols (e.g., HTTPS), authenticate users, and authorize access to resources. * **Performance:** Optimize your SQL queries and interoperability configurations for performance. Use indexes, prepared statements, and efficient data transformations. * **Error Handling:** Implement robust error handling to prevent failures and ensure data integrity. * **Monitoring:** Monitor your systems regularly to detect and resolve issues promptly. * **Logging:** Log important events and errors for auditing and troubleshooting. * **Transactions:** Use transactions to ensure data consistency when performing multiple operations. * **Namespaces:** Use namespaces to organize your code and data. * **Documentation:** Document your code and configurations thoroughly. **Example Scenario: Order Processing** 1. **Business Service:** Receives an order message (e.g., in XML format) from a web service. 2. **Data Transformation:** Transforms the XML message into a canonical format. 3. **Business Process:** * Validates the order data. * Enriches the message with customer data from a database. * Routes the message to an inventory system. * Routes the message to a payment processing system. 4. **Business Operations:** Send messages to the inventory and payment processing systems. 5. **Error Handling:** If any errors occur, the business process logs the error and sends an alert to an administrator. **How to Translate to Japanese:** To translate the above information into Japanese, you would need to translate each section and code example. Here's a general approach: 1. **Translate Headings and Explanations:** Use a translation tool (like Google Translate, DeepL, or a professional translator) to translate the headings and explanations. Review the translations carefully to ensure accuracy and clarity. 2. **Translate Code Comments:** Translate the comments within the code examples to explain what the code does. 3. **Consider Terminology:** Use consistent terminology throughout the translation. For example, decide on the best Japanese translation for "Business Process," "Business Operation," "Adapter," etc., and use those terms consistently. 4. **Test the Code:** If possible, test the translated code examples to ensure that they work correctly in a Japanese environment. Pay attention to character encoding and other locale-specific issues. **Example Translation (Partial):** **English:** **1. Executing SQL Queries** InterSystems IRIS provides several ways to execute SQL queries: * **SQL Shell (Terminal):** The most direct way. **Japanese:** **1. SQLクエリの実行** InterSystems IRISでは、SQLクエリを実行するためのいくつかの方法が提供されています。 * **SQLシェル（ターミナル）：** 最も直接的な方法です。 (SQL Sheru (Tāminaru): Mottomo chokusetsuteki na hōhō desu.) **Important Note:** While I can provide a basic translation, it's highly recommended to have a native Japanese speaker review the translation for accuracy and naturalness, especially for technical documentation. This comprehensive guide should help you get started with executing SQL queries and working with Interoperability in InterSystems IRIS. Remember to consult the official InterSystems IRIS documentation for more detailed information and specific instructions. Good luck!

Python CLI Tool for Generating MCP Servers from API Specs

AnthropicのSDKを用いて、OpenAPIまたはGraphQLの仕様を入力としてMCPサーバーを生成します。

MCP Server for Running E2E Tests

AI が生成したコードの検証を自動化する e2e MCP サーバー

GitLab MCP Server Tools

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

Linear MCP Server

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

MCP Tools

MCP (Model Context Protocol) サーバーとやり取りするためのコマンドラインインターフェース。標準入出力 (stdio) と HTTP トランスポートの両方を使用します。

Mattermost MCP Server

Claudeやその他のMCPクライアントがMattermostワークスペースと連携できるようにするMCPサーバー。チャンネル管理、メッセージング機能、トピック監視機能を提供します。

Edgeone Pages Mcp Server

EdgeOne PagesにHTMLコンテンツを迅速にデプロイし、デプロイされたコンテンツに対して自動的に公開URLを生成するサービス。

Azure Log Analytics MCP Server

自然言語を使用して Azure Log Analytics をクエリするための MCP サーバー

Gemini Context MCP Server

複数のAIクライアントアプリケーション間で効率的なコンテキスト管理とキャッシュを行い、Geminiの2Mトークンコンテキストウィンドウを最大限に活用するMCPサーバー実装。

Model Context Protocol (MCP) Schema for Rust

Rust での、公式 Model Context Protocol (MCP) スキーマの型安全な実装。

Agentis MCP

MCPサーバーをツールとして使用するAIエージェントを作成するためのPythonフレームワーク。あらゆるMCPサーバーおよびモデルプロバイダーと互換性があります。

Azure DevOps MCP (Model Context Protocol)

Model Context Protocol のリファレンスサーバー実装。AIアシスタントが Azure DevOps リソースと連携し、プロジェクト管理、作業項目追跡、リポジトリ操作、コード検索などの操作をプログラム的に実行できるようにします。

Algorand MCP Implementation

Algorandブロックチェーンとのツール連携（40種類以上）とリソースアクセス（60種類以上）のための包括的なMCPサーバー、さらに多くの便利なプロンプト。

Krep MCP Server

高性能な文字列検索ユーティリティ。Model Context Protocolとの統合により、AIアシスタントがファイルや文字列内で効率的なパターン検索を実行できるようになります。

Scast

静的解析を通じてコードをUML図やフローチャートに変換し、コード構造の可視化と機能の説明を可能にします。

Petstore3

AIエージェントと外部APIを橋渡しするプロキシサーバー。OpenAPI仕様を標準化されたMCPツールに動的に変換することで、カスタム統合コードなしにシームレスなインタラクションを可能にする。

DeepView MCP

CursorやWindsurfのようなIDEがGeminiの広範なコンテキストウィンドウを利用して大規模なコードベースを分析できるようにする、モデルコンテキストプロトコルサーバー。

MCP Server for RSS3

MCPサーバー実装で、RSS3 APIを統合し、ユーザーが分散型チェーン、ソーシャルメディアプラットフォーム、およびRSS3ネットワークから自然言語でデータをクエリできるようにするもの。