LiteLLM 完整教程（2026）

你是否遇到过这些场景：项目跑在 OpenAI 上，某天突然想切 Claude，发现所有 SDK 调用都要改；或者同时用三家 API，API Key 散落各处，账单完全看不清楚在哪个服务上花了多少；又或者系统上线后某个模型频繁限速，手动加重试逻辑写了一堆样板代码？

LiteLLM 就是为了解决这些问题而生的。GitHub 53k Star，v1.91.0（2026-07-04），支持 100+ LLM Provider，8ms P95 延迟，1.5k+ RPS 承压能力。它有两种使用姿势：Python SDK（直接嵌入代码）和 Proxy Server（自托管 AI 网关）。两者可以单独用，也可以组合。

本文是目前中文社区最完整的 LiteLLM 教程，涵盖：SDK 基础用法、跨模型切换、Router 路由策略、Proxy 搭建与配置、Claude Code 接入、成本追踪、国内中转站接入、生产部署。全文约 6000 字，建议收藏分段阅读。

一、LiteLLM 是什么，解决什么问题

LiteLLM 的核心价值可以用一句话概括：用同一套代码调用任意 LLM，不需要学各家不同的 SDK 格式。

100+ Provider 的 API 格式各不相同——OpenAI 一套、Anthropic 一套、Google Vertex 一套、AWS Bedrock 又是另一套。LiteLLM 在它们上面封装了一层统一的 OpenAI 兼容接口：你只需要改一行 model 参数，请求就能路由到任意 Provider。

除了统一接口，LiteLLM 还提供：

• 智能路由：自动负载均衡、故障转移、按延迟/成本/权重分发请求
• 成本追踪：每次调用自动计算 token 费用，汇总多 Provider 账单
• 可观测性：一行配置接入 Langfuse、MLflow、Helicone 等监控平台
• Proxy 模式：自托管 OpenAI 兼容服务器，任何用 OpenAI SDK 的工具（包括 Claude Code）都能无缝切换
• 虚拟 Key 与预算：给团队不同成员发放虚拟 API Key，设置独立消费上限

两种使用模式的对比：

模式	适用场景	优点	缺点
Python SDK	自己的 Python 项目，需要在代码里调用 LLM	轻量、零额外依赖、调试方便	只能用于 Python，无法给其他语言/工具共享
Proxy Server	团队共享网关、给 Claude Code / Cursor 等工具提供后端	语言无关、集中管理 Key 和费用、生产级高可用	需要额外维护一个进程/容器

二、安装

2.1 安装 Python SDK

# 推荐用 uv（速度快）
uv add litellm

# 或 pip
pip install litellm

2.2 安装 Proxy Server

# 安装含 Proxy 功能的完整版
uv tool install 'litellm[proxy]'

# 或 pip
pip install 'litellm[proxy]'

安装完后运行 litellm --version 验证，当前最新版本为 v1.91.0。

三、Python SDK：基础用法

3.1 最简单的调用

LiteLLM 的 completion() 函数与 OpenAI 的 chat.completions.create() 接口完全一致，只是多了一个 model 前缀来指定 Provider：

from litellm import completion
import os

# OpenAI
os.environ["OPENAI_API_KEY"] = "sk-..."
response = completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "你好，写一段 Python 快速排序"}]
)
print(response.choices[0].message.content)

切换到 Anthropic Claude，只需改 model 和对应的 Key：

os.environ["ANTHROPIC_API_KEY"] = "sk-ant-..."
response = completion(
    model="anthropic/claude-sonnet-5",   # 注意：anthropic/ 前缀
    messages=[{"role": "user", "content": "你好，写一段 Python 快速排序"}]
)
print(response.choices[0].message.content)

切换到 Google Gemini：

os.environ["GEMINI_API_KEY"] = "AIza..."
response = completion(
    model="gemini/gemini-3.5-flash",
    messages=[{"role": "user", "content": "你好，写一段 Python 快速排序"}]
)
print(response.choices[0].message.content)

除了 model 参数，其余代码完全不变。这就是 LiteLLM 最核心的价值：切换模型不需要修改业务逻辑。

3.2 主要 Provider 的 model 字符串格式

Provider	model 格式示例	环境变量
OpenAI	openai/gpt-4o	OPENAI_API_KEY
Anthropic	anthropic/claude-sonnet-5	ANTHROPIC_API_KEY
Google Gemini	gemini/gemini-3.5-flash	GEMINI_API_KEY
AWS Bedrock	bedrock/anthropic.claude-3-sonnet	AWS_ACCESS_KEY_ID 等
Azure OpenAI	azure/<deployment-name>	AZURE_API_KEY 等
Ollama（本地）	ollama/llama3.2	无需 Key
DeepSeek	deepseek/deepseek-chat	DEEPSEEK_API_KEY
OpenAI 兼容（中转站）	openai/model-name + api_base	自定义

3.3 流式输出（Streaming）

response = completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "写一篇关于 AI 的短文"}],
    stream=True
)

for chunk in response:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end='', flush=True)
print()  # 换行

3.4 异步调用

import asyncio
from litellm import acompletion

async def main():
    response = await acompletion(
        model="anthropic/claude-sonnet-5",
        messages=[{"role": "user", "content": "解释量子纠缠"}]
    )
    print(response.choices[0].message.content)

asyncio.run(main())

3.5 函数调用（Tool Use）

import json
from litellm import completion

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "城市名称"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

response = completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "北京今天天气怎么样？"}],
    tools=tools,
    tool_choice="auto"
)

# 解析工具调用
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"调用工具：{tool_call.function.name}")
    print(f"参数：{json.loads(tool_call.function.arguments)}")

四、Python SDK：进阶技巧

4.1 统一错误处理

LiteLLM 将所有 Provider 的错误映射到 OpenAI 的异常类型，你只需处理一套异常：

from litellm import completion
from litellm.exceptions import (
    AuthenticationError,
    RateLimitError,
    APIError,
    BadRequestError
)

try:
    response = completion(
        model="anthropic/claude-sonnet-5",
        messages=[{"role": "user", "content": "你好"}]
    )
except AuthenticationError as e:
    print(f"API Key 错误：{e}")
except RateLimitError as e:
    print(f"限速，等待后重试：{e}")
except BadRequestError as e:
    print(f"请求参数错误：{e}")
except APIError as e:
    print(f"服务端错误：{e}")

4.2 成本追踪（单次调用）

import litellm

response = completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "写100字的短文"}]
)

# 获取本次调用的费用（美元）
cost = litellm.completion_cost(completion_response=response)
print(f"本次费用：${cost:.6f}")
print(f"输入 tokens：{response.usage.prompt_tokens}")
print(f"输出 tokens：{response.usage.completion_tokens}")

4.3 可观测性接入（Langfuse）

import litellm

# 一行接入 Langfuse，自动记录所有 LLM 调用
litellm.success_callback = ["langfuse"]
os.environ["LANGFUSE_PUBLIC_KEY"] = "pk-..."
os.environ["LANGFUSE_SECRET_KEY"] = "sk-..."

response = completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "你好"}]
)
# 调用会自动被记录到 Langfuse dashboard

支持的监控平台还包括：MLflow、Helicone、Lunary、Arize、Weights & Biases 等，配置方式完全相同。

4.4 接入 OpenAI 兼容的中转站（自定义 api_base）

国内中转站（如硅基流动、AiHubMix）通常提供 OpenAI 兼容接口，LiteLLM 可以直接接入：

response = completion(
    model="openai/deepseek-v4-flash",   # 模型名以中转站支持的为准
    api_base="https://api.siliconflow.cn/v1",  # 中转站端点
    api_key="sk-...",   # 你在中转站的 API Key
    messages=[{"role": "user", "content": "你好"}]
)

五、Router：负载均衡与故障转移

当你的系统需要调用多个同类部署（比如三个 Azure GPT-4o 部署分布在不同区域），或者需要在主模型失败时自动切换备用模型，就需要 litellm.Router。

5.1 基础路由配置

from litellm import Router

model_list = [
    {
        "model_name": "gpt-4o",   # 对外暴露的统一名称
        "litellm_params": {
            "model": "openai/gpt-4o",
            "api_key": "sk-openai-primary",
            "weight": 7   # 70% 流量
        }
    },
    {
        "model_name": "gpt-4o",
        "litellm_params": {
            "model": "azure/gpt-4o-eastus",
            "api_base": "https://my-eastus.openai.azure.com/",
            "api_key": "azure-key",
            "api_version": "2024-08-01-preview",
            "weight": 3   # 30% 流量
        }
    }
]

router = Router(model_list=model_list)

# 调用方式和 litellm.completion() 完全一样
response = router.completion(
    model="gpt-4o",   # 使用统一名称
    messages=[{"role": "user", "content": "你好"}]
)

5.2 七种路由策略详解

策略	适用场景	特点
simple-shuffle（默认）	通用生产环境	按 RPM/TPM 或权重加权随机，最低开销，推荐首选
rate-limit-aware-v2	多账号防限速	实时追踪各部署 TPM，过滤超限的部署，异步执行
latency-based-routing	延迟敏感的实时系统	动态缓存各部署响应时间，选最快的
least-busy	控制并发，防止某个部署过载	选当前进行中请求数最少的部署
usage-based-routing	多实例分布式部署	按 TPM 路由到用量最低的，需要 Redis
cost-based-routing	成本敏感场景	每次请求选最便宜的可用部署
custom	自定义业务逻辑	继承 CustomRoutingStrategyBase 实现自定义逻辑

5.3 故障转移与重试策略

from litellm.router import RetryPolicy, AllowedFailsPolicy

retry_policy = RetryPolicy(
    RateLimitErrorRetries=3,        # 限速错误重试3次
    TimeoutErrorRetries=2,          # 超时重试2次
    AuthenticationErrorRetries=0,   # 认证错误不重试
    BadRequestErrorRetries=1,
    ContentPolicyViolationErrorRetries=3
)

allowed_fails_policy = AllowedFailsPolicy(
    RateLimitErrorAllowedFails=100,  # 限速错误容忍100次才冷却
    ContentPolicyViolationErrorAllowedFails=1000
)

router = Router(
    model_list=model_list,
    retry_policy=retry_policy,
    allowed_fails_policy=allowed_fails_policy,
    allowed_fails=3,      # 某部署1分钟内失败超3次触发冷却
    cooldown_time=30      # 冷却时间30秒
)

5.4 优先级顺序（order 参数）

model_list = [
    {
        "model_name": "claude-sonnet",
        "litellm_params": {
            "model": "anthropic/claude-sonnet-5",
            "api_key": "primary-key",
            "order": 1   # 最高优先级，先尝试
        }
    },
    {
        "model_name": "claude-sonnet",
        "litellm_params": {
            "model": "anthropic/claude-sonnet-5",
            "api_base": "https://中转站地址/v1",
            "api_key": "relay-key",
            "order": 2   # 备用：主线路失败后使用中转站
        }
    }
]
router = Router(model_list=model_list)

六、Proxy Server：自托管 AI 网关

LiteLLM Proxy 是一个可以独立部署的 HTTP 服务器，暴露与 OpenAI 完全兼容的接口。团队里所有成员、所有语言的代码、所有 AI 工具（Claude Code、Cursor、Open WebUI 等），只需把 base_url 指向这个 Proxy，统一管理所有 LLM 访问。

6.1 最简单启动

# 直接启动，路由到指定模型
litellm --model openai/gpt-4o

# 代理运行在 http://0.0.0.0:4000

6.2 config.yaml 核心配置

生产环境建议用 config.yaml 管理所有配置：

model_list:
  # 主力模型：Claude Sonnet 5
  - model_name: claude-sonnet
    litellm_params:
      model: anthropic/claude-sonnet-5
      api_key: os.environ/ANTHROPIC_API_KEY

  # 备用：硅基流动的 DeepSeek（国内直连）
  - model_name: claude-sonnet
    litellm_params:
      model: openai/deepseek-v4-flash
      api_base: https://api.siliconflow.cn/v1
      api_key: os.environ/SILICONFLOW_API_KEY
      order: 2   # 备用

  # 免费编程模型：GLM-4.7-Flash（国内直连）
  - model_name: glm-flash
    litellm_params:
      model: openai/glm-4.7-flash
      api_base: https://open.bigmodel.cn/api/paas/v4/
      api_key: os.environ/GLM_API_KEY

  # 本地 Ollama
  - model_name: local-llama
    litellm_params:
      model: ollama/llama3.2
      api_base: http://localhost:11434

litellm_settings:
  drop_params: true          # 自动丢弃目标模型不支持的参数
  num_retries: 3             # 全局重试次数
  request_timeout: 60        # 超时时间（秒）
  success_callback: ["langfuse"]  # 监控回调

general_settings:
  master_key: sk-my-secret-key   # 访问 Proxy 需要的 Key
  alerting: ["slack"]            # 慢请求/错误告警

router_settings:
  routing_strategy: simple-shuffle
  allowed_fails: 3
  cooldown_time: 30

# 用 config 启动
litellm --config config.yaml

# 验证启动
curl http://localhost:4000/health

6.3 通过 OpenAI SDK 调用 Proxy

import openai

# 指向本地 Proxy
client = openai.OpenAI(
    api_key="sk-my-secret-key",    # config.yaml 里的 master_key
    base_url="http://localhost:4000"
)

response = client.chat.completions.create(
    model="claude-sonnet",    # 对应 config.yaml 里的 model_name
    messages=[{"role": "user", "content": "你好"}]
)
print(response.choices[0].message.content)

6.4 模型发现（列出所有可用模型）

curl http://localhost:4000/models \
  -H "Authorization: Bearer sk-my-secret-key"

七、与 Claude Code 集成

这是 LiteLLM 在国内开发者中最热门的用途之一：把 Claude Code 的请求路由到其他模型（GPT-5.6、Gemini、DeepSeek、GLM），或者通过国内中转站接入，解决国内访问稳定性问题。

7.1 原理

Claude Code 内部使用 Anthropic Messages API 格式。LiteLLM Proxy 会：

1. 接收 Claude Code 发出的 Anthropic 格式请求
2. 自动转换为目标 Provider（OpenAI/Gemini/DeepSeek 等）的格式
3. 转发给目标 Provider
4. 把响应转换回 Anthropic 格式返回给 Claude Code

7.2 配置步骤

Step 1：创建 config.yaml（以接入 GPT-4o 和国内中转站为例）

model_list:
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: os.environ/OPENAI_API_KEY

  - model_name: deepseek-v4-flash
    litellm_params:
      model: openai/deepseek-v4-flash
      api_base: https://api.siliconflow.cn/v1
      api_key: os.environ/SILICONFLOW_API_KEY

  - model_name: glm-flash
    litellm_params:
      model: openai/glm-4.7-flash
      api_base: https://open.bigmodel.cn/api/paas/v4/
      api_key: os.environ/GLM_API_KEY

general_settings:
  master_key: sk-claude-proxy

Step 2：启动 Proxy

litellm --config config.yaml
# 监听 http://0.0.0.0:4000

Step 3：配置 Claude Code 环境变量

export ANTHROPIC_BASE_URL="http://0.0.0.0:4000"
export ANTHROPIC_AUTH_TOKEN="sk-claude-proxy"

Step 4：启动 Claude Code，指定模型

# 使用 GPT-4o
claude --model gpt-4o

# 使用国内直连的 DeepSeek
claude --model deepseek-v4-flash

# 使用免费的 GLM-4.7-Flash
claude --model glm-flash

# 启用网关模型发现（在 Claude Code 里用 /model 命令切换）
export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
claude   # 启动后用 /model 命令列出并切换模型

7.3 与 claude-code-router 的对比

很多读者可能已经在用 claude-code-router（CCR），那 LiteLLM Proxy 和 CCR 有什么区别？

对比项	LiteLLM Proxy	claude-code-router
支持 Provider 数量	100+	主流几家
路由策略	7种，高度可配	基于请求类型路由
Claude Code 集成	✓	✓（专为此设计）
Admin Dashboard	✓（内置 UI）	✗
团队多用户	✓（虚拟 Key）	✗
成本追踪	✓（精细）	✗
部署复杂度	中等（需要运维）	简单（单进程）

简单来说：个人用 CCR 更轻便，团队用 LiteLLM Proxy 更完整。两者也可以叠加：CCR 处理 Claude Code 的智能路由，LiteLLM 处理其他 Python 服务的多 Provider 统一调用。

八、成本追踪与预算控制

8.1 自定义成本回调

import litellm
from litellm.integrations.custom_logger import CustomLogger

class CostTracker(CustomLogger):
    def __init__(self):
        self.total_cost = 0.0
        self.calls = []

    def log_success_event(self, kwargs, response_obj, start_time, end_time):
        cost = kwargs.get("response_cost", 0)
        self.total_cost += cost
        self.calls.append({
            "model": kwargs.get("model"),
            "cost": cost,
            "tokens": response_obj.usage.total_tokens,
            "latency": (end_time - start_time).total_seconds()
        })
        print(f"[Cost] {kwargs.get('model')}: ${cost:.6f}")

tracker = CostTracker()
litellm.callbacks = [tracker]

# 调用后查看
response = litellm.completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)
print(f"累计费用：${tracker.total_cost:.4f}")

8.2 Proxy 的虚拟 Key 与预算

LiteLLM Proxy 支持给不同用户/项目发放虚拟 API Key，并独立设置消费上限：

# 创建虚拟 Key（通过 Admin API）
curl -X POST http://localhost:4000/key/generate \
  -H "Authorization: Bearer sk-my-secret-key" \
  -H "Content-Type: application/json" \
  -d '{
    "team_id": "frontend-team",
    "max_budget": 10.0,       # 最多消费 $10
    "budget_duration": "30d", # 30天重置
    "models": ["claude-sonnet", "glm-flash"],  # 只允许用这些模型
    "metadata": {"user": "alice@example.com"}
  }'

# 返回：{"key": "sk-virtual-abc123", ...}

Alice 用 sk-virtual-abc123 调用 Proxy，超过 $10 自动拒绝，完全不需要共享主 Key。

九、国内中转站接入配置

国内主流 AI API 中转站都支持 OpenAI 兼容接口，接入 LiteLLM 非常简单。以下是几个常见中转站的配置：

model_list:
  # 硅基流动 SiliconFlow（国内直连，DeepSeek/Qwen/GLM全系）
  - model_name: deepseek-v4-flash
    litellm_params:
      model: openai/deepseek-v4-flash
      api_base: https://api.siliconflow.cn/v1
      api_key: os.environ/SILICONFLOW_API_KEY

  # AiHubMix（Claude/GPT国内直连，支持Prompt Caching）
  - model_name: claude-sonnet-via-relay
    litellm_params:
      model: openai/claude-sonnet-5-20261001
      api_base: https://aihubmix.com/v1
      api_key: os.environ/AIHUBMIX_API_KEY

  # 智谱AI GLM（国内直连，免费模型可用）
  - model_name: glm-flash-free
    litellm_params:
      model: openai/glm-4.7-flash
      api_base: https://open.bigmodel.cn/api/paas/v4/
      api_key: os.environ/GLM_API_KEY

  # OpenRouter（全球400+模型统一接口）
  - model_name: openrouter-sonnet
    litellm_params:
      model: openai/anthropic/claude-sonnet-5
      api_base: https://openrouter.ai/api/v1
      api_key: os.environ/OPENROUTER_API_KEY

配置环境变量后启动：

export SILICONFLOW_API_KEY="sk-sf-..."
export AIHUBMIX_API_KEY="sk-ahm-..."
export GLM_API_KEY="your-glm-key"

litellm --config config.yaml

这样一个 Proxy 就整合了四家中转站，你的代码只需连接 http://localhost:4000，通过不同的 model_name 调用不同的中转站，完全统一管理。

十、生产部署：Docker + Redis

10.1 Docker 单容器部署

# docker-compose.yml
version: '3.8'
services:
  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000"
    volumes:
      - ./config.yaml:/app/config.yaml
    environment:
      - ANTHROPIC_API_KEY=${'{ANTHROPIC_API_KEY}'}
      - SILICONFLOW_API_KEY=${'{SILICONFLOW_API_KEY}'}
      - GLM_API_KEY=${'{GLM_API_KEY}'}
      - LITELLM_MASTER_KEY=sk-production-key
    command: --config /app/config.yaml --port 4000 --num_workers 8
    restart: unless-stopped

docker-compose up -d

10.2 生产级部署：加 Redis 实现分布式状态共享

# docker-compose-production.yml
version: '3.8'
services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data

  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000"
    volumes:
      - ./config.yaml:/app/config.yaml
    environment:
      - ANTHROPIC_API_KEY=${'{ANTHROPIC_API_KEY}'}
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - LITELLM_MASTER_KEY=sk-production-key
    depends_on:
      - redis
    command: --config /app/config.yaml --port 4000 --num_workers 8

volumes:
  redis-data:

在 config.yaml 里启用 Redis：

router_settings:
  routing_strategy: usage-based-routing   # 分布式感知路由
  redis_host: redis
  redis_port: 6379
  cache_responses: true   # 开启响应缓存降低成本

10.3 性能参数参考

配置	RPS	P95 延迟
单实例 8 worker	~400	<10ms（代理层）
单实例 16 worker	~800	<10ms
3 实例 + Redis	~1500+	<8ms（P95）

十一、安全注意事项

⚠️ 重要安全警告：LiteLLM PyPI 包的 v1.82.7 和 v1.82.8 版本已被确认受到供应链攻击，植入了凭证窃取恶意软件，会将你的 API Key 和环境变量发送到外部服务器。如果你安装了这两个版本，请立即：① 升级到最新版本；② 轮换所有 API Key；③ 检查系统是否有异常进程。

其他安全建议：

• 不要在 config.yaml 里硬编码 API Key，一律使用 os.environ/VAR_NAME 格式引用环境变量
• Proxy 不要暴露到公网，除非配置了虚拟 Key 和 IP 白名单；本地开发绑定 127.0.0.1:4000 而非 0.0.0.0:4000
• 定期轮换 master_key，虚拟 Key 可以设置过期时间
• 启用请求日志时注意 PII 脱敏，避免把用户输入的敏感内容记录到外部监控系统

十二、常见问题

Q：我已经在用 OpenAI SDK，接入 LiteLLM 需要改多少代码？

A：如果用 Proxy 模式，只需改两行：api_key 改为 Proxy 的 master_key，base_url 改为 Proxy 地址。业务代码完全不用动。如果用 Python SDK，把 openai.ChatCompletion.create() 换成 litellm.completion()，参数格式完全相同。

Q：LiteLLM 会增加多少延迟？

A：官方测试 P95 延迟约 8ms（代理层本身，不含 LLM 响应时间）。对于大多数 LLM 调用场景，LLM 本身响应就需要数百毫秒到几秒，8ms 的额外延迟可以忽略不计。

Q：能不能把 LiteLLM 用在 Node.js / Go / Java 项目里？

A：可以，通过 Proxy 模式。Proxy 暴露的是标准 HTTP REST 接口（OpenAI 兼容），任何语言都可以用 HTTP 客户端直接调用，或者用各自语言的 OpenAI SDK 把 base_url 指向 Proxy。

Q：LiteLLM 的 Anthropic 兼容端点（`/anthropic`）支持哪些功能？

A：支持 Messages API 的核心功能，包括 streaming、tool_use、vision（图片输入）、system prompt，以及通过 Proxy 把 Claude Code 等 Anthropic SDK 工具路由到其他 Provider（GPT、Gemini、DeepSeek 等）。

Q：如何调试路由是否按预期工作？

A：启动时加 --detailed_debug 参数，或在 Router 初始化时加 set_verbose=True，会输出每次请求的路由决策、重试日志和实际使用的部署。

Q：LiteLLM 是否支持 Embeddings 和图像生成？

A：支持。LiteLLM 的统一接口覆盖 /embeddings（文本向量化）、/images/generations（图像生成）、/audio/transcriptions（语音识别）等多个端点，调用方式和 completion() 类似。

十三、总结

LiteLLM 解决了 LLM 工程中一个非常真实的痛点：多 Provider 碎片化。当你的系统需要同时依赖 OpenAI、Anthropic、本地模型和中转站时，LiteLLM 是目前最成熟的统一层。

按使用场景推荐：

• 写 Python 脚本 / 个人项目：用 SDK 模式，pip install 后直接用 completion()，最轻量
• 给 Claude Code / Cursor 接入多模型：用 Proxy 模式，5分钟搭完，ANTHROPIC_BASE_URL 指向本地 Proxy
• 团队共享 LLM 访问：Proxy + 虚拟 Key + 预算控制，完整的企业级管理
• 高可用生产系统：Proxy + Redis + 多实例，1500+ RPS，P95 延迟 <8ms

对于国内开发者：LiteLLM 和中转站（硅基流动、AiHubMix、GLM等）的组合是目前最灵活的 LLM 访问方案——中转站解决国内直连问题，LiteLLM 解决多 Provider 统一管理问题，两者互补。