"JSON-RPC" 标签

基于 Model Context Protocol（MCP）的完整服务器实现，提供资源、工具、提示模板等的标准化后端服务，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多种传输方式。

基于 Model Context Protocol 的 VerifiMind-PEAS MCP 服务器实现，提供 X-Z-CS RefleXion Trinity 的多模型评审、资源与工具管理，并通过 JSON-RPC 的 MCP 协议与客户端通信。

基于 Model Context Protocol (MCP) 的 WhatsApp 后端服务器实现，使用 Go 语言编写，提供工具注册与执行、会话管理与多传输模式支持，旨在为大模型客户端提供统一的资源访问、外部功能调用和上下文渲染能力，并可与 WhatsApp Bridge 集成使用以实现对话上下文的实时服务。

基于 Model Context Protocol (MCP) 的后端实现，提供资源、工具和提示模板等以标准化 JSON-RPC 形式暴露给 LLM 客户端，通过 stdio 传输与 Claude Code/LEO 等对话系统进行交互，并支持多租户、工具注册、资源管理和会话能力声明。

基于 Model Context Protocol (MCP) 的后端服务器，提供浏览器自动化能力的资源、工具与提示模板，通过 JSON-RPC 与 MCP 客户端通信，并通过 WebSocket 与 Chrome 扩展协同执行任务。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具注册与执行、以及提示模板的定义渲渲染，并通过 JSON-RPC 与 Claude Desktop 等 MCP 客户端进行通信，支持多传输方式以实现对大语言模型的上下文服务。

基于模型上下文协议（MCP）的后端服务器实现，使用 FastMCP 将 ChatBot 的查询、会话历史和配置信息以工具的形式对 MCP 客户端暴露，并支持通过 MCP 客户端进行跨进程/跨平台的上下文交互。

基于 Model Context Protocol (MCP) 的内存图后端服务器，提供标准化的 JSON-RPC 接口向各类 MCP 客户端暴露资源、工具、提示以及会话管理能力，并支持多客户端并发访问与会话持久化。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 Prompt 的结构化评估能力，通过标准化工具接口向 LLM 客户端暴露评估功能，并通过标准输入/输出的传输通道（如 STDIO）进行 JSON-RPC 通信。

基于 Model Context Protocol 的本地 MCP 服务器，向本地 AI 客户端提供 9 个系统工具（如获取Last Session Context、路由推荐、效率快照、优化建议等），并通过标准的 JSON-RPC 形式进行资源、工具与 Prompt 的统一访问与渲染。该仓库实现了一个完整的 MCP 服务器端，包含注册工具、处理请求、会话与推送等核心能力。

一个基于 Model Context Protocol (MCP) 的后端实现，用于向大语言模型客户端提供 Fiji / ImageJ 的资源、工具和提示模板等上下文信息，并通过 JSON-RPC 进行通信。核心功能包括托管 Fiji 资源、注册可调用的工具、渲染提示模板，以及会话管理。该实现通过 fastmcp 库暴露一个服务器实例，注册工具并提供运行入口。当前为 Proof of Concept（POC），依赖 ImageJ/Fiji 的 Java/JVM 环境以及对应的 Python 封装，便于在本地桌面环境或开发机上进行功能验证。

基于 GraphQL 架构，能够从 GraphQL 模式自动提取 Query/Mutation，生成一组 MCP 工具并通过 JSON-RPC 暴露，供大模型客户端查询、操作数据以及执行外部功能。

基于 Model Context Protocol（MCP）的嵌入式后端实现。提供资源访问、工具执行与提示/上下文渲染能力，使用 JSON-RPC 通过 Unix 套接字与 LLM 客户端通信，包含会话管理、能力声明与多种传输适配的实现框架。该实现将资源、工具、以及与 LLM 交互所需的上下文信息暴露给客户端，方便构建对话型应用的上下文服务后端。

基于 Model Context Protocol (MCP) 的 MCP 服务器实现，旨在为 LLM 客户端提供标准化的上下文服务：托管资源、注册和执行工具，以及定义与渲染提示模板，并通过 HTTP JSON-RPC 与客户端进行交互，支持会话管理与多传输模式（如 HTTP/StdIO）。

基于 Model Context Protocol (MCP) 的服务端实现，提供资源、工具和 API 形式的 MCP 请求处理能力，并将本地技能、外部源及 Bitwarden 等工具通过 JSON-RPC 暴露给 LLM 客户端，支持多传输协议与会话管理，适用于将 AI 辅助能力以标准化上下文服务提供给大语言模型。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大语言模型客户端提供技能目录（Resources）、可注册与执行的工具（Tools）、以及可渲染的 Prompt 模板（Prompts），并通过 JSON-RPC 与客户端通信以提供上下文与能力服务。

基于 Model Context Protocol (MCP) 的服务器端实现，提供对代理任务看板的资源、工具、提示等能力，通过 JSON-RPC 的 MCP 交互向 LLM 客户端暴露 backlog、编辑、查询等能力，并包含本地/团队模式、UI Kanban 界面以及 Leader 选举等特性。该仓库中的 MCP 服务端实现了工具注册、请求分发、日志与数据库契合，以及与前端 UI 的协同工作。

基于 Lemma 引擎实现的 MCP（Model Context Protocol）服务器，提供对资源、工具与 Prompt 的标准化访问，通过 JSON-RPC 与客户端通讯，支撑 LLM 在后端获取上下文、执行外部功能与渲染提示模板等能力。

基于模型上下文协议（MCP）的服务器实现，提供网关端的懒加载工具与后端MCP连接管理，能够通过标准化的JSON-RPC风格交互向LLM客户端暴露可用的MCP、工具和提示模板，并支持多传输协议（如 stdio、HTTP/SSE 等）。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大型语言模型客户端提供统一的资源数据、工具调用、以及可渲染的 Prompt 模板等上下文服务，通过 JSON-RPC 进行通信，支持会话管理、能力声明与多传输协议接入。

基于 Model Context Protocol 的后端服务，按照 MCP 标准提供资源管理、工具注册与执行、以及 Prompt 模板渲染等能力，通过 JSON-RPC 作为传输协议与 Claude Desktop/Code/Cursor 等客户端进行上下文对话与功能调用。该服务器内置会话管理、能力声明，并支持多种传输协议，以为 LLM 应用提供可扩展、安全的上下文服务框架。

Aura 是基于 Rust 的 MCP 服务器实现，提供资源、工具和提示的标准化管理与执行，并通过 JSON-RPC 在标准输入输出等传输下与 LLM 客户端通信，支持多种传输协议以提供可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的 PostgreSQL 后端服务器实现，向大语言模型客户端提供数据库资源、可调用工具、以及可渲染的 Prompt，支持多种传输协议（stdio、HTTP/SSE），并内置认证、会话管理与安全策略。

基于 Model Context Protocol 的 MCP 服务器实现，提供本地化的上下文资源、工具注册与内置提示模板渲染能力，并通过 MCP 的 JSON-RPC 与客户端通信，支持会话管理与本地存储。

基于 Model Context Protocol 的后端实现，提供对知识图谱资源、工具与提示模板的托管与查询，通过 JSON-RPC（以 STDIO 传输）与 LLM 客户端进行交互，支持本地与云端推理的调度与安全控制。

基于 Model Context Protocol (MCP) 的服务器实现，提供资源、工具、提示等接口的标准化管理与访问，支持 JSON-RPC 的请求/响应，通过 WebSocket、SSE、HTTP POST 等传输方式与 LLM 客户端进行交互，并在 Cloudflare Workers 上实现会话管理、权限控制和多传输协议支持的后端服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供工具注册与执行、模型/能力管理，以及通过 JSON-RPC 形式对外服务。服务器通过标准传输（如 StdIO）与 MCP 客户端通信，支持多模型调用、任务编排与可扩展的上下文能力，为 LLM 客户端提供统一的上下文与外部功能入口。

基于 Model Context Protocol 的 MCP 服务器实现，Cloudflare Worker 端对外提供通过 JSON-RPC 的上下文服务，向 LLM 客户端提供着色器资源检索、工具调用与 Prompts 渲染等能力，并支持多种传输与兼容端点。该实现包含完整的 MCP 请求/响应处理、会话管理与多端点支持。]

基于 MCP（Model Context Protocol）实现的后端服务，向大语言模型（LLM）客户端以标准化的 JSON-RPC 方式提供资源、工具和提示模板等上下文能力，并支持远程访问、UI 展现及多传输协议等场景。

基于 Model Context Protocol (MCP) 的后端服务实现，提供资源管理、工具注册与执行、以及提示模板渲染等能力，通过 JSON-RPC 形式与搭载的 LLM 客户端进行安全、可扩展的上下文服务。该仓库实现了一个可运行的 MCP 服务器端，包含对看板相关资源（Boards、Areas、Cards、Comments 等）的管理、工具执行及通知等功能，并集成了身份认证、邮件发送等服务。

基于 Model Context Protocol 的后端服务器实现，向 LLM 客户端（如 Claude）提供 Binance 的市场数据、账户信息和交易工具等资源与工具。通过 JSON-RPC 方式暴露工具接口，并使用标准传输（如 Stdio）与客户端通信，支持会话管理与能力声明，便于在 AI 场景中实现可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的服务器实现，向大语言模型客户端提供标准化的上下文服务与能力，包括资源管理、工具注册/执行以及提示模板的定义与渲染，并通过 JSON-RPC 与客户端通信，支持多传输协议（如 HTTP/HTTPS、stdio），具备会话管理、能力声明与可扩展的后端架构。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具注册/执行、以及可渲染的 Prompt 模板等能力，并通过 JSON-RPC 在多种传输通道（stdio、SSE、HTTP、WebSocket）与客户端进行通信，支持会话管理、热更新和工具缓存等特性。

基于模型上下文协议（MCP）的后端服务器，向大语言模型客户端提供对 PostgreSQL 数据库的上下文信息、工具执行与数据访问能力，通过 JSON-RPC 进行通信，支持查询、表/视图与约束描述、索引、慢查询分析等多种工具的统一调用。

基于 Horizons 的 MCP 网关实现，提供以 JSON-RPC 2.0 进行跨 MCP 服务的请求分发与路由能力，支持标准传输（stdio、HTTP），实现多租户场景的工具调用与资源管理的入口网关。通过配置可将客户端的 MCP 请求路由到一个或多个子 MCP 服务器，具备工具调用、配置管理和工具发现等核心功能。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、以及可渲染的 Prompt 模板等功能，通过 JSON-RPC 与 LLM 客户端交互，支持多传输协议以便在不同环境中提供上下文与外部能力访问。

基于 Model Context Protocol 的后端服务器，向大型语言模型客户端提供资源管理、工具注册/执行以及可定制的提示模板等上下文服务；通过 JSON-RPC 进行请求/响应，并支持多种传输方式（如标准输入输出、HTTP SSE、WebSocket），实现会话管理与能力声明，面向配置管理场景的强扩展后端。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源、工具与提示模板（Prompts）的标准化上下文服务，并通过 JSON-RPC 2.0 与 MCP 客户端通信，支持多租户数据管理、工具执行以及对外部分析/推理能力的接入。

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

一个基于 Model Context Protocol (MCP) 的服务端实现，作为后端向大模型/LLM 客户端提供资源、工具调用和提示模板等上下文信息，通过 JSON-RPC 形式进行通信，并支持 SSE、WebSocket 等传输方式及会话管理、能力声明等安全可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的服务器实现，作为后端上下文服务端，向 MCP 客户端提供资源、工具、提示模板等（Resources、Tools、Prompts）的管理与执行能力，并通过 JSON-RPC 与客户端进行通信。服务器负责会话管理、能力声明、以及对多种传输协议的支持（本仓库实现了标准输入/输出的 stdio 传输模式），为 LLM 应用提供安全、可扩展的上下文服务框架，适用于 BizTalk 到 Logic Apps 的迁移场景。

基于 Model Context Protocol (MCP) 的后端框架，提供资源托管、工具注册与执行、以及提示模板渲染，并通过多传输通道与客户端进行标准化的 JSON-RPC 通信，支持在 Express、Hono、Fastify、Koa、Hono 等适配器上部署的 MCP 服务。

基于 Model Context Protocol 的后端服务，实现对资源、工具和 Prompts 的标准化上下文提供，配合 MCP 客户端通过 JSON-RPC 进行交互，支持多传输通道（stdio/HTTP+SSE）并具备会话管理与能力声明能力。

基于 Model Context Protocol (MCP) 的后端实现，提供资源管理、工具注册与执行、并渲染/提供 Prompt 模板等能力。服务器通过 JSON-RPC 与客户端通信，内置会话管理、能力声明，并支持多种传输协议（如 Stdio、SSE、WebSocket），可在 IDE 中以 MCP 服务器的形式集成，为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的服务器端实现，为 AI 助手提供对 Hop 配置、连接、分组、历史、工具和命令构建等能力的标准化访问；通过 JSON-RPC 与客户端通信，支持只读工具、可选开启的远程执行工具，以及可浏览的资源接口，便于 AI 助手对服务器进行查询、检索和执行操作。

基于 JD.AI 架构的 MCP 服务器实现，提供资源管理、工具注册与执行、Prompt 模板定义与渲染，并通过 JSON-RPC 与 LLM 客户端进行上下文服务交互，支持多传输协议以实现安全可扩展的后端上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器，向大型语言模型客户端提供 Home Assistant 的资源、工具和提示模板，并通过 JSON-RPC 标准化通信实现上下文管理、资源访问、工具执行与模板渲染等能力，支持多传输协议（以 WebSocket 为主，REST 提供部分 CRUD 功能），实现对 LLM 的安全、可扩展上下文服务。

基于模型上下文协议（MCP）的本地内存检索与管理后端，提供“搜索/解释/蒸馏/记忆 Pin/导出”等工具，面向与 LLM 客户端的上下文服务与功能扩展。通过 JSON-RPC 风格的 MCP 接口对外暴露服务，支持记忆资源、工具执行、以及提示模板的渲染等能力。

基于 Model Context Protocol (MCP) 的后端服务，提供资源、工具和提示模板的标准化上下文服务，用于向大语言模型客户端提供代码库知识、资源访问、工具执行和提示渲染能力，并通过多种传输协议与客户端进行交互。

基于 Model Context Protocol (MCP) 的后端服务器实现，负责以标准化方式向 LLM 客户端提供上下文信息与功能，包括资源管理、工具注册/执行以及提示模板的定义与渲染；通过 JSON-RPC 与客户端通信，支持会话管理、能力声明，并可通过多种传输协议（如标准输入输出、SSE、WebSocket）实现轻量级、高扩展性的上下文服务。

基于 MCP 协议实现的后端服务器，提供 DaisyUI 组件文档的资源查询与工具调用接口，供 LLM 客户端通过 JSON-RPC 进行组件列表和详细文档的获取与交互。

基于 Model Context Protocol (MCP) 的后端服务器集合，提供可标准化的数据资源访问与工具执行能力，供大语言模型客户端通过 JSON-RPC 进行交互，并通过 STDIO 传输实现跨进程通信，支持多服务器并行运行。该仓库实现了实际可运行的 MCP 服务器端代码，以及与之配套的配置和测试。

在 Cloudflare Workers 上实现的 MCP 服务器，采用插件化架构聚合多家服务（Daiso、CU、Olive Young、Megabox、CGV），通过 JSON-RPC 与 LLM 客户端进行通信，提供资源管理、工具注册与执行、以及 Prompt 模板渲染等核心能力，并对 MCP 客户端提供多种传输与会话管理支持，以及可扩展的 REST 代理与文档端点。

基于模型上下文协议（Model Context Protocol，MCP）的后端服务实现，提供资源管理、工具注册与执行、以及提示模板渲染等能力，并通过 JSON-RPC 与客户端进行通信，支持多种传输方式以为大语言模型应用提供可扩展的上下文服务框架。

基于模型上下文协议（MCP）的后端服务，提供资源管理、工具注册与执行、以及提示模板的统一渲染，通过 JSON-RPC 与 LLM 客户端进行高效的上下文服务交互，支援知识库检索、文档生成、ROI 计算等功能。

基于 Cognithor 的 Model Context Protocol (MCP) 服务器实现，提供资源（Resources）托管与管理、Tool（工具）注册与执行，以及 Prompt 模板的定义与渲染等能力；通过 JSON-RPC 与客户端通信，支持会话管理、能力声明，并具备多传输通道（如 StdIO、SSE、WebSocket）的可扩展上下文服务框架。}

基于 Model Context Protocol (MCP) 的后端服务器实现，向 MCP 客户端提供资源、工具与提示模板等上下文能力，通过 JSON-RPC 进行请求/响应处理，并支持会话管理与多传输协议扩展，适用于将 LLM 客户端接入 Sentinel AI 的上下文服务框架。

基于 Model Context Protocol（MCP）的后端服务，向大型语言模型（LLM）客户端提供标准化的资源托管、工具注册与执行，以及 Prompt 模板渲染等能力，并通过 JSON-RPC 与客户端进行通信，支持可扩展的传输方式与会话管理。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管与访问、工具注册与执行、以及提示模板的定义与渲染，通过 JSON-RPC 与客户端通信，支持多传输协议并具备会话管理和能力声明能力，用于为 LLM 客户端提供统一的上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端服务实现。该仓库提供资源、工具、提示模板等的托管与管理，并通过 JSON-RPC/多传输协议与 MCP 客户端进行交互，实现对上下文信息、工具执行以及提示渲染的标准化后端服务。

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

基于 Model Context Protocol（MCP）的后端实现，为 MCP 客户端提供资源管理、工具注册与执行、以及 Prompt 渲染等功能；通过 JSON-RPC 与客户端通信，支持多种传输模式，面向大型语言模型（LLM）的上下文服务与任务协同。

基于 Model Context Protocol 的后端实现，提供 Gmail 相关的资源、工具与提示模板，通过 JSON-RPC 与 LLM 客户端进行交互，支持资源管理、工具执行与提示渲染等核心能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大型语言模型（LLM）客户端提供结构化的上下文信息、资源、工具和提示模板，并通过 JSON-RPC 进行通信；同时包含资源、工具、提示的托管与渲染、工具发现、元工具接口，以及多传输协议支持与会话管理等完整功能。

基于 Model Context Protocol 的 MCP 服务器实现，提供与 SUMO 交通仿真系统的资源、工具与工作流等能力，通过 JSON-RPC 的标准化接口对接大型语言模型客户端，支持在 STDIO 等传输方式下的交互。

基于 Model Context Protocol (MCP) 的本地化服务器，提供资源、工具与提示模板的标准化管理与访问，并通过 JSON-RPC 与客户端通讯，支持多传输协议（如 stdio/SSE/WebSocket）以便让 LLM 客户端在本地安全、可扩展地上下文化浏览器环境。

基于 Atmosphere 框架实现的 Model Context Protocol（MCP）服务器。该服务端承担资源管理、工具注册与执行、以及 Prompt 模板的渲染等核心 MCP 功能，并通过 JSON-RPC 与 LLM 客户端通信，提供安全、可扩展的上下文服务框架，同时支持多传输协议（WebSocket、SSE、Long-Polling 等）以适配不同场景。

基于 Model Context Protocol (MCP) 的服务器实现与工具包，提供资源托管、工具注册与执行、以及 Prompt 模板渲染等能力，采用 JSON-RPC 与客户端通信，支持会话管理与多传输协议（_stdio、SSE、WebSocket）等，目标为为 LLM 客户端提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源托管、工具注册与执行、以及提示模板渲染等能力，并通过 JSON-RPC 与客户端通信；支持会话管理、能力声明與多传输协议接入，形成可扩展的 LLM 上下文服务框架。该仓库包含完整的 MCP 服务端实现、客户端适配、工具与资源注册，以及相关的测试与示例。注：文档和示例中的实现细节来自代码库中的 mcp 目录及相关模块。

基于 Model Context Protocol (MCP) 的后端服务器实现，用于向大语言模型客户端提供统一的资源访问、工具调用和提示模板渲染能力；通过 JSON-RPC/HTTP+SSE 等协议与客户端通信，支持多传输协议、会话管理与能力声明，便于将上下文、工具和提示模板整合到 LLM 工作流中。

基于 Model Context Protocol (MCP) 的后端服务器集合，为大模型客户端提供资源管理、工具执行与 prompts 渲染等标准化上下文服务，包含药物、蛋白、组学、文献、成像、沙盒等领域服务器，以及 PaperQA 等深度分析组件的本地化实现。

基于 Model Context Protocol（MCP）的后端服务器实现，为 LLM 客户端提供 Cheat Engine 的上下文服务，包括资源管理、工具注册与执行，以及提示模板的渲染与渲染逻辑。服务器通过 JSON-RPC/自定义消息格式与客户端通信，支持会话管理、能力声明，以及多种传输方式，旨在为 AI 应用提供可扩展的内存、调试与脚本化能力覆盖。

基于 Model Context Protocol (MCP) 的后端服务器，负责通过 JSON-RPC 向 LLM 客户端提供上下文信息与功能，包括托管和管理 Resources（资源）、注册与执行 Tools（工具），以及定义与渲染 Prompt 模板与交互模式。服务器负责会话管理、能力声明，并支持多种传输协议（如 STDIO、SSE、WebSocket），为 LLM 应用提供安全、可扩展的上下文服务框架。

基于模型上下文协议（Model Context Protocol，MCP）的后端服务实现，向大语言模型客户端以标准化JSON-RPC方式提供资源、工具和Prompt模板等上下文能力，并通过HTTP传输在人机/代理之间进行可审计的协作与对话管理。

基于 Model Context Protocol (MCP) 的 OmniFocus 后端服务器实现，提供对 OmniFocus 的资源、工具、提示模板的标准化访问，并通过 JSON-RPC 与 LLM 客户端进行通信。服务器底层通过 AppleScript 与 OmniFocus 交互，支持资源管理、工具执行、提示渲染等 MCP 服务器核心能力。

基于 Model Context Protocol (MCP) 的后端服务，作为 Kubernetes 相关上下文信息、工具注册与渲染 Prompt 的标准化提供者，支持与 LLM 客户端通过 JSON-RPC 进行资源访问、工具调用与提示渲染，并提供多传输协议（stdio、SSE、WebSocket 等）以实现安全可扩展的上下文服务。该仓库实现了一个可运行的 MCP 服务端（以 k13d 为 MCP 服务名称），并内置工具注册与 MCP 客户端示例。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管/访问、工具注册/执行、以及 Prompt 模板的定义与渲染，并通过 JSON-RPC/SSE/HTTP 等传输机制与 LLM 客户端进行上下文服务与协作。

基于 Model Context Protocol (MCP) 的后端实现，向 LLM 客户端以标准化方式提供图标资源、可注册的工具以及可渲染的 Prompt 模板，并通过 JSON-RPC 与客户端进行通信，当前实现包含资源查询、图标获取、分类列表等核心功能。

基于 Model Context Protocol (MCP) 的后端服务实现，提供 Flow 工具的注册与执行、资源访问、Prompt 模板渲染等能力，通过 JSON-RPC 与 LLM 客户端（如 Claude Desktop、Cursor 等）进行通信，支持 stdio/http 传输并实现多工具集成的 MCP 服务器核心功能。

基于 Model Context Protocol（MCP）的后端服务，提供标准化的资源、工具、Prompts 的托管与管理，并通过 JSON-RPC 方式与 LLM 客户端通信。支持多源数据接入、工具注册/执行、Prompt 模板渲染，以及对话上下文的统一上下文服务，方便 LLMs 调用外部功能与获取上下文信息。

基于 Model Context Protocol 的随机数工具 MCP 服务器实现，提供随机整数、随机浮点数、带权随机、打乱、取样，以及安全令牌和加密随机整数等工具，面向大模型客户端提供一致的工具调用能力和 JSON-RPC 交互。

基于 Model Context Protocol 的后端服务器，提供资源托管、工具注册与执行、Prompt 模板渲染等能力，并通过 JSON-RPC 与 LLM 客户端通信，支持多传输协议（如 STDIO、HTTP），用于为 LLM 应用提供安全、可扩展的上下文服务框架。

在 Visual Studio 中实现基于 Model Context Protocol 的后端服务器，提供资源、工具执行和提示模板等核心能力，供 Copilot CLI 通过 /ide 与 VS 集成并获得上下文与功能服务。

基于 Model Context Protocol (MCP) 的服务器端实现，负责向 LLM 客户端提供资源托管、工具注册与执行、以及 Prompts 定义与渲染的能力，并通过 JSON-RPC 与客户端通信；支持多传输协议，具备会话管理与能力声明等扩展特性，适合作为 LLM 场景中的上下文服务后端。

基于 Model Context Protocol 的 MCP 服务器实现，暴露 BeigeBox 的工具注册表为 MCP 服务，支持 initialize、tools/list、tools/call 等方法，按 JSON-RPC 2.0 规范与 MCP 客户端通信，方便 Claude Desktop 等客户端直接调用 BeigeBox 的工具能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供 Roslyn 代码理解与分析相关的资源、工具注册与执行、以及可渲染的提示模板能力，通过 JSON-RPC 与客户端通信，支持会话管理和多传输协议接入，用以向 LLM 客户端提供结构化的代码上下文与可执行功能。

基于 Model Context Protocol 的 MCP 服务器实现，提供统一的资源、工具和提示模板的管理与上下文服务，面向 LLM 客户端通过 JSON-RPC 进行交互。

基于 Model Context Protocol（MCP）的后端服务器实现，作为 wt-tools 生态的一部分，向 LLM 客户端提供标准化的上下文信息与功能接口。核心能力包括托管与管理 资源（Resources，如工作树、Ralph 循环状态、团队活动等）、注册并执行 Tools、以及定义/渲染 Prompt 模板等，所有交互通过 JSON-RPC 协议完成，并支持多种传输方式（如 STDIO）。

一个基于 Model Context Protocol (MCP) 的 ServiceNow 后端服务器实现，提供资源管理、工具注册与提示模板的标准化上下文服务，通过 JSON-RPC 与 LLM 客户端通信。

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

基于模型上下文协议（Model Context Protocol，MCP）的后端实现，为大语言模型（LLM）客户端提供统一的资源管理、工具注册与执行、以及可定制的 Prompt 模板渲染等功能，并通过 JSON-RPC 与客户端通信，支持多传输协议与会话管理，构建 AI 场景中的上下文服务核心。

基于 Model Context Protocol 的后端服务，作为 MCP 客户端的上下文信息与功能提供端，托管资源、注册并执行工具、定义并渲染 Prompt 模板，并通过 JSON-RPC 与前端或 LLM 客户端进行通信，支持多种传输协议以实现安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器实现集合，向 LLM 客户端以标准化方式提供资源、工具和提示，并通过 JSON-RPC 进行通信；支持多机器协同、会话管理与多传输协议（如 STDIO、SSE、WebSocket）的可扩展上下文服务框架。仓库内含多个 MCP 服务实例及封装器，用于托管资源、注册工具、渲染Prompts，并提供运行和测试环境。

基于 Hono 的 MCP 服务器实现，提供统一的资源/工具管理、提示模板渲染与 JSON-RPC 通信能力，允许将 Hono API 端点暴露为 MCP 工具供 LLM 客户端调用。

基于 Model Context Protocol 的后端实现，为大型语言模型客户端提供规范化的上下文资源、工具执行和提示渲染能力，支持与客户端通过 JSON-RPC 通信并实现会话、能力声明与多传输适配的后端服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，使用 FastMCP 通过标准的 JSON-RPC 方式向 LLM 客户端提供资源、工具以及提示模板等上下文能力，并实现会话管理、能力声明及多传输协议的扩展接口。该仓库同时提供注册与暴露 MCP Tool 名称与描述的功能，支持与客户端的对等互操作。

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

基于 Model Context Protocol 的 MCP 服务器实现，向 LLM 客户端以标准化方式提供上下文、资源、工具和提示模板等能力，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多传输协议接入，实现对资源、工具与提示的托管与渲染。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行，以及可渲染的 Prompt 模板，面向 LLM 客户端以标准化 JSON-RPC 方式获取上下文信息与外部功能。

基于 Model Context Protocol (MCP) 的后端服务实现，提供资源托管、工具注册与执行，以及可渲染的提示/模板等能力，帮助 LLM 客户端以标准化的 JSON-RPC 方式获取上下文、调用外部功能并渲染提示。仓库内包含多种 MCP 服务器实现（如 stdio 传输与 SSE 传输）的后端实现，具备会话管理、JWT/鉴权、跨传输协议的支持，以及相应的单元测试与示例，用于将 LCYT 的字幕/前端服务与 LLM 集成。

基于 Model Context Protocol（MCP）的服务器实现，提供网页内容获取与转换等工具的 MCP 服务接口，允许 LLM 客户端通过 JSON-RPC 调用工具、检索工具列表并执行网页相关任务，进而得到结构化输出和元数据。该服务明确实现了 MCP 的核心请求处理路径（如 ListTools、CallTool），并提供可运行的服务端代码，作为 MCP 服务器使用。

基于 Model Context Protocol 的 MCP 服务器实现，作为 LLM 客户端的后端上下文服务，提供资源/内存、工具、日志与交互能力，并通过 JSON-RPC 形式与客户端通信，支持多传输协议（如 Streamable HTTP）。

基于 Model Context Protocol (MCP) 的后端服务，能够将 OpenAPI 定义的 REST API 端点暴露为 MCP 工具，并可选地提供 Prompts 和 Resources，支持标准的 JSON-RPC 通信、会话管理以及多种传输方式（Stdio、HTTP streaming）以供 LLM 客户端使用。

基于 Model Context Protocol (MCP) 的后端服务，提供资源管理、工具注册/执行、Prompts 定义与渲染，并通过 JSON-RPC 向 MCP 客户端提供标准化的上下文和功能接口。

基于 Model Context Protocol (MCP) 的服务器实现，用于向 MCP 客户端（如 Claude Desktop、VS Code、Cursor 等）暴露 Agoragentic 市场的资源、工具与提示模板，并通过 JSON-RPC 进行请求/响应与通知。该服务器具备注册、执行、查询能力等核心 MCP 功能，可为 LLM 应用提供统一的上下文与外部能力接入。

基于 Model Context Protocol 的 MCP 服务器后端，实现通过 JSON-RPC 与客户端进行交互，向 LLM 客户端提供资源（Resources）、工具（Tools）以及提示模板（Prompts）的托管、注册、执行与渲染能力，并支持会话管理、能力声明以及多传输协议扩展。该实现不仅提供核心的 MCP 请求处理，还包含可运行的服务器组件与完整的服务逻辑。

基于 Model Context Protocol 的 MCP 服务器实现，在 Windows 上向 LLM 客户端以标准化方式暴露工具、资源与上下文信息，并通过 JSON-RPC 提供本地/远程的上下文服务与自动化能力。

基于 MCP 的后端服务器（Rust 实现），通过 JSON-RPC 提供对 GitHub 数据的实时访问能力，支持标签、变更日志、README、文件树等资源的管理与查询。

Boucle 框架中基于 Model Context Protocol 的服务器实现，将 Broca 内存暴露为 MCP 服务，支持通过 JSON-RPC 与 LLM 客户端进行资源读取、工具调用等交互（当前实现以 stdio 传输为主）。

基于 Model Context Protocol (MCP) 的后端服务器实现，为 LLM 客户端提供标准化的上下文服务：托管资源、注册与执行工具、以及定义渲染 Prompt 的能力；通过 JSON-RPC 与客户端通信，支持会话管理、能力声明和多传输协议（如 Stdio、SSE、WebSocket）等扩展能力。

基于模型上下文协议（MCP）的 AgenC 文档服务端，实现将架构文档以资源形式托管、注册可执行工具、提供可渲染的提示模板，并通过 MCP 服务器对外以标准化的 JSON-RPC 方式与客户端交互，为 LLM 客户端提供文档查询与上下文能力。该服务器属于对外提供上下文与工具的后端组件。<br/>核心能力包括：资源托管与数据访问、工具注册与执行、Prompt 模板定义与渲染，以及通过多传输协议（如 STDIO）实现的 MCP 通信。>

基于 Model Context Protocol 的后端服务，向大语言模型客户端提供资源管理、工具执行与提示模板渲染等能力，支持 JSON-RPC 通信和多传输协议（如 stdio、SSE、WebSocket），实现对会话、能力声明及可扩展上下文服务的统一管理。

基于 Model Context Protocol 的后端实现，提供资源与工具的托管、Prompts 交互以及通过 JSON-RPC 在标准 I/O 流上与 LLM 客户端通信的 MCP 服务器

基于 Model Context Protocol（MCP）的 Kubani 服务器端实现，提供资源与工具的暴露、MCP 的工具调用，以及对外提供的服务器能力声明，支持通过标准的 JSON-RPC 进行客户端请求与响应，适配多种传输方式（如 Stdio、SSE 等）以向 LLM 客户端提供上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端服务实现，提供资源管理、工具注册/执行和Prompt模板渲染，并通过 JSON-RPC 与客户端通信，支持多轮对话与多传输协议（如 STDIO、SSE、WebSocket）。

基于 Model Context Protocol (MCP) 的服务器实现，为 AI 客户端提供 Prometheus 观测数据查询与诊断能力的上下文服务。当前实现通过 MCP 暴露工具（例如 prom_query、prom_targets），即可读取 Prometheus 指标、目标信息等，支持以 JSON-RPC 方式与 LLM 客户端对接，便于 AI 进行系统诊断与自愈场景的上下文访问。

基于 Model Context Protocol 的 MCP 服务器实现与运行框架，提供资源托管、工具注册与执行、以及 Prompt 模板渲染等核心能力，并支持多种传输协议（如 StdIO、HTTP 等）以便为大语言模型客户端提供可扩展的上下文服务。

基于模型上下文协议的 NFL 数据后端，提供资源、工具和提示模板的标准化访问，通过 Streamable HTTP 与大语言模型客户端通信，使用 DuckDB 本地存储并支持数据查询与外部工具调用。

基于模型上下文协议（MCP）的后端服务器实现，聚焦资源管理、工具注册与执行，以及提示模板渲染，为大型语言模型客户端提供标准化的上下文和功能服务，支持多服务器并发、会话管理与多传输协议（如 SSE/HTTP 流、STDIO 等）通信。

基于 Model Context Protocol (MCP) 的后端实现，提供面向 LLM 客户端的上下文与功能服务。核心能力包括托管与管理资源（Resources）、注册与执行工具（Tools）、定义与渲染 Prompt 模板（Prompts），并通过 JSON-RPC 与客户端进行通信；服务器端负责会话管理、能力声明，以及支持多种传输协议（如 Stdio、SSE、WebSocket），为 LLM 应用提供可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具注册与执行、Prompt 模板渲染等核心能力；通过 JSON-RPC 与客户端通信，支持 StdIO 与 HTTP 两种传输模式，并使用 Qdrant 进行向量检索，为 LLM 客户端提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的 MCP 服务器实现，使用 FastMCP 构建并对外暴露天气查询与警报工具，支持通过 JSON-RPC 与客户端进行交互，配合 Gemini API 调用外部天气服务。该实现包含服务器端工具注册、请求处理与响应逻辑，属于完整的 MCP 服务器实现范例。

基于 Model Context Protocol（MCP）的后端服务实现，向大型语言模型（LLM）客户端以标准化方式提供上下文信息与功能：托管资源、注册并执行工具、定义与渲染提示模板；通过 JSON-RPC 与客户端通信，并支持多传输协议（如 STDIO、Server-Sent Events、WebSocket），实现会话管理、能力声明与可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的后端服务实现示例，提供一个可运行的 MCP 服务器，用于暴露工具并通过 JSON-RPC 与 MCP 客户端通信，底层以 Claude Code 的快速 MCP 服务端为例展开实现。该服务器可与多种前端客户端协同工作，支持工具注册、执行与提示渲染等 MCP 相关能力。

基于 Model Context Protocol 的 MCP 服务器实现，向大语言模型客户端提供对 amdWiki 内容、资源、工具和提示模板的上下文化访问，并通过 JSON-RPC 进行通信与能力声明

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具、提示模板的管理与渲染，通过 JSON-RPC 与 LLM 客户端进行通信，支持多租户、向量检索、关系图、访问控制等能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具、Prompts 等上下文信息的托管与渲染，支持通过 JSON-RPC 进行请求/响应，且可通过 stdio 和 HTTP 两种传输方式与 LLM 客户端对接。

基于 Model Context Protocol（MCP）的后端框架，提供资源（Resources）、工具（Tools）、提示模板（Prompts）的托管与管理，并通过 JSON-RPC 与 LLM 客户端进行交互；内置 MCP 服务器实现，支持会话管理、能力声明，以及多传输协议适配，面向 AI 代理和上下文服务场景的扩展型后端解决方案。

基于模型上下文协议（MCP）的后端服务，提供资源管理、工具注册与执行、以及提示模板渲染等能力，并具备策略执行、审计追踪与多传输协议支持的 MCP 服务器实现。通过 JSON-RPC 与客户端通信，支持会话管理、能力声明与多种传输模式，面向高安全性、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源、工具、提示等上下文服务，通过 JSON-RPC 与 LLM 客户端通信，支持 SSE/stdio/WebSocket 等传输，并实现会话管理、持久化存储与内置网页控制台。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具注册与执行、以及提示模板等能力，并通过 JSON-RPC 与客户端通信，内置以 stdin/stdout 形式的传输支持，便于在本地编辑器与 LLM 客户端中集成使用。

基于 Model Context Protocol (MCP) 的完整 MCP 服务器实现，提供资源/工具/提示模板的管理与渲染，支持 Redis 持久化、JSON-RPC 通信以及多传输方式（如 StdIO、HTTP/WS），为 LLM 客户端提供结构化上下文服务与分布式协作能力。

基于 Model Context Protocol (MCP) 的后端服务，向 LLM 客户端提供资源、工具和提示模板等统一的上下文服务，支持 JSON-RPC 通信、会话管理与能力声明，并可通过多传输协议（如 Stdio/ SSE/ WebSocket）与客户端进行安全、可扩展的交互。该仓库实现了完整的 MCP 服务器端逻辑，注册工具、管理资源、定义并渲染提示模板，面向本地离线环境的上下文服务应用。

基于 Model Context Protocol (MCP) 的本地后端服务器，向 LLM 客户端提供资源、工具与提示模板的统一上下文服务。通过 JSON-RPC 与客户端通信，服务器在 FOUNDATION 应用内运行，暴露本地知识图谱、工具执行能力以及可渲染的 Prompt 模板等功能，便于多样化的 LLM 交互场景。

基于 MCP 的后端服务器，向大型语言模型（LLM）客户端暴露 Google Maps Platform 的工具与数据接口，支持通过 JSON-RPC 协议进行资源访问、工具调用与提示渲染。

基于 Model Context Protocol (MCP) 的后端实现，使用 Vert.x 架构通过 JSON-RPC 与客户端通信，提供工具注册、会话管理与能力声明等核心 MCP 功能，支持将生成的上下文和能力暴露给 LLM 客户端以实现高效的上下文服务。

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

基于 Model Context Protocol (MCP) 的服务器实现，作为 SubNetree 后端的一部分，统一向大型语言模型客户端提供上下文资源、可注册与执行的工具，以及可渲染的提示模板。当前实现通过标准输入输出传输（stdio）提供 MCP 服务，内部通过 ReconStore/vault 等模块暴露设备与硬件信息、服务清单等资源，并注册一组工具供 LLM 客户端查询与操作，同时以 JSON-RPC 方式进行请求/响应通信，适合与 Claude Desktop 等客户端进行集成和对接。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具注册与执行，以及可渲染的提示模板，按标准 JSON-RPC 方式与客户端通信，为 LLM 客户端提供统一的上下文数据与外部功能入口。

基于 Model Context Protocol (MCP) 的后端服务，实现对资源、工具、提示模板的管理与渲染，并通过 JSON-RPC（基于 stdin/stdout）与 LLM 客户端进行交互，提供会话管理、工具注册与调用、以及可定制的 Prompt 渲染等能力。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源管理、工具注册/执行、以及 Prompt 模板渲染等能力，并通过 JSON-RPC 与 LLM 客户端通信，用于向本地应用数据、功能和交互模板提供统一上下文服务。

基于模型上下文协议（MCP）的后端服务，提供资源管理、工具注册/执行与提示模板等能力，并通过 JSON-RPC 与 LLM 客户端进行安全、可扩展的上下文服务交互，支持多传输通道（SSE、WebSocket、标准输入输出等）与会话管理。

基于 Model Context Protocol 的 MCP 服务器实现，提供对资源、工具与提示模板的标准化访问与执行能力，支持 JSON-RPC 通信、会话管理以及多传输协议（如 Stdio、HTTP、SSE、WebSocket），用于与 LLM 客户端构建安全、可扩展的上下文服务后端。

基于 Model Context Protocol（MCP）构建的后端服务器实现，提供通过 JSON-RPC 与 LLM 客户端交互的标准化上下文服务。核心功能包括托管与访问资源（资源、数据、索引等），注册与执行工具（Tools），以及定义/渲染提示模板（Prompts），以支撑可扩展的 LLM 场景。服务器实现了基于 STDIO/命名管道等传输方式的 MCP 通信，包含会话管理、能力声明与多传输协议支持，是一个完整的 MCP 服务端实现，而非单纯的客户端示例。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（Resources）、工具（Tools）、以及Prompt模板的注册、管理与渲染，支持 JSON-RPC 形式的客户端交互，并实现会话管理、能力声明与多传输协议（如 STDIO、SSE、WebSocket）下的 MCP 服务，以向大语言模型（LLM）客户端提供标准化的上下文和外部功能能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供对资源、工具和提示模板的托管与渲染，并通过 JSON-RPC 与客户端进行标准化通信；包含从本地或远程 MCP 服务器加载工具的能力，以及将 MCP 请求转换为 LM-Deluge 内部请求、再将响应转换回 MCP 格式的适配器组件，支持多种传输模式，旨在为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的 Kahunas 服务端实现，将 Kahunas API 功能以 MCP 工具的形式暴露给大模型客户端，支持资源管理、工具执行、提示模板渲染等上下文服务，提供 stdio、HTTP/SSE、streamable-http 等传输方式，并通过 JSON-RPC 进行通信与会话管理。

基于 Model Context Protocol (MCP) 的本地后端服务器，实现对资源、工具和提示模板的标准化暴露，提供 JSON-RPC 通信能力、会话管理与任务调度，供 LLM 客户端通过标准接口访问上下文信息与外部功能。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 CodeKG 知识图谱的资源管理、工具执行及 Prompt/上下文渲染能力，并通过 JSON-RPC 与 LLM 客户端进行交互，支持多传输协议以便与各类 AI 客户端集成。

基于 MCP（Model Context Protocol）的本地后端服务器，实现 Resources、Tools、Prompts 的注册、托管与渲染，并通过 JSON-RPC 与客户端（如 Claude Desktop、Cursor 等 MCP 客户端）进行上下文信息和功能的访问与协作，支持多传输协议（stdio、HTTP 等）以实现对 LLM 的上下文服务。

基于 Model Context Protocol 的后端 MCP 服务器实现，提供可执行的 MCP 服务（工具、资源、提示等能力）以供 LLM 客户端访问，采用 JSON-RPC 风格进行通信并支持多种传输方式（如 Server-Sent Events）。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、以及提示模板等能力，并通过 MCP 标准的 JSON-RPC 风格接口与客户端通信，适合作为 LLM 的上下文与功能后端。

基于模型上下文协议（MCP）的后端服务器实现，提供对 S3 兼容存储的资源管理、工具注册与执行、以及输出的提示模板等能力，支持多连接、可扩展中间件/拦截器与多传输协议，面向让大语言模型客户端以标准化方式访问对象存储与相关功能。

基于 Model Context Protocol 的后端服务器，提供对 Midjourney API 的资源、工具和提示模板的统一管理与对接，通过 JSON-RPC 与 MCP 客户端交互，支持本地 STDIO 与 HTTP 传输模式，便于在Claude、VS Code等环境中进行大语言模型驱动的创作工作。

基于模型上下文协议（MCP）的后端服务实现，提供资源、工具、提示模板等能力，使用 JSON-RPC 与客户端通信，包含会话管理、能力声明，以及多传输协议支持的 MCP 服务器实现与服务端逻辑。代码通过 am-cli 提供的服务器入口与工具集成，达到在 LLM 客户端中以标准方式提供上下文信息与外部功能调用的目标。

基于模型上下文协议（MCP）的后端服务实现，标准化向LLM客户端暴露资源、工具与Prompt模板，支持JSON-RPC通信、会话管理与能力声明，并可通过多传输协议（如 Stdio、SSE、WebSocket）提供上下文服务与扩展能力。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源托管与访问、工具注册与执行、以及提示模板的定义与渲染，支持 JSON-RPC 通信和多传输适配的上下文服务框架。

基于 Model Context Protocol 的多语言 MCP 服务器实现集合，提供资源与工具的管理、JSON-RPC 风格请求响应、SSE 推送、健康与监控等核心能力，支持 Go、Python 等语言实现，适合与大语言模型客户端进行模态化上下文服务交互。

基于 MCP 协议实现的本地内存管理服务器，用于存储、检索和管理长期记忆，供 LLM 客户端通过 JSON-RPC 调用访问和扩展上下文信息。

基于 Model Context Protocol (MCP) 的后端服务器实现，聚焦 Azure Retail Pricing，提供资源管理、工具注册与执行、以及提示模板渲染等能力。通过 JSON-RPC 与 MCP 客户端通信，向 LLM 客户端提供 Azure 定价相关的上下文信息和功能，支持会话管理、能力声明与多种传输协议（如 STDIO、SSE/HTTP）。

DivineOS 的 MCP 服务器实现，提供资源、工具、提示模板等通过 JSON-RPC 的方式对外服务，支持多传输协议（stdio、HTTP），并内置完整的工具集供 LLM 客户端调用。

基于模型上下文协议（MCP）的嵌入式后端服务器，部署在 Cytoscape Desktop 中，为大语言模型客户端提供资源访问、工具执行与 Prompt 相关的上下文服务，采用 JSON-RPC 风格通信并支持流式传输。

基于 Model Context Protocol 的后端服务器实现，提供资源、工具和 Prompt 的注册、托管与渲染，并通过 JSON-RPC 与 LLM 客户端通信，支持多种执行环境用于 AI 代理的上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，提供工具注册/执行、资源接口、日志通知和 SSE 传输等能力，供大语言模型客户端以标准化上下文服务进行上下文获取、工具执行和提示模板渲染等任务。

基于 Model Context Protocol 的企业级 MCP 服务器实现，向 LLM 客户端提供资源、工具和提示等上下文信息，通过 JSON-RPC 进行通信，支持多传输通道（stdio、SSE、WebSocket）以实现高效的上下文服务。该仓库内包含完整的 MCP 服务器实现及相关 API、传输、会话与安全机制等模块。

基于 Model Context Protocol (MCP) 的 JSON-RPC MCP 服务器实现，提供资源（Resources）、工具（Tools）和提示模板（Prompts）的托管与管理，并通过统一的 JSON-RPC 与 LLM 客户端通信，支持会话管理与多传输场景。仓库中包含用于 MCP 校验的工具定义、JSON-RPC 路由实现，以及在 Next.js 环境下的服务器端实现代码。该实现不仅提供客户端调用示例，还实现了服务端的鉴权、能力声明与请求分发等核心功能。<div align="center">(MCP 服务器核心功能在 src/app/api/mcp/route.ts，可处理 initialize、tools/list、tools/call、ping 等方法并返回标准 JSON-RPC 响应。)</div>

基于 Model Context Protocol 的通用后端服务器，将任意 REST/OpenAPI 规格暴露给 AI 助手，提供资源管理、工具注册、以及可定制的提示模板等能力，并通过 JSON-RPC 与客户端通信，支持多种传输与安全特性。

基于 Model Context Protocol (MCP) 的服务器实现，提供资源、工具和提示模板的托管与管理，通过 JSON-RPC 与 LLM 客户端进行安全、可扩展的上下文服务交互；底层与 Neo4j 数据库协同，支持多工具执行、上下文组装和生成提示的完整后端服务。

基于 Model Context Protocol (MCP) 的高性能后端，将 Obsidian 符合语义的笔记库暴露为可被大语言模型访问的上下文服务，核心职责包括托管资源、注册与执行工具、以及定义与渲染 Prompt 模板，支持多 Vault 管理与多传输协议。实现了标准化的 JSON-RPC 通信，便于 LLM 客户端进行读取、调用外部工具、以及获取 Prompts 的能力声明与渲染。

基于 Model Context Protocol (MCP) 的 OpenStudio 后端服务器，向大型语言模型 (LLM) 客户端提供标准化的上下文信息与功能。核心职责包括托管和管理 OpenStudio 资源（如模型、设计日、结果等）、注册和执行工具（Tools，供 LLM 调用外部功能）、定义与渲染 Prompt 模板，并通过 JSON-RPC 与客户端通信实现会话管理、能力声明与多传输协议支持（如标准输入输出、服务器发送事件、WebSocket 等）。通过一个内存中的模型管理器维护模型状态，运行结果与跑步(Runs)输出存放在 /runs，提供安全、可扩展的后端服务框架。该实现面向与 OpenStudio/EnergyPlus 的集成与自动化工作流场景，方便将 LLM 的推理过程与能源模型操作结合起来。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 Resources、Tools 与 Prompts 的标准化管理与访问，并通过 JSON-RPC 与客户端进行通信，支持多传输方式以提供安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的服务端实现，将 SmartLead API 以 MCP 工具形式暴露给 LLM 客户端，支持资源管理、工具注册与执行、提示模板渲染等核心能力，且通过 JSON-RPC 方式与客户端通信，具备会话管理、能力声明及多传输协议兼容（如 StdIO）等特性。

基于 Model Context Protocol 的 MCP 服务器实现，为本地知识引擎提供标准化的资源管理、工具注册与执行、以及 Prompt 模板渲染，并通过 JSON-RPC 与 LLM 客户端通信，支持多传输协议与会话管理，适用于离线或私有环境的上下文服务场景。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供向 LLM 客户端按标准化方式暴露资源、工具与 Prompt 模板的能力。服务器通过 JSON-RPC 风格的协议与客户端交互，支持本地代码索引、插件化语言工具、语义检索以及可扩展的上下文服务，适用于在本地环境或容器中为 AI 助手提供代码理解与上下文数据。

基于 Model Context Protocol 的 MCP 服务器实现，能够托管资源、注册工具、定义和渲染 Prompt，支持 JSON-RPC 通信，具备本地与嵌入式 MCP 服务器的管理能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供工具注册、API 访问、Prompts/输出渲染能力，并通过 JSON-RPC 与 LLM 客户端通信，支持 STDIO 与 SSE 等传输方式，以为大语言模型提供标准化的上下文与外部功能访问。

基于模型上下文协议（MCP）的后端服务实现，提供对 Enjoy 游戏的工具管理与查询能力，通过 JSON-RPC 形式与 MCP 客户端（如 Claude）进行交互，核心功能聚焦工具注册与调用，支持通过标准化接口获取项目状态、排行榜、玩家信息、GitHub 活动等数据。该实现使用 Stdio 传输，适合嵌入到 Claude Code/桌面端等工作流中进行上下文服务接入。

基于 Model Context Protocol 的图像编辑 MCP 服务器，提供工具集成、任务执行与插件化扩展，通过 JSON-RPC 与 LLM 客户端进行交互，支持在 Minecraft 内容工作流中对纹理和图片进行实时处理。

基于模型上下文协议(MCP)的后端服务器实现，暴露 Docketeer 的工具注册表给 MCP 客户端，以便读取工具信息、执行工具并记录审计日志，支持通过 JSON-RPC 与客户端进行交互。

基于 Model Context Protocol (MCP) 的后端服务，提供资源、工具和提示模板等上下文能力，采用 JSON-RPC 与客户端通信，支持多种传输方式（stdio、HTTP/SSE 等），并实现了 10 个 MCP 工具以便 Claude Code 进行高效、上下文化的回答与操作。

Overlord 提供基于 Model Context Protocol (MCP) 的服务器端实现，用于向 LLM 客户端以标准化的上下文服务方式暴露资源与工具、执行工具、以及可渲染的提示模板，并通过 JSON-RPC/Socket.IO 等协议进行通信，同时对 MCP 子服务器进行托管、管理与自动重连。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源/工具/提示的托管与管理，通过 JSON-RPC 与 LLM 客户端通信；整合 Claude Code、WebSocket 通信、实时会话监控与 API 代理等组件，实现可扩展的上下文服务框架。

基于 Model Context Protocol 的后端服务器实现，通过 JSON-RPC 规范向 LLM 客户端提供 Harness 平台的资源、工具与提示模板等上下文服务，支持多传输协议与会话管理，具备完整的工具注册、资源注册与提示模板渲染能力。

基于 Model Context Protocol (MCP) 的后端服务器，为本地 AI 客户端提供资源管理、工具注册与执行、以及 Prompt 模板渲染等上下文服务，支持 JSON-RPC 通信、以及多传输协议信息（如 STDIN/STDOUT、SSE、WebSocket），实现会话管理、能力声明，并提供插件化的工作流与工具执行能力。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源托管、工具注册与执行、Prompt 定义与渲染，并通过 JSON-RPC 与客户端通信，支持多种传输协议，用以向 LLM 客户端提供一致的上下文与功能。若干资源、工具和提示可通过 MCP 服务器集中管理与渲染，适用于 Claude Desktop 等集成场景。

基于 Model Context Protocol (MCP) 的桌面UI自动化后端，提供 JSON-RPC 接口用于向LLM客户端暴露资源管理、工具注册/执行与提示模板渲染等能力。核心实现包含在 macOS 上的无头/交互式Accessibility引擎、跨平台框架占位，以及对MCP初始化、工具执行等请求的处理与响应。

基于 Model Context Protocol (MCP) 的后端服务端实现，提供对资源、工具、提示模板的托管与渲染，使用 JSON-RPC 与客户端通信，默认通过标准输入输出进行交互，支持多传输通道的扩展能力，为大模型客户端提供高效的上下文与功能服务。

基于 MCP 标准的后端服务器，提供资源、工具与提示模板的注册、读取与执行，并通过 JSON-RPC 与客户端进行通信，支持在 Cloudflare Worker 环境中运行，面向 LLM 客户端提供标准化的上下文与能力服务。

基于 Model Context Protocol 的 MCP 服务器，运行在 ESP32（以及 Nordic nRF52840 的传感器端模式），通过 WebSocket/JSON-RPC 提供资源管理、工具注册与调用、以及可渲染的 Prompt 模板等能力，面向 LLM 客户端实现上下文与功能服务。

基于模型上下文协议（MCP）的后端服务器实现，提供用于 Claude Code 文档查询的工具集，并通过 JSON-RPC 风格请求/响应与客户端进行交互，具备可运行的服务端能力和简单的资源/工具暴露能力。

基于 Model Context Protocol 的后端实现集合，提供用于 LLM 的上下文资源管理、工具执行与提示模板渲染的 MCP 服务器。仓库中包含多个独立的 MCP 服务器实现（如 Context Hub、Service Registry、Service MCP 等），通过 JSON-RPC 对外暴露工具集和接口，支持与 Claude Code、Clawdbot 等 MCP 客户端进行交互，以及与 Context Hub 的交互与协作。

基于 Model Context Protocol (MCP) 的后端服务器实现，暴露 JustOneAPI 的工具与资源，向大型语言模型客户端提供统一的上下文访问入口，并原样返回上游 API 的原始JSON数据以保持数据保真。

基于 Model Context Protocol (MCP) 的后端服务器实现，整合向量检索、知识图谱与网页智能等能力，向大型语言模型客户端以标准化的 JSON-RPC 提供资源、工具和提示模板等上下文服务，包含会话管理、能力声明、鉴权与多种传输协议的支持。

基于 PHP 实现的 MCP（Model Context Protocol）服务器，提供对 MariaDB/MySQL 的只读上下文服务、工具调用与查询审计，支持通过 JSON-RPC 与 LLM 客户端交互。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源管理、工具注册与执行、Prompt 模板渲染等核心 MCP 功能，供 LLM 客户端通过 JSON-RPC 进行资源访问、工具调用与提示渲染等操作。

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

基于 Model Context Protocol (MCP) 的后端服务器，提供与 Factorial HR API 的集成，向大语言模型客户端暴露资源、工具与提示模板，并通过 JSON-RPC（STDIO/HTTP等传输）进行标准化通信与会话管理。

基于 Model Context Protocol 的后端实现，提供对资源、工具与 Prompt 的标准化管理与读取，并通过 JSON-RPC 与 LLM 客户端进行交互，以实现可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，通过 JSON-RPC 提供资源管理、工具调用和爬取功能，并以 STDIO 方式运行的 MCP 服务端，用于向 LLM 客户端提供网页抓取与站点爬取能力。

基于 Model Context Protocol (MCP) 的后端服务，提供资源、工具和提示模板的标准化管理与 JSON-RPC 通信，支持多传输协议、会话管理与权限控制，为大型语言模型提供可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器，暴露 Harmonica 会话管理、数据查询与 AI 助手工具给 LLM 客户端，使用 JSON-RPC 进行通信，并支持多种传输方式（如 Stdio）以提供可扩展的上下文服务。

基于 MCP 架构的后端服务器，为大语言模型（LLM）客户端提供对 Yandex Wiki 的页面读取与写入、以及相关工具的访问与缓存支持，通过 JSON-RPC 提供统一接口，支持读写模式并可选 Redis 缓存。

基于 Model Context Protocol (MCP) 的后端实现，提供通过 JSON-RPC 方式与客户端通信的 MCP 服务器能力，核心职责包括托管资源、注册与执行工具、以及定义与渲染提示模板，支持跨组织的上下文服务与证据管理。

基于模型上下文协议（MCP）的后端服务器，为大语言模型客户端提供 Foundry 文档的上下文、检索、工具执行和 Prompt 渲染等能力，并通过 JSON-RPC 与客户端进行通信，实现资源管理、工具注册/执行和 Prompt 定义的标准化后端服务。

基于 Model Context Protocol 的 MCP 服务器实现，使用 PHP 搭建，提供对 MariaDB/MySQL 的只读上下文服务、工具注册与执行、以及提示模板渲染等能力，并通过 JSON-RPC 与客户端通信以支持 LLM 的上下文获取与外部功能调用。

基于 Model Context Protocol (MCP) 的后端服务器集合，提供多源学术检索（OpenAlex、Scopus、Web of Science）与资源/工具/提示模板的统一管理与渲染。通过 JSON-RPC 风格的 MCP 规范，与客户端进行资源读取、工具调用和提示渲染等交互，支持标准传输（当前实现为 stdio），并涵盖会话管理、能力声明以及跨源结果聚合与去重等核心能力，便于在 LLM 端构建可扩展的上下文服务。

基于 Model Context Protocol 的本地后端服务器，向大语言模型客户端提供统一的资源管理、工具注册与执行、以及可定制的提示模板渲染，全部通过 JSON-RPC 与客户端通信，支持多种传输通道以实现安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务，提供标准化的资源、工具和提示模板管理能力，供大语言模型（LLM）客户端通过 JSON-RPC 调用，实现对 Webhooks 场景的上下文服务、工具执行与数据访问。该仓库包含可运行的 MCP 服务器实现及对应工具集，用于将 AI 助手接入 webhooks 平台的资源与功能。

基于 Model Context Protocol (MCP) 的服务器实现，用于将 Kunobi 桌面应用的多变体环境、可用工具、资源与提示以标准化的 MCP 形式暴露给 LLM 客户端，支持多变体自动发现、动态注册与工具调用等能力。

基于 Model Context Protocol (MCP) 的后端实现，为 LLM 客户端提供标准化的上下文与功能服务，核心包括资源（Items/Tags/Users）的托管、工具（如搜索、获取、更新、创建等）注册与执行，以及通过 MCP JSON-RPC 与客户端通信的能力，支持 HTTP 传输并具备会话管理与能力声明。

基于 Model Context Protocol 的后端服务器实现，向大语言模型客户端提供资源管理、工具注册与执行、以及可定制的 Prompt 模板渲染等上下文服务；通过 JSON-RPC 进行通信，支持会话管理、能力声明、并发执行、热加载与观测等特性，具备完整的服务端框架与扩展能力。

基于 Model Context Protocol 的本地提示压缩服务端，暴露 compress_prompt 工具，使用 Ollama 的 llama3.2:1b 进行文本压缩并通过 nomic-embed-text 进行嵌入验证，向 MCP 客户端提供压缩文本及相关元信息。

基于 MCP（Model Context Protocol）的内存管理服务器，实现对 Falcon AI Agent 的记忆资源的持久化管理、工具注册与执行、以及简易的上下文服务能力，通过 JSON-RPC 与客户端进行通信。

基于 MCP（Model Context Protocol）的 HTTP 流式后端服务，通过逐会话创建子进程来实现沙箱化上下文和工具调用的安全隔离，支持资源/工具的托管，以及基于 Prompts 的交互模板渲染；客户端通过 JSON-RPC 与桥接服务通信，桥接再与底层 MCP 子进程对接，采用 POST 请求+ SSE 推送的流式传输模式。该实现覆盖初始化握手、根目录（roots/list）协商、沙箱锁定以及会话终止等核心 MCP 语义，并提供多种传输模式（STDIO、HTTP 桥接、SSE 等）以支持多样化的 LLM 客户端场景。<br/>注：核心 MCP 服务器组件由 ahma_mcp 子系统提供，ahma_http_bridge 负责作为“服务器端”的桥接实现，连接客户端与 MCP 子进程。

基于 Model Context Protocol (MCP) 的后端实现，作为 QueryWeaver 的 MCP 服务器，通过标准化的 MCP HTTP 面向 LLM 客户端提供资源托管、工具注册与执行，以及 Prompt 模板渲染等上下文服务，并通过 JSON-RPC 进行通信与会话管理。

一个基于 Model Context Protocol（MCP）的后端服务，提供安全审计与自动修复的代码上下文服务，通过 MCP 与客户端进行 JSON-RPC 通信。

基于 Model Context Protocol 的后端服务实现，提供资源管理、工具注册与调用、以及提示模板渲染等核心功能，通过 JSON-RPC 与大语言模型客户端进行标准化上下文服务交互，支持本地文件存储+向量检索等能力。

基于 Model Context Protocol (MCP) 的音乐分数生成与编辑后端服务器，提供资源/工具/提示模板的管理与执行，并通过 MuseScore、Dorico、Sibelius 的远程控制桥接与 LLM 进行标准化的上下文服务交互。

基于 Model Context Protocol（MCP）的后端服务，实现标准化的上下文提供与外部功能调用能力。该服务器托管资源与工具，定义并渲染 Prompt 模板，支持 JSON-RPC 通信，提供会话管理与跨传输协议（如 StdIO、SSE、WebSocket）等能力，专为 Claude Desktop/Cowork 等客户端提供并行化的上下文服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大型语言模型客户端提供资源管理、工具注册与执行、以及可定制的 Prompt 模板渲染等上下文服务，支持 JSON-RPC 通信并可通过 STDIO、HTTP、SSE、WebSocket 等传输协议接入客户端。

基于 Model Context Protocol (MCP) 的后端服务，提供资源托管、工具注册与执行以及可渲染的 Prompt 模板，旨在以标准化的 JSON-RPC 方式向 AI 客户端提供代码上下文与功能支持，并可通过多种传输协议与会话管理实现安全、可扩展的 MCP 服务。

基于 Model Context Protocol (MCP) 的服务器端实现，作为 MCP 客户端与后端 MCP 服务之间的桥接层，提供对 Tools 的发现、调用和输入/输出模式的支持，并通过 JSON-RPC 与客户端通信，支持本地 STDIO 与 Streamable HTTP 等传输方式的接入。

基于模型上下文协议（Model Context Protocol，MCP）的后端服务器，向大模型客户端以标准化方式提供上下文信息与功能。核心能力包括托管与管理资源、注册并执行工具、定义与渲染提示模板；通过 JSON-RPC 实现与客户端的通信，支持会话管理与多传输通道（如 StdIO、SSE、WebSocket），并提供安全、可扩展的上下文服务。

基于 Canopy 的 MCP（Model Context Protocol）后端实现，提供资源、工具与提示模板等上下文服务，并通过 STDIO/HTTP 等传输协议与 LLM 客户端进行 JSON-RPC 通信与协作。

基于 Model Context Protocol (MCP) 的服务器实现，作为后端服务向 LLM 客户端提供标准化的上下文信息与功能。核心职责包括托管与管理 资源(Resource)、注册与执行 工具(Tools)、定义与渲染 Prompt 模板(Prompts)，并通过 MCP 规范的协议与客户端进行 JSON-RPC 风格的请求/响应交互，支持会话管理、能力声明，以及对接 Core/扩展组件的桥接能力。

基于 Model Context Protocol (MCP) 的 MCP 服务器实现，向 LLM 客户端以标准化方式暴露 Godot 的资源、工具与 prompts，并提供多引擎执行（Headless、Runtime、LSP、DAP）以及会话管理等能力。

基于 MCP 协议的异步后端实现，为 LLM 客户端提供 Azure AI Foundry 的模型调用、资源管理与提示渲染能力，并通过标准化的 JSON-RPC 交互实现工具执行与会话管理。

基于 Model Context Protocol (MCP) 的服务器端实现，作为后端上下文服务提供者，统一托管资源（Resources）、注册与执行 Tools、以及渲染 Prompt 模板；通过 JSON-RPC 与客户端进行通信，支持多传输模式（如 Stdio、SSE、WebSocket），实现会话管理和能力声明，帮助 LLM 客户端以标准化方式获取上下文、外部功能和提示模板。

基于 Model Context Protocol (MCP) 的本地 MCP 服务器集成于 SnapTray 主应用，向本地的 LLM 客户端提供资源、工具与 Prompt 模板的统一访问与执行能力，并通过本地 HTTP 的 JSON-RPC 进行通信。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具和 Prompt 的标准化管理，并通过 JSON-RPC 与客户端通信；支持 stdio 与 HTTP 传输，具备会话管理、能力声明和多传输协议扩展能力，旨在为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务，Graph-It-Live 提供完整的资源管理、工具注册与执行、以及可渲染的 Prompt 模板，面向 LLM 客户端以 JSON-RPC 方式提供依赖分析、符号图、调用图等能力，并支持多传输协议实现安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的服务器端实现，作为后端后置服务提供对资源、工具与提示模板的管理和执行能力。通过 JSON-RPC 与 LLM 客户端通信，统一托管资源、注册并执行工具、渲染并提供 Prompt 模板，支持多工具组合及可扩展的上下文服务能力，并内置监控、信任评估与鲁棒的错误处理。

基于 Model Context Protocol (MCP) 的后端服务器，提供对 AI 代理目录的发现、检索、健康与统计等信息的标准化访问接口，支持多工具方法以便 LLM 客户端查询与集成。

基于 Model Context Protocol（MCP）实现的后端服务器，为大型语言模型客户端提供标准化的上下文服务，包含资源管理、工具注册与执行、以及 Prompt 模板渲染等核心能力，并通过 JSON-RPC 与客户端通信，支持标准化传输通道（如 STDIO、HTTP）。

基于 Model Context Protocol (MCP) 的后端服务器，向 MCP 客户端提供 Agoragentic 市场的能力、资源、提示等上下文服务与执行能力，并通过 JSON-RPC 与客户端通信。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具暴露与提示模板渲染等核心能力，通过 JSON-RPC 与 AI 客户端通信，支持多传输模式，具备会话管理与能力协商能力。

基于 Model Context Protocol 的 MCP 服务器实现，作为后端为大语言模型客户端提供标准化的上下文信息、资源数据、工具执行能力以及自定义提示模板等功能，支持 JSON-RPC 通信、会话管理和多种传输协议。

基于 Model Context Protocol 的 MCP 服务器实现，利用 llms-full-unbind 解析的 llms-full.txt 文件提供文档读取与搜索等工具，向 LLM 客户端以标准化的 JSON-RPC 形式暴露能力，并通过 stdio 传输等多种通道进行通信。

基于 Model Context Protocol (MCP) 的后端服务，提供资源托管、工具注册与执行，以及提示模板渲染，并通过 JSON-RPC 与客户端进行标准化交互。

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 RuVector 生态的一部分，负责通过标准化的 JSON-RPC 向 LLM 客户端提供上下文信息和功能。核心职责包括托管与管理 Resources（资源数据访问）、注册并执行 Tools（工具调用）、定义与渲染 Prompts（提示模板），并支持多传输协议（如 Stdio、SSE、WebSocket）。服务器端负责会话管理、能力声明与扩展性配置，适配多种客户端场景，提供安全、可扩展的上下文服务框架，支持与 RuVector 其他组件的无缝对接。

基于 Model Context Protocol (MCP) 的后端服务实现，将 Charles Proxy 的上下文数据以资源、工具与提示模板等形式暴露给 LLM 客户端，通过 JSON-RPC 进行通信，支持实时 live 捕获、历史快照、分析与分组等功能，构建一个可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的后端服务器，通过 JSON-RPC 标准向 MCP 客户端提供 Resources、Tools 与 Prompts 的注册、查询、执行与渲染等核心能力，并支持会话管理与多传输协议接入。

基于 Model Context Protocol (MCP) 的后端服务器实现，使用 Rust 编写并通过 JSON-RPC 与 MCP 客户端通信，提供记忆资源管理、工具注册与执行、以及可定制的提示/交互模板渲染能力；支持自带的内存后端、嵌入向量与混合检索、以及可选的 LLM 自动提取与知识 consolidating 流程，具备会话管理与多种传输形态的扩展能力。

基于 Model Context Protocol (MCP) 的 NotebookLM 后端服务器实现，提供资源、工具和提示的标准化管理与渲染，支持通过 JSON-RPC 与 LLM 客户端通信，具备会话管理、能力声明以及对多种传输协议的支持，适用于将 NotebookLM 的上下文和功能暴露给强大的 AI 助手。

一个将 Model Context Protocol (MCP) 服务器能力嵌入 Hydra 守护进程的实现，用于向本地 LLM 客户端提供资源管理、工具执行和提示模板渲染等能力，并通过 HTTP/SSE 传输进行 JSON-RPC 交互。

基于 Model Context Protocol (MCP) 的后端服务实现：提供资源托管、工具注册/执行、以及提示模板的定义与渲染，并通过 JSON-RPC 与 LLM 客户端进行标准化上下文服务交互（资源访问、工具调用、Prompts 获取/渲染等），支持多传输协议以实现安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源/工具/提示等标准接口，并通过 JSON-RPC 风格的通信为 LLM 客户端提供上下文服务与多代理协作能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管、工具注册与执行、及 Prompt 模板渲染，通过 JSON-RPC 与 MCP 客户端通信，支持会话管理、能力声明与多传输协议（如 STDIO、SSE、WebSocket）的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具、提示模板等的注册、管理与执行能力，并通过 JSON-RPC 形式对接 LLM 客户端，支持会话管理、能力声明以及多传输通道（如 HTTP、StdIO、SSE/WebSocket 之类扩展）的上下文服务框架。

基于 CodeKG 的 Model Context Protocol (MCP) 服务器实现，向 LLM 客户端以标准化 JSON-RPC 方式提供资源数据、工具调用与提示模板等上下文服务，并实现会话管理、能力声明与多传输协议支持（如 STDIO、SSE、WebSocket）。

基于 Model Context Protocol 的服务器端实现，提供面向大语言模型客户端的资源、工具和提示模板等上下文服务。仓库内包含多个并行的 MCP 服务端模块（如用户管理、图表、BPMN、图像生成等），通过 JSON-RPC 形式与客户端通信并支持多种传输通道（如 SSE、WebSocket/流式传输等）。该实现集成于 Reflex 应用之中，提供会话管理、能力声明和安全特性，能够作为后端 MCP 服务提供者供 LLM 客户端调用和上下文获取。

基于模型上下文协议（MCP）的服务端实现，提供一个可运行的服务器用来暴露 Agent Reach 的状态与功能给 MCP 客户端，通过 JSON-RPC 方式进行调用与响应。

基于 Model Context Protocol (MCP) 的后端服务，实现资源（Resources）、工具（Tools）和提示模板（Prompts）的管理与渲染，提供标准化的 JSON-RPC 交互给 LLM 客户端，并支持多种传输方式（stdio、Streamable HTTP、SSE/WebSocket 等）以及 OAuth2 安全认证，是一个面向 MCP 客户端的后端服务实现。

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 Tilth 的 MCP 服务端，通过 JSON-RPC 在标准输入输出（stdio）上与客户端通信，向 LLM 客户端提供资源、工具注册与执行、以及提示模板的管理与渲染等能力，支持会话管理、能力声明以及多种工具接口

基于 Model Context Protocol (MCP) 的后端服务实现，用于向 LLM 客户端以标准化方式暴露资源、工具与提示模板；通过 JSON-RPC 与客户端通信，内置本地 MCP 服务与可选的 FastMCP 适配，支持通过标准输入输出（stdio）方式作为 MCP 服务器运行。

基于 Model Context Protocol (MCP) 的自托管后端服务器实现，提供资源、工具、提示等标准化接口，并通过 JSON-RPC（stdin/stdout）与 LLM 客户端交互，支持内存存储与检索、知识图谱链接、提示渲染，以及本地内存浏览器等扩展功能。

基于 Model Context Protocol 的后端服务，提供资源管理、工具执行和提示模板等能力，通过 JSON-RPC 与 LLM 客户端交互，实现对 Fiddler 实时 traffic 的 MCP 封装与分析。

基于 MCP 协议的后端服务，暴露文本转语音（TTS）功能为可通过 JSON-RPC 调用的工具，供大语言模型客户端在对话中按需进行语音输出与会话管理扩展。该实现提供一个注册的 speak 工具，通过标准 MCP 机制接收文本输入并返回语音执行结果或错误信息。

基于 Model Context Protocol 的 MCP 服务器实现，作为后端上下文服务中枢，托管资源、注册并执行工具、渲染可自定义的 Prompt 模板，并通过 JSON-RPC 提供统一的上下文服务接口给 LLM 客户端。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供通过 MCP 客户端进行 WhatsApp 消息收发、工具执行和对话上下文管理的能力，支持多种传输方式及会话持久化。

基于模型上下文协议（MCP）的后端服务，向 MCP 客户端提供资源、工具注册/执行以及提示模板渲染等上下文服务，通过 JSON-RPC 与客户端通信，支持会话管理和多种传输模式以支撑 LLM 应用的安全上下文服务。

基于 Model Context Protocol (MCP) 的 MCP 服务器实现，提供可运行的浏览器自动化技能服务，通过 JSON-RPC 与客户端通信，注册并执行工具、管理资源与提示模板，供 LLM 客户端调用实现浏览器操作。

基于 Model Context Protocol (MCP) 的后端服务器实现，用于对选项策略进行筛选、回测仿真、数据加载与工具执行，并通过 JSON-RPC 的 MCP 协议与客户端交互，提供资源管理、工具注册/执行、以及可渲染的 Prompt 模板支持。

基于 Hydra 的 MCP 服务器实现，提供资源、工具与 Prompt 的标准化上下文服务，并通过 JSON-RPC 与客户端通信以支持多轮对话与上下文管理。

基于 Model Context Protocol（MCP）的 JSON-RPC 服务器实现，作为 gdcli 的内置组件，向 LLM 客户端暴露 Godot 项目的资源、工具、以及提示模板等能力，并通过标准输入输出进行 JSON-RPC 通信，支持以 stdio 传输的 MCP 客户端交互模式。该实现不仅提供运行在服务器端的 JSON-RPC 处理，还将现有的 gdcli 命令（如 doctor、scene、node、run 等）封装为 MCP 工具，供客户端远程注册和执行。

基于 Model Context Protocol (MCP) 的服务器实现，向大型语言模型客户端提供标准化的上下文资源、工具执行和可渲染的提示模板，采用 JSON-RPC 的通信方式，并支持多传输协议接入与会话管理，旨在为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的多组件后端服务集合，向 LLM 客户端以标准化的 JSON-RPC 方式暴露资源、工具与 Prompts 等上下文信息与功能，支持统一或分布式部署，用于对家庭/本地网络环境的上下文管理、监控与自动化集成。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对欧洲议会开放数据的结构化上下文访问、工具注册与调用、以及可渲染的提示模板，客户端通过 JSON-RPC 与之通信，支持多种传输方式并具备会话管理与安全合规能力。

基于模型上下文协定（MCP）的后端服务器实现，提供资源管理、工具注册/执行、以及提示模板渲染等核心能力，并通过 JSON-RPC/SSE 提供给 LLM 客户端使用的上下文服务与功能调用入口，同时包含 REST API、权限与计费等完整实现。

基于 Model Context Protocol 的简单 MCP 服务器，提供对 Star Wars API 的资源与工具的暴露与管理，便于通过标准化的 MCP 客户端进行上下文服务调用。

基于 Model Context Protocol 的后端服务器实现，向语言模型客户端提供标准化的上下文信息和功能。核心能力包括托管与访问资源、注册与执行工具、定义与渲染 Prompt 模板；通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多种传输协议（stdio、SSE、WebSocket），为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供 Sitecore GraphQL 的资源、工具与提示模板，以 JSON-RPC 形式通过标准传输（如 STDIO）与 LLM 客户端通信，支持对 Sitecore 内容上下文的管理与外部功能调用。

基于 Model Context Protocol（MCP）的后端服务器实现，向大语言模型客户端提供规范化的上下文服务，包括资源管理、工具注册与执行，以及可定制的提示模板渲染；通过 JSON-RPC 进行通信，支持多种传输模式（如 stdio、HTTP/Streamable HTTP），并实现会话管理与能力声明，适用于在本地搭建的 MCP 服务端场景。

基于 Model Context Protocol (MCP) 的多引擎后端服务器集合，核心职责是通过 JSON-RPC 2.0 与 LLM 客户端通信，提供资源托管与数据访问、注册和执行工具、定义与渲染 Prompt 模板等能力，支持多种传输形态并实现会话与能力声明，适合将 AI 客户端接入到各种构建、测试、环境管理等后端服务场景。

基于 Model Context Protocol 的 MCP 服务器，向 LLM 客户端以标准化方式提供资源、工具与 Prompts，并通过 JSON-RPC 进行通信，支持会话管理、插件运行时以及多传输协议。

基于 Model Context Protocol (MCP) 的后端服务，向 LLM 客户端提供工具、资源和 Prompt 渲染等上下文能力。仓库实现了两个 MCP 服务器（send-turtle 与 bot-control），通过 JSON-RPC 草案标准与客户端通信，并使用文件系统 IPC 机制协调后台任务与 Claude Telegram Bot 的交互。

基于 Model Context Protocol 的 MCP 服务器实现，作为 Cloudflare Worker 提供对 agents-radar 摘要数据的标准化访问接口，支持 list、get、get_latest、search 等工具的 JSON-RPC 调用，以便 MCP 客户端查询最新报告、历史报告及关键关键字搜索。

基于 Model Context Protocol（MCP）的后端服务器，向 LLM 客户端提供资源、工具与 Prompt 模板等统一上下文服务，并通过 JSON-RPC 与客户端进行请求/响应交互，附带会话管理与能力声明，支持多传输协议以实现安全、可扩展的上下文服务框架。

基于模型上下文协议（MCP）的后端服务器实现，利用 WebMCP 框架暴露资源、工具和提示模板，支持 JSON-RPC 调用和多传输通道，以便向 LLM 客户端提供可扩展的上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，提供对 ARIA 规范数据的资源、工具与提示模板的标准化 JSON-RPC 访问，并支持本地（STDIO）和远程（Netlify Functions）传输方式。

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

基于模型上下文协议（MCP）的后端服务，提供 Pancake POS 的资源访问、工具执行与对话相关能力，通过 JSON-RPC 与客户端通信，支持本地 stdio 与 HTTP 两种传输模式。

基于 Model Context Protocol (MCP) 的 JSON-RPC 2.0 服务器实现，提供资源管理、工具调用与上下文提示渲染，作为 Claude Code 等客户端的后端上下文服务，采用标准输入输出传输进行通信。

基于 Model Context Protocol 的桌面后端实现，提供资源、工具与提示模板的托管与管理，并通过 JSON-RPC 在本地与远程客户端通信；包含会话管理、能力声明以及对多传输协议的支持，便于在本地环境下为 LLM 客户端提供结构化上下文与外部功能调用能力。

基于 Model Context Protocol 的 MCP 服务器实现，作为后端服务向 LLM 客户端暴露资源、工具和提示模板等上下文信息，通过 JSON-RPC 提供资源访问、工具执行和提示渲染能力，支持会话管理与多传输协议的扩展能力。

基于 Model Context Protocol（MCP）的服务器端实现，提供资源、工具、提示模板管理，并通过 JSON-RPC 与客户端进行上下文与功能协作，支持多传输协议用于与大语言模型客户端对接。

基于 Model Context Protocol（MCP）的后端服务，向 LLM 客户端提供标准化的上下文信息和功能。通过 JSON-RPC（以 STDIO 传输为主）与客户端通信，支持托管资源、注册和执行工具、以及定义/渲染 Prompt 模板，并结合 OpenTelemetry 实现可观测性与可扩展性。

Spacebot 的 MCP 服务器实现，提供资源管理、工具注册与执行、以及 Prompt 模板渲染等能力。通过 MCP 标准协议与客户端进行 JSON-RPC 通信，支持本地 stdio 与 HTTP 传输，并在配置中实现对 MCP 服务器的注册、监控与热重载，作为多进程/多任务 AI 应用的上下文与工具服务后端。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行，以及提示模板渲染等能力，供 LLM 客户端以统一的 JSON-RPC 风格通过 MCP 进行访问与调用。

基于 Model Context Protocol 的后端服务实现，提供资源管理、工具注册/执行、以及 Prompt 模板渲染等核心能力，并通过 JSON-RPC 与客户端进行通信，支持会话管理与多传输协议。

基于 Model Context Protocol (MCP) 的后端服务器实现集合，提供资源管理、工具注册/执行以及提示/模板渲染等能力，供 LLM 客户端通过 JSON-RPC 与多种 MCP 服务器进行交互。仓库内包含多个独立的 MCP 服务端实现（如 lexis-mcp、lawborg-mcp、borg-mcp 等），通过 StdioTransport 提供标准化的服务入口，支持工具列表、工具调用以及跨提供方的集成能力。

基于 Model Context Protocol (MCP) 的本地 MCP 服务器实现，提供资源、工具、提示模板等上下文相关能力，并通过 JSON-RPC 与 LLM 客户端进行通信，支持多种传输方式，便于在本地搭建可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的浏览器控制后端服务器实现，提供一组浏览器操作工具给 LLM 客户端通过 MCP 协议调用，核心通过 Chrome DevTools Protocol (CDP) 控制浏览器，并通过 STDIO 的 JSON-RPC 方式与客户端通信。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对资源（Resources）、工具（Tools）和提示模板（Prompts）的注册、管理和渲染能力，并通过 JSON-RPC 与客户端通信，支持 SSE 传输模式的事件推送，适合作为 LLM 客户端的上下文服务和外部功能执行入口。

基于 Model Context Protocol (MCP) 的后端服务，为 Paprika Recipe Manager 数据提供资源、工具与提示模板，通过 JSON-RPC 方式与客户端通信，并支持标准传输通道（如 stdio），用于向大型语言模型提供可检索的配方数据与外部工具调用能力。

基于 Model Context Protocol（MCP）的后端服务器，向大型语言模型客户端提供标准化的资源、工具与提示模板，并通过JSON-RPC进行交互；具备会话管理、能力声明、多传输协议支持（如 StdIO、SSE、WebSocket）以及安全可扩展的上下文服务框架。

基于 Model Context Protocol 的后端 MCP 服务器，提供资源管理、工具注册与执行以及 Prompt 模板渲染的统一上下文服务，并通过 JSON-RPC 与 LLM 客户端通信，支持在多种传输协议下工作（如 STDIO、SSE、WebSocket）。

基于 Model Context Protocol (MCP) 的服务端实现，为每个引擎实例提供语义代码搜索和 Overlay 索引管理能力，支持双表检索、实时状态查询与覆盖合并，能够通过标准化的 JSON-RPC 方式与 MCP 客户端通信。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具与提示模板等上下文服务，通过 JSON-RPC 2.0 的 MCP 接口与 LLM 客户端对接，支持在 MultiversX 区块链上进行证据证明与工具调用等能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源与工具的管理、JSON-RPC 通信与多场景部署能力，能够让 LLM 客户端通过标准接口调用音效资源、获取 Pack 信息并执行音频播放等功能。

基于 Model Context Protocol (MCP) 的本地 MCP 服务器实现，嵌入 FOUNDATION 桌面应用中，通过 JSON-RPC 提供资源管理、工具注册/执行以及提示模板等上下文服务，供本地 AI 客户端请求并获得标准化响应。

基于 Model Context Protocol 的 MCP 服务器实现，作为 Roxlit 向 LLM 客户端暴露 Luau 执行、资源访问与日志等能力的后端服务。通过标准输入输出（stdio）进行 JSON-RPC 通信，能够与 Roxlit Launcher 的 HTTP 服务协同工作，向 AI 客户端提供统一的上下文与工具执行能力。

Grimoire Kit 框架中的 BMAD MCP 服务器实现，为本地 IDE 客户端提供对 BMAD Intelligence Layer 的工具、资源和 Prompts 的统一访问接口，采用 MCP 标准通过 JSON-RPC 进行通信。服务器内置对 BMAD 生态工具的暴露与自动发现，支持对工具执行、资源读取、Prompts 渲染等功能的远程调用，与多种前端 IDE 或 Copilot/Cursor 等 MCP 客户端集成。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册/执行、以及提示模板的后端服务，支持 JSON-RPC 通信与多传输协议（如 Stdio、SSE、WebSocket），用于向大语言模型客户端提供可扩展的上下文与功能接入。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（资源管理与数据访问）、工具（外部功能注册与调用）、以及提示模板（Prompts）的标准化提供，采用 JSON-RPC 形式与客户端通信，具备会话管理、能力声明，并可扩展多种传输方式。

基于 Model Context Protocol (MCP) 的后端服务器实现，用于向 LLM 客户端提供上下文信息与功能。核心能力包括托管与管理 Resources（数据资源）、注册与执行 Tools（外部功能）、定义与渲染 Prompts（提示模板），通过 JSON-RPC 与客户端通信，支持会话管理、能力声明，并可通过多种传输协议（如 Stdio、SSE、WebSocket）实现安全、可扩展的上下文服务。该实现与 Skylos 项目紧密集成，提供对代码分析结果、资源访问、工具执行等能力的统一后端服务。

基于 Model Context Protocol (MCP) 的后端实现，提供资源管理、工具注册与执行、以及提示模版渲染等核心能力，并通过 JSON-RPC 与客户端进行交互，支持会话管理、能力声明以及多种传输协议（如 SSE、WebSocket、STDIN/STDOUT 等）以为大型语言模型应用提供可扩展的上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，向大语言模型客户端以标准化的 JSON-RPC 形式提供资源管理、工具执行以及提示模板等能力，支持多运行配置（Profile），并通过 stdio 传输与客户端进行交互。该实现包含服务端核心逻辑、工具清单、工厂化的适配器以及对各运行档案的支持，属于完整的服务器端实现而非仅仅示例。

基于 Model Context Protocol 的 MCP 服务器实现与示例，提供资源管理、工具注册与执行、以及提示模板渲染等能力，通过 JSON-RPC 与客户端交互，适配多种传输方式以为 LLM 应用提供可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的本地后端实现，作为 LLM 客户端的上下文提供与能力服务中心，负责托管资源、注册并执行工具、定义与渲染提示模板，并通过 JSON-RPC 在多种传输通道上与客户端通信，支持会话、能力声明与安全沙箱机制的扩展能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源与工具的注册/托管、提示模板的渲染与执行，以及通过 JSON-RPC 与客户端进行标准化通信的后端服务。

基于 Model Context Protocol (MCP) 的服务器实现，向 LLM 客户端以标准化方式暴露上下文资源、可执行工具与提示模板，并通过 JSON-RPC 形式进行交互，支持会话管理与多种传输通道的对接（当前实现以 STDIO 传输为主）。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行，以及 Prompt 模板渲染，通过 JSON-RPC 与 LLM 客户端通信，支持会话管理与多种传输协议的可扩展上下文服务。

基于 Model Context Protocol（MCP）的后端服务器实现，提供工具注册与执行、资源访问、以及对话模板渲染等能力，允许通过 JSON-RPC 与客户端协同工作，并通过 STDIO 传输实现与 LLM 客户端的通信。

基于模型上下文协议（MCP）的后端服务器实现，集成资源/工具/提示模板的管理与暴露，通过 Express + WebSocket 提供对 LLM 客户端的上下文服务，并支持通过外部 MCP 服务器和设备插件进行扩展与连接。

基于 Model Context Protocol (MCP) 的企业级后端服务器，向 LLM 客户端提供资源、注册与执行工具、以及可渲染的提示模板等上下文服务，并通过 JSON-RPC/HTTP 与 Claude 等客户端进行通信，支持本地化计算、企业数据集成与多种传输方式。

基于 Model Context Protocol (MCP) 的后端服务，统一管理资源、注册并执行工具、定义并渲染提示模板，并通过 JSON-RPC 与 LLM 客户端进行通信，提供可扩展的上下文服务与多传输协议支持。

基于 Model Context Protocol (MCP) 的后端 MCP 服务器实现，提供 ADIF 数据的资源、工具与提示模板等能力，供 LLM 客户端以标准化的 JSON-RPC 方式进行上下文信息获取、功能调用与模板渲染。

基于 Model Context Protocol (MCP) 的后端实现，作为通用的上下文服务网关：托管与管理资源、注册并执行工具、定义并渲染提示模板；通过 JSON-RPC 与 LLM 客户端通信，支持会话管理、能力声明，以及多种传输协议（如 STDIO、SSE、WebSocket），并内置治理与合规机制保障上下文服务的安全、可扩展性与可追踪性。

Brakit 提供基于 Model Context Protocol (MCP) 的服务器端实现，向大型语言模型（LLM）客户端以标准化方式暴露资源、工具和提示模板，并通过 JSON-RPC 进行通信，支持会话管理、能力声明以及多种传输方案，用于在本地环境中为 LLM 应用提供上下文服务与扩展能力。

基于 Model Context Protocol 的后端服务器，提供资源管理、工具注册/执行和提示模板渲染的标准化服务，采用 JSON-RPC 与 LLM 客户端通信，支持多传输协议并具备会话管理与能力声明能力。

Arkana 是一个基于 Model Context Protocol (MCP) 的后端实现，提供资源托管、工具注册/执行、提示模板渲染等能力，并通过 JSON-RPC 与 MCP 客户端进行通信，支持多种传输模式（stdio、SSE、streamable-http），用于给 LLM 客户端提供安全、可扩展的上下文和分析工具集成环境。

基于 FAF 的 MCP 后端服务器，实现资源管理、工具执行与 FAF 相关的提示模板渲染，使用 JSON-RPC 通过标准输入输出进行通信。该服务器提供 5 个工具：faf_init、faf_git、faf_read、faf_score、faf_sync，并实现 MCP 协议的核心功能（初始化、工具列出与调用、资源查询等）。

基于 Model Context Protocol (MCP) 的后端服务器实现，通过 MCP 协议向 LLM 客户端提供对 Remarq 注释系统的资源、工具和提示上下文访问，支持 JSON-RPC 的请求/响应模式。

基于 Model Context Protocol 的本地后端实现，作为 MCP 服务器向 LLM 客户端提供资源托管、工具注册与执行、以及可渲染的 Prompt 模板等上下文服务，并通过 JSON-RPC 与客户端通信，支持多传输协议与会话管理，便于在本地环境调试 AI 驅动的移动开发工作流。

基于模型上下文协议（Model Context Protocol，MCP）的后端服务器实现，提供资源与工具管理、提示模板渲染，以及与 Claude Code/其他客户端的 JSON-RPC 通信，支持会话管理、跨传输协议的上下文服务。

基于 Model Context Protocol 的后端服务器，向 LLM 客户端提供凭证元数据、工具和资源信息，并通过 JSON-RPC 进行通信，便于在对话中查询和执行外部功能。它包含资源管理、工具注册与调用、以及轻量的提示/模板能力支撑，适配多种传输方式。

基于 Model Context Protocol (MCP) 的后端实现，提供资源/工具/提示的标准化上下文服务，支持通过 JSON-RPC 在 stdio/HTTP 传输，并与 Nostr、SurrealDB、嵌入式模型及上下文虚拟机等模块无缝协作，兼容多种客户端框架的后端上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，用于向大语言模型（LLM）客户端提供图标资源、工具与可自定义的 Prompt 模板等上下文服务。该仓库中的 iconx 包提供一个可运行的 MCP 服务器实现，通过标准输入输出（stdio）传输，与客户端进行 JSON-RPC 通信，注册并执行工具（如搜索图标、生成图标组件等），并支持通过配置管理图标资源与输出。

基于 Model Context Protocol 的 MCP 服务器实现，提供 JSON-RPC 交互、资源与工具注册与执行、以及提示模板的管理与渲染等能力，支持通过标准输入/输出与客户端进行通信，以及会话管理与多协议传输的扩展能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行、以及 Prompt 模板渲染等核心能力，通过 JSON-RPC 与客户端通信，支持 HTTP/微前端传输与 stdio 等多种传输方式，适合作为 LLM 客户端的上下文与功能后端服务。

基于 Model Context Protocol 的 MCP 服务器实现，为 1C:EDT 的 AI 助手提供上下文和功能服务。服务器负责托管资源、注册并执行工具、定义并渲染提示模板，采用 JSON-RPC 与客户端通信，支持流式传输（SSE/HTTP）以实现实时交互，并提供会话管理与多种传输协议的后端上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供 Claude Cortex 的内存检索、时间线、详细信息与保存等工具的标准化 JSON-RPC 接口，供 LLM 客户端按统一协议查询与调用，支持本地文本检索、向量检索与知识图谱扩展等能力。

基于 Model Context Protocol 的后端服务器，为 LLM 客户端提供标准化的上下文信息和能力服务。核心功能包括托管和管理 资源（Resources）、注册与执行 Tools、以及定义与渲染 Prompt 模板（Prompts），并通过 JSON-RPC 与客户端通信，支持多种传输模式（如 STDIO、HTTP、WebSocket），整合节点管理、RBAC 权限控制和 Zenoh 通信等组件，用于在硬件/物联网场景中提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的后端实现，提供资源（Resources）托管、工具（Tools）注册/执行、以及 Prompt 模板的定义与渲染，通过 JSON-RPC 与 LLM 客户端进行标准化上下文服务交互，并支持会话管理与跨传输协议的通信能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供组件注册与查询、工具执行以及应用模板获取等功能，通过 JSON-RPC 与客户端通信，供 LLM 客户端查询和执行资源、工具、Prompts 等上下文服务。

基于 Model Context Protocol (MCP) 的服务器实现，提供资源（Resources）管理、工具（Tools）注册与执行、Prompts 定义与渲染，并通过 JSON-RPC 与客户端通信，支持多传输协议（如 STDIO、SSE、WebSocket），用于为大模型/LLM 客户端提供标准化的上下文信息和功能访问。

基于 Model Context Protocol 的 MCP 服务器实现，提供跨多 AI 客户端的工具、提示与潜在资源上下文服务，支持 JSON-RPC 请求/响应、会话管理以及标准传输（如 STDIO）。

Radar 内置的 Model Context Protocol (MCP) 服务器实现，提供统一的资源数据访问、工具调用与 Prompt 渲染接口，支持通过 JSON-RPC 与 LLM 客户端通信，方便 AI 助手查询集群上下文、执行外部功能、渲染对话模板等。

基于 MCP 协议的后端实现集合，提供面向 LLM 客户端的上下文服务、资源与工具注册、以及提示模板的标准化渲染能力。仓库内包含多个 MCP 服务器实现（如 Context Hub MCP、Service Registry MCP、Service MCP、Peer MCP 等），通过 JSON-RPC 在 STDIN/STDOUT 进行通信，支持通过工具化接口向 LLM 提供资源、执行外部工具、以及渲染 Prompts/模板等上下文能力。

基于 Model Context Protocol (MCP) 的后端服务，提供资源管理、工具注册与执行，以及基于 Prompts 的渲染能力，通过 JSON-RPC 与 LLM 客户端进行通信；实现了一个用于 MCP 的服务器端，以便 LLM 客户端能读取资源、调用工具、以及渲染/获取提示模板等上下文信息。

基于 Model Context Protocol (MCP) 的后端实现，为 LLM 客户端提供标准化的资源、工具与提示的暴露和管理，并通过 JSON-RPC 进行远程调用与会话管理，具备可扩展的插件式架构与本地化推理上下文服务。

基于模型上下文协议（MCP）的后端服务器实现，由 Prolog 编写，提供对资源、工具和提示模板的注册、查询与执行能力，并通过 JSON-RPC 与客户端通信，支持会话管理与能力声明，便于将上下文信息和功能暴露给大语言模型（LLM）客户端使用。

基于 Model Context Protocol (MCP) 的后端服务器实现，用于向 LLM 客户端以标准化方式提供资源、工具和提示等上下文服务，并通过 JSON-RPC 与客户端通信，支持多 provider 路由与会话管理。

基于 MCP 协议的后端服务，提供对浏览器自动化能力的统一访问入口，通过 JSON-RPC 与客户端交互并将命令映射到 WebAct 的 CLI/SDK 操作，实现对资源、工具及提示模板等能力的托管与执行，适用于将浏览器自动化功能嵌入到大语言模型的工作流中。

基于模型上下文协议（MCP）的后端服务器，提供资源、工具与提示模板等标准化上下文服务，支持以 JSON-RPC 形式与 AI 代理进行交互，便于在不同代理中进行上下文获取、工具调用与提示渲染。

基于 Forge 项目实现的 Model Context Protocol (MCP) 服务器，提供资源、工具与提示等上下文服务，通过 JSON-RPC 方式与 MCP 客户端通信，支持以 STDIO 等传输协议接入，便于将 LLM 调用外部功能、访问数据资源并渲染自定义提示模板等能力。

基于 Model Context Protocol 的 Robinhood 投资组合只读后端，为LLM客户端提供统一的数据访问、工具调用与对话能力。

基于 Model Context Protocol (MCP) 的后端服务，为大语言模型客户端提供绘图规格、实现代码、库信息的上下文与工具访问能力，并通过 JSON-RPC 与客户端进行通信。该服务器负责资源管理、工具注册与执行、Prompt 模板的定义与渲染，以及会话管理与能力声明，支持多种传输协议以适配不同的集成场景。

基于模型上下文协议（MCP），为大模型/LLM 客户端提供字段发现、资源筛选以及外部工具执行等能力的后端服务。通过 JSON-RPC 与客户端通信，支持资源管理、工具注册与执行、以及可定制的 Prompt 渲染等功能，便于在对话系统中提供证券市场数据上下文与交互能力。

基于 Model Context Protocol 的 MCP 服务器实现，为 LLM 客户端提供资源管理、工具注册与提示模板等上下文服务，并通过 JSON-RPC 与客户端通信，支持标准化的资源、工具与提示渲染管理。

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

基于 Model Context Protocol 的后端实现，为 MCP 客户端提供统一的上下文资源、工具执行和 Prompt 渲染能力，采用 JSON-RPC 形式对外提供服务，支持多传输协议，具备会话管理和能力声明等特性，适合作为 LLM 客户端的上下文与功能服务端。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供标准化的工具集与内存检索能力，允许本地或远程的 LLM 客户端通过 MCP 访问会话记忆、搜索结果、以及外部源捕获工具等功能，并支持 STDIO 与 SSE 等传输方式。

基于 Model Context Protocol 的地理空间数据后端服务器，提供资源管理、工具注册与调用，以及按 MCP 规范渲染的提示模板与路由能力，支持 STDIO/HTTP 等传输，面向向量数据、地图服务与地理统计数据的 LLM 应用上下文服务。

基于 Guilders API 的 MCP 服务器实现，通过 JSON-RPC 提供资源访问、工具执行以及提示模板渲染等能力，供大型语言模型（LLM）客户端安全地获取上下文数据与外部功能。

基于 Model Context Protocol（MCP）的本地化后端服务，使用 SQLite 持久化存储并通过 stdio 进行 JSON-RPC 通信，向 LLM 客户端提供资源、工具和提示模板等能力，便于在本地环境中为 AI 编码代理提供上下文与功能。

基于 Model Context Protocol (MCP) 的服务器实现，提供一个代理型 MCP 服务器，将上游 MCP 客户端的请求暴露为本地 HTTP/Streamable HTTP 服务，支持工具、资源、提示等请求的转发与认证代理，并可用于 AI 沙箱场景的安全访问与测试。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源管理、工具注册/执行以及可渲染的提示模板等能力，并通过 JSON-RPC 与 LLM 客户端通信，支持多传输协议（如 Stdio、SSE、WebSocket）与会话管理，适配分布式上下文服务场景。

基于 Model Context Protocol（MCP）实现的后端服务器，提供资源托管、工具注册与执行、以及可定制的 Prompt 模板渲染。通过 JSON-RPC 形式与 LLM 客户端通信，支持多传输方式（HTTP、STDIO 等），并提供会话管理、能力声明、访问控制与审计追踪等完整后端能力。仓库内不仅包含完整的 MCP 服务端实现，还实现了与 Claude/Cursor/Windsurf 等 MCP 客户端的对接支持。

基于 Model Context Protocol (MCP) 的服务器实现，将 LCOV 覆盖率数据以标准化的 JSON-RPC 工具形式暴露给 LLM 客户端，提供覆盖统计、未覆盖区域查询与带注释源码等能力，便于 AI 辅助分析和引导测试工作。

基于 Model Context Protocol (MCP) 的后端实现，能够以标准化的 JSON-RPC 方式向 LLM 客户端提供资源管理、工具注册与执行，以及上下文相关的输出（包括提示/模板等），并通过可扩展的工具集合支持多种传输与认证方式，具备会话管理与跨源访问控制能力。

基于 Forge 平台的 MCP（Model Context Protocol）后端实现，提供资源管理、工具注册与执行、Prompt 模板渲染等核心能力，通过 JSON-RPC 与多传输协议（如标准输入输出、Server-Sent Events、WebSocket）对接 LLM 客户端，实现跨会话的上下文服务与能力声明。

基于 Model Context Protocol (MCP) 的后端服务，向大语言模型客户端以标准化方式提供世界魔方协会（WCA）数据的资源、工具与提示模板等上下文能力，并通过 JSON-RPC 与客户端交互实现数据读取、外部功能调用与提示渲染等功能。

基于 Model Context Protocol (MCP) 的后端服务，作为 LLM 客户端的上下文提供与能力服务中心，负责托管资源、注册与执行工具，以及管理提示模板、会话与安全性策略。通过 JSON-RPC 与客户端通信，支持 HTTP 传输与 Stdio 传输，适用于在生产环境中为 LLM 提供可扩展的上下文与功能服务。

基于 Model Context Protocol (MCP) 的本地 MCP 服务器实现，提供资源管理、工具注册/执行、以及提示模板渲染等能力，供离线/本地 LLM 客户端通过 JSON-RPC 调用获取上下文、执行外部工具和渲染提示。

基于 Model Context Protocol (MCP) 的 JSON-RPC 服务器实现，提供 immygo_widget_catalog、immygo_generate_code、immygo_search_docs 等工具，供 Claude Code、Cursor 等 MCP 客户端通过标准 MCP 流式/非流式请求进行调用与协作。该仓库同时包含可运行的 MCP 客户端接入示例，形成完整的服务端与客户端配合方案。

Walrus Daemon 的 MCP 服务器实现：通过 MCP 桥接连接一个或多个 MCP 服务器，注册工具、转发工具调用并将 MCP 能力整合到 Walrus 的运行时中，提供对外部工具的统一访问，支持与 LLM 客户端以标准化方式进行工具调用与资源访问。

基于 Model Context Protocol (MCP) 的 Schelling 协调网络后端服务器，实现资源/工具/提示模板等上下文服务，通过 JSON-RPC 与 MCP 客户端通信，支持会话管理、能力声明以及工具生态绑定，适配 Claude Desktop 等 MCP 客户端进行跨系统协作。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源与工具的托管与访问、工具注册与执行、Prompt 模板渲染，并通过 JSON-RPC/HTTP-SSE 与客户端通信，包含会话管理、能力声明，以及支持多传输协议的上下文服务框架。

基于 Model Context Protocol（MCP）的后端服务器实现，面向 LLM 客户端提供标准化的上下文服务：托管资源、注册与执行工具、定义与渲染 prompts，并通过 JSON-RPC 与客户端通信，支持多传输协议（如 SSE、WebSocket、StdIO）以实现安全、可扩展的上下文服务框架。仓库中已有大量 MCP 相关模块和对接实现，能够与客户端协同提供资源、工具与提示等能力。对接示例包括通过 llm_client 与 MCP 平台服务器进行交互以及对 MCP 服务的自检与自动重启等能力。

基于 Model Context Protocol（MCP）的后端实现，为 AI 客户端提供资源、工具调用能力与提示模板渲染等上下文服务；通过 JSON-RPC 2.0 以换行分隔的文本协议在标准输入输出（STDIN/STDOUT）上与客户端通信，支持对桌面应用的自动化控制与上下文信息管理。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行、以及模板渲染等能力，通过 JSON-RPC 与客户端通信，支持多提供者协同与并行执行的后端上下文服务。

基于 Model Context Protocol (MCP) 的后端服务端实现，提供资源管理、工具注册与执行、以及 Prompt 模板渲染，支持通过 JSON-RPC 与 MCP 客户端通信，具备对会话、能力声明与多传输协议的支持，属于一个完整的 MCP 服务器实现（含服务器端核心、工具暴露与网络化 MCP 传输适配）。

基于模型上下文协议（MCP）的后端服务实现，提供对 MCP 客户端的资源访问、工具注册与执行、以及与上游 MCP 服务器的JSON-RPC交互能力。实现自包含的服务器端逻辑、工具访问控制、会话管理和凭证处理，并通过侧车代理在容器环境中实现安全的流量控制与跨服务器协作。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大语言模型客户端提供股票数据、市场数据以及工具调用等上下文服务，核心通过 JSON-RPC 进行通信并具备路由、容错与健康监控能力。

一个实现 MCP（Model Context Protocol）的后端服务器，提供资源管理、工具注册、Prompt 定义与渲染，并通过 JSON-RPC 与 LLM 客户端进行通信，支持多传输协议，面向将网站/数据源暴露为可被 LLM 调用的上下文服务的场景。

基于 Model Context Protocol（MCP）的后端实现，提供资源(Resource)、工具(Tools)、提示模板(Prompts)的托管、注册与渲染，客户端通过 JSON-RPC 与服务器通信，支持多会话管理、能力声明，以及多传输协议（如 Stdio、SSE、WebSocket），为LLM应用提供可扩展的上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端服务，实现了一个可对接的 MCP 服务器，向 LLM 客户端提供资源、工具和提示模板等上下文服务，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多传输协议扩展。

基于 Model Context Protocol 的 MCP 服务器实现，能够自动发现并注册多政府 API 模块，向大语言模型客户端提供上下文资源、工具和 prompts，并通过 JSON-RPC 与客户端通信，支持多种传输协议与会话管理。

基于 Model Context Protocol (MCP) 的后端服务，用于在 LLM 客户端与代理/资源之间提供可扩展的上下文服务。该服务器实现了工具注册与执行、成本/预算相关查询、会话摘要等 MCP 功能，支持通过 JSON-RPC 与客户端通信，并能够暴露“健康/状态”等查询能力，便于 Claude Code/Cursor 等工具进行上下文协作。

基于 Model Context Protocol (MCP) 的服务器实现，用于向 LLM 客户端以标准化方式提供资源、工具、提示等上下文和功能，通过 JSON-RPC 在标准输入输出（stdio）内通信，支持会话管理与多种传输场景，作为后端后端服务为 LLM 应用提供可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 构建的后端服务器，向 LLM 客户端标准化暴露资源、工具与 Prompt 模板，并通过 JSON-RPC 与客户端交互，实现知识管理、工具注册与自定义对话模板的渲染与执行。

基于 Model Context Protocol (MCP) 的服务器端实现，提供资源管理、工具注册及提示模板等能力，通过 JSON-RPC 与 LLM 客户端通信，支持多传输协议（stdio、SSE、WebSocket），为 LLM 应用提供可扩展的上下文服务和代码重构能力。

基于 Model Context Protocol 的 MCP 服务器实现，为 LLM 客户端提供标准化的资源、工具和提示（Prompts）上下文服务，通过 JSON-RPC 与客户端通信，支持资源管理、工具注册/执行以及提示渲染等核心能力。实现中包含对工具注册、资源列举、资源读取、工具执行等 MCP 核心操作的处理逻辑，并提供了可运行的 MCP 服务入口。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具注册与执行，以及通过 JSON-RPC 与客户端进行通信的能力，支持会话管理、能力声明与多传输通道的扩展性，用于将 AI 客户端（LLM）接入到包含资源、外部工具以及可定制提示的实验环境中。

Haira 的 MCP 服务器实现，基于 Model Context Protocol（MCP）提供资源与工具的管理、以及将工作流暴露为外部工具的能力，服务器通过 JSON-RPC 与客户端通信，支持多种传输方式（如标准输入输出stdio 和 SSE），并与 Haira 内部运行时紧密集成以实现对上下文、工具执行和提示模板的标准化服务。

基于 Model Context Protocol（MCP）的后端服务器实现，用于以标准化的 JSON-RPC 方式向 LLM 客户端提供上下文资源、工具能力与提示模板；支持会话管理、能力声明，以及多传输协议（如 Stdio、SSE、WebSocket），以实现对资源、工具和提示的统一托管与渲染，辅助构建安全、可扩展的 MCP 服务端上下文服务。

基于 Model Context Protocol（MCP）的后端服务器，提供资源、工具与 Prompt 的标准化管理与 JSON-RPC 通信，以支持 LLM 客户端按阶段获取上下文、执行计划、验证以及工作流渲染等能力。

基于 MCP 协议实现的后端服务，按标准 JSON-RPC 向 LLM 客户端暴露工具（Tools）、资源管理能力与提示模板等能力，并通过与沙箱模拟器的集成提供统一的上下文和功能接口。服务器核心包含对 MCP 请求的处理、初始化能力声明、工具列表示以及工具调用执行等核心功能，支持与 BikiniBottom 沙箱的发送/接收、路由与任务管理等模块协同工作。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源、工具与提示模板的托管与渲染，并通过 JSON-RPC 与客户端进行通信，支持多传输协议（stdio、SSE、HTTP/WS），为大语言模型提供可扩展的上下文服务框架。

基于模型上下文协议（MCP）的后端服务，专注托管与管理资源（Resources）、注册并执行工具（Tools）、定义与渲染 Prompt 模板，随后通过 JSON-RPC 与 LLM 客户端进行标准化的上下文交互。服务端负责会话管理、能力声明，并可通过多种传输通道（REST/SignalR、Stdio、Server-Sent Events、WebSocket）实现跨平台的上下文服务能力，适配 JD.AI 生态内的网关、通道与工具体系。

基于模型上下文协议（MCP）的 Unity 后端服务器实现，提供资源管理、工具注册与执行、以及提示模板渲染等能力，方便将游戏上下文以标准化的 JSON-RPC 形式暴露给大型语言模型（LLM）客户端；支持通过 HTTP 的流式传输实现实时通信与多会话管理。

基于 Model Context Protocol 的后端服务器实现，提供资源及工具托管、Prompt 渲染等能力，并通过 JSON-RPC 风格的 MCP 协议在 Unix 域套接字上与客户端进行通信与协作。

基于 Model Context Protocol 的服务器实现示例，提供列出线程、获取线程、搜索会话、获取具体会话等工具，用于将本地对话历史以 MCP 方式暴露给 Claude Desktop 等客户端进行导出与查询。

基于 Model Context Protocol (MCP) 的 Obsidian 知识库后端，向 MCP 兼容的 AI 客户端提供对本地 Obsidian Vault 的资源访问、工具执行与元数据渲染，并通过标准化的 JSON-RPC 协议进行通信与会话管理。

基于 Model Context Protocol 的 MCP 服务器实现，嵌入在 Claude Terminal 桌面应用中，提供资源、工具、提示模板等 MCP 组件给 LLM 客户端，通过 JSON-RPC 进行通信，并支持会话管理、能力声明与插件化注册表功能。

基于 Model Context Protocol (MCP) 的后端服务器，面向 LLM 客户端提供统一的上下文能力（资源、工具、Prompts），通过 JSON-RPC 进行通信，底层采用 FastMCP 与 Starlette 构建，支持会话管理、能力声明以及多传输协议（如 Stdio、SSE、WebSocket）等扩展能力，面向 Allure TestOps 场景的资源与工具服务化暴露。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对资源、工具与提示模板的标准化管理与访问，通过 JSON-RPC 与 LLM 客户端进行通信，支持会话管理、能力声明，以及与 Firebase 数据库的交互。该仓库包含可运行的 MCP 服务端代码及相关工具与测试，适用于将 LLM 客户端接入 Planning Game XP 的上下文与功能服务。

基于 Model Context Protocol 的 Sigil MCP 服务器实现，提供资源与工具托管、Prompt 模板管理，以及通过 JSON-RPC 方式与 LLM 客户端进行上下文和功能交互，支持向外暴露工具查询、调用与渲染能力。

基于 Model Context Protocol (MCP) 的服务器端实现，提供资源、工具、提示等核心上下文能力给大模型/LLM 客户端，通过 JSON-RPC 形式对外提供 MCP 功能与会话管理，并可与多种传输模式协作。

LEMON 是一个面向临床决策工作流的全栈后端，仓库中包含一个 MCP 服务器桥接实现。该桥接通过 JSON-RPC 提供模型上下文服务，核心职责包括托管资源、注册与执行工具、定义与渲染提示模板，并支持多种传输协议（如标准 I/O、Server-Sent Events、WebSocket）。通过 MCP 桥接，客户端可以读取资源、调用工具、获取并渲染提示模板等，以实现对 LLM 的统一上下文服务与扩展能力。仓库提供 MCP 服务器入口脚本 run_mcp.py，以及 Bridge 实现模块，形成一个可运行的服务器端 MCP 实现。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、以及 Prompt/上下文相关支持，专为让大语言模型（LLM）以标准化方式访问文件资源、执行外部工具（如 S3/SFTP 操作）而设计。服务器通过 JSON-RPC 与客户端通信，支持在标准输入/输出（STDIO）传输上运行，便于与 AI 客户端（如 Claude 等）进行无缝对接。

基于 Model Context Protocol (MCP) 的后端服务器实现，聚合 ICC 配置分析、工具执行、资源管理与提示模板渲染，提供标准化的 JSON-RPC 通道供 LLM 客户端查询资源、注册并执行工具、以及获取和渲染提示模板。

基于 Model Context Protocol (MCP) 的 Atlas 后端服务器实现，提供资源管理、工具注册与执行、以及 Prompt/模板的渲染等 MCP 核心能力，通过 JSON-RPC 与客户端通信，支持 StdIO 与 SSE 等传输方式，适配多种 LLM 客户端的上下文服务需求。

基于 Model Context Protocol 的 MCP 服务器实现，提供对资源、工具和提示模板等核心能力的标准化访问。通过 JSON-RPC 与客户端通信，服务器负责资源管理、工具注册与执行，以及提示模板的定义与渲染，支持将语言规范与工具集成到 AI 客户端的上下文服务中。

基于 Model Context Protocol (MCP) 的后端实现，向大模型客户端提供资源管理、工具注册/执行与可定制的提示模板等能力，并通过 JSON-RPC 与客户端通信，支持多种传输通道（stdio、WebSocket、SSE 等）以提供安全、可扩展的上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具注册与执行、Prompt 模板定义与渲染，并通过 JSON-RPC 与客户端通信的后端服务，支持多传输通道（如标准输入输出、服务器发送事件、WebSocket），具备会话管理、能力声明与策略执行能力，便于向大语言模型客户端提供标准化的上下文信息和外部功能。

基于 Model Context Protocol (MCP) 的开源后端实现，提供对资源、工具、提示模板等的托管与管理，通过 JSON-RPC 与 MCP 客户端通信，支持多传输协议（如 stdio、TCP）、策略评估、审计日志和热加载等特性，旨在为大语言模型（LLM）场景中的上下文服务提供安全、可扩展的后端支持。

基于 Model Context Protocol 的后端服务端实现，面向 LLM 客户端提供资源管理、工具注册与执行，以及 Prompts 的定义渲染，使用 JSON-RPC 进行通信，并支持通过多种传输方式与 Claude Desktop 等 MCP 客户端集成。

基于 Model Context Protocol (MCP) 的服务器端应用，提供对 microCMS 文档的访问、检索与工具调用能力，并通过 JSON-RPC 与 MCP 客户端通信，支持本地文档资源的管理与渲染。

基于 Flow Weaver 的 MCP 服务器实现，提供资源、工具和提示模板的标准化管理与对外暴露，通过 JSON-RPC 与 LLM 客户端进行上下文服务、工具调用和提示渲染，支持多传输协议与会话管理，适配 Claude Code、Cursor、OpenClaw 等 MCP 客户端与插件生态。

基于 Model Context Protocol（MCP）的后端服务，提供资源、工具与提示模板的标准化访问，用于让 AI/LLM 客户端以结构化上下文与能力与本地系统进行交互，并通过 JSON-RPC 等传输协议与客户端沟通。

基于 Model Context Protocol 的 MCP 服务器实现，向大语言模型客户端暴露监控与运维上下文工具、资源和提示模板等能力，通过 JSON-RPC 进行规范化通信，支持工具执行、资源查询、健康与告警上下文等场景，便于将生产系统上下文整合到 LLM 的决策流程中。

基于 Model Context Protocol（MCP）的后端服务实现，集成到 CCC（Claude Code Launcher）中，用于托管资源、注册与执行工具，以及定义与渲染提示模板。通过内联（Inline）MCP 与 Claude Code 的虚拟文件系统（VFS）进行 JSON-RPC 通信，支持多层配置体系（全局/预设/项目）以及插件扩展，目标是为大型语言模型客户端提供标准化的上下文服务与外部功能调用能力。

基于 Model Context Protocol 的本地 MCP 服务器实现，将 The Null Epoch 的游戏 REST API 以 JSON-RPC 风格暴露给 MCP 客户端，方便 AI 客户端通过 get_state 和 submit_action 等工具与游戏后端交互。该实现提供初始化、工具清单、单工具调用、通知等 MCP 基本功能，适用于 Claude Desktop、Cursor、Kiro 等支持 MCP 的客户端。

DivineOS MCP Server 基于 MCP 协议实现的后端服务，利用 MCP SDK 将资源、工具和提示等能力以 JSON-RPC 形式暴露给 MCP 客户端，支持标准输入输出和 HTTP 传输，提供完整的伺服器端实现与工具集合。

基于 Model Context Protocol (MCP) 的后端服务器实现，用于向 MCP 客户端提供数据资源、工具执行和 Prompt 渲染能力。通过将 XHelio 的 OrchestratorAgent 以 MCP 工具形式暴露，支持以 JSON-RPC 形式进行请求与响应，适用于由 MCP 客户端发起的对话、数据查询和可视化任务的后端服务，且可通过 stdio 等传输通道进行通信。

基于 Model Context Protocol (MCP) 的后端服务器，提供资源、工具和 UI 渲染等能力，使用 JSON-RPC 通过 /mcp 与客户端通信，支持 Durable Objects、WebSocket、SSE 等传输，面向 LLM 客户端的上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端实现，提供对资源的托管与访问、工具的注册/执行，以及 Prompt 模板的定义与渲染。服务器通过 JSON-RPC 与客户端进行交互，支持会话管理、能力声明，并可通过多种传输协议（如标准输出/终端、Server-Sent Events、WebSocket）进行上下文服务与功能调用，为 LLM 应用提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，向 LLM 客户端以标准化方式暴露资源、注册工具并提供提示模板，支持 stdio 与 HTTP 流式传输，便于在本地搭建可扩展的上下文服务。

基于模型上下文协议（MCP）的后端服务，将 EOD Historical Data 的金融数据 API 统一暴露给 MCP 客户端，提供资源管理、工具调用与可渲染提示模板等能力，支持 HTTP/SSE/STDIO 等传输模式，实现与 Claude/ChatGPT 等大语言模型的安全可扩展上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具和提示模板的标准化管理与渲染，支持通过 JSON-RPC 进行通信，能够使用stdio和流式HTTP等传输、并具备协议协商、健康检查和工具缓存等完整服务器能力。

基于 Model Context Protocol (MCP) 的 Kea 语言后端服务器实现，提供通过 MCP 客户端进行资源管理、工具调用与诊断输出的上下文服务，支持与编辑器/代理等外部组件的集成。

基于 MCP（Model Context Protocol）的后端服务器实现，提供资源管理、工具注册与执行、以及提示模板的统一接口，并通过 JSON-RPC 与客户端通信，支持多种传输协议（如 Stdio、SSE、WebSocket），用于向大模型/LLM 客户端提供可扩展的上下文、数据访问以及外部功能调用能力。该仓库包含完整的服务端实现与大量 MCP 相关工具和测试用例，旨在作为企业级代码分析与 AI 辅助工作的后端上下文服务框架。

基于模型上下文协议（MCP）的本地服务器代理，通过 STDIO/JSON-RPC 将客户端请求转发到 InboxAPI MCP 服务，并在本地管理凭证、工具列表、身份注入与渲染提示等能力，提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与调用、Prompt 模板渲染等能力，支持 STDIO、SSE/HTTP 等传输模式，通过 JSON-RPC 与 LLM 客户端进行交互，为 AI 代理提供可扩展的上下文服务框架。

基于 Model Context Protocol 的 MCP 服务器实现，提供可执行的 Windows 命令工具集合。通过 JSON-RPC/STDIO 与 LLM 客户端通信，具备命令执行安全控制、进程管理、以及 anti-hang/防僵死机制，旨在为 AI 助手在本地 Windows 环境提供可控的上下文能力与工具入口。

基于 Model Context Protocol (MCP) 的服务器实现，向 AI 助手提供宠物资源、工具注册/执行等能力，采用 JSON-RPC 形式进行通信。内置 FastAPI 应用，通过 FastMCP 暴露工具接口，允许 AI 客户端查询宠物状态、注册/喂养宠物、获取历史等，并通过 /mcp/mcp 路径提供 MCP 服务端入口。

基于 Model Context Protocol 的 MCP 服务器实现，提供对 Haskell 代码的执行、资源与工具的注册与调用，以及 Prompt 模板的渲染等标准 MCP 服务，支持 stdio 与 HTTP 传输与会话管理。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具与提示模板的标准化管理与渲染，通过 JSON-RPC 与 LLM 客户端通信，支持多传输协议（如 STDIO）以为 LLM 应用提供安全、可扩展的上下文服务。

基于 Model Context Protocol (MCP) 的服务器实现，将 Alfanous Quranic 搜索引擎暴露为 MCP 的资源、工具与提示模板，提供面向 LLM 客户端的上下文与功能服务，支持通过 MCP 客户端进行资源读取、工具调用与提示渲染。

基于 Model Context Protocol 的 MCP 服务器实现，为 LLM 客户端提供资源、工具以及提示模板等上下文信息，通过 JSON-RPC 与客户端通信，支持多传输通道（当前实现以 stdio 介质为主，后续可扩展为 SSE/WebSocket），并与 Composio 集成以暴露元工具，，用以构建可扩展的对话式 AI 后端服务。

基于 Model Context Protocol (MCP) 的服务器实现，暴露财务相关资源、工具和报表模板，供 MLP 客户端通过 JSON-RPC 调用以获取上下文、注册并执行工具、以及渲染 Prompt 模板；并内置 Gemini Bridge 支持，提供对外部模型协作与自动化执行能力。

基于 Model Context Protocol 的完整 MCP 服务器实现，面向 LLM 客户端提供标准化的上下文与功能服务。核心功能包括托管与管理 Resources（资源/数据）、注册与执行 Tools（工具）、以及定义与渲染 Prompt 模板。服务器通过 JSON-RPC 与客户端通信，支持多协议传输、会话管理、能力声明和可扩展的工具集合，内置 51 个 Flowise 原生工具的 MCP 接口。

基于 Model Context Protocol (MCP) 的服务器实现，为 LLM 客户端提供资源管理、工具注册与执行、以及可渲染的 Prompt 模板；通过 JSON-RPC 进行请求/响应，并可在多种传输通道（如标准输入输出、SSE、WebSocket 等）下工作，内部包含会话管理、能力声明和文档/缓存等后端能力，用于构建可扩展的上下文服务平台。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大语言模型客户端提供资源、工具与可渲染的提示模板，并通过 JSON-RPC 进行通信，支持通过 MCP.json 配置或代码属性进行注册与启动，具备会话管理、能力声明与多传输协议（如 Stdio、SSE、WebSocket）的扩展能力。

基于 Model Context Protocol(MCP) 的后端服务器实现，提供以 JSON-RPC 2.0 方式向 AI 客户端暴露资源管理、工具注册/执行以及可渲染的 Prompt 模板等能力，并支持多传输协议（如 STDIO、WebSocket、SSE），实现会话管理与能力声明，用于为 LLM 应用提供结构化的上下文服务与外部功能入口。

基于 Model Context Protocol (MCP) 的后端服务器， provide 资源管理、工具注册与执行、以及 Prompt 模板的定义/渲染，并通过 JSON-RPC 与 LLM 客户端进行通信。服务器负责会话管理、能力声明，并支持扩展的传输协议（如 STDIO、SSE、WebSocket），用于向大语言模型应用提供标准化的上下文信息、数据访问、和外部功能调用能力。该仓库实现了完整的 MCP 服务器端能力，包含资源、工具、知识库、演示/demo、以及多工具链的整合。

基于 Model Context Protocol 的后端服务器实现，提供资源托管、工具注册与执行，以及 Prompt 模板渲染等 MCP 核心能力，支持 Stdio、SSE、WebSocket 等传输模式并以 JSON-RPC 形式与客户端通信。

基于 Model Context Protocol (MCP) 的后端服务器实现，向 LLM 客户端提供资源管理、工具执行和 Prompt 渲染等上下文服务，支持 JSON-RPC 通信与多传输通道（此实现以标准输入/输出（stdio）为通信介质）并实现了初始化、工具与资源查询等核心功能。

基于 Model Context Protocol 的 MCP 服务器端实现，提供 Bitbucket CLI 的资源、工具注册与执行能力，供 LLM/AI 客户端通过 JSON-RPC 调用并获取上下文信息和功能。

基于模型上下文协议（MCP）的后端服务器实现，提供对 GitHub 数据的上下文服务。通过标准输入输出的 JSON-RPC 方式，支持读取并管理 GitHub 仓库数据的工具集，如获取标签、变更日志、README、文件树、特定文件内容以及代码搜索，供大型语言模型（LLM）客户端调用。

基于 Model Context Protocol (MCP) 的后端服务器实现，使用 Claude Agent SDK 构建并暴露资源、工具及提示模板，通过 JSON-RPC 与 LLM 客户端进行交互，支持多传输协议并具备会话和能力管理能力。

基于 Model Context Protocol (MCP) 的后端服务器模板与实现集合，提供资源管理、工具注册与执行、提示模板渲染，以及通过 JSON-RPC 与 MCP 客户端进行通信的完整服务器框架与示例。包含可运行的服务器入口、资源与工具实现模板，以及对 Google 日历、Gmail 等服务的实验性扩展。

基于 Model Context Protocol (MCP) 的后端服务器实现，向大语言模型（LLM）客户端以标准化的 JSON-RPC 方式提供资源管理、工具注册/执行以及可自定义的 Prompt 模板渲染，具备会话管理、并发浏览上下文、以及对多传输协议的支持，便于在浏览器自动化场景中提供安全、可扩展的上下文服务。

基于 Mark Protocol 的 MCP 服务器实现，向大型语言模型客户端以标准化方式暴露读取资源、执行工具、以及渲染提示模板等能力，并通过 JSON-RPC 进行通信。

基于 Model Context Protocol 的后端服务器，向 MCP 客户端暴露工具、资源与提示模板，支持执行子代理、资源读取与会话管理，提供安全、可扩展的上下文服务。

基于 Java Spring Boot 的 MCP 服务器实现，提供资源托管、工具注册与执行、提示模板渲染等能力，遵循 Model Context Protocol，支持 JSON-RPC 形式的请求/响应，并通过多种传输方式（如 STDIO/SSE/HTTP）与 LLM 客户端进行上下文服务交互。

基于 Model Context Protocol 的 MCP 服务端实现，提供对资源、工具和提示模板的标准化管理与访问，支持与大语言模型客户端通过 JSON-RPC 进行交互，并定义不同传输方式（如 StdIo、SSE 等）以供 LLM 应用接入。仓库中包含完整的 MCP 服务入口、19 个工具实现及集成示例，具备可运行的服务器端代码。<br>核心功能包括：托管资源与知识、注册并执行工具、渲染 Prompt 模板、以及会话与能力声明管理等。

基于 Model Context Protocol (MCP) 的本地后端服务器实现，提供资源管理、工具注册与执行、以及可渲染的 Prompt 模板等能力，供 LLM 客户端通过标准化的 JSON-RPC 进行资源读取、工具调用与提示渲染。实现了多传输协议（如 STDIO、SSE、WebSocket）下的通信，具备会话管理与能力声明，旨在为本地化的上下文服务与推理工作流提供结构化的后端支撑。

基于 Model Context Protocol（MCP）的后端实现，提供 Google Workspace API 的工具集并通过 JSON-RPC 以标准化方式与 MCP 客户端通信，支持工具注册、执行调用、会话管理与多种传输场景（如 STDIO）。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册/执行、以及提示模板等功能，通过 JSON-RPC 与客户端交互，支持标准传输（如 Stdio）并可扩展为多种传输方式，适用于向 LLM 客户端提供上下文和外部功能接入能力。

基于 Model Context Protocol（MCP）的后端实现，提供资源、工具和提示模板的管理与执行，并通过 MCP JSON-RPC 规范与语言模型客户端进行通信，支持将上下文服务、安全检测和评估功能以工具形式暴露给 LLM 代理。

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

基于 Model Context Protocol 的 MCP 服务器，利用 Roslyn 提供对 C# 项目的语义分析与工具能力，并通过 JSON-RPC 方式与 LLM 客户端交互，支持标准化的资源管理、工具执行与提示渲染，适用于向 LLM 客户端提供上下文信息与分析能力的后端服务。

基于 Model Context Protocol 的后端服务器实现，提供资源、工具与提示模板的统一上下文服务，支持多传输协议（stdio、HTTP 等）并通过 JSON-RPC 与 LLM 客户端通信，适用于 Huly 集成场景。

AigoHotel 基于 Model Context Protocol (MCP) 的后端服务，提供酒店搜索、酒店详情与标签等工具，通过 JSON-RPC 与客户端交互，供 AI 助手获取上下文信息与功能。

基于 Model Context Protocol (MCP) 的后端服务器实现，能够托管资源、注册并执行工具、定义并渲染 Prompt 模板；通过 JSON-RPC 提供跨语言/跨进程的上下文服务，并支持多传输协议、会话管理与能力声明，适配 LLM 客户端的上下文服务需求。

基于模型上下文协议（MCP）的后端服务器实现，提供资源与工具的托管与管理、提示模板渲染，以及通过 JSON-RPC 与客户端进行的数据交互，支持守护进程模式、会话管理和多传输通道，适用于将 MCP 服务暴露给大型语言模型（LLM）客户端的场景。

基于 Model Context Protocol 的 MCP 服务器，将 LLM 客户端通过 JSON-RPC 接入 Vivid 运行时的控制接口，以统一管理资源、注册与执行工具，以及渲染与获取 Prompt 模板，提供对三域运行（GPU/GPU 纹理、音频、控制信号）的上下文服务。

基于 Model Context Protocol（MCP）的后端服务器实现，实现资源、工具、提示模板的统一管理与渲染，并通过 JSON-RPC/MCP 接口向 LLM 客户端提供上下文与能力，支持 HTTP+SSE 传输以及 stdio 模式的后端交互，内置会话管理与网页控制台，使用 SQLite 作为运行时状态存储。

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具、Prompt 模板等上下文信息的注册、管理与对外服务，通过 JSON-RPC 与 MCP 客户端通信，并支持会话管理与多传输协议（如 Stdio、SSE、WebSocket）等扩展能力，面向 LLM 客户端提供安全、可扩展的上下文服务框架。

基于模型上下文协议（MCP）的本地后端服务器，向大语言模型客户端提供结构化的浏览器上下文、工具和提示模板，并通过 JSON-RPC 进行通信。实现了资源、工具、提示模板的托管、注册与渲染，以及会话管理和跨传输协议的支持，适用于在本地环境中为 LLM 客户端提供可扩展的上下文服务。

基于模型上下文协议（MCP）的后端实现，作为 MCP 服务器向 LLM 客户端提供上下文信息、资源与工具，并支持提示模板的渲染与执行。通过 JSON-RPC 与客户端通信，提供资源读取、工具调用、Prompt 获取等能力，支持会话管理、能力声明以及多传输协议（如 stdio）的扩展性上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对 LinkedIn Sales Navigator 的资源访问、工具调用和提示模板等能力。通过 JSON-RPC 方式与 MCP 客户端通信，支持标准的 stdio 传输，内部实现了完整的 MCP 服务端框架与客户端封装，能够在服务端执行多种与 LinkedIn 相关的操作任务并对外暴露为可重用的工具集合。

基于 Model Context Protocol 的后端实现，提供资源托管与访问、工具注册与执行，以及面向 LLM 的 JSON-RPC 通信，并通过 WebSocket、SSE 与 HTTP 传输协议与客户端交互。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源、工具、 Prompts 的标准化管理与查询，并通过 JSON-RPC 与 MCP 客户端进行交互，支持多传输通道（如标准输入/输出、WebSocket、SSE），为 AI 代理提供上下文、数据访问和外部功能调用能力。

基于 Model Context Protocol 的 MCP 服务器实现，提供对本地 Aegis Agent Kit 的 MCP 接口，允许对实例管理、秘密、工具调用等功能进行统一的 JSON-RPC 访问，并与本地 aegisd/Aegis 运行时无缝协作以驱动 LLM 客户端的上下文能力获取与任务执行。

基于 Model Context Protocol（MCP）的后端服务器，聚合资源、工具与提示模板，提供标准化的 JSON-RPC 接口与会话管理，支持多传输协议以向大语言模型客户端提供上下文与功能能力。

基于 Model Context Protocol (MCP) 的本地知识库后端服务器，提供资源管理、工具注册与调用、提示模板渲染等能力，并通过 JSON-RPC 与 MCP 客户端通信，支持多种传输协议以便与大语言模型进行安全、可扩展的上下文服务交互。

基于 Model Context Protocol (MCP) 的本地后端服务，提供资源管理、工具注册与执行，以及提示模板渲染，通过 JSON-RPC 与 LLM 客户端进行交互，并支持本地化部署与多种传输方式。

基于 Model Context Protocol (MCP) 的本地化后端服务集合，提供资源管理、工具注册与执行，以及 Prompts 渲染等能力，面向 LLM 客户端通过 JSON-RPC 进行标准化上下文与功能访问，并支持多种传输路径与安全部署。该仓库实现了 Image 生成和 LinkedIn 发布等 MCP 服务的服务端逻辑，与 Claude 等客户端进行无缝集成。

基于 Model Context Protocol（MCP）的后端服务器集合，为 OpenAI Codex 及其生态中的多代理系统提供资源管理、工具执行、提示模板等统一的上下文服务，并通过 JSON-RPC 与 LLM 客户端通信，支持会话管理与多种传输通道（如 STDIO）。

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 MCP 客户端的上下文与能力提供者，托管资源、注册并执行工具、定义与渲染 Prompts，并通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多传输协议（如 stdio、HTTP、WebSocket）等能力，附带可审计的合规证据与安全保障。该实现定位为 MCP 服务器端架构，适合将 LLM 客户端接入到受控的工具与资源生态中。

基于 Model Context Protocol 的本地 MCP 后端，为 Claude Code 提供浏览器自动化的资源、工具与提示模板服务。通过本地 Unix 套接字与原生主机通信，支持 JSON-RPC 的工具调用与响应，并实现会话管理、扩展工具集、以及多传输协议的通信能力，适用于在本地 Firefox 环境中为 LLM 客户端提供上下文信息与功能。

基于 Model Context Protocol 的 MCP 服务器实现，作为 AI 助手的后端上下文服务，提供资源管理、工具注册与执行、以及提示模板渲染等核心能力，支持以 JSON-RPC 方式与运行在标准输入/输出、SSE、HTTP 的客户端进行通信。它将 Obsidian 笔记库与快速查询/推理功能整合，为 LLM 客户端提供安全、可扩展的上下文和功能接口。

基于模型上下文协议（MCP）的后端服务器，实现资源、工具与提示的注册、执行与渲染，并通过 JSON-RPC/HTTP 与客户端通信，提供多租户、RBAC、RAG 集成等能力，支持多传输方式的上下文服务框架。

面向 LLM 客户端的高性能MCP服务器，实现资源管理、工具注册与执行、以及Prompt渲染，通过JSON-RPC进行通信，支持多传输协议和可扩展生态。该仓库不仅提供MCP服务器端实现，还包含与前端Web应用的桥接组件和多种工具集合。

基于 Model Context Protocol (MCP) 的 Rust 实现，作为后端服务器提供以标准化方式向 LLM 客户端暴露上下文、资源、工具与 Prompt 的能力。通过 STDIO JSON-RPC 提供 MCP 服务器核心功能，支持会话管理、能力声明和工具调用等，并集成 CLI、HTTP 等多接口入口，便于在本地或嵌入式环境中实现多模型协作场景下的任务上下文服务。

基于 Model Context Protocol (MCP) 的 PubMed 资源与工具服务端，提供资源托管、工具注册与执行、以及可渲染的 Prompt 模板，支持通过标准的 JSON-RPC 与客户端进行上下文与功能交互，支持_stdio/HTTP/Cloudflare Workers 等传输方式，便于将 PubMed 的数据与检索能力暴露给大型语言模型进行查询、分析与生成。

基于 Model Context Protocol (MCP) 的后端服务实现，提供资源管理、工具注册与执行、以及 Prompt 模板的定义和渲染等功能，通过 JSON-RPC 与 LLM 客户端进行上下文信息和能力的交互，同时支持多种传输协议以实现安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端框架与一系列可运行的 MCP 服务器实现，提供资源、工具、提示模板的统一管理，并通过 MCP JSON-RPC 机制向本地或远端的 LLM 客户端渲染上下文与功能。

基于 Model Context Protocol (MCP) 的后端服务，提供工具注册与执行、资源管理以及与客户端的 JSON-RPC 通信能力，支持多种传输场景并可在无服务器环境中以内存传输方式运行，适用于将 LLM 与外部功能无缝对接的后端上下文服务框架。

基于 Model Context Protocol (MCP) 的服务器实现，提供资源与工具暴露、提示模板渲染等能力，并通过 STDIO 进行 JSON-RPC 风格的通信，方便 LLM 客户端以统一方式读取资源、调用工具、获取提示模板等上下文信息。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源存储、工具注册与执行、以及 Prompt 模板的管理与渲染，并通过 JSON-RPC 与客户端通信，支持多传输协议（如 StdIO、SSE、WebSocket），为大语言模型在应用中的上下文服务提供完整的 MCP 服务端能力。

基于 Model Context Protocol (MCP) 的后端服务实现，作为 LLM 客户端的上下文与能力提供者。该仓库实现了 MCP 服务器核心功能，包括资源（Resources）的托管与访问、工具（Tools）的注册与执行、Prompt 模板的定义与渲染，以及通过 JSON-RPC 与客户端的通信，支持多种传输通道（如标准输入输出、SSE、WebSocket），并具备会话管理与能力声明能力，用于提供安全、可扩展的上下文服务。

基于模型上下文协议（Model Context Protocol，MCP）的后端服务实现，提供向 MCP 客户端暴露 HTTP/StreamableHTTP 传输的 MCP 接口，以及可选的 stdio 传输，支持从浏览器端抓取的组件上下文实时供 Claude Code 等 MCP 兼容代理读取，并提供多种 MCP 工具（读取元素上下文、撤销/重做、会话历史、可及性与渲染分析等）的访问入口。

基于 Model Context Protocol (MCP) 的服务器实现，提供资源管理、工具注册与执行，以及 Prompt 模板渲染等能力，通过 JSON-RPC 与 LLM 客户端进行通信，支持纯 Python 实现与 Rust 实现的双版本 MCP 服务端，适用于 Claude Desktop 等 MCP 客户端场景。

基于 Model Context Protocol (MCP) 的后端服务实现，提供 MCP 请求的处理、JSON-RPC 响应、工具路由与上下文资源管理等能力，用于在 Sublime Text 编辑器中让 LLM 客户端通过 MCP 进行上下文供给、工具调用与提示模板渲染等交互。

基于 Model Context Protocol (MCP) 的后端服务，向大语言模型(LLM)客户端提供资源、工具注册与执行、以及可自定义的 Prompt 模板等上下文能力，并通过 JSON-RPC/ SSE/ stdio 等传输协议进行交互，适用于在浏览器、终端或应用中集成上下文服务。

基于 Model Context Protocol (MCP) 的本地后端实现，提供资源（Resources）托管与管理、工具（Tools）注册与执行、Prompt 模板的定义与渲染，并通过 JSON-RPC 的 MCP 协议与客户端通信，当前实现以 STDIO 传输为主，支持后续扩展的传输协议。

基于模型上下文协议（MCP）的后端服务器集合，提供托管资源、注册并执行工具、定义与渲染提示模板等能力，并通过 JSON-RPC 与客户端通信。该仓库实现了多台内置 MCP 服务器以及一个统一的 MCP 服务端，支持本地（stdio）、WebSocket/SSE 等传输协议的扩展上下文服务框架，适用于将大模型客户端接入到后端资源、工具与提示模板的强大上下文服务。

基于 Model Context Protocol 的 MCP 服务器端实现，提供资源管理、工具注册/执行、Prompts 渲染等能力，采用 JSON-RPC 与客户端进行通信，支持 SSE/WebSocket 等传输模式，供 LLM 客户端获得上下文与外部功能访问。

基于 Flyto-core 的 MCP 服务器实现，提供资源与工具的标准化注册与管理、Prompt 模板定义，以及通过 JSON-RPC 与客户端进行交互的服务端核心功能。支持会话管理、能力声明，并可通过多种传输协议（如 STDIO、HTTP、SSE、WebSocket）进行上下文服务提供，面向 LLM 客户端的上下文数据、工具调用和提示渲染等能力。

基于 Model Context Protocol (MCP) 的后端服务器，实现资源管理、工具调用与上下文渲染，供大语言模型客户端通过 JSON-RPC 进行高效、可扩展的上下文服务访问。

基于 ft 的 MCP 后端实现，通过标准的 JSON-RPC 向 LLM 客户端提供 Resources、Tools、Prompts 等上下文信息与功能，以及会话与能力管理，支持多传输协议（如 StdIO/SSE/WebSocket），以实现面向大语言模型的上下文服务后端。

Kiln 是一个基于 Model Context Protocol 的 MCP 服务器端实现，负责向 LLM 客户端以标准化方式提供上下文信息、资源访问、工具注册与执行，以及提示模板渲染，采用 JSON-RPC 与客户端通信，支持会话管理与多传输协议，适配多种打印后端与外部服务。