from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import tool
from langchain import hub
from pydantic import BaseModel
import re

llm = ChatOpenAI(model="gpt-4", temperature=0)

# 1. 定义工具
class CalculatorInput(BaseModel):
    expression: str

@tool(args_schema=CalculatorInput)
def calculate(expression: str) -> str:
    """执行数学计算"""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"计算错误: {e}"

@tool
def search_web(query: str) -> str:
    """搜索网络信息"""
    return f"搜索结果: {query}的相关信息"

tools = [calculate, search_web]

# 2. 构建Agent
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 3. 执行任务
result = agent_executor.invoke({"input": "计算 25 * 4 + 10"})
print(f"结果: {result['output']}")

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from typing import TypedDict, List

llm = ChatOpenAI(model="gpt-4", temperature=0)

# 1. 定义状态
class AgentState(TypedDict):
    task: str
    research: str
    analysis: str
    final_answer: str

# 2. 定义Agent节点
def researcher(state: AgentState) -> AgentState:
    """研究Agent：收集信息"""
    response = llm.invoke(f"研究以下问题: {state['task']}")
    return {"research": response.content}

def analyzer(state: AgentState) -> AgentState:
    """分析Agent：深度分析"""
    response = llm.invoke(f"基于以下研究进行分析:\n{state['research']}")
    return {"analysis": response.content}

def writer(state: AgentState) -> AgentState:
    """写作Agent：生成最终答案"""
    response = llm.invoke(f"基于以下分析写一个清晰的回答:\n{state['analysis']}")
    return {"final_answer": response.content}

# 3. 构建图
workflow = StateGraph(AgentState)
workflow.add_node("researcher", researcher)
workflow.add_node("analyzer", analyzer)
workflow.add_node("writer", writer)

workflow.set_entry_point("researcher")
workflow.add_edge("researcher", "analyzer")
workflow.add_edge("analyzer", "writer")
workflow.add_edge("writer", END)

graph = workflow.compile()

# 4. 执行
result = graph.invoke({"task": "AI的未来发展趋势是什么？"})
print(result["final_answer"])

from langchain_openai import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

llm = ChatOpenAI(model="gpt-4", temperature=0.7)

# 1. 带记忆的对话Agent
memory = ConversationBufferMemory(
    return_messages=True,
    memory_key="history"
)

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有帮助的助手，记住之前的对话内容。"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

conversation = ConversationChain(
    llm=llm,
    prompt=prompt,
    memory=memory,
    verbose=False
)

# 2. 对话演示
print(conversation.invoke({"input": "我叫张三"}))
print(conversation.invoke({"input": "我叫什么名字？"}))
print(conversation.invoke({"input": "我喜欢Python编程"}))
print(conversation.invoke({"input": "我刚才说我喜欢什么？"}))

from langchain.callbacks.base import BaseCallbackHandler
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import tool
from langchain import hub
import time

# 1. 自定义回调处理器（可观测性）
class AgentCallbackHandler(BaseCallbackHandler):
    def __init__(self):
        self.steps = []
    
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"📝 LLM开始处理...")
    
    def on_llm_end(self, response, **kwargs):
        print(f"✅ LLM完成，耗时: 短")
    
    def on_tool_start(self, serialized, input_str, **kwargs):
        print(f"🔧 调用工具: {serialized['name']}")
    
    def on_tool_end(self, output, **kwargs):
        print(f"📊 工具输出长度: {len(output)}")

# 2. 构建带观测的Agent
@tool
def get_weather(city: str) -> str:
    """获取城市天气"""
    return f"{city}的天气是晴天，25度"

tools = [get_weather]
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(ChatOpenAI(model="gpt-4"), tools, prompt)

agent_executor = AgentExecutor(
    agent=agent, 
    tools=tools, 
    callbacks=[AgentCallbackHandler()],
    verbose=True
)

# 3. 执行并观测
agent_executor.invoke({"input": "北京的天气怎么样？"})

from langchain_openai import ChatOpenAI
from langchain.agents import tool
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4", temperature=0)

@tool
def search_code_documentation(query: str) -> str:
    """搜索编程文档"""
    return f"关于{query}的官方文档说明"

@tool
def run_python_code(code: str) -> str:
    """运行Python代码"""
    try:
        exec(code)
        return "代码执行成功"
    except Exception as e:
        return f"错误: {e}"

tools = [search_code_documentation, run_python_code]

# ReAct提示词
react_prompt = """你是一个ReAct Agent。请按以下格式思考：

Thought: 你需要思考应该做什么
Action: 工具名称 (如果需要工具调用)
Action Input: 工具输入 (如果需要工具调用)
Observation: 工具返回的结果 (如果调用了工具)

最后给出最终答案。

可用工具: {tool_names}

问题: {input}
"""

# ReAct执行循环
def react_agent(query: str, max_iterations: int = 5):
    current_query = query
    history = []
    
    for i in range(max_iterations):
        # 构建提示
        prompt = react_prompt.format(
            tool_names=[t.name for t in tools],
            input=current_query
        )
        
        # 添加历史
        if history:
            prompt += "\n\n历史:\n" + "\n".join(history)
        
        response = llm.invoke(prompt).content
        
        # 解析响应
        if "Final Answer" in response:
            return response.split("Final Answer:")[1].strip()
        
        # 提取Action
        if "Action:" in response:
            action_line = response.split("Action:")[1].split("\n")[0].strip()
            action_name = action_line.split("(")[0].strip()
            action_input = action_line.split("(")[1].replace(")", "").strip()
            
            # 调用工具
            for tool in tools:
                if tool.name == action_name:
                    result = tool.invoke(action_input)
                    history.append(f"Action: {action_name}({action_input})")
                    history.append(f"Observation: {result}")
                    current_query = f"基于以上信息，继续回答: {query}"
                    break
    
    return "达到最大迭代次数"

# 测试ReAct Agent
result = react_agent("如何用Python计算1到100的和？")
print(result)