Discover Awesome MCP Servers

mock-assistant-mcp-server

MCP 服务器助手，用于模拟数据。

create-mcp-server

构建具有集成 Web 功能的强大模型上下文协议 (MCP) 服务器的综合架构

McpDocs

Okay, this is a complex task involving several moving parts. Here's a breakdown of how you can provide Elixir project documentation (including dependencies) to an LLM via an SSE (Server-Sent Events) MCP (Message Channel Protocol) server. I'll outline the steps, technologies, and considerations. **1. Project Setup and Documentation Generation** * **Elixir Project:** Assume you have an Elixir project with modules, functions, and proper documentation using `ExDoc`. * **ExDoc Configuration:** Ensure your `mix.exs` file has the `ex_doc` dependency and is configured correctly. This is crucial for generating the documentation in a usable format. ```elixir def deps do [ {:ex_doc, "~> 0.31", only: :dev, runtime: false} ] end def project do [ app: :my_elixir_app, version: "0.1.0", elixir: "~> 1.14", start_permanent: Mix.env() == :prod, deps: deps(), docs: [ main: "MyElixirApp", # Optional: The main page for your documentation source_url: "https://github.com/your-username/my-elixir-app", # Optional: Link to your source code extras: ["README.md"] # Optional: Include other files in the documentation ] ] end ``` * **Generate Documentation:** Run `mix docs` in your project directory. This will create a `doc` directory containing the HTML documentation. **2. Extracting Documentation Data** The key challenge is extracting the relevant information from the generated documentation in a format suitable for an LLM. Here are a few approaches: * **Parsing HTML:** The simplest approach is to parse the generated HTML files. You can use libraries like `Floki` or `HTML5ever` in Elixir to extract the function names, arguments, documentation strings, and module names. This is fragile because the HTML structure of `ExDoc` can change between versions. ```elixir # Example using Floki (requires adding Floki to your dependencies) defmodule DocExtractor do require Logger import Floki def extract_function_docs(html_file) do html_content = File.read!(html_file) {:ok, html} = HTML5.parse(html_content) # Example: Extract function names and descriptions (adjust selectors as needed) function_data = html |> Floki.find(".detail-header") # Adjust selector to match ExDoc's HTML |> Enum.map(fn element -> function_name = element |> Floki.find(".detail-name") |> Floki.text() |> List.first() description = element |> Floki.find(".detail-doc") |> Floki.text() |> List.first() %{name: function_name, description: description} end) function_data end end ``` * **Using `ExDoc.Markdown` (More Robust):** A better approach is to leverage `ExDoc.Markdown` directly. This allows you to parse the Markdown source files that `ExDoc` uses internally. This is more stable than parsing HTML. You'll need to understand how `ExDoc` structures its Markdown files. This is more complex but less prone to breaking with `ExDoc` updates. ```elixir # Example (Conceptual - requires more detailed implementation) defmodule DocExtractor do require Logger def extract_function_docs_from_markdown(markdown_file) do markdown_content = File.read!(markdown_file) # Use ExDoc.Markdown to parse the Markdown content # (This part requires more research and implementation) # Example: # parsed_markdown = ExDoc.Markdown.parse(markdown_content) # Then, traverse the parsed_markdown structure to extract function details # ... end end ``` * **Directly Accessing `ExDoc`'s Internal Data (Advanced, Risky):** You *could* try to access `ExDoc`'s internal data structures directly. This is the most fragile approach and is highly discouraged because it relies on undocumented internal APIs that are subject to change without notice. You'd need to delve into `ExDoc`'s source code to understand how it stores the documentation data. **3. Dependency Documentation** * **Include Dependencies:** When generating documentation with `mix docs`, `ExDoc` will also generate documentation for your project's dependencies (if they have `ExDoc` documentation). The documentation for dependencies will be located in the `doc` directory, organized by package name. * **Extract Dependency Docs:** Use the same extraction methods (HTML parsing or `ExDoc.Markdown`) to extract documentation from the dependency documentation files. Make sure to clearly identify the source of the documentation (i.e., the dependency name and version). **4. Structuring the Data for the LLM** The LLM needs structured data. A good format is JSON, with each function represented as a JSON object. ```json [ { "module": "MyElixirApp.MyModule", "function": "my_function", "signature": "my_function(arg1, arg2)", "docstring": "This function does something important.", "source_file": "lib/my_elixir_app/my_module.ex", "dependency": null // or "SomeDependency" if it's from a dependency }, { "module": "SomeDependency.SomeModule", "function": "another_function", "signature": "another_function(x)", "docstring": "This function is from a dependency.", "source_file": "deps/some_dependency/lib/some_dependency/some_module.ex", "dependency": "SomeDependency" } ] ``` **5. SSE MCP Server Implementation** * **Choose a Web Server:** Use a web server like `Phoenix` or `Plug` to create the SSE endpoint. `Phoenix` is a full-featured framework, while `Plug` is a lightweight option. * **SSE Endpoint:** Create an endpoint that streams the documentation data as Server-Sent Events. SSE is a simple protocol for pushing data from the server to the client over HTTP. * **MCP (Message Channel Protocol):** MCP is a higher-level protocol that can be built on top of SSE. It provides features like message IDs, acknowledgments, and error handling. You'll need to implement the MCP logic on both the server and client sides. There isn't a standard Elixir MCP library, so you'll likely need to build your own or adapt an existing one from another language. Here's a basic example using `Plug` for the SSE server: ```elixir defmodule DocServer do use Plug.Router require Logger plug(:match) plug(:dispatch) def init(_opts) do [] end def call(conn, _opts) do conn |> Plug.Conn.put_resp_header("content-type", "text/event-stream") |> Plug.Conn.send_resp(200, stream_docs()) end defp stream_docs() do # Replace with your actual documentation extraction logic docs = [ %{module: "MyModule", function: "my_func", docstring: "Does something"}, %{module: "AnotherModule", function: "another_func", docstring: "Does something else"} ] Enum.map_join(docs, "\n", fn doc -> data = Jason.encode!(doc) # Use Jason for JSON encoding "event: doc\ndata: #{data}\n\n" end) end end ``` * **MCP Layer (Conceptual):** * **Message IDs:** Assign a unique ID to each documentation chunk sent. * **Acknowledgments:** The LLM client should send an acknowledgment message back to the server after receiving each chunk. * **Error Handling:** Implement error handling to deal with network issues or data corruption. * **Framing:** MCP often involves framing messages to ensure proper delivery. This might involve adding a header with the message length. **6. LLM Client** * **SSE Client:** The LLM client needs to connect to the SSE endpoint and receive the documentation data. Most programming languages have libraries for handling SSE connections. * **MCP Client:** Implement the MCP client logic to send acknowledgments and handle errors. * **Data Processing:** The LLM client needs to parse the JSON data and feed it to the LLM. **7. Considerations** * **Scalability:** For large projects, consider using a more robust streaming solution like Apache Kafka or RabbitMQ. SSE is suitable for smaller datasets. * **Error Handling:** Implement comprehensive error handling throughout the system. * **Security:** If the documentation contains sensitive information, secure the SSE endpoint with authentication and authorization. * **Rate Limiting:** Implement rate limiting to prevent the LLM client from overwhelming the server. * **Data Size:** Consider the size of the documentation data. If it's very large, you might need to chunk it into smaller pieces. * **LLM Context Window:** Be mindful of the LLM's context window. You might need to break the documentation into smaller chunks that fit within the context window. * **Tokenization:** Consider the tokenization used by the LLM. You might need to pre-tokenize the documentation data to optimize performance. * **Incremental Updates:** Implement a mechanism for sending incremental updates to the LLM when the documentation changes. **Example Client (Conceptual - Python):** ```python import sseclient import requests import json url = "http://localhost:4000" # Replace with your server URL def main(): response = requests.get(url, stream=True) client = sseclient.SSEClient(response) for event in client.events(): if event.event == 'doc': try: doc = json.loads(event.data) print(f"Received doc: {doc['module']}.{doc['function']}") # Process the documentation data and feed it to the LLM # ... # Send an acknowledgment (MCP) # ... except json.JSONDecodeError as e: print(f"Error decoding JSON: {e}") # Handle the error (MCP) # ... else: print(f"Received event: {event.event}, data: {event.data}") if __name__ == "__main__": main() ``` **Summary** This is a complex project that requires a good understanding of Elixir, `ExDoc`, web servers, SSE, MCP, and LLMs. Start with the basics (documentation generation and HTML parsing) and gradually add complexity as needed. Consider using a more robust streaming solution if you have a large project. Remember to prioritize error handling and security. Good luck!

Apache Doris MCP Server

Apache Doris 和 VeloDB 的 MCP 服务器

ChatGPT MCP Server

镜子 (jìng zi)

Kubectl MCP Tool

一个模型上下文协议服务器，它使 AI 助手能够通过自然语言与 Kubernetes 集群交互，支持核心 Kubernetes 操作、监控、安全和诊断。

FreeCAD MCP

这个仓库是一个 FreeCAD MCP，它允许你从 Claude Desktop 控制 FreeCAD。

untapped-mcp

一个未被使用的 MCP 服务器，用于与 Claude 配合使用。

MCP Server для Prom.ua

MCP 服务器，用于与 Prom.ua API 交互

mcp-server-fetch-typescript MCP Server

镜子 (jìng zi)

Google Scholar

🔍 通过一个简单的 MCP 接口，使 AI 助手能够搜索和访问 Google Scholar 论文。

comment-stripper-mcp

一个灵活的 MCP 服务器，可以批量处理代码文件，以删除多种编程语言中的注释。目前支持 JavaScript、TypeScript 和 Vue 文件，并使用基于正则表达式的模式匹配。可以处理单个文件、目录（包括子目录）和文本输入。专为代码的清洁维护和准备而构建。

Model Context Protocol Community

轻松运行、部署和连接到 MCP 服务器

MCP Chess

一个用于下国际象棋的 MCP 服务器 (Yī gè yòng yú xià guójì xiàngqí de MCP fúwùqì) **Breakdown:** * **一个 (yī gè):** A * **用于 (yòng yú):** for * **下国际象棋 (xià guójì xiàngqí):** playing chess (literally "play international chess") * **的 (de):** a possessive particle, linking the preceding phrase to the following noun. * **MCP 服务器 (MCP fúwùqì):** MCP server

MCP Server Runner

一个用于运行模型上下文协议（MCP）服务器的 WebSocket 服务器实现。此应用程序允许通过 WebSocket 连接访问 MCP 服务器，从而方便与 Web 应用程序和其他支持网络的客户端集成。

Pure Storage Model Context Protocol Server

一个简单的 MCP 服务器，用于与 Pure Storage 阵列交互。 (Yī gè jiǎndān de MCP fúwùqì, yòng yú yǔ Pure Storage zhènliè jiāohù.)

VSCode MCP

启用像 Goose 或 Claude 这样的人工智能代理和助手，使其可以通过模型上下文协议与 VS Code 交互。

mcp-tavily-search

MCP 服务器赋予客户端在互联网上搜索的能力。

Twilio MCP Server

一个模型上下文协议（Model Context Protocol）服务器，它使 Claude 和其他 AI 助手能够使用 Twilio 发送 SMS 和 MMS 消息。

My MCP Servers 🛠

我的一些MCP服务器的集合。

Linear MCP Server

镜子 (jìng zi)

Google Calendar MCP Server

镜子 (jìng zi)

kube-mcp

Kubernetes MCP (Machine Config Pool) servers can be translated as: **Kubernetes 机器配置池服务器** Here's a breakdown: * **Kubernetes (K8s):** Kubernetes (Kubernetes) * **MCP (Machine Config Pool):** 机器配置池 (Jīqì pèizhì chí) - This directly translates to "Machine Configuration Pool." * **servers:** 服务器 (Fúwùqì) Therefore, the complete translation is: **Kubernetes 机器配置池服务器**