使用 Gemini 3.1 与 Google Cloud 构建多智能体 AI 系统：单个机器人 ->

以下内容为“利用 Gemini 3 和 Google Cloud 构建多智能体 AI 系统：从单一智能体到协同智能”这一主题提供的实用路径指引。重点在于契约、校验机制以及可直接插入的代码占位符，而非激励性陈述。

为何单一智能体不够用

在探讨“为何需要单一智能体”这一阶段时，首先需明确契约内容：所需输入、成功标志以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 在记录功能结果的同时，还需标注处理时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境过渡到共享环境时出现意外费用。 每次调用时都要记录请求 ID、模型 ID 以及延迟时间。若没有这些记录，偶尔出现的服务提供商错误就会被视为应用程序故障。

问题所在：单体式提示语无法扩展

在处理“问题单体提示”阶段时，首先写下相关规范：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。 将配置信息置于应用程序代码之外。环境文件、密钥存储以及功能开关应集中存放于一个位置，这样操作人员无需查看整个系统结构即可进行审计。 每次调用时都要记录请求ID、模型ID以及延迟时间。如果没有这些记录，间歇性的服务错误就会被视为应用程序的故障。

架构概览

在完成架构概览阶段时，首先写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。 同时记录正常流程和异常恢复流程。重试机制、人工审核环节以及死信处理都是产品本身的组成部分，而非后续需要补充的功能。 每次调用时都要记录请求ID、模型ID以及延迟时间。如果没有这些记录，间歇性的服务提供商错误就会被视为应用程序的缺陷。

步骤1：搭建代理开发工具包（30分钟）

在完成“第一步：设置环境”阶段时，首先写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。 建议使用小型、可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应指向单一的责任模块，而非复杂的流程链。 每次调用时都要记录请求ID、模型ID以及延迟时间。如果没有这些记录，间歇性的服务端错误就会被视为应用程序的缺陷。

pip install google-adk google-generativeai google-cloud-firestore pydantic

support_agents/
├── main.py              # Entry point for Cloud Run
├── common/
│   ├── __init__.py
│   └── schemas.py       # Shared Pydantic models (the "handshake")
├── agents/
│   ├── __init__.py
│   ├── orchestrator.py
│   ├── triage.py
│   ├── research.py
│   ├── action.py
│   └── qa.py
└── config.py            # Environment & project IDs

第二步：构建分类处理代理（30分钟）

在执行“构建阶段”的第二步时，首先需写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 将此阶段视为输入与验证后输出之间的契约。为相关产物命名，明确成功判定标准，杜绝无声的半完成状态。 每次调用时都要记录请求ID、模型ID以及延迟时间。如果没有这些记录，间歇性的服务端错误就会被视为应用程序的故障。 在执行“构建阶段”的第二步时，首先需写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 将配置信息置于应用程序代码之外。环境文件、密钥存储以及功能开关应集中存放于一个位置，以便操作人员无需查看整个系统结构即可进行审计。

# common/schemas.py
from pydantic import BaseModel, Field

class TriageResult(BaseModel):
    intents: list[str] = Field(description="List of detected customer goals")
    urgency: str = Field(pattern="^(low|medium|high|critical)quot;)
    sentiment: str = Field(description="Current emotional state of the user")
    required_agents: list[str] = Field(
        description="List of sub-agents needed (research, action, etc.)"
    )

# agents/triage.py
from google.adk.agents import LlmAgent
from common.schemas import TriageResult

triage_agent = LlmAgent(
    name="triage_agent",
    model="gemini-3.1-flash-lite",  # Fast and cheap for classification
    instruction="""You are a triage specialist. Analyze the customer's
    message and categorize it accurately.

    Urgency rules:
    - critical: Active outages or safety threats
    - high: Frustrated users or financial issues > $100
    - medium: Standard requests needing action
    - low: General info/feedback

    You must NOT attempt to solve the problem. Only classify it.""",
    output_schema=TriageResult,  # Force structured JSON output
    output_key="triage_data"
)

第3步：构建研究代理（30分钟）

将“构建”阶段视为可度量的对象来处理效果最佳。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。同时记录正常流程和恢复流程的文档。重试机制、人工审核环节以及死信处理都是产品的一部分，而非后续需要补充的内容。在讲解循环逻辑之前，先锁定解释器和依赖项的锁文件。笔记本电脑与持续集成环境之间的差异是API演示中最常见的隐性故障原因。

# common/schemas.py (add to existing file)

class ResearchBrief(BaseModel):
    order_status: str = Field(description="Current order state")
    customer_tier: str = Field(description="e.g. Gold, Standard")
    applicable_policy: str = Field(description="Relevant policy text")
    can_refund: bool = Field(description="Whether a refund is allowed")
    reasoning: str = Field(description="Why this conclusion was reached")

# agents/research.py
from google.adk.agents import LlmAgent
from google.cloud import firestore
from common.schemas import ResearchBrief

db = firestore.Client()

def lookup_order(order_id: str) -> dict:
    """Fetch real-time shipping status and line items for an order ID."""
    doc = db.collection('orders').document(order_id).get()
    if doc.exists:
        return doc.to_dict()
    return {"error": f"Order {order_id} not found"}

def lookup_customer(customer_id: str) -> dict:
    """Retrieve customer profile, tier, and interaction history."""
    doc = db.collection('customers').document(customer_id).get()
    if doc.exists:
        return doc.to_dict()
    return {"error": f"Customer {customer_id} not found"}

def search_knowledge_base(query: str) -> list:
    """Search product docs and company policies via RAG pipeline."""
    # Uses the RAG pipeline from our previous article
    from rag_pipeline import pipeline
    result = pipeline.query(query, top_k=5)
    return result['sources']

research_agent = LlmAgent(
    name="research_agent",
    model="gemini-3.1-flash",
    instruction="""You are a research specialist.
    1. Extract identifiers (Order ID, Customer ID) from the triage data.
    2. Use tools to gather order history and relevant company policies.
    3. If policy info is missing, use search_knowledge_base.

    CRITICAL: Do not answer the customer. Output a formal ResearchBrief.""",
    tools=[lookup_order, lookup_customer, search_knowledge_base],
    output_schema=ResearchBrief,
    output_key="research_brief"
)

第4步：构建动作代理（30分钟）

第4步“构建测试环境”若被视为可度量的对象，效果会更好。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。 优先选择小型且可测试的单元，而非庞大的脚本。当某一步骤失败时，故障应指向单一责任模块，而非复杂的流程链。 在讲解循环之前，先确定解释器及依赖项锁定文件的版本。在笔记本电脑与持续集成环境之间的差异是API演示中最常见的隐性故障原因。

# common/schemas.py (add to existing file)

class ActionSummary(BaseModel):
    actions_taken: list[str] = Field(description="List of actions executed")
    refund_id: str | None = Field(default=None, description="Refund ID if issued")
    escalated: bool = Field(default=False)
    escalation_reason: str | None = Field(default=None)

# agents/action.py
from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from common.schemas import ResearchBrief, ActionSummary

def process_refund(order_id: str, amount: float, reason: str) -> dict:
    """Process a financial refund. Required: valid order_id and amount."""
    # In production: call your payment API
    return {
        "status": "processed",
        "refund_id": f"REF-{order_id}",
        "amount": amount
    }

def create_replacement_order(
    order_id: str,
    item_id: str,
    shipping_speed: str
) -> dict:
    """Create a replacement order with specified shipping speed."""
    # In production: call your order management API
    return {
        "status": "created",
        "new_order_id": f"REPL-{order_id}",
        "estimated_delivery": "2 business days"
    }

def escalate_to_human(reason: str, priority: str) -> dict:
    """Escalate to a human agent with full context."""
    return {
        "status": "escalated",
        "queue": "priority" if priority == "high" else "standard"
    }

# Wrap refund tool with human confirmation for high-value transactions
refund_tool = FunctionTool(
    func=process_refund,
    require_confirmation=True  # Pauses for human approval before executing
)

action_agent = LlmAgent(
    name="action_agent",
    model="gemini-3.1-flash",
    instruction="""You are an action specialist.
    Review the 'research_brief' in the session state.

    CRITICAL RULES:
    1. Only refund if 'can_refund' is True in the research brief
    2. If amount > $500, you MUST use escalate_to_human
    3. You must call tools for every action — do not just tell the user
       it happened
    4. If information is missing from the brief, escalate""",
    tools=[refund_tool, create_replacement_order, escalate_to_human],
    input_schema=ResearchBrief,   # Only sees research data, not raw chat
    output_schema=ActionSummary,
    output_key="action_result"
)

第5步：构建QA代理（30分钟）

将第5步“构建阶段”视为可度量的对象来处理效果最佳。在扩大范围之前，需记录一份理想运行案例、一个故障案例以及回滚说明。 应将此阶段视为输入与已验证输出之间的契约。为相关成果命名，明确成功标准，绝不允许出现悄无声息的半完成状态。 在讲解循环逻辑之前，先锁定解释器及依赖项。在笔记本电脑与持续集成环境之间切换是API演示中最常见的隐性故障来源。 将第5步“构建阶段”视为可度量的对象来处理效果最佳。在扩大范围之前，需记录一份理想运行案例、一个故障案例以及回滚说明。 应将配置信息置于应用程序代码之外。环境文件、密钥存储及功能开关应集中存放于一处，以便操作人员无需查看整个系统结构即可进行审计。

# common/schemas.py (add to existing file)

class QAReview(BaseModel):
    is_approved: bool = Field(description="True if the response meets all criteria")
    feedback: str = Field(description="Specific corrections if not approved")
    final_text: str = Field(description="The customer-facing message")

# agents/qa.py
from google.adk.agents import LlmAgent
from google.adk.planners import BuiltInPlanner
from google.genai.types import ThinkingConfig
from common.schemas import QAReview

qa_agent = LlmAgent(
    name="qa_agent",
    model="gemini-3.1-pro",
    instruction="""You are a senior QA auditor. Compare the 'action_result'
    against the 'research_brief' in the session state.

    CRITICAL CHECKS:
    1. Did the Action Agent refund the EXACT amount listed in the brief?
    2. Does the response cite the policy found during research?
    3. Is the tone empathetic but professional?
    4. Are ALL intents from the triage classification addressed?
    5. No unauthorized promises, discounts, or policy exceptions

    If any check fails, set is_approved to False with specific feedback.""",
    output_schema=QAReview,
    output_key="qa_review",
    # MEDIUM for routine QA; switch to HIGH for edge cases or audits
    planner=BuiltInPlanner(
        thinking_config=ThinkingConfig(thinking_level="MEDIUM")
    )
)

第6步：协调器——整合所有组件（1小时）

在第6步的协调器阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 需同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及死信处理都是产品本身的组成部分，而非后续需要补充的功能。 应将客户端构建与消息循环分开，这样在更换服务提供商时无需重写对话状态机。

# agents/orchestrator.py
from google.adk.agents import LlmAgent
from agents.triage import triage_agent
from agents.research import research_agent
from agents.action import action_agent
from agents.qa import qa_agent

orchestrator = LlmAgent(
    name="support_orchestrator",
    model="gemini-3.1-pro",  # Best reasoning for delegation decisions
    instruction="""You are the lead coordinator of a customer support team.
    Use the following specialists in order:
    1. triage_agent: to classify the intent and urgency
    2. research_agent: to gather order data and relevant policies
    3. action_agent: to execute the required operations
    4. qa_agent: to verify the final response

    Special cases:
    - If triage classifies as 'critical': bypass the chain and escalate
    - If QA returns is_approved=False: re-route to the responsible agent
      with the feedback (maximum 2 revision cycles, then escalate)
    - If any agent fails: escalate to human with full context

    You must never respond to the customer directly.
    Always route through the specialist pipeline.""",
    sub_agents=[triage_agent, research_agent, action_agent, qa_agent]
)

运行协调器

在“运行调度器”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及终止条件。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 优先选择小型、可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应指向单一的责任模块，而非复杂的流程链。 将客户端构建逻辑与消息处理循环分开，这样就可以更换提供方，而无需重写对话状态机。

# main.py
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from agents.orchestrator import orchestrator

APP_NAME = "customer_support"
USER_ID = "system"

# For production, replace with a Firestore-backed session service
session_service = InMemorySessionService()

runner = Runner(
    agent=orchestrator,
    app_name=APP_NAME,
    session_service=session_service
)

async def handle_customer_message(customer_id: str, message: str):
    """
    Entry point for customer messages.
    """
    session_id = f"support-{customer_id}"

    # Ensure session exists
    session = await session_service.get_session(
        app_name=APP_NAME, user_id=USER_ID, session_id=session_id
    )
    if not session:
        session = await session_service.create_session(
            app_name=APP_NAME, user_id=USER_ID, session_id=session_id
        )

    # run_async yields events as agents execute
    final_response = None
    async for event in runner.run_async(
        user_id=USER_ID,
        session_id=session_id,
        new_message=message
    ):
        if event.is_final_response():
            final_response = event

    return {
        "response": final_response.content.parts[0].text if final_response else None,
        "session_id": session_id
    }

第7步：部署到生产环境（30分钟）

在第七步“部署到测试环境”中，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 将此阶段视为输入与已验证输出之间的契约。为相关工件命名，定义成功检测标准，并拒绝默许的半完成状态。 将客户端构建与消息处理循环分开，这样即便更换提供方也不必重写对话状态机。 在第七步“部署到测试环境”中，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 将配置信息置于应用程序代码之外。环境文件、密钥存储以及功能开关应集中存放于一个操作人员可审计的位置，无需查看整个系统结构。

选项A：Vertex AI Agent Engine（推荐）

在采用选项A的Vertex AI方案时，首先需明确相关约定：所需输入参数、成功标志以及部分失败时的处理方式。这样的清单能确保后续代码修改的规范性。 同时记录正常流程与异常恢复路径。重试机制、人工审核环节以及错误消息处理都是产品本身的一部分，而非后续需要补充的功能。 每次调用时都要记录请求ID、模型ID以及响应延迟时间。如果没有这些记录，间歇性的服务错误就会被视为应用程序的缺陷。

PROJECT_ID=your-project-id
LOCATION_ID=us-central1

adk deploy agent_engine \
  --project=$PROJECT_ID \
  --region=$LOCATION_ID \
  --display_name="Customer Support Team" \
  support_agents

选项B：Cloud Run（自定义控制）

在处理选项B的Cloud Run阶段时，首先写下相关约定：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 优先选择小型且可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应能指向单一的责任模块，而非复杂的流程链。 每次调用时都要记录请求ID、模型ID以及延迟时间。如果没有这些记录，间歇性的服务错误就会被视为应用程序的缺陷。

# server.py
from quart import Quart, request, jsonify
from main import handle_customer_message

app = Quart(__name__)

@app.route("/support", methods=["POST"])
async def support():
    data = await request.get_json()
    # No asyncio.run needed — Quart handles the event loop
    result = await handle_customer_message(
        data["customer_id"],
        data["message"]
    )
    return jsonify(result)

@app.route("/health", methods=["GET"])
async def health():
    return jsonify({"status": "healthy"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

# Dockerfile
FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .
EXPOSE 8080

CMD ["python", "server.py"]

gcloud run deploy support-agents \
  --source . \
  --region us-central1 \
  --memory 4Gi \
  --cpu 2 \
  --allow-unauthenticated

你应该选择哪一个？

在“应选择哪一个”这一阶段，首先需明确合同条款：所需输入、成功标志以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持透明可溯。 将这一阶段视为输入与验证后输出之间的契约。为相关产物命名，定义成功检测标准，并杜绝默许的部分完成情况。 每次调用时都要记录请求ID、模型ID以及延迟时间。若没有这些记录，间歇性的服务端错误就会被视为应用程序的故障。 在“应选择哪一个”这一阶段，首先需明确合同条款：所需输入、成功标志以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持透明可溯。 将配置信息置于应用程序代码之外。环境文件、密钥存储以及功能开关应集中存放于一个位置，以便操作人员无需查看整个系统结构即可进行审计。

第8步：多轮对话的持久会话（30分钟）

将第8步的持久会话阶段视为可度量的测试对象最为有效。在扩大范围之前，需记录一份理想的操作日志、一个失败案例以及回滚说明。同时文档化正常流程与故障恢复路径。重试机制、人工干预环节以及死信处理都是产品功能的一部分，而非后续需要补充的内容。在讲解循环逻辑之前，需先锁定解释器及相关依赖文件。笔记本电脑与持续集成环境之间的差异是API演示中最常见的隐性故障原因。

选项A：Vertex AI会话服务（推荐与Agent Engine搭配使用）

将选项A的Vertex AI阶段视为可测量的实体来使用效果最佳。在扩大范围之前，先记录一份理想的运行结果、一个故障案例以及回滚说明。 相较于庞大的脚本，应优先选择小型且可测试的单元。当某一步骤出现故障时，故障原因应能明确指向某个特定责任方，而非复杂的流程链。 在讲解循环逻辑之前，先固定解释器及依赖项的锁定文件。笔记本电脑与持续集成环境之间的差异是API演示中最常见的隐性故障来源。

# config.py
from google.adk.sessions import VertexAiSessionService

session_service = VertexAiSessionService(
    project="your-project-id",
    location="us-central1",
    agent_engine_id="your-agent-engine-id"  # From adk deploy output
)

选项B：数据库会话服务（适用于Cloud Run部署）

将选项B的数据库会话阶段视为可度量的对象来处理，效果最佳。在扩大范围之前，需记录一份完美的操作日志、一个故障案例以及回滚说明。 应将此阶段视为输入与经过验证的输出之间的契约。为相关文档命名，明确成功标准，绝不允许出现无声的半完成状态。 在讲解循环逻辑之前，先锁定解释器及依赖项。在笔记本电脑与持续集成环境之间切换是API演示中最常见的无声故障诱因。 将选项B的数据库会话阶段视为可度量的对象来处理，效果最佳。在扩大范围之前，需记录一份完美的操作日志、一个故障案例以及回滚说明。 应将配置信息置于应用程序代码之外。环境文件、密钥存储及功能开关应集中存放于一个位置，以便操作人员无需查看整个系统结构即可进行审计。

# config.py
from google.adk.sessions import DatabaseSessionService

# PostgreSQL for production
session_service = DatabaseSessionService(
    db_url="postgresql+asyncpg://user:pass@host:5432/agents"
)

# Or SQLite for development
session_service = DatabaseSessionService(
    db_url="sqlite+aiosqlite:///sessions.db"
)

状态如何在智能体之间传递

在“状态如何流转”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及退出标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 需同时记录正常流程和异常恢复流程。重试机制、人工审核环节以及死信处理都是产品本身的组成部分，而非后续需要补充的功能。 应将客户端构建逻辑与消息循环分离，这样在更换提供方时无需重写对话状态机。

triage_agent (output_key="triage_data")
    ↓ writes to session.state["triage_data"]
research_agent (reads triage_data, output_key="research_brief")
    ↓ writes to session.state["research_brief"]
action_agent (input_schema=ResearchBrief, output_key="action_result")
    ↓ writes to session.state["action_result"]
qa_agent (reads action_result + research_brief, output_key="qa_review")

内存设计原则

在内存设计原则阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比冗长的脚本，更应采用小型且可测试的单元。当某个步骤失败时，故障原因应能指向单一责任模块，而非复杂的流程链。应将客户端构建逻辑与消息循环分开，这样在更换提供者时无需重写对话状态机。

多智能体为何优于单智能体（以及何时不适用）

在“多智能体战胜单智能体”阶段，修改代码之前需先明确输入参数、该步骤的负责人以及终止条件。操作员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 将此阶段视为输入与已验证输出之间的契约。为相关产物命名，定义成功判定标准，并拒绝默许的半完成状态。 将客户端构建逻辑与消息循环分离，这样即便更换提供方也不必重写对话状态机。 在“多智能体战胜单智能体”阶段，修改代码之前需先明确输入参数、该步骤的负责人以及终止条件。操作员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 将配置信息置于应用程序代码之外。环境文件、密钥存储以及功能开关应集中存放于操作员可审计的位置，且不得随意更改。

浏览整个图表。

常见陷阱与解决方案

在处理“常见陷阱与解决方案”这一阶段时，首先写下相关约定：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 同时记录正常流程和异常恢复流程。重试机制、人工审核环节以及死信处理都是产品功能的一部分，而非后续需要补充的内容。 每次调用时都要记录请求ID、模型ID以及延迟时间。如果没有这些记录，间歇性的服务错误就会被视为应用程序的缺陷。

性能预期

在处理性能预期阶段时，首先写下相关约定：所需的输入参数、成功标志以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 建议使用小型、可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应能指向单一责任模块，而非复杂的流程链。 每次调用时都要记录请求ID、模型ID以及延迟时间。没有这些记录，间歇性的服务错误就会被视为应用程序的缺陷。

每月大致成本（10万次复杂查询/月）

在处理“每月成本约10万”阶段时，首先需明确合同条款：所需输入、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改始终符合约定。 将此阶段视为输入与验证后输出之间的契约。为相关产物命名，定义成功检测标准，杜绝默许的半完成状态。 每次调用时都要记录请求ID、模型ID及延迟时间。若没有这些记录，间歇性的服务错误就会被视为应用程序的缺陷。 在处理“每月成本约10万”阶段时，首先需明确合同条款：所需输入、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改始终符合约定。 将配置信息置于应用程序代码之外。环境文件、密钥存储及功能开关应集中存放于一处，以便操作人员无需查看整个系统结构即可进行审计。

下一步是什么

“下一步计划”阶段若被视为可度量的目标面，效果会最佳。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。同时将正常流程与恢复流程都记录下来。重试机制、人工审核环节以及死信处理都是产品本身的组成部分，而非后续需要补充的内容。在讲解循环逻辑之前，先锁定解释器及依赖项的锁文件。笔记本电脑与持续集成环境之间的差异是API演示中最常见的隐性故障原因。

结论

在“结论”阶段，若将其视为可度量的对象来处理效果最佳。在扩大范围之前，先记录一份优秀的测试案例、一个失败案例以及回滚说明。相比庞大的脚本，应优先选择小型且可测试的单元。当某一步骤失败时，故障应能指向单一责任点，而非复杂的流程链。在讲解循环之前，先确定解释器及依赖项的锁定文件。在笔记本电脑与持续集成环境之间的差异是API演示中最常见的隐性故障原因。

操作检查清单

在“操作检查清单”阶段，修改代码之前需明确输入内容、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏的状态。

在功能结果旁记录执行时间以及令牌或查询成本。提前显示成本可避免在从演示环境切换到共享环境时出现意外账单。

将客户端构建与消息循环分开，这样无需重写对话状态机即可更换服务提供商。

在成本较高的步骤之后设置检查点。当操作员重新尝试后续节点时，恢复流程不应再次对同一次大语言模型调用收费。

锁定依赖版本，并记录用于演示的图像摘要。可重复性比经验知识更为可靠。

优先选择小型、可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应能指向单一责任模块，而非复杂的流程链。

在推广该技术栈之前，应先冻结版本，为关键流程记录标准输出日志，并明确回滚步骤。共享环境需要设置速率限制、租户验证机制，以及负责密钥轮换的明确责任人。与其展示花哨的一次性演示，不如注重扎实的可靠性。

关于 dc0c111e30e7 的批量说明：请将提供商密钥移出代码仓库，设定单会话令牌上限，并将日志存储在评估用示例文件旁，以便后续模型更换时保持数据可比性。