Agent开发基础¶

⚠️ 时效性说明：本章涉及前沿模型/价格/榜单等信息，可能随版本快速变化；请以论文原文、官方发布页和 API 文档为准。

📌 定位说明：本章从框架使用视角讲解Agent开发（LangChain/LangGraph等）。 - 动手实践（手写Agent框架、从零编码）→ AI Agent开发实战/01-Agent基础与架构 - 研究前沿（智能体系统最新进展）→ LLM学习/04-前沿探索/02-智能体系统

📖 章节导读¶

AI Agent是能够自主感知环境、做出决策并执行行动的智能系统。本章将深入探讨Agent的核心概念、架构设计和开发方法。

🎯 学习目标¶

理解Agent的核心概念和原理
掌握Agent的架构设计方法
学会开发基础的Agent系统
了解Agent的应用场景
掌握大厂面试中的相关问题

7.1 Agent概述¶

7.1.1 什么是Agent¶

定义:Agent(AI智能体)是能够自主感知环境、推理决策并执行行动以实现目标的智能系统。

核心特征:

自主性:能够自主做出决策
感知能力:能够感知环境和状态
推理能力:能够进行推理和规划
行动能力:能够执行具体行动
学习能力:能够从经验中学习

Agent vs 传统程序:

特性	Agent	传统程序
决策方式	自主决策	预设规则
适应性	强	弱
学习能力	有	无
复杂性	高	低
应用场景	复杂任务	简单任务

7.1.2 Agent的发展历程¶

关键里程碑:

早期(1950s-1980s): - 符号AI:基于规则的Agent - 专家系统:领域知识Agent - 有限能力,固定规则

中期(1990s-2010s): - 强化学习Agent:通过学习优化 - 多Agent系统:协作与竞争 - 能力提升,但仍有局限

现代(2020s-至今): - 大模型Agent:基于大语言模型 - 通用Agent:跨领域应用 - 强大的推理和规划能力

7.1.3 Agent的类型¶

按功能分类:

反应型Agent:
基于当前状态直接行动
无内部状态
简单快速
基于模型的Agent:
维护内部世界模型
基于模型预测和规划
更智能
基于目标的Agent:
有明确的目标
规划实现目标的路径
目标驱动
基于效用的Agent:
有效用函数
最大化期望效用
最优决策

按应用分类:

对话Agent:ChatGPT、Claude
任务Agent:AutoGPT、BabyAGI
推荐Agent:个性化推荐
游戏Agent:游戏AI
机器人Agent:物理机器人

7.2 Agent架构¶

7.2.1 基础架构¶

核心组件:

Text Only

感知 → 推理 → 规划 → 行动 → 反馈

详细架构:

感知模块:
输入接收
信息处理
状态更新
推理模块:
上下文理解
逻辑推理
决策制定
规划模块:
目标分解
任务规划
行动序列
执行模块:
工具调用
行动执行
结果反馈
记忆模块:
短期记忆
长期记忆
知识库

代码实现:

Python

from typing import Any
from abc import ABC, abstractmethod

class BaseAgent(ABC):  # ABC抽象基类，定义接口规范
    """基础Agent类"""

    def __init__(self, name: str):
        """
        初始化Agent

        Args:
            name: Agent名称
        """
        self.name = name
        self.memory = {}
        self.tools = {}

    @abstractmethod  # @abstractmethod子类必须实现此方法
    def perceive(self, input_data: dict) -> dict:
        """
        感知环境

        Args:
            input_data: 输入数据

        Returns:
            感知结果
        """
        pass

    @abstractmethod
    def reason(self, perception: dict) -> dict:
        """
        推理决策

        Args:
            perception: 感知结果

        Returns:
            推理结果
        """
        pass

    @abstractmethod
    def plan(self, reasoning: dict) -> list[dict]:
        """
        规划行动

        Args:
            reasoning: 推理结果

        Returns:
            行动计划
        """
        pass

    @abstractmethod
    def act(self, action: dict) -> dict:
        """
        执行行动

        Args:
            action: 行动

        Returns:
            执行结果
        """
        pass

    def run(self, input_data: dict) -> dict:
        """
        运行Agent

        Args:
            input_data: 输入数据

        Returns:
            执行结果
        """
        # 感知
        perception = self.perceive(input_data)

        # 推理
        reasoning = self.reason(perception)

        # 规划
        plan = self.plan(reasoning)

        # 执行
        results = []
        for action in plan:
            result = self.act(action)
            results.append(result)

        return {
            'perception': perception,
            'reasoning': reasoning,
            'plan': plan,
            'results': results
        }

7.2.2 LangChain Agent¶

简介:LangChain提供了强大的Agent框架,简化了Agent开发。

核心组件:

LLM:大语言模型
Tools:工具集合
Agent:Agent逻辑
Chain:执行链

代码实现:

Python

from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.tools import Tool
from langchain_openai import ChatOpenAI
from langchain_community.utilities import SerpAPIWrapper
from langchain_core.prompts import ChatPromptTemplate

class LangChainAgent:
    """LangChain Agent（使用 create_react_agent，替代已弃用的 initialize_agent）"""

    def __init__(self, api_key: str, tools: list[Tool]):
        """
        初始化Agent

        Args:
            api_key: OpenAI API密钥
            tools: 工具列表
        """
        self.llm = ChatOpenAI(
            model_name="gpt-4o",
            temperature=0,
            openai_api_key=api_key
        )

        # 构建ReAct提示模板
        prompt = ChatPromptTemplate.from_messages([
            ("system", "你是一个有用的AI助手。请按照ReAct模式（思考→行动→观察）来解决问题。\n\n"
                       "你可以使用以下工具:\n{tools}\n\n工具名: {tool_names}\n\n"
                       "Use the following format:\n"
                       "Thought: 思考下一步\nAction: 工具名\nAction Input: 工具输入\n"
                       "Observation: 工具输出\n... (可重复)\nThought: 我现在知道最终答案了\n"
                       "Final Answer: 最终答案"),
            ("human", "{input}\n\n{agent_scratchpad}"),
        ])

        agent = create_react_agent(self.llm, tools, prompt)
        self.agent_executor = AgentExecutor(
            agent=agent, tools=tools, verbose=True
        )

    def run(self, task: str) -> str:
        """
        运行Agent

        Args:
            task: 任务描述

        Returns:
            执行结果
        """
        result = self.agent_executor.invoke({"input": task})
        return result["output"]

# 使用示例
# 创建工具
search = SerpAPIWrapper()
search_tool = Tool(
    name="Search",
    func=search.run,
    description="用于搜索最新信息"
)

# 创建Agent
# agent = LangChainAgent("your-api-key", [search_tool])
#
# # 运行任务
# result = agent.run("搜索最新的AI技术进展")
# print(result)

7.2.3 自定义Agent¶

设计原则:

模块化:将功能分解为独立模块
可扩展:易于添加新功能
可配置:支持灵活配置
可测试:易于测试和调试

代码实现:

Python

import time
from openai import OpenAI

class CustomAgent:
    """自定义Agent"""

    def __init__(self, name: str, llm_client):
        """
        初始化Agent

        Args:
            name: Agent名称
            llm_client: LLM客户端
        """
        self.name = name
        self.llm_client = llm_client
        self.memory = []
        self.tools = {}

    def add_tool(self, name: str, func: callable, description: str):
        """
        添加工具

        Args:
            name: 工具名称
            func: 工具函数
            description: 工具描述
        """
        self.tools[name] = {
            'func': func,
            'description': description
        }

    def perceive(self, input_data: dict) -> dict:
        """
        感知环境
        """
        perception = {
            'input': input_data,
            'timestamp': time.time(),
            'context': self.memory[-5:] if self.memory else []
        }
        return perception

    def reason(self, perception: dict) -> dict:
        """
        推理决策
        """
        # 构建推理Prompt
        tools_info = "\n".join([
            f"- {name}: {info['description']}"
            for name, info in self.tools.items()
        ])

        prompt = f"""
你是一个智能Agent,名为{self.name}。

可用工具:
{tools_info}

当前任务: {perception['input']['task']}

上下文:
{perception['context']}

请分析任务,决定需要使用哪些工具,以及如何使用。
"""

        response = self.llm_client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )

        reasoning = response.choices[0].message.content

        return {
            'reasoning': reasoning,
            'tools_needed': self._extract_tools(reasoning)
        }

    def _extract_tools(self, reasoning: str) -> list[str]:
        """从推理中提取需要的工具"""
        import re
        tools = re.findall(r'使用\s*(\w+)', reasoning)  # re.findall正则查找所有匹配项
        return tools

    def plan(self, reasoning: dict) -> list[dict]:
        """
        规划行动
        """
        plan = []
        for tool_name in reasoning['tools_needed']:
            if tool_name in self.tools:
                plan.append({
                    'tool': tool_name,
                    'action': 'call_tool',
                    'params': {}
                })
        return plan

    def act(self, action: dict) -> dict:
        """
        执行行动
        """
        tool_name = action['tool']
        if tool_name in self.tools:
            tool_func = self.tools[tool_name]['func']
            result = tool_func(**action.get('params', {}))

            # 记录到记忆
            self.memory.append({
                'tool': tool_name,
                'result': result,
                'timestamp': time.time()
            })

            return {
                'success': True,
                'result': result
            }
        else:
            return {
                'success': False,
                'error': f'Tool {tool_name} not found'
            }

    def run(self, task: str) -> dict:
        """
        运行Agent
        """
        input_data = {'task': task}

        # 感知
        perception = self.perceive(input_data)

        # 推理
        reasoning = self.reason(perception)

        # 规划
        plan = self.plan(reasoning)

        # 执行
        results = []
        for action in plan:
            result = self.act(action)
            results.append(result)

        return {
            'task': task,
            'perception': perception,
            'reasoning': reasoning,
            'plan': plan,
            'results': results
        }

# 使用示例
# 创建LLM客户端
llm_client = OpenAI(api_key="your-api-key")

# 创建Agent
agent = CustomAgent("助手", llm_client)

# 添加工具
def search_tool(query: str) -> str:
    """搜索工具"""
    return f"搜索结果: {query}"

def calculator_tool(expression: str) -> float:
    """计算器工具（使用AST安全解析）"""
    import ast
    tree = ast.parse(expression, mode='eval')
    for node in ast.walk(tree):
        if not isinstance(node, (ast.Expression, ast.BinOp, ast.UnaryOp,  # isinstance检查类型
                                ast.Constant, ast.Add, ast.Sub, ast.Mult,
                                ast.Div, ast.Mod, ast.Pow, ast.USub)):
            raise ValueError(f"不允许的表达式: {expression}")
    return eval(compile(tree, '<expr>', 'eval'), {"__builtins__": {}}, {})

agent.add_tool("search", search_tool, "用于搜索信息")
agent.add_tool("calculator", calculator_tool, "用于数学计算")

# 运行任务
result = agent.run("计算 2 + 3 * 4")
print(result)

7.3 Agent工具¶

7.3.1 工具类型¶

常用工具:

搜索工具:
网络搜索
知识库搜索
文档搜索
计算工具:
数学计算
数据分析
统计分析
API工具:
天气API
股票API
新闻API
文件工具:
文件读写
文件处理
文件转换
数据库工具:
数据库查询
数据库更新
数据分析

7.3.2 工具开发¶

设计原则:

单一职责:每个工具只做一件事
清晰接口:接口清晰易用
错误处理:完善的错误处理
文档完整:提供完整文档

代码实现:

Python

from typing import Any
from abc import ABC, abstractmethod

class BaseTool(ABC):
    """基础工具类"""

    def __init__(self, name: str, description: str):
        """
        初始化工具

        Args:
            name: 工具名称
            description: 工具描述
        """
        self.name = name
        self.description = description

    @abstractmethod
    def run(self, **kwargs) -> Any:  # **kwargs收集关键字参数
        """
        运行工具

        Args:
            **kwargs: 参数

        Returns:
            执行结果
        """
        pass

    def __call__(self, **kwargs) -> Any:  # __call__魔术方法：使实例可像函数一样调用，tool(...)等价于tool.run(...)
        """调用工具"""
        return self.run(**kwargs)  # **kwargs将收集的关键字参数解包后传给run方法

class SearchTool(BaseTool):
    """搜索工具"""

    def __init__(self):
        super().__init__(  # super()调用父类方法
            name="search",
            description="用于搜索网络信息"
        )

    def run(self, query: str, num_results: int = 5) -> list:
        """
        搜索

        Args:
            query: 搜索查询
            num_results: 返回结果数量

        Returns:
            搜索结果列表
        """
        # 这里简化处理,实际应该调用搜索API
        results = [
            {
                'title': f'结果{i+1}',
                'url': f'https://example.com/{i+1}',
                'snippet': f'关于"{query}"的搜索结果{i+1}'
            }
            for i in range(num_results)
        ]
        return results

class CalculatorTool(BaseTool):
    """计算器工具"""

    def __init__(self):
        super().__init__(
            name="calculator",
            description="用于数学计算"
        )

    def run(self, expression: str) -> float:
        """
        计算（使用AST安全解析）

        Args:
            expression: 数学表达式

        Returns:
            计算结果
        """
        import ast
        try:  # try/except捕获异常，防止程序崩溃
            tree = ast.parse(expression, mode='eval')
            for node in ast.walk(tree):
                if not isinstance(node, (ast.Expression, ast.BinOp, ast.UnaryOp,
                                        ast.Constant, ast.Add, ast.Sub, ast.Mult,
                                        ast.Div, ast.Mod, ast.Pow, ast.USub)):
                    raise ValueError(f"不允许的表达式: {expression}")
            result = eval(compile(tree, '<expr>', 'eval'), {"__builtins__": {}}, {})
            return float(result)
        except Exception as e:
            raise ValueError(f"计算错误: {str(e)}")

class WeatherTool(BaseTool):
    """天气工具"""

    def __init__(self, api_key: str):
        super().__init__(
            name="weather",
            description="用于查询天气信息"
        )
        self.api_key = api_key

    def run(self, city: str) -> dict:
        """
        查询天气

        Args:
            city: 城市名称

        Returns:
            天气信息
        """
        # 这里简化处理,实际应该调用天气API
        return {
            'city': city,
            'temperature': 25,
            'condition': '晴',
            'humidity': 60
        }

# 使用示例
search_tool = SearchTool()
calculator_tool = CalculatorTool()
weather_tool = WeatherTool("your-api-key")

# 使用工具
results = search_tool(query="AI技术", num_results=3)
print("搜索结果:", results)

result = calculator_tool(expression="2 + 3 * 4")
print("计算结果:", result)

weather = weather_tool(city="北京")
print("天气信息:", weather)

7.4 Agent应用¶

7.4.1 对话Agent¶

需求:构建一个能够进行多轮对话的Agent。

实现:

Python

class ConversationalAgent:
    """对话Agent"""

    def __init__(self, llm_client, system_prompt: str = None):
        """
        初始化对话Agent

        Args:
            llm_client: LLM客户端
            system_prompt: 系统提示
        """
        self.llm_client = llm_client
        self.system_prompt = system_prompt or "你是一个友好的助手。"
        self.conversation_history = []

    def chat(self, user_message: str) -> str:
        """
        对话

        Args:
            user_message: 用户消息

        Returns:
            Agent回复
        """
        # 添加用户消息到历史
        self.conversation_history.append({
            'role': 'user',
            'content': user_message
        })

        # 构建消息列表
        messages = [
            {'role': 'system', 'content': self.system_prompt}
        ] + self.conversation_history

        # 调用LLM
        response = self.llm_client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            temperature=0.7
        )

        assistant_message = response.choices[0].message.content

        # 添加助手消息到历史
        self.conversation_history.append({
            'role': 'assistant',
            'content': assistant_message
        })

        return assistant_message

    def reset(self):
        """重置对话"""
        self.conversation_history = []

# 使用示例
from openai import OpenAI

llm_client = OpenAI(api_key="your-api-key")
agent = ConversationalAgent(
    llm_client,
    system_prompt="你是一个专业的AI助手,擅长回答技术问题。"
)

# 对话
while True:
    user_input = input("用户: ")
    if user_input.lower() in ['exit', 'quit']:
        break

    response = agent.chat(user_input)
    print(f"助手: {response}")

7.4.2 任务Agent¶

需求:构建一个能够执行复杂任务的Agent。

实现:

Python

class TaskAgent:
    """任务Agent"""

    def __init__(self, llm_client, tools: dict[str, BaseTool]):
        """
        初始化任务Agent

        Args:
            llm_client: LLM客户端
            tools: 工具字典
        """
        self.llm_client = llm_client
        self.tools = tools
        self.task_queue = []

    def add_task(self, task: str):
        """
        添加任务

        Args:
            task: 任务描述
        """
        self.task_queue.append(task)

    def plan_tasks(self, tasks: list[str]) -> list[dict]:
        """
        规划任务

        Args:
            tasks: 任务列表

        Returns:
            任务计划
        """
        tools_info = "\n".join([
            f"- {name}: {tool.description}"
            for name, tool in self.tools.items()
        ])

        prompt = f"""
你是一个任务规划专家。请为以下任务制定执行计划。

可用工具:
{tools_info}

任务列表:
{chr(10).join(f"{i+1}. {task}" for i, task in enumerate(tasks))}

请为每个任务指定需要使用的工具,并说明执行顺序。
"""

        response = self.llm_client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )

        plan = response.choices[0].message.content
        return self._parse_plan(plan)

    def _parse_plan(self, plan_text: str) -> list[dict]:
        """解析计划"""
        # 这里简化处理
        import re
        tasks = re.findall(r'(\d+)\.\s*(.+)', plan_text)
        return [
            {
                'task_id': int(task_id),
                'task': task,
                'status': 'pending'
            }
            for task_id, task in tasks
        ]

    def execute_task(self, task: dict) -> dict:
        """
        执行任务

        Args:
            task: 任务信息

        Returns:
            执行结果
        """
        # 这里简化处理,实际应该根据任务选择合适的工具
        return {
            'task': task,
            'status': 'completed',
            'result': f"完成任务: {task['task']}"
        }

    def run(self) -> list[dict]:
        """
        运行所有任务

        Returns:
            执行结果列表
        """
        if not self.task_queue:
            return []

        # 规划任务
        plan = self.plan_tasks(self.task_queue)

        # 执行任务
        results = []
        for task in plan:
            result = self.execute_task(task)
            results.append(result)

        return results

# 使用示例
tools = {
    'search': SearchTool(),
    'calculator': CalculatorTool(),
    'weather': WeatherTool("your-api-key")
}

agent = TaskAgent(llm_client, tools)

# 添加任务
agent.add_task("搜索AI技术进展")
agent.add_task("计算 2 + 3 * 4")
agent.add_task("查询北京天气")

# 运行任务
results = agent.run()
print("执行结果:")
for result in results:
    print(result)

7.5 练习题¶

练习题1:基础Agent¶

题目:实现一个简单的Agent,能够感知输入、推理决策并执行行动。

参考答案:

Python

class SimpleAgent:
    """简单Agent"""

    def __init__(self, name: str):
        self.name = name
        self.memory = []

    def perceive(self, input_data: str) -> str:
        """感知"""
        return f"感知到: {input_data}"

    def reason(self, perception: str) -> str:
        """推理"""
        return f"基于{perception},决定执行相应行动"

    def act(self, reasoning: str) -> str:
        """行动"""
        return f"执行: {reasoning}"

    def run(self, input_data: str) -> str:
        """运行"""
        perception = self.perceive(input_data)
        reasoning = self.reason(perception)
        action = self.act(reasoning)
        return action

练习题2:工具开发¶

题目:开发一个工具,用于查询股票价格。

参考答案:

Python

class StockTool(BaseTool):
    """股票工具"""

    def __init__(self, api_key: str):
        super().__init__(
            name="stock",
            description="用于查询股票价格"
        )
        self.api_key = api_key

    def run(self, symbol: str) -> dict:
        """
        查询股票

        Args:
            symbol: 股票代码

        Returns:
            股票信息
        """
        # 这里简化处理,实际应该调用股票API
        return {
            'symbol': symbol,
            'price': 100.0,
            'change': 2.5,
            'change_percent': 2.56
        }

7.6 面试准备¶

7.6.1 大厂面试题¶

字节跳动面试题:

问题:什么是Agent?它有什么特点?

参考答案: - Agent是能够自主感知、推理和行动的智能系统 - 特点: - 自主性:自主决策 - 感知能力:感知环境 - 推理能力:推理决策 - 行动能力:执行行动 - 学习能力:从经验学习

问题:Agent和传统程序有什么区别?

参考答案: - 决策方式:自主 vs 预设 - 适应性:强 vs 弱 - 学习能力:有 vs 无 - 复杂性:高 vs 低

腾讯面试题:

问题:如何设计一个Agent系统?

参考答案: - 需求分析:明确应用场景 - 架构设计:设计模块化架构 - 工具开发:开发所需工具 - 推理设计:设计推理逻辑 - 测试优化:测试和优化 - 部署监控:部署并监控

问题:Agent有哪些应用场景?

参考答案: - 对话系统:智能客服 - 任务自动化:自动执行任务 - 推荐系统:个性化推荐 - 游戏:游戏AI - 机器人:物理机器人

阿里巴巴面试题:

问题:LangChain Agent有什么优势?

参考答案: - 简化开发:提供现成框架 - 工具丰富:内置多种工具 - 易于扩展:易于添加新工具 - 社区支持:活跃的社区

问题:如何优化Agent的性能?

参考答案: - 工具优化:优化工具性能 - 缓存优化:缓存结果 - 并行执行:并行执行任务 - 推理优化:优化推理逻辑 - 记忆管理:优化记忆存储

7.6.2 面试技巧¶

技巧1:理论联系实际

结合实际项目经验,说明如何应用Agent解决实际问题。

技巧2:架构设计

展示Agent架构设计能力,说明模块划分和交互。

技巧3:工具开发

说明工具开发的经验,展示工程能力。

技巧4:持续优化

说明如何通过监控和反馈持续优化Agent。

📝 本章小结¶

本章系统介绍了Agent开发的核心内容:

✅ Agent概述:定义、发展历程、类型
✅ Agent架构:基础架构、LangChain Agent、自定义Agent
✅ Agent工具:工具类型、工具开发
✅ Agent应用:对话Agent、任务Agent
✅ 练习题:基础Agent、工具开发
✅ 面试准备:大厂面试题和解答技巧

通过本章学习,你应该能够: - 理解Agent的核心概念和原理 - 掌握Agent的架构设计方法 - 学会开发基础的Agent系统 - 了解Agent的应用场景 - 准备好应对大厂面试

🔗 下一步¶

下一章我们将深入学习LangChain框架,掌握如何使用LangChain构建复杂应用。

继续学习: 08-LangChain框架.md

💡 思考题¶

Agent的核心特征是什么?

①自主性：能独立决策执行，无需人工逐步指令 ②工具使用：能调用API/搜索/代码执行等外部工具 ③规划能力：复杂任务自动分解为子任务 ④记忆：维护短期(对话)和长期(经验)记忆 ⑤反思：能评估结果并自我纠正。核心循环：感知→思考→行动→观察(ReAct范式)。
Agent和传统程序有什么区别?

传统程序：固定逻辑(if/else)、确定性输出、预定义流程。Agent：动态决策(LLM驱动)、概率性输出、根据环境反馈调整行为。关键差异：Agent的"控制流"由LLM在运行时决定，而非硬编码。但Agent也因此更难调试和保证一致性。
如何设计一个Agent系统?

核心组件：①LLM大脑(GPT-4o/Claude) ②系统提示词(角色+能力边界) ③工具集(Function Calling) ④记忆模块(对话历史+向量存储) ⑤规划模块(ReAct/Plan-and-Execute)。设计原则：最小权限原则、失败回退机制、人机协作(Human-in-the-loop)、可观测性(日志+追踪)。
Agent有哪些应用场景?

代码助手(Cursor/GitHub Copilot)、数据分析(自动写SQL+可视化)、客服机器人(查订单+退款)、研究助手(搜索+总结+引用)、自动化运维(监控+告警+修复)。最成熟领域：代码生成和数据分析，因为反馈明确(代码能运行/结果可验证)。
在实际项目中如何应用Agent?

生产要点：①从简单场景开始，逐步增加工具 ②严格定义工具的输入输出Schema ③设置最大迭代次数防止无限循环 ④关键操作加Human-in-the-loop确认 ⑤全链路可观测(LangSmith/Phoenix) ⑥成本控制(Token预算)。框架选择：LangGraph(灵活)、CrewAI(多Agent)、AutoGen(微软)。

📚 参考资料¶

LangChain Documentation
AutoGPT Documentation
BabyAGI Documentation
"ReAct: Synergizing Reasoning and Acting in Language Models" - Yao et al.
OpenAI Documentation

最后更新日期：2026-02-12 适用版本：LLM应用指南 v2026