import os
from dotenv import load_dotenv
from langchain_deepseek import ChatDeepSeek

load_dotenv()

# 实例化模型
llm = ChatDeepSeek(
    model="deepseek-chat",   # 模型 ID
    temperature=0,           # 采样温度：0 最确定，越大越发散
    max_tokens=None,         # 最大生成 token 数，None 表示不限制
    timeout=None,            # 请求超时时间（秒）
    max_retries=2,           # 失败自动重试次数
    # api_key="sk-...",      # 不传则自动读取环境变量 DEEPSEEK_API_KEY
    # base_url="https://api.deepseek.com",  # 默认即是官方地址，一般不用改
)

# 直接传入字符串调用
response = llm.invoke("用一句话解释什么是 LangChain。")

print(type(response))        # <class 'langchain_core.messages.ai.AIMessage'>
print(response.content)      # 模型返回的文本内容

# 查看 token 用量
print(response.usage_metadata)

from dotenv import load_dotenv
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
from langchain_deepseek import ChatDeepSeek

load_dotenv()
llm = ChatDeepSeek(model="deepseek-chat", temperature=0)

# ========== 1. 使用消息对象 ==========
messages = [
    SystemMessage(content="你是一个将中文翻译成英文的助手，只输出译文。"),
    HumanMessage(content="我喜欢编程。"),
]
ai_msg = llm.invoke(messages)
print(ai_msg.content)  # I like programming.

# ========== 2. 使用元组简写（等价写法） ==========
messages2 = [
    ("system", "你是一个将中文翻译成日语的助手，只输出译文。"),
    ("human", "我喜欢编程。"),
]
ai_msg2 = llm.invoke(messages2)
print(ai_msg2.content)  # J'aime programmer.

# ========== 3. 手动维护多轮对话历史 ==========
chat_history = [
    SystemMessage(content="你是一个简洁的助手，回答不超过 50 字。"),
    HumanMessage(content="中国的首都是哪里？"),
]
reply1 = llm.invoke(chat_history)
print("AI:", reply1.content)

# 关键：把模型的回复也追加进历史，模型才能"记住"上文
chat_history.append(AIMessage(content=reply1.content))
chat_history.append(HumanMessage(content="那它的人口大约是多少？"))

reply2 = llm.invoke(chat_history)
print("AI:", reply2.content)  # 模型知道"它"指北京

from dotenv import load_dotenv
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_deepseek import ChatDeepSeek

load_dotenv()
llm = ChatDeepSeek(model="deepseek-chat", temperature=0.7)

# ========== 1. from_template：单轮字符串模板 ==========
prompt = ChatPromptTemplate.from_template(
    "请用不超过 {limit} 个字，向一个 {audience} 解释什么是 {topic}。"
)
# 模板本身是 Runnable，可以先单独调用看看渲染结果
rendered = prompt.invoke({"limit": 50, "audience": "小学生", "topic": "区块链"})
print(rendered.to_messages())

# ========== 2. from_messages：多消息模板（最常用） ==========
prompt2 = ChatPromptTemplate.from_messages([
    ("system", "你是一位资深{role}，回答风格{style}。"),
    ("human", "{question}"),
])
chain_input = {"role": "Python 工程师", "style": "幽默", "question": "什么是装饰器？"}
response = llm.invoke(prompt2.invoke(chain_input))
print(response.content)

# ========== 3. MessagesPlaceholder：在模板中预留"历史消息"插槽 ==========
prompt3 = ChatPromptTemplate.from_messages([
    ("system", "你是一个乐于助人的助手。"),
    MessagesPlaceholder(variable_name="history"),   # 历史消息插入这里
    ("human", "{question}"),
])
value = prompt3.invoke({
    "history": [
        ("human", "我叫小明。"),
        ("ai", "你好小明，很高兴认识你！"),
    ],
    "question": "我刚才说我叫什么？",
})
print(llm.invoke(value).content)  # 你叫小明

from dotenv import load_dotenv
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough, RunnableParallel
from langchain_deepseek import ChatDeepSeek

load_dotenv()
llm = ChatDeepSeek(model="deepseek-chat", temperature=0)

# ========== 1. 最基础的链：prompt | model | parser ==========
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个{src}到{dst}的翻译专家，只输出译文。"),
    ("human", "{text}"),
])
chain = prompt | llm | StrOutputParser()

result = chain.invoke({"src": "中文", "dst": "英文", "text": "人工智能改变世界"})
print(result)  # 直接得到字符串，而不是 AIMessage

# ========== 2. RunnablePassthrough：原样透传输入 ==========
# 当 prompt 只有一个变量时特别方便
single_prompt = ChatPromptTemplate.from_template("讲一个关于{subject}的冷笑话。")
single_chain = {"subject": RunnablePassthrough()} | single_prompt | llm | StrOutputParser()
print(single_chain.invoke("程序员"))

# ========== 3. RunnableParallel：并行执行多个链 ==========
analysis_prompt = ChatPromptTemplate.from_template("分析这句话的情感倾向（正面/负面/中性）：{text}")
summary_prompt = ChatPromptTemplate.from_template("用 10 个字总结这句话：{text}")

parallel = RunnableParallel(
    sentiment=analysis_prompt | llm | StrOutputParser(),
    summary=summary_prompt | llm | StrOutputParser(),
)
result = parallel.invoke({"text": "这家餐厅的菜太难吃了，但服务员态度特别好。"})
print(result)
# {'sentiment': '中性（菜品负面，服务正面）', 'summary': '菜难吃但服务好'}

from dotenv import load_dotenv
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser, CommaSeparatedListOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_deepseek import ChatDeepSeek

load_dotenv()
llm = ChatDeepSeek(model="deepseek-chat", temperature=0)

# ========== 1. StrOutputParser：AIMessage -> str ==========
prompt = ChatPromptTemplate.from_template("用一句话介绍{city}。")
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"city": "杭州"}))

# ========== 2. CommaSeparatedListOutputParser：解析逗号分隔列表 ==========
list_prompt = ChatPromptTemplate.from_template("列出 5 个{category}，用英文逗号分隔。")
list_chain = list_prompt | llm | CommaSeparatedListOutputParser()
print(list_chain.invoke({"category": "中国地级市"}))
# ['北京', '上海', '天津', '重庆', ...]

# ========== 3. JsonOutputParser：解析 JSON（可配合 Pydantic 约束格式） ==========
from pydantic import BaseModel, Field

class Person(BaseModel):
    name: str = Field(description="人物姓名")
    birth_year: int = Field(description="出生年份")
    achievements: list[str] = Field(description="主要成就，最多3条")

json_parser = JsonOutputParser(pydantic_object=Person)

json_prompt = ChatPromptTemplate.from_messages([
    ("system", "从用户输入中提取人物信息。\n{format_instructions}"),
    ("human", "{text}"),
])
# get_format_instructions() 会自动生成告诉模型输出格式的说明文字
json_chain = json_prompt | llm | json_parser

result = json_chain.invoke({
    "text": "爱因斯坦，1879年出生，提出了相对论，获得诺贝尔物理学奖，推动了现代物理学发展。",
    "format_instructions": json_parser.get_format_instructions(),
})
print(type(result), result)
# <class 'dict'> {'name': '爱因斯坦', 'birth_year': 1879, 'achievements': [...]}

from typing import Literal
from dotenv import load_dotenv
from langchain_core.prompts import ChatPromptTemplate
from langchain_deepseek import ChatDeepSeek
from pydantic import BaseModel, Field

load_dotenv()
llm = ChatDeepSeek(model="deepseek-chat", temperature=0)

# ========== 1. 定义输出结构 ==========
class MovieReview(BaseModel):
    """电影评价抽取结果"""
    title: str = Field(description="电影名称")
    sentiment: Literal["positive", "negative", "mixed"] = Field(description="情感倾向")
    rating: float = Field(description="评分，0-10", ge=0, le=10)
    pros: list[str] = Field(description="优点列表")
    cons: list[str] = Field(description="缺点列表")

# ========== 2. 绑定结构到模型 ==========
structured_llm = llm.with_structured_output(MovieReview)

text = """
《流浪地球2》特效炸裂，太空电梯那段堪称国产科幻巅峰，刘德华和吴京的演技都在线。
不过剧情节奏有些拖沓，中间一段文戏略显冗长。总体值得一看，我给8分。
"""

review = structured_llm.invoke(f"从以下影评中提取信息：\n{text}")
print(type(review))        # <class '__main__.MovieReview'> —— 真正的 Pydantic 对象！
print(review.title)        # 流浪地球2
print(review.sentiment)    # positive
print(review.rating)       # 8.0

# ========== 3. 与 LCEL 组合 ==========
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是影评分析专家。"),
    ("human", "分析这条影评：{text}"),
])
chain = prompt | structured_llm
result = chain.invoke({"text": text})
print(result.model_dump_json(indent=2))  # 序列化为 JSON 字符串

from dotenv import load_dotenv
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_deepseek import ChatDeepSeek

load_dotenv()

# 方式一：实例化时开启 streaming=True
llm = ChatDeepSeek(model="deepseek-chat", streaming=True)

print("=== 模型直接流式输出 ===")
for chunk in llm.stream("写一首关于秋天的五言绝句。"):
    print(chunk.content, end="", flush=True)   # chunk 是 AIMessageChunk
print()

# 方式二：整条链流式输出（LCEL 自动穿透流式）
prompt = ChatPromptTemplate.from_template("给我讲一个{topic}方面的趣事，100字左右。")
chain = prompt | llm | StrOutputParser()

print("\n=== 链式流式输出 ===")
for chunk in chain.stream({"topic": "程序员"}):
    print(chunk, end="", flush=True)           # 经过 parser 后 chunk 直接是字符串
print()

# 方式三：astream_events 获取细粒度事件（LangChain 0.2+ 推荐）
import asyncio

async def demo_events():
    async for event in llm.astream_events("数到5", version="v2"):
        if event["event"] == "on_chat_model_stream":
            print(event["data"]["chunk"].content, end="", flush=True)
    print()

asyncio.run(demo_events())

import asyncio
import time
from dotenv import load_dotenv
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_deepseek import ChatDeepSeek

load_dotenv()
llm = ChatDeepSeek(model="deepseek-chat", temperature=0)
prompt = ChatPromptTemplate.from_template("用一句话介绍{country}的首都。")
chain = prompt | llm | StrOutputParser()

countries = ["中国", "日本", "法国", "巴西", "埃及"]

# ========== 1. batch：批量调用（内部并发） ==========
inputs = [{"country": c} for c in countries]
start = time.time()
results = chain.batch(inputs, config={"max_concurrency": 5})
print(f"batch 耗时: {time.time() - start:.2f}s")
for c, r in zip(countries, results):
    print(f"{c}: {r}")

# ========== 2. 异步 ainvoke / astream ==========
async def async_demo():
    # 异步单条
    result = await chain.ainvoke({"country": "德国"})
    print("ainvoke:", result)

    # 异步流式
    async for chunk in chain.astream({"country": "意大利"}):
        print(chunk, end="", flush=True)
    print()

    # 用 asyncio.gather 手动并发多条
    results = await asyncio.gather(*[
        chain.ainvoke({"country": c}) for c in ["美国", "英国", "俄罗斯"]
    ])
    print("gather:", results)

asyncio.run(async_demo())

# ========== 3. batch 失败容错 ==========
results = chain.batch(inputs, config={"max_concurrency": 5}, return_exceptions=True)
for c, r in zip(countries, results):
    if isinstance(r, Exception):
        print(f"{c}: 调用失败 - {r}")
    else:
        print(f"{c}: {r}")

from dotenv import load_dotenv
from langchain_core.chat_history import BaseChatMessageHistory, InMemoryChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_deepseek import ChatDeepSeek

load_dotenv()
llm = ChatDeepSeek(model="deepseek-chat", temperature=0.7)

# ========== 1. 定义带历史插槽的链 ==========
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个友好的助手，请记住用户告诉你的信息。"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{question}"),
])
chain = prompt | llm

# ========== 2. 用字典管理多个会话的历史 ==========
store = {}  # session_id -> ChatMessageHistory

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

# ========== 3. 包装成带记忆的链 ==========
with_memory = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="question",    # 输入中哪个键是用户消息
    history_messages_key="history",   # prompt 中哪个变量接收历史
)

config = {"configurable": {"session_id": "user_001"}}

# 第一轮
r1 = with_memory.invoke({"question": "我叫小明，我喜欢打篮球。"}, config=config)
print("AI:", r1.content)

# 第二轮——模型记得名字和爱好
r2 = with_memory.invoke({"question": "我叫什么名字？我喜欢什么运动？"}, config=config)
print("AI:", r2.content)

# 换 session_id，开启全新会话（互不干扰）
r3 = with_memory.invoke(
    {"question": "我叫什么名字？"},
    config={"configurable": {"session_id": "user_002"}},
)
print("AI（新会话）:", r3.content)  # 不知道——这是另一个会话

# ========== 4. 限制历史长度（防止 token 爆炸） ==========
from langchain_core.messages import trim_messages
from langchain_core.runnables import RunnablePassthrough

trimmer = trim_messages(
    max_tokens=500,
    strategy="last",            # 保留最近的消息
    token_counter=llm,          # 用模型的 tokenizer 计数
    include_system=True,        # 始终保留 system 消息
)

chain_with_trimming = (
    RunnablePassthrough.assign(history=trimmer)  # 先裁剪 history
    | prompt
    | llm
)
with_memory_trimmed = RunnableWithMessageHistory(
    chain_with_trimming,
    get_session_history,
    input_messages_key="question",
    history_messages_key="history",
)

from dotenv import load_dotenv
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from langchain_deepseek import ChatDeepSeek

load_dotenv()

# ========== 1. 定义工具：docstring 就是给模型看的说明书 ==========
@tool
def get_current_weather(city: str) -> str:
    """查询指定城市的实时天气。

    Args:
        city: 城市名称，例如"北京"
    """
    # 演示用假数据，生产环境替换为真实天气 API
    fake_db = {"北京": "晴，25°C", "上海": "多云，28°C", "深圳": "雷阵雨，30°C"}
    return fake_db.get(city, f"{city}：暂无数据")


@tool
def calculator(expression: str) -> str:
    """计算一个数学表达式的值。

    Args:
        expression: 合法的 Python 数学表达式，例如 "1024 * 768"
    """
    try:
        return str(eval(expression, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"计算出错: {e}"


tools = [get_current_weather, calculator]
tools_by_name = {t.name: t for t in tools}

# ========== 2. 把工具绑定到模型 ==========
llm = ChatDeepSeek(model="deepseek-chat", temperature=0)
llm_with_tools = llm.bind_tools(tools)

# ========== 3. 手动执行工具调用循环 ==========
messages = [HumanMessage(content="北京现在天气怎么样？另外帮我算一下 1024*768 等于多少。")]

# 第一次调用：模型决定调用哪些工具
ai_msg = llm_with_tools.invoke(messages)
print("模型请求调用的工具:", ai_msg.tool_calls)
# [{'name': 'get_current_weather', 'args': {'city': '北京'}, 'id': 'call_xxx'}, ...]

messages.append(ai_msg)

# 执行模型请求的每个工具，把结果包装成 ToolMessage
for call in ai_msg.tool_calls:
    tool_result = tools_by_name[call["name"]].invoke(call["args"])
    messages.append(ToolMessage(content=tool_result, tool_call_id=call["id"]))
    print(f"工具 {call['name']} 返回: {tool_result}")

# 第二次调用：模型基于工具结果生成最终回答
final = llm_with_tools.invoke(messages)
print("最终回答:", final.content)

from dotenv import load_dotenv
from langchain_core.tools import tool
from langchain_deepseek import ChatDeepSeek
from langgraph.prebuilt import create_react_agent

load_dotenv()

# ========== 1. 定义工具 ==========
@tool
def search_product(query: str) -> str:
    """在商品库中搜索商品，返回商品名称和价格。"""
    fake_db = [
        {"name": "机械键盘", "price": 299},
        {"name": "无线鼠标", "price": 99},
        {"name": "27寸显示器", "price": 1299},
    ]
    hits = [f"{p['name']}（¥{p['price']}）" for p in fake_db if query in p["name"]]
    return "；".join(hits) if hits else "未找到相关商品"


@tool
def calculate_total(prices: list[float]) -> float:
    """计算一组价格的总和。"""
    return sum(prices)

# ========== 2. 创建 Agent ==========
llm = ChatDeepSeek(model="deepseek-chat", temperature=0)
agent = create_react_agent(
    llm,
    tools=[search_product, calculate_total],
    prompt="你是一个购物助手。用户想买什么就先搜索，再帮忙算总价。",
)

# ========== 3. 运行 Agent（自动完成 思考->调用工具->观察->再思考 循环） ==========
result = agent.invoke({
    "messages": [("user", "我想买个机械键盘和一个无线鼠标，一共多少钱？")]
})

# 打印完整的推理过程
for msg in result["messages"]:
    msg.pretty_print()

import os
from dotenv import load_dotenv
from langchain_community.vectorstores import FAISS
from langchain_core.documents import Document
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_deepseek import ChatDeepSeek
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

load_dotenv()

# ========== 1. 准备文档（演示用内存文档；生产可用 PyPDFLoader/WebBaseLoader 等加载） ==========
raw_docs = [
    Document(page_content="公司年假政策：员工入职满一年后可享受 5 天带薪年假，"
                          "工龄每增加一年年假增加 1 天，上限 15 天。年假需在当年 12 月 31 日前休完。"),
    Document(page_content="报销制度：差旅报销需在出差结束后 10 个工作日内提交，"
                          "住宿标准为一线城市每晚不超过 500 元，其他城市不超过 350 元。"),
    Document(page_content="考勤制度：标准工作时间为 9:00-18:00，弹性打卡范围为 8:30-10:00，"
                          "每月允许 3 次迟到（10 分钟以内），超出按事假处理。"),
]

# ========== 2. 文本切分 ==========
splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=20)
splits = splitter.split_documents(raw_docs)
print(f"切分出 {len(splits)} 个片段")

# ========== 3. 向量化并入库（FAISS 本地向量库） ==========
embeddings = OpenAIEmbeddings()  # 需要 OPENAI_API_KEY；可换成其他 Embedding
vectorstore = FAISS.from_documents(splits, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})  # 每次检索最相关的 2 个片段

# ========== 4. 构建 RAG 链 ==========
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是公司制度问答助手。仅根据以下检索到的资料回答问题，"
               "资料中没有的信息就回答'制度中未提及'，不要编造。\n\n资料：\n{context}"),
    ("human", "{question}"),
])

llm = ChatDeepSeek(model="deepseek-chat", temperature=0)

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# ========== 5. 提问 ==========
print(rag_chain.invoke("我工龄 3 年，有几天年假？"))
# 入职满一年 5 天，工龄每增一年加 1 天，3 年工龄即 5+2=7 天……

print(rag_chain.invoke("在北京出差住宿费一晚 600 能报销吗？"))
# 不能，一线城市住宿标准上限为每晚 500 元。

print(rag_chain.invoke("公司有健身房吗？"))
# 制度中未提及

from dotenv import load_dotenv
from langchain_core.tools import tool
from langchain_deepseek import ChatDeepSeek
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent

load_dotenv()

# ========== 工具 ==========
@tool
def get_current_time() -> str:
    """获取当前的日期和时间。"""
    from datetime import datetime
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


@tool
def calculate(expression: str) -> str:
    """计算数学表达式。参数 expression 为合法数学表达式字符串。"""
    try:
        return str(eval(expression, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"错误: {e}"

# ========== 构建带记忆的 Agent ==========
llm = ChatDeepSeek(model="deepseek-chat", streaming=True)
memory = MemorySaver()  # LangGraph 检查点：自动持久化对话状态

agent = create_react_agent(
    llm,
    tools=[get_current_time, calculate],
    prompt="你是一个聪明友好的中文助手，回答简洁明了。",
    checkpointer=memory,
)

# thread_id 相当于会话 ID，同一 ID 共享记忆
config = {"configurable": {"thread_id": "cli-session-1"}}

# ========== 交互循环 ==========
print("🤖 聊天机器人已启动（输入 quit 退出，输入 clear 清空记忆）\n")

while True:
    user_input = input("你: ").strip()
    if not user_input:
        continue
    if user_input.lower() == "quit":
        print("再见！")
        break
    if user_input.lower() == "clear":
        config = {"configurable": {"thread_id": f"cli-session-{id(user_input)}"}}
        print("🤖: 记忆已清空。\n")
        continue

    print("🤖: ", end="", flush=True)
    # stream_mode="messages" 按 token 流式输出模型生成的内容
    for chunk, metadata in agent.stream(
        {"messages": [("user", user_input)]},
        config=config,
        stream_mode="messages",
    ):
        # 只打印 AI 生成的 token（过滤掉工具消息等）
        if metadata.get("langgraph_node") == "agent" and chunk.content:
            print(chunk.content, end="", flush=True)
    print("\n")