使用说明

MCP Plexus：现代人工智能的安全多租户MCP服务器框架

轻松构建功能强大、可扩展且安全的模型上下文协议（MCP）应用程序。MCP Plexus是一个基于健壮的Python框架 jlowin/fastmcp （FastMCP 2.7）库，旨在使开发人员能够部署多对端MCP服务器，通过OAuth 2.1与外部服务无缝集成，并管理工具的API密钥访问。

引言

什么是MCP Plexus？

MCP Plexus扩展了FastMCP 2.7的功能，为创建复杂的多租户AI后端系统提供了一个结构化的环境。它允许您定义不同的、隔离的环境（租户），这些环境可以向大型语言模型（LLM）和AI代理公开定制的工具、资源和提示集。

关键的差异化特征包括：

稳健的多租户模式： 在单个部署上托管多个客户端或组织，每个客户端或组织都有自己的数据和工具访问权限。
简化外部服务集成： 通过内置的流管理，将您的MCP工具安全地连接到受OAuth 2.1保护的外部服务（如GitHub、Google API等）。
用户特定的持久访问： 使主机应用程序能够向Plexus注册其用户，允许持久存储外部OAuth令牌，减少重新身份验证的摩擦。
API工具密钥管理： 对于需要对外部服务进行直接基于密钥的身份验证的工具，安全地存储和注入API密钥。
标准化和可扩展： 利用FastMCP的Pythonic装饰器的全部功能来定义MCP组件，同时为扩展提供清晰的结构。

为什么选择MCP Plexus？

随着人工智能应用程序复杂性的增长，安全地为LLM提供相关上下文和可执行功能的需求变得至关重要。MCP Plexus通过以下方式解决了这个问题：

简化多租户部署： 降低了管理多个孤立MCP环境的样板和复杂性。
标准化外部API访问： 为工具与OAuth-protected和API key-gated服务交互提供了一致且安全的机制。
提升用户体验： 通过持久的用户身份验证和令牌存储，它最大限度地减少了对外部服务的重复登录提示。
推广安全实践： 管理核心工具逻辑之外的敏感凭据（OAuth令牌、API密钥）。
利用FastMCP电源： 基于经过验证的高性能FastMCP 2.7库，用于核心MCP协议处理及其开发人员友好的界面。

核心理念

安全第一： 以OAuth 2.1和安全凭据管理为核心进行设计。
开发人员经验： 旨在提供一个直观的API，用于定义租户、工具和安全集成。
可扩展性和隔离性： 为具有明确关注点分离的多租户架构而构建。
可扩展性： 提供了一个可以用自定义身份验证提供程序和服务扩展的基础。

主要特点

多租户：
- 支持通过URL路径识别的多个孤立租户（例如。， /{entity_id}/mcp/).
- 租户特定的MCP会话管理（目前默认使用Redis）。
- （计划）工具可见性和提供者设置的租户特定配置。
Plexus用户身份验证：
- 主机应用程序可以通过安全端点向MCP Plexus注册用户(/{entity_id}/plexus-auth/register-user).
- 获取a plexus_user_auth_token 它将主机应用程序的用户链接到Plexus中的持久身份。
- 允许持久存储范围为用户的外部OAuth令牌和API密钥。
外部OAuth 2.1流促进工具：
- 这 @requires_auth(provider_name, scopes) MCP工具的装饰器通过外部提供者（如GitHub）的PKCE流触发OAuth 2.1授权代码授予。
- 管理OAuth回调、令牌交换和安全令牌存储（为访客用户绑定的会话，针对 persistent_user_id 对于经过身份验证的Plexus用户）。
- 工具接收经过身份验证的 httpx.AsyncClient 通过 PlexusContext 用于与外部提供者交互。
- 管理CLI/API，用于管理外部OAuth提供商的租户特定配置（例如，GitHub的客户端ID/secret）。
API工具密钥管理：
- 这 @requires_api_key(provider_name, key_name_display, instructions) MCP工具的装饰器。
- 提示用户（通过结构化MCP错误）提交其API密钥（如果尚未存储）。
- 安全存储API密钥（使用 PLEXUS_ENCRYPTION_KEY)坚持反对 persistent_user_id.
- 在运行时将解密的API密钥注入到工具函数中。
- 端点(/{entity_id}/plexus-services/api-keys)以便用户提交他们的API密钥。
标准MCP服务器功能（通过FastMCP 2.7）：
- 完全支持使用FastMCP的Python装饰器和类定义MCP工具、资源和提示（例如。， PLEXUS_SERVER_INSTANCE.tool()).
- MCP通信的原生流式HTTP传输。
- 访问 PlexusContext （延伸 fastmcp.Context)在用于日志记录、会话数据和访问经过身份验证的客户端或API密钥的工具/资源/提示中。
可配置存储：
- 默认情况下，使用SQLite持久存储Plexus用户身份验证令牌、用户特定的外部OAuth令牌、API密钥、外部OAuth-提供程序配置、租户配置和用户提交的API密钥。
- 目前需要Redis进行MCP会话管理（计划为SQLite会话存储进行增强）。
（正在进行中）内部OAuth 2.1提供程序：
- MCP Plexus作为自己的OAuth 2.1授权服务器的基础元素。
- 包括基本模型和截断端点。全面实施（动态客户端注册、内部客户端的用户同意、完整的令牌管理）是未来的目标。

架构概述

MCP Plexus作为一个ASGI应用程序（通常与Uvicorn一起运行），充当MCP客户端和底层FastMCP服务器实例之间的复杂中介。

FastAPI： 用于主web应用程序路由、处理HTTP请求以及提供管理API端点。
FastMCP(jlowin/fastmcp): 共享实例 FastMCP 用作通过Streamable HTTP处理MCP协议消息（工具、资源、提示）的核心引擎。
Plexus核心：
- 租户管理： 从URL路径识别租户(/{entity_id}/...)并确保租户配置得到尊重（正在进行完整配置，目前是数据库支持的验证）。
- 会话管理(PlexusSessionManager): 管理MCP会话数据（例如。， Mcp-Session-Id)，目前使用Redis进行会话状态。它将MCP会话与 entity_id 如果可用，a persistent_user_id.
- Plexus用户身份验证： 处理主机应用程序用户的注册和管理 plexus_user_auth_token 链接到a的值 persistent_user_id.
- OAuth流编排： 管理需要访问外部服务的工具的OAuth 2.1授权代码授予流，包括安全令牌存储和刷新（刷新WIP）。
- API密钥服务： 管理用户提供的工具API密钥的安全存储和检索。
- PlexusContext: 注入MCP工具的增强上下文对象，提供对 entity_id, persistent_user_id、会话数据和助手方法，以获取经过身份验证的HTTP客户端或API密钥。
储存：
- Redis（会话所需）： 目前用于临时MCP会话数据。
- SQLite（持久数据的默认值）： 用于存储Plexus用户身份验证令牌、特定于用户的外部OAuth令牌、API密钥、外部OAuth提供程序配置和租户元数据。

入门指南

先决条件

Python 3.10+
Redis（目前MCP会话管理所需）
访问命令行/终端。

安装/设置

克隆存储库：

git clone https://github.com/Super-I-Tech/mcp_plexus mcp-plexus
cd mcp-plexus

创建和激活虚拟环境：
```
python -m venv venv
```
在Windows上
```
.\venv\Scripts\activate
```
在macOS/Linux上
```
source venv/bin/activate
```
安装依赖关系：
```
pip install -r requirements.txt
```
配置环境变量(.env 文件）： 创建一个 .env 项目根目录中的文件(mcp-plexus/.env).您可以从以下位置复制 .env.example 如果提供，或手动创建。

关键变量：
- HOST_APP_REGISTRATION_SECRET: 关键。 主机应用程序必须提供一个强大而独特的秘密，以便在Plexus注册用户（通过 X-Host-App-Secret 头球 更改任何生产或共享部署的默认生成值。
- PLEXUS_ENCRYPTION_KEY: 关键。 Fernet加密密钥，用于加密敏感数据，如存储在数据库中的API密钥和外部OAuth令牌。使用以下方法生成一个：
```
python -c "from mcp_plexus.utils import generate_fernet_key; print(generate_fernet_key())"
```
  将输出放在您的 .env. 把这把钥匙保密并备份。 丢失它意味着无法访问加密数据。
- STORAGE_BACKEND：设置为 "sqlite" （默认）或 "redis" 对于大多数持久存储（例如，Plexus用户身份验证令牌、外部OAuth提供者配置）。
  - 重要： MCP会话管理当前 需要Redis 并使用 RedisPlexusSessionStore 而不管该设置如何。未来的更新可能会启用SQLite进行会话存储。
- SQLITE_DB_PATH：SQLite数据库文件的路径（例如。， ./mcp_plexus_data.sqlite3).
- REDIS_HOST, REDIS_PORT, REDIS_DB, REDIS_PASSWORD （可选）， REDIS_SSL （可选）：Redis实例的连接详细信息（MCP会话需要；如果 STORAGE_BACKEND=redis 其他数据）。
- DEBUG_MODE：设置为 True 用于开发（更详细的日志记录，Uvicorn reload）。
- PLEXUS_FASTMCP_LOG_LEVEL：FastMCP组件的日志记录级别（例如。， DEBUG, INFO).
- ADMIN_API_KEY：用于访问管理端点（例如，管理租户、外部OAuth提供商）的API密钥。 设置一个强值。
示例 .env:
```
 # Uvicorn Development Server
 DEV_SERVER_HOST=127.0.0.1
 DEV_SERVER_PORT=8000
 DEV_SERVER_LOG_LEVEL=info
 DEV_SERVER_RELOAD=True

 # Application Settings
 APP_NAME=MCP Plexus Server
 DEBUG_MODE=True

 REDIS_HOST=localhost
 REDIS_PORT=6379
 REDIS_DB=0
 # REDIS_PASSWORD=
 # REDIS_SSL=False

 PLEXUS_FASTMCP_LOG_LEVEL="DEBUG"

 STORAGE_BACKEND=sqlite
 SQLITE_DB_PATH=./mcp_plexus_data.sqlite3

 HOST_APP_REGISTRATION_SECRET=host_app_secre

 ADMIN_API_KEY=your_super_secret_admin_api_key_here_12345

 PLEXUS_CLI_API_BASE_URL=http://127.0.0.1:8080

 PLEXUS_ENCRYPTION_KEY=your_generated_fernet_key_here # see mcp_plexus/utils/generate_key.py
```
初始化数据库（如果使用SQLite）： 如果SQLite数据库和表不存在，通常会在第一次运行时自动创建。

运行服务器（开发）

使用 run_dev.py 脚本：

python run_dev.py

这将启动Uvicorn服务器，通常在 http://127.0.0.1:8000 （主机/端口可以通过以下方式配置 DEV_SERVER_HOST/DEV_SERVER_PORT 在……里面 .env).

使用MCP Plexus（开发人员指南）

MCP Plexus充当构建自定义多租户MCP服务器的框架或SDK。以下是您通常如何使用它：

1.定义租户

租户（实体）是最高级别的组织单位。

管理层： 租户当前通过管理CLI命令进行管理（如果构建管理界面，则直接调用API）。
- CLI示例：
```
plexus admin tenant create --entity-id "mycompany" --name "My Company Inc."
```
访问权限： 每个租户都有自己的MCP端点： http://<server>/{entity_id}/mcp/

2.注册主机应用程序用户

为了在主应用程序（“主机应用程序”）的特定用户的会话之间持久存储外部OAuth令牌，您首先需要向给定租户的MCP Plexus注册该用户身份。

端点： POST /{entity_id}/plexus-auth/register-user
请求标头： X-Host-App-Secret: <your_HOST_APP_REGISTRATION_SECRET_value>

请求正文（JSON）：

{
    "user_id_from_host_app": "unique_stable_user_id_from_your_main_app"
}

响应体（JSON）：

{
    "plexus_user_auth_token": "a_long_secure_token_string_for_this_user",
    "persistent_user_id": "unique_stable_user_id_from_your_main_app", 
    "message": "User token processed successfully."
}

您的主机应用程序应安全地存储返回的 plexus_user_auth_token 并使用它来验证该用户的后续MCP请求。

3.初始化MCP会话

MCP客户端与特定租户的MCP端点进行交互。

端点： /{entity_id}/mcp/
身份验证：
- 对于经过身份验证的Plexus用户： 包括 plexus_user_auth_token 在步骤2中通过以下方式获得 Authorization: Bearer <token> 所有MCP请求的HTTP标头，包括初始请求 initialize 电话。

标准MCP初始化：

{
    "jsonrpc": "2.0",
    "method": "initialize",
    "id": "client-init-123",
    "params": {
        "protocolVersion": "2025-03-26",
        "capabilities": {},
        "clientInfo": {
            "name": "MyHostApplicationClientName",
            "version": "1.0.0"
        }
    }
}

服务器将以 Mcp-Session-Id header，客户端必须将其包含在该会话的后续请求中。

4.创建MCP工具、资源和提示

您可以在Python模块中定义工具、资源和提示，这些模块位于 mcp_plexus/tool_modules/ 目录。这些模块使用全球可用的 PLEXUS_SERVER_INSTANCE （这是一个实例 MCPPlexusServer)以注册其组件。

mcp_plexus/core/global_registry.py:

# This instance is populated at server startup
PLEXUS_SERVER_INSTANCE: Optional[MCPPlexusServer] = None

工具模块示例(mcp_plexus/tool_modules/my_custom_tools.py):

import logging
from typing import Dict, Any, Optional, List
import httpx # Required for @requires_auth example
from fastmcp import Context as FastMCPBaseContext # For type hinting standard ctx
from mcp_plexus.core.global_registry import PLEXUS_SERVER_INSTANCE
from mcp_plexus.plexus_context import PlexusContext # For specific Plexus context features
from mcp_plexus.oauth.decorators import requires_auth
from mcp_plexus.services.decorators import requires_api_key

logger = logging.getLogger(__name__)

if PLEXUS_SERVER_INSTANCE is None:
    # This check helps catch issues if tool modules are imported before PLEXUS_SERVER_INSTANCE is set
    raise RuntimeError("PLEXUS_SERVER_INSTANCE not initialized when my_custom_tools.py was imported.")

@PLEXUS_SERVER_INSTANCE.tool(
    name="get_tenant_specific_greeting",
    description="Returns a greeting specific to the current tenant.",
    allowed_tenant_ids=["mycompany", "another_tenant"] # Tool only visible to these tenants
)
async def get_greeting(ctx: FastMCPBaseContext) -> Dict[str, str]:
    plexus_ctx: PlexusContext = PlexusContext(ctx.fastmcp) # Create PlexusContext from base
    
    entity_id = plexus_ctx.entity_id
    user_id = plexus_ctx.persistent_user_id # Will be None for guest users
    session_val = await plexus_ctx.get_session_value("my_key")

    greeting = f"Hello from entity '{entity_id}'!"
    if user_id:
        greeting += f" Authenticated user: {user_id}."
    if session_val:
        greeting += f" Session value for 'my_key': {session_val}."
        
    return {"greeting": greeting}

# Example: Tool requiring external GitHub OAuth
@PLEXUS_SERVER_INSTANCE.tool(
    name="get_my_github_repos",
    description="Fetches the user's GitHub repositories.",
    tool_sets=["developer_tools"], # Categorize tool
    allowed_tenant_ids=["mycompany"] 
)
@requires_auth(provider_name="github", scopes=["repo", "read:user"])
async def get_my_github_repos(
    ctx: FastMCPBaseContext, 
    *,  # This enforces subsequent arguments as keyword-only
    _authenticated_client: httpx.AsyncClient
) -> List[Dict[str, Any]]:
    plexus_ctx = PlexusContext(ctx.fastmcp)
    logger.info(f"Fetching GitHub repos for user '{plexus_ctx.persistent_user_id}' in entity '{plexus_ctx.entity_id}'")
    response = await _authenticated_client.get("https://api.github.com/user/repos")
    response.raise_for_status()
    return response.json()

# Example: Tool requiring an API key
WEATHER_API_PROVIDER_NAME = "openweathermap"
@PLEXUS_SERVER_INSTANCE.tool(
    name="get_weather_forecast",
    description=f"Gets weather forecast using {WEATHER_API_PROVIDER_NAME}.",
    allowed_tenant_ids=["mycompany", "another_tenant"]
)
@requires_api_key(
    provider_name=WEATHER_API_PROVIDER_NAME,
    key_name_display="OpenWeatherMap API Key",
    instructions="Please provide an API key for OpenWeatherMap."
)
async def get_weather(
    ctx: FastMCPBaseContext, 
    city: str,
    *,
    openweathermap_api_key: str # Injected by @requires_api_key
) -> Dict[str, Any]:
    plexus_ctx = PlexusContext(ctx.fastmcp)
    logger.info(f"Fetching weather for {city} for user '{plexus_ctx.persistent_user_id}' in entity '{plexus_ctx.entity_id}' using provided API key.")
    # Use openweathermap_api_key to call the external weather API
    # Example: weather_data = await httpx.get(f"api.openweathermap.org/data/2.5/weather?q={city}&appid={openweathermap_api_key}")
    return {"city": city, "temperature": "20C", "condition": "Sunny (mock data)"}

logger.info("my_custom_tools.py - Tools registered with PLEXUS_SERVER_INSTANCE.")

工具范围：
- allowed_tenant_ids：列表 entity_id 串。如果提供，该工具只能被这些租户发现和调用。如果 None 或者为空，该工具是全局的（对所有租户可见，受 tool_set 过滤）。
- tool_sets：字符串列表。客户端可以通过传递以下命令来请求属于特定集合的工具 tool_set_filter 到 tools/list MCP呼叫。
PlexusContext:
- 您的工具通常会收到 fastmcp.Context （别名为 FastMCPBaseContext 在示例中）。
- 创建一个实例 mcp_plexus.plexus_context.PlexusContext(base_ctx.fastmcp) 要访问Plexus的特定功能：
  - plexus_ctx.entity_id：当前租户的ID。
  - plexus_ctx.persistent_user_id：经过身份验证的Plexus用户的稳定ID（如果有的话）。
  - plexus_ctx.mcp_session_id：当前MCP会话ID。
  - await plexus_ctx.get_session_value(key) / await plexus_ctx.set_session_value(key, value)：租户和会话范围的键值存储（使用Redis）。
  - await plexus_ctx.get_authenticated_external_client(provider_name, required_scopes)：由以下人员使用 @requires_auth 或者可以直接调用。
  - await plexus_ctx.get_api_key(provider_name)：由以下人员使用 @requires_api_key 或者可以直接调用。

5.固定工具

a.外部OAuth(`@requires_auth`)

当工具需要代表用户访问第三方服务（例如GitHub、Google）时使用。

流量：

管理员配置提供程序： 管理员使用CLI（或Admin API）为特定租户注册外部OAuth提供程序详细信息（客户端ID、机密、URL、默认作用域）。

CLI示例：

plexus admin ext-oauth create --entity-id "mycompany" --provider-name "github" --client-id "YOUR_GITHUB_CLIENT_ID" --client-secret "YOUR_GITHUB_CLIENT_SECRET" --authorization-url "https://github.com/login/oauth/authorize" --token-url "https://github.com/login/oauth/access_token" --scopes "repo,user:email" --userinfo-url "https://api.github.com/user"

工具装饰： 用以下方式装饰您的工具功能 @requires_auth(provider_name="github", scopes=["repo", "read:user"]).
工具调用：
- 当MCP客户端调用该工具时，装饰器（通过 PlexusContext)检查当前用户（如果是Plexus用户，则为持久令牌；如果是访客，则为会话令牌）和请求的提供者/作用域的有效存储OAuth令牌。
- 令牌有效期： 装饰器注入一个经过身份验证的 httpx.AsyncClient （命名 authenticated_client)进入你的工具的kwargs。
- 令牌无效/丢失： 装饰师提出了一个 PlexusExternalAuthRequiredError。这被FastMCP捕获并转换为结构化MCP ToolError错误有效载荷包括 authorization_url.
客户端处理重定向： MCP客户端应用程序负责将用户重定向到此 authorization_url.
用户身份验证和同意： 用户向外部提供商进行身份验证并授予同意。
回拨Plexus： 外部提供商将用户重定向回 /{entity_id}/oauth/external_callback/{provider_name}.
代币交换和存储： MCP Plexus交换令牌的授权码，安全地存储它们（会话和/或持久用户存储），并显示成功页面。
客户端检索工具： 用户返回MCP客户端，然后该客户端应重试原始工具调用。这一次， PlexusContext 将找到有效令牌。

graph TD
    subgraph Tool Developer
        A[Define Tool with @requires_auth] --> B{Tool Called by LLM/Client}
    end

    subgraph MCP Plexus
        B --> C{PlexusContext: Token Check};
        C -- Valid Token --> D[Inject Auth_Client];
        D --> E[Execute Tool Logic];
        C -- Invalid/No Token --> F[Raise PlexusExternalAuthRequiredError];
        F --> G[Return MCP ToolError with auth_url];
    end
    
    subgraph MCP Client App
        G --> H[Redirect User to auth_url];
    end

    subgraph User & External Provider
        H --> I[User Authenticates & Consents at Ext. Provider];
        I --> J[Ext. Provider Redirects to Plexus /callback];
    end

    subgraph MCP Plexus
        J --> K{Plexus /callback Endpoint};
        K --> L[Exchange Auth Code for Tokens];
        L --> M[Store Tokens Session/Persistent];
        M --> N[Show Success Page to User];
    end
    
    subgraph MCP Client App
        N --> O[User Returns to Client App];
        O --> P[Client Retries Tool Call];
    end
    
    P --> C;
    E --> Q[Return Tool Result to Client];

b.API密钥访问(`@requires_api_key`)

当工具需要来自用户的直接API密钥来与外部服务交互时使用。

流量：

工具装饰： 装饰工具 @requires_api_key(provider_name="my_service", key_name_display="My Service API Key", instructions="Get your key from ...").
工具调用：
- 装饰师（通过 PlexusContext)检查是否存储了当前用户和提供程序的API密钥（如果是Plexus用户，则持久有效）。
- 找到密钥： 解密后的API密钥被注入到工具的kwargs中，作为 {provider_name}_api_key （例如。， my_service_api_key).
- 未找到密钥： 提升 PlexusApiKeyRequiredErrorFastMCP将其转换为结构化MCP ToolError 指示客户端/用户如何提交密钥。
用户提交API密钥： 用户（通过MCP客户端或其他接口）调用 POST /{entity_id}/plexus-services/api-keys 终点。
- 请求标头： Authorization: Bearer <plexus_user_auth_token> （持久存储所需）。
- 请求正文（JSON）：
```
{
    "provider_name": "my_service",
    "api_key_value": "users_actual_api_key_value"
}
```
密钥存储： MCP Plexus加密并存储与用户的 persistent_user_id.
客户端检索工具： 重试工具调用，现在找到并注入了密钥。

graph TD
    subgraph Tool Developer
        A[Define Tool with @requires_api_key] --> B{Tool Called by LLM/Client}
    end

    subgraph MCP Plexus
        B --> C{PlexusContext: API Key Check};
        C -- Key Found & Decrypted --> D[Inject API Key into Tool];
        D --> E[Execute Tool Logic];
        C -- Key Not Found --> F[Raise PlexusApiKeyRequiredError];
        F --> G[Return MCP ToolError with submission instructions];
    end
    
    subgraph User/MCP Client App
        G --> H[User/Client Submits API Key via /api-keys endpoint];
    end

    subgraph MCP Plexus
        H --> I{Plexus /api-keys Endpoint};
        I --> J[Encrypt & Store API Key];
    end
    
    subgraph User/MCP Client App
        J --> K[Client Retries Tool Call];
    end
    
    K --> C;
    E --> L[Return Tool Result to Client];

项目状态和路线图

本节概述了当前的实施状态和计划中的功能。

实现

[x] 核心多租户： 通过URL进行基本租户识别(/{entity_id}/mcp/)以及DB支持的验证。
[x] FastMCP 2.7集成： 用途 jlowin/fastmcp 用于核心MCP协议（流式HTTP）、工具/资源/提示定义。
[x] 会话管理： Redis支持的MCP会话存储(PlexusSessionManager, SessionData).
[x] Plexus用户身份验证： 主机应用程序用户注册(/{entity_id}/plexus-auth/register-user)为了得到 plexus_user_auth_token 用于链接到a persistent_user_id.MCP请求通过承载令牌或URL令牌路径进行身份验证。
[x] 外部OAuth 2.1流促进：
- @requires_auth 工具装饰师。
- OAuth回调处理(/{entity_id}/oauth/external_callback/{provider_name}).
- 为经过身份验证的Plexus用户持久存储外部OAuth令牌（默认为SQLite）。
- 为访客用户存储外部OAuth令牌的会话范围。
- 管理员API/CLI，用于管理每个租户的外部OAuth提供程序配置。
[x] API工具密钥管理：
- @requires_api_key 装饰师。
- 链接到的用户提交的API密钥（默认为SQLite）的安全（加密）持久存储 persistent_user_id.
- API密钥提交的终结点(/{entity_id}/plexus-services/api-keys).
[x] PlexusContext: 提供 entity_id, persistent_user_id, mcp_session_id以及用于OAuth/API密钥访问的方法。
[x] 管理端点和基本CLI： 用于管理租户和外部OAuth提供程序配置。
[x] SQLite持久存储： 用户身份验证令牌、外部令牌/API密钥、提供程序配置、租户数据的默认后端。
[x] 工具范围和设置： 基于工具可见性的基本实现 allowed_tenant_ids 并通过以下方式进行过滤 tool_sets 通过 tools/list 参数。

已计划/正在进行中

[ ] 完整的内部OAuth 2.1提供程序：
- []内部OAuth客户端的动态客户端注册。
- []面向用户的内部OAuth客户端同意屏幕。
- []完成令牌撤销和自检端点。
- []更强大的安全性和授权类型支持。
[ ] SQLite会话存储： 实施 SQLitePlexusSessionStore 使Redis完全可选。
[ ] 精细存储后端配置： 允许为不同的数据类型（会话、持久令牌等）提供单独的后端选择（Redis/SQLite）。
[ ] Plexus用户身份验证令牌生命周期： 实施稳健的到期和撤销 plexus_user_auth_token.
[ ] 全面的租户配置： 允许租户自定义其环境的更多方面（例如，默认工具集、UI主题（如果适用））。
[ ] 高级工具范围界定： 更复杂的工具可见性和访问控制规则。
[ ] 增强的CLI： 更多命令，提高了管理员和用户任务的可用性。
[ ] 所有存储后端都完全支持异步： 如果还没有，请确保所有数据库操作都是完全异步的。
[ ] 更稳健的错误处理和可观察性： 所有API的标准化错误响应、改进的结构化日志记录和潜在指标。
[ ] 生产部署指南： Docker、反向代理、扩展的文档。
[ ] 综合测试套件： 扩展所有功能的单元、集成和端到端测试。
[ ] 详细的用户和开发人员文档： 将此README扩展到结构化文档网站。

贡献

有关向MCP Plexus捐款的详细信息将很快添加。我们欢迎为bug修复、功能增强和文档改进做出贡献。

许可证

该项目的许可证与FastMCP相同。