用户输入 → LLM 推理(Thought) → 决定行动(Action) → 执行工具 → 观察结果(Observation) → 继续推理 → ...

react_prompt_template = """
你是一个智能助手，可以使用以下工具：
1. search(query): 搜索信息
2. calculate(expression): 计算数学表达式
3. get_weather(city): 查询天气

请按以下格式回答：
Thought: [你的思考过程]
Action: [工具名称]
Action Input: [工具参数]
Observation: [工具返回的结果]
... (重复 Thought/Action/Observation 直到得出答案)
Answer: [最终答案]

问题：{question}
"""

# 用户问题："北京明天的天气适合户外活动吗？"

# LLM 输出：
"""
Thought: 我需要先查询北京明天的天气
Action: get_weather
Action Input: {"city": "北京", "date": "明天"}
Observation: 明天北京天气：晴，温度 22°C，微风

Thought: 根据天气信息，晴天、温度适中、微风，非常适合户外活动
Answer: 根据天气预报，北京明天天气晴朗，温度 22°C，微风，非常适合户外活动。
"""

tool_selection_prompt = """
根据用户输入，选择合适的工具并提取参数。

可用工具：
- get_weather: 查询天气，参数: city, date
- send_email: 发送邮件，参数: to, subject, body
- search: 搜索信息，参数: query

用户输入：{user_input}

请以 JSON 格式返回：
{
  "tool": "工具名称",
  "parameters": {
    "参数名": "参数值"
  }
}
"""

# 用户："查询明天上海的天气"
# LLM 返回：
{
  "tool": "get_weather",
  "parameters": {
    "city": "上海",
    "date": "明天"
  }
}

from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain.tools import BaseTool

# 定义工具
class WeatherTool(BaseTool):
    name = "get_weather"
    description = "获取指定城市的天气信息。输入：城市名称"
    
    def _run(self, city: str) -> str:
        return f"{city}的天气：晴朗"

class EmailTool(BaseTool):
    name = "send_email"
    description = "发送邮件。输入：收件人,主题,正文"
    
    def _run(self, to: str, subject: str, body: str) -> str:
        return f"已发送邮件给 {to}"

# 创建 Agent
tools = [WeatherTool(), EmailTool()]
agent = create_react_agent(llm, tools, prompt_template)
agent_executor = AgentExecutor(agent=agent, tools=tools)

# 执行
result = agent_executor.run("查询北京的天气并发邮件通知张三")

from sentence_transformers import SentenceTransformer
import numpy as np

# 1. 工具库（包含描述）
tools_library = [
    {"name": "get_weather", "description": "查询城市天气信息"},
    {"name": "send_email", "description": "发送电子邮件"},
    {"name": "search_web", "description": "在网络上搜索信息"},
    {"name": "calculate", "description": "计算数学表达式"},
    # ... 100+ 个工具
]

# 2. 向量化工具描述
model = SentenceTransformer('all-MiniLM-L6-v2')
tool_embeddings = model.encode([t["description"] for t in tools_library])

# 3. 检索相关工具
def retrieve_tools(user_query, top_k=3):
    query_embedding = model.encode([user_query])
    similarities = np.dot(query_embedding, tool_embeddings.T)[0]
    top_indices = np.argsort(similarities)[-top_k:][::-1]
    return [tools_library[i] for i in top_indices]

# 4. 让 LLM 从候选工具中选择
user_query = "明天北京会下雨吗？"
candidate_tools = retrieve_tools(user_query)  # 返回：get_weather, search_web

# 5. LLM 从候选中选择
function_calling_with_candidates(user_query, candidate_tools)

code_gen_prompt = """
你有以下 Python 函数可用：
- get_weather(city, date)
- send_email(to, subject, body)
- calculate(expression)

根据用户需求，生成 Python 代码来完成任务。

用户：查询明天北京的天气
代码：
```python
result = get_weather("北京", "明天")
print(result)

weather = get_weather("上海", "明天")
send_email("user@example.com", "天气通知", f"明天上海天气：{weather}")

#### 优势
- **灵活性极高**：可以实现复杂的逻辑组合
- **无需预定义**：不需要严格的工具 schema
- **支持组合**：可以组合多个工具调用

#### 劣势
- **安全风险**：执行生成的代码有安全隐患
- **难以控制**：生成的代码可能不符合预期
- **调试困难**：代码错误难以追踪

### 6. Fine-tuned Model（微调模型）

专门训练一个小模型用于意图识别和参数提取。

#### 实现流程

```python
# 1. 准备训练数据
training_data = [
    {
        "input": "查询明天北京的天气",
        "output": {
            "intent": "get_weather",
            "params": {"city": "北京", "date": "明天"}
        }
    },
    # ... 数千条标注数据
]

# 2. 微调模型
from transformers import AutoModelForSequenceClassification, Trainer

model = AutoModelForSequenceClassification.from_pretrained("bert-base-chinese")
trainer = Trainer(model=model, train_dataset=training_data)
trainer.train()

# 3. 推理
def predict_intent_and_params(text):
    result = model(text)
    return result  # {"intent": "...", "params": {...}}

# 示例：Tool Retrieval + Function Calling
def hybrid_agent(user_input):
    # 1. 工具检索：从 100+ 工具中筛选出 5 个候选
    candidate_tools = retrieve_tools(user_input, top_k=5)
    
    # 2. Function Calling：从候选中精确选择
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": user_input}],
        tools=candidate_tools,  # 只传入候选工具
        tool_choice="auto"
    )
    
    return response

用户应用
   ↓
[LangChain/LlamaIndex 框架] ← 可选
   ↓
[Function Calling API] ← 核心
   ↓
[LLM (GPT-4/Claude)]

# 未来主流架构
def next_gen_agent(user_query, tool_library_size=1000+):
    # 第一层：语义检索（快速筛选）
    candidates = vector_search(user_query, top_k=5)
    
    # 第二层：Function Calling（精确选择）
    tool_call = llm.function_call(user_query, tools=candidates)
    
    # 第三层：执行和反馈
    result = execute_tool(tool_call)
    return result

# 未来示例：图像 + 文本 → 工具调用
response = llm.function_call(
    messages=[
        {"role": "user", "content": [
            {"type": "text", "text": "这张图片中的产品多少钱？"},
            {"type": "image_url", "image_url": "..."}
        ]}
    ],
    tools=[
        {"name": "product_search", ...},
        {"name": "price_lookup", ...}
    ]
)
# LLM 识别图片内容并调用价格查询工具

用户查询 → 协调 Agent → 拆解任务 → 并行调度专业 Agent → 结果汇总
           (Function Calling)  ↓         ↓
                          [数据分析 Agent]  [报告生成 Agent]
                          [信息检索 Agent]  [代码执行 Agent]

方案：Function Calling (OpenAI/Claude/Gemini)
原因：稳定、可靠、开发效率高、持续优化
成本：中等（API 调用费用）

方案：Tool Retrieval + Function Calling
原因：支持大量内部工具，可扩展性好
成本：中等

方案：LangChain + Function Calling
原因：快速开发，丰富的组件
成本：低（快速迭代）

方案：Fine-tuned Model 或 本地 Llama + Function Calling
原因：低延迟，无需网络，成本可控
成本：高（训练和部署）

方案：ReAct + Function Calling
原因：可解释性强，适合多步推理
成本：高（多次 LLM 调用）