"JSON-RPC"标签的搜索结果

基于 Model Context Protocol (MCP) 的后端服务器实现，为 LLM 客户端提供资源管理、工具注册与执行、以及可自定义的 Prompt 模板渲染等上下文服务，支持 JSON-RPC 通信及多传输协议（如 STDIO、HTTP/SSE/WebSocket）以实现安全、可扩展的后端上下文服务。

基于 Model Context Protocol（MCP）的后端框架，提供资源托管、工具注册与执行、以及基于模板的 Prompt 渲染，支持 JSON-RPC 通信与多传输协议（如 StdIO、SSE、WebSocket）以向 LLM 客户端提供上下文信息与外部功能。仓库不仅包含客户端示例，还实现服务器端能力、Prompts 及与客户端的集成运行逻辑。若要在实际环境中搭建 MCP 服务器，可使用内置的 MCP Prompts 服务器和通用服务器配置来对接不同的 MCP 客户端。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供面向大语言模型的资源管理、工具调用与提示渲染能力；仓库包含多个独立的 MCP 服务模块（如 Distiller、NCEMPy、4DCamera 等），通过 FastMCP 框架实现工具注册、资源访问与 JSON-RPC 风格的请求响应，支持通过多种传输方式进行客户端通信。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源、工具和提示模板等上下文能力，面向 LLM 客户端以标准化的 JSON-RPC 形式进行交互，支持多传输协议并实现会话管理与能力声明。

基于 Model Context Protocol (MCP) 的服务器实现，提供通过 HTTP SSE/STDIO 传输的 JSON-RPC 风格接口，管理资源、注册与执行工具、定义与渲染提示模板，面向大语言模型（LLM）客户端提供标准化的上下文服务和功能调用能力。

基于 Model Context Protocol (MCP) 的服务器实现，提供标准化的后端上下文服务，能够向客户端暴露 Resources、Tools，以及通过 MCP 协议读取和执行操作的能力，并以 JSON-RPC 形式进行请求/响应。实现了 MCP 的核心处理路径（初始化、获取资源、读取资源、列出工具、执行工具），并提供一个可运行的服务器接口入口（包括在 STDIO 模式下接收请求并返回响应的能力）。

基于 Model Context Protocol (MCP) 的本地服务器实现，提供对浏览器标签、分组、窗口等资源的访问、工具的注册与执行，以及提示模板的定义与渲染，供外部大语言模型（LLM）客户端通过 JSON-RPC 进行上下文查询、操作与交互。

基于 Deno 的 MCP（模型上下文协议）服务端实现，提供用于 LLM 客户端的上下文资源、工具调用与提示模板等能力，支持多场景的 MCP 会话（如全局、账单/支出等），通过 JSON-RPC/流式传输与客户端进行交互，具备会话管理、能力声明以及多种传输协议的支持。该仓库不仅实现服务器端路由与会话，还对接了数据库、OAuth、以及 MCP 服务实例化等核心组件，形成完整的 MCP 服务端框架。

基于 Foobara 的 MCP 服务器实现，提供资源(Resource)、工具(Tools)、提示模板(Prompts)等 MCP 组件的服务器端能力，通过 JSON-RPC 形式在 STDIO 通道下与客户端进行上下文信息与功能交互，支持命名域、会话、与命令注册的 MCP TOOL 列表与调用等核心能力。

基于 Model Context Protocol (MCP) 的服务器实现，为 AI Agent 提供长时记忆、工具执行和资源管理能力，并通过 JSON-RPC 与 LLM 客户端进行交互，支持多种传输通道（如 StdIO、SSE、WebSocket）。

基于 Model Context Protocol 的 MCP 服务器实现，作为 Copilot Studio 的后端上下文与工具提供者。核心职责包括托管与管理资源、注册和执行工具，以及定义和渲染提示与 UI 资源，并通过 MCP 的 JSON-RPC 2.0 协议与客户端进行通信（支持标准的初始化、工具列表与工具调用等请求，当前实现通过标准输入输出传输）。

基于 Flux 的 MCP（Model Context Protocol）服务器实现，提供标准化的资源管理、工具执行以及基于模板的提示渲染能力，以 JSON-RPC 方式与客户端交互，支持多传输（如 Stdio、HTTP/SSE），可为 LLM 客户端提供上下文和外部功能调用能力。

基于 Model Context Protocol 的后端服务实现，提供资源管理、工具注册与执行、以及可渲染的提示模板等能力，通过 JSON-RPC 与 LLM 客户端进行通信，支持会话管理、能力声明及多种传输形式，便于在编辑器、IDE 等环境中以标准化方式获取上下文信息与功能。该仓库实现了完整的 MCP 服务器端逻辑，包含任务发现、任务执行、结果与日志通知等核心能力。

基于模型上下文协议（MCP）的后端服务器，提供音乐项目的状态数据访问、资源查询、工具调用和会话管理，并通过 JSON-RPC 以标准化方式与 LLM 客户端通信，支持本地资源、专辑、轨道、想法等数据的读取、更新与重建。

基于 FastAPI 的 MCP 服务器实现，提供按标准化方式向 LLM 客户端暴露资源、工具和提示模板的能力，并通过 JSON-RPC 风格的 API 与客户端通信，支持多种传输方式（HTTP/SSE），实现会话管理与能力声明等 MCP 服务器核心功能。

基于 Model Context Protocol 的 MCP 服务器实现，提供文档处理资源、工具注册与执行、以及 Prompt/模板的上下文服务，支持通过 STDIO、HTTP/SSE 等传输协议与 LLM 客户端进行 JSON-RPC 通信，并具备健康检查、会话管理与多传输能力的后端服务框架。

基于 Model Context Protocol（MCP）的后端服务，暴露本地 Zotero 库的资源、工具和 Semantic Scholar 集成，供大语言模型客户端通过 JSON-RPC 进行交互与上下文获取。

基于 MCP（Model Context Protocol）的后端服务器实现，用于模拟向 LLM 客户端提供资源、注册与执行工具、以及渲染提示模板的能力，具备可运行的服务端代码和一套可测试的微型 MCP 服务场景，便于开发、验证和集成测试。

基于 Model Context Protocol (MCP) 的后端服务器框架，提供 A2A 端点、工具注册、跨服务器协作与 JSON-RPC 通信，能够向 LLM 客户端以标准化方式暴露工具集合、实现会话与上下文管理。

将本地 Ollama API 以工具形式暴露给 Cursor、Claude Desktop 等 LLM 客户端的后端服务，提供模型管理、对话、生成与嵌入等能力的 MCP 服务端实现。

基于 Model Context Protocol (MCP) 的后端服务器，向大型语言模型（LLM）客户端提供 Sequence 银行业务的上下文资源、可执行工具以及可渲染的提示模板，支持通过多种传输协议与客户端进行 JSON-RPC 交互，實现账户查询与远程规则触发等功能。

基于 Model Context Protocol 的 MCP 服务器实现，为 LLM 客户端提供权限提示、问题解答和计划审批等上下文能力。通过 JSON-RPC 与客户端交互，并在本地通过 TUI（通过 Unix socket 与 UI 组件通信）提供可扩展的外部功能接入与会话管理。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大型语言模型客户端以标准化方式提供上下文资源、可调用工具、以及可定制的提示模板。服务器通过 JSON-RPC 与客户端通信，支持会话管理与多种传输协议（如 STDIO、SSE、WebSocket），实现资源/工具/提示的托管、注册与渲染，面向本地开发环境的可扩展上下文服务。

基于 Model Context Protocol (MCP) 的后端实现，使用 JSON-RPC 规范与客户端通信，提供 MCP 初始化、工具列表以及工具调用等基本服务器端能力，用于向 LLM 客户端暴露资源、工具与提示渲染等上下文服务。

基于 Model Context Protocol (MCP) 的完整 MCP 服务器实现，提供对 Final Cut Pro X 的 FCPXML 文件进行分析、修改和自动化的标准化 JSON-RPC 接口，支持资源发现、工具执行、提示渲染等核心能力，便于与 LLM 客户端协作完成上下文管理与功能调用。

基于模型上下文协议（MCP）的后端服务器实现，提供本地资源管理、外部工具调用和提示渲染，支持与LLM客户端通过JSON-RPC进行交互，具备SQLite持久化与外部天气API查询等功能。

基于 Model Context Protocol (MCP) 的聚合型服务器实现，通过网关式中间件将本地 MCP 服务器聚合为一个可通过 JSON-RPC 与客户端交互的统一入口，提供对资源与工具的托管、执行、以及提示模板的渲染与导出，具备会话管理、 secret 管理、日志流、以及跨进程通信的能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行、以及提示模板渲染等能力，通过 JSON-RPC 与客户端通信，支撑 LLM 应用的上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，聚合多家生物医药数据库的工具与资源，通过 JSON-RPC 与 LLM 客户端通信，提供资源托管、工具注册与执行、提示模板渲染等能力，并支持统一端点与各个 API 的专用端点，面向将来将上下文信息与功能模块化提供给大语言模型进行后端上下文服务。该仓库实现了一个以 FastMCP 为核心、覆盖 Reactome、KEGG、UniProt、Omim、GWAS、PubMed、OpenFDA、MyVariant、BioThings、NCI 等多家 API 的 MCP 服务器集合。

基于 MCP 的后端服务，向 LLM 客户端提供循环肽分析工具、资源和提示模板，并通过 JSON-RPC 协议进行通信。

基于 Model Context Protocol (MCP) 的后端服务器，实现对资源、工具和提示模板的统一管理，并通过 JSON-RPC 与 LLM 客户端进行交互，支撑多传输协议的上下文服务与安全扩展能力。

基于 Model Context Protocol (MCP) 的 LeetCode 学习与练习后端，提供资源、工具、提示等标准化访问，并通过 JSON-RPC 形式对接大型语言模型客户端

在 Obsidian 中实现一个基于 Model Context Protocol 的 MCP 服务器，提供资源、工具与提示模板的后端服务，并通过 JSON-RPC 与客户端进行交互，支持并发会话、HTTP/HTTPS 传输以及安全访问控制。

基于 Titan Memory 的 Model Context Protocol (MCP) 服务器，采用 JSON-RPC 与客户端进行资源、工具、提示模板等上下文能力的标准化交互，支持多传输协议、会话管理与安全认证，面向 LLM 客户端提供可扩展的上下文服务框架。

基于模型上下文协议（MCP）的后端实现，提供对 Markdown 内容资源的托管与管理、工具注册与执行，以及可渲染的 Prompt 模板，供 LLM 客户端通过 JSON-RPC 进行资源读取、工具调用和提示渲染等交互，包含可运行的服务器端代码与完整工具集。

基于 Model Context Protocol (MCP) 的 Poznote 后端服务器实现，利用 FastMCP 在 HTTP 流式传输上通过 JSON-RPC 提供笔记资源、工具方法与数据访问能力，支持多用户环境与简易的扩展工具集。该服务器可让大语言模型（LLM）以统一、标准化的方式读取笔记、执行笔记操作、查询工作区与文件等上下文信息。

基于 Model Context Protocol 的 MCP 服务器实现，提供外部工具注册、资源管理和提示渲染等能力，并通过 JSON-RPC/stdio 等传输与客户端进行交互。

基于模型上下文协议（Model Context Protocol，MCP）的后端服务器实现，将 Infinity-API 的 FastAPI 应用通过 MCP 桥接暴露为可被 LLM 客户端通过 JSON-RPC 调用的上下文服务，支持资源、工具、提示等的统一管理与访问，并在同一应用中同时提供 REST API 与 MCP 服务。

基于模型上下文协议（MCP）的后端服务器实现，处理 JSON-RPC 请求，提供初始化、工具列表以及将 Claude 的 selections 写入本地文件的能力，并附带输入校验与日志记录。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 Laravel Workflow 的资源、工具与流程的 MCP 接口支持，允许 AI 客户端通过 JSON-RPC 向服务器发起启动工作流、查询状态等操作，并在 Laravel 应用内完成工作流调度与结果存储。

基于 Model Context Protocol (MCP) 的后端服务器实现，通过 HTTP 的 JSON-RPC 提供资源、工具和提示模板等能力给 LLM 客户端进行上下文查询与功能调用，核心与后台容器生命周期、网络/镜像等能力集成在一个可扩展的 MCP 服务端中。

基于 Model Context Protocol（MCP）的后端服务器，实现资源对接、工具注册/执行与提示模板渲染等能力，向大语言模型客户端提供标准化的上下文服务，通过 JSON-RPC 进行通信，支持多传输协议和会话管理，适用于多实例协同的上下文服务场景。

基于模型上下文协议（MCP）的后端服务，向大语言模型客户端提供依赖分析、风险评估、工具执行和提示渲染等能力。通过 JSON-RPC 与客户端通信，支持资源管理、工具注册、Prompts 定义与多种传输通道（如 Stdio），实现对后端分析流程的标准化上下文服务。

基于 Buttondown API 的 MCP 风格后端服务，为大语言模型客户端提供资源访问、工具调用和上下文渲染等能力。通过 JSON-RPC 与客户端通信，支持多种传输方式（如标准输入输出、SSE、WebSocket），实现对 Buttondown 邮件、订阅者等数据的安全、可扩展访问。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具与提示模板的管理以及 JSON-RPC 通信，支持标准化的上下文服务与多传输协议。

基于 Model Context Protocol 的 MCP 服务器实现，用于通过标准化的 JSON-RPC 接口向 LLM 客户端提供 Recharge API 的资源、工具和提示模板等上下文服务，并通过标准传输（如 stdio）与客户端进行通信。

基于 Model Context Protocol (MCP) 的 Manim 渲染后端服务器，提供资源托管、工具执行和 Prompts/模板的标准化接口，供 LLM 客户端通过 JSON-RPC 与后端进行资源读取、工具调用以及渲染作业管理等交互。

基于模型上下文协议（MCP）的知识库后端服务器实现，提供资源管理、工具执行以及提示模板等功能，并通过 JSON-RPC 与 LLM 客户端进行标准化交互，支持网络访问与安全认证。该仓库中存在实现 MCP 的服务器端代码（如 mcp_kb_server.py、feonix_kb_server.py 等），实现了 Initialize、Tools、Resources 等 MCP 端点及健康检查等功能。

基于 Rust 的 MCP 服务器实现，向 AI 客户端以标准化的 JSON-RPC 方式暴露会议记录的资源、工具和提示渲染能力，支持文档列表、检索、获取原始转写、同步、以及基于 OpenAI 的摘要等功能，方便将本地会议数据接入到 LLM 代理进行上下文查询与分析。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具注册与执行、Prompt 模板渲染等核心能力，通过 JSON-RPC 与客户端通信，并支持多种传输方式（如 Stdio、SSE、WebSocket）以构建面向 LLM 的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供多层内存管理、资源与工具治理，以及推理提示渲染，使用 JSON-RPC 的 MCP 标准通过标准输入输出（Stdio）等协议与 MCP 客户端通信，为 LLM 应用提供安全、可扩展的上下文服务。

基于模型上下文协议（MCP）的后端服务，向大型语言模型客户端提供资源、工具和提示模板的上下文能力，通过 JSON-RPC 的方式进行请求/响应，并支持多种传输协议（如 STDIO、SSE、WebSocket）以实现安全、可扩展的上下文服务框架。

将 Visa 的 TAP 与 MCP 集成的后端服务器，提供对资源、工具与 Prompt 的 MCP 风格暴露，并通过 JSON-RPC 与 LLM 客户端进行通信，支持 TAP 签名、ACRO/APC/JWKS 等安全机制，旨在为 AI 代理提供可扩展的上下文服务与功能调用能力。

基于 Model Context Protocol (MCP) 的服务器端实现，用于对代码项目进行上下文分析、向量化检索和外部工具调用的统一管理。通过 JSON-RPC 风格的 MCP 客户端通信，服务器端负责会话管理、能力声明，以及资源(向量/元数据)的托管、工具执行和 Prompt 模板的渲染。实现了完整的 MCP 服务端逻辑（8 个工具），并使用 ChromaDB 进行向量存储、OpenAI 模型进行代码分析与嵌入生成，提供本地 STDIO 传输的运行能力，同时包含一个可选的 Web 管理端供查看和管理索引数据。该实现可直接作为 MCP 服务器使用或作为开发参考与扩展。

基于 SAP HANA 的 MCP 服务器实现，提供资源/工具/Prompt 的暴露与管理，通过 JSON-RPC 与 AI 客户端通信，支持只读访问、鉴权、以及多传输协议的后端上下文服务。

基于 Model Context Protocol（MCP）的本地 MCP 服务器实现，提供对 Tools、Resources、Prompts 的标准化暴露，并通过 JSON-RPC 形式与客户端通信，支持通过标准输入输出（STDIN/STDOUT）进行请求与响应。

基于 Model Context Protocol（MCP）的后端服务器实现，向 LLM 客户端以标准化的 JSON-RPC 方式暴露资源管理、工具执行以及提示模板的能力，核心通过 registerTool 将大量 Google Workspace 相关操作暴露为可调用的工具集，支持以 Stdio 传输等多种通信方式进行上下文服务与会话管理。

基于 Model Context Protocol (MCP) 的后端服务，向大模型客户端以标准化方式提供资源、工具与提示模板等上下文能力；通过 JSON-RPC 与客户端通信，支持多传输协议（stdio、SSE、WebSocket），并实现会话管理、能力声明以及对 MCP 请求/响应的处理。

基于 Model Context Protocol (MCP) 的后端服务器，通过 Infura 提供对以太坊及多网络区块链数据的上下文服务、工具执行与提示模板渲染，支持 stdio 与 HTTP 两种传输模式，面向对话式 AI 客户端提供安全、可扩展的上下文能力。

基于 Model Context Protocol（MCP）的后端服务，提供统一的资源管理、工具注册与执行、Prompt 模板渲染等能力，通过 JSON-RPC 与 LLM 客户端通信，用于单位转换、维度分析与上下文服务等场景。该实现将 ucon 的单位/维度计算能力暴露为可被 AI 客户端调用的后端服务。

基于 Model Context Protocol 的完全实现级 MCP 服务器端，提供资源管理、工具注册与执行、以及 Prompts 定义与渲染，支持多传输协议并通过 JSON-RPC 与客户端通信，供 LLM 代理进行高效的上下文服务及能力扩展。

基于 Model Context Protocol (MCP) 的后端服务器，为 MCP 客户端提供 pyscn 的资源访问、工具注册/执行和提示模板渲染能力，通过 JSON-RPC 与客户端通信，支持多种传输通道并实现会话管理与能力声明。该实现以 pyscn 的命令行分析能力为核心，暴露给 AI 辅助工具集成使用。

基于 Model Context Protocol (MCP) 的后端服务器，实现对资源、工具和提示模板的标准化对外接口，通过 JSON-RPC/SSE 与 LLM 客户端进行交互，提供会话管理、能力声明以及多传输协议支持的 MCP 服务端能力。

基于 Model Context Protocol (MCP) 的本地化后端服务，嵌入式使用 FastAPI 提供 MCP 资源、工具和 Prompt 的注册、管理与渲染，并通过 JSON-RPC 与 LLM 客户端通信，支持会话管理和多种传输方式。

基于 AWS SageMaker 的 MCP 服务器实现示例，提供一个可运行的 MCP 服务端，用于注册并暴露一个 tooling（工具）给 LLM 客户端通过 MCP 协议进行调用。该示例直接使用 mcp.FastMCP 库，通过 stdio 传输启动服务，并注册一个将 SageMaker 请求转发到 SageMaker 推理端的工具。

基于 Model Context Protocol 的 MCP 服务器实现，向 LLM 客户端以标准化方式提供资源、工具与 Prompt 的注册、执行及渲染能力，并通过 JSON-RPC 进行通信，支持会话管理与多传输协议的后端上下文服务。

基于 Model Context Protocol (MCP) 的 JSON-RPC 服务端实现，暴露 plan、log、ask 等工具，并通过 /mcp 接口向客户端提供能力和上下文服务，用于与 LLM 的交互与协作。

基于 MCP（Model Context Protocol）的 Airflow 后端实现，提供标准化的资源、工具和提示模板的访问接口，支持会话管理、身份认证、跨传输协议通信，并通过 JSON-RPC 风格的请求/响应与 LLM 客户端交互。

基于 Model Context Protocol (MCP) 的多层后端服务，向大型语言模型客户端提供资源管理、工具执行与 Prompt 模板渲染等上下文与功能，支持多种传输通道（stdio、HTTP、WebSocket、UDP InterLock）实现可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的服务器实现样例，展示如何在后端注册工具与资源，并通过 Express HTTP 传输提供 JSON-RPC 风格的 MCP 服务。

基于 Model Context Protocol (MCP) 的后端服务，提供对多种数据库的资源管理、查询执行与数据导出能力，通过 JSON-RPC 与 LLM 客户端进行通信，并支持多种传输协议（如 STDIO），为大语言模型应用提供可扩展的数据库上下文服务。

基于 Model Context Protocol (MCP) 的服务器端实现，将 Mage Remote Run CLI 的命令注册为 MCP 工具，通过 TCP/STDIO 或 SSE 支持的传输协议向 LLM 客户端提供资源、工具执行能力与 Prompts 渲染等上下文服务。

基于 Model Context Protocol 的后端服务，向大语言模型（LLM）客户端提供 Currents 的测试与持续集成（CI）数据的资源、工具和提示模板，并通过 JSON-RPC 进行交互，以实现上下文信息托管、工具调用以及定制的对话模板渲染。

基于 Model Context Protocol (MCP) 的服务器端实现，提供对 Coda API 的资源、工具及交互能力的标准化访问，采用 JSON-RPC 进行通信，支持通过标准传输协议接入。该实现具备服务端会话管理、工具注册与执行、以及资源访问等核心能力。

一个基于 Model Context Protocol 的 MCP 服务器实现，使用标准的 JSON-RPC over STDIO 与 MCP 客户端通信，能够托管和管理资源、注册并执行工具、定义并渲染 Prompt，并为 LLM 客户端提供上下文服务和功能调用能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，向 LLM 客户端以标准化的 JSON-RPC 形式提供资源、工具和提示模板，支持会话管理、能力声明以及多传输协议接入，具备资源管理、工具注册、流程模板渲染等完整功能。该实现包含服务端核心组件、工具/资源注册、数据框架、以及与 Claude Desktop 等客户端对接所需的 stdio 传输入口。

基于 Model Context Protocol 的 MCP 服务器实现，用于以标准化的 JSON-RPC 方式向 LLM 客户端提供资源、工具及上下文相关功能，采用标准输入输出（STDIN/STDOUT）进行通信，便于 Claude Code 等客户端对接执行与查询。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行，以及提示模板的渲染，采用 JSON-RPC 通过标准输入输出与 LLM 客户端通信，支持插件化工具、会话管理与多种传输接口。

基于 Model Context Protocol (MCP) 的后端服务器，向大语言模型（如 Claude、ChatGPT）提供 DA（Document Authoring）资源、工具调用和提示模板等上下文能力，通过 JSON-RPC 与 MCP 客户端通信，并支持云端部署（Cloudflare Workers）、流式传输与简单的令牌鉴权。

基于 AtomCLI 的 Model Context Protocol (MCP) 服务器实现，向 LLM 客户端以标准化方式提供资源、工具、提示模版与会话管理等上下文能力，并通过 JSON-RPC 与客户端通信，支持多传输协议（如 Stdio、SSE、WebSocket）与灵活的配置扩展。

基于 Model Context Protocol (MCP) 的后端服务器，将 LLM 客户端对资源、工具、Prompt 等的标准化请求通过 JSON-RPC 转发给 nucleus-tool-proxy，并返回相应的 JSON-RPC 响应，支持审批、会话标识等能力。

基于 Model Context Protocol 的后端服务实现，提供资源、工具、Prompts 的注册与管理，并通过 JSON-RPC 与客户端通信，支持多传输协议（STDIO、SSE、WebSocket），实现会话管理和能力声明，用于为 LLM 客户端提供一致的上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端服务器，提供标准化的 JSON-RPC 接口，使 LLM 客户端能够读取资源、注册并执行工具、以及获取和渲染提示模板等上下文能力，用于支持以 AI 驱动的软件工厂工作流。

基于 Model Context Protocol (MCP) 的后端服务器，注册并暴露 AI 文本检测、AI 图像检测、抄袭检测和文本对比等工具，供 MCP 客户端通过 JSON-RPC 调用并进行安全、可扩展的上下文服务。

基于 MCP 协议的后端服务器实现，暴露 Wiz 灯具控制工具给可扩展的 LLM 客户端，通过 JSON-RPC 风格调用实现灯具状态查询与颜色控制等功能。

基于模型上下文协议（MCP）的后端服务器，向大语言模型客户端提供资源管理、工具执行与提示模板的统一上下文服务，并通过 JSON-RPC 与客户端进行通信。

基于 Model Context Protocol (MCP) 的后端服务器，为 LLM 客户端提供对瑞士法院判例数据的资源访问与工具调用，通过 JSON-RPC 在标准输入输出(stdio)传输，与客户端进行交互，支持搜索、获取判决、统计等功能。

基于 Model Context Protocol (MCP) 的服务器实现，作为 AI 助手与 Exegol 安全评估环境之间的中枢，为客户端提供标准化的上下文服务：托管与管理 Resources、注册与执行 Tools、定义与渲染 Prompts，并通过 JSON-RPC 与客户端进行通信与协作。该实现包含可运行的 MCP 服务器代码及相关工具、资源和工作流集成，适配本地开发及容器化部署场景。

基于 Model Context Protocol (MCP) 的后端服务，向支持 MCP 的大语言模型客户端提供视频上下文资源、工具与提示模板，通过 JSON-RPC 进行统一通信，并可通过标准化传输协议（如_stdio、SSE、WebSocket）实现会话管理与能力声明，作为视频理解型 LLM 应用的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供从 SEC EDGAR 提取的 filings、财务数据与指标的工具接口，并通过 JSON-RPC 与大语言模型客户端进行通信。

基于 MCP 协议的后端服务，提供资源、工具、提示模板等的托管、注册、执行与渲染，通过 JSON-RPC 与 LLM 客户端通信，当前实现支持基于标准输入输出的简单传输模式，便于与模型对话系统进行上下文服务和功能调用协作。

基于 Model Context Protocol 的 MCP 服务器实现，作为 Grafana 插件后端，负载资源管理、工具注册与执行、提示渲染等功能，并通过 JSON-RPC 与客户端通信，支持多传输协议、RBAC、多租户等场景的上下文服务框架。

一个包含多种 MCP 服务实现和协调网关的综合后端，提供资源管理、工具注册与执行、提示模板渲染等 MCP 功能；通过 JSON-RPC 风格的请求/响应在各 MCP 服务之间路由调用，并提供多传输与完整的监控能力（如 PostgreSQL、Redis、Grafana/Loki 等）。该仓库实现了 MCP 服务器模板、网关协调、工具路由、以及多模型/多服务的协同工作能力，适合作为 LLM 客户端的上下文与功能服务后端。

基于 Model Context Protocol (MCP) 的后端服务实现，为大型语言模型客户端提供统一的上下文资源、工具调用和提示模板渲染能力，并通过 JSON-RPC 进行通信，支持多服务器协作（如 JIRA、GitHub 及任务队列等）。

基于 Model Context Protocol 的服务器实现，用于向 LLM 客户端以标准化的 JSON-RPC 方式提供浏览器资源、工具执行能力与提示模板，并支持资源管理、工具注册、提示渲染以及会话/状态管理等多模态上下文服务。该实现把浏览器自动化能力暴露为 MCP 工具集，方便 Claude Desktop/Code 等 MCP 客户端接入和协同工作。

基于 Model Context Protocol (MCP) 的后端实现，提供对 Unified Hi-Fi Control 桥接器的工具集访问能力，通过 JSON-RPC 与 Claude 等 LLM 客户端进行交互，支持以统一接口调用中控工具并获取响应。

基于 Model Context Protocol (MCP) 的服务端实现，作为 CompText Codex 的后端上下文服务，向 MCP 客户端暴露工具清单、执行工具调用、以及初始化能力声明等接口。通过将 Codex 中注册的命令工具对外暴露，MCP 客户端能够读取资源、调用工具、以及获取提示/模板等相关能力信息，并在会话中实现上下文管理与跨模块协作。目前实现提供工具列出、工具执行和初始化响应等核心能力，属于可直接在应用中集成的 MCP 服务器端组件。

基于 Model Context Protocol (MCP) 的服务端实现，向大型语言模型客户端以标准化方式提供资源、工具与对话上下文能力，支持 JSON-RPC 交互并集成多源数据健康与替代项查询。

基于 Model Context Protocol 的 MCP 服务器实现，向 LLM 客户端提供资源托管、工具注册与执行，以及可渲染的 Prompt 模板等标准化上下文服务，支持多种传输协议（如 SSE、HTTP）并通过 JSON-RPC 与客户端交互。

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具、提示模板等上下文信息的管理与执行，并通过 JSON-RPC 与 MCP 客户端进行通信，支持并发执行、会话管理与多种传输方式以支持对话型 AI 应用。

基于 Model Context Protocol 的 MCP 服务器实现，向大语言模型客户端提供资源数据、工具执行能力和 Prompt 模板渲染等上下文服务，支持通过标准化的 JSON-RPC 方式交互，并可通过 STDIO、SSE/HTTP 等传输协议进行通信与会话管理。

基于 MCP 协议的后端服务器，暴露 Arena PLM REST API 的查询与数据获取能力，供大语言模型客户端通过 JSON-RPC 调用工具、读取资源并渲染提示模板。

基于 Model Context Protocol 的 MCP 服务器实现，向大模型客户端提供工具、资源与提示的托管、执行和渲染能力，并通过 JSON-RPC 与客户端通信，用于在 Gemini 等环境中通过 tmux 代理执行自引用命令、后台任务和日志监控等功能。

基于 Model Context Protocol（MCP）的后端实现，向大语言模型客户端提供测试管理的上下文、资源、工具及提示模板渲染，并通过 JSON-RPC 的 MCP 协议与客户端进行通信与协作。

一个基于 Model Context Protocol (MCP) 的服务器实现与示例集合，包含使用 FastMCP 的 Python 版本服务器、SSE 与 Streamable HTTP 传输模式，以及用于注册工具、提示、资源等组件的示例脚本，支持通过 JSON-RPC 与客户端进行资源访问、工具调用、提示获取等上下文服务的交互，适合对接 LLM 客户端进行 MCP 服务端能力测试、扩展与演示。

基于 Model Context Protocol (MCP) 的 Gemini 模型后端实现，提供资源、工具和提示模板的上下文服务，通过 JSON-RPC 与客户端通信，并以 stdio 传输实现 MCP 服务器。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 SQLite 数据库的资源、工具与提示的标准化上下文服务，支持原生与 WASM 两种后端、OAuth 2.1 身份认证、JSON-RPC 通信以及 HTTP/SSE/stdio 等传输方式，面向 LLM 客户端进行可扩展的上下文与功能托管。

基于 Model Context Protocol（MCP）的后端服务器，作为与大语言模型（LLM）客户端的标准化上下文服务入口，提供资源管理、工具注册/执行以及提示模板的渲染能力，支持 JSON-RPC 交互与多种传输模式（如 stdin/stdout、SSE、WebSocket），并具备会话管理、能力声明和动态工具发现等特性。该服务器以 kubectl-mtv 项目内的实现为基础，能够与客户端通过 JSON-RPC 请求交互，提供迁移相关的资源、工具及提示信息的上下文服务。

基于 Model Context Protocol (MCP) 的后端实现，提供内存资源管理、工具执行以及提示模板渲染等能力，通过 JSON-RPC 在标准输入输出（STDIO）与 LLM 客户端进行通信，支持多种内部传输与会话管理，用于向 LLM 客户端提供可访问的上下文信息与功能。

基于 Model Context Protocol 的 MCP 服务器实现，提供对 Reactive Resume 的资源、工具与提示模板的标准化访问，支持通过 JSON-RPC 与 LLM 客户端交互，完成简历管理、编辑及导出等能力的远程调用。

一个基于 Model Context Protocol（MCP）的 OmniFocus MCP 服务器实现，提供以标准化方式向 LLM 客户端暴露上下文数据、工具和提示模板的能力。服务器端处理 MCP 请求并返回 JSON-RPC 风格的响应，配合 macOS 环境的 OmniFocus 插件桥接实现，实现任务、项目、标签等数据的查询与管理。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源索引查询、工具调用与提示渲染能力；通过 JSON-RPC（以标准输入输出传输）与客户端进行通信，支持会话管理、能力声明和简单的状态监控，便于将本地代码库上下文提供给大语言模型客户端使用。

基于模型上下文协议（MCP）的后端网关与服务器聚合实现，能够将多个后端MCP服务器 behind 一个统一入口进行托管、注册工具并通过JSON-RPC进行交互与通知。

基于 Model Context Protocol (MCP) 的后端服务，向大型语言模型（LLM）客户端提供 Griffin API 的资源、工具和提示模板，并通过 JSON-RPC 进行交互，支持 STDIO 传输等多种传输方式，帮助在对话中访问和操作银行相关数据。

基于 Model Context Protocol (MCP) 的服务器端实现，提供通过 JSON-RPC/MCP 风格请求处理资源、工具与提示模板等功能，以及对代理人会话、工具注册、资源管理和跨进程通信的完整支持，底层以 relay-pty 提供的 UNIX 套接字和 PTY 注入机制实现，具备多种传输与扩展能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供将速率测试后端数据以 MCP 标准暴露给大语言模型客户端的能力；通过 JSON-RPC 风格的输入输出，在 stdin/stdout 方式下与客户端对话，支持初始化、工具列表与工具调用等核心功能，便于搭建可扩展的 LLM 辅助上下文服务入口。

基于 Model Context Protocol (MCP) 的后端服务器，向 LLM 客户端以标准化的 JSON-RPC 方式暴露 Flutter 应用的资源/工具/提示模板等上下文信息，并通过多传输协议实现会话管理、能力声明与扩展能力，帮助 AI Agent 在 Flutter 应用中进行自动化控制与测试。

基于 Model Context Protocol (MCP) 的服务器实现，将 Max/MSP 的补丁、对象、工具等上下文信息以标准化的 JSON-RPC 形式提供给 MCP 客户端（如 Claude Code 这类集成工具），支持通过 WebSocket 与 stdio 两种传输通道进行通信，并包含对多补丁、工具集、资源访问、以及补丁渲染模板等功能的实现与管理。

基于 Model Context Protocol 的 MCP 服务器实现，将本地技能暴露为 MCP 工具，支持 Claude Code、GitHub Copilot 等代理直接调用技能，从而实现本地技能的 Agent-Native 访问与执行。

基于 Model Context Protocol（MCP）的后端服务，向 MCP 客户端提供资源、工具和提示模板等上下文能力，支持通过 JSON-RPC 与客户端通信，并可通过多种传输方式（stdio、SSE/HTTP）进行交互。

基于 Model Context Protocol 的云端 WordPress MCP 服务器实现，运行在 Cloudflare Workers，提供多租户的资源、工具和 Prompt 管理能力，并通过 MCP JSON-RPC 协议与客户端进行交互。

基于 Model Context Protocol 的 MCP 服务端实现，用于向 LLM 客户端提供资源、工具和提示模板的标准化上下文与功能服务，支持多传输协议并通过 JSON-RPC 进行通信。

基于 Model Context Protocol 的 FRM 后端实现，作为 FRM Desktop 应用的一部分，提供 MCP 服务端能力：注册并执行 FRM 的工具、托管与访问资源、渲染与提供 Prompt 模板等，并通过 JSON-RPC 与客户端通信。当前实现将 MCP 服务运行在 Electron 的主进程中，使用 InMemoryTransport 进行本地通信，适合作为本地集成的 MCP 服务端示例。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具注册与执行、Prompt 模板渲染，并通过 JSON-RPC 与客户端通信，支持本地 IPC 与 WebSocket 等传输方式，面向 LLM 客户端提供可扩展的上下文服务。

基于 Model Context Protocol 的后端服务器实现，向大型语言模型客户端提供资源管理、工具注册/执行、以及可渲染的 Prompt 模板，并通过 JSON-RPC 进行通信，支持标准输入输出（stdio）传输等多种传输协议，以实现统一的上下文服务和外部功能访问。

基于 Model Context Protocol (MCP) 的后端实现，作为 StoreConfig 的 MCP 服务器，向 LLM 客户端提供 JSON 结构化的资源、工具和上下文内容，支持通过 JSON-RPC 的请求/响应方式进行资源查询、工具执行、以及对配置模板的交互渲染，帮助 AI 辅助的配置管理场景。

基于 Model Context Protocol (MCP) 的后端服务器，为大语言模型客户端提供 MDN 文档、浏览器兼容性数据与搜索等资源，并通过 JSON-RPC 的 MCP 协议进行交互，支持工具注册、日志与错误上报等扩展能力。

基于 Model Context Protocol 的后端服务器，提供资源、工具与提示模板的托管与管理，并通过 JSON-RPC 与 LLM 客户端通信，支持会话管理、跨传输协议接入，具备嵌入向量、图谱化决策存储等能力，适用于 Claude Code/Desktop/OpenClaw 等环境的上下文服务与功能扩展。

基于 Model Context Protocol (MCP) 的 Mollie API 服务端，向大型语言模型（LLM）客户端以标准化方式提供 Mollie 支付信息、查询工具与 prompts，通过 JSON-RPC 与客户端通信并通过标准传输（如 Stdio）实现扩展性与会话管理。

基于 Model Context Protocol 的 MCP 服务器实现，向大语言模型客户端提供资源/工具的注册、查询与执行，并通过 JSON-RPC 进行通信以实现后端上下文服务。

基于 MemFlow 的 MCP 服务器实现，向大型语言模型客户端提供 Obsidian Vault 的上下文、资源访问、工具执行与可定制的提示模板等能力；通过 JSON-RPC/HTTP 及标准输入输出等多种传输方式与客户端进行交互，并支持本地化、隐私优先的上下文服务。

LightMem 的 MCP 服务端实现，使用 Model Context Protocol 提供资源、工具与提示模板的注册与执行，以 JSON-RPC 形式与 LLM 客户端交互。

基于 Model Context Protocol 的 MCP 服务器端实现，提供资源管理、工具注册与执行，以及 Prompt 模板渲染等能力，面向大语言模型（LLM）客户端提供标准化的上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，用于向大语言模型客户端提供包生态数据的上下文和查询工具；在本地 SQLite 数据库可用时优先使用本地数据，无法时回退到远端 API；通过 JSON-RPC 提供工具调用、健康检查等能力，支持标准的 stdio 通道进行通信。

基于 GraphJin 的 MCP 服务器实现，为 LLM 客户端提供标准化的上下文服务，包含资源管理、工具注册和提示模板等上下文能力，支持通过 STDIO 和 HTTP 代理两种传输模式进行 JSON-RPC 通信，方便与 Claude Desktop 等 AI 助手对接。

基于 Model Context Protocol (MCP) 的后端服务器，向大语言模型客户端以标准化方式提供上下文信息与能力。服务器托管资源、注册并执行工具、定义与渲染 Prompt 模板；通过 JSON-RPC 进行通信，支持会话管理、能力声明，并可通过多种传输途径如标准输入输出、SSE、WebSocket 等与客户端协作，构建安全、可扩展的代码上下文服务框架。

基于 Model Context Protocol (MCP) 的服务器端实现，提供一个后端框架用于向 LLM 客户端以标准化方式暴露资源、工具和提示模板，并能对接和聚合多个外部 MCP 服务器进行统一管理与调用。

基于 Model Context Protocol 的 MVP MCP 服务器实现，提供知识分析、沉淀与存储能力，通过标准化的 JSON-RPC 交互向 LLM 客户端提供资源、工具和提示模板等能力，支持标准的 STDIO 通信模式，适合作为后端知识上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，为 OpenClaw 等 LLM 客户端提供标准化的资源、工具和提示模板服务，支持 StdIO/HTTP SSE 等传输方式，通过 JSON-RPC 与客户端通信并暴露 MCP 工具与服务器信息。

基于 Model Context Protocol (MCP) 的服务器端实现，提供资源(Resource)、工具(Tools)和提示模板(Prompts)的注册、管理与渲染，并通过 JSON-RPC 与 LLM 客户端进行通信，支持多传输协议（如 Stdio、HTTP 流和 SSE）。实现了会话管理、能力声明以及对外暴露的内存引擎（OpenMemory/SQlite），可用于在本地或远程环境中为LLM客户端提供统一的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器集合，提供资源管理、工具执行和提示/模板渲染，并通过 JSON-RPC 与 LLM 客户端通信；底座集成 ZenML 进行生产级管道编排，支持多种传输方式与会话管理，构建可扩展的上下文服务框架。该仓库实现了多个 MCP 服务器单元及其客户端集成，具备可运行的服务端代码与示例用例。

基于 Model Context Protocol (MCP) 的后端服务，实现对 Obsidian 记忆库的读写、资源管理与工具执行的统一接口，提供 JSON-RPC 风格的请求/响应，包含认证、日志、路由与可扩展的插件架构，支持与多种前端/LLM 客户端协作。

基于模型上下文协议（MCP）的后端服务器实现，提供通过 MCP 客户端以标准化 JSON-RPC 方式访问 Bitbucket Cloud 的资源、工具和提示模板，支持在 stdio 传输下与 LLM 应用对接。

基于 Model Context Protocol (MCP) 的 ShipUI 后端实现，提供资源托管、工具注册与执行、以及提示模板的 MCP 服务端，能通过 JSON-RPC 与各类 MCP 客户端通信，支持标准的会话管理与多传输通道（如标准输入输出）。

基于 Model Context Protocol 的 MCP 服务器实现，能够托管 Dynatrace Managed 环境的资源、注册并执行工具、定义并渲染提示模板，并通过 JSON-RPC 与多环境客户端进行通信，提供本地或远程传输模式的上下文服务与能力声明。中间集成了对资源、工具、提示、以及多环境 Dynatrace 数据的统一管理与查询能力。

基于 Model Context Protocol（MCP）的本地后端实现，向大型语言模型客户端以标准化的 JSON-RPC 方式提供资源管理、工具执行以及提示模板渲染能力，包含会话管理、能力声明，并支持多传输通道（以 stdio 为主）实现一个可扩展的上下文服务框架。

基于 Model Context Protocol 的多服务器后端实现，向 LLM 客户端提供资源、工具及可渲染的提示模板等上下文服务，通过 JSON-RPC 与客户端进行通信，支持多种传输方式，具备注册、管理、执行工具以及安全治理等能力。

基于 Model Context Protocol 的 MCP 服务器，提供资源、工具与提示模板的后端服务，通过 JSON-RPC 与 MCP 客户端通信，内置对 Mackerel API 的多工具封装，支持多传输通道（如标准输入输出、SSE、WebSocket）以向大语言模型客户端提供可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务实现，专门暴露 PaperQA2 检索能力给 LLM 客户端。通过 MCP 框架提供 JSON-RPC 风格的请求/响应接口，支持检索上下文片段、列出可用索引及查询索引状态等功能，适用于嵌入式上下文服务场景。

基于 Model Context Protocol (MCP) 的后端服务器，向大语言模型客户端暴露工具（Tools）与外部数据源访问能力，通过 JSON-RPC 风格的请求/响应进行交互，并支持 STDIO 传输以便与本地或嵌入式 LLM 集成。

基于 Model Context Protocol (MCP) 的后端服务器，向 MCP 客户端提供资源（数据访问）、工具（可执行外部功能）以及提示模板（Prompts）的统一上下文服务，采用 JSON-RPC 与客户端通讯，支持本地/标准化传输方式，集成 Notion 发表与 GitHub 数据源等能力，面向 AI 驱动的工程上下文工作流。

基于 MCP Apps 规范的后端服务实现，提供资源的注册与管理、工具的注册与执行、以及按规范渲染与传递 UI 资源，支持多主机环境并通过 JSON-RPC 与客户端通信，包含服务端核心逻辑、中间件、实验性扩展与测试用例。

基于 Model Context Protocol (MCP) 的轻量级后端服务器，提供对 LLM 客户端的上下文服务（资源、工具、提示等），通过 JSON-RPC 进行通信，支持以标准化方式读取资源、注册并执行工具、渲染 Prompt 模板，核心实现包含服务器端的请求/响应处理、会话管理与多传输协议支持（以 stdio 为核心的实现，具备行分隔及 Content-Length framing 方式）。

基于 Model Context Protocol 的后端服务器，向大语言模型（LLM）客户端以标准化的 JSON-RPC 形式提供资源、工具和提示模板等上下文服务，并通过 SSE/HTTP 等传输协议实现资源托管、工具注册与 Prompt 渲染等核心能力。

基于 Model Context Protocol 的完整 MCP 服务器实现，提供浏览器端边缘节点与远程代理之间的 JSON-RPC 通信、资源与工具管理、事件存储/查询，以及多会话、多标签下的工具路由等能力，支持 WebSocket 与 HTTP 传输。该仓库不仅包含前端边缘设备的实现，还实现了用于代理端的 Node.js 服务器、以及与 MCP 协议对接的服务端组件，形成一套较完整的 MCP 服务端生态。]

基于 Model Context Protocol (MCP) 的后端服务，提供统一的资源管理、工具调用和提示渲染能力，以便向大模型客户端（LLM）提供可访问的上下文信息和功能。实现包含对资源（Memory）的托管、工具注册与执行，以及对提示/上下文的组织与渲染，支持通过标准输入输出（stdio）以及 TCP/HTTP 钩子等多种传输方式进行 JSON-RPC 交互。

基于模型上下文协议（Model Context Protocol, MCP）的后端服务器实现，提供任务看板数据、工具方法以及提示模板等上下文能力，面向大语言模型客户端以 JSON-RPC 方式交互。支持本地化存储、可扩展的工具集合以及基于 MCP 的工具执行与上下文渲染能力。

基于 Model Context Protocol (MCP) 的 Bedrock 模型信息查询与管理服务器，提供模型提供商、模型列表和推理配置等资源，支持以标准化 JSON-RPC 形式与客户端进行交互。

基于 Model Context Protocol (MCP) 的 Java 实现的 MCP 服务器端，提供对资源、工具、提示的注册与执行，以及会话管理与多传输协议（REST/Servlet/SSE、Streamable HTTP）的支持，通过 JSON-RPC 与客户端进行通信。

基于 Model Context Protocol (MCP) 的后端服务实现，提供对资源(Resource)、工具(Tools)及提示模板(Prompts)的管理与执行能力，并通过标准的 JSON-RPC 与客户端进行通信。支持多服务器配置、OAuth 与微支付等扩展能力，能够作为 LLM 客户端的上下文与功能提供端。

基于 Model Context Protocol 的可扩展后端，提供资源、工具与提示模板的 MCP 服务，通过 JSON-RPC 与 LLM 客户端交互，支持插件化视觉分析能力和多种传输方式。整个体系以 FastAPI/uv 工具链实现服务器端能力管理与会话管理。

基于 Model Context Protocol（MCP）的后端服务器实现，提供对任务、代理人与消息等资源的管理，并通过 MCP 定义的工具接口向 LLM 客户端暴露可执行工具，支持通过标准的 JSON-RPC 风格请求与响应进行交互，传输可通过 STDIO（标准输入输出）实现，便于与 AI 模型或代理进行上下文协作。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行、提示模板渲染，并通过 MCP 外部端点集成远程工具，支持 AG-UI 协议与 JSON-RPC 风格通信，适配多传输通道（如 WebSocket、轮询等）以为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的后端服务器实现，向大型语言模型（LLM）客户端提供资源管理、工具执行和 Prompt 模板渲染等标准化上下文服务，并通过 JSON-RPC 与客户端通信，支持 Stdio、HTTP 等传输模式与 UCP 发现、证据化资产流转能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（Resources）托管与访问、工具（Tools）注册与执行、以及 Prompt 模板的自定义渲染，使用 JSON-RPC 与客户端通信，支持会话管理、能力声明并可通过多种传输协议（如 Stdio、SSE、WebSocket）对外暴露上下文服务，适用于让 LLM 客户端按统一协议获取上下文与外部功能。

基于 Model Context Protocol (MCP) 的后端服务，作为 MCP 服务器向 LLM 客户端提供资源管理、工具注册与执行、以及 Prompt 模板渲染等上下文能力；通过 JSON-RPC（NDJSON/多传输协议）与客户端通信，支持会话管理、模型切换、跨服务协同等扩展能力，适配多种传输协议（如 Stdio、SSE、WebSocket）以为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管与访问、工具注册与调用、以及提示模板的定义与渲染能力，并通过 JSON-RPC 与 LLM 客户端进行通信，支持多种传输方式（如 STDIO、HTTP、WebSocket 等），用于为大语言模型提供统一的上下文与功能服务。

基于 Model Context Protocol 的 MCP 服务器实现，提供任务、时间块、子任务、用户等资源的管理和工具注册，面向 LLM 客户端通过 JSON-RPC 进行统一上下文服务与能力调用，支持 Stdio 等传输协议。)

基于 Model Context Protocol（MCP）的后端服务器集合，向大型语言模型客户端以标准化方式提供上下文信息与功能，包括托管资源、注册与执行工具，以及定义/渲染提示模板；支持多种传输协议（Stdio、SSE、HTTP），通过 JSON-RPC 与客户端通信，适用于 Claude Code 等工作流场景。

基于 Model Context Protocol (MCP) 的后端服务，提供资源与工具的注册、对接外部数据源，并通过 JSON-RPC/stdio 方式与 MCP 客户端通信，以支持 LLM 场景下的上下文、工具调用与提示模板渲染。

基于 Model Context Protocol（MCP）的后端服务器实现集合，提供 Tavily 与 Brave 的统一工具表面、密钥管理、鉴权以及 Admin UI 配套，支持通过 JSON-RPC 的 /mcp 端点进行资源访问、工具调用与 Prompt 渲染等核心 MCP 功能。

基于 Model Context Protocol (MCP) 的后端服务，提供资源、工具、提示模板等上下文能力，支持通过 JSON-RPC 与 AI 客户端进行资源读取、工具调用和提示渲染，并实现会话管理、能力声明与多种传输协议的扩展性，为 AI 代理提供稳定的上下文记忆和操作能力。

基于 Model Context Protocol（MCP）的后端服务器，向 MCP 客户端以标准化的 JSON-RPC 方式提供对离线邮件存档的上下文信息、资源访问、工具执行以及提示模板渲染等能力，便于与 Claude Desktop 等 MCP 客户端进行深度集成与对话式分析。该实现包含服务器端代码、会话管理与资源查询逻辑，支持通过多种传输通道与安全的本地部署方式进行扩展使用。

基于 Model Context Protocol 的 MCP 后端实现，提供资源管理、工具注册与执行、以及提示模板渲染等核心能力，并通过 JSON-RPC 与客户端进行交互，具备会话管理与多传输通道支持，适用于向大语言模型客户端提供结构化上下文与外部功能入口。

基于 Veritas Kanban 的 MCP 服务器实现，提供以 JSON-RPC 方式向 AI 助手/客户端暴露资源、工具、提示模板等上下文能力的后端服务，并支持多传输通道与会话管理。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大模型客户端提供可读的资源、可注册并执行的工具，以及可渲染的提示模板，采用 JSON-RPC 形式在 stdio、HTTP（Streamable HTTP/SSE）等传输协议下进行通信，支持会话管理、能力声明与多传输通道扩展。该仓库同时提供完整的服务端实现与配套客户端示例，便于将大模型接入为上下文服务与外部功能入口。

基于 Model Context Protocol（MCP）实现的服务器端，提供对 Kubani Registry 的资源、端点、模型、部署等元数据的标准化访问和工具调用入口，供大语言模型客户端进行上下文获取、功能调用与数据渲染等协作操作。

基于模型上下文协议的简单MCP服务器实现，提供工具注册与执行、资源管理、以及Prompt/模板等核心能力，采用JSON-RPC通过标准输入输出（stdio）与客户端通信，便于教育演示和本地测试。

基于 Model Context Protocol (MCP) 的服务器实现，注册并暴露一组用于文件检索、文档管理与查询的工具，供大语言模型客户端通过 JSON-RPC 调用、统一上下文信息与功能。

Patina 是基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源、工具、提示模板等上下文相关能力，通过 JSON-RPC 与 LLM 客户端通信，并支持多传输协议（如 Stdio、SSE、WebSocket）以便对接不同的客户端。该仓库包含实现 MCP 协议的服务端组件及相关基础设施，用于在本地或容器化环境中托管上下文数据与外部功能。

基于 Model Context Protocol (MCP) 的在进程内 Ruby 实现的 MCP 服务器，用于向 Claude Agent 提供工具、资源和提示等上下文能力，并通过 JSON-RPC 风格的 MCP 协议进行通信。

基于 Model Context Protocol (MCP) 的后台服务实现，用于暴露并管理资源、工具和提示模板给 LLM 客户端（通过 JSON-RPC），并提供 HTTP/STDIO 传输、健康端点与Creds 集成等核心能力。

基于模型上下文协议（MCP）的 Rust 实现框架，提供标准化的服务端能力以向 LLM 客户端暴露资源、工具和提示，并通过 JSON-RPC 进行通信，附带测试服务器示例以验证协议交互和渲染输出。

基于 Model Context Protocol (MCP) 的后端服务器实现，负责以标准化的 JSON-RPC 方式向 LLM 客户端提供资源管理、工具注册/执行以及 Prompts 渲染等能力，并支持多传输协议（如 Stdio、SSE、WebSocket），实现会话管理、能力声明和可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供 maestro_status 工具用于向 Maestro UI 汇报会话状态，并通过 JSON-RPC 与客户端交互，支持 initialize、tools/list、tools/call、notifications/initialized 等消息。服务器通过 STDIO 与 MCP 客户端通信，兼容 Maestro 的状态上报与会话管理，集成在 Maestro 的 Tauri 应用中用于多会话上下文服务。

基于 Model Context Protocol (MCP) 的多租户后端服务器，实现资源管理、工具注册与执行、以及 Prompt 模板渲染等功能，并通过 JSON-RPC 与客户端进行通信，支持 HTTP/Streamable HTTP 和 SSE 等传输协议。

基于 Model Context Protocol (MCP) 的后端服务器，提供会话线程的托管与管理、工具注册与执行、以及输出格式的渲染；通过 JSON-RPC 与 MCP 客户端通信，支持本地与远程存储，以及通过标准输入输出（stdio）等传输方式进行交互，适用于在 LLM 应用中提供上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源、工具与 Prompt 模板的注册、管理、执行与渲染，并通过 JSON-RPC 与客户端进行通信，支持多种传输方式与会话管理，便于 LLM 客户端获取上下文信息与外部功能。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具执行与提示模板渲染等核心能力，并通过 JSON-RPC 与客户端通信，支持 stdio 与 HTTP 两种传输模式，便于将 AI 助手接入 Phoebe API 的上下文与功能。

基于 Model Context Protocol (MCP) 的后端服务器，将 Hono API 端点暴露为 MCP 工具，核心实现包括资源托管、工具注册/执行、提示模板渲染，并通过 JSON-RPC 与客户端通信，支持多种传输协议（如 Stdio、SSE、WebSocket），为 LLM 客户端提供安全、可扩展的上下文服务。

基于 Model Context Protocol 的后端服务器，向大语言模型客户端提供资源管理、工具注册与执行、以及可渲染的提示模板等上下文服务；通过 JSON-RPC 进行请求/响应，并支持会话管理、能力声明与多传输协议（如 Stdio、SSE、WebSocket）的扩展能力。

基于模型上下文协议（MCP）的后端服务器实现，提供资源管理、工具调用与提示模板渲染的标准化上下文服务，并通过 JSON-RPC 与 Claude Code 等客户端交互，支持可扩展的传输模式与会话管理。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源发现、工具注册与执行、以及通过 JSON-RPC 与 LLM 客户端交互的能力，用于向 LLM 应用提供上下文信息与外部功能。该服务器以 MCP 规范为核心，托管并管理资源、注册工具、渲染提示模板等，支持标准的请求/响应流程。

基于 MCP（Model Context Protocol）的后端服务器，实现对资源、工具和提示模板的统一管理与渲染，并通过 JSON-RPC 与 LLM 客户端进行交互，支持多传输协议以适配不同应用场景。

基于 Model Context Protocol 的后端服务实现，提供资源、工具、提示等统一管理，并通过 JSON-RPC 与 LLM 客户端进行交互，支持多种传输方式（如 SSE）。完整的 MCP 服务器端实现，包含服务初始化、挑战/结果管理、评测与分析、以及对外暴露的健康端点。

基于 Model Context Protocol (MCP) 的后端实现，作为 LLM 客户端的上下文服务提供者，托管与管理 Resources（资源）、Tools（工具）以及 Prompts（提示模板），并通过 JSON-RPC 与客户端进行请求/响应通信，支持多传输协议（如 Stdio、SSE、WebSocket），为 LLM 应用提供安全、可扩展的上下文服务框架。

本仓库提供基于 MCP 的服务器实现示例，包含 JavaScript 与 Java 两种实现，展示如何注册工具、提供能力、以及通过标准化的 JSON-RPC 与 LLM 客户端交互，支持多种传输协议并进行会话与能力声明管理。

基于 Model Context Protocol 的后端服务，使用 FastAPI 构建，提供资源、工具与提示模板等 MCP 功能，并通过 JSON-RPC 与客户端通信为大型语言模型客户端提供上下文和能力服务（如资源访问、工具调用与提示渲染）。服务器通过对外暴露的 MCP 路由实现对接、会话管理与多传输协议的支持（如 SSE/StdIo/WebSocket 等），以实现可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务，向 LLM 客户端通过标准化的 JSON-RPC 方式提供资源、工具与提示模板等上下文信息，并支持开发/生产两种模式、以及通过标准传输通道进行通信。

基于模型上下文协议（MCP）的后端服务器，将 CyberChef 的海量数据处理操作和工具暴露给对话式AI客户端，支持资源管理、工具注册与执行，以及可定制的提示模板渲染，且通过 JSON-RPC 与客户端通信，覆盖多种传输方式（STDIO、HTTP、SSE、WebSocket），帮助生成式AI在执行数据处理任务时获得稳定、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源托管与管理、注册与执行工具、以及 Prompt 模板的定义与渲染，面向大型语言模型（LLM）客户端，通过 JSON-RPC 与客户端通信，并支持会话管理、能力声明以及多种传输协议（如 Stdio、SSE、WebSocket）以实现安全、可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供对 Sirchmunk 的资源托管、工具注册与执行，以及提示模板渲染等能力，向 LLM 客户端以标准化的 JSON-RPC 方式提供上下文与功能服务。

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具、提示模板的托管与执行，并通过 JSON-RPC 形式对接 LLM 客户端，支持多传输方式（如标准输入输出/HTTP），为 LLM 应用提供安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端实现，围绕资源管理、工具注册/执行和提示模板渲染，提供通过 JSON-RPC 与 LLM 客户端通信的服务器能力，并在内置组件之间暴露资源、工具、提示等接口，支持多种传输方式与会话管理。该仓库包含用于 Memory/Task/A2A/Events 的 MCP 相关服务端实现以及一个用于启动 MCP 服务器的命令行接口。

基于 Farnsworth 的 Model Context Protocol(MCP) 服务端实现；通过 MCP 协议向 MCP 客户端暴露资源管理、工具注册/执行以及提示模板等能力，支持多传输协议（如 Stdio、SSE、WebSocket），并实现会话管理与能力声明，提供一个安全、可扩展的上下文服务后端。

基于 Model Context Protocol (MCP) 的后端服务，连接 PostgreSQL 数据库，为大语言模型客户端提供统一的资源、工具和上下文能力，以实现安全、可扩展的上下文访问与操作。

基于 Model Context Protocol（MCP）的服务器端实现，为 Claude Code 插件提供一个“交互式 Markdown 审阅”工具。通过 MCP 的 JSON-RPC 风格调用，LLM 客户端可以注册工具、读取可用工具、调用 start_review 进行 Markdown 内容审阅，并在本地浏览器中以交互界面收集审核结果，服务器再返回结构化结果。

基于 Model Context Protocol(MCP) 的后端服务器实现，提供资源管理、工具注册与调用、以及 Prompt 模板渲染等能力，供 LLM 客户端以标准化方式获取上下文、数据与外部功能。

基于 Model Context Protocol (MCP) 的完整服务器端实现与示例，提供 JSON-RPC 2.0 交互、Stdio/HTTP 等传输、资源/工具/提示的管理，以及会话与扩展能力，面向将 MCP 服务化以供 LLM 客户端调用的后端应用。

基于 Model Context Protocol (MCP) 的后端服务实现，提供资源托管、工具注册与执行、以及 Prompt 模板渲染，向 LLM 客户端以标准化的 JSON-RPC 方式提供上下文、数据访问和外部功能调用能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供工具拦截、策略评估、人工同意、凭证注入与审计日志等核心能力，并通过 JSON-RPC 与 MCP 客户端进行通信，支持与上游 MCP 服务器协同工作及多种交互通道（如终端、Telegram、Webhook）。

基于 Model Context Protocol (MCP) 的 JSON-RPC 服务器实现，提供健康监控、健康态势证据 attestations、全局与回声脉冲等工具与资源接口，供 LLM 客户端通过 MCP 协议读取资源、执行工具、获取健康信息并提交证据。

基于 Model Context Protocol (MCP) 的服务器实现集合，提供将工具、资源和对话记忆等能力暴露给 LLM 客户端的服务端组件。仓库中包含至少两个完整的 MCP 服务器实现（Databricks DevTools 与 Conversation Memory），采用 JSON-RPC 通信、支持标准化的工具注册与调用、并通过 stdio 传输与客户端交互，适配插件化的后端能力管理场景。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源与工具的注册/管理、Prompt 的定义与渲染，以及会话管理与协议能力声明，支持通过标准输入输出或流式 HTTP 等传输协议与客户端进行 JSON-RPC 通信，用于为大型语言模型（LLM）提供上下文信息与外部功能访问能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行，以及提示模板渲染等上下文服务，能够通过 JSON-RPC 与 LLM 客户端进行资源读取、工具调用与模板获取等交互，并支持多种传输协议以实现安全、可扩展的上下文服务。

基于模型上下文协议（MCP）的后端服务，提供资源、工具和提示模板的管理与渲染，并通过 JSON-RPC 与 LLM 客户端通信；内置 Notion 数据源作为底层存储，包含一个独立的 Agent 服务用于将自然语言转化为可执行工具调用。

基于 ELF 的 MCP 服务器实现，提供对大型语言模型（LLM）客户端的资源、工具调用与提示模板的上下文服务。通过 JSON-RPC 风格的 MCP 协议，将对资源和工具的访问请求转发到 ELF HTTP API，支持多种传输和会话模式，易于与 Claude 等 MCP 客户端对接。

Roo Extensions 是一个面向开发者的 MCP 服务器生态，基于 Model Context Protocol 提供面向 LLM 客户端的资源管理、工具注册与执行以及可定制 Prompt 渲染等能力，核心通过 JSON-RPC 与客户端通信，并在多传输协议（如 Stdio、SSE、WebSocket）下提供会话管理、能力声明与扩展性，支持多 MCP 实例协同工作与跨机器同步。仓库中包含多个内部/外部 MCP 实例、同步系统 RooSync、SDDD 跟踪等组件，构成完整的后端上下文服务框架。

基于 Model Context Protocol (MCP) 构建的后端服务器，为大语言模型客户端提供规范化的资源管理、工具注册与执行、以及可渲染的 Prompt 模板等上下文服务，支持 JSON-RPC 通信、会话管理与多传输通道。

基于 Model Context Protocol (MCP) 的后端实现，提供对资源、工具与提示模板的托管、注册与渲染能力，并通过 JSON-RPC 与 LLM 客户端通信。内置会话管理、能力声明以及支持多传输协议的 MCP 服务器代理功能，面向大语言模型应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务，向 LLM 客户端提供资源管理、工具注册/执行以及提示模板渲染等标准化上下文服务，支持多传输协议并实现会话与能力声明等 MCP 核心能力。仓库中包含用于集成 LispLang LangGraph 与 Playwright 的 MCP 服务实现、以及与 Argus E2E 测试引擎的对接插件。

基于 Model Context Protocol 的 MCP 服务器实现，使用 SQLite 数据库提供资源、工具与提示模板管理，供 LLM 客户端查询并执行外部功能，通过 JSON-RPC 与客户端进行通信，并支持会话管理与多种传输形式。

基于模型上下文协议（MCP）的后端服务器实现，专注为大语言模型客户端提供标准化的上下文服务：托管资源、注册并执行工具、定义和渲染Prompt模板；通过 JSON-RPC 进行通信，具备会话管理与能力声明，并支持多种传输通道，以实现安全、可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）理念的后端服务器实现，提供资源管理、工具注册与执行、以及 Prompt 模板渲染等核心能力，通过 JSON-RPC 与客户端通信，支持多传输协议（如 STDIN/STDIO、SSE、WebSocket）与会话管理，目标是在大语言模型客户端上提供结构化、可扩展的上下文服务。该仓库包含服务器端示例、核心数学与治理逻辑、工具与会话处理等模块，适用于搭建多智能体后端上下文服务场景。

基于 MCP（Model Context Protocol）的后端服务，提供通过 JSON-RPC 与 LLM 客户端进行交互的能力，允许对工具进行注册与执行、获取项目状态与排行榜等，并通过标准传输（如 STDIO）实现与 Claude/GPT 等客户端的无缝对接。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供 MCP 的核心能力：注册并执行工具（Tools）、托管资源与数据，以及通过 JSON-RPC 风格的交互向 LLM 客户端提供上下文与功能，支持多传输协议（stdio 与 HTTP/SSE）以便与不同的 AI 客户端对接。项目中包含可运行的 MCP 服务器代码和 HTTP/SSE 传输实现，适合作为对接大模型代理的后端服务。

基于 Model Context Protocol（MCP）的后端服务，作为 LLM 客户端的标准化上下文服务入口，提供资源托管、工具注册/执行、提示模板定义与渲染等能力，并通过 JSON-RPC 与前端/其他组件进行通信，支持嵌入式部署与回退模式，便于实现可扩展的上下文服务框架。

基于 SystemPrompt 的 MCP 服务器实现集合，提供资源管理、工具注册与执行、以及提示模板渲染等 MCP 核心能力，供大语言模型客户端通过 JSON-RPC 获取上下文信息与外部功能，并支持多种传输与会话场景。仓库中包含多个 MCP 服务器实现（如 systemprompt、moltbook、content-manager），共同构成一个可扩展的 MCP 后端生态。

基于 Model Context Protocol 的后端服务器，向 LLM 客户端以标准化方式提供上下文资源、可执行工具和可渲染的 Prompt 模板，支持多传输协议（如 STDIO、HTTP、SSE、WebSocket），并实现会话管理与工具加载策略。

基于模型上下文协议（MCP）的 Verkada API 后端服务器，提供资源管理、工具注册与执行，以及提示模板渲染等能力，通过 JSON-RPC 与大语言模型客户端进行通信，具备本地部署与扩展能力，并内置对 Verkada API 的工具集和请求处理框架。

基于 Model Context Protocol 的后端服务器实现，向大语言模型客户端提供资源托管、工具注册与执行，以及可渲染的 Prompt 模板，采用 JSON-RPC 进行通信，支持多种传输协议并具备会话管理与能力声明。

基于 Model Context Protocol (MCP) 的后端服务器实现，通过 Dedalus MCP 框架向 LLM 客户端提供 Discord API 的上下文信息与功能，包含一组可调用的工具（例如发送消息、读取历史、获取服务器信息等），并通过 JSON-RPC 与客户端通信。

基于 Model Context Protocol (MCP) 的后端实现，作为对话型LLM客户端的后端服务，托管并管理资源（Resources）、注册与执行工具（Tools）、定义并渲染 Prompt 模板（Prompts），通过 JSON-RPC 与客户端通信，支持 stdio 与 HTTP 等传输方式，提供会话管理和能力声明的上下文服务框架。

基于 Model Context Protocol 的机器学习代理协同后端，嵌入在 Skwad macOS 应用中，提供资源、工具和提示的 JSON-RPC 访问接口，供本地和远程的 LLM 客户端通过 MCP 进行上下文服务和任务协作。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（Resources）托管与访问、工具（Tools）注册与执行、以及 Prompt 模板的渲染与管理，通过 JSON-RPC 2.0 与本地的 LLM 客户端进行通信。支持多传输协议（如 StdIO、HTTP 及 SSE），具备会话管理、能力宣告和安全可扩展的上下文服务能力，适用于在本地环境下为本地 AI 助手提供稳定的上下文及外部能力接入。

基于 Model Context Protocol (MCP) 的后端服务器实现，承载资源、工具和提示模板，并通过 JSON-RPC 与 LLM 客户端进行标准化交互，支持多种传输模式，便于向 LLM 客户端提供统一的上下文信息和功能入口。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具、提示模板的托管与管理，以及通过 JSON-RPC 与客户端进行通信，支持多传输通道，供大语言模型应用安全、可扩展地获取上下文与外部功能。

基于 Model Context Protocol (MCP) 的后端服务器实现，向 MCP 客户端提供 Neo4j 资源访问、工具执行和提示模板渲染等能力，采用 JSON-RPC 进行通信，支持 STDIO 和 HTTP 传输模式，为大语言模型（LLM）应用提供标准化的上下文和功能服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管与管理、工具注册与执行、以及 Prompt 模板渲染等核心功能，能够通过 JSON-RPC 与 LLM 客户端进行上下文信息与功能的标准化交互。服务器端负责会话管理、能力声明与多传输通道支持（如 Stdio、SSE、WebSocket），为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的服务器实现，为大语言模型（LLM）客户端提供标准化的资源、工具执行能力以及提示模板的数据与接口，通过 JSON-RPC 进行通信，并通过标准传输（如 STDIO）提供会话管理与能力声明。该实现从组件、图书、图标及设计令牌等 Design System 元数据出发，支持查询、搜索、获取 Tokens 等能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 CoinBase Advanced Trading API 的资源管理、工具注册与执行，以及用于 Claude 等大语言模型的提示模板渲染与自助交易能力。服务器通过 JSON-RPC 与客户端通信，支持 HTTP（/mcp）、标准输入输出（stdio）等传输方式，并内置工具与提示注册、会话管理与安全日志处理。实现不仅包含完整的 MCP 服务端逻辑，还提供大量工具的注册、Prompts、以及用于自动交易技能的集成示例。

基于 Model Context Protocol 的服务器端实现，向客户端暴露 Whenny 的日期与时间相关工具，支持通过 JSON-RPC 请求执行工具、注册与查询工具、以及基于时区的传输/时区上下文等功能，适用于将日期服务接入到 AI 客户端的上下文环境中。

基于 Model Context Protocol（MCP）的通用后端实现，提供 dialectical 问答流程、自动编码工作流、资源与工具管理，以及基于 Prompt 的模板渲染。通过 JSON-RPC 与客户端通信，支持资源读取、工具调用、Prompt 获取与渲染等核心 MCP 功能，并实现会话管理、能力声明以及多传输通道的扩展能力（如 StdIO、SSE、WebSocket 等）以为 LLM 客户端提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源与工具的注册与管理、提示模板定义，并通过 JSON-RPC 协议与 LLM 客户端进行上下文和功能交互，支持多种传输层（如 Nostr、Stdio 等）的安全扩展和会话管理。

基于 Model Context Protocol (MCP) 的后端服务器，用于向 LLM 客户端提供 DaisyUI 组件文档、资源和工具的访问与执行能力。

基于 Model Context Protocol 的 Dolibarr ERP/CRM 的 MCP 服务器实现，提供资源/工具/提示等上下文服务，支持 STDIO 与 HTTP 传输，通过 MCP 协议与客户端进行 JSON-RPC 交互，实现对 Dolibarr 的完整后端集成能力。

基于模型上下文协议（AdCP）的后端服务器实现，提供资源（Resources）托管与管理、工具（Tools）注册及执行、以及提示模板（Prompts）的定义与渲染，并通过JSON-RPC 与客户端通信，支持多租户、多传输协议（如官方的Stdio、SSE、WebSocket）以为LLM应用提供安全、可扩展的上下文服务框架。

一个基于 MCP（Model Context Protocol）协议的后端实现示例，专注于模拟一个邮件发送工具的注册与调用，通过标准的 MCP 流程向客户端暴露工具并支持通过 STDIO 传输与客户端通信。

基于 Model Context Protocol 的 MCP 服务器实现，提供工具注册与执行、资源/上下文能力的托管，以及通过 JSON-RPC 与客户端通信的能力，支持多种传输方式（stdio、HTTP），用于为 LLM 客户端提供稳定、安全、可扩展的上下文服务。

基于模型上下文协议（Model Context Protocol，MCP）的后端服务器，向大语言模型客户端提供资源管理、工具注册/执行和提示模板渲染等能力，并通过 JSON-RPC 进行通信与协作，支持多传输协议（如 Stdio、SSE、WebSocket）和会话管理，提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的 TypeScript 服务器端框架，提供资源(Resource)、工具(Tool)、提示(Prompt)等上下文服务，并通过插件体系扩展能力，支持多传输协议（如流式HTTP、SSE、WebSocket）与会话管理，面向构建可扩展的 MCP 后端应用。

基于 Model Context Protocol (MCP) 的后端服务器，实现对 CTFD 的挑战资源、容器化运维工具的执行，以及对外暴露的资源接口，通过 JSON-RPC 与客户端通信，提供可扩展的上下文服务以支持 LLM 交互。

基于 Model Context Protocol (MCP) 的后端实现，提供对资源、工具与提示模板的托管、注册与渲染，并通过 JSON-RPC 风格接口与客户端交互，支持会话管理、能力声明与多种传输方式（如 StdIO、SSE、WebSocket）。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大语言模型客户端以标准化方式提供 GitHub Actions 的上下文信息、工具和提示模板，并通过 JSON-RPC 与客户端通信，支持以 Stdio 传输模式运行，便于在 Claude Desktop 等环境中集成使用。

基于 Model Context Protocol（MCP）的后端服务器实现。该服务器通过 JSON-RPC 提供对工具的注册与执行、会话管理及跨客户端通信能力，支持多工具整合、Plans 与会话监控等功能，并通过标准传输（如 STDIO）与 MCP 客户端进行交互。该实现可作为 LLM 客户端（如 Claude Code、Codex 等）访问的上下文服务后端。

基于Model Context Protocol的结构化AI任务执行服务器，提供标准化上下文和功能调用服务，支持LLM客户端多协议接入。

基于 Model Context Protocol 的 Discogs 数据 MCP 服务器，向大型语言模型客户端提供资源读取、工具执行和提示模板渲染等能力，并通过 JSON-RPC 与客户端通信，支持会话管理、鉴权与缓存等核心功能。

基于 Model Context Protocol 的后端服务器实现，向大语言模型客户端提供统一的上下文服务，包括资源管理、工具注册与执行、以及 Prompt 模板渲染等能力，支持 JSON-RPC 通信和多传输通道（如 STDIO/WebSocket/SSE）以供 AI Agent 调用。

基于 Model Context Protocol 的 MCP 服务端实现，负责与 MCP 客户端通过 JSON-RPC 协议通信，注册并执行外部工具、管理资源与提示模板，并支持多种传输方式（如 STDIO、HTTP SSE），提供会话管理、能力声明及外部工具的接入能力。

基于 Model Context Protocol 的 MCP 服务器实现，为 LLM 客户端提供资源管理、工具执行与提示模板渲染等功能。服务器通过 JSON-RPC 与客户端进行通信，支持资源读取、工具注册/执行、以及提示模板的定义与渲染，並可通过多种传输方式（如标准输入输出、SSE、WebSocket）扩展到不同的应用场景。该实现与 Kernle 的核心存储/推理能力紧密集成，面向企业/研究场景提供安全、可扩展的上下文服务后台。

基于 Model Context Protocol 的 MCP 服务器实现，将 ClawStreetBets 的市场与代理管理功能暴露给 AI 客户端，允许通过 JSON-RPC 调用工具、查询资源以及执行投票等操作，并通过 STDIO 传输进行交互。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大型语言模型客户端提供 npm 包的上下文、健康数据与可用工具，通过 JSON-RPC 形式处置资源、工具、提示模板等能力，并支持 MCP 客户端的连接与调用。

基于 Model Context Protocol (MCP) 的后端实现，向大模型客户端提供资源、工具、Prompts 等上下文服务，并通过 JSON-RPC/SSE/HTTP 协议进行通信与协作。该仓库实现了 MCP 服务端核心逻辑、工具注册、知识查询等能力。

基于 Model Context Protocol (MCP) 的后端实现，提供服务器端工具注册、跨模型查询以及服务器端函数发现与调用的 JSON-RPC 服务，支持通过 STDIO 等传输方式与客户端交互。

基于 Model Context Protocol (MCP) 的后端服务器，为大语言模型(LLM)客户端提供资源托管、工具注册与执行、以及 Prompt 模板渲染等上下文服务；通过 JSON-RPC 与客户端通信，支持会话管理、能力声明，并可通过多传输协议（如 StdIO、SSE、WebSocket）进行安全、可扩展的上下文服务交互。

基于 Model Context Protocol (MCP) 的后端服务实现，作为 MCP 客户端的服务器端，托管与管理资源、注册与执行工具、定义与渲染 Prompt 模板，并通过 JSON-RPC 与 LLM 客户端通信，提供会话管理、能力声明及多传输协议支持的上下文服务框架。该仓库实现了 MCP 服务器端的核心功能，并与向量检索后端（嵌入、数据库等）进行整合。

基于 Model Context Protocol (MCP) 的后端服务器，实现资源(Resource)托管、工具(Tools)注册与执行，以及 Prompt 模板的定义与渲染，并通过 JSON-RPC 与客户端通信，提供安全、可扩展的上下文服务，便于 LLM 进行集成查询和调用外部功能。

基于 Model Context Protocol (MCP) 的服务器端实现，提供对资源、工具与提示模板的统一管理与渲染，通过 JSON-RPC 与 LLM 客户端进行通信，支持会话管理、能力声明以及多种传输方式，用于在代码分析与开发场景中提供可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的 BoxLang 后端服务器实现，提供对 Resources、Tools 与 Prompts 的注册、管理与暴露，并通过 JSON-RPC 与 MCP 客户端进行通信，支持多传输协议（如 STDIO、SSE、WebSocket），为 LLM 客户端提供标准化的上下文服务、会话与能力声明。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管与数据访问、工具注册与执行、以及用于 LLM 的 Prompt 模板渲染。通过 JSON-RPC 与客户端通信，当前实现采用标准输入输出（Stdio）传输，读取客户端请求并输出响应；同时具备会话管理、能力声明与资源/工具渲染等核心能力，便于外部代理或图形化客户端接入以提供上下文信息与外部功能调用。

基于模型上下文协议的 MCP 服务器实现，提供资源、工具和提示模板的后端能力，通过 JSON-RPC 与客户端通信，注册并执行工具、管理会话并支持简单的 stdio 传输。

基于 MoonBit 的 MCP 服务器实现，向 LLM 客户端提供资源托管、工具注册和提示模板等上下文服务，并通过 JSON-RPC 进行稳定的通信。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具和提示模板的托管与通过 JSON-RPC 与客户端通信的后端服务。

一组基于 Model Context Protocol (MCP) 的 MCP 服务器实现集合，提供资源读取、代码/文档处理、代码索引、网页/文件检索等工具服务。通过 FastMCP 等框架实现服务器端的工具暴露与JSON-RPC通信，支持多种服务器脚本独立运行，用于向 LLM 客户端提供统一的上下文、工具执行和提示渲染能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供以标准化方式向 LLM 客户端提供上下文信息和功能的能力。通过 JSON-RPC 与客户端通信，核心包含工具注册/执行、提示模板渲染，以及与资源/查询接口的集成。当前实现使用 stdio 传输，在服务端对接 Linggen 后端 API 提供的能力，支撑 LLM 在设计、索引与查询场景中的上下文服务。

基于 Model Context Protocol (MCP) 的后端实现，作为 MCP 服务器向 LLM 客户端暴露 Helicone 的数据资源与工具，并通过 JSON-RPC 进行通信；当前实现注册了若干工具（如 query_requests、query_sessions、use_ai_gateway），实现了通过标准输入/输出的传输（Stdio）运行方式，以供 LLM 客户端调用与交互。

基于 Model Context Protocol 的 MCP 服务器实现，作为 LLM 客户端的后端上下文服务，提供资源管理、工具注册与执行、以及提示模板渲染等能力；通过 JSON-RPC 与客户端通信，支持多传输（如 STDIO、HTTP），并包含会话管理、能力声明与日志控制等核心特性。

基于模型上下文协议（MCP）的本地后端服务，提供资源管理、工具注册与执行，以及提示模板渲染等能力，支持 STDIO 与 HTTP 传输，面向与 LLM 客户端的上下文服务与对接。

基于 Model Context Protocol 的 MCP 服务器实现，提供 Gerbil Scheme 运行时的资源、工具与提示模板等能力，通过 JSON-RPC 与客户端进行标准化通信，支持多种传输方式（如 stdio）。

一个完整的MCP服务器实现，提供资源、工具、提示模板等上下文服务，支持JSON-RPC通信、会话管理与多传输协议，面向本地开发、调试和集成OpenAI/Claude等LLM应用。

基于 Model Context Protocol 的 MCP 服务器实现，提供标准化的资源、工具、Prompts 等能力，通过 JSON-RPC 与客户端通信，支持公开的 MCP 接入点与工具集注册，便于 LLM 客户端获取上下文信息、执行外部功能与获取 Prompt/模板等能力。

基于 MIESC 的 MCP（Model Context Protocol）服务器实现，提供资源托管、工具注册与执行、提示模板定义等功能，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多种传输协议的上下文服务能力。

基于 Model Context Protocol 的 MCP 服务端实现，提供资源、工具与会话管理，使用 JSON-RPC 进行通信，支持本地运行与演示。

基于 Model Context Protocol（MCP）的后端服务器，提供资源管理、工具注册与执行、以及提示模板的标准化上下文服务，面向 LLM 客户端通过 JSON-RPC 进行通信与交互。

基于 Model Context Protocol（MCP）的广告自动化后端实现，提供资源、工具和 Prompt 模板的托管与管理，并通过 JSON-RPC 与客户端进行通信，支持多传输协议（如 STDIO、SSE、WebSocket），为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的服务器端实现，提供资源（Resources）托管与管理、工具（Tools）的注册与执行、以及 Prompt 模板的定义与渲染，并通过 JSON-RPC 与客户端进行安全、可扩展的上下文服务交互，支持多传输协议（如 Stdio、SSE、WebSocket）和会话管理等核心能力。

基于 Model Context Protocol (MCP) 的后端网关实现，作为 MCP 服务器生态的核心网关，负责路由、聚合并管理后端 MCP 服务器，向 MCP 客户端提供一致的上下文、工具、资源等能力，并通过 Docker 容器或本地进程启动后端服务以实现 Stdio/HTTP 等传输模式和 JSON-RPC 通信。

基于模型上下文协议(MCP)的服务端实现，提供资源管理、工具注册与执行、以及Prompt模板渲染等核心功能，通过JSON-RPC与LLM客户端通信，支持多传输协议（如STDIO、WebSocket、SSE），并在浏览器自动化场景中实现对Brave浏览器及Puppeteer的可扩展上下文服务，适合为LLM代理提供可控、可扩展的上下文和能力服务。

基于 MCP（Model Context Protocol）协议的后端服务器，向 LLM 客户端提供统一的上下文资源、可注册执行的工具以及可渲染的提示/模板，支持 JSON-RPC 通信、多种传输协议，以及会话管理与能力声明，便于在聚类分析、语义检索和论文上下文中为大语言模型提供可扩展的 contexto 服务。

基于 Model Context Protocol（MCP）的后端实现，提供资源、工具和提示模板的上下文服务，供 LLP/LLM 客户端通过 JSON-RPC 方式访问办公室出勤数据，并在 HTTP 端点 /mcp/v1/ 提供 MCP 服务能力与工具执行能力。

一个基于 Model Context Protocol (MCP) 的后端服务，加载内置与外部 SOP，将它们作为可调用的提示注册，通过 FastMCP 提供 JSON-RPC 服务供 MCP 客户端访问，用于向大型语言模型提供结构化上下文和功能性提示。

基于 Model Context Protocol 的 MCP 服务器，向大型语言模型客户端提供对 Azure Logic Apps 的资源、工具与工作流定义的标准化访问，使用 JSON-RPC 进行请求/响应，并通过标准的 Stdio 传输实现本地集成与扩展能力。

基于 Model Context Protocol 的 MCP 服务器，向大型语言模型客户端提供对 Gitea 实例的资源、工具与提示模板等上下文能力，支持资源访问、工具调用与提示渲染。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供 STRIDE 威胁建模框架、工具调用与报告生成功能，支持通过 JSON-RPC 与 LLM 客户端进行上下文管理与协作。

基于 Model Context Protocol (MCP) 的服务器实现，使用 OpenAPI/FastMCP 将 mcpproxy 的控制接口暴露为 MCP 工具，支持工具注册、路由过滤、以及与 MCP 客户端的 JSON-RPC 通信，便于对 MCPProxy 的安全、可扩展后端服务提供上下文和控制能力。

基于 Model Context Protocol 的 MCP 服务器实现，用于通过标准化方式向 LLM 客户端提供 MSSQL 数据库的资源、工具和提示等上下文服务，支持多语言实现（Node 与 .NET 版本）以及基于 JSON-RPC 的交互。

基于 Model Context Protocol (MCP) 的后端服务器，采用知识图谱作为资源中心，提供工具调用、资源管理与结构化输出，支持 Neo4j 主存储与本地文件回退，并通过 JSON-RPC 的标准 MCP 规范与客户端进行交互，涵盖日志通知、错误码体系以及多传输通道的运行能力。

基于 Model Context Protocol 的 MCP 服务器实现，用于向 LLM 客户端提供上下文信息、工具调用通道与 Prompts 渲染等功能；核心通过 JSON-RPC 与客户端通信，示例实现包含最小化的服务器以支持集成测试场景。

基于 Model Context Protocol (MCP) 的后端服务，集成资源管理、工具注册与执行、以及提示模板渲染等能力，并通过 JSON-RPC 与 LLM 客户端通信，支持多种传输方式（stdio、SSE、HTTP）以提供可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，支持多代理协同的会话管理、工具执行和提示渲染，面向 LLM 客户端提供标准化的上下文服务。

基于 Model Context Protocol 的后端服务，作为 MCP 服务器向 LLM 客户端以标准化方式提供资源、工具和提示模板，并通过 JSON-RPC 进行通信，支持会话管理、能力声明以及多传输协议接入（如 Stdio、SSE、WebSocket）以实现安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的观测型后端代理，作为 MCP 客户端与服务器之间的透明中间件，实现对 JSON-RPC 请求/响应的零拷贝透传，同时提供实时可视化、历史日志与可选的审计签名能力，帮助开发者在不干预执行的前提下对工具链进行观测和回放。

基于 Model Context Protocol（MCP）的后端服务，提供资源管理、工具注册/执行与提示模板渲染等能力，并通过 JSON-RPC 与 LLM 客户端进行标准化通信，支持多种传输协议与会话管理以实现安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器，向大语言模型客户端提供 Overseerr 集成的上下文信息、工具和提示模板，通过 JSON-RPC 进行通信，并支持 STDIO、SSE/HTTP 等传输通道，便于在 AI 应用中进行资源检索、请求管理与媒体详情查询等功能的上下文服务。

基于 Model Context Protocol 的后端服务器实现，提供资源托管、工具注册与执行、提示模板管理，并通过 JSON-RPC 与客户端进行通信，支持多传输协议、会话管理与权限策略，以为大模型客户端提供安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务实现，提供工具注册、资源管理和提示模板渲染等核心能力，通过 JSON-RPC/Connect 框架与 MCP 客户端进行标准化通信，支持多个传输和会话能力，服务端还与前端 Web 界面和后端资源/工具链进行协作。

基于 Model Context Protocol 的 MCP 服务器实现，提供工具注册与执行、资源访问、以及与 LLM 的对话上下文渲染等核心能力。通过 JSON-RPC 与客户端通信，采用 STDIO 传输实现本地进程间通信，适用于 Claude Code 的 Telegram 插件后端场景。该实现涵盖工具调用、批量通知、审批流、AFK/监听等功能模块，具备完整的服务端能力与测试用例。

基于 Model Context Protocol (MCP) 的本地服务器实现，提供以 JSON-RPC 方式与客户端通信的能力，暴露工具调用入口并可扩展资源与提示等能力

基于 Model Context Protocol (MCP) 的后端服务器集合，面向软件开发生命周期（SDLC）的资源/工具管理、AI 审核与挑战、状态与流程管控等功能，提供标准化的 JSON-RPC 风格接口并支持多种传输方式（如 标准输入/输出、WebSocket、SSE 等）以供 LLM 客户端调用与协作。

基于模型上下文协议（MCP）的后端实现，提供资源、工具与 Prompt 的管理与渲染，通过 JSON-RPC 与 LLM 客户端进行通信，支持多传输模式（如 Stdio、SSE、WebSocket）以及会话与能力声明，并可通过 MCP 客户端接入扩展能力。该仓库在后端 Go 语言实现了核心服务，并在 README 提供了配套的 MCP 客户端服务（MCP 服务器端 bundles/示例及接入文档）。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 MCP 服务器进程的托管、注册、JSON-RPC 桥接和多会话管理，供 LLM 客户端通过 MCP 获得资源数据、调用工具与渲染 Prompt 模板等上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，提供翻译、分析与能力声明等核心服务，通过标准化接口向多语言客户端提供资源访问、工具执行与 Prompt 模板相关能力，并以 JSON-RPC 风格的 API 与客户端交互，具备会话管理、能力声明、以及可扩展的传输与部署方式，适配代码翻译及形式化验证等后续扩展场景。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、以及 Prompt 模板的定义与渲染，通过 JSON-RPC 与 客户端通信，支持多种传输通道，面向让大语言模型客户端高效获取上下文、能力和工具的后端服务。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源托管、工具注册与执行、Prompt 模板渲染等核心能力，并支持多传输协议（如 WebSocket、MQTT/UDP 等）通过 JSON-RPC 与客户端通信，面向边缘设备和物联网场景的上下文服务解决方案。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具注册与执行、以及 Prompt 模板渲染，支持 stdio、HTTP、SSE 等传输，并通过 JSON-RPC 与客户端进行消息交互，具备会话管理、能力声明及多传输协议支持等能力。

基于 Model Context Protocol 的 MCP 服务端，为 LLM 客户端提供 NiceGUI 资源、工具、文档与示例等能力，并通过 JSON-RPC 与客户端通信，支持资源读取、工具执行、主题索引、示例检索、组件信息查询以及可选的屏幕截图和主提示渲染等功能。

基于 Model Context Protocol (MCP) 的后端实现，提供标准化的资源（Resources）、工具（Tools）以及提示模板（Prompts），通过 JSON-RPC 与 LLM 客户端通信，支持多传输通道并对接 Supabase 数据源，构建面向 AI 赋能的上下文服务框架。该仓库包含一个完整的 MCP 服务器实现（含工具定义、资源暴露、提示模板以及 Prompt 执行逻辑），并以 Stdio 传输方式提供服务入口。

基于 Model Context Protocol (MCP) 的后端实现，提供资源/工具/提示模板的管理与渲染，通过 JSON-RPC 与 LLM 客户端进行交互，支持 HTTP 与 STDIO 等传输模式的多种通信方式。

基于 Rust 的本地 Model Context Protocol (MCP) 服务器，提供握手初始化、工具注册与调用，以及本地文件系统相关辅助功能，面向 LLM 客户端通过标准 JSON-RPC 在本地环境获取上下文信息与可执行工具

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源、工具、提示模板的标准化管理与渲染，支持 JSON-RPC 通信、会话管理及多传输协议，内置插件生态并实现了对外部工具与推理能力的统一接入与协作。

基于 Model Context Protocol（MCP）的后端服务器实现，面向 LLM 客户端提供资源、工具和 Prompt 的标准化上下文服务，并通过 JSON-RPC 进行通信；支持会话管理、能力声明，以及多传输协议（如 Stdio、SSE、WebSocket）的扩展能力，适用于将 Tana 数据和功能暴露给 AI 模型进行推理、调用和渲染。

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 MCP 服务器提供多昵称通知、工具执行和提示模板渲染，并通过 JSON-RPC 与 MCP 客户端通信。

基于模型上下文协议（MCP）的 Rust 实现，提供服务器端与客户端的完整 MCP 功能，包括资源、工具、提示的托管与管理，以及通过 JSON-RPC 的请求/响应处理，支持多传输通道（stdio、TCP、HTTP SSE）与会话管理，面向在 AI 应用中提供上下文与功能的后端服务。

一款基于 Model Context Protocol（MCP）的后端服务器框架，向大语言模型客户端以标准化方式提供资源管理、工具注册/执行以及提示模板渲染等功能，支持 JSON-RPC 通信、会话管理、能力声明，并可通过多传输协议（如 Stdio、SSE、WebSocket）进行扩展与部署。

基于模型上下文协议（MCP）的后端实现，向 MCP 客户端暴露 Klondike Spec 的资源、工具和提示模板等能力，并通过 JSON-RPC 形式处理请求与响应，支持多传输协议用于与大型语言模型的无缝对接。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源、工具、Prompt 的托管、读取和渲染能力，并通过 JSON-RPC 与 LLM 客户端进行通信，支持多传输协议以提供安全、可扩展的上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现与桥接组件，允许 LM 模型/代理通过标准 JSON-RPC 方式读取资源、调用工具、获取与渲染 Prompt 模板等，核心包含一个可运行的 MCP 服务端以及将 Cursor 等客户端接入 Docmost 的桥接层。

基于 Model Context Protocol 的 MCP 服务器实现，使用 Arivu 的连接器生态在 JSON-RPC 下向 LLM 客户端提供资源、工具与提示模板等上下文信息，并通过标准输入输出（目前实现）进行 JSON-RPC 通信与会话管理。

基于 Model Context Protocol(MCP) 的后端服务，作为本地大模型应用的上下文提供者。该服务器托管与管理 Resources（数据资源）、Tools（可注册并供 LLM 调用的外部功能）以及 Prompts（Prompt 模板渲染），通过 JSON-RPC 与客户端通信，完成会话管理、能力声明以及跨传输协议（如 Stdio、SSE、WebSocket）的上下文服务，方便编辑器、IDE 以及本地模型进行组合式推理与扩展。仓库中明确包含 MCP 集成组件、启动脚本及相关文档，具备对 MCP 客户端的完整支持能力。

基于 MCP 的系统监控后端，提供系统信息、资源数据、工具调用等能力，通过 JSON-RPC 与客户端通信，并支持 HTTP REST API 与 STDIO 两种传输方式，方便 AI 客户端与集成工具（如 OpenCode 等）进行远程监控与上下文服务。

基于 Model Context Protocol (MCP) 的后端服务，实现资源、工具与提示模板的标准化上下文服务，并通过 JSON-RPC 与客户端通信，支持会话管理与 SSE 实时推送。

基于 Model Context Protocol 的 MCP 服务器实现集合，核心职责是以标准化的 JSON-RPC 方式向 LLM 客户端提供上下文信息和能力：托管与管理 Resources、注册与执行 Tools，并定义/渲染 Prompt 模板，同时支持会话管理与多传输协议，面向 Claude Code 等 LLM 应用的上下文服务后端。该仓库包含可运行的服务模板和示例服务器实现，旨在帮助开发者快速搭建符合 MCP 的后端服务。

ModelCypher MCP 服务器是一个基于 Model Context Protocol 的后端服务，提供资源、工具和提示模板的统一管理，并通过 JSON-RPC 与 LLM 客户端通信，支持会话管理、能力声明及多传输协议。

基于 Model Context Protocol 的后端服务，向大语言模型客户端提供圣经经文、原文字词、注释及文章等资源的标准化访问与上下文服务，通过 JSON-RPC 进行通信，支持多传输模式、会话管理与能力声明。

基于 Model Context Protocol（MCP）的后端服务器，通过 JSON-RPC 提供资源、工具与提示模板给 LLM 客户端，并以标准化的方式与 OSINT 平台 API 对接，支持通过 Stdio 传输进行通信与会话管理。

基于 Model Context Protocol（MCP）的 StarCraft 回放数据查询服务端，实现了可通过 MCP 客户端以 JSON-RPC 形式查询、获取数据库模式和 StarCraft 知识的后端，支持 SQLite/PostgreSQL 存储和 stdio 传输模式。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具执行与提示模板的注册与渲染能力，并通过 JSON-RPC 与客户端进行交互，支持会话管理、能力声明以及多传输协议接入，旨在为 LLM 客户端提供安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端实现，承担资源、工具、 Prompt 模板等的托管与管理，并通过 JSON-RPC 与 LLM 客户端进行通信，提供会话管理、能力声明、以及多传输协议支持（HTTP、SSE、WebSocket）的上下文服务框架，供前端仪表盘、Captain 编排与代理执行组件协同工作。

基于 Model Context Protocol 的后端服务，通过 JSON-RPC 方式向 LLM 客户端提供监控、部署与故障分析相关的工具接口，支持通过标准化请求-响应模式执行工具、查询部署信息等，服务器端实现了工具注册、请求处理与错误封装，通信以 STDIO 为载体。

基于模型上下文协议（MCP）的后端服务器，实现资源托管、工具注册/执行以及提示模板渲染，并通过 JSON-RPC 与客户端通信，提供会话管理、能力声明以及对多传输协议的支持，旨在为LLM客户端提供标准化的上下文和外部功能访问服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，用标准化的 JSON-RPC 形式向 LLM 客户端暴露资源、注册和执行 Tools，以及 Prompt 模板的渲染与管理，核心包含会话管理、能力声明与对多传输协议的支持，旨在为 LLM 应用提供可扩展、可验证的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器，实现对 Resources、Tools 与 Prompts 的托管、注册与渲染，并通过 JSON-RPC 2.0 与 LLM 客户端进行通信，支持资源读取/订阅、工具调用、提示获取，以及远程订阅通知等功能。该实现包含完整的服务器端约束、路由、订阅管理与通知输出，具备可运行的 MCP 服务端能力。

基于 Model Context Protocol 的 MCP 服务器，实现对 XPR（Proton 区块链）的工具查询、数据访问与外部部署能力，通过 JSON-RPC 与 MCP 客户端通信，并提供 Azure Functions 部署支持。

基于 Model Context Protocol 的 MCP 服务器实现，提供对资源、工具和提示模板的管理与执行，并通过 JSON-RPC 与客户端进行通信，支持本地化持久化与多代理会话协作。该仓库包含完整的服务端实现代码，而非仅为示例。

基于 Model Context Protocol（MCP）的后端服务器框架，提供资源与工具管理、提示模板，以及通过 JSON-RPC/HTTP/WebSocket 等协议与客户端交互的上下文服务能力。

基于 Model Context Protocol (MCP) 的 Discord 集成后端，提供标准化的资源、工具、提示模板管理，并通过 JSON-RPC 与客户端进行通信，实现对 Discord 服务的自动化上下文支持。

基于 Model Context Protocol 构建的后端服务实现，作为 MCP（Model Context Protocol）服务器向大型语言模型客户端提供结构化的资源管理、工具注册与执行、以及可自定义的 Prompt 模板渲染能力；通过 JSON-RPC 进行通信，并支持 HTTP/STDIO 等传输模式与会话管理、能力声明与访问控制等安全特性。

一个基于 Node.js 的最小 MCP 服务器实现，公开 WordPress REST API 工具给 MCP 客户端，并通过标准输入输出（stdio）与客户端通信，支持 WordPress 的文章、页面、分类、标签、用户、插件及自定义 CPT 的路由等功能。

基于模型上下文协议的后端实现，提供资源管理、外部工具注册与执行以及对外暴露的工具集合，支持通过标准化的 JSON-RPC 方式与客户端进行对话式上下文交互。

基于 Model Context Protocol 的后端服务器，向大型语言模型客户端提供资源、工具和提示模板等上下文与功能，并通过 JSON-RPC 进行通信与协作。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源、工具与提示模板等上下文功能的注册、执行与渲染，并通过 JSON-RPC 与外部 AI 客户端进行通信，支持本地与网络模式以及对管线的自动化控制。

基于 Model Context Protocol (MCP) 的服务器端实现示例，展示如何通过 JSON-RPC 提供资源管理、工具执行与 Prompt 模板渲染等核心能力，并支持通过标准输入输出 (stdio) 的传输模式与客户端进行通信，适合作为学习和实验用途的 MCP 服务器实现。

基于 Model Context Protocol 的后端 MCP 服务器实现，作为后端上下文服务提供商，向 LLM 客户端以标准化的 JSON-RPC 调用提供资源、工具与提示模板等能力，并通过 MCP 协议进行请求处理与响应返回。该仓库内实现了服务器端工具注册、请求分发以及对 Supabase 等后端的数据访问逻辑，可用于对接外部大模型应用场景。

基于 Model Context Protocol 的 MCP 服务器实现，集成在 EllyMUD 游戏后端，提供资源管理、工具注册与执行、以及 Prompt 模板渲染等能力，便于与大型语言模型或外部 AI 客户端通过 JSON-RPC 进行上下文与功能交互。

基于 Model Context Protocol（MCP）的后端服务器实现，提供面向大语言模型客户端的上下文服务能力，包含工具（Tools）、资源（Resources）和提示模板（Prompts）的注册、管理与执行，支持通过 Spring Boot 部署并对接支持 MCP 的 Agent 客户端。

基于模型上下文协议（MCP）的后端服务器实现，提供资源管理、工具注册与执行，以及提示模板渲染等能力，并通过 JSON-RPC 与客户端进行通信，支持 TUI/GUI 与 AI 助手的集成使用。

基于 Model Context Protocol 的后端服务实现，提供资源管理、工具注册与执行、以及提示模板渲染，采用 STDIO 传输用于与 MCP 客户端进行 JSON-RPC 风格的通信，支持多模态上下文的读取、操作和交互。

基于 Model Context Protocol 的本地 MCP 服务器实现，提供资源、工具和提示渲染等能力，供本地 LLM 客户端通过 JSON-RPC 方式访问并管理项目数据（包含会话、能力声明、以及多传输协议支持）。

基于 Model Context Protocol (MCP) 的后端服务器，为 LLM 客户端提供可管理的资源、可注册的工具和可渲染的 Prompt 模板，通过 JSON-RPC 进行通信，支持多种传输协议（如 Stdio、SSE、WebSocket），并实现会话管理与能力声明等功能。

基于 Model Context Protocol (MCP) 的后端服务器实现，向 LLM 客户端以标准化的 JSON-RPC 方式提供资源管理、工具注册/执行以及 Prompt 模板渲染等上下文服务，支持会话管理、能力声明与多传输协议（如 stdio、SSE、WebSocket），旨在为 LLM 应用提供可扩展、安全的上下文服务能力。

基于 Model Context Protocol (MCP) 的后端服务器实现集合，提供 Resources 的托管与管理、Tools 的注册与执行，以及可扩展的提示模板/交互能力，并通过标准化的 JSON-RPC 风格接口与 LLM 客户端进行通信，支持会话管理与多种传输场景。当前实现包括 MemoryMCPServer 与 RAGMCPServer 等服务器骨架，可作为 MCP 客户端对接的后端服务端。

一个基于 MCP 的后端服务器实现，提供 JSON-RPC 2.0 的初始化、工具列表与工具执行等核心接口，并通过标准输入输出与客户端通信，支持在本地运行、生成并管理 MCP 配置与规则输出。

基于 Crackerjack 的 MCP（Model Context Protocol）服务器实现，提供资源托管与管理、工具注册与执行、以及可渲染的 Prompt 模板等核心能力，通过 JSON-RPC 与客户端通信，并支持多种传输方式（如 WebSocket、StdIO、SSE），为 LLM 客户端提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务，提供资源（Resources）管理、工具（Tools）注册与执行，以及 Prompt 模板渲染等能力，采用 JSON-RPC 与 LLM 客户端进行通信，支持多种传输通道（如 SSE、StdIO、WebSocket），为大语言模型应用提供标准化的上下文与能力服务。

基于模型上下文协议（MCP）的服务器实现组件，作为 Polar 电子应用的一部分，提供工具定义查询、工具执行与健康检查等核心接口，通过 HTTP 端点与客户端通信，并通过 Electron 渲染进程 IPC 与后台工具 definition/执行能力对接，从而向 LLM 客户端暴露资源、工具与提示渲染能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对资源、工具和提示模板的管理与执行，支持通过 JSON-RPC 与 MCP 客户端通信，并具备标准化的服务器端会话管理和多传输模式能力（如 StdIO）。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、Prompt 模板渲染等能力，并通过 MCP JSON-RPC 与客户端通信。该仓库实现了完整的 MCP 服务端逻辑、工具集合和向量存储等组件，支持通过多种传输方式（如 stdio、HTTP、gRPC 等）向 LLM 客户端提供结构化的上下文服务和功能。

基于 Model Context Protocol (MCP) 的后端服务器，提供对 GitHub 的上下文资源、工具执行与提示模板的标准化访问，支持 JSON-RPC 交互，适配多种传输方式并具备会话管理、能力声明与远程工具发现等能力，用于为大语言模型提供可扩展的上下文服务。

基于模型上下文协议（MCP）的后端服务器实现，提供资源管理、工具注册与执行、以及 Prompt 模板的定义与渲染，并通过 JSON-RPC 与客户端通信，支持多传输协议（如 STDIO、SSE、WebSocket）以为 LLM 客户端提供可扩展的上下文服务框架。

基于 Model Context Protocol 的 AutoHotkey v2 MCP 服务器，提供资源、工具、提示词(Prompts)的管理与上下文注入，并通过 JSON-RPC 与客户端进行通信，支持多传输协议（如 STDIO、SSE），实现会话管理和能力声明以服务化地提供上下文服务。

基于模型上下文协议（MCP）的后端服务器实现，向大型语言模型（LLM）客户端提供统一的资源/工具/提示模板等上下文服务，通过 JSON-RPC 进行通信，并支持多传输协议与会话管理，内置 Word/Excel/PPT/PDF 等办公文档处理能力的托管实现。

基于模型上下文协议（MCP）的服务器端实现，面向后端提供统一的资源管理、工具注册与执行、以及 Prompt 模板的定义与渲染。通过 JSON-RPC 与客户端通信，支持会话管理、能力申明，并可通过多种传输协议（如 STDIO、SSE、WebSocket）实现安全、可扩展的上下文服务，方便 LLM 客户端调取资源、执行工具与获取定制的 Prompt。该仓库明确包含 MCP 相关的服务端实现与集成能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大语言模型客户端提供资源、工具与提示等上下文能力，并通过 JSON-RPC 在标准输入输出传输通道进行通信，支持本地及远程执行场景的脚本运行、会话管理与审计日志记录。

基于 Model Context Protocol 构建的后端服务，为对话型客户端提供标准化的资源管理、工具注册与执行、以及可渲染的提示模板等上下文服务，支持多引擎协同、JSON-RPC 通信以及多种传输协议的 MCP 场景实现。

基于 MCP（Model Context Protocol）在 ESP32/ESP-IDF 上实现的 MQTT 传输 MCP 服务器，提供资源管理、工具注册与调用、以及 Prompt/模板支持，利用 JSON-RPC 与客户端通信，适用于边缘设备上的上下文与能力服务。

基于 Model Context Protocol（MCP）的完整服务器实现，提供资源管理、工具注册与执行、Prompts 定义与渲染，以及以 JSON-RPC 形式与客户端通信的能力，支持多传输通道（stdio、SSE、WebSocket）与会话管理，适合作为 LLM 客户端的上下文服务后端。

基于 Model Context Protocol（MCP）的服务器实现，作为后端上下文服务提供者，负责托管并管理 资源（如 UniAST/AST 数据、仓库结构等）、注册与执行工具，以及定义和渲染 Prompt 模板，供大语言模型（LLM）客户端通过 JSON-RPC 进行资源访问、工具调用与提示渲染等交互。实现了 MCP 服务端核心能力，支持 STDIO/HTTP 等传输模式的通信。

基于 Flask 的 MCP 服务器实现，提供工具、资源、提示等接口，支持 JSON-RPC 风格的请求/响应以及流式传输，便于向大模型客户端提供上下文信息和外部功能接入。

基于 MQTT 5.0 的 MCP 服务器实现，使用 paho-mqtt-c 库，提供资源管理、工具注册与调用、以及基于 JSON-RPC 的 MCP 请求/响应处理，支持服务器上线、会话管理和多客户端交互。

基于模型上下文协议（MCP）的后端实现示例，包含可运行的 MCP 服务器代码、工具/资源注册以及简单的 Prompt 管理能力，能够通过标准化的 JSON-RPC 方式与客户端交互。

基于 Model Context Protocol (MCP) 的后端服务，提供15种图表生成功能、AI智能配色与输出能力，并通过 MCP 协议供 LLM 客户端读取资源、调用工具和获取图表输出。

基于模型上下文协议（MCP）的后端服务器实现，提供资源管理、工具注册/执行、提示模板等核心能力，支持 JSON-RPC 通过 WebSocket/HTTP 与客户端通信，内置量子安全加密（Ed25519 与 Dilithium 的混合模式）、W3C DID 身份、审计日志和会话管理，满足企业级的可扩展上下文服务需求。

基于 Model Context Protocol (MCP) 的后端实现，为 AI 客户端（如大型语言模型）提供标准化的上下文服务：托管资源、注册并执行工具、定义与渲染提示模板，支持通过 JSON-RPC 进行通信。

基于 Model Context Protocol (MCP) 的多模型上下文服务后端，向 LLM 客户端提供资源管理、工具注册与执行、Prompt 模板渲染等核心能力；通过 JSON-RPC 与客户端通信，支持会话管理并兼容多种传输协议（STDIO/SSE/WebSocket），为 AI 应用提供可扩展、安全的上下文服务框架。

基于 Model Context Protocol 的 MCP 风格服务器实现，提供对资源、工具和提示模板的标准化管理，内置 STDIO 与 SSE/HTTP 传输方式的服务器端实现，并可与 Agent2Agent 等组件协同工作，支持异步请求处理、流式响应和任务驱动的上下文服务。

基于模型上下文协议（Model Context Protocol, MCP）的后端服务器，向大型语言模型（LLM）客户端以标准化方式提供资源数据、工具执行能力和可渲染的提示模板，支持多租户、会话管理以及通过 JSON-RPC 与客户端通信的上下文服务框架，适用于广告投放场景的自动化协作与执行。

基于 Model Context Protocol (MCP) 的后端服务器实现，用于向大型语言模型（LLM）客户端暴露私有代码资源、可执行工具和可渲染的 Prompt 模板等上下文服务，并通过 JSON-RPC 方式进行通信，支持 STDIO 和 HTTP 两种传输通道。

基于 WeKnora 的 MCP（Model Context Protocol）服务器实现，向大模型客户端提供标准化的资源、工具与提示模板的上下文服务，并支持多传输协议（如 Stdio、SSE、WebSocket）与会话管理，用于实现安全、可扩展的上下文环境。该服务器通过 JSON-RPC 与客户端进行通信，承载资源访问、工具注册/执行与提示渲染等核心能力。典型场景包括对接外部知识库、执行工具调用、以及渲染与提供定制化的 Prompt 模板。

基于 Model Context Protocol (MCP) 的后端实现，提供资源、工具、Prompts 的注册、管理与渲染，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多传输协议接入，面向 LLM 的上下文服务与功能扩展。

基于 Model Context Protocol 的后端服务器，统一暴露多种消息队列适配器作为工具，向 LLM 客户端提供资源、工具执行与 Prompts 渲染的上下文服务。

基于 Model Context Protocol（MCP）的后端服务器，聚合 Vault、SOPS 等密钥/机密管理工具的工具接口，向大语言模型（LLM）客户端提供以 JSON-RPC 形式调用的密钥读取、写入等操作的统一入口，并支持通过标准化传输（如 STDIO）进行交互。

基于 Model Context Protocol 的多运行时容器管理 MCP 服务器，提供对 nerdctl/podman/docker 的统一 MCP 接口，支持 STDIO 与 Streamable HTTP 传输，供大模型客户端以标准化方式获取资源、调用工具与渲染提示等上下文信息。

基于 Model Context Protocol（MCP）的后端服务器，聚合多语言静态站点生成器（SSG）的工具集，并通过 MCP JSON-RPC 暴露给大模型客户端使用，支持 STDIO 与流式HTTP传输模式。

基于 Model Context Protocol (MCP) 的 CapCut 风格后端服务器，通过 JSON-RPC 与 MCP 客户端通信，提供资源、工具、草稿管理等核心能力，支持把视频/音频/图片等素材以标准化方式暴露给大语言模型等客户端使用。

基于 Claude Code Workflow 的 MCP 服务器实现，使用 JSON-RPC 与客户端通信，核心职责是托管资源、注册工具、定义并渲染 Prompt 模板，为 LLM 客户端提供可扩展的上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具注册与执行、Prompt 模板定义与渲染等核心能力，并通过 JSON-RPC 与客户端通信；内置认证、授权、速率限制、观测与审计等安全特性，支持多传输协议（Stdio、HTTP、SSE）以及多服务器路由场景，能为 LLM 客户端提供安全、可扩展的上下文服务框架。

基于模型上下文协议（MCP）的后端服务器实现，提供面向客户与财务的工具服务，通过 FastMCP HTTP 传输向 LLM 客户端暴露可调用的工具，支持资源访问与任务执行，便于在对话式应用中以标准化方式获取上下文信息和外部功能。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管、工具注册/执行、Prompt 模板渲染，并通过 MCP/JSON-RPC 进行客户端交互，支持会话管理与跨协议传输，面向 LLM 客户端提供可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器端实现，作为 AI 助手的后端上下文服务，提供资源管理、工具注册与执行、以及 Prompt 模板渲染等功能，支持通过 JSON-RPC 与客户端通信，并可在 stdio、HTTP（含 SSE）等传输模式下运行，具备会话管理、能力声明和安全保护机制。

基于模型上下文协议（MCP）的后端服务器实现，提供资源（Resources）托管与访问、工具（Tools）的注册与执行，以及提示模板（Prompts）的定义与渲染，支持通过 JSON-RPC 与客户端通信，并具备会话管理与多传输协议（如 Stdio、SSE、WebSocket）扩展能力，为大语言模型（LLM）应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器，用于向 LLM 客户端提供持久化记忆、工具执行和 Prompt 模板渲染等上下文服务；通过 JSON-RPC 与客户端通信，支持内存资源管理、工具注册/执行、Prompt 渲染，以及会话管理，具备本地向量检索、离线嵌入和多种传输能力的服务端实现。

基于 Model Context Protocol (MCP) 的后端服务器，实现 Claude Code 会话的资源管理、工具执行与提示渲染，提供统一的上下文服务给 LLM 客户端，采用 JSON-RPC 进行交互，支持多传输方式并完成会话、资源、工具等能力的托管与管理。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具调用以及资源渲染的服务端能力，并通过 JSON-RPC/ SSE 方式与客户端通信，支持多会话与会话管理，适用于在后端向 LLM 客户端提供可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的服务端实现，用于向基于 MCP 的中文/英文客户端提供标准化的上下文信息与功能。核心职责包括托管与管理 Tools、Resources、Prompts，支持通过 JSON-RPC 与客户端通信，提供会话管理、能力声明以及多传输协议的支持，适合在浏览器环境或本地服务中搭建对 LLM 的上下文服务框架。

基于 Model Context Protocol 的后端服务器，提供任务资源、工具调用和提示模板等上下文服务，通过 JSON-RPC 2.0 与 AI 客户端（如 Claude Code）进行交互，实现多代理协作的上下文管理与执行能力。

基于 Model Context Protocol 的后端服务，提供资源、工具与提示模板的标准化上下文服务，通过 JSON-RPC 与 LLM 客户端进行交互，当前实现以 STDIO 传输为主要通讯方式，能够托管本地知识库中的日常简报、事实、理事会简报等资源，并暴露查询与渲染工具以支持多样化的 LLM 交互场景。

基于 Model Context Protocol (MCP) 的 HealthSim 后端实现，用于以标准化方式向 LLM 客户端提供上下文信息和功能，包括资源管理、工具注册/执行，以及提示模板渲染。服务器通过 JSON-RPC 与客户端通信，具备会话管理、能力声明，并对接多种传输协议（如 Stdio、SSE、WebSocket），为健康数据生成与模拟应用提供可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管与管理、工具注册/执行，以及提示模板的定义与渲染，通过 JSON-RPC 与客户端进行通信，支持会话管理与多传输协议的上下文服务框架。

一个基于 Model Context Protocol 的最小可运行服务器实现，使用 stdio 传输，与客户端通过 JSON-RPC 进行交互，公开一个简单的 hello 工具，便于开发者快速上手 MCP 服务端开发。

一个面向大型语言模型的 MCP 服务器模板仓库，提供多达17种独立的 MCP 服务器及底层核心组件，支持资源管理、工具注册与执行、Prompt 模板渲染，并通过 JSON-RPC 与客户端进行通信，适合本地自托管和容器化部署。

基于 Model Context Protocol (MCP) 的后端服务器，作为 VidCap YouTube API 的上下文服务提供方，管理资源与工具，支持 JSON-RPC 的请求/响应，并通过 STDIO、流式 HTTP/WebSocket 等传输方式与 MCP 客户端进行交互，便于 AI 助手在对话中获取视频数据、执行外部功能和渲染提示模板。

基于 Model Context Protocol (MCP) 的本地秘密管理与上下文服务服务器，提供秘密资源的托管、工具注册与执行，以及可渲染的 Prompt 模板，供本地的 AI 编码助手安全地获取上下文与功能。所有敏感密钥仅存于本地，AI 客户端通过 JSON-RPC 与服务器交互读取资源、调用工具并渲染 Prompts。

基于 Common Lisp 的 MCP（Model Context Protocol）服务器实现，提供资源管理、工具注册与执行、提示模板渲染等核心能力，并通过 JSON-RPC 进行请求/响应。支持多种传输协议（stdio、TCP、HTTP），为大语言模型（LLM）客户端提供可扩展、可安全的上下文服务框架。

基于 Sugar 的 MCP 服务器实现；通过 JSON-RPC 以标准化方式在 STDIN/STDOUT 上与 MCP 客户端通信，提供任务/工具相关的后端能力，并通过 Sugar CLI 实现实际功能调用，作为 Claude Code 与 Sugar 生态的后端上下文与功能提供端。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供可运行的思维链管理与分支导航能力，通过 JSON-RPC 与客户端进行交互，并通过 STDIO 传输实现与外部模型或工具的对接。

基于模型上下文协议（MCP）的后端实现，作为 YakShaver 桌面应用的服务端，负责托管与管理内部 MCP 服务器、注册与执行工具，以及定义与渲染提示模板，通过 JSON-RPC 进行与 LLM 客户端的标准化通信，提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具和提示模板的注册、路由与 JSON-RPC 响应，作为 Elixir 应用的后端服务，与 Claude Code CLI 控制协议配合使用（支持 in-process 服务器模式）。

基于 MCP 协议的高性能后端服务器实现，提供与 IBKR TWS/Gateway 交互的工具、市场数据、账户信息等能力，通过 JSON-RPC 形式对接 MCP 客户端，并以 Axum 构建的 HTTP/WebSocket 服务提供可扩展的上下文能力。

基于 MCP 的后端服务，为大语言模型客户端提供标准化的上下文信息与功能支持，托管资源、注册工具、定义与渲染提示模板，并通过 JSON-RPC 与客户端交互，支持多种传输协议与会话管理。该仓库实现了 MCP 相关组件与服务器端能力，旨在在本地或分布式环境下提供可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的服务器端实现，作为 Whimbox 的后端服务，通过 JSON-RPC 提供资源/工具（Tasks/宏相关接口）等能力给大语言模型客户端调用，支持健康检查、嵌入式工具渲染与多传输协议（如 streamable-http）。

基于 Model Context Protocol 的后端服务器，为 AI 客户端提供对 Mock Service Worker (MSW) 的统一上下文服务。服务器负责托管资源、注册可执行工具、定义并渲染提示模板，并通过 JSON-RPC/WebSocket 等传输与浏览器中的 MSW 服务工作者进行动态交互和控制。

基于 MCP 的后端服务器实现，提供通过 Cheat Engine 与 LLM 客户端之间的 JSON-RPC 通信，支持内存读取、工具调用以及提示模板渲染等上下文服务的本地化 MCP 服务器。

基于 Model Context Protocol (MCP) 的服务器框架，提供对 MCP 请求/响应的处理能力、资源与工具注册管理，以及通过 JSON-RPC 与客户端进行通信的多进程服务器支持与会话管理。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行、以及 Prompt 模板的定义与渲染能力。通过 JSON-RPC 形式与客户端通信，支持将 LLM 的推理与外部设备（如 Minecraft 实例）进行无缝协作，具备会话管理、能力声明与多传输协议扩展能力（如 Stdio、SSE、WebSocket）的后端上下文服务框架。

基于 LiveKit Agents 框架的 MCP（Model Context Protocol）服务器实现与示例，提供资源、工具与提示模板的托管与暴露，支持 JSON-RPC 风格的通信以及多传输协议（如 SSE/WebSocket/StdIO）以供 LLM 客户端访问上下文信息和外部功能。

基于 Model Context Protocol (MCP) 的 MCP 服务器实现，提供资源管理、工具注册/执行、Prompt 模板定义与渲染等能力，作为后端上下文服务框架供 LLM 客户端通过 JSON-RPC 进行资源访问、外部功能调用与交互模板渲染。仓库中包含多个可运行的 MCP 服务器示例，支持通过标准化接口对接 Claude/LLM 客户端。

基于 Model Context Protocol（MCP）的后端服务器实现示例，提供资源/工具管理、工具执行以及面向 LLM 的上下文渲染能力，展示了如何用 MCPX 服务器核心实现 JSON-RPC 风格的请求/响应，并支持多种传输方式（如标准输入输出、SSE、HTTP 流等）。

基于 Model Context Protocol（MCP）的服务器端实现，提供工具、资源、提示的注册与执行，并通过 JSON-RPC 与客户端进行通信，支持多传输方式（HTTP、stdio、Inspector 调试）以为大语言模型提供可扩展的上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端运行时与代理，提供资源、工具和提示的统一管理，并通过 JSON-RPC 与 MCP 客户端通信，支持多传输协议（stdio、SSE、WebSocket）等，能够在沙箱中运行并托管任意 MCP 兼容的服务器。*

基于模型上下文协议（MCP）的后端服务器，提供 MCP 指令注册与执行、资源与工具的管理，以及提示模板的渲染，供大模型客户端通过 JSON-RPC 调用，并可通过多传输协议进行通信。

基于 Model Context Protocol 的 MCP 服务器实现，用于向 LLM 客户端以标准化方式提供 M3M 的运行时文档、工具和资源信息。服务器通过 JSON-RPC 进行通信，支持标准输入输出（stdio）和 HTTP/SSE 两种传输方式，并且具备插件扩展能力以加载外部模块的接口描述。

基于Model Context Protocol（MCP）的后端服务器，提供 Sekiban 文档与示例的查询、检索、分段渲染以及与LLM的交互工具，支持通过SSE/HTTP等传输方式与客户端通信，并可通过JSON-RPC风格请求获取资源、工具和提示模板等能力。

基于 Model Context Protocol (MCP) 的后端服务器，结合 Joern 代码分析平台，为 LLM 客户端提供统一的资源管理、工具注册、提示模板渲染等上下文服务，并通过 JSON-RPC 支持多种传输协议（如 stdio、SSE、WebSocket）来读取资源、执行工具和渲染 Prompt。该服务器实现了 MCP 的核心功能，包含会话管理、能力声明以及对外暴露的丰富工具和资源接口。

基于 Model Context Protocol 的 MCP 服务器端后端，提供资源与工具的托管、会话管理、以及与 MCP 客户端的 JSON-RPC 通信，辅以网关、调度、工具聚合等模块实现对 MCP 服务的弹性编排与扩展。

基于模型上下文协议（MCP）的后端服务，实现了通过标准 JSON-RPC 对外提供资源管理、工具注册与执行、以及上下文相关提示/工作流的能力。该实现以 stdio 为传输介质，供 LLM 客户端（如 Claude Code、Cursor、Gemini CLI、Codex CLI 等）调用并集成到软件工程场景的推理与协作中，内部使用 SQLite DB 存储知识组件与工作流状态，支持多阶段的 FP F（First Principles Framework）推理循环。

基于 Model Context Protocol (MCP) 的服务端实现，作为后端上下文与功能提供者，向 LLM 客户端暴露资源访问、工具注册/执行以及可渲染的对话模板能力。通过 JSON-RPC/HTTP 交互方式，整合资源管理、工具执行与上下文管理，支持会话与多种传输模式的后端服务框架。

基于模型上下文协议（MCP）的后端服务器，向LLM客户端标准化提供资源管理、工具注册/执行以及可自定义的提示模板渲染，通过 JSON-RPC 进行通信与协作。

基于 Model Context Protocol (MCP) 构建的后端服务器，提供对 JWT 的解码、编码、验证、破解与攻击载荷生成等工具，通过 MCP 客户端以 JSON-RPC 形式进行查询与调用，支持标准化的资源管理与工具执行接口（通过 stdio 传输）。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具与提示模板的注册与渲染，通过 JSON-RPC 与 AI 客户端进行交互，支持以标准输入输出（StdIO）传输的通信方式，为 LLM 应用提供可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，用于在 Claude Desktop 等 LLM 客户端中提供统一的 CRM 上下文服务。服务器端职责包括托管资源、注册并执行工具、定义与渲染提示模板，以及通过 JSON-RPC 与客户端进行通讯，当前实现通过标准输入输出（STDIO）传输并可扩展为其他传输协议。

基于 Model Context Protocol（MCP）的服务器实现，提供资源（Notes/边/图）管理、工具注册与执行、以及 Prompt 模板渲染等能力，供大语言模型（LLM）客户端通过 JSON-RPC 调用获取上下文信息、执行外部功能与搭建对话场景。

基于模型上下文协议（MCP）的服务器端实现，向大型语言模型客户端提供 Tempo 区块链的资源、工具和提示模板，并通过 JSON-RPC 进行交互，支持多传输协议与严格的会话与安全机制。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源与工具的托管与管理、Prompt/模板的渲染，以及通过 JSON-RPC 与客户端通信的能力，支持多传输通道如 STDIO、WebSocket 等，帮助 LLM 客户端以标准化方式获取上下文、数据访问和外部功能调用。

基于模型上下文协议（MCP）的后端服务器集合，提供对资源、工具和提示模板的托管与执行，并通过 JSON-RPC 与 MCP 客户端进行通信，支持多种传输方式，适用于为大语言模型（LLM）客户端提供上下文与功能服务的后端架构。仓库内包含 Python 与 TypeScript 实现的多个 MCP 服务器实例及客户端示例，覆盖新闻、YouTube 工具箱、Notion 驱动的框架资源等场景。

基于 FastMCP 的 MCP 服务器实现，通过 JSON-RPC 提供对 OpenAlex 的资源访问、工具执行与 Prompt 相关功能，供大语言模型客户端进行上下文查询、数据获取与分析。

基于 MCP 协议的后端服务器实现，向大语言模型客户端以统一的 JSON-RPC 方式暴露新闻检索与全文获取等工具，方便在对话中调用外部功能、获取上下文信息与执行相关任务。

TEQUMSA_NEXUS 仓库提供以 Model Context Protocol（MCP）为核心的后端服务器实现，涵盖资源、工具、提示模板等资源的托管与管理，以及通过 JSON-RPC 风格接口进行跨节点协同与数据访问，为大语言模型（LLM）客户端提供可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的后端实现，提供对 OCTAVE 文档协议的标准化上下文服务。通过注册的工具集向 LLM 客户端暴露资源访问、外部功能调用能力，并提供对话上下文的可控渲染能力；使用 JSON-RPC 风格的通信，当前通过标准输入输出（stdio）进行交互，具备会话管理和能力声明等核心能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具与提示模板的托管与管理，支持 JSON-RPC 客户端交互，并具备会话管理与多传输协议扩展能力，适用于向 LLM 客户端提供可访问的数据、外部功能与定制化提示。

基于 Model Context Protocol (MCP) 的后端服务器，为 LLM 客户端提供资源、工具与模板等上下文服务，基于 JSON-RPC 通信，支持会话管理、能力声明，并可通过多种传输协议（如 STDIO、SSE、WebSocket）与客户端对接，面向股票分析与量化交易场景的统一上下文服务框架。

基于 Model Context Protocol（MCP）的后端服务器实现，面向大语言模型客户端提供资源管理、工具注册与执行，以及提示模板的渲染等核心能力，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明及多传输协议（如 Stdio、SSE、WebSocket）以实现安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供长期记忆知识库、关系图谱与记忆章节的读写与管理能力，并通过 MCP 与 AI 客户端进行 JSON-RPC 风格的交互与协作。

基于 Model Context Protocol (MCP) 的服务器端实现，提供通过 API 访问组件库资源、暴露工具以供 AI 助手调用、并支持以 MCP JSON-RPC 形式与客户端进行交互的后端服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 AI 客户端的上下文服务中心，提供资源（Resources）管理、工具（Tools）注册与执行、以及 Prompt 模板（Prompts）的定义与渲染，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明与多种传输协议以便进行安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器，实现了资源(数据)托管、工具注册与执行、以及提示模板渲染等核心能力，并通过 JSON-RPC 方式与客户端通信，具備会话管理、能力声明以及对多传输协议的支持，用于为 LLM 客户端提供可扩展的金融上下文服务。

基于 Model Context Protocol 的后端服务器，向 LLM 客户端以标准化 JSON-RPC 提供资源、工具与提示模板，并实现会话管理、认证与多传输协议扩展。

基于 MCP（Model Context Protocol）的 Neovim 后端实现，为 MCP 客户端提供工具暴露与执行、以及与 Neovim 的远程过程调用（RPC）桥接。通过 JSON-RPC 提供标准化的请求/响应，支持在 Studio/stdio 传输环境下与 Claude 等 LLM 客户端协同工作，便于在编辑器内进行上下文管理和外部功能调用。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供新闻数据查询、AI分析工具、存储与通知等能力，采用 FastMCP 2.0 实现 MCP 协议并支持 STDIO 与 HTTP 传输，与 MCP 客户端进行标准化上下文信息访问与功能调用。

基于 Model Context Protocol (MCP) 的服务器实现，作为 RSSMonster 应用的 MCP 服务端，向大型语言模型（LLM）客户端提供资源访问、工具执行和提示模板渲染能力。服务器通过 JSON-RPC 与客户端通信，提供对 RSS/文章、分类、订阅等资源的托管与管理，注册并执行工具以调用外部功能，以及渲染与自定义提示模板，且具备会话管理和能力声明，支持通过 HTTP（以及未来扩展的传输协议）进行多路传输。核心实现包含完整的服务端路由、数据库模型、MCP 工具集以及与 AI 相关的分析能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，面向 LLM 客户端提供统一的上下文资源、可注册的工具以及可渲染的 Prompt 模板。通过 JSON-RPC 与客户端通信，支持会话管理、能力宣告，以及多传输协议（如 Stdio、SSE、WebSocket）等扩展能力，适配 Claude 等 AI 助手的上下文服务需求。

基于 Model Context Protocol 的 MCP 服务器实现，用于托管与执行 BL1NK Skills，并集成 AWS Bedrock Nova Lite 进行技能生成与推理，支持资源、工具、提示模板的标准化管理与 JSON-RPC 通信。

基于模型上下文协议（MCP）的服务器实现，提供内存管理、工具注册/执行和提示模板的后端服务，通过 JSON-RPC 与 LLM 客户端进行通信，支持与各种后端组件协同工作，便于在代理代理的对话系统中提供上下文性与功能性支持。

基于 Model Context Protocol 的后端服务器实现，提供资源与工具的托管、Prompt 模板的渲染，以及通过 JSON-RPC 与 LLM 客户端进行通信的能力，支持标准化的会话管理与多传输通道（如 stdio）。

一个基于 Model Context Protocol (MCP) 的轻量级示例服务器，展示了如何注册和调用自定义工具，用于与LLM客户端交互。

一个基于 Model Context Protocol (MCP) 标准，能够以 JSON-RPC 协议对外提供 AI-Parrot 工具服务的应用后端。

该项目为 Storybook 提供 MCP (Model Context Protocol) 服务器，帮助 AI 代理高效理解 UI 组件信息并辅助开发流程。

提供基于 Model Context Protocol (MCP) 的本地服务器，为 LLM 客户端提供 LlamaIndex 生态系统的文档上下文和工具调用能力。

这是一个基于Model Context Protocol (MCP) 的服务器，用于管理简单的文本笔记作为资源，并提供总结笔记的提示模板和添加笔记的工具。

OSVM Unikernel 工具执行器是一个高性能、安全隔离的后端，专为 LLM 客户端通过 vsock 协议调用 MCP 工具而设计。

Intlayer MCP 服务器为LLM应用提供AI驱动的多语言内容管理、翻译工具和上下文服务，通过JSON-RPC协议实现高效交互。

基于 Airlift 框架构建的 MCP 服务器实现，提供上下文信息、工具和 Prompt 管理，支持 LLM 客户端通过 JSON-RPC 协议进行交互。

Poet 是一个集成 MCP 服务器的静态网站生成器，为 LLM 应用提供内容上下文和交互能力。

AgentGateway是一个为Agentic AI设计的连接平面，支持Model Context Protocol (MCP) 和Agent2Agent (A2A)，提供安全性、可观测性和治理能力，并能将传统API转换为MCP资源。

一个基于Model Context Protocol (MCP) 的简单Python服务器，提供天气预警和天气预报查询工具，通过JSON-RPC与LLM客户端通信。

Enso Labs Orchestra是一个基于MCP和A2A协议的AI代理编排后端，为LLM提供上下文、工具和会话管理。

一个基于 Express.js 和 Node.js 实现的 MCP 服务器，提供天气预警和预报功能，可无缝部署到 Azure。

一个基于FastMCP框架构建的MCP服务器，用于管理和查询虚拟的Cupcake订单资源。

一个轻量、类型安全的API框架，通过内置的Model Context Protocol (MCP) 插件，可轻松将现有API转换为LLM可用的工具和资源。

一个符合Model Context Protocol (MCP) 标准的服务器，提供全面的宝可梦数据访问和逼真的对战模拟功能，支持自然语言交互。

一个基于 Symfony 框架构建的 MCP 服务器示例，通过 JSON-RPC 协议向 LLM 客户端提供工具服务。

将 SQL Server 数据库能力通过 MCP 协议暴露给 LLM 客户端

基于Node.js实现的MCP服务器示例，支持JSON-RPC、工具调用、资源访问和SSE传输。

专为本地 Laravel 开发构建的 MCP 服务器，为 AI 客户端提供丰富的项目上下文和操作工具。

一个基于MCP协议的服务器，通过JSON-RPC将思科ISE（Identity Services Engine）数据动态封装为可调用的工具。

基于 TypeScript 的远程 MCP 服务器框架，快速构建并托管 AI 工具和服务。

提供基于 Rush Stack 工具链的上下文信息和功能的 MCP 服务器实现。

使用Go语言实现的Model Context Protocol (MCP)服务器，为LLM提供资源、工具及Prompt服务。

一个Go语言实现的模型上下文协议(MCP)库，用于连接LLM应用与外部数据、工具和服务。

一个简单的MCP服务器示例，用于测试和演示MCP协议的基本工具功能。

轻量、快速、兼容 NativeAOT 的 .NET MCP 服务器和客户端框架。

通过 MCP 协议（基于 JSON-RPC）远程管理 KVM 虚拟机，提供生命周期、网络和存储等操作接口。

基于 MCP 协议，为 LLM 客户端提供阶段式项目初始化和工作流管理上下文服务。

一个基于Spring AI和MCP协议实现的后端服务，提供天气预报和警报查询工具。

提供多种功能各异的MCP服务器示例，用于测试和验证Model Context Protocol客户端及服务器实现。

一个VS Code扩展，提供数据库作为AI编码的上下文信息，支持自动发现、数据浏览和修改。

go-a2a 是使用 Go 语言实现的 Agent-to-Agent (A2A) 协议库，它不仅实现了 A2A 协议，还集成了 Model Context Protocol (MCP)，可以作为有效的 MCP 服务器使用，为 LLM 应用提供资源、工具和 Prompt 管理等上下文服务。

Swissknife A2A 服务器是一个多代理系统后端，通过 JSON-RPC 和 SSE 协议，以 A2A 协议向客户端提供 AI 代理服务、工具扩展和上下文管理能力。

ACI.dev 是一个开源平台，通过统一的 MCP 服务器和 Python SDK，为 AI Agent 提供安全、可扩展的工具集成和上下文服务。

KWDB MCP Server 是一个基于 Model Context Protocol 的应用后端，旨在为 LLM 客户端提供访问 KaiwuDB 数据库的标准化上下文服务，支持资源管理、工具注册和 Prompt 模板渲染等核心 MCP 功能。

Viam MCP SDK 是一个 Rust 库，用于简化 MCP 服务器组件的开发，支持工具注册、调用和标准化的 JSON-RPC 通信。

API200 MCP 服务器是一个基于 MCP 协议的应用后端，旨在将 API-200 平台集成的第三方 API 以工具形式提供给 LLM 客户端使用。

一个简单的MCP服务器，通过CoinGecko API提供加密货币价格信息，展示了MCP协议工具注册和执行的基本功能。

基于A2A协议实现的代理伙伴服务器，提供工具注册、任务管理和推送通知等功能，用于构建智能代理协作系统。

轻量级 TypeScript 库，用于构建可编排的多智能体 AI 系统，支持 Model Context Protocol (MCP) 服务器集成，提供上下文服务框架。

Coco MCP服务器是 wearable 设备 coco 的后端实现，通过 Model Context Protocol (MCP) 标准协议，为 LLM 应用提供音频数据资源访问和向量检索能力。

基于Bash的轻量级MCP服务器，用于通过JSON-RPC管理和执行命令行工具。

TinyMCP Server SDK 是一个轻量级的 C++ SDK，用于构建基于 Model Context Protocol (MCP) 的服务器，专注于通过 JSON-RPC 和 Stdio 提供工具执行能力。

轻量级的MCP服务器与客户端Python实现，提供天气、时间等示例服务，助力LLM访问外部工具。

基于Spring MVC和SSE实现的MCP服务器，支持通过JSON-RPC协议与LLM客户端进行上下文信息和功能交互。

一个基于MCP协议的Fetch服务器，可以将URL内容抓取并转换为Markdown格式，优化AI模型的内容输入。

基于TypeSpec生成的MCP服务器，通过Stdio提供向量数学工具服务。

为 Claude, Cursor, WindSurf 等 MCP 客户端提供数据库查询和 schema 上下文的 MCP 服务器。

Emmett MCP 是一个用于构建 Model Context Protocol (MCP) 服务器的 Emmett 框架扩展，支持 SSE 传输协议，为 LLM 客户端提供上下文信息和工具能力。

基于 Internet Computer 的最小化 MCP 服务器实现，目前仅支持工具 (Tools) 功能和 Streamable HTTP。

基于pyATS的实验性MCP服务器，为LLM应用提供网络自动化和多服务工具集成能力。

基于MCP协议的任务管理服务器，使用SQLite存储，提供项目和任务的创建、查询、更新等工具接口。

提供工具和提示的MCP服务器，扩展大型语言模型能力，支持多种工具和提示模板，简化LLM应用开发。

官方Rust SDK，用于构建Model Context Protocol (MCP) 服务器和客户端，提供资源管理、工具执行和Prompt模板渲染等核心功能。

一个简单的 MCP 服务器示例，提供了一个名为 "dust" 的工具用于演示。

基于Micronaut框架构建的MCP服务器PoC，专注于提供工具注册和调用功能，通过标准输入/输出与客户端通信。

一个使用Python实现的简单但功能完备的MCP服务器，支持工具注册和调用，并提供时间工具示例。

一个基于CrewAI框架构建的MCP服务器，提供文本摘要工具，支持自定义摘要长度，方便集成到LLM应用中。

基于Langchain和NestJS构建的MCP服务器示例，演示了如何使用MCP协议提供上下文信息和工具能力。

cpp-mcp 框架是一个用 C++ 编写的 MCP 服务器实现，提供资源管理、工具注册和 Prompt 模板等核心功能，并通过 JSON-RPC 协议与客户端通信。

PuTi MCP Server 是一个基于 FastMCP 构建的轻量级 MCP 服务器，旨在为 LLM 应用提供工具注册和执行的后端服务。

一个基于Model Context Protocol (MCP) 的服务器，通过STDIO和JSON-RPC 2.0协议，将Cisco pyATS和Genie的网络自动化能力以工具形式提供给LLM客户端。

通过 JSON-RPC 接口控制 Windows 11 画图程序，实现自动化绘图和图像编辑功能。

基于Model Context Protocol构建的MCP服务器，为Medusa电商平台提供数据访问和功能扩展，支持AI智能体集成。

OmniAI MCP服务器是一个基于Ruby实现的MCP协议服务器，旨在为LLM客户端提供资源、工具和Prompt模板管理能力，实现标准化的上下文服务。

Go-MCP 是一个 Go 语言 SDK，用于构建和交互 Model Context Protocol (MCP) 应用，支持服务端和客户端实现。

使用 Go 语言构建的 MCP 服务器示例，提供工具、Prompt 和资源管理功能，用于扩展 LLM 应用能力。

提供Bun和Python两种语言实现的MCP服务器示例，用于演示如何构建和运行支持资源与工具管理的MCP后端服务。

一个基于Model Context Protocol (MCP) 的函数工具服务器，支持注册、执行多种编程语言编写的工具函数，并通过HTTP桥接扩展工具能力。