# 1. 安装 LangChain
pip install langchain langchain-openai langchain-community

# 2. 获取 API Key
export OPENAI_API_KEY="sk-..."
# 或使用 Anthropic Claude
export ANTHROPIC_API_KEY="sk-..."

# 3. 创建第一个 Agent
python hello_agent.py

from langchain.agents import create_openai_functions_agent, AgentExecutor
from langchain.tools import Tool
from langchain_openai import ChatOpenAI
from langchain import hub

# 定义工具
def search_tool(query: str) -> str:
    """搜索工具（示例）"""
    return f"搜索结果：{query}"

tools = [
    Tool(
        name="Search",
        func=search_tool,
        description="用于搜索最新信息"
    )
]

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

# 获取 prompt 模板
prompt = hub.pull("hwchase17/openai-functions-agent")

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

# 测试
result = agent_executor.invoke({"input": "搜索今天的天气"})
print(result)

# ReAct = Reasoning + Acting
from langchain.agents import create_react_agent

prompt = hub.pull("hwchase17/react")

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

result = agent_executor.invoke({
    "input": "帮我查一下今天的天气，然后决定要不要带伞"
})

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# 短期记忆
memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 测试记忆
conversation.predict(input="我叫张三")
conversation.predict(input="我叫什么名字？")

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# 定义 prompt 模板
prompt = PromptTemplate(
    input_variables=["topic"],
    template="写一篇关于{topic}的短文，100字左右。"
)

# 创建 chain
chain = LLMChain(llm=llm, prompt=prompt)

# 执行
result = chain.run(topic="AI Agent")
print(result)

from langgraph.graph import StateGraph, END

# 定义状态
class AgentState(dict):
    pass

# 定义节点
def research_node(state):
    # 研究步骤
    state["research"] = "研究结果"
    return state

def writing_node(state):
    # 写作步骤
    state["draft"] = "草稿"
    return state

# 构建图
workflow = StateGraph(AgentState)
workflow.add_node("research", research_node)
workflow.add_node("writing", writing_node)

workflow.add_edge("research", "writing")
workflow.add_edge("writing", END)

workflow.set_entry_point("research")

app = workflow.compile()

# 执行
result = app.invoke({})

# 安装 evals
pip install evals

# 下载 MMLU 数据集
git clone https://github.com/hendrycks/test.git
cd test

# 运行 benchmark
python evaluate_mmlu.py \
  --data_dir data \
  --model_name gpt-4 \
  --num_few_shot 5

# 无 Memory 的 Agent
agent_no_memory = create_react_agent(llm, tools, prompt)

# 有 Memory 的 Agent
agent_with_memory = create_react_agent(llm, tools, prompt)
memory = ConversationBufferMemory()
agent_with_memory.memory = memory

# 对比测试
test_query = "先搜索天气，然后搜索明天，最后对比两者的温度"

result_no_memory = agent_no_memory.invoke({"input": test_query})
result_with_memory = agent_with_memory.invoke({"input": test_query})

# 结论：Memory 对于多步骤任务至关重要

models = {
    "gpt-4o": ChatOpenAI(model="gpt-4o"),
    "gpt-4o-mini": ChatOpenAI(model="gpt-4o-mini"),
    "claude-3-5-sonnet": ChatAnthropic(model="claude-3-5-sonnet-20241022")
}

for name, llm in models.items():
    agent = create_react_agent(llm, tools, prompt)
    result = agent.invoke({"input": test_query})
    print(f"{name}: {result}")

# Agent（自主决策）
agent_result = agent.invoke({"input": "帮我查天气然后决定要不要带伞"})

# Chain（固定流程）
chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        template="步骤1：查天气\n步骤2：决定带伞\n\n{input}"
    )
)
chain_result = chain.run("帮我查天气然后决定要不要带伞")

# 对比：Agent 更灵活，Chain 更可控

from langchain.callbacks import StdOutCallbackHandler

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,  # 打印思考过程
    callbacks=[StdOutCallbackHandler()]
)

# 观察输出
# > Entering new AgentExecutor chain...
# > Action: Search
# > Action Input: 今天天气
# > Observation: 晴天，25度
# > Thought: 我现在知道最终答案了
# > Final Answer: 今天是晴天，25度，不需要带伞

# 测试 1：超过 Context Window
long_text = "..." * 100000  # 超长文本
agent.invoke({"input": long_text})

# 测试 2：循环依赖
agent.invoke({"input": "一直搜索，直到找到答案"})

# 测试 3：工具不存在
agent.invoke({"input": "使用不存在的工具"})

# 结论：Agent 的边界在哪里

def broken_tool(query: str) -> str:
    raise Exception("工具不可用")

# 观察 Agent 如何处理
agent = create_react_agent(llm, [
    Tool(name="BrokenTool", func=broken_tool, description="...")
], prompt)
agent.invoke({"input": "使用 BrokenTool"})

llm = ChatOpenAI(model="gpt-4o", timeout=0.001)  # 极短超时
agent = create_react_agent(llm, tools, prompt)
agent.invoke({"input": "正常查询"})

memory = ConversationBufferMemory()
for i in range(100000):
    memory.chat_memory.add_user_message(f"消息 {i}")
# 观察何时崩溃

tools = [
    Tool(name="BrokenTool", func=broken_tool, description="返回虚假信息")
]
agent.invoke({"input": "查询不存在的功能"})

import asyncio

async def concurrent_query(agent, query):
    return await agent.ainvoke({"input": query})

tasks = [concurrent_query(agent, f"查询 {i}") for i in range(100)]
results = await asyncio.gather(*tasks)

from locust import HttpUser, task

class AgentUser(HttpUser):
    @task
    def query_agent(self):
        response = self.client.post("/agent", json={"query": "测试"})

# 运行 24 小时，观察内存泄漏
import time
start_time = time.time()
while time.time() - start_time < 86400:
    agent.invoke({"input": "测试查询"})
    time.sleep(10)

def safe_tool_wrapper(func):
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            return f"工具调用失败: {str(e)}"
    return wrapper

tools = [
    Tool(
        name="SafeSearch",
        func=safe_tool_wrapper(search_tool),
        description="..."
    )
]

from langchain.callbacks import BaseCallbackHandler

class TimeoutHandler(BaseCallbackHandler):
    def on_llm_start(self, prompts, **kwargs):
        self.start_time = time.time()

    def on_llm_end(self, response, **kwargs):
        elapsed = time.time() - self.start_time
        if elapsed > 10:  # 10 秒超时
            raise TimeoutError("LLM 响应超时")

# Circuit Breaker 模式
from pybreaker import CircuitBreaker

breaker = CircuitBreaker(
    fail_max=5,
    timeout_duration=60
)

@breaker
def call_agent(query):
    return agent.invoke({"input": query})

# Accuracy（准确率）
def accuracy(predictions, labels):
    return sum(p == l for p, l in zip(predictions, labels)) / len(labels)

# F1-score
from sklearn.metrics import f1_score

# Pass@k（代码生成）
def pass_at_k(n, c, k):
    """
    n: 总样本数
    c: 通过样本数
    k: 尝试次数
    """
    return 1 - (comb(n - c, k) / comb(n, k))

# BLEU（文本相似度）
from nltk.translate.bleu_score import sentence_bleu

baselines = {
    "gpt-4o": OpenAI(model="gpt-4o"),
    "claude-3-5-sonnet": Anthropic(model="claude-3-5-sonnet-20241022"),
    "llama-3-70b": Local(model="meta-llama/Llama-3-70b")
}

# 下载 MMLU
wget https://people.eecs.berkeley.edu/~hendrycks/data.tar

# 解压
tar -xf data.tar

from evals import MMLUEvaluator

evaluator = MMLUEvaluator(
    data_path="data/mmlu",
    model=llm,
    num_few_shot=5
)

results = evaluator.evaluate()
print(results)

import matplotlib.pyplot as plt

subjects = list(results.keys())
scores = list(results.values())

plt.bar(subjects, scores)
plt.xlabel("Subject")
plt.ylabel("Accuracy")
plt.title("MMLU Results")
plt.show()

# 对比 3 个模型
for model_name, model in baselines.items():
    results = evaluate(model, mmlu_data)
    print(f"{model_name}: {results['average']}")

prompts = [
    "直接回答",
    "Let's think step by step",
    "First, analyze the problem. Then, solve it."
]

for prompt in prompts:
    results = evaluate_with_prompt(llm, mmlu_data, prompt)
    print(f"{prompt}: {results['average']}")

# 对比两个版本的 Agent
agent_v1 = create_agent_v1()
agent_v2 = create_agent_v2()

results_v1 = evaluate_agent(agent_v1, test_cases)
results_v2 = evaluate_agent(agent_v2, test_cases)

print(f"v1: {results_v1}, v2: {results_v2}")

# 绘制系统架构图
"""
┌─────────────────────────────────────┐
│           User Interface            │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│         Agent Orchestrator          │
│  (LangChain / LangGraph)            │
└──────┬────────────────┬─────────────┘
       │                │
┌──────▼──────┐  ┌─────▼─────────┐
│    RAG      │  │  Tool Caller  │
│  (Knowledge)│  │  (API / DB)   │
└─────────────┘  └───────────────┘
"""

# 1. RAG 系统
from langchain.vectorstores import Pinecone
from langchain.embeddings import OpenAIEmbeddings

vectorstore = Pinecone.from_documents(
    documents,
    embedding=OpenAIEmbeddings()
)

# 2. 工具定义
tools = [
    Tool(name="查询订单", func=query_order, description="..."),
    Tool(name="退款处理", func=process_refund, description="..."),
    Tool(name="人工转接", func=transfer_to_human, description="...")
]

# 3. Agent 创建
agent = create_openai_functions_agent(llm, tools, prompt)

# 测试用例
test_cases = [
    "查询订单 12345",
    "退款订单 12345",
    "投诉产品质量",
    "转人工客服"
]

for query in test_cases:
    result = agent.invoke({"input": query})
    print(f"Query: {query}\nResult: {result}\n")

# 1. 容器化
cat > Dockerfile <<EOF
FROM python:3.11
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]
EOF

# 2. 本地测试
docker build -t ai-agent .
docker run -p 8000:8000 ai-agent

# 3. 云端部署（可选）
# 使用 Streamlit Cloud / Hugging Face Spaces

# 自定义 Benchmark
evaluator = AgentEvaluator(
    test_cases=100,
    metrics=["accuracy", "response_time", "user_satisfaction"]
)

results = evaluator.evaluate(agent)

# 对比基线
baseline_results = evaluate_baseline()

print(f"Agent: {results['accuracy']}")
print(f"Baseline: {baseline_results['accuracy']}")
print(f"Improvement: {results['accuracy'] - baseline_results['accuracy']}")

# 项目文档

## 功能特性
- ✅ RAG 知识检索
- ✅ 工具调用
- ✅ 多轮对话
- ✅ 人工转接

## 技术栈
- LangChain
- Pinecone
- OpenAI GPT-4o

## 性能指标
- 准确率: 85%
- 响应时间: 2s
- 用户满意度: 4.5/5

## 在线演示
[视频 / Demo]