LLMs

一份关于在 CrewAI 项目中配置和使用大型语言模型（ LLMs ）的综合指南

概述

CrewAI 通过各提供商原生 SDK 集成了多种 LLM 提供商，使你能够灵活地为具体用例选择合适的模型。本指南将帮助你了解如何在 CrewAI 项目中配置和使用不同的 LLM 提供商。

什么是 LLMs？

大型语言模型（ LLMs ）是 CrewAI agents 背后的核心智能。它们使 agent 能够理解上下文、做出决策，并生成类似人类的响应。以下是你需要了解的内容：

LLM 基础

大型语言模型是基于海量文本数据训练的 AI 系统。它们为你的 CrewAI agents 提供智能能力，使其能够理解并生成类似人类的文本。

上下文窗口

上下文窗口决定了一个 LLM 一次可以处理多少文本。更大的窗口（例如 128K tokens ）能够容纳更多上下文，但通常成本更高、速度更慢。

Temperature

Temperature（ 0.0 到 1.0 ）控制响应的随机性。较低的值（例如 0.2 ）会产生更聚焦、更具确定性的输出，而较高的值（例如 0.8 ）会提升创造性和多样性。

提供商选择

每个 LLM 提供商（例如 OpenAI、Anthropic、Google ）都提供不同的模型，它们在能力、价格和功能方面各不相同。请根据你对准确性、速度和成本的需求进行选择。

设置你的 LLM

在 CrewAI 代码中，你可以在不同位置指定要使用的模型。一旦指定了所使用的模型，你就需要为每个使用到的模型提供商提供相应配置（例如 API key ）。请参阅下方 provider 配置示例部分，找到对应提供商的配置方法。

1. 环境变量

最简单的入门方式。直接在环境中设置模型，可以通过 .env 文件或在应用代码中设置。如果你使用 crewai create 初始化项目，那么它通常已经被预设好了。

MODEL=model-id  # 例如 gpt-4o, gemini-2.0-flash, claude-3-sonnet-...
# 请务必在这里也设置你的 API keys。见下方 Provider
# 部分。

注意：永远不要将 API keys 提交到版本控制系统中。请使用环境文件（ .env ）或系统级密钥管理方案。

2. YAML 配置

创建一个 YAML 文件来定义你的 agent 配置。这种方式非常适合版本控制与团队协作：

researcher:
    role: Research Specialist
    goal: Conduct comprehensive research and analysis
    backstory: A dedicated research professional with years of experience
    verbose: true
    llm: provider/model-id  # 例如 openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
    # （更多内容见下方 provider 配置示例）

YAML 配置允许你：

• 对 agent 配置进行版本控制
• 轻松切换不同模型
• 在团队成员之间共享配置
• 记录模型选择及其用途

3. 直接代码配置

如果你需要最大灵活性，可以直接在 Python 代码中配置 LLM ：

from crewai import LLM
# 基础配置
llm = LLM(model="model-id-here")  # gpt-4o, gemini-2.0-flash, anthropic/claude...
# 带详细参数的高级配置
llm = LLM(
    model="model-id-here",  # gpt-4o, gemini-2.0-flash, anthropic/claude...
    temperature=0.7,        # 更高值用于更具创造性的输出
    timeout=120,            # 等待响应的秒数
    max_tokens=4000,        # 响应的最大长度
    top_p=0.9,              # 核采样参数
    frequency_penalty=0.1 , # 降低重复
    presence_penalty=0.1,   # 鼓励主题多样性
    response_format={"type": "json"},  # 用于结构化输出
    seed=42                 # 用于可复现结果
)

参数说明：

• temperature：控制随机性（ 0.0 - 1.0 ）
• timeout：响应最大等待时间
• max_tokens：限制响应长度
• top_p：Temperature 的另一种采样方式
• frequency_penalty：减少词语重复
• presence_penalty：鼓励引入新主题
• response_format：指定输出结构
• seed：确保输出一致

说明：CrewAI 为 OpenAI、Anthropic、Google（ Gemini API ）、Azure 和 AWS Bedrock 提供原生 SDK 集成 —— 除了 provider 对应的 extras 之外，无需额外安装（例如 uv add "crewai[openai]" ）。

其他所有 provider 都通过 LiteLLM 提供支持。如果你计划使用其中任意一个，请将其作为依赖添加到你的项目中：

uv add 'crewai[litellm]'

Provider 配置示例

CrewAI 支持大量 LLM providers，每个 provider 都提供独特的功能、认证方式和模型能力。在本节中，你将看到详细示例，帮助你选择、配置并优化最适合你项目需求的 LLM。

OpenAI

CrewAI 通过 OpenAI Python SDK 提供对 OpenAI 的原生集成。

# 必填
OPENAI_API_KEY=sk-...
# 可选
OPENAI_BASE_URL=<custom-base-url>

基础用法：

from crewai import LLM
llm = LLM(
    model="openai/gpt-4o",
    api_key="your-api-key",  # 或设置 OPENAI_API_KEY
    temperature=0.7,
    max_tokens=4000
)

高级配置：

from crewai import LLM
llm = LLM(
    model="openai/gpt-4o",
    api_key="your-api-key",
    base_url="https://api.openai.com/v1",  # 可选自定义 endpoint
    organization="org-...",  # 可选 organization ID
    project="proj_...",  # 可选 project ID
    temperature=0.7,
    max_tokens=4000,
    max_completion_tokens=4000,  # 用于较新的模型
    top_p=0.9,
    frequency_penalty=0.1,
    presence_penalty=0.1,
    stop=["END"],
    seed=42,  # 用于可复现输出
    stream=True,  # 启用流式输出
    timeout=60.0,  # 请求超时时间（秒）
    max_retries=3,  # 最大重试次数
    logprobs=True,  # 返回对数概率
    top_logprobs=5,  # 最可能 tokens 的数量
    reasoning_effort="medium"  # 用于 o1 模型：low, medium, high
)

结构化输出：

from pydantic import BaseModel
from crewai import LLM
class ResponseFormat(BaseModel):
    name: str
    age: int
    summary: str
llm = LLM(
    model="openai/gpt-4o",
)

支持的环境变量：

• OPENAI_API_KEY：你的 OpenAI API key（必填）
• OPENAI_BASE_URL：OpenAI API 的自定义 base URL（可选）

特性：

• 原生函数调用支持（ o1 模型除外 ）
• 通过 JSON schema 支持结构化输出
• 支持实时流式响应
• Token 用量追踪
• Stop sequences 支持（ o1 模型除外 ）
• 用于 token 级洞察的对数概率
• 针对 o1 模型的 reasoning effort 控制

支持的模型：

Responses API：

OpenAI 提供两种 API：Chat Completions（默认）和较新的 Responses API。Responses API 从底层开始就以原生多模态支持为设计目标 —— 文本、图像、音频和函数调用都是一等公民。它在推理模型上性能更好，并支持自动链式调用和内置工具等附加功能。

from crewai import LLM
# 使用 Responses API 而不是 Chat Completions
llm = LLM(
    model="openai/gpt-4o",
    api="responses",  # 启用 Responses API
    store=True,  # 为多轮对话存储 responses（可选）
    auto_chain=True,  # 为推理模型启用自动链式调用（可选）
)

Responses API 参数：

• api：设置为 "responses" 以使用 Responses API（默认值："completions"）
• instructions：系统级指令（仅 Responses API ）
• store：是否为多轮对话存储 responses
• previous_response_id：用于多轮对话的上一条 response ID
• include：响应中需要附带的附加数据（例如 ["reasoning.encrypted_content"] ）
• builtin_tools：OpenAI 内置工具列表："web_search"、"file_search"、"code_interpreter"、"computer_use"
• parse_tool_outputs：返回带已解析内置工具输出的结构化 ResponsesAPIResult
• auto_chain：自动跟踪并使用 response IDs 进行多轮对话
• auto_chain_reasoning：跟踪加密的 reasoning items，以满足 ZDR（ Zero Data Retention ）合规

建议：对于新项目，特别是在使用推理模型（ o1、o3、o4 ）或需要原生多模态支持 files 时，建议使用 Responses API 。

注意： 要使用 OpenAI，请安装所需依赖：

uv add "crewai[openai]"

Meta-Llama

CrewAI 通过 Meta 的 Llama API 提供对 Meta 大语言模型家族的访问能力。

# Meta Llama API Key 配置
LLAMA_API_KEY=LLM|your_api_key_here

示例：

from crewai import LLM
llm = LLM(
    model="meta_llama/Llama-4-Scout-17B-16E-Instruct-FP8",
    temperature=0.8,
    stop=["END"],
    seed=42
)

支持模型：

注意： 此 provider 使用 LiteLLM：

uv add 'crewai[litellm]'

Anthropic

CrewAI 通过 Anthropic Python SDK 提供对 Anthropic 的原生集成。

# 必填
ANTHROPIC_API_KEY=sk-ant-...

基础用法：

from crewai import LLM
llm = LLM(
    model="anthropic/claude-3-5-sonnet-20241022",
    api_key="your-api-key",  # 或设置 ANTHROPIC_API_KEY
    max_tokens=4096  # Anthropic 必填
)

高级配置：

from crewai import LLM
llm = LLM(
    model="anthropic/claude-3-5-sonnet-20241022",
    api_key="your-api-key",
    base_url="https://api.anthropic.com",  # 可选自定义 endpoint
    temperature=0.7,
    max_tokens=4096,  # 必填参数
    top_p=0.9,
    stop_sequences=["END", "STOP"],  # Anthropic 使用 stop_sequences
    stream=True,  # 启用流式输出
    timeout=60.0,  # 请求超时时间（秒）
    max_retries=3  # 最大重试次数
)

Extended Thinking（ Claude Sonnet 4 及更新版本 ）：

from crewai import LLM
llm = LLM(
    model="anthropic/claude-sonnet-4",
    thinking={"type": "enabled"},
    max_tokens=10000
)
llm = LLM(
    model="anthropic/claude-sonnet-4",
    thinking={
        "type": "enabled",
        "budget_tokens": 5000
    },
    max_tokens=10000
)

Thinking 配置选项：

• type：设置为 "enabled" 以启用 extended thinking 模式
• budget_tokens（可选）：thinking 可使用的最大 token 数

支持 Extended Thinking 的模型：

• claude-sonnet-4 及更新模型
• claude-3-7-sonnet

何时使用 Extended Thinking：

• 复杂推理与多步问题求解
• 数学计算与证明
• 代码分析与调试
• 战略规划与决策制定
• 研究与分析任务

支持的环境变量：

• ANTHROPIC_API_KEY：你的 Anthropic API key（必填）

特性：

• 针对 Claude 3+ 模型的原生工具使用支持
• 针对 Claude Sonnet 4+ 的 Extended Thinking 支持
• 支持实时流式响应
• 自动系统消息处理
• Stop sequences
• Token 用量追踪
• 多轮工具调用对话

重要说明：

• max_tokens 是所有 Anthropic 模型的 必填 参数
• Claude 使用 stop_sequences，而不是 stop
• 系统消息与对话消息分开处理
• 第一条消息必须来自用户
• 消息必须在 user 和 assistant 之间交替

支持的模型：

注意：

uv add "crewai[anthropic]"

Google（ Gemini API ）

CrewAI 通过 Google Gen AI Python SDK 提供对 Google Gemini 的原生集成。

# 必填（以下二选一）
GOOGLE_API_KEY=<your-api-key>
GEMINI_API_KEY=<your-api-key>
# 用于 Vertex AI Express mode（API key 认证）
GOOGLE_GENAI_USE_VERTEXAI=true
GOOGLE_API_KEY=<your-api-key>
# 用于带 service account 的 Vertex AI
GOOGLE_CLOUD_PROJECT=<your-project-id>
GOOGLE_CLOUD_LOCATION=<location>

基础用法：

from crewai import LLM
llm = LLM(
    model="gemini/gemini-2.0-flash",
    api_key="your-api-key",
    temperature=0.7
)

高级配置：

from crewai import LLM
llm = LLM(
    model="gemini/gemini-2.5-flash",
    api_key="your-api-key",
    temperature=0.7,
    top_p=0.9,
    top_k=40,
    max_output_tokens=8192,
    stop_sequences=["END", "STOP"],
    stream=True,
    safety_settings={
        "HARM_CATEGORY_HARASSMENT": "BLOCK_NONE",
        "HARM_CATEGORY_HATE_SPEECH": "BLOCK_NONE"
    }
)

Vertex AI Express Mode：

GOOGLE_GENAI_USE_VERTEXAI=true
GOOGLE_API_KEY=<your-api-key>

from crewai import LLM
llm = LLM(
    model="gemini/gemini-2.0-flash",
    temperature=0.7
)

Vertex AI（ Service Account ）：

from crewai import LLM
llm = LLM(
    model="gemini/gemini-1.5-pro",
    project="your-gcp-project-id",
    location="us-central1"
)

支持的环境变量：

• GOOGLE_API_KEY 或 GEMINI_API_KEY
• GOOGLE_GENAI_USE_VERTEXAI
• GOOGLE_CLOUD_PROJECT
• GOOGLE_CLOUD_LOCATION

特性：

• 针对 Gemini 1.5+ 和 2.x 模型的原生函数调用支持
• 支持实时流式响应
• 多模态能力（文本、图像、视频）
• Safety settings 配置
• 同时支持 Gemini API 与 Vertex AI
• 自动系统指令处理
• Token 用量追踪

Gemini 模型：

Gemma 模型：

注意：

uv add "crewai[google-genai]"

Google（ Vertex AI ）

import json
file_path = 'path/to/vertex_ai_service_account.json'
with open(file_path, 'r') as file:
    vertex_credentials = json.load(file)
vertex_credentials_json = json.dumps(vertex_credentials)

from crewai import LLM
llm = LLM(
    model="gemini-1.5-pro-latest",
    temperature=0.7,
    vertex_credentials=vertex_credentials_json
)

支持模型：

注意：

uv add 'crewai[litellm]'

Azure

CrewAI 通过 Azure AI Inference Python SDK 原生集成 Azure AI Inference 和 Azure OpenAI。

# 必填
AZURE_API_KEY=<your-api-key>
AZURE_ENDPOINT=<your-endpoint-url>
# 可选
AZURE_API_VERSION=<api-version>

Endpoint URL 格式：

Azure OpenAI deployments：

https://<resource-name>.openai.azure.com/openai/deployments/<deployment-name>

Azure AI Inference endpoints：

https://<resource-name>.inference.azure.com

基础用法：

llm = LLM(
    model="azure/gpt-4",
    api_key="<your-api-key>",
    endpoint="<your-endpoint-url>",
    api_version="2024-06-01"
)

高级配置：

llm = LLM(
    model="azure/gpt-4o",
    temperature=0.7,
    max_tokens=4000,
    top_p=0.9,
    frequency_penalty=0.0,
    presence_penalty=0.0,
    stop=["END"],
    stream=True,
    timeout=60.0,
    max_retries=3
)

支持的环境变量：

• AZURE_API_KEY
• AZURE_ENDPOINT
• AZURE_API_VERSION

特性：

• Azure OpenAI 模型的原生函数调用支持
• 支持实时流式响应
• 自动校验并修正 endpoint URL
• 带重试逻辑的全面错误处理
• Token 用量追踪

注意：

uv add "crewai[azure-ai-inference]"

AWS Bedrock

CrewAI 通过 boto3 SDK 使用 Converse API 原生集成 AWS Bedrock。

# 必填
AWS_ACCESS_KEY_ID=<your-access-key>
AWS_SECRET_ACCESS_KEY=<your-secret-key>
# 可选
AWS_SESSION_TOKEN=<your-session-token>
AWS_DEFAULT_REGION=<your-region>
AWS_REGION_NAME=<your-region>

基础用法：

from crewai import LLM
llm = LLM(
    model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
    region_name="us-east-1"
)

高级配置：

from crewai import LLM
llm = LLM(
    model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
    aws_access_key_id="your-access-key",
    aws_secret_access_key="your-secret-key",
    aws_session_token="your-session-token",
    region_name="us-east-1",
    temperature=0.7,
    max_tokens=4096,
    top_p=0.9,
    top_k=250,
    stop_sequences=["END", "STOP"],
    stream=True,
    guardrail_config={
        "guardrailIdentifier": "your-guardrail-id",
        "guardrailVersion": "1"
    },
    additional_model_request_fields={
        "top_k": 250
    }
)

支持的环境变量：

• AWS_ACCESS_KEY_ID
• AWS_SECRET_ACCESS_KEY
• AWS_SESSION_TOKEN
• AWS_DEFAULT_REGION
• AWS_REGION_NAME

特性：

• 通过 Converse API 提供原生工具调用支持
• 支持流式和非流式响应
• 带重试逻辑的全面错误处理
• guardrail 配置
• 模型专属参数
• Token 用量追踪
• 支持所有 Bedrock foundation models
• 自动处理对话格式

重要说明：

• 使用现代 Converse API
• 自动处理模型专属对话要求
• 系统消息与对话消息分开处理
• 第一条消息必须来自用户
• 某些模型要求对话必须以用户消息结束

其他 Provider 简表

Amazon SageMaker

AWS_ACCESS_KEY_ID=<your-access-key>
AWS_SECRET_ACCESS_KEY=<your-secret-key>
AWS_DEFAULT_REGION=<your-region>

llm = LLM(
    model="sagemaker/<my-endpoint>"
)

Mistral

MISTRAL_API_KEY=<your-api-key>

llm = LLM(
    model="mistral/mistral-large-latest",
    temperature=0.7
)

Nvidia NIM

NVIDIA_API_KEY=<your-api-key>

llm = LLM(
    model="nvidia_nim/meta/llama3-70b-instruct",
    temperature=0.7
)

Groq

GROQ_API_KEY=<your-api-key>

llm = LLM(
    model="groq/llama-3.2-90b-text-preview",
    temperature=0.7
)

IBM watsonx.ai

WATSONX_URL=<your-url>
WATSONX_APIKEY=<your-apikey>
WATSONX_PROJECT_ID=<your-project-id>

llm = LLM(
    model="watsonx/meta-llama/llama-3-1-70b-instruct",
    base_url="https://api.watsonx.ai/v1"
)

Ollama（本地 LLMs）

llm = LLM(
    model="ollama/llama3:70b",
    base_url="http://localhost:11434"
)

Fireworks AI

FIREWORKS_API_KEY=<your-api-key>

llm = LLM(
    model="fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct",
    temperature=0.7
)

Perplexity AI

PERPLEXITY_API_KEY=<your-api-key>

llm = LLM(
    model="llama-3.1-sonar-large-128k-online",
    base_url="https://api.perplexity.ai/"
)

Hugging Face

HF_TOKEN=<your-api-key>

llm = LLM(
    model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
)

SambaNova

SAMBANOVA_API_KEY=<your-api-key>

llm = LLM(
    model="sambanova/Meta-Llama-3.1-8B-Instruct",
    temperature=0.7
)

Cerebras

CEREBRAS_API_KEY=<your-api-key>

llm = LLM(
    model="cerebras/llama3.1-70b",
    temperature=0.7,
    max_tokens=8192
)

Open Router

OPENROUTER_API_KEY=<your-api-key>

llm = LLM(
    model="openrouter/deepseek/deepseek-r1",
    base_url="https://openrouter.ai/api/v1",
    api_key=OPENROUTER_API_KEY
)

Nebius AI Studio

NEBIUS_API_KEY=<your-api-key>

llm = LLM(
    model="nebius/Qwen/Qwen3-30B-A3B"
)

以上 provider 多数使用 LiteLLM，请添加依赖：

uv add 'crewai[litellm]'

流式响应

CrewAI 支持来自 LLM 的流式响应，使你的应用能够在响应生成过程中实时接收并处理输出。

基础设置

from crewai import LLM
llm = LLM(
    model="openai/gpt-4o",
    stream=True
)

启用流式输出后，响应会以分块形式逐步返回，从而带来更高的交互响应性。

事件处理

from crewai.events import (
  LLMStreamChunkEvent
)
from crewai.events import BaseEventListener
class MyCustomListener(BaseEventListener):
    def setup_listeners(self, crewai_event_bus):
        @crewai_event_bus.on(LLMStreamChunkEvent)
        def on_llm_stream_chunk(self, event: LLMStreamChunkEvent):
          print(f"Received chunk: {event.chunk}")
my_listener = MyCustomListener()

Agent 与 Task 追踪

from crewai import LLM, Agent, Task, Crew
from crewai.events import LLMStreamChunkEvent
from crewai.events import BaseEventListener
class MyCustomListener(BaseEventListener):
    def setup_listeners(self, crewai_event_bus):
        @crewai_event_bus.on(LLMStreamChunkEvent)
        def on_llm_stream_chunk(source, event):
            if researcher.id == event.agent_id:
                print("\n==============\n Got event:", event, "\n==============\n")
my_listener = MyCustomListener()
llm = LLM(model="gpt-4o-mini", temperature=0, stream=True)
researcher = Agent(
    role="About User",
    goal="You know everything about the user.",
    backstory="""You are a master at understanding people and their preferences.""",
    llm=llm,
)
search = Task(
    description="Answer the following questions about the user: {question}",
    expected_output="An answer to the question.",
    agent=researcher,
)
crew = Crew(agents=[researcher], tasks=[search])
result = crew.kickoff(
    inputs={"question": "..."}
)

适用场景：

• 调试特定 agent 的行为
• 按 task 类型记录 LLM 使用情况
• 审计哪些 agents 在发起何种类型的 LLM 调用
• 对特定任务进行性能监控

异步 LLM 调用

CrewAI 支持异步 LLM 调用，以提升 AI 工作流中的性能与并发能力。

基础用法

import asyncio
from crewai import LLM
async def main():
    llm = LLM(model="openai/gpt-4o")
    response = await llm.acall("What is the capital of France?")
    print(response)
asyncio.run(main())

结合 Streaming

import asyncio
from crewai import LLM
async def stream_async():
    llm = LLM(model="openai/gpt-4o", stream=True)
    response = await llm.acall("Write a short story about AI")
    print(response)
asyncio.run(stream_async())

结构化 LLM 调用

from crewai import LLM
class Dog(BaseModel):
    name: str
    age: int
    breed: str
llm = LLM(model="gpt-4o", response_format=Dog)
response = llm.call(
    "Analyze the following messages and return the name, age, and breed. "
    "Meet Kona! She is 3 years old and is a black german shepherd."
)
print(response)
# 输出：
# Dog(name='Kona', age=3, breed='black german shepherd')

高级特性与优化

上下文窗口管理

from crewai import LLM
llm = LLM(
    model="gpt-4",
    max_tokens=4000,
)

上下文管理最佳实践：

1. 选择具有合适上下文窗口的模型
2. 尽可能预处理长输入
3. 对大文档使用分块策略
4. 监控 token 用量以优化成本

性能优化

Token 用量优化

• 小型任务（最多 4K tokens ）：标准模型
• 中型任务（ 4K - 32K ）：增强型模型
• 大型任务（超过 32K ）：大上下文模型

llm = LLM(
    model="openai/gpt-4-turbo-preview",
    temperature=0.7,
    max_tokens=4096,
    timeout=300
)

提示：

• 更低的 temperature（ 0.1 到 0.3 ）适合事实性响应
• 更高的 temperature（ 0.7 到 0.9 ）适合创意任务

最佳实践

1. 监控 token 用量
2. 实现速率限制
3. 尽可能使用缓存
4. 设置合理的 max_tokens 限制

丢弃附加参数

from crewai import LLM
import os
os.environ["OPENAI_API_KEY"] = "<api-key>"
o3_llm = LLM(
    model="o3",
    drop_params=True,
    additional_drop_params=["stop"]
)

传输拦截器

支持的 Providers：

• OpenAI
• Anthropic

import httpx
from crewai import LLM
from crewai.llms.hooks import BaseInterceptor
class CustomInterceptor(BaseInterceptor[httpx.Request, httpx.Response]):
    """用于修改请求和响应的自定义拦截器。"""
    def on_outbound(self, request: httpx.Request) -> httpx.Request:
        print(request)
        return request
    def on_inbound(self, response: httpx.Response) -> httpx.Response:
        print(f"Status: {response.status_code}")
        print(f"Response time: {response.elapsed}")
        return response
llm = LLM(
    model="openai/gpt-4o",
    interceptor=CustomInterceptor()
)

重要说明：

• 两个方法都必须返回接收到的对象或对应类型对象
• 修改接收到的对象可能导致不可预期行为或应用崩溃
• 并非所有 provider 都支持拦截器

适用场景：

• 消息转换与过滤
• 调试 API 交互

常见问题与解决方案

认证

大多数认证问题都可以通过检查 API key 格式和环境变量名称来解决。

# OpenAI
OPENAI_API_KEY=sk-...
# Anthropic
ANTHROPIC_API_KEY=sk-ant-...

模型名称

始终在模型名称中包含 provider 前缀。

# 正确
llm = LLM(model="openai/gpt-4")
# 错误
llm = LLM(model="gpt-4")

上下文长度

对于大型任务，请使用更大上下文窗口的模型。

llm = LLM(model="openai/gpt-4o")  # 128K tokens