Agent 智能体

# pip install -qU "langchain[anthropic]"

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """获取指定城市的天气信息"""
    weather_data = {
        "北京": "晴，25°C，微风",
        "上海": "多云，22°C，东南风3级",
        "广州": "小雨，28°C，湿度85%",
        "深圳": "晴，30°C，紫外线强"
    }
    return weather_data.get(city, f"{city}天气数据暂无")

# 创建 Agent - 就这么简单！
agent = create_agent(
    model="claude-sonnet-4-5-20250929",  # 或 "gpt-4", "gpt-3.5-turbo"
    tools=[get_weather],
    system_prompt="你是一个天气助手，帮助用户查询天气信息"
)

# 运行 Agent
result = agent.invoke({
    "messages": [{"role": "user", "content": "北京和上海的天气怎么样？"}]
})
print(result)

from langchain.agents import create_agent
from datetime import datetime

def get_weather(city: str) -> str:
    """获取城市天气"""
    return f"{city}：晴天，25°C"

def get_time(timezone: str = "Asia/Shanghai") -> str:
    """获取当前时间"""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def search_restaurant(city: str, cuisine: str) -> str:
    """搜索餐厅"""
    return f"在{city}找到3家{cuisine}餐厅：美食轩、味道楼、香满园"

def book_restaurant(name: str, date: str, people: int) -> str:
    """预订餐厅"""
    return f"已成功预订 {name}，{date}，{people}人"

# 创建多工具 Agent
agent = create_agent(
    model="gpt-4",
    tools=[get_weather, get_time, search_restaurant, book_restaurant],
    system_prompt="""你是一个智能生活助手，可以帮助用户：
    1. 查询天气
    2. 查看时间
    3. 搜索和预订餐厅
    
    请友好地与用户交流，并在需要时使用工具完成任务。"""
)

# 复杂任务：Agent 会自动规划和执行
result = agent.invoke({
    "messages": [{
        "role": "user", 
        "content": "帮我看看北京今天的天气，然后搜索一家日料餐厅，预订今晚7点2人桌"
    }]
})

from langchain.agents import create_agent

def calculate(expression: str) -> str:
    """计算数学表达式"""
    try:
        return str(eval(expression))
    except:
        return "计算错误，请检查表达式"

def translate(text: str, to_language: str) -> str:
    """翻译文本"""
    return f"[翻译成{to_language}]: {text} 的翻译结果"

agent = create_agent(
    model="gpt-4",  # 使用 OpenAI GPT-4
    tools=[calculate, translate],
    system_prompt="你是一个多功能助手，可以进行计算和翻译"
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "计算 (15 * 8) + 230，然后把结果翻译成英文"}]
})

from langchain.agents import create_agent

# 使用智谱 AI GLM-4
agent = create_agent(
    model="glm-4",  # 智谱 AI
    tools=[get_weather],
    system_prompt="你是一个天气助手"
)

# 使用通义千问
agent = create_agent(
    model="qwen-turbo",  # 阿里通义千问
    tools=[get_weather],
    system_prompt="你是一个天气助手"
)

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
from dotenv import load_dotenv

load_dotenv()

# 定义工具
@tool
def search(query: str) -> str:
    """搜索网络获取信息"""
    return f"搜索'{query}'的结果：这是一些相关信息..."

@tool
def calculator(expression: str) -> str:
    """计算数学表达式"""
    try:
        return str(eval(expression))
    except:
        return "计算错误"

tools = [search, calculator]

# 创建 LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# 获取 ReAct 提示词模板
prompt = hub.pull("hwchase17/react")

# 创建 Agent
agent = create_react_agent(llm, tools, prompt)

# 创建 Agent 执行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,  # 显示详细执行过程
    max_iterations=5  # 最大迭代次数
)

# 运行
result = agent_executor.invoke({
    "input": "搜索 LangChain 是什么，然后计算 2024 减去它的发布年份"
})
print(result["output"])

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# 定义工具
@tool
def get_weather(city: str) -> str:
    """获取城市天气"""
    weather_data = {
        "北京": "晴，25°C",
        "上海": "多云，22°C",
        "广州": "小雨，28°C"
    }
    return weather_data.get(city, "未找到该城市")

@tool
def get_news(topic: str) -> str:
    """获取新闻"""
    return f"关于'{topic}'的最新新闻：今日要闻..."

tools = [get_weather, get_news]

# 创建提示词
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有用的助手，可以使用各种工具帮助用户。"),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

# 创建 LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# 创建 Agent
agent = create_tool_calling_agent(llm, tools, prompt)

# 创建执行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True
)

# 运行
result = agent_executor.invoke({
    "input": "北京和上海的天气怎么样？然后给我看看科技新闻"
})

from langchain.agents import create_react_agent
from langchain import hub

prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)

from langchain.agents import create_tool_calling_agent

agent = create_tool_calling_agent(llm, tools, prompt)

from langchain.agents import create_structured_chat_agent
from langchain import hub

prompt = hub.pull("hwchase17/structured-chat-agent")
agent = create_structured_chat_agent(llm, tools, prompt)

from langchain.agents import create_openai_functions_agent

agent = create_openai_functions_agent(llm, tools, prompt)

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,                    # 显示详细信息
    max_iterations=10,               # 最大迭代次数
    max_execution_time=60,           # 最大执行时间（秒）
    early_stopping_method="force",   # 超时处理方式
    handle_parsing_errors=True,      # 处理解析错误
    return_intermediate_steps=True   # 返回中间步骤
)

# 获取中间步骤
result = agent_executor.invoke({"input": "问题"})
for step in result["intermediate_steps"]:
    action, observation = step
    print(f"工具: {action.tool}")
    print(f"输入: {action.tool_input}")
    print(f"输出: {observation}")

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# 创建带历史的提示词
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有用的助手。"),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

# 创建 Agent
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 会话存储
session_store = {}

def get_session_history(session_id: str):
    if session_id not in session_store:
        session_store[session_id] = ChatMessageHistory()
    return session_store[session_id]

# 包装成带历史的执行器
agent_with_history = RunnableWithMessageHistory(
    agent_executor,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history"
)

# 使用
response1 = agent_with_history.invoke(
    {"input": "我叫小明"},
    config={"configurable": {"session_id": "user1"}}
)

response2 = agent_with_history.invoke(
    {"input": "我叫什么名字？"},
    config={"configurable": {"session_id": "user1"}}
)

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

@tool
def search(query: str) -> str:
    """搜索信息"""
    return f"关于 {query} 的搜索结果..."

@tool
def calculator(expression: str) -> str:
    """计算数学表达式"""
    return str(eval(expression))

tools = [search, calculator]
tool_map = {t.name: t for t in tools}

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
llm_with_tools = llm.bind_tools(tools)

system_prompt = """你是一个智能助手，可以使用以下工具：

1. search - 搜索网络信息
2. calculator - 进行数学计算

请根据用户的问题，选择合适的工具来完成任务。
如果不需要工具，直接回答即可。"""

def run_agent(query: str, max_iterations: int = 5):
    """运行自定义 Agent"""
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": query}
    ]
    
    for i in range(max_iterations):
        print(f"\n--- 迭代 {i + 1} ---")
        
        response = llm_with_tools.invoke(messages)
        messages.append(response)
        
        # 如果没有工具调用，返回结果
        if not response.tool_calls:
            print(f"最终回答: {response.content}")
            return response.content
        
        # 执行工具调用
        for tool_call in response.tool_calls:
            tool_name = tool_call["name"]
            tool_args = tool_call["args"]
            
            print(f"调用工具: {tool_name}")
            print(f"参数: {tool_args}")
            
            # 执行工具
            tool = tool_map[tool_name]
            result = tool.invoke(tool_args)
            
            print(f"结果: {result}")
            
            # 添加工具结果
            messages.append(ToolMessage(
                content=str(result),
                tool_call_id=tool_call["id"]
            ))
    
    return "达到最大迭代次数"

# 测试
run_agent("搜索 Python 发布年份，然后计算从那年到 2024 年过了多少年")

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-3.5-turbo")

# 计划器
planner_prompt = ChatPromptTemplate.from_template("""
为完成以下任务，制定一个详细的计划。
每个步骤应该简洁明了。

任务：{task}

请列出完成这个任务需要的步骤（每行一个步骤）：
""")

planner = planner_prompt | llm | StrOutputParser()

# 执行器
executor_prompt = ChatPromptTemplate.from_template("""
你正在执行一个多步骤任务。

整体任务：{task}

已完成的步骤和结果：
{completed_steps}

当前需要执行的步骤：{current_step}

请执行这个步骤并给出结果：
""")

executor = executor_prompt | llm | StrOutputParser()

def plan_and_execute(task: str):
    """计划并执行任务"""
    # 1. 制定计划
    plan = planner.invoke({"task": task})
    steps = [s.strip() for s in plan.split("\n") if s.strip()]
    
    print("=== 计划 ===")
    for i, step in enumerate(steps, 1):
        print(f"{i}. {step}")
    
    # 2. 逐步执行
    completed = []
    print("\n=== 执行 ===")
    
    for i, step in enumerate(steps, 1):
        print(f"\n步骤 {i}: {step}")
        
        result = executor.invoke({
            "task": task,
            "completed_steps": "\n".join(completed) or "无",
            "current_step": step
        })
        
        completed.append(f"步骤 {i}: {step}\n结果: {result}")
        print(f"结果: {result}")
    
    return completed

# 测试
plan_and_execute("写一篇关于 Python 的简短介绍文章")

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-3.5-turbo")

# 生成器
generator_prompt = ChatPromptTemplate.from_template("""
任务：{task}

{feedback}

请完成这个任务：
""")

# 反思器
reflector_prompt = ChatPromptTemplate.from_template("""
评估以下任务完成情况：

任务：{task}
完成结果：{result}

请评估：
1. 是否完整完成了任务？（是/否）
2. 有什么可以改进的地方？
3. 如果需要改进，具体建议是什么？

格式：
完成状态：[是/否]
改进建议：[建议内容或"无"]
""")

def reflect_and_improve(task: str, max_iterations: int = 3):
    """反思并改进"""
    feedback = ""
    
    for i in range(max_iterations):
        print(f"\n=== 迭代 {i + 1} ===")
        
        # 生成
        result = (generator_prompt | llm).invoke({
            "task": task,
            "feedback": feedback
        }).content
        print(f"生成结果：\n{result}")
        
        # 反思
        reflection = (reflector_prompt | llm).invoke({
            "task": task,
            "result": result
        }).content
        print(f"\n反思：\n{reflection}")
        
        # 检查是否完成
        if "完成状态：是" in reflection or "完成状态: 是" in reflection:
            print("\n任务完成！")
            return result
        
        # 提取改进建议
        feedback = f"上一次的结果需要改进。反馈：{reflection}"
    
    return result

# 测试
reflect_and_improve("写一个 Python 函数，计算斐波那契数列的第 n 项")

"""
智能客服 Agent - 处理用户咨询、投诉、退款等
"""
from langchain.agents import create_agent

def query_order(order_id: str) -> str:
    """查询订单状态"""
    orders = {
        "ORD001": {"status": "已发货", "tracking": "SF1234567890", "eta": "明天送达"},
        "ORD002": {"status": "配送中", "tracking": "YT9876543210", "eta": "今天下午"},
        "ORD003": {"status": "已签收", "tracking": "ZTO1111111111", "eta": "已完成"},
    }
    order = orders.get(order_id)
    if order:
        return f"订单 {order_id}：{order['status']}，快递单号 {order['tracking']}，{order['eta']}"
    return f"未找到订单 {order_id}"

def apply_refund(order_id: str, reason: str) -> str:
    """申请退款"""
    return f"退款申请已提交。订单：{order_id}，原因：{reason}。预计1-3个工作日处理。"

def query_product(product_name: str) -> str:
    """查询商品信息"""
    products = {
        "iPhone 15": {"price": 5999, "stock": 100, "specs": "6.1寸，128GB"},
        "MacBook Pro": {"price": 14999, "stock": 50, "specs": "14寸，M3芯片"},
        "AirPods Pro": {"price": 1899, "stock": 200, "specs": "主动降噪，空间音频"},
    }
    product = products.get(product_name)
    if product:
        return f"{product_name}：¥{product['price']}，库存{product['stock']}，{product['specs']}"
    return f"未找到商品 {product_name}"

def transfer_human() -> str:
    """转人工客服"""
    return "正在为您转接人工客服，请稍候..."

customer_service_agent = create_agent(
    model="gpt-4",
    tools=[query_order, apply_refund, query_product, transfer_human],
    system_prompt="""你是一个专业的电商客服助手。

你的职责：
1. 帮助用户查询订单状态
2. 处理退款申请
3. 解答商品咨询
4. 必要时转接人工客服

注意事项：
- 始终保持礼貌和专业
- 如果无法解决问题，主动提议转人工
- 退款需要用户提供订单号和原因
"""
)

# 测试对话
conversations = [
    "我的订单 ORD001 到哪了？",
    "我想退款，订单号是 ORD002，商品有质量问题",
    "iPhone 15 多少钱？有货吗？",
    "我要投诉，你们服务太差了！",
]

for msg in conversations:
    print(f"\n用户：{msg}")
    result = customer_service_agent.invoke({
        "messages": [{"role": "user", "content": msg}]
    })
    print(f"客服：{result}")

"""
代码助手 Agent - 帮助开发者写代码、解释代码、调试
"""
from langchain.agents import create_agent
import subprocess

def run_python_code(code: str) -> str:
    """执行 Python 代码并返回结果"""
    try:
        result = subprocess.run(
            ["python", "-c", code],
            capture_output=True,
            text=True,
            timeout=10
        )
        if result.returncode == 0:
            return f"执行成功：\n{result.stdout}"
        else:
            return f"执行错误：\n{result.stderr}"
    except subprocess.TimeoutExpired:
        return "执行超时"
    except Exception as e:
        return f"执行失败：{str(e)}"

def search_documentation(query: str) -> str:
    """搜索技术文档"""
    docs = {
        "python list": "Python list 是可变序列，支持 append(), extend(), pop() 等方法",
        "python dict": "Python dict 是键值对映射，支持 get(), keys(), values() 等方法",
        "async await": "Python async/await 用于异步编程，async 定义协程，await 等待结果",
        "langchain agent": "LangChain Agent 是能够自主决策和使用工具的智能体",
    }
    for key, value in docs.items():
        if key in query.lower():
            return value
    return f"关于 '{query}' 的文档：请参考官方文档获取详细信息"

def analyze_error(error_message: str) -> str:
    """分析错误信息"""
    if "SyntaxError" in error_message:
        return "语法错误：请检查代码的括号、引号、缩进是否正确"
    elif "NameError" in error_message:
        return "变量未定义：请检查变量名拼写，确保变量在使用前已定义"
    elif "TypeError" in error_message:
        return "类型错误：请检查函数参数类型是否正确"
    elif "ImportError" in error_message:
        return "导入错误：请确保模块已安装（pip install）"
    return f"错误分析：{error_message}"

code_assistant = create_agent(
    model="gpt-4",
    tools=[run_python_code, search_documentation, analyze_error],
    system_prompt="""你是一个专业的 Python 开发助手。

你的能力：
1. 编写和执行 Python 代码
2. 解释代码逻辑
3. 调试和分析错误
4. 搜索技术文档

注意事项：
- 代码要简洁、可读、符合 PEP8 规范
- 执行代码前先解释其功能
- 遇到错误时提供修复建议
"""
)

# 测试
result = code_assistant.invoke({
    "messages": [{"role": "user", "content": "帮我写一个快速排序函数，并测试它"}]
})

"""
数据分析 Agent - 分析数据、生成报告、可视化
"""
from langchain.agents import create_agent
import json

def query_database(sql: str) -> str:
    """执行 SQL 查询（模拟）"""
    # 模拟数据库查询结果
    mock_results = {
        "SELECT * FROM sales": [
            {"date": "2024-01", "product": "A", "revenue": 10000},
            {"date": "2024-02", "product": "A", "revenue": 12000},
            {"date": "2024-03", "product": "A", "revenue": 15000},
        ],
        "SELECT SUM(revenue)": {"total_revenue": 37000},
    }
    for key in mock_results:
        if key in sql:
            return json.dumps(mock_results[key], ensure_ascii=False)
    return "查询结果为空"

def calculate_statistics(data: str) -> str:
    """计算统计数据"""
    try:
        numbers = json.loads(data)
        if isinstance(numbers, list):
            values = [item.get("revenue", 0) for item in numbers if "revenue" in item]
            if values:
                return json.dumps({
                    "平均值": sum(values) / len(values),
                    "最大值": max(values),
                    "最小值": min(values),
                    "总和": sum(values),
                    "数量": len(values)
                }, ensure_ascii=False)
        return "无法计算统计数据"
    except:
        return "数据格式错误"

def generate_chart(chart_type: str, data: str) -> str:
    """生成图表（模拟）"""
    return f"已生成{chart_type}图表，数据：{data[:100]}..."

def export_report(title: str, content: str) -> str:
    """导出报告"""
    return f"报告《{title}》已导出为 PDF 格式"

data_analyst = create_agent(
    model="gpt-4",
    tools=[query_database, calculate_statistics, generate_chart, export_report],
    system_prompt="""你是一个专业的数据分析师。

你的能力：
1. 执行 SQL 查询获取数据
2. 计算统计指标
3. 生成可视化图表
4. 导出分析报告

工作流程：
1. 理解用户的分析需求
2. 查询所需数据
3. 进行统计分析
4. 生成图表和报告
"""
)

# 测试
result = data_analyst.invoke({
    "messages": [{"role": "user", "content": "分析一下今年的销售数据，生成趋势图和报告"}]
})

"""
旅行规划 Agent - 搜索航班、酒店、景点，制定行程
"""
from langchain.agents import create_agent

def search_flights(from_city: str, to_city: str, date: str) -> str:
    """搜索航班"""
    flights = [
        {"flight": "CA1234", "time": "08:00-11:00", "price": 800},
        {"flight": "MU5678", "time": "14:00-17:00", "price": 650},
        {"flight": "CZ9012", "time": "19:00-22:00", "price": 720},
    ]
    result = f"{from_city}→{to_city} {date} 的航班：\n"
    for f in flights:
        result += f"  {f['flight']} {f['time']} ¥{f['price']}\n"
    return result

def search_hotels(city: str, checkin: str, checkout: str) -> str:
    """搜索酒店"""
    hotels = [
        {"name": "希尔顿酒店", "rating": 4.8, "price": 800},
        {"name": "如家快捷", "rating": 4.2, "price": 200},
        {"name": "亚朵酒店", "rating": 4.5, "price": 400},
    ]
    result = f"{city} {checkin}~{checkout} 的酒店：\n"
    for h in hotels:
        result += f"  {h['name']} ⭐{h['rating']} ¥{h['price']}/晚\n"
    return result

def search_attractions(city: str) -> str:
    """搜索景点"""
    attractions = {
        "北京": ["故宫", "长城", "天坛", "颐和园", "798艺术区"],
        "上海": ["外滩", "东方明珠", "迪士尼", "豫园", "新天地"],
        "杭州": ["西湖", "灵隐寺", "宋城", "西溪湿地", "龙井村"],
    }
    spots = attractions.get(city, ["暂无数据"])
    return f"{city}热门景点：{'、'.join(spots)}"

def create_itinerary(destination: str, days: int, interests: str) -> str:
    """生成行程建议"""
    return f"""
{destination} {days}天行程建议（{interests}）：

第1天：抵达，入住酒店，周边逛逛
第2天：核心景点游览
{"第3天：深度体验当地文化" if days >= 3 else ""}
{"第4天：自由活动、购物" if days >= 4 else ""}
{"最后一天：返程" if days > 2 else ""}

建议预算：约 ¥{days * 800}/人
"""

travel_agent = create_agent(
    model="gpt-4",
    tools=[search_flights, search_hotels, search_attractions, create_itinerary],
    system_prompt="""你是一个专业的旅行规划师。

你的能力：
1. 搜索航班和酒店
2. 推荐景点和美食
3. 制定详细行程
4. 预算规划建议

注意事项：
- 根据用户预算推荐合适的选项
- 考虑行程的合理性和可行性
- 提供实用的旅行建议
"""
)

# 测试
result = travel_agent.invoke({
    "messages": [{
        "role": "user", 
        "content": "我想下周从北京去杭州玩3天，帮我规划一下，预算3000左右"
    }]
})

"""
文档问答 Agent - 结合 RAG 技术回答文档相关问题
"""
from langchain.agents import create_agent

# 模拟向量数据库检索
def search_documents(query: str) -> str:
    """从知识库检索相关文档"""
    knowledge_base = {
        "退款": "退款政策：购买后7天内可无理由退款，需保持商品完好。退款将在3-5个工作日内原路返回。",
        "配送": "配送说明：默认使用顺丰快递，一般1-3天送达。偏远地区可能需要5-7天。",
        "保修": "保修政策：电子产品保修1年，非人为损坏免费维修。过保后提供有偿维修服务。",
        "会员": "会员权益：银卡9.5折，金卡9折，钻石卡8.5折。消费满1000升银卡，满5000升金卡。",
    }
    results = []
    for key, value in knowledge_base.items():
        if key in query:
            results.append(value)
    return "\n".join(results) if results else "未找到相关信息"

def get_faq(category: str) -> str:
    """获取常见问题"""
    faqs = {
        "支付": [
            "Q: 支持哪些支付方式？A: 支持微信、支付宝、银行卡支付",
            "Q: 可以分期付款吗？A: 订单满3000元可选择3/6/12期分期",
        ],
        "发票": [
            "Q: 如何开发票？A: 在订单详情页点击申请发票",
            "Q: 支持开专票吗？A: 支持，需提供公司资质",
        ],
    }
    return "\n".join(faqs.get(category, ["暂无该类别的常见问题"]))

doc_qa_agent = create_agent(
    model="gpt-4",
    tools=[search_documents, get_faq],
    system_prompt="""你是一个智能文档问答助手。

你的能力：
1. 从知识库检索相关信息
2. 获取常见问题解答
3. 综合信息回答用户问题

注意事项：
- 回答要准确，基于检索到的文档
- 如果找不到相关信息，诚实说明
- 复杂问题可以分步回答
"""
)

# 测试
questions = [
    "退款需要多长时间？",
    "会员有什么优惠？",
    "可以用微信支付吗？",
]

for q in questions:
    print(f"\n问：{q}")
    result = doc_qa_agent.invoke({
        "messages": [{"role": "user", "content": q}]
    })
    print(f"答：{result}")

"""
研究助手 Agent - 高级 Agent 示例
"""

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from datetime import datetime
from dotenv import load_dotenv

load_dotenv()

# 定义工具
@tool
def web_search(query: str) -> str:
    """搜索网络获取最新信息
    
    Args:
        query: 搜索关键词
    """
    # 模拟搜索结果
    return f"""
搜索结果 - "{query}":
1. 相关文章：{query} 的最新进展
2. 研究报告：关于 {query} 的深入分析
3. 新闻报道：{query} 行业动态
"""

@tool
def read_document(url: str) -> str:
    """读取并总结网页或文档内容
    
    Args:
        url: 文档URL或路径
    """
    return f"文档摘要（{url}）：这是一份关于该主题的详细介绍..."

@tool
def take_notes(content: str) -> str:
    """记录研究笔记
    
    Args:
        content: 要记录的内容
    """
    timestamp = datetime.now().strftime("%H:%M:%S")
    return f"[{timestamp}] 笔记已保存：{content[:50]}..."

@tool
def create_outline(topic: str) -> str:
    """为指定主题创建大纲
    
    Args:
        topic: 主题名称
    """
    return f"""
《{topic}》研究大纲：
1. 引言
   - 背景介绍
   - 研究意义
2. 主要内容
   - 核心概念
   - 关键技术
   - 应用场景
3. 分析与讨论
4. 结论与展望
"""

@tool
def write_summary(notes: str) -> str:
    """根据笔记撰写总结报告
    
    Args:
        notes: 研究笔记内容
    """
    return f"""
研究总结报告
===========
基于收集的资料，以下是主要发现：

{notes}

结论：通过系统的研究和分析，我们对该主题有了深入的理解...
"""


class ResearchAgent:
    """研究助手 Agent"""
    
    def __init__(self):
        self.tools = [
            web_search,
            read_document,
            take_notes,
            create_outline,
            write_summary
        ]
        
        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
        
        self.prompt = ChatPromptTemplate.from_messages([
            ("system", """你是一个专业的研究助手，帮助用户进行主题研究。

你的工作流程：
1. 首先理解用户的研究需求
2. 搜索相关资料
3. 记录重要信息
4. 创建研究大纲
5. 撰写总结报告

请根据用户的需求，合理使用工具完成研究任务。"""),
            MessagesPlaceholder(variable_name="chat_history", optional=True),
            ("human", "{input}"),
            MessagesPlaceholder(variable_name="agent_scratchpad")
        ])
        
        self.agent = create_tool_calling_agent(
            self.llm,
            self.tools,
            self.prompt
        )
        
        self.executor = AgentExecutor(
            agent=self.agent,
            tools=self.tools,
            verbose=True,
            max_iterations=10,
            return_intermediate_steps=True
        )
    
    def research(self, topic: str) -> dict:
        """进行研究"""
        result = self.executor.invoke({
            "input": f"请帮我研究以下主题：{topic}。请搜索资料、记录笔记、创建大纲，最后撰写一份总结报告。"
        })
        
        return {
            "output": result["output"],
            "steps": [
                {
                    "tool": step[0].tool,
                    "input": step[0].tool_input,
                    "output": step[1]
                }
                for step in result["intermediate_steps"]
            ]
        }


def main():
    agent = ResearchAgent()
    
    print("=" * 50)
    print("  研究助手 Agent")
    print("  输入研究主题，我会帮你收集资料并生成报告")
    print("  输入 'quit' 退出")
    print("=" * 50)
    
    while True:
        topic = input("\n请输入研究主题：").strip()
        
        if topic.lower() == "quit":
            print("再见！")
            break
        
        if not topic:
            continue
        
        print(f"\n开始研究：{topic}\n")
        result = agent.research(topic)
        
        print("\n" + "=" * 50)
        print("研究完成！")
        print("=" * 50)
        print(f"\n{result['output']}")


if __name__ == "__main__":
    main()