LLM Gateway MCP 服务器

<div align="center">

一个模型上下文协议 (MCP) 服务器，支持从高能力 AI 代理到高性价比 LLM 的智能委派

快速开始 • 主要特性 • 使用示例 • 架构 •

</div>

什么是 LLM Gateway？

LLM Gateway 是一个 MCP 原生服务器，它支持从高级 AI 代理（如 Claude 3.7 Sonnet）到更具成本效益的模型（如 Gemini Flash 2.0 Lite）的智能任务委派。它提供了一个统一的接口来访问多个大型语言模型 (LLM) 提供商，同时优化成本、性能和质量。

愿景：AI 驱动的资源优化

LLM Gateway 的核心代表了我们与 AI 系统交互方式的根本转变。它不是对所有任务都使用单一的昂贵模型，而是启用了一个智能层级结构，其中：

• 像 Claude 3.7 这样的高级模型专注于高层次的推理、编排和复杂任务
• 具有成本效益的模型处理例行处理、提取和机械任务
• 整个系统以一小部分成本实现接近顶级的性能

这种方法类似于人类组织的工作方式——专家处理复杂的决策，同时将例行任务委派给具有特定任务所需技能的其他人。

MCP 原生架构

该服务器构建在 模型上下文协议 (MCP) 之上，专门设计用于与像 Claude 这样的 AI 代理协同工作。所有功能都通过 MCP 工具公开，这些工具可以被这些代理直接调用，从而为 AI 到 AI 的委派创建无缝的工作流程。

主要用例：AI 代理任务委派

LLM Gateway 的主要设计目标是允许像 Claude 3.7 Sonnet 这样复杂的 AI 代理智能地将任务委派给成本较低的模型：

                          委派给
┌─────────────┐ ────────────────────────► ┌───────────────────┐         ┌──────────────┐
│ Claude 3.7  │                           │   LLM Gateway     │ ───────►│ Gemini Flash │
│   (代理)   │ ◄──────────────────────── │    MCP 服务器     │ ◄───────│ DeepSeek     │
└─────────────┘      返回结果      └───────────────────┘         │ GPT-4o-mini  │
                                                                        └──────────────┘

示例工作流程：

1. Claude 识别出需要总结文档（使用 Claude 进行此操作成本很高）
2. Claude 通过 MCP 工具将此任务委派给 LLM Gateway
3. LLM Gateway 将摘要任务路由到 Gemini Flash（比 Claude 便宜 10-20 倍）
4. 摘要返回给 Claude，用于更高层次的推理和决策
5. 然后，Claude 可以将其能力集中在真正需要其智能的任务上

这种委派模式可以节省 70-90% 的 API 成本，同时保持输出质量。

为什么使用 LLM Gateway？

🔄 AI 到 AI 的任务委派

最强大的用例是使高级 AI 代理能够将例行任务委派给更便宜的模型：

• 让 Claude 3.7 使用 GPT-4o-mini 进行初始文档摘要
• 让 Claude 使用 Gemini 2.0 Flash light 进行数据提取和转换
• 允许 Claude 跨不同的提供商编排多阶段工作流程
• 使 Claude 能够为每个特定的子任务选择合适的模型

💰 成本优化

高级模型的 API 成本可能很高。LLM Gateway 通过以下方式帮助降低成本：

• 将适当的任务路由到更便宜的模型（例如，0.01 美元/1K tokens vs 0.15 美元/1K tokens）
• 实施高级缓存以避免冗余 API 调用
• 跟踪和优化跨提供商的成本
• 启用具有成本意识的任务路由决策

🔄 提供商抽象

使用统一的接口避免锁定特定提供商：

• OpenAI、Anthropic (Claude)、Google (Gemini) 和 DeepSeek 的标准 API
• 一致的参数处理和响应格式
• 无需更改应用程序代码即可更换提供商的能力
• 防止特定于提供商的中断和限制

📄 大规模文档处理

高效地处理大型文档：

• 将文档分解为语义上有意义的块
• 跨多个模型并行处理块
• 从非结构化文本中提取结构化数据
• 从大型文本生成摘要和见解

主要特性

MCP 协议集成

• 原生 MCP 服务器：构建在模型上下文协议之上，用于 AI 代理集成
• MCP 工具框架：所有功能都通过标准化的 MCP 工具公开
• 工具组合：工具可以组合用于复杂的工作流程
• 工具发现：支持工具列表和能力发现

智能任务委派

• 任务路由：分析任务并路由到适当的模型
• 提供商选择：根据任务要求选择提供商
• 成本-性能平衡：优化成本、质量或速度
• 委派跟踪：监控委派模式和结果

高级缓存

• 多级缓存：多种缓存策略：
  • 精确匹配缓存
  • 语义相似性缓存
  • 任务感知缓存
• 持久缓存：基于磁盘的持久性，具有快速的内存访问
• 缓存分析：跟踪节省和命中率

文档工具

• 智能分块：多种分块策略：
  • 基于 Token 的分块
  • 语义边界检测
  • 结构分析
• 文档操作：
  • 摘要
  • 实体提取
  • 问题生成
  • 批量处理

结构化数据提取

• JSON 提取：使用模式验证提取结构化的 JSON
• 表格提取：以多种格式提取表格
• 键值提取：从文本中提取键值对
• 语义模式推断：从文本生成模式

锦标赛模式

• 代码和文本竞赛：支持运行锦标赛风格的竞赛
• 多个模型：同时比较来自不同模型的输出
• 性能指标：评估和跟踪模型性能
• 结果存储：持久化锦标赛结果以供进一步分析

高级向量操作

• 语义搜索：查找跨文档的语义相似内容
• 向量存储：高效存储和检索向量嵌入
• 混合搜索：结合关键字和语义搜索功能
• 批量处理：高效处理大型数据集

使用示例

Claude 使用 LLM Gateway 进行文档分析

此示例展示了 Claude 如何使用 LLM Gateway 通过将任务委派给更便宜的模型来处理文档：

import asyncio
from mcp.client import Client

async def main():
    # Claude 将使用此客户端连接到 LLM Gateway
    client = Client("http://localhost:8013")
    
    # Claude 可以识别出需要处理的文档
    document = "... large document content ..."
    
    # 步骤 1：Claude 委派文档分块
    chunks_response = await client.tools.chunk_document(
        document=document,
        chunk_size=1000,
        method="semantic"
    )
    print(f"文档被分成 {chunks_response['chunk_count']} 块")
    
    # 步骤 2：Claude 将摘要委派给更便宜的模型
    summaries = []
    total_cost = 0
    for i, chunk in enumerate(chunks_response["chunks"]):
        # 使用 Gemini Flash（比 Claude 便宜得多）
        summary = await client.tools.summarize_document(
            document=chunk,
            provider="gemini",
            model="gemini-2.0-flash-lite",
            format="paragraph"
        )
        summaries.append(summary["summary"])
        total_cost += summary["cost"]
        print(f"已处理块 {i+1}，成本为 ${summary['cost']:.6f}")
    
    # 步骤 3：Claude 将实体提取委派给另一个便宜的模型
    entities = await client.tools.extract_entities(
        document=document,
        entity_types=["person", "organization", "location", "date"],
        provider="openai",
        model="gpt-4o-mini"
    )
    total_cost += entities["cost"]
    
    print(f"总委派成本：${total_cost:.6f}")
    # Claude 现在将使用其高级功能处理这些摘要和实体
    
    # 完成后关闭客户端
    await client.close()

if __name__ == "__main__":
    asyncio.run(main())

用于决策的多提供商比较

# Claude 可以比较来自不同提供商的输出，以进行关键任务
responses = await client.tools.multi_completion(
    prompt="解释量子计算对密码学的影响。",
    providers=[
        {"provider": "openai", "model": "gpt-4o-mini", "temperature": 0.3},
        {"provider": "anthropic", "model": "claude-3-haiku-20240307", "temperature": 0.3},
        {"provider": "gemini", "model": "gemini-2.0-pro", "temperature": 0.3}
    ]
)

# Claude 可以分析这些响应并决定哪个最准确
for provider_key, result in responses["results"].items():
    if result["success"]:
        print(f"{provider_key} 成本：${result['cost']}")

成本优化工作流程

# Claude 可以定义和执行复杂的多阶段工作流程
workflow = [
    {
        "name": "初始分析",
        "operation": "summarize",
        "provider": "gemini",
        "model": "gemini-2.0-flash-lite",
        "input_from": "original",
        "output_as": "summary"
    },
    {
        "name": "实体提取",
        "operation": "extract_entities",
        "provider": "openai",
        "model": "gpt-4o-mini",
        "input_from": "original", 
        "output_as": "entities"
    },
    {
        "name": "问题生成",
        "operation": "generate_qa",
        "provider": "deepseek",
        "model": "deepseek-chat",
        "input_from": "summary",
        "output_as": "questions"
    }
]

# 执行工作流程
results = await client.tools.execute_optimized_workflow(
    documents=[document],
    workflow=workflow
)

print(f"工作流程在 {results['processing_time']:.2f}s 内完成")
print(f"总成本：${results['total_cost']:.6f}")

文档分块

要将大型文档分解为更小、更易于管理的块：

large_document = "... your very large document content ..."

chunking_response = await client.tools.chunk_document(
    document=large_document,
    chunk_size=500,     # 目标大小（以 tokens 为单位）
    overlap=50,         # 块之间的 Token 重叠
    method="semantic"   # 或 "token", "structural"
)

if chunking_response["success"]:
    print(f"文档被分成 {chunking_response['chunk_count']} 块。")
    # chunking_response['chunks'] 包含文本块的列表
else:
    print(f"错误：{chunking_response['error']}")

多提供商完成

要同时从多个提供商/模型获取相同提示的完成结果以进行比较：

multi_response = await client.tools.multi_completion(
    prompt="使用 MCP 协议的主要好处是什么？",
    providers=[
        {"provider": "openai", "model": "gpt-4o-mini"},
        {"provider": "anthropic", "model": "claude-3-haiku-20240307"},
        {"provider": "gemini", "model": "gemini-2.0-flash-lite"}
    ],
    temperature=0.5
)

if multi_response["success"]:
    print("多完成结果：")
    for provider_key, result in multi_response["results"].items():
        if result["success"]:
            print(f"--- {provider_key} ---")
            print(f"完成：{result['completion']}")
            print(f"成本：${result['cost']:.6f}")
        else:
            print(f"--- {provider_key} 错误：{result['error']} ---")
else:
    print(f"多完成失败：{multi_response['error']}")

结构化数据提取 (JSON)

要将信息从文本提取到特定的 JSON 模式中：

text_with_data = "用户 John Doe (john.doe@example.com) 于 2024-07-15 创建了一个帐户。他的用户 ID 是 12345。"

desired_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "email": {"type": "string", "format": "email"},
        "creation_date": {"type": "string", "format": "date"},
        "user_id": {"type": "integer"}
    },
    "required": ["name", "email", "creation_date", "user_id"]
}

json_response = await client.tools.extract_json(
    document=text_with_data,
    json_schema=desired_schema,
    provider="openai", # 选择能够进行结构化提取的提供商
    model="gpt-4o-mini"
)

if json_response["success"]:
    print(f"提取的 JSON：{json_response['json_data']}")
    print(f"成本：${json_response['cost']:.6f}")
else:
    print(f"错误：{json_response['error']}")

检索增强生成 (RAG) 查询

要使用 RAG 提出问题，系统在生成答案之前检索相关上下文（假设相关文档已编入索引）：

rag_response = await client.tools.rag_query( # 假设工具名称为 rag_query
    query="最新财务报告中的主要发现是什么？",
    # 用于控制检索的参数，例如：
    # index_name="financial_reports",
    # top_k=3, 
    provider="anthropic",
    model="claude-3-haiku-20240307" # 用于根据上下文生成答案的模型
)

if rag_response["success"]:
    print(f"RAG 答案：\n{rag_response['answer']}")
    # 可能会包含检索到的来源：rag_response['sources']
    print(f"成本：${rag_response['cost']:.6f}")
else:
    print(f"错误：{rag_response['error']}")

融合搜索（关键字 + 语义）

要使用 Marqo 执行结合关键字相关性和语义相似性的混合搜索：

fused_search_response = await client.tools.fused_search( # 假设工具名称为 fused_search
    query="AI 对软件开发生产力的影响",
    # Marqo 索引和调整的参数：
    # index_name="tech_articles",
    # keyword_weight=0.3, # 关键字分数的权重（0.0 到 1.0）
    # semantic_weight=0.7, # 语义分数的权重（0.0 到 1.0）
    # top_n=5,
    # filter_string="year > 2023"
)

if fused_search_response["success"]:
    print(f"融合搜索结果（{len(fused_search_response['results'])} 个命中）：")
    for hit in fused_search_response["results"]:
        print(f" - 分数：{hit['_score']:.4f}，ID：{hit['_id']}，内容：{hit.get('text', '')[:100]}...")
else:
    print(f"错误：{fused_search_response['error']}")

本地文本处理

要执行本地、离线文本操作，而无需调用 LLM API：

# 假设一个捆绑本地文本函数的工具
local_process_response = await client.tools.process_local_text( 
    text="  Extra   spaces   and\nnewlines\t here.  ",
    operations=[
        {"action": "trim_whitespace"},
        {"action": "normalize_newlines"},
        {"action": "lowercase"}
    ]
)

if local_process_response["success"]:
    print(f"处理后的文本：'{local_process_response['processed_text']}'")
else:
    print(f"错误：{local_process_response['error']}")

运行模型锦标赛

要比较多个模型在特定任务（例如，代码生成）上的输出：

# 假设一个锦标赛工具
tournament_response = await client.tools.run_model_tournament(
    task_type="code_generation",
    prompt="编写一个 Python 函数来计算数字的阶乘。",
    competitors=[
        {"provider": "openai", "model": "gpt-4o-mini"},
        {"provider": "anthropic", "model": "claude-3-opus-20240229"}, # 用于比较的高端模型
        {"provider": "deepseek", "model": "deepseek-coder"}
    ],
    evaluation_criteria=["correctness", "efficiency", "readability"],
    # 可选：ground_truth="def factorial(n): ..." 
)

if tournament_response["success"]:
    print("锦标赛结果：")
    # tournament_response['results'] 将包含排名、分数、输出
    for rank, result in enumerate(tournament_response.get("ranking", [])):
        print(f"  {rank+1}. {result['provider']}/{result['model']} - 分数：{result['score']:.2f}")
    print(f"总成本：${tournament_response['total_cost']:.6f}")
else:
    print(f"错误：{tournament_response['error']}")

(此处可以添加更多工具示例...)

快速开始

安装

# 如果您还没有 uv，请安装它：
curl -LsSf https://astral.sh/uv/install.sh | sh

# 克隆存储库
git clone https://github.com/yourusername/llm_gateway_mcp_server.git
cd llm_gateway_mcp_server

# 使用 uv 在 venv 中安装：
uv venv --python 3.13
source .venv/bin/activate
uv pip install -e ".[all]"

环境设置

创建一个包含您的 API 密钥的 .env 文件：

# API 密钥（至少需要一个提供商）
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GEMINI_API_KEY=your_gemini_key
DEEPSEEK_API_KEY=your_deepseek_key

# 服务器配置
SERVER_PORT=8013
SERVER_HOST=127.0.0.1

# 日志配置
LOG_LEVEL=INFO
USE_RICH_LOGGING=true

# 缓存配置
CACHE_ENABLED=true
CACHE_TTL=86400

运行服务器

# 启动 MCP 服务器
python -m llm_gateway.cli.main run

# 或使用 Docker
docker compose up

运行后，服务器将在 http://localhost:8013 上可用。

高级配置

虽然 .env 文件对于基本设置很方便，但 LLM Gateway 提供了更详细的配置选项，主要通过环境变量进行管理。

服务器配置

• SERVER_HOST：（默认值：127.0.0.1）服务器侦听的网络接口。使用 0.0.0.0 侦听所有接口（Docker 或外部访问所必需）。
• SERVER_PORT：（默认值：8013）服务器侦听的端口。
• API_PREFIX：（默认值：/）API 端点的 URL 前缀。

日志配置

• LOG_LEVEL：（默认值：INFO）控制日志的详细程度。选项：DEBUG、INFO、WARNING、ERROR、CRITICAL。
• USE_RICH_LOGGING：（默认值：true）使用 Rich 库进行彩色、格式化的控制台日志记录。设置为 false 以获取纯文本日志（更适合文件重定向或某些日志聚合系统）。
• LOG_FORMAT：（可选）指定自定义日志格式字符串。
• LOG_TO_FILE：（可选，例如，gateway.log）应写入日志的文件的路径。

缓存配置

• CACHE_ENABLED：（默认值：true）全局启用或禁用缓存。
• CACHE_TTL：（默认值：86400 秒，即 24 小时）缓存项目的默认生存时间。特定工具可能会覆盖此值。
• CACHE_TYPE：（默认值：memory）缓存后端的类型。选项可能包括 memory、redis、diskcache。（注意：检查当前实现以获取支持的类型）。
• CACHE_MAX_SIZE：（可选）缓存的最大项目数或内存大小。
• REDIS_URL：（如果 CACHE_TYPE=redis 则为必需）Redis 缓存服务器的连接 URL（例如，redis://localhost:6379/0）。

提供商超时和重试

• PROVIDER_TIMEOUT：（默认值：120 秒）对 LLM 提供商 API 的请求的默认超时。
• PROVIDER_MAX_RETRIES：（默认值：3）失败的提供商请求的默认重试次数（例如，由于临时网络问题或速率限制）。
• 特定提供商的超时/重试可以通过专用变量（如 OPENAI_TIMEOUT、ANTHROPIC_MAX_RETRIES 等）进行配置。（注意：检查当前实现）。

特定于工具的配置

• 某些工具可能具有自己的特定环境变量用于配置（例如，用于融合搜索的 MARQO_URL、默认分块参数）。请参阅各个工具的文档或源代码。

始终确保在启动服务器之前正确设置环境变量。更改通常需要重新启动服务器。

部署注意事项

虽然直接使用 python 或 docker compose up 运行服务器适用于开发和测试，但对于更健壮或生产环境部署，请考虑以下事项：

1. 作为后台服务运行

为了确保网关持续运行并在发生故障或服务器重新启动时自动重新启动，请使用进程管理器：

• systemd (Linux): 创建一个服务单元文件（例如，/etc/systemd/system/llm-gateway.service）来管理该进程。这允许使用诸如 sudo systemctl start|stop|restart|status llm-gateway 之类的命令。
• supervisor: 一种流行的用 Python 编写的进程控制系统。配置 supervisord 以监视和控制网关进程。
• Docker 重启策略： 如果使用 Docker（独立或 Compose），请在 docker run 命令或 docker-compose.yml 文件中配置适当的重启策略（例如，unless-stopped 或 always）。

2. 使用反向代理 (Nginx/Caddy/Apache)

强烈建议在 LLM Gateway 前面放置一个反向代理：

• HTTPS/SSL 终止： 代理可以处理 SSL 证书（例如，使用 Caddy 的 Let's Encrypt 或 Nginx/Apache 的 Certbot），从而加密客户端和代理之间的流量。
• 负载均衡： 如果您需要运行网关的多个实例以实现高可用性或性能，则代理可以在它们之间分配流量。
• 路径路由： 将外部路径（例如，https://api.yourdomain.com/llm-gateway/）映射到内部网关服务器 (http://localhost:8013)。
• 安全标头： 添加重要的安全标头（如 CSP、HSTS）。
• 缓冲/缓存： 某些代理提供额外的请求/响应缓冲或缓存功能。

示例 Nginx location 块（简化）：

location /llm-gateway/ {
    proxy_pass http://127.0.0.1:8013/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    # 添加超时、缓冲等的配置。
}

3. 容器编排 (Kubernetes/Swarm)

如果在容器化环境中部署：

• 健康检查： 在部署清单中实现和配置健康检查端点（例如，前面提到的 /healthz），以便编排器可以监视服务的健康状况。
• 配置： 使用 ConfigMaps 和 Secrets (Kubernetes) 或等效机制来安全地管理环境变量和 API 密钥，而不是将它们硬编码到镜像中或仅依赖 .env 文件。
• 资源限制： 为网关容器定义适当的 CPU 和内存请求/限制，以确保稳定的性能并防止资源匮乏。
• 服务发现： 利用编排器的服务发现机制，而不是硬编码 IP 地址或主机名。

4. 资源分配

• 确保主机或容器具有足够的 RAM，尤其是在使用内存缓存或处理大型文档/请求时。
• 监控 CPU 使用率，尤其是在负载较重或多个复杂操作同时运行时。

通过委派节省成本

使用 LLM Gateway 进行委派可以显著节省成本：

任务	Claude 3.7 直接	委派给更便宜的 LLM	节省
总结 100 页文档	$4.50	$0.45 (Gemini Flash)	90%
从 50 条记录中提取数据	$2.25	$0.35 (GPT-4o-mini)	84%
生成 20 个内容创意	$0.90	$0.12 (DeepSeek)	87%
处理 1,000 个客户查询	$45.00	$7.50 (混合委派)	83%

通过让 Claude 专注于高层次的推理和编排，同时将机械任务委派给具有成本效益的模型，可以在保持高质量输出的同时实现这些节省。

为什么 AI 到 AI 的委派很重要

AI 到 AI 委派的战略重要性超出了简单的成本节省：

普及高级 AI 功能

通过使像 Claude 3.7、GPT-4o 等强大的模型能够有效地委派，我们：

• 以一小部分成本提供高级 AI 功能
• 允许预算有限的组织利用顶级的 AI 功能
• 实现跨行业更有效地利用 AI 资源

经济资源优化

AI 到 AI 的委派代表了根本的经济优化：

• 复杂的推理、创造力和理解能力留给顶级模型
• 例行数据处理、提取和更简单的任务交给具有成本效益的模型
• 整个系统以一小部分成本实现接近顶级的性能
• API 成本成为可控的支出，而不是不可预测的负债

可持续的 AI 架构

这种方法促进了更可持续的 AI 使用：

• 减少了对高端计算资源的非必要消耗
• 创建了一种分层的 AI 方法，将能力与需求相匹配
• 允许仅使用顶级模型在成本上令人望而却步的实验性工作
• 创建了一种可扩展的 AI 集成方法，可以随着业务需求而增长

技术演进路径

LLM Gateway 代表了 AI 应用程序架构中的一个重要演进：

• 从单片 AI 调用转向分布式、多模型工作流程
• 实现 AI 驱动的复杂处理管道的编排
• 为 AI 系统创建一个基础，该系统可以推理自己的资源使用情况
• 构建能够做出智能委派决策的自优化 AI 系统

AI 效率的未来

LLM Gateway 指向一个未来，其中：

• AI 系统主动管理和优化自己的资源使用情况
• 更高能力的模型充当整个 AI 生态系统的智能编排器
• AI 工作流程变得越来越复杂和自组织
• 组织可以以具有成本效益的方式利用 AI 功能的全部范围

这种高效、自组织 AI 系统的愿景代表了实际 AI 部署的下一个前沿，超越了当前对每个任务都使用单一模型的模式。

架构

MCP 集成如何工作

LLM Gateway 本身构建在模型上下文协议之上：

1. MCP 服务器核心：网关实现了一个完整的 MCP 服务器
2. 工具注册：所有功能都作为 MCP 工具公开
3. 工具调用：Claude 和其他 AI 代理可以直接调用这些工具
4. 上下文传递：结果以 MCP 的标准格式返回

这确保了与 Claude 和其他 MCP 兼容代理的无缝集成。

组件图

┌─────────────┐         ┌───────────────────┐         ┌──────────────┐
│  Claude 3.7 │ ────────► LLM Gateway MCP   │ ────────► LLM 提供商│
│   (代理)   │ ◄──────── 服务器和工具    │ ◄──────── (多个)   │
└─────────────┘         └───────┬───────────┘         └──────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  完成   │  │   文档    │  │  提取   │        │
│  │    工具      │  │    工具      │  │    工具      │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  优化 │  │  核心 MCP     │  │  分析    │        │
│  │    工具      │  │   服务器      │  │    工具      │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │    缓存      │  │    向量     │  │    提示     │        │
│  │   服务     │  │   服务     │  │   服务     │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  锦标赛   │  │    代码       │  │   多代理 │        │
│  │     工具     │  │  提取   │  │  协调 │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │   RAG 工具   │  │ 本地文本    │  │  元工具   │        │
│  │               │  │    工具      │  │               │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

委派的请求流程

当 Claude 将任务委派给 LLM Gateway 时：

1. Claude 发送一个 MCP 工具调用请求
2. 网关通过 MCP 协议接收请求
3. 适当的工具处理该请求
4. 缓存服务检查结果是否已被缓存
5. 如果未缓存，则优化服务选择适当的提供商/模型
6. 提供商层将请求发送到选定的 LLM API
7. 响应被标准化、缓存，并记录指标
8. MCP 服务器将结果返回给 Claude

详细功能文档

提供商集成

• 多提供商支持：对以下内容的一流支持：

  • OpenAI (GPT-4o-mini, GPT-4o, GPT-4o mini)
  • Anthropic (Claude 3.7 系列)
  • Google (Gemini Pro, Gemini Flash, Gemini Flash Light)
  • DeepSeek (DeepSeek-Chat, DeepSeek-Reasoner)
  • 用于添加新提供商的可扩展架构

• 模型管理：

  • 基于任务要求的自动模型选择
  • 模型性能跟踪
  • 提供商中断的后备机制

成本优化

• 智能路由：根据以下内容自动选择模型：

  • 任务复杂性要求
  • 预算限制
  • 性能优先级
  • 历史性能数据

• 高级缓存系统：

  • 多种缓存策略（精确、语义、基于任务）
  • 每个任务类型可配置的 TTL
  • 具有快速内存查找的持久缓存
  • 缓存统计信息和成本节省跟踪

文档处理

• 智能文档分块：

  • 多种分块策略（基于 Token、语义、结构）
  • 用于上下文保留的重叠配置
  • 高效处理非常大的文档

• 文档操作：

  • 摘要（具有可配置的格式）
  • 实体提取
  • 问答对生成
  • 具有并发控制的批量处理

数据提取

• 结构化数据提取：
  • 具有模式验证的 JSON 提取
  • 表格提取（JSON、CSV、Markdown 格式）
  • 键值对提取
  • 语义模式推断

锦标赛和基准测试

• 模型竞赛：

  • 在不同的模型和配置之间运行竞赛
  • 比较跨提供商的代码生成能力
  • 生成统计性能报告
  • 存储竞赛结果以进行历史分析

• 代码提取：

  • 从模型响应中提取干净的代码
  • 分析和验证提取的代码
  • 支持多种编程语言

向量操作

• 嵌入服务：

  • 高效的文本嵌入生成
  • 嵌入缓存以降低 API 成本
  • 用于提高性能的批量处理

• 语义搜索：

  • 查找