"资源管理" 标签

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

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

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

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

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

基于 Model Context Protocol (MCP) 的后端实现，提供资源、工具、提示模板等上下文信息，并通过 JSON-RPC（以 STDIO 传输为主）与 Claude Code 客户端进行交互，支持会话管理与能力声明，能够向 LLM 客户端暴露多种工作工具与上下文资源。该仓库中包含完整的服务端实现和对外暴露的 MCP 工具集合。

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

基于 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) 的多服务端 MCP 实现集合，提供资源管理、工具执行、自动化和 Kanban/Vault 等功能，以便向 LLM 客户端提供统一的上下文服务和能力调用接口。

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

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

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

基于 Model Context Protocol (MCP) 构建的后端服务器集合，提供资源/内存等资源管理、工具注册与执行，以及提示模板渲染等能力，作为 LLM 客户端的上下文与功能服务提供商。包含 state/memory/code_intel/trace/team 等独立 MCP 服务，通过 JSON-RPC 风格的请求/响应进行交互，并可通过 StdIO 启动在后台运行，支持会话管理与多传输协议适配，面向真实的 MCP 客户端使用场景。

基于 Model Context Protocol（MCP）的后端服务，实现资源、工具和提示模板的统一托管与执行，并通过 JSON-RPC 与 LLM 客户端通信，支持多传输方式（如标准输入输出、SSE、WebSocket）以提供可扩展的上下文服务。该仓库包含完整的 MCP 服务端实现及与本地后端的对接逻辑。

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

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

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

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

基于 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/HTTP+SSE 等协议与客户端通信，支持多传输协议、会话管理与能力声明，便于将上下文、工具和提示模板整合到 LLM 工作流中。

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

基于 Model Context Protocol (MCP) 的多实现服务器集合，提供资源管理、工具注册与执行、以及提示模板渲染等上下文服务，供大语言模型客户端通过标准化的接口进行上下文数据访问与外部功能调用。

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

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

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

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

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

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

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

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

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

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

基于 Model Context Protocol (MCP) 的后端服务器实现，向 Claude Code 客户端提供资源、工具与提示模板等上下文服务，支持资源管理、工具注册与执行、提示渲染，以及面向 LLM 的任务编排、成本估算、集成报告等功能，帮助实现可扩展、安全的上下文服务框架。

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

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

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行以及 Prompts 渲染，并通过 JSON-RPC 与客户端通信。

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

基于 Model Context Protocol (MCP) 的服务器端实现，提供资源管理、工具注册与执行、可自定义的 Prompt 模板渲染，以及多传输协议支持（如 HTTP 流、SSE、AWS Lambda 等），用于向大语言模型（LLM）客户端提供标准化的上下文和功能服务。具备会话管理、任务存储、实时通知、以及对 MCP 2025-11-25 规格的全面实现。

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

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

基于 Model Context Protocol (MCP) 的后端服务，提供资源管理、工具注册与执行以及提示模板渲染，并通过 JSON-RPC 与 MCP 客户端通信，支持多种传输与会话管理。

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

基于 Model Context Protocol 的 MCP 服务器实现，提供标准化的资源管理、工具注册与执行、以及 Prompt 模板渲染等功能，并通过 JSON-RPC 及 WebSocket/HTTP 等传输向 LLM 客户端暴露上下文与能力。该仓库实现了服务器端的完整 MCP 体系，包含工具箱、资源、提示模板等核心组成部分，以及用于与 MCP 客户端进行通信的路由与路由器。

基于 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 与客户端通信，内置以 stdin/stdout 形式的传输支持，便于在本地编辑器与 LLM 客户端中集成使用。

基于 Model Context Protocol（MCP）的后端实现，提供 Trips、Wishlists、Places 等资源的管理、工具执行以及 AI 助手交互能力，通过 /mcp HTTP 接口对外暴露给 MCP 客户端，支持本地 Ollama 模型、URL 导入、地理编码、天气等数据服务，适合作为 LLM 客户端的上下文与功能提供端。

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

基于 Model Context Protocol (MCP) 的后端服务器，托管资源、注册工具、定义与渲染 Prompt 模板，并通过 JSON-RPC 与 LLM 客户端进行交互，支持跨进程/网络传输以提供可扩展的上下文服务。

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

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

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

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源/文档管理、工具（Tools）的注册与执行、以及对外提供的提示模板等能力，客户端通过 JSON-RPC 与服务器通信；实现了多工具入口、会话/认证支持，以及通过标准输入输出（STDIO）的 MCP 服务端。

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

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

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、以及可渲染的 Prompt 模板等能力，设计用于通过 JSON-RPC 与 LLM 客户端进行标准化的上下文服务、工具调用与提示渲染等交互。

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

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

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

基于 Model Context Protocol (MCP) 的后端服务器实现，向 LLM 客户端通过 JSON-RPC 提供统一的上下文信息与功能。该服务器聚合 Xcode 构建、模拟器、资源缓存、持久化等资源与工具、提示模板的访问、执行与渲染，支持会话管理与能力声明，默认通过 STDIO 传输进行通信，便于在对话式 AI 应用中嵌入与扩展。

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

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

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

基于 Model Context Protocol 的 MCP 服务器实现，提供浏览器调试上下文的资源、工具与提示模板的管理，并通过 JSON-RPC 与客户端进行通信。

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

基于 Model Context Protocol (MCP) 的 ICC 配色分析与工具服务器实现，提供资源托管、工具注册与执行、以及（通过 Web UI 的 REST 接口）对外暴露的操作接口，支持通过 JSON-RPC 与客户端交互，方便对 ICC 配置进行分析、验证和管理。

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

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

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

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

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

这是一个包含多个基于模型上下文协议（MCP）的服务器实现的插件集，提供资源管理、工具注册与执行、以及提示模板渲染等能力，并通过 MCP SDK 的 JSON-RPC 与客户端进行交互，适用于 Claude Desktop 的上下文服务与插件化扩展场景。

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

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

基于 Model Context Protocol 的 MCP 服务器实现，提供资源、工具和 Prompt 的标准化管理，并通过 JSON-RPC 与客户端通信；支持 stdio 与 HTTP 传输，具备会话管理、能力声明和多传输协议扩展能力，旨在为 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) 的后端服务器实现，用于通过 JSON-RPC 与 LLM 客户端协同，管理多设备串口资源、注册并执行工具（Tools）、以及提供动态的提示/模板渲染能力，核心在于为 AI 应用提供统一的上下文和外部功能访问接口。

基于 Model Context Protocol (MCP) 的 Godot 项目后端服务器，实现资源、工具、Prompts 等 MCP 核心能力，并通过 JSON-RPC 与客户端进行通信，提供会话管理、能力声明、工具执行与数据渲染等功能。

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

一个跨语言的 MCP 服务器实现集合，用于将 Knowledge Context Protocol (KCP) 的 knowledge.yaml 声明暴露为 MCP 资源、工具和提示，提供单元资源读取、工具调用和提示获取等核心 MCP 功能，并支持子清单、验证、不同传输方式以及命令行与程序化接口。

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 SlimClaw 的内部 MCP 服务端，向 LLM 客户端以标准化的 JSON-RPC 形式提供资源管理、工具注册与调用、以及提示模板渲染等能力；通过标准的传输（如 stdin/stdout）与容器化执行环境进行交互，支撑多组会话、任务调度与分组上下文管理等功能。

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

基于 Model Context Protocol (MCP) 的后端实现，用于向大语言模型客户端以标准化方式提供资源、工具、提示模板等上下文及功能，并通过 JSON-RPC 进行通信，支持 STDIO 与 HTTP 传输模式以及多种会话管理能力。

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

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

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

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

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

基于 Model Context Protocol (MCP) 的后端服务，向 LLM 客户端以标准化方式提供资源数据、可注册与调用的工具，以及可渲染的 Prompt 模板；通过 JSON-RPC 进行通信，支持会话管理、能力声明与多传输协议（如 StdIO、SSE、WebSocket），为 LLM 应用提供安全、可扩展的上下文服务框架。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

基于 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) 的 Unity 后端实现，提供资源托管与访问、注册与执行工具、以及渲染 Prompt/模板，通过 JSON-RPC 与客户端通信，支持在多种传输方式下进行会话管理与能力声明，适用于向大型语言模型安全、可扩展地提供 Unity 资源与功能上下文。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管、工具注册与执行、以及 Prompt 模板渲染，使用 JSON-RPC 进行通信，支持多会话和热重载能力，并通过 SSE/HTTP 等传输方式向 LLM 客户端暴露上下文服务。

基于 Model Context Protocol 的 MCP 服务器实现，用于向 LLM 客户端以标准化方式提供资源管理、工具注册与执行以及 Prompt 模板渲染等上下文服务，支持通过 gRPC/JSON-RPC 与前端/IDE 等工具进行高效、安全的交互。项目包含用于生成与集成 MCP 输入输出的代码、以及面向资源类型的 API 框架与网关组件，定位为后端服务端实现。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（Resources）、工具（Tools）注册与执行，以及 Prompts 的定义与渲染，向 LLM 客户端以标准化方式暴露上下文与功能，并通过 JSON-RPC/HTTP 等协议进行通信，支持会话管理与多种传输途径，致力于为 LLM 应用提供可扩展的上下文服务框架。

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

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

基于 Model Context Protocol (MCP) 的后端服务，按标准化方式向 LLM 客户端提供资源、工具与 Prompt 模板，并通过 JSON-RPC 进行通信，支持多传输协议与会话管理，适用于以上下文驱动的 AI 应用场景。

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

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

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

基于 Model Context Protocol（MCP）的后端实现，作为后端服务器向大型语言模型客户端提供资源、工具执行能力与提示模板等上下文服务，支持会话管理、能力声明及多传输协议（如标准输入输出、SSE、WebSocket）等特性，适用于在 iOS/macOS/Xcode 项目中作为代理服务的后端服务器。

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

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

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

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

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

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

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

基于 Model Context Protocol (MCP) 的后端服务器，向 LLM 客户端提供标准化的资源访问、工具执行与提示模板渲染能力，并通过 JSON-RPC 与客户端进行通信，支持多传输协议（如 Stdio、HTTP、SSE、WebSocket），用于在代码上下文中以高效、可审计的方式提供上下文与功能服务。

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 Koharu 项目的后端“上下文服务网关”，通过 JSON-RPC/流式接口向 LLM 客户端提供对资源、工具和提示等的访问与执行能力，便于将 Koharu 的对象检测、OCR、翻译/翻译后处理、以及文本渲染等功能以统一的 MCP 形式暴露给外部代理或智能体。该实现包含服务器核心逻辑、资源/工具路由及对外提供的信息接口，支持通过网络与本地进程协作。

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

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

基于 Model Context Protocol 的后端服务端实现，聚合并暴露多家集成（如 GitHub、Datadog、Linear、Sentry、Slack、Metabase、PostgreSQL、ClickHouse、RWX 等）的工具（Tools），通过统一的 MCP 端点向 LLM 客户端提供资源、工具执行和提示模板渲染能力，并支持 Web UI 配置与会话管理。

基于 Model Context Protocol (MCP) 的后端服务器实现，托管资源、注册并执行工具、定义并渲染提示模板，提供面向 LLM 的标准化上下文服务与工具执行能力，支持多传输通道（如 Stdio、HTTP、SSE/WebSocket）与会话管理。

基于 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）的后端服务器实现，提供资源、工具和提示模板的注册、管理与执行，允许通过 JSON-RPC 与任意 LLM 客户端进行上下文信息服务与外部功能调用，并支持多种传输方式与会话能力声明。

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

基于 Model Context Protocol (MCP) 的 Modbus 设备后端服务器，向大语言模型客户端提供对 Modbus 设备的资源读取、工具执行与提示渲染等能力，采用 JSON-RPC 风格的 MCP 通信，支持资源、工具、提示的统一管理与执行。

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

基于 CCOS 的 MCP 服务器实现，提供资源管理、工具注册/执行、以及基于 Prompts 的导航与渲染能力，支持通过 JSON-RPC 与 LLM 客户端进行资源读取、工具调用和提示模板获取等标准化上下文服务。

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

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

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

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

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

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

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

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

基于 Model Context Protocol (MCP) 的后端服务，提供资源、工具与提示的统一注册、管理与访问，通过 JSON-RPC 与 LLM 客户端进行安全、可扩展的上下文服务交互，支持多模块扩展和 Bearer Token 认证。

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

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

基于 Model Context Protocol 的 MCP 服务器实现，为本地 Markdown 项目提供标准化的上下文服务，包括资源托管、工具注册与执行，以及对外暴露的 MCP HTTP/stdio 接口，便于与各类大语言模型或本地 AI 客户端进行深度集成。

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

基于 Model Context Protocol (MCP) 的服务器实现，提供工具与资源的暴露、对后端的代理调用，以及面向 LLM 的上下文服务能力，并支持多种传输协议（stdio、Streamable HTTP/SSE 等）以实现安全可扩展的上下文服务框架。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源、工具与提示模板，并通过 JSON-RPC 形式与 LLM 客户端交互，核心通过 clawdstrike CLI 进行策略执行、审计与 receipts 的产出，支持 STDIO 传输方式用于嵌入式/桌面场景。通过 Cursor 插件中的 MCP 服务器实现，将策略执法与工具边界保护融入到 MCP 框架之中。

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

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

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

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

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

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

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

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

基于 Cortex 的 Model Context Protocol (MCP) 服务器实现，向 LLM 客户端提供标准化的上下文、资源与工具访问，并支持多传输协议（标准输出/HTTP+SSE），实现资源、工具、提示模板等 MCP 核心能力。

基于模型上下文协议（MCP）的 DuckDB 后端实现与扩展，提供资源、工具、提示模板的托管、注册与查询能力，并通过多种传输协议（stdio、HTTP、WebMCP、内存等）与 LLM 客户端进行 JSON-RPC 交互，涵盖服务器端会话、权限控制与安全模型的完整实现。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，作为 Libra 项目的一部分，向 LLM 客户端以标准化方式提供上下文信息与能力：托管并管理资源（Resources）、注册并执行工具（Tools）、定义与渲染 Prompt 模板（Prompts），并通过 JSON-RPC 与客户端进行通信，支持多种传输通道（如 Stdio、SSE、WebSocket），实现会话管理与能力声明，便于 AI 场景下的上下文服务与功能扩展。

基于 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 服务器实现，提供资源管理、工具注册与执行、以及提示模板渲染等能力，面向大语言模型客户端提供标准化的上下文服务。

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

基于 Model Context Protocol (MCP) 的后端服务，提供技能资源管理、工具注册与执行、以及提示模板渲染，向 LLM 客户端以标准 JSON-RPC 交互提供上下文与能力，支持多传输接口与会话管理。适合作为 AI 代理的可扩展上下文服务端。

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

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

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

基于 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）的后端服务器实现，向大型语言模型（LLM）客户端提供 Onshape REST API 的上下文信息、资源和工具，支持资源管理、工具注册与执行，以及提示模板的渲染；通过 JSON-RPC 风格的接口进行交互，具备多传输通道（如 stdio、HTTP）与 OAuth 等认证能力，适合作为面向 AI 助手的上下文服务框架。

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具和提示模板的托管与注册，并通过 JSON-RPC 与 LLM 客户端通信，支持本地开发与扩展传输。

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

基于 Model Context Protocol 的企业级后端实现，提供资源读取、工具执行、提示模板管理等能力的 MCP 服务器实现，用于为大型语言模型客户端提供实时上下文数据与外部功能接入。

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

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

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

基于 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 服务器实现，能够向 LLM 客户端以标准化方式提供上下文信息和功能，包括资源管理、工具注册与执行，以及 Prompt 模板的渲染与渲染结果的序列化，通过 JSON-RPC 与客户端通信，并支持流式传输等多种传输模式。该仓库实现了服务器端逻辑和对外暴露的工具/资源接口，便于与大型语言模型进行后端上下文交互与功能调用。

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

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

基于 Model Context Protocol 的 MCP 服务器后端，提供对 Google Drive 的资源管理、工具执行和提示模板渲染等能力，通过 JSON-RPC 与客户端通信，支持 STDIO 传输，供大语言模型（LLM）应用读取资源、执行工具、以及获取或渲染提示。该实现包括资源读取/搜索、工具执行（如搜索、读取、下载、导出、上传等）以及可选的 Sheets 读取和资源列表示等功能。

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

基于 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 与客户端通信，支持会话管理与多传输协议，适配多种打印后端与外部服务。

基于 Model Context Protocol (MCP) 的后端实现，提供资源管理、工具执行以及提示模板的标准化上下文服务，供 LLM 客户端通过 JSON-RPC 进行数据访问、功能调用和提示渲染，并通过 stdio 等传输协议与 Claude Desktop 等客户端协同工作。

基于 Model Context Protocol (MCP) 的后端服务器，向 LLM 客户端提供资源、工具和 Prompts，并通过 JSON-RPC/SSE 等协议实现统一的上下文服务与对话管理。

基于 Model Context Protocol (MCP) 的 FoundryVTT 后端服务器，实现资源托管、工具注册与执行，以及提示模板渲染，通过 JSON-RPC 与客户端进行通信，支持多传输协议并提供会话管理与健康诊断等能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（Resources）托管与数据访问、工具（Tools）的注册与执行、以及提示模板（Prompts）的定义与渲染；通过 JSON-RPC 与客户端进行交互，支持会话管理、能力声明与多传输通道，构建面向LLM应用的可扩展上下文服务框架。

基于 Model Context Protocol (MCP) 的分布式后端实现，作为 LLM 客户端的上下文与能力服务中心，提供资源管理、工具注册与执行、Prompt 模板渲染等能力，并通过 JSON-RPC 方式进行通信；包含多节点架构、会话与能力声明，以及对 Stdio、SSE、WebSocket 等传输协议的支持，适配多种 LLM 应用场景。

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源托管与访问、工具注册与执行、以及 Prompt 模板的渲染与管理；通过 JSON-RPC 方式与客户端通信，支持多传输协议（如标准输入输出和 SSE），实现会话管理、能力声明与权限控制，面向 LLM 客户端提供可扩展、可审计的上下文服务框架。

基于 Model Context Protocol (MCP) 的服务器端实现，作为 Nightshade 引擎的一部分在本地启动并提供资源管理、工具执行与 prompts 渲染等能力，允许对运行中的场景进行实时上下文操作，并通过 HTTP JSON-RPC 与 Claude 等 MCP 客户端通信。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册/执行、以及提示模板的定义与渲染，并通过 JSON-RPC 与客户端通信，支持本地或混合模型的上下文服务和执行能力。该仓库包含可运行的服务器端实现及相关集成组件，不仅是客户端示例或测试代码。

基于 Model Context Protocol (MCP) 的后端服务器，实现资源、对象/场景管理与工具执行等能力，面向 LLM 客户端提供标准化的上下文与功能服务。

基于 Model Context Protocol（MCP）的后端服务器实现，面向 LLM 客户端提供标准化的上下文资源、工具注册与执行能力，以及可定制的 Prompt 模板渲染；通过 JSON-RPC 进行通信，包含会话管理、能力声明，且支持多种传输协议（如 STDIO、SSE、WebSocket），为代码基地级别的上下文服务提供端到端的后端能力。

基于 MDDB 的 MCP 服务器实现，提供资源托管、工具注册与执行、以及 MCP 配置输出等核心能力，便于将 MDDB 作为上下文服务对接大语言模型客户端。

基于 Nevermined Payments 的 MCP 服务器实现，为大型语言模型客户端提供资源、工具、提示等上下文能力的标准化服务。通过 JSON-RPC 与客户端通信，处理请求/响应，包含会话管理、能力声明，并支持多种传输方式与安全认证机制，便于搭建安全、可扩展的上下文服务平台。

基于 Model Context Protocol (MCP) 的后端服务实现，向大语言模型客户端提供资源管理、工具注册与执行，以及提示模板渲染等上下文服务，采用 JSON-RPC 风格接口进行通信，支持在本地 SQLite 存储中管理会话、记忆、工具输出等上下文信息。该仓库内含完整的 MCP 服务器实现及相关组件，可作为可运行的 MCP 服务端使用。

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具、提示模板等统一注册、执行与渲染能力，通过 JSON-RPC 与客户端通信，支持会话管理、能力声明以及多传输协议扩展，作为 LLM 客户端的上下文服务与功能入口。

基于 MCP 的后端服务器，用标准化的 JSON-RPC 形式向 LLM 客户端暴露资源、工具和提示模板的注册、执行与渲染能力，并通过 交易所需的支付流程（402 协议）完成资源访问与工具调用的权限控制。

基于 Model Context Protocol 的 MCP 服务器实现，提供对 Resources、Tools 和 Prompts 的标准化托管与交互，客户端通过 JSON-RPC 与服务器通信，支持会话管理、能力声明，以及多种传输协议扩展。仍需配合仓库中的客户端进行使用。

基于 MCP（Model Context Protocol）的后端服务体系，面向 Claude Code 等 LLM 客户端提供标准化的上下文资源、工具执行与提示模板管理，并通过 JSON-RPC 进行通信，支持多种传输通道与会话能力。

基于 Model Context Protocol (MCP) 的服务器实现，作为 Raven 的后端服务，通过 JSON-RPC 2.0 向 LLM 客户端暴露资源、工具和提示模板等上下文能力，支持将 Raven CLI 作为工具执行、资源与对象的查询与管理，并为 agent 与工具链提供统一的上下文服务。

基于 Model Context Protocol (MCP) 的服务器端实现，向大语言模型客户端提供资源、工具与提示模板等上下文服务，并通过 JSON-RPC 进行通信，包含认证、会话管理与多种传输能力，适用于在本地自托管环境中为智能代理提供上下文与外部功能调用能力。

基于 Model Context Protocol（MCP）的后端服务实现，作为LMM客户端的上下文与能力提供者：承载并管理资源、注册与执行工具、定义与渲染 Prompt 模板；通过 JSON-RPC 在多种传输通道（如 WebSocket/Stdio/SSE 等）上与客户端通信，实现会话管理、能力声明与安全扩展的上下文服务框架。

基于模型上下文协议（MCP）的后端服务器模板，提供资源托管、工具注册与执行、以及 Prompt 模板渲染能力；通过 JSON-RPC 与客户端通信，支持多传输模式（如 StdIO、SSE、WebSocket），适用于为大语言模型（LLM）提供上下文数据与外部功能访问。

Pare 是一个面向开发者的 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) 的后端服务器实现，提供资源管理、工具注册与执行，以及提示模板渲染能力，通过 JSON-RPC 与 LLM 客户端进行交互，支持多种传输方式（如 StdIO/SSE/WebSocket）以在本地模型对话中提供统一的上下文服务。

基于模型上下文协议（MCP）的后端服务实现，提供资源管理、工具注册/执行、Prompt 模板渲染等功能，通过 JSON-RPC 与客户端通信，支持多传输协议（如 Stdio、SSE、WebSocket）以及会话管理与能力声明，用于为大模型/代理提供可扩展的上下文与外部操作能力。

基于 Model Context Protocol (MCP) 的后端实现，为大语言模型客户端以标准化方式提供 VINE 任务图的资源、工具和提示模板；通过 JSON-RPC 进行通信，支持多传输方式（如 StdIO、SSE、WebSocket），并实现会话管理、能力声明及对 vine 文件的读写/扩展能力。

基于 Model Context Protocol (MCP) 的后端实现，向 LLM 客户端以标准化的 JSON-RPC 形式提供带时间戳的资源、工具和促发模板，支持多传输协议、会话管理与安全控制，便于构建可扩展的上下文服务。

基于 Model Context Protocol 的后端 MCP 服务器，实现资源、工具与提示模板的托管与管理，并通过 JSON-RPC 提供对外访问，供 LLM 客户端检索资源、调用工具、渲染提示并进行会话管理与能力声明。

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具及提示模板的托管与管理，并通过 JSON-RPC/WebSocket 形式与 LLM 客户端进行通信，实现会话管理、能力声明与多传输协议的上下文服务。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、Prompt 模板渲染等核心能力，并通过 JSON-RPC 与 LLM 客户端进行上下文信息托管和功能调用，支持会话管理与跨会话记忆，面向自动化代码与软件工程场景的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务，集中管理资源、注册与执行工具、定义与渲染 Prompt 模板，并通过 JSON-RPC 与 LLM 客户端通信，支持多传输协议，提供本地化的代码上下文服务与扩展能力。

基于 Model Context Protocol (MCP) 的后端服务实现，面向大语言模型客户端提供标准化的上下文服务。核心职责包括托管与管理资源、注册和执行工具、定义与渲染 Prompt 模板，并通过 JSON-RPC 与客户端进行通信。具备资源/工具/提示的托管、会话管理、能力声明，以及对多传输协议的支持（如 Stdio、SSE、WebSocket）等能力。

基于 Model Context Protocol (MCP) 的后端服务器，桥接 LLM 客户端与 Actual Budget 数据、工具与 Prompts，提供资源访问、工具调用与 Prompt 渲染等能力，并通过 JSON-RPC 与客户端进行交互，支持会话管理与认证等商业级特性。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源读取、工具执行、以及上下文相关能力，能够通过 Claude Code 等 LLM 客户端以 JSON-RPC 风格进行交互，向客户端提供工作区状态、Ralph 循环状态、团队活动等资源，并暴露可执行的工具集和资源查询、记忆等能力，支持插件式扩展与多机器协作场景。

基于 Model Context Protocol 的 MCP 服务器实现，能够加载 MF 配置、注册工具、管理远程资源、渲染 MF 应用并通过 MCP 协议与客户端通信，提供多传输协议支持与安全的上下文服务框架。

基于模型上下文协议（MCP）的后端服务器实现，提供资源管理、工具注册与执行、以及可渲染的 Prompt 模板，供大模型客户端以标准化的 JSON-RPC 方式获取上下文数据、调用外部功能与获取对话模板。服务器实现了会话管理、能力声明，并支持多种传输协议（如 Stdio、SSE、WebSocket），为结构化辩论场景中的 Wind/Wall/Door 模型提供安全、可扩展的上下文服务框架。

基于 Model Context Protocol (MCP) 的后端服务，实现资源托管、工具注册/执行与 Prompt 模板渲染，向 LLM 客户端以标准化的 JSON-RPC 方式提供上下文与功能，并通过 Axum 构建的 MCP 服务端实现会话管理、能力声明与多传输协议支持（如 Stdio、SSE、WebSocket）以服务化地提供组织级记忆与上下文服务。

基于 Model Context Protocol (MCP) 的后端服务，提供资源管理、工具注册与执行、以及可渲染的 Prompt 模板等能力，使用 JSON-RPC 机制与 LLM 客户端进行通信，支持多传输协议（包括标准输入输出、SSE、WebSocket）并内嵌 SQLite/FAISS 等组件实现安全、可扩展的上下文服务框架。

Nebula 是基于 Model Context Protocol 的 MCP 服务器实现，能够对接 LLM 客户端，通过 JSON-RPC 提供资源管理、工具注册与执行、以及提示模板渲染等上下文服务，支持 STDIO 与 HTTP/SSE 等传输方式，便于在云安全场景中为 AI 助手提供后端能力。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源托管与数据访问、工具注册与执行、以及提示模板渲染等 MCP 核心能力，并通过 JSON-RPC 与 LLM 客户端进行通信；包含委派服务器等 MCP 服务入口，支持基于 stdio 的服务以及可扩展的传输协议。该仓库实现了 MCP 服务器端逻辑与启动集成，能够为 LLM 客户端提供上下文服务、工具执行能力以及可渲染的 Prompt 模板。

基于模型上下文协议（MCP）的后端服务，提供资源托管、工具注册与执行、Prompt 模板渲染，并通过 JSON-RPC 与客户端进行标准化交互；支持多传输协议、会话管理与能力声明，适配多种 LLM 客户端场景。

基于 MCP 的高性能后端服务器，提供资源、工具、以及提示模板的统一上下文服务，通过 JSON-RPC 与客户端通信，支持 STDIO、SSE、HTTP 等传输模式。

基于模型上下文协议(MCP)的后端服务器实现，提供资源与工具的注册、SSE传输的MCP服务端，以及多种认证方式（JWT、AK/SK、Open API签名）。通过 MCP 客户端（如 Claude、Cursor、CodeBuddy 等）以统一的JSON-RPC风格远程访问文件管理、统计与系统信息等能力，支持扩展的资源与工具。

基于 Model Context Protocol 的后端服务实现，提供资源管理、工具注册与执行、以及 Prompt 模板渲染，支持 JSON-RPC 通信与多传输接入，面向 LLM 客户端提供统一的上下文与功能入口。

基于 Model Context Protocol (MCP) 构建的 Kanban 项目管理后端，通过 MCP 与 AI 助手进行上下文交互，提供创建与查询项目、任务、阶段等资源的能力，并支持工具调用与计划规划等 MCP 功能。服务器与客户端通过 JSON-RPC 风格的 MCP 协议进行通信，支持通过标准输入/输出等传输模式进行对话与协作。

基于 Model Context Protocol (MCP) 的后端服务器，负责托管资源、注册与执行工具、定义并渲染可定制的 Prompt 模板，并通过 JSON-RPC 与 LLM 客户端进行标准化的上下文服务交互，支持多种传输协议以提供安全、可扩展的后端能力。

基于 MCP 的服务器端组件，通过 logseq-cli 提供 MCP 服务器，实现资源管理、工具调用和 Prompt 渲染，为 LLM 客户端提供上下文信息和功能，支持 HTTP 与 STDIO 传输。

基于 Model Context Protocol (MCP) 的后端服务，作为 Antigravity-Manager 项目的一部分，提供标准化的模型上下文后端能力：托管 Resources（资源与数据）、注册与执行 Tools（外部功能调用）、定义与渲染 Prompts（提示模版），并通过 JSON-RPC 与 LLM 客户端进行通信，支持会话管理、能力声明以及多种传输协议，实现跨 OpenAI/Claude/Gemini 等协议的统一上下文服务和模型路由能力。

基于 Model Context Protocol (MCP) 的后端服务器，向 LLM 客户端以标准化的 JSON-RPC/工具调用方式提供资源存储、工具执行和提示渲染等能力，并支持会话管理、权限控制与多传输协议（标准输入/输出与 HTTP 流式传输），实现面向 AI 代理的上下文服务平台。

基于 Model Context Protocol (MCP) 的本地后端实现，提供向量检索、工具调用与 DyTopo 多代理路由等能力，旨在为本地离线/私有环境中的大模型客户端通过 MCP 协议以标准化方式获取上下文资源与功能。

基于 Model Context Protocol（MCP）的后端实现，提供资源托管与管理、工具注册与执行、以及提示模板的渲染与测试能力，并通过 JSON-RPC 与 LLM 客户端进行交互。支持多传输协议（如 SSE、WebSocket、stdin/stdio），用于为 LLM 应用提供可扩展的上下文服务框架。仓库实现包含服务端核心路由、MCP Apps 与 Widget 集成、OAuth/API Key 等认证测试用例，以及用于调试与开发的工具和中间件。

基于 Model Context Protocol (MCP) 的服务器实现，提供带缓存的文件读取工具、批量读取、缓存状态与清理等功能，面向大语言模型（LLM）客户端以标准化方式提供资源、工具与提示渲染能力。

基于 Model Context Protocol（MCP）的后端服务器实现，向 LLM 客户端提供资源管理、工具注册与执行、以及 Prompt 模板渲染等上下文服务，并通过 JSON-RPC 与客户端通信，支持 Claude Code 的多主体协作与扩展能力。

基于 zkmin 的 MCP 服务器实现，提供资源、工具与提示模板的托管与渲染；通过 JSON-RPC 与客户端通信，支持 HTTP/SSE 传输，用于向大语言模型客户端提供可上下文化的后端能力与交互功能。

基于 Model Context Protocol (MCP) 的后端服务器，实现资源、工具与 Prompt 模板的注册、管理与渲染，并通过 JSON-RPC 与客户端通信，提供会话管理与多传输协议支持的上下文服务框架。

基于 Model Context Protocol 的后端服务器集合，提供资源、工具和提示模板的标准化上下文服务；通过 JSON-RPC 与 LLM 客户端通信，支持多传输模式（SSE、stdio、HTTP），并包含多种领域的 MCP 服务实现（资源管理、分析、报告撰写、团队分析等）。

基于 MCP（Model Context Protocol）的后端服务，向 LLM 客户端通过标准化的JSON-RPC提供资源、工具和提示模板，并支持多传输协议（stdio/SSE/HTTP），实现会话管理与能力声明，便于上下文信息的安全、可扩展加载与调用。

基于 Model Context Protocol (MCP) 的后端服务器实现，用于向大语言模型客户端提供资源、工具和提示模板等上下文信息，并通过 JSON-RPC 进行请求/响应交互，作为 RestFlow 的 MCP 服务端核心能力之一。

基于 Model Context Protocol (MCP) 的后端服务，将资源、工具与提示模板以标准化的 MCP 服务器形式提供给 LLM 客户端，通过 JSON-RPC 进行交互，支持多种传输通道（如 STDIO、SSE、WebSocket），实现会话管理、能力宣告与可扩展上下文服务。

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

基于 Model Context Protocol (MCP) 构建的 MCP 服务器实现，负责以标准化方式向 LLM 客户端提供上下文信息与功能，包括资源管理、工具注册与执行，以及 Prompts 的定义与渲染，支持本地/远程 relay 环境与多传输通道的 JSON-RPC 通信。

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

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

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

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

基于 Model Context Protocol (MCP) 的后端服务器集合，提供资源、工具、提示模板等能力，供大语言模型（LLM）通过 JSON-RPC 方式调用和使用，用于资源管理、工具执行、提示渲染等场景。

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

基于模型上下文协议（MCP）的多租户文档上下文服务端，提供资源托管、工具注册与执行、Prompts 定义与渲染等核心能力，并通过 JSON-RPC 与客户端通信，支持健康检查、会话管理与多传输协议扩展，适用于为大语言模型提供可控的上下文与功能门控。

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

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供对本地钥日志、屏幕截图及相关资源的访问、工具注册与执行能力，并通过 HTTP 传输实现与客户端（如 Claude Desktop 等 LLM 客户端）的 JSON-RPC 通信。

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

基于 Model Context Protocol (MCP) 的完整 MCP 服务端框架与生态系统，提供可扩展的 MCP 服务器实现、资源与工具托管、提示模板渲染，以及通过 JSON-RPC 与客户端通信的能力，支持多传输协议（如 Stdio、SSE、WebSocket）与会话管理，适用于搭建支持 LLM 的上下文服务后端。

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

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

基于 Model Context Protocol 的服务器端实现，作为 MCP 后端为 LLM 客户端提供资源、工具、Prompts 的标准化上下文与功能服务，通过 JSON-RPC 与客户端通信，并支持多种传输方式的扩展与会话管理。

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

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

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

基于 Model Context Protocol (MCP) 的完整后端服务器实现，提供资源管理、工具注册与执行、以及 Prompt 模板渲染等核心能力，通过 JSON-RPC 与 LLM 客户端通信，支持 Godot 引擎与编辑器插件的桥接执行，满足在多传输通道下的上下文服务需求。

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

基于 Ray Serve 的 MCP（模型上下文协议）服务端实现，提供注册、管理与暴露 MCP 服务器的能力，并通过 HTTP/JSON-RPC 风格接口与客户端进行资源读取、工具调用与请求渲染等交互，同时支持通过侧车代理实现对外部 MCP 服务器的访问控制与转发。

基于 Model Context Protocol (MCP) 的 MCP 服务器实现，围绕 Swarm 的 Hive/Hivemind/Swarmmail/Swarm 工具等组件，通过标准化的 JSON-RPC 接口向 LLM 客户端暴露工具注册、资源访问、提示模板等能力，并以 stdio 为传输实现服务器端与客户端的通信与协作。

基于 Model Context Protocol (MCP) 的后端服务器实现集合，用于向大语言模型客户端提供统一的上下文服务，包括资源（Resources）的托管与访问、工具（Tools）的注册与执行，以及提示模板（Prompts）的定义与渲染。仓库内含 Memory Bank 与 Cursor Shortcuts 两个成熟的 MCP 服务器实现示例，均通过标准的 JSON-RPC 形式与客户端通信，并提供以Stdio等多种传输方式的支持。

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

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

基于 Model Context Protocol (MCP) 的企业级后端服务集合，提供资源管理、工具注册与执行、以及可渲染的 Prompt 模板等能力，用于向大语言模型客户端提供上下文与外部功能访问。仓库中包含多种以 MCP 为核心的服务器实现示例，支持不同传输方式（SSE、HTTP、stdio 等）与部署场景，覆盖从工具注册到调用、以及与外部系统的集成等完整场景。

基于 Model Context Protocol (MCP) 构建的后端服务器，向大语言模型（LLM）客户端提供标准化的上下文服务，包括资源（Resources）的管理、工具（Tools）的注册与执行，以及提示模板（Prompts）的定义与渲染；通过 JSON-RPC 与客户端通信，支持会话管理与多传输协议（如 STDIO、SSE、WebSocket）的扩展能力。

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

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

基于 Model Context Protocol 的后端 MCP 服务器，实现资源、工具、提示模板等核心接口，使用 JSON-RPC 与客户端通信，向 LLM 客户端提供资源访问、工具调用与提示渲染能力，并支持多种传输协议（stdio、SSE、streamable-http 等）。

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

基于 Model Context Protocol (MCP) 的后端服务集合，提供资源管理、工具注册与执行，以及可渲染的 Prompt 模板，支持 JSON-RPC 风格通信和 STDIO/WebSocket 等传输协议，用于向 LLM 客户端暴露上下文、工具和资源等能力。

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

Nosia 的 Model Context Protocol（MCP）后端实现，负责向大语言模型客户端提供资源、工具与提示模板等上下文能力，并通过 MCP 协议规范化地对接外部服务与数据源，支持多租户场景、会话状态管理以及多种传输方式（如 STDIO、SSE、WebSocket），以实现对外部能力的扩展与整合。该项目不仅具备服务端管理能力，还通过服务器端的工具、提示和资源管理，促进 LLM 与外部系统的无缝交互。

基于 Model Context Protocol (MCP) 的后端服务器（MeMesh，原 Claude Code Buddy），为大语言模型客户端提供记忆化上下文、资源管理、工具执行与可定制的 Prompt 模板渲染，支持 JSON-RPC 通信、会话管理以及多传输协议（如 Stdio、SSE、WebSocket）。

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

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

基于 FastAPI 的 MCP（Model Context Protocol）服务器实现，提供对资源、工具和提示模板的托管与执行能力，支持与单个或多服务器协作、OAuth/API Key 授权、工具同步、以及流式传输等特性，面向 LLM 客户端提供标准化上下文服务。

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

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

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

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

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源托管、工具注册与执行、以及提示模板渲染等核心能力，并通过 JSON-RPC 与 LLM 客户端进行上下文与功能交互，部署在 Cloudflare Workers 中以实现安全、可扩展的上下文服务。

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

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

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

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

基于 Model Context Protocol (MCP) 的服务器端实现，作为后端上下文服务提供者，面向 LLM 客户端提供资源管理、工具执行和提示模板定义等功能，并通过 JSON-RPC/MCP 协议进行通信。实现了资源、工具、提示、多模态信息处理、会话管理以及通过配置驱动的行业路由与风险等级评估等能力。

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

基于 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 与客户端通信，并可通过多种传输方式（stdio、SSE/HTTP）进行交互。

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

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

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

基于模型上下文协议（MCP）的后端服务器，向LLM客户端提供资源管理、工具执行和提示模板等上下文信息，支持多传输协议（如 Stdio、HTTP/WebSocket），通过 JSON-RPC 进行请求-响应交互。该实现覆盖资源、工具、Prompts 的注册、查询与渲染，以及会话管理与安全能力声明等核心功能，构成可扩展的对话上下文服务框架。

基于 Model Context Protocol（MCP）的后端实现，提供当前最先进模型的信息、硬件感知的资源筛选、可调用的工具，以及可渲染的提示模板；通过 JSON-RPC 与客户端通信，支持多传输通道，用于在 LLM 客户端中统一提供上下文信息与能力。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（Resources）管理、工具（Tools）注册与执行、以及提示模板（Prompts）的渲染等能力，允许通过 JSON-RPC 与 LLM 客户端进行标准化交互，支持多传输协议（如流式 HTTP、StdIO、SSE、WebSocket），为 LLM 应用提供安全、可扩展的上下文服务框架。仓库内包含基于 Python 的 FastAPI 实现（以及可选的 Node.js 实现结构），实现完整的 MCP 服务端功能与实际数据源集成。

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

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

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

一个基于 Model Context Protocol (MCP) 的完整 MCP 服务器实现，作为后端上下文服务向 LLM 客户端提供资源管理、工具执行和 Prompt 渲染等能力。服务器通过 MCP 标准接口处理来自 LLM 的请求，管理会话与能力声明，并使用 SQLite 持久化资源状态与依赖关系，支持通过 stdio 传输渠道与客户端进行通信，便于在本地或集成开发环境中快速原型与迭代。

一个实现模型上下文协议（MCP）核心功能的后端服务器集合，提供 Weather、Tech News、Math 等 MCP 服务端实现示例。基于 FastMCP 库构建并通过标准的 MCP 传输（如 stdio）暴露工具接口，便于 MCP 客户端注册、请求资源与执行工具，形成标准化的上下文服务后端。

基于 Model Context Protocol 的后端服务实现，提供资源托管、工具执行、以及提示模板渲染等能力，支持通过 JSON-RPC 与大语言模型客户端进行资源读取、外部功能调用、以及上下文管理等交互。服务器端提供 STDIO 传输的 JSON-RPC 服务，并可选搭建 HTTP 调试接口，适合将本地上下文服务嵌入到 AI 助手工作流中，便于对接 Kubernetes 资源、CRD、以及服务器端的 dry-run 验证等功能。

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

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

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

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

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

一个用于 AI 代理的模型上下文协议（MCP）服务器实现，提供资源、工具和提示模板等上下文服务，并通过 JSON-RPC 与客户端进行交互。

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

基于 Model Context Protocol (MCP) 的后端服务器，提供资源、工具和提示模板的管理与执行，通过 JSON-RPC 与客户端通信，支持多种传输协议（stdio、WebSocket、SSE），用于向大语言模型（LLM）提供可扩展的上下文服务。

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

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

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

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具和提示模板的标准化管理与对外接口，支持 HTTP 与 STDIO 等传输模式，面向大语言模型客户端的上下文服务。

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

基于 Model Context Protocol 的 MCP 服务器，实现 Hydra 项目的资源、工具与提示模板等能力的 JSON-RPC 访问与执行，支持多种传输模式，便于 LLM 客户端获取上下文信息与功能。<name></name>

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

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

基于 Model Context Protocol（MCP）的后端服务器实现；通过标准化的 JSON-RPC 方式向 LLM 客户端提供上下文信息、资源管理、工具注册与执行，以及可渲染的 Prompt 模板，支持多传输协议（如 Stdio、SSE、WebSocket），用于构建安全、可扩展的 LLM 上下文服务平台。

基于 Model Context Protocol 的后端 MCP 服务器实现，向大语言模型客户端提供资源管理、工具注册与调用、以及可渲染的 Prompt 模板等能力，通过 JSON-RPC/流式传输等方式进行通信，并具备会话管理、认证、备份与技能管理等完整功能。

基于 Model Context Protocol 的 MCP 服务器实现，提供资源托管、工具注册与提示模板渲染等能力，供 LLM 客户端以标准化方式获取上下文信息和外部功能访问。

基于 Model Context Protocol 的后端服务，提供资源管理、工具注册/调用以及提示模板渲染等能力，通过 JSON-RPC 与客户端通信，并集成 Rossum API 提供安全、可扩展的上下文服务。

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

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

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

InfoMosaic 提供基于 Model Context Protocol (MCP) 的服务器端实现框架，能够托管资源、注册并执行工具、定义并渲染提示模板，并通过多种传输方式对外提供上下文服务与能力声明。

基于 Model Context Protocol（MCP）的 AKS 后端服务器实现，向大型语言模型(LLM)客户端以标准化方式提供 AKS 资源、工具与提示模板，支持多种传输协议（stdio、SSE、streamable-http），并实现会话管理、能力声明以及安全认证能力。

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

基于模型上下文协议（MCP）的后端服务器实现，提供资源、工具与提示模板的托管、注册与渲染，支持基于 JSON-RPC 的通信、会话管理以及多种传输协议（如 STDIO、HTTP、SSE）以供 LLM 客户端调用。

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

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

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

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

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

基于 Model Context Protocol (MCP) 的完整后端服务器实现，提供资源、工具和提示模板的托管与数据访问，通过 JSON-RPC 形式与 MCP 客户端通信，支持 HTTP 与 stdio 两种传输模式，并实现会话管理、能力声明及多工具集扩展与集成 Harness API 的能力。

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

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

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

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

基于 Model Context Protocol 的 MCP 服务器实现，负责向 LLM 客户端以标准化格式提供技能资源、工具注册与执行、以及 Prompt 模板的渲染，支持会话管理、能力声明，并通过 JSON-RPC 与客户端进行通信，具备沙箱化执行、工具调用以及多传输协议的能力。该实现包含服务器端逻辑、工具/技能管理、以及对外暴露的 MCP 接口，属于服务器端实现而非仅仅的客户端示例。

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

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

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

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

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

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

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

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

基于 Model Context Protocol（MCP）的服务端实现，提供标准化的资源管理、工具注册与执行、以及 Prompt 模板渲染等功能，支持通过 JSON-RPC 与 LLM 客户端通信，管理会话与能力声明，并具备多传输协议（如 Stdio、SSE、WebSocket）等扩展能力，用于对接外部数据源、工具和上下文提示等，实现对 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服务器实现，提供资源、工具、提示模板等上下文服务，支持JSON-RPC通信、会话管理与多传输协议，面向本地开发、调试和集成OpenAI/Claude等LLM应用。

基于 MIESC 的 MCP（Model Context Protocol）服务器实现，提供资源托管、工具注册与执行、提示模板定义等功能，并通过 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) 的后端服务，加载内置与外部 SOP，将它们作为可调用的提示注册，通过 FastMCP 提供 JSON-RPC 服务供 MCP 客户端访问，用于向大型语言模型提供结构化上下文和功能性提示。

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

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源与工具的托管、权限化访问，以及 Prompt 模板的定义与渲染，外部通过 JSON-RPC 进行通信，支持多种传输协议（如 HTTP/WS/SSE），用于向 LLM 客户端提供可扩展的上下文服务与工具调用能力。

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

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

基于 Model Context Protocol（MCP）的服务器端实现示例集合，展示如何暴露工具、资源与 Prompt 模板，并通过 JSON-RPC 与客户端进行通信，涵盖多种 MCP 服务端实现与用法，适合作为后端上下文服务的参考实现。

基于模型上下文协议（MCP）的后端服务实现，提供资源管理、工具执行与提示模板渲染等能力，并通过 JSON-RPC 与客户端通信。实现了服务器端的工具注册与执行、资源导出与资产管理、以及对 Prompts/模板的支持，支持多传输协议（如标准输入/输出、SSE、WebSocket 等），用于为大模型/LLM 客户端提供标准化的上下文服务与能力暴露。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，面向 LLM 客户端提供统一的上下文信息、资源、工具与提示模板的管理与执行能力。服务器通过 JSON-RPC 风格的交互，支持资源读取、工具注册/执行、Prompts 渲染等核心功能，并具备会话管理、能力声明，以及对多种传输协议（如 STDIO、SSE、WebSocket 等）的扩展支持，适合在本地或服务端环境中作为 MCP 服务端使用。

基于 Model Context Protocol (MCP) 的后端服务实现，提供资源托管与访问、工具注册与执行、以及提示模板渲染等能力，并通过 JSON-RPC 进行与 LLM 客户端的通信，支持多传输协议用于上下文服务的扩展性。

基于 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 客户端进行交互，支持多工具与内容生成功能。

基于模型上下文协议（MCP）的服务器实现，向LLM客户端提供ATLAS Central Page的资源、工具与提示模板的统一访问接口，支持JSON-RPC风格请求/响应，以及多传输模式（如STDIO、HTTP）以服务化LLM上下文信息和能力查询。

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

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

基于 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 客户端的完整支持能力。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源管理、工具注册与执行、Prompts 定义与渲染等能力，并通过 JSON-RPC 风格接口向 LLM 客户端暴露上下文与功能。服务器支持多种传输形式（HTTP）、会话管理、能力声明，以及可拓展的工具与资源生态，提升大模型在编码协作中的上下文服务能力。

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

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

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

基于 Model Context Protocol 的 MCP 服务器实现，提供资源（Resources）托管与数据访问、工具（Tools）注册与执行、以及 Prompt 模板（Prompts）的定义与渲染，并通过 JSON-RPC/WebSocket 等通道与 LLM 客户端进行标准化上下文服务交互。

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

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

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

基于 Model Context Protocol (MCP) 的后端服务器，用于托管资源、注册与执行工具、渲染 prompts，并通过 JSON-RPC/事件流等协议为 LLM 客户端提供标准化的上下文服务与能力扩展。

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

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

基于 Nim 的 MCP 服务器实现，提供资源、工具、提示模板等管理，支持多种传输协议（stdio、SSE、HTTP/Streamable、InMemory），并通过 JSON-RPC 与客户端进行请求与响应通信。

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

基于 Model Context Protocol (MCP) 的后端服务器实现，提供资源（Resources）管理、工具（Tools）注册与执行、以及提示模板（Prompts）渲染，支持 stdio、Web 服务等传输协议，通过 JSON-RPC 与 MCP 客户端通信，向大模型客户端提供上下文、数据访问、外部功能调用等能力。

基于 Model Context Protocol（MCP）的服务器实现，用于向 LLM 客户端以标准化方式暴露资源、工具以及 Prompt 模板等上下文服务，支持通过多种传输协议与客户端通信，负责会话管理与能力声明，并可与 LangGraph 生态整合进行工具发现与执行。

基于 Model Context Protocol (MCP) 的 STDIO 交互后端，为大语言模型客户端提供资源管理、工具注册/执行以及提示模板渲染的统一上下文服务。

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

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

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

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具注册与执行，以及提示模板渲染，使用 JSON-RPC 与客户端通信，当前实现通过标准输入输出传输（Stdio）提供 MCP 服务并暴露设计系统的令牌、组件规则与提示内容。

基于 Model Context Protocol (MCP) 的服务器端实现框架，提供资源、工具、提示的托管、注册、路由与多传输支持，面向 LLM 客户端的上下文服务。

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

基于 Model Context Protocol 的 MCP 服务器实现，提供资源管理、工具注册与执行、以及 Prompt 的定义/渲染，支持通过多种传输方式进行 JSON-RPC 通信，供 LLM 客户端以标准化方式获取上下文、调用外部工具并渲染对话模板。

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

将 Fess 转换为基于 MCP 的服务器，提供 JSON-RPC 2.0 的接口，用于资源、工具、提示等的管理与调用

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

基于 Fred 平台的 MCP 服务器实现，提供以标准化方式向大语言模型客户端提供资源、工具、提示模板等上下文与能力的后端服务，并通过 JSON-RPC/多传输通道进行通信。包含知识流后端的完整 MCP 服务、以及用于快速演示的最小 MCP 服务器示例和相应部署示例。

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

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

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

基于 UI-TARS-desktop 的 MCP 服务实现与集成，为桌面端应用提供资源管理、工具注册与提示模板的统一上下文服务，通过 MCP 协议与 LLM 客户端进行交互；在本地环境中可以以 In-Memory/MCP 服务器等多种方式暴露工具与资源，并支持浏览器、文件系统等内置模块的扩展与组合使用，形成一个可运行的 MCP 服务端框架生态。

基于 Model Context Protocol（MCP）的后端服务器，用于通过标准化的 JSON-RPC 与客户端交互，提供对 YouTube 资源的托管和访问、工具执行以及 Prompt 模板渲染等功能。

基于 Model Context Protocol (MCP) 的后端示例服务器，提供资源注册、提示渲染，以及多传输（HTTP/STDIO）支持，便于与 MCP 客户端对接与集成。

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

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

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

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

基于 Model Context Protocol (MCP) 的高性能本地后端服务器实现，提供资源管理、工具注册与执行、以及基于模板的 Prompt 渲染，支持 JSON-RPC 标准交互、会话管理和多传输协议（如 STDIO、SSE、WebSocket），用于本地化的代码上下文理解与分析场景。内置多语言代码解析、符号与引用检索、调用图与安全分析等工具集，面向离线/隐私安全的 LLM 客户端提供丰富上下文服务。

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

基于 Model Context Protocol 的 MCP 服务器实现，为 AI 代理提供资源、工具、提示等上下文服务，并通过 JSON-RPC 与客户端交互，支持资源管理、工具执行与提示渲染等核心能力。

基于 Model Context Protocol (MCP) 的服务器端框架，聚合、管理资源与工具，并通过 JSON-RPC 将上下文、工具与提示暴露给 LLM 客户端，同时支持本地与远程 MCP 服务器的代理与协作。

基于Go实现的MCP后端服务器，提供资源管理、工具注册与执行、提示模板渲染，以及面向多MCP服务器的上下文服务框架；通过多协议通信（HTTP/SSE/stdio 等）与LLM客户端协同工作，支持任务编排、工具调用、以及会话级别的上下文管理。该仓库不仅包含服务端实现，还包含用于工具、客户端以及前端的相关组件与示例，目标是构建一个可扩展的MCP服务器生态。通过统一的接口实现资源、工具、提示模板的托管、注册与执行。

基于 Model Context Protocol (MCP) 的后端服务器实现，提供统一的资源管理、工具注册/执行以及 Prompt 模板的定义和渲染，能够通过 JSON-RPC 与 LLM 客户端进行交互，并支持多传输协议（如 Stdio、SSE、WebSocket）与会话管理、能力声明及健康监控等扩展能力。

基于模型上下文协议（MCP）的服务器端实现，提供资源托管、工具注册/执行以及 Prompts 定义与渲染，通过 JSON-RPC 与 LLM 客户端通信，支持多种传输方式并具备会话管理与跨应用的 MCP 服务器管理能力。

基于 Model Context Protocol 的完整 MCP 服务器集合，覆盖 Google Drive、PostgreSQL、Notion、Figma、Google Calendar、GitHub、Zendesk 等多服务工具与资源托管，支持 JSON-RPC 通信、STDIO/REST 网关等传输方式，提供资源管理、工具注册与 Prompts 渲染等能力，便于与 LLM 客户端在同一后端进行上下文与功能扩展。

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

基于 Model Context Protocol (MCP) 的后端服务器，实现资源管理、工具注册与执行、以及提示模板渲染，向大语言模型客户端提供可扩展且结构化的上下文服务与数据访问能力。

基于 Model Context Protocol 构建的 MCP 服务器实现集合，提供资源与工具的托管、Prompt 定义及渲染能力，并通过 JSON-RPC 与客户端通信，支持多入口输出、浏览器扩展场景，以及跨进程/跨页面的上下文服务能力。

基于 Model Context Protocol 的 MCP 服务器实现，用于作为后端上下文服务向大语言模型客户端提供资源管理、工具执行和提示模板渲染等能力，支持通过 JSON-RPC 方式与客户端交互并管理会话与安全策略。

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

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

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

基于 Model Context Protocol（MCP）的后端服务器合集，提供 MCP 服务的资源管理、工具/客户端对接、模板/提示等能力，支持多协议交互与容器化部署，用于向 LLM 客户端提供统一的上下文和外部功能调用能力。

基于 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）推理循环。

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

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

基于 Model Context Protocol (MCP) 的服务端实现，使用 SSE 传输，提供资源与资源模板的托管、工具注册与执行，以及嵌入式 Widget 的渲染能力，作为 ChatGPT 应用的上下文与功能后端。

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

基于 Model Context Protocol（MCP）的后端服务器实现，提供资源管理、工具注册与执行、Prompt 模板渲染等上下文服务，并通过 JSON-RPC 与客户端通信，支持会话管理与多传输协议接入。

基于 Model Context Protocol (MCP) 的后端服务端实现，作为 MCP 服务器向大语言模型客户端提供标准化的资源管理、工具注册/执行以及 Prompt 模板渲染等能力，使用 JSON-RPC 进行通信，并支持会话管理与多传输协议（如 Stdio、SSE、WebSocket）以满足多样化上下文服务需求。

基于 Model Context Protocol (MCP) 的后端服务，面向 Strudel 音乐助手，提供资源管理、工具执行与提示模板等上下文信息，通过 JSON-RPC 与 LLM 客户端进行交互，并支持基于文件系统的存储与扩展工具集。

基于 Model Context Protocol (MCP) 的完整 MCP 服务器实现，提供资源托管、工具执行、提示模板渲染，以及与大模型客户端的 JSON-RPC 通信，支持会话管理、能力声明和多种传输协议（如 Stdio、SSE、WebSocket）以为 LLM 应用提供安全、可扩展的上下文服务。该仓库不仅包含服务器核心逻辑，还实现了资源、工具、会话初始化、自动上下文注入等关键能力的模块化实现。

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

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

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

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

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