# 策略 1：滑动窗口 — 只保留最近 K 轮
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(k=5)

# 策略 2：Token 限制截断 — 精确控制 Token 消耗
from langchain.memory import ConversationTokenBufferMemory
memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=2000)

# 策略 3：摘要压缩 — 用摘要替代原始对话
from langchain.memory import ConversationSummaryMemory
memory = ConversationSummaryMemory(llm=llm)

# 策略 4：混合策略 — 摘要 + 最近完整对话
from langchain.memory import ConversationSummaryBufferMemory
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=2000)

# 向量数据库存储对话历史
from langchain.memory import VectorStoreRetrieverMemory
from langchain.vectorstores import ChromaDB

vectorstore = ChromaDB(embedding_function=embeddings)
memory = VectorStoreRetrieverMemory(retriever=vectorstore.as_retriever())

用户：北京今天天气怎么样？

Agent 内部过程：
Thought: 用户想知道北京的天气，我需要调用天气 API
Action: call_weather_api(city="北京")
Observation: 北京今天晴，气温 25°C，湿度 40%
Thought: 已经获取天气信息，可以回答用户了
Answer: 北京今天晴天，气温 25 度，湿度较低，适合外出活动。

from langchain.tools import Tool

# 定义工具
search_tool = Tool(
    name="web_search",
    description="搜索互联网获取信息，输入搜索关键词",
    func=search_function
)

# Agent 使用工具
from langchain.agents import AgentExecutor

agent = AgentExecutor.from_agent_and_tools(
    agent=llm_agent,
    tools=[search_tool, calculator_tool, weather_tool]
)

from langgraph.graph import StateGraph

# 定义状态
class ChainState(TypedDict):
    input: str
    search_result: str
    summary: str
    translation: str

# 构建 DAG
graph = StateGraph(ChainState)
graph.add_node("search", search_agent)
graph.add_node("summarize", summarize_agent)
graph.add_node("translate", translate_agent)

graph.add_edge("search", "summarize")
graph.add_edge("summarize", "translate")
graph.set_finish_point("translate")

from autogen import AssistantAgent, UserProxyAgent

# 管理者
manager = AssistantAgent(
    name="Manager",
    system_message="你是项目经理，负责拆解任务并分配给合适的工程师"
)

# 工作者
coder = AssistantAgent(name="Coder", system_message="你负责写代码")
tester = AssistantAgent(name="Tester", system_message="你负责测试")
deployer = AssistantAgent(name="Deployer", system_message="你负责部署")

# 组建团队
groupchat = GroupChat(
    agents=[manager, coder, tester, deployer],
    messages=[]
)

# 链式编排
workflow = [
    ("sql_agent", "查询数据库获取销售数据"),
    ("analysis_agent", "分析数据趋势"),
    ("chart_agent", "生成可视化图表"),
    ("writer_agent", "撰写报表文字说明")
]

from langgraph.graph import StateGraph

class ReportState(TypedDict):
    raw_data: list      # SQL 查询结果
    analysis: dict      # 分析结论
    charts: list        # 图表文件路径
    report: str         # 最终报表文本

graph = StateGraph(ReportState)

# SQL Agent
def sql_agent(state):
    query = "SELECT date, revenue FROM sales WHERE date >= '2024-01-01'"
    data = db.execute(query)
    return {"raw_data": data}

# Analysis Agent
def analysis_agent(state):
    data = state["raw_data"]
    # 计算增长率、异常点等
    analysis = analyze_sales_data(data)
    return {"analysis": analysis}

# Chart Agent
def chart_agent(state):
    charts = generate_charts(state["raw_data"])
    return {"charts": charts}

# Writer Agent
def writer_agent(state):
    report = write_report(state["analysis"], state["charts"])
    return {"report": report}

# 构建流程
graph.add_node("sql", sql_agent)
graph.add_node("analysis", analysis_agent)
graph.add_node("chart", chart_agent)
graph.add_node("writer", writer_agent)

graph.add_edge("sql", "analysis")
graph.add_edge("analysis", "chart")
graph.add_edge("chart", "writer")

LangChain
├── langchain-core      # 核心抽象（Chain、Agent、Tool）
├── langchain-community # 社区集成（各种 API、数据库）
├── langchain-openai    # OpenAI 专用集成
├── langchain-anthropic # Anthropic 专用集成
└── langgraph           # 状态机编排（独立包）

from langgraph.graph import StateGraph, END

# 定义状态（在节点间传递的数据）
class AgentState(TypedDict):
    messages: list
    next_action: str

# 定义节点（Agent 或函数）
def agent_node(state):
    response = llm.invoke(state["messages"])
    return {"messages": state["messages"] + [response]}

def tool_node(state):
    tool_result = execute_tool(state["messages"][-1])
    return {"messages": state["messages"] + [tool_result]}

# 构建图
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tool", tool_node)

# 定义边（条件分支）
def should_continue(state):
    if state["messages"][-1].tool_calls:
        return "tool"
    return END

graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tool", "agent")

# 运行
app = graph.compile()
result = app.invoke({"messages": ["帮我查北京天气"]})

import autogen

# 配置 LLM
config_list = [{"model": "gpt-4", "api_key": "your-key"}]

# 创建 Agent
assistant = autogen.AssistantAgent(
    name="Assistant",
    llm_config={"config_list": config_list}
)

user_proxy = autogen.UserProxyAgent(
    name="User",
    human_input_mode="TERMINATE",  # 人类只在结束时介入
    code_execution_config={"work_dir": "coding"}
)

# 开始对话
user_proxy.initiate_chat(
    assistant,
    message="写一个 Python 函数计算斐波那契数列"
)

问：小明有 5 个苹果，给了小红 2 个，又买了 3 个，现在有多少个？
答：6 个

问：小明有 5 个苹果，给了小红 2 个，又买了 3 个，现在有多少个？
请逐步思考：
1. 初始有多少？
2. 给出去多少？
3. 又买了多少？
4. 最终有多少？

答：
1. 初始有 5 个苹果
2. 给小红 2 个，剩下 5-2=3 个
3. 又买了 3 个，现在有 3+3=6 个
4. 最终有 6 个苹果

prompt = """
任务：将句子翻译成 SQL

示例：
句子：查询所有年龄大于 20 的用户
SQL：SELECT * FROM users WHERE age > 20

句子：查询订单金额超过 1000 的订单
SQL：SELECT * FROM orders WHERE amount > 1000

现在请翻译：
句子：查询最近一周登录过的用户
SQL：
"""

from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel

class AnalysisResult(BaseModel):
    sentiment: str      # positive/negative/neutral
    topics: list[str]   # 主题列表
    summary: str        # 总结

parser = PydanticOutputParser(pydantic_object=AnalysisResult)

prompt = f"""
分析以下文本的情感和主题：
{text}

{parser.get_format_instructions()}
"""

react_prompt = """
你是一个智能助手，可以使用工具完成任务。

可用工具：
- search: 搜索互联网
- calculator: 数学计算
- weather: 查询天气

思考过程格式：
Thought: 思考下一步做什么
Action: 调用什么工具（tool_name）
Action Input: 工具输入参数
Observation: 工具返回结果
...（重复直到完成任务）
Answer: 最终答案

开始！
用户问题：{question}
"""

import os
os.environ["LANGCHAIN_API_KEY"] = "your-key"
os.environ["LANGCHAIN_TRACING_V2"] = "true"

# 所有 LangChain 调用都会记录到 LangSmith
from langchain.agents import AgentExecutor

agent = AgentExecutor.from_agent_and_tools(...)
result = agent.invoke({"input": "hello"})
# 在 LangSmith 网站查看完整调用链、Token 消耗、耗时等