跳至主要内容

MCP 概述

LiteLLM Proxy 提供了一个 MCP 网关，允许您对所有 MCP 工具使用固定的端点，并按密钥（Key）或团队（Team）控制 MCP 的访问权限。

LiteLLM MCP 架构：将 MCP 工具与 LiteLLM 支持的所有模型配合使用

概述​

功能描述
MCP 操作• 列出工具
• 调用工具
• 提示词（Prompts）
• 资源（Resources）
支持的 MCP 传输方式• 可流式传输的 HTTP
• SSE (服务器发送事件)
• 标准输入/输出 (stdio)
LiteLLM 权限管理• 按密钥 (By Key)
• 按团队 (By Team)
• 按组织 (By Organization)
MCP 协议更新

从 LiteLLM v1.80.18 开始，LiteLLM MCP 协议版本为 2025-11-25。
LiteLLM 通过在每个工具名称前加上 MCP 服务器名称的前缀来实现多个 MCP 服务器的命名空间管理，因此新创建的服务器现在必须使用符合 SEP-986 规范的名称——不符合规范的名称将无法再被添加。目前，违反 SEP-986 的现有服务器仅会发出警告，但未来 MCP 侧的更新可能会完全阻止这些名称，因此我们建议在 MCP 强制执行导致它们无法使用之前，主动更新任何旧版服务器名称。

添加您的 MCP​

先决条件​

要在数据库中存储 MCP 服务器，您需要启用数据库存储

环境变量

export STORE_MODEL_IN_DB=True

或者在 config.yaml 中配置

general_settings:
  store_model_in_db: true

细粒度的数据库存储控制​

默认情况下，当 store_model_in_db 为 true 时，所有对象类型（模型、MCP、护栏、向量存储等）都会存储在数据库中。如果您只想存储特定的对象类型，请使用 supported_db_objects 设置。

示例：仅在数据库中存储 MCP 服务器

config.yaml
general_settings:
  store_model_in_db: true
  supported_db_objects: ["mcp"]  # Only store MCP servers in DB

model_list:
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-xxxxxxx

查看所有可用对象类型： 配置设置 - supported_db_objects

如果未设置 supported_db_objects，则会从数据库加载所有对象类型（默认行为）。

如需在设置后诊断连接问题，请参阅 MCP 故障排除指南。

在 LiteLLM UI 上，导航至“MCP Servers”并点击“Add New MCP Server”。

在此表单中，您需要输入 MCP 服务器 URL 以及您想要使用的传输方式。

LiteLLM 支持以下 MCP 传输方式

  • 可流式传输的 HTTP
  • SSE (Server-Sent Events)
  • 标准输入/输出 (stdio)


添加 HTTP MCP 服务器​

本视频演示了如何在 LiteLLM UI 上添加和使用 HTTP MCP 服务器，并在 Cursor IDE 中使用它。



添加 SSE MCP 服务器​

本视频演示了如何在 LiteLLM UI 上添加和使用 SSE MCP 服务器，并在 Cursor IDE 中使用它。



添加 STDIO MCP 服务器​

对于 stdio MCP 服务器，选择“Standard Input/Output (stdio)”作为传输类型，并以 JSON 格式提供 stdio 配置。



OAuth 配置与覆盖​

LiteLLM 默认尝试 OAuth 2.0 授权服务器发现。当您在 UI 中创建 MCP 服务器并设置 Authentication: OAuth 时，LiteLLM 将定位提供商元数据、动态注册客户端，并执行基于 PKCE 的授权，无需您提供任何额外细节。

必要时自定义 OAuth 流程

  • 提供显式客户端凭据 – 如果 MCP 提供商不提供动态客户端注册，或者您希望自行管理客户端，请填写 client_id、client_secret 和所需的 scopes。
  • 覆盖发现 URL – 在某些环境中，LiteLLM 可能无法到达提供商的元数据端点。请使用可选的 authorization_url、token_url 和 registration_url 字段，直接将 LiteLLM 指向正确的端点。

AWS SigV4 认证​

对于托管在 AWS Bedrock AgentCore 上的 MCP 服务器，请选择 AWS SigV4 作为认证类型。LiteLLM 将使用 Signature Version 4，利用您的 AWS 凭据对每个出站 MCP 请求进行签名。

填写您的 AWS 区域、服务名称（默认为 bedrock-agentcore），以及可选的 AWS 访问密钥和机密。如果省略凭据，LiteLLM 将回退至 boto3 凭据链（IAM 角色、环境变量等）。

查看完整的 SigV4 设置指南


静态标头​

有时您的 MCP 服务器在每个请求中都需要特定的标头。这可能是一个 API 密钥，或者是服务器预期的自定义标头。与其配置认证，不如直接进行设置。

这些标头会随每个请求发送到服务器。就这么简单。

何时使用此功能

  • 您的服务器需要不符合标准认证模式的自定义标头
  • 您希望完全控制发送哪些确切的标头
  • 您正在调试，需要快速添加标头而无需更改认证配置

将 OpenAPI 规范转换为 MCP 服务器​

LiteLLM 可以将 OpenAPI 规范转换为 MCP 服务器，从而无需编写自定义服务器代码即可将任何 REST API 作为 MCP 工具公开。

请参阅 基于 OpenAPI 规范的 MCP 指南，了解完整的设置、使用示例以及如何覆盖工具名称和描述。

MCP OAuth​

LiteLLM 支持用于 MCP 服务器的 OAuth 2.0 —— 包括面向用户的交互式 (PKCE) 流程，以及用于后端服务的机器对机器 (M2M) client_credentials 流程。

请参阅 MCP OAuth 指南，了解设置说明、序列图和测试服务器。

详细的 OAuth 参考（点击展开）

LiteLLM v1.77.6 增加了对 MCP 服务器 OAuth 2.0 客户端凭据的支持。

您可以在 config.yaml 中配置，也可以直接从 LiteLLM UI（MCP Servers → Authentication → OAuth）配置。

mcp_servers:
  github_mcp:
    url: "https://api.githubcopilot.com/mcp"
    auth_type: oauth2
    client_id: os.environ/GITHUB_OAUTH_CLIENT_ID
    client_secret: os.environ/GITHUB_OAUTH_CLIENT_SECRET

查看 Claude Code 教程

工作原理​

参与者

  • Client (客户端) – 支持 MCP 的 AI 智能体（如 Claude Code、Cursor 或其他 IDE/智能体），代表用户发起 OAuth 发现、授权和工具调用。
  • LiteLLM Proxy – 协调所有的 OAuth 发现、注册、令牌交换和 MCP 流量，同时保护已存储的凭据。
  • Authorization Server (授权服务器) – 通过动态客户端注册、PKCE 授权和令牌端点颁发 OAuth 2.0 令牌。
  • MCP Server (资源服务器) – 接收 LiteLLM 经过认证的 JSON-RPC 请求的受保护 MCP 端点。
  • User-Agent (浏览器) – 临时参与，以便最终用户在授权步骤中授予许可。

流程步骤

  1. 资源发现: 客户端从 LiteLLM 的 .well-known/oauth-protected-resource 端点获取 MCP 资源元数据，以了解作用域和能力。
  2. 授权服务器发现: 客户端通过 LiteLLM 的 .well-known/oauth-authorization-server 端点检索 OAuth 服务器元数据（令牌端点、授权端点、支持的 PKCE 方法）。
  3. 动态客户端注册: 客户端通过 LiteLLM 进行注册，LiteLLM 将请求转发给授权服务器 (RFC 7591)。如果提供商不支持动态注册，您可以预先在 LiteLLM 中存储 client_id/client_secret（例如 GitHub MCP），流程照常进行。
  4. 用户授权: 客户端启动浏览器会话（带代码质询和资源提示）。用户批准访问，授权服务器通过 LiteLLM 将代码发送回客户端。
  5. 令牌交换: 客户端携带授权代码、代码验证器和资源调用 LiteLLM。LiteLLM 与授权服务器交换这些信息，并返回颁发的访问/刷新令牌。
  6. MCP 调用: 拥有有效令牌后，客户端向 LiteLLM 发送 MCP JSON-RPC 请求（加上 LiteLLM API 密钥），LiteLLM 将其转发给 MCP 服务器并中转工具响应。

请参阅官方的 MCP 授权流程 以获取更多参考。

将自定义标头转发至 MCP 服务器​

LiteLLM 支持使用 extra_headers 配置参数，将额外的自定义标头从 MCP 客户端转发到后端 MCP 服务器。这允许您传递自定义认证令牌、API 密钥或其他 MCP 服务器所需的标头。

配置

在您的 MCP 服务器配置中配置 extra_headers，以指定应转发哪些标头名称

带有 extra_headers 的 config.yaml
mcp_servers:
  github_mcp:
    url: "https://api.githubcopilot.com/mcp"
    auth_type: "bearer_token"
    auth_value: "ghp_default_token"
    extra_headers: ["custom_key", "x-custom-header", "Authorization"]
    description: "GitHub MCP server with custom header forwarding"

客户端使用​

从 MCP 客户端连接时，包含与 extra_headers 配置匹配的自定义标头

带有自定义标头的 FastMCP 客户端
from fastmcp import Client
import asyncio

# MCP client configuration with custom headers
config = {
    "mcpServers": {
        "github": {
            "url": "https://:4000/github_mcp/mcp",
            "headers": {
                "x-litellm-api-key": "Bearer sk-1234",
                "Authorization": "Bearer gho_token", 
                "custom_key": "custom_value",
                "x-custom-header": "additional_data"
            }
        }
    }
}

# Create a client that connects to the server
client = Client(config)

async def main():
    async with client:
        # List available tools
        tools = await client.list_tools()
        print(f"Available tools: {tools}")
        
        # Call a tool if available
        if tools:
            result = await client.call_tool(tools[0].name, {})
            print(f"Tool result: {result}")

# Run the client
asyncio.run(main())

工作原理​

  1. 配置: 在您的 MCP 服务器配置中定义 extra_headers，并包含您想要转发的标头名称
  2. 客户端标头: 在您的 MCP 客户端请求中包含相应的标头
  3. 标头转发: LiteLLM 自动将匹配的标头转发至后端 MCP 服务器
  4. 认证: 后端 MCP 服务器同时接收配置的认证标头和自定义标头

将请求标头传递至 STDIO 环境变量​

如果您的 stdio MCP 服务器需要按请求凭据，您可以将客户端请求中的 HTTP 标头直接映射到启动的 stdio 进程的环境变量中。使用 ${X-HEADER_NAME} 语法在 env 值中引用标头名称。LiteLLM 将从传入请求中读取该标头，并在启动命令前设置环境变量。

将 X-GITHUB_PERSONAL_ACCESS_TOKEN 标头转发至 stdio 环境变量
{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${X-GITHUB_PERSONAL_ACCESS_TOKEN}"
      }
    }
  }
}

在此示例中，当客户端发送带有 X-GITHUB_PERSONAL_ACCESS_TOKEN 标头的请求时，代理会将该值作为 GITHUB_PERSONAL_ACCESS_TOKEN 环境变量转发给 stdio 进程。

控制最终用户的 MCP 访问权限​

控制您的 AI 应用程序的最终用户（例如内部聊天 UI 的用户）可以访问哪些 MCP 服务器。在 x-litellm-end-user-id 标头中传递客户 ID，以：

  • 强制执行对象权限（限制他们可以访问的 MCP 服务器）
  • 应用客户特定的预算
  • 跟踪每个客户的支出

FastMCP 客户端示例

使用 x-litellm-end-user-id 跟踪客户支出
from fastmcp import Client
import asyncio

# MCP client configuration with customer tracking
config = {
    "mcpServers": {
        "github": {
            "url": "https://:4000/github_mcp/mcp",
            "headers": {
                "x-litellm-api-key": "Bearer sk-1234",
                "x-litellm-end-user-id": "customer_123",  # 👈 CUSTOMER ID
                "Authorization": "Bearer gho_token"
            }
        }
    }
}

client = Client(config)

async def main():
    async with client:
        # All MCP calls will be tracked under customer_123
        tools = await client.list_tools()
        result = await client.call_tool(tools[0].name, {})
        print(f"Tool result: {result}")

asyncio.run(main())

Cursor IDE 示例

带有客户跟踪的 Cursor 配置
{
  "mcpServers": {
    "GitHub": {
      "url": "https://:4000/github_mcp/mcp",
      "headers": {
        "x-litellm-api-key": "Bearer $LITELLM_API_KEY",
        "x-litellm-end-user-id": "customer_123"
      }
    }
  }
}

发生了什么

  • 强制执行客户特定的对象权限（仅可访问允许的 MCP 服务器）
  • 应用客户预算
  • 所有工具调用均归集到 customer_123 下

了解更多关于客户管理的信息 →

调用代理的 /v1/responses 端点​

当调用您的 LiteLLM Proxy 的 /v1/responses 端点以使用 MCP 工具时，务必在 tools 数组中使用 server_url: "litellm_proxy"。这告诉代理使用其配置的 MCP 服务器。

不要使用完整的代理 URL

当请求已经发送到代理时，使用 server_url: "https://your-proxy.com/mcp" 是错误的。代理需要字面值 litellm_proxy 来路由到其配置的 MCP 服务器。

正确：使用 litellm_proxy
curl --location 'https://your-proxy.com/v1/responses' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $LITELLM_API_KEY" \
--data '{
    "model": "gpt-4",
    "tools": [
        {
            "type": "mcp",
            "server_label": "litellm",
            "server_url": "litellm_proxy",
            "require_approval": "never"
        }
    ],
    "input": "Run available tools",
    "tool_choice": "required"
}'

向 MCP 服务器发送自定义标头​

要将自定义标头（例如 API 密钥、认证令牌）传递给特定的 MCP 服务器，请使用：

选项 1: 请求标头 – 将 x-mcp-{server_alias}-{header_name} 添加到您的请求标头中。代理会将它们转发给匹配的 MCP 服务器。

# Send Authorization header to the "weather2" MCP server
--header 'x-mcp-weather2-authorization: Bearer your-token'

# Send custom header to the "github" MCP server  
--header 'x-mcp-github-x-api-key: your-api-key'

选项 2: 工具配置中的标头 – 在工具定义中包含一个 headers 对象。这些会与请求标头合并。

{
    "type": "mcp",
    "server_label": "litellm",
    "server_url": "litellm_proxy",
    "require_approval": "never",
    "headers": {
        "x-litellm-api-key": "Bearer YOUR_LITELLM_API_KEY",
        "x-mcp-servers": "Zapier_MCP,dev-group",
        "x-mcp-weather2-authorization": "Bearer your-weather-api-token"
    }
}

使用客户端凭据使用您的 MCP​

如果您想将客户端认证令牌传递给 LiteLLM，再由 LiteLLM 传递给您的 MCP 以进行认证，请使用此方法。

您可以使用格式为 x-mcp-{server_alias}-{header_name} 的服务器特定标头来指定 MCP 认证令牌。这允许您为不同的 MCP 服务器使用不同的认证。

优势

  • 服务器特定认证: 每个 MCP 服务器可以使用不同的认证方法
  • 更好的安全性: 无需在所有服务器间共享同一个认证令牌
  • 灵活的标头名称: 支持不同类型的认证标头（authorization, x-api-key 等）
  • 清晰的分离: 每个服务器的认证标识明确

旧版认证标头（已弃用）​

您还可以使用标头 x-mcp-auth 指定您的 MCP 认证令牌。它将被转发到所有 MCP 服务器，目前已弃用，建议使用服务器特定标头。

通过带有服务器特定认证的 OpenAI Responses API 连接​

使用 OpenAI Responses API 并包含服务器特定认证标头

带有服务器特定认证的 cURL 示例
curl --location 'https://api.openai.com/v1/responses' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $OPENAI_API_KEY" \
--data '{
    "model": "gpt-4o",
    "tools": [
        {
            "type": "mcp",
            "server_label": "litellm",
            "server_url": "litellm_proxy",
            "require_approval": "never",
            "headers": {
                "x-litellm-api-key": "Bearer YOUR_LITELLM_API_KEY",
                "x-mcp-github-authorization": "Bearer YOUR_GITHUB_TOKEN",
                "x-mcp-zapier-x-api-key": "YOUR_ZAPIER_API_KEY"
            }
        }
    ],
    "input": "Run available tools",
    "tool_choice": "required"
}'

通过带有旧版认证的 OpenAI Responses API 连接​

使用 OpenAI Responses API 并为您的 MCP 服务器认证包含 x-mcp-auth 标头

带有旧版 MCP 认证的 cURL 示例
curl --location 'https://api.openai.com/v1/responses' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $OPENAI_API_KEY" \
--data '{
    "model": "gpt-4o",
    "tools": [
        {
            "type": "mcp",
            "server_label": "litellm",
            "server_url": "litellm_proxy",
            "require_approval": "never",
            "headers": {
                "x-litellm-api-key": "Bearer YOUR_LITELLM_API_KEY",
                "x-mcp-auth": YOUR_MCP_AUTH_TOKEN
            }
        }
    ],
    "input": "Run available tools",
    "tool_choice": "required"
}'

自定义 MCP 认证标头名称​

默认情况下，LiteLLM 使用 x-mcp-auth 将您的凭据传递给 MCP 服务器。您可以通过以下方式之一更改此标头名称：

  1. 设置 LITELLM_MCP_CLIENT_SIDE_AUTH_HEADER_NAME 环境变量
环境变量
export LITELLM_MCP_CLIENT_SIDE_AUTH_HEADER_NAME="authorization"
  1. 在 config.yaml 文件的常规设置中设置 mcp_client_side_auth_header_name
config.yaml
model_list:
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-xxxxxxx

general_settings:
  mcp_client_side_auth_header_name: "authorization"

使用 authorization 标头​

在此示例中，authorization 标头将传递给 MCP 服务器进行认证。

带有 authorization 标头的 cURL
curl --location '<your-litellm-proxy-base-url>/v1/responses' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $LITELLM_API_KEY" \
--data '{
    "model": "gpt-4o",
    "tools": [
        {
            "type": "mcp",
            "server_label": "litellm",
            "server_url": "litellm_proxy",
            "require_approval": "never",
            "headers": {
                "x-litellm-api-key": "Bearer YOUR_LITELLM_API_KEY",
                "authorization": "Bearer sk-zapier-token-123"
            }
        }
    ],
    "input": "Run available tools",
    "tool_choice": "required"
}'

将 MCP 工具与 /chat/completions 配合使用​

适用于所有提供商

此流程是与提供商无关的：同一个 MCP 工具定义适用于 LiteLLM 后端的每个 LLM（OpenAI、Azure OpenAI、Anthropic、Amazon Bedrock、Vertex、自托管部署等）。

LiteLLM Proxy 还在经典的 /v1/chat/completions 端点上支持感知 MCP 的工具。直接在 tools 数组中提供 MCP 工具定义，LiteLLM 将获取并转换 MCP 服务器的工具为 OpenAI 兼容的函数调用。当 require_approval 设置为 "never" 时，代理会自动执行返回的工具调用，并将结果反馈回模型，然后再返回助手的响应。

带有 MCP 工具的聊天完成（Chat Completions）
curl --location '<your-litellm-proxy-base-url>/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $LITELLM_API_KEY" \
--data '{
  "model": "gpt-4o-mini",
  "messages": [
    {"role": "user", "content": "Summarize the latest open PR."}
  ],
  "tools": [
    {
      "type": "mcp",
      "server_url": "litellm_proxy/mcp/github",
      "server_label": "github_mcp",
      "require_approval": "never"
    }
  ]
}'

如果您省略 require_approval 或将其设置为 "never" 之外的任何值，MCP 工具调用将返回给客户端，以便您可以手动审查和执行它们，这符合上游 OpenAI 的行为。

LiteLLM Proxy - MCP 网关演练​

LiteLLM 为管理员提供了一个 MCP 网关，用于将他们所有的 MCP 服务器添加到 LiteLLM。使用 LiteLLM Proxy 和 MCP 的关键好处是：

  1. 为所有 MCP 工具使用固定的端点
  2. 按密钥、团队或用户管理 MCP 权限

本视频演示了如何将 MCP 服务器加入到 LiteLLM Proxy、使用它并设置访问控制。

LiteLLM Python SDK MCP 桥接​

LiteLLM Python SDK 充当 MCP 桥接器，以便将 MCP 工具与 LiteLLM 支持的所有模型配合使用。LiteLLM 为使用 MCP 提供了以下功能：

  • 列出 可用的 MCP 工具：OpenAI 客户端可以查看所有可用的 MCP 工具
    • litellm.experimental_mcp_client.load_mcp_tools 以列出所有可用的 MCP 工具
  • 调用 MCP 工具：OpenAI 客户端可以调用 MCP 工具
    • litellm.experimental_mcp_client.call_openai_tool 以在 MCP 服务器上调用 OpenAI 工具

1. 列出可用 MCP 工具​

在此示例中，我们将使用 litellm.experimental_mcp_client.load_mcp_tools 列出任何 MCP 服务器上所有可用的 MCP 工具。此方法有两种使用方式：

  • format="mcp" - (默认) 返回 MCP 工具
    • 返回: mcp.types.Tool
  • format="openai" - 返回转换为与 OpenAI API 兼容的 MCP 工具。允许与 OpenAI 端点配合使用。
    • 返回: openai.types.chat.ChatCompletionToolParam
MCP 客户端列出工具
# Create server parameters for stdio connection
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import os
import litellm
from litellm import experimental_mcp_client


server_params = StdioServerParameters(
    command="python3",
    # Make sure to update to the full absolute path to your mcp_server.py file
    args=["./mcp_server.py"],
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        # Initialize the connection
        await session.initialize()

        # Get tools
        tools = await experimental_mcp_client.load_mcp_tools(session=session, format="openai")
        print("MCP TOOLS: ", tools)

        messages = [{"role": "user", "content": "what's (3 + 5)"}]
        llm_response = await litellm.acompletion(
            model="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY"),
            messages=messages,
            tools=tools,
        )
        print("LLM RESPONSE: ", json.dumps(llm_response, indent=4, default=str))

2. 列出并调用 MCP 工具​

在此示例中，我们将使用：

  • litellm.experimental_mcp_client.load_mcp_tools 列出任何 MCP 服务器上所有可用的 MCP 工具
  • litellm.experimental_mcp_client.call_openai_tool 以在 MCP 服务器上调用 OpenAI 工具

第一次 LLM 响应返回一个 OpenAI 工具列表。我们从 LLM 响应中获取第一个工具调用，并将其传递给 litellm.experimental_mcp_client.call_openai_tool，以便在 MCP 服务器上调用该工具。

litellm.experimental_mcp_client.call_openai_tool 的工作原理​

  • 接收来自 LLM 响应的 OpenAI 工具调用
  • 将 OpenAI 工具调用转换为 MCP 工具
  • 在 MCP 服务器上调用 MCP 工具
  • 返回 MCP 工具调用的结果
MCP 客户端列出并调用工具
# Create server parameters for stdio connection
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import os
import litellm
from litellm import experimental_mcp_client


server_params = StdioServerParameters(
    command="python3",
    # Make sure to update to the full absolute path to your mcp_server.py file
    args=["./mcp_server.py"],
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        # Initialize the connection
        await session.initialize()

        # Get tools
        tools = await experimental_mcp_client.load_mcp_tools(session=session, format="openai")
        print("MCP TOOLS: ", tools)

        messages = [{"role": "user", "content": "what's (3 + 5)"}]
        llm_response = await litellm.acompletion(
            model="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY"),
            messages=messages,
            tools=tools,
        )
        print("LLM RESPONSE: ", json.dumps(llm_response, indent=4, default=str))

        openai_tool = llm_response["choices"][0]["message"]["tool_calls"][0]
        # Call the tool using MCP client
        call_result = await experimental_mcp_client.call_openai_tool(
            session=session,
            openai_tool=openai_tool,
        )
        print("MCP TOOL CALL RESULT: ", call_result)

        # send the tool result to the LLM
        messages.append(llm_response["choices"][0]["message"])
        messages.append(
            {
                "role": "tool",
                "content": str(call_result.content[0].text),
                "tool_call_id": openai_tool["id"],
            }
        )
        print("final messages with tool result: ", messages)
        llm_response = await litellm.acompletion(
            model="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY"),
            messages=messages,
            tools=tools,
        )
        print(
            "FINAL LLM RESPONSE: ", json.dumps(llm_response, indent=4, default=str)
        )

常见问题解答​

问：如何配合 LiteLLM 后端的 MCP 服务器使用 OAuth2 client_credentials (机器对机器)？

LiteLLM 支持 client_credentials 授权的自动令牌管理。在您的 MCP 服务器上配置 client_id、client_secret 和 token_url，LiteLLM 将自动获取、缓存和刷新令牌。请参阅 MCP OAuth M2M 指南 以获取设置说明。

问：当我从 LiteLLM UI 获取 OAuth 令牌时，它存储在哪里？

UI 仅在 sessionStorage 中保持瞬态状态，以便 OAuth 重定向流程能够完成；令牌不会持久化到服务器或数据库中。

问：我遇到了 MCP 连接错误——我应该检查什么？

请查阅 MCP 故障排除指南 进行分步隔离（客户端 → LiteLLM 与 LiteLLM → MCP）、查看日志示例以及使用 MCP Inspector 和 curl 等验证方法。

🚅
LiteLLM 企业版
SSO/SAML、审计日志、支出跟踪、多团队管理和护栏 —— 专为生产环境构建。
了解更多 →