from ollama import Client

client = Client()

# 注意：messages 是一个列表，每个元素是 {"role": "...", "content": "..."}
response = client.chat(
    model='qwen3:14b',
    messages=[{'role': 'user', 'content': '写一首关于春天的诗'}]
)

print(response['message']['content'])

# 2. 加载文档
print("正在加载 PDF...")
documents = SimpleDirectoryReader(input_files=[pdf_path]).load_data()

if not documents:
    raise FileNotFoundError(f"未加载到任何内容，请检查 PDF 路径：{pdf_path}")

print(f"✅ 成功加载 {len(documents)} 个文本块")

embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-zh-v1.5")

# 4. 构建索引
index = VectorStoreIndex.from_documents(
    documents,
    embed_model=embed_model
)

llm = Ollama(model="qwen2:7b", 
             request_timeout=600.0, 
             base_url="http://127.0.0.1:11434" )

response = query_engine.query("这本书主要讲了哪些 Java 开发规范？")
print("\n🤖 AI 回答:", response.response)

# rag_book.py
import os
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.huggingface import HuggingFaceEmbedding

# 启用 HF 镜像（加速中文模型下载）
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"

# 1. 设置文档路径（单个 PDF 文件）
pdf_path = "/Users/zhangyujin1/Desktop/阿里巴巴-Java开发手册（详尽版）.pdf"

# 2. 加载文档
print("正在加载 PDF...")
documents = SimpleDirectoryReader(input_files=[pdf_path]).load_data()

if not documents:
    raise FileNotFoundError(f"未加载到任何内容，请检查 PDF 路径：{pdf_path}")

print(f"✅ 成功加载 {len(documents)} 个文本块")

# 3. 设置嵌入模型（使用中文优化模型）和 LLM
embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-zh-v1.5")

# 使用 Ollama 官方支持的真实存在的模型
llm = Ollama(model="qwen2:7b", 
             request_timeout=600.0, 
             base_url="http://127.0.0.1:11434" )

# 4. 构建索引
index = VectorStoreIndex.from_documents(
    documents,
    embed_model=embed_model
)

# 5. 查询（此时会连接 Ollama，确保服务已运行！）
query_engine = index.as_query_engine(
    llm=llm,
    similarity_top_k=5,      # 默认是 2，改为 10
    response_mode="compact",   # 合并多个 chunk 再回答（推荐）
    verbose=True               # 开启日志，看传给 LLM 的 prompt
)

response = query_engine.query("这本书主要讲了哪些 Java 开发规范？")
print("\n🤖 AI 回答:", response.response)

from langchain_ollama import OllamaLLM
from langchain_core.prompts import PromptTemplate

llm = OllamaLLM(
    model="qwen2:7b",
    base_url="http://127.0.0.1:11434"
)

rewrite_prompt = PromptTemplate.from_template(
    "请将以下内容改写为正式、书面化的中文：\n{text}"
)

translate_prompt = PromptTemplate.from_template(
    "请将以下中文内容准确翻译为英文：\n{text}"
)

title_prompt = PromptTemplate.from_template(
    "Based on the following text, generate a concise and informative English title:\n{text}"
)

rewrite_chain = rewrite_prompt | llm
translate_chain = translate_prompt | llm
title_chain = title_prompt | llm

full_chain = rewrite_chain | translate_chain | title_chain

{"text": "今天我去了公园，看到好多花开了，心情特别好。"}

input_text = "今天我去了公园，看到好多花开了，心情特别好。"

final_title = full_chain.invoke({"text": input_text})

print("\n🎯 最终输出（生成的英文标题）：")
print(final_title)

# multi_step_chain.py
from langchain_ollama import OllamaLLM
from langchain_core.prompts import PromptTemplate

# === 第 1 步：初始化大模型 ===
llm = OllamaLLM(
    model="qwen2:7b",
    base_url="http://127.0.0.1:11434"
)

# === 第 2 步：定义三个任务的提示模板 ===

# 任务1：改写为正式语气
rewrite_prompt = PromptTemplate.from_template(
    "请将以下内容改写为正式、书面化的中文：\n{text}"
)

# 任务2：翻译成英文
translate_prompt = PromptTemplate.from_template(
    "请将以下中文内容准确翻译为英文：\n{text}"
)

# 任务3：生成一个简洁的英文标题
title_prompt = PromptTemplate.from_template(
    "Based on the following text, generate a concise and informative English title:\n{text}"
)

# === 第 3 步：构建多步骤链（使用 | 管道）===
# 每一步：Prompt + LLM → 自动组成 Runnable
rewrite_chain = rewrite_prompt | llm
translate_chain = translate_prompt | llm
title_chain = title_prompt | llm

# 串联合并：输入 → 改写 → 翻译 → 生成标题
full_chain = rewrite_chain | translate_chain | title_chain

# === 第 4 步：执行任务 ===
input_text = """
今天我去了公园，看到好多花开了，心情特别好。
"""

print("📝 原始输入：")
print(input_text)

# 执行整个流水线
final_title = full_chain.invoke({"text": input_text})

print("\n🎯 最终输出（生成的英文标题）：")
print(final_title)

from langchain_community.llms import Ollama
from langchain_community.utilities import GoogleSearchAPIWrapper
from langchain_community.tools import Calculator
from langchain.tools import Tool

# 初始化模型
llm = Ollama(model="qwen2:7b", request_timeout=600.0, base_url="http://127.0.0.1:11434")

# 工具1：Google 搜索（需设置环境变量）
search = GoogleSearchAPIWrapper()
search_tool = Tool(
    name="Search",
    func=search.run,
    description="用于查询实时信息，如新闻、天气、事件等"
)

# 工具2：计算器
calc_tool = Tool(
    name="Calculator",
    func=Calculator().run,
    description="执行数学运算，支持加减乘除、括号等"
)

from langchain_core.prompts import PromptTemplate

# 定义 Agent 的思考模板
prompt = PromptTemplate.from_template(
    """你是一个智能助手，可以使用以下工具：

{tools}

请按以下格式回答：
Question: 用户的问题
Thought: 你是否需要使用工具？为什么？
Action: 要使用的工具名称（只能选 {tool_names}）
Action Input: 工具的输入
Observation: 工具返回的结果
...（可重复多次）
Final Answer: 最终答案

Begin!

Question: {input}
"""
)

from langchain.agents import create_react_agent, AgentExecutor

# 创建 ReAct Agent
agent = create_react_agent(
    llm=llm,
    tools=[search_tool, calc_tool],
    prompt=prompt
)

# 创建执行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=[search_tool, calc_tool],
    verbose=True,
    handle_parsing_errors=True  # 自动处理格式错误
)

test_questions = [
    "123 * 456 + 789 / 3 是多少？",   # 需要计算
    "Python 是谁发明的？"             # 可直接回答（无需工具）
]

for i, question in enumerate(test_questions, 1):
    print(f"\n🔍 问题 {i}: {question}")
    try:
        response = agent_executor.invoke({"input": question})
        print(f"✅ 回答: {response['output']}")
    except Exception as e:
        print(f"❌ 错误: {e}")

# lesson7_tools.py
import os
from langchain_community.llms import Ollama
from langchain_community.tools import Calculator
from langchain.tools import Tool
from langchain_core.prompts import PromptTemplate
from langchain.agents import create_react_agent, AgentExecutor

# === 第 1 步：初始化本地大模型与工具 ===
llm = Ollama(model="qwen2:7b", request_timeout=600.0, base_url="http://127.0.0.1:11434")

# 仅使用计算器（避免 Google API 依赖）
calc_tool = Tool(
    name="Calculator",
    func=Calculator().run,
    description="执行数学运算，支持加减乘除、括号等"
)

tools = [calc_tool]

# === 第 2 步：构建 Agent 的决策提示词 ===
prompt = PromptTemplate.from_template(
    """你是一个智能助手，可以使用以下工具：

{tools}

请按以下格式回答：
Question: 用户的问题
Thought: 你是否需要使用工具？为什么？
Action: 要使用的工具名称（只能选 {tool_names}）
Action Input: 工具的输入
Observation: 工具返回的结果
...（可重复多次）
Final Answer: 最终答案

Begin!

Question: {input}
"""
)

# === 第 3 步：创建 Zero-Shot Agent ===
agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    handle_parsing_errors=True
)

# === 第 4-5 步：测试问题并执行 ===
test_questions = [
    "123 * 456 + 789 / 3 是多少？",
    "地球到月球的距离大约是多少公里？",  # 模型应直接回答（无搜索工具）
]

for i, question in enumerate(test_questions, 1):
    print(f"\n🔍 问题 {i}: {question}")
    try:
        response = agent_executor.invoke({"input": question})
        print(f"✅ 回答: {response['output']}")
    except Exception as e:
        print(f"❌ 错误: {e}")

from langchain_community.llms import Ollama
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

llm = Ollama(model="qwen2:7b", request_timeout=600.0, base_url="http://127.0.0.1:11434")

# 创建记忆缓冲区（最多保留最近 4 条消息）
memory = ConversationBufferMemory(
    memory_key="history",
    max_len=4,
    return_messages=True
)

# 创建对话链
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

response1 = conversation.predict(input="你好，我是张三，来自杭州。")
print("👤 用户：你好，我是张三，来自杭州。")
print("🤖 AI：", response1)

response2 = conversation.predict(input="你是谁？")
print("\n👤 用户：你是谁？")
print("🤖 AI：", response2)

for msg in ["今天天气怎么样？", "我喜欢吃西湖醋鱼。", "你记得我叫什么吗？"]:
    resp = conversation.predict(input=msg)
    print(f"\n👤 用户：{msg}")
    print("🤖 AI：", resp)

print("\n🧠 当前记忆内容：")
for msg in memory.chat_memory.messages:
    role = "👤" if msg.type == "human" else "🤖"
    print(f"{role} {msg.content}")

# lesson8_memory.py
from langchain_community.llms import Ollama
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# === 第 1 步：初始化带记忆的聊天链 ===
llm = Ollama(model="qwen2:7b", request_timeout=600.0, base_url="http://127.0.0.1:11434")

memory = ConversationBufferMemory(
    memory_key="history",
    max_len=4,
    return_messages=True
)

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

# === 第 2-4 步：多轮对话测试 ===
messages = [
    "你好，我是张三，来自杭州。",
    "你是谁？",
    "今天天气怎么样？",
    "我喜欢吃西湖醋鱼。",
    "你记得我叫什么吗？"
]

for msg in messages:
    resp = conversation.predict(input=msg)
    print(f"👤 用户：{msg}")
    print(f"🤖 AI：{resp}\n")

# === 第 5 步：打印当前记忆 ===
print("🧠 当前记忆内容：")
for msg in memory.chat_memory.messages:
    role = "👤" if msg.type == "human" else "🤖"
    print(f"{role} {msg.content}")

from langchain.tools import tool

@tool
def get_order_status(order_id: str):
    """根据订单号查询物流状态"""
    mock_db = {"ORD1001": "已发货", "ORD1002": "正在打包"}
    return mock_db.get(order_id, "订单未找到")

@tool
def cancel_order(order_id: str):
    """取消指定订单"""
    return f"订单 {order_id} 已成功取消。"

from langchain_community.llms import Ollama
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.prompts import PromptTemplate

llm = Ollama(model="qwen2:7b", request_timeout=600.0, base_url="http://127.0.0.1:11434")
tools = [get_order_status, cancel_order]

prompt = PromptTemplate.from_template(
    "Answer the following questions as best you can. You have access to the following tools:\n\n{tools}\n\nUse the following format:\n\nQuestion: ...\nThought: ...\nAction: ...\nAction Input: ...\nObservation: ...\n... (repeat N times)\nFinal Answer: ...\n\nBegin!\n\nQuestion: {input}\n"
)

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

result = agent_executor.invoke({"input": "我的订单 ORD1001 到哪了？"})
print("✅ 查询结果:", result["output"])

result = agent_executor.invoke({"input": "帮我取消订单 ORD1002"})
print("✅ 操作结果:", result["output"])

result = agent_executor.invoke({"input": "我有个订单，但不知道编号"})
print("✅ 模糊问题处理:", result["output"])

# lesson9_agent.py
from langchain.tools import tool
from langchain_community.llms import Ollama
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.prompts import PromptTemplate

# === 第 1 步：定义工具 ===
@tool
def get_order_status(order_id: str):
    """根据订单号查询物流状态"""
    mock_db = {"ORD1001": "已发货，预计明天送达", "ORD1002": "正在打包"}
    return mock_db.get(order_id, "订单未找到")

@tool
def cancel_order(order_id: str):
    """取消指定订单"""
    return f"订单 {order_id} 已成功取消。"

# === 第 2 步：初始化 Agent ===
llm = Ollama(model="qwen2:7b", request_timeout=600.0, base_url="http://127.0.0.1:11434")
tools = [get_order_status, cancel_order]

prompt = PromptTemplate.from_template(
    "Answer the following questions as best you can. You have access to the following tools:\n\n{tools}\n\nUse the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n\nBegin!\n\nQuestion: {input}\n"
)

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

# === 第 3-5 步：测试 ===
test_cases = [
    "我的订单 ORD1001 到哪了？",
    "帮我取消订单 ORD1002",
    "我有个订单，但不知道编号"
]

for q in test_cases:
    print(f"\n🔍 问题: {q}")
    try:
        res = agent_executor.invoke({"input": q})
        print(f"✅ 回答: {res['output']}")
    except Exception as e:
        print(f"❌ 错误: {e}")

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一名耐心、专业的电商客服，名叫小智。请用亲切、简洁的中文回答用户问题。"),
    ("human", "{input}")
])

from langchain_community.llms import Ollama

llm = Ollama(
    model="qwen2:7b",
    request_timeout=600.0,
    base_url="http://127.0.0.1:11434",
    streaming=True  # 启用流式
)

from langchain_core.output_parsers import StrOutputParser

chain = prompt | llm | StrOutputParser()

import asyncio

async def stream_answer(question: str):
    print(f"\n👤 用户：{question}")
    print("🤖 小智：", end="", flush=True)
    async for chunk in chain.astream({"input": question}):
        print(chunk, end="", flush=True)
    print()

if __name__ == "__main__":
    questions = ["你们支持货到付款吗？", "退货怎么操作？"]
    for q in questions:
        asyncio.run(stream_answer(q))

# lesson10_streaming.py
import asyncio
from langchain_community.llms import Ollama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# === 第 1 步：角色化提示 ===
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一名耐心、专业的电商客服，名叫小智。请用亲切、简洁的中文回答用户问题。"),
    ("human", "{input}")
])

# === 第 2 步：启用流式 ===
llm = Ollama(
    model="qwen2:7b",
    request_timeout=600.0,
    base_url="http://127.0.0.1:11434",
    streaming=True
)

# === 第 3 步：构建链 ===
chain = prompt | llm | StrOutputParser()

# === 第 4-5 步：流式输出 ===
async def stream_answer(question: str):
    print(f"\n👤 用户：{question}")
    print("🤖 小智：", end="", flush=True)
    async for chunk in chain.astream({"input": question}):
        print(chunk, end="", flush=True)
    print()

if __name__ == "__main__":
    questions = [
        "你们支持货到付款吗？",
        "退货怎么操作？",
        "能开发票吗？"
    ]
    for q in questions:
        asyncio.run(stream_answer(q))

from langchain_community.llms import Ollama
from pydantic import BaseModel, Field

# 定义输出结构（Pydantic 模型）
class User(BaseModel):
    name: str = Field(..., description="用户姓名")
    age: int = Field(..., description="用户年龄")
    city: str = Field(..., description="所在城市")

# 初始化模型并开启 JSON 模式
llm = Ollama(
    model="qwen2:7b",
    request_timeout=600.0,
    base_url="http://127.0.0.1:11434",
    format="json"  # 关键：强制输出 JSON 格式
)

from langchain_core.prompts import PromptTemplate

prompt = PromptTemplate.from_template(
    """请根据以下信息提取用户资料：

{input}

请严格按照以下 JSON 格式返回结果：
{
  "name": "姓名",
  "age": 年龄,
  "city": "城市"
}
"""
)

from langchain_core.output_parsers import PydanticOutputParser

# 创建解析器
parser = PydanticOutputParser(pydantic_object=User)

# 构建链
chain = prompt | llm | parser

test_input = """
用户名叫张三，今年 28 岁，住在杭州。
他喜欢喝茶，平时工作很忙。
"""

result = chain.invoke({"input": test_input})
print("✅ 解析结果：")
print(result)
print("\n🛠️ 字段类型：")
print(f"name: {type(result.name)}")
print(f"age: {type(result.age)}")
print(f"city: {type(result.city)}")

# bonus1_json.py
from langchain_community.llms import Ollama
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field

# === 第 1 步：定义模型与 JSON 模式 ===
class User(BaseModel):
    name: str = Field(..., description="用户姓名")
    age: int = Field(..., description="用户年龄")
    city: str = Field(..., description="所在城市")

llm = Ollama(
    model="qwen2:7b",
    request_timeout=600.0,
    base_url="http://127.0.0.1:11434",
    format="json"  # 强制 JSON 输出
)

# === 第 2 步：构建提示模板 ===
prompt = PromptTemplate.from_template(
    """请根据以下信息提取用户资料：

{input}

请严格按照以下 JSON 格式返回结果：
{
  "name": "姓名",
  "age": 年龄,
  "city": "城市"
}
"""
)

# === 第 3 步：创建解析器和链 ===
parser = PydanticOutputParser(pydantic_object=User)
chain = prompt | llm | parser

# === 第 4-5 步：测试 ===
test_input = """
用户名叫张三，今年 28 岁，住在杭州。
他喜欢喝茶，平时工作很忙。
"""

try:
    result = chain.invoke({"input": test_input})
    print("✅ 解析结果：")
    print(result)
    print("\n🛠️ 字段类型：")
    print(f"name: {type(result.name)}")
    print(f"age: {type(result.age)}")
    print(f"city: {type(result.city)}")
except Exception as e:
    print(f"❌ 错误：{e}")

def search_weather(city: str) -> str:
    """查询城市天气"""
    mock_data = {
        "北京": "晴，20°C",
        "上海": "多云，22°C",
        "杭州": "小雨，18°C"
    }
    return mock_data.get(city, "未知城市")

def calculate_discount(price: float, rate: float) -> float:
    """计算折扣价"""
    return price * (1 - rate)

import json

# 手动构造函数签名（类似 OpenAPI）
functions = [
    {
        "name": "search_weather",
        "description": "查询指定城市的天气",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名称"}
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate_discount",
        "description": "计算商品折扣价",
        "parameters": {
            "type": "object",
            "properties": {
                "price": {"type": "number", "description": "原价"},
                "rate": {"type": "number", "description": "折扣率（0～1）"}
            },
            "required": ["price", "rate"]
        }
    }
]

import requests

url = "http://127.0.0.1:11434/api/generate"

payload = {
    "model": "qwen2:7b",
    "prompt": "北京今天天气怎么样？",
    "stream": False,
    "tools": functions,
    "tool_choice": "auto"  # 自动选择工具
}

response = requests.post(url, json=payload)
result = response.json()

if "error" in result:
    print(f"❌ 错误：{result['error']}")
else:
    # 检查是否调用了工具
    if "tool_calls" in result:
        tool_call = result["tool_calls"][0]
        func_name = tool_call["function"]["name"]
        args = tool_call["function"]["arguments"]

        print(f"🔧 调用函数：{func_name}")
        print(f"📌 参数：{args}")

        # 执行对应函数
        if func_name == "search_weather":
            weather = search_weather(args["city"])
            print(f"🌤️ 天气：{weather}")
        elif func_name == "calculate_discount":
            discount_price = calculate_discount(args["price"], args["rate"])
            print(f"💰 折扣价：{discount_price:.2f}")
    else:
        print("💬 直接回答：", result["response"])

test_questions = [
    "北京今天天气怎么样？",
    "买一台 5000 元的手机打 8 折多少钱？",
    "你能帮我做什么？"
]

for q in test_questions:
    print(f"\n🔍 问题：{q}")
    payload["prompt"] = q
    response = requests.post(url, json=payload)
    result = response.json()

    if "error" in result:
        print(f"❌ 错误：{result['error']}")
    elif "tool_calls" in result:
        tool_call = result["tool_calls"][0]
        func_name = tool_call["function"]["name"]
        args = tool_call["function"]["arguments"]
        print(f"🔧 调用：{func_name}({args})")

        if func_name == "search_weather":
            print(f"🌤️ 天气：{search_weather(args['city'])}")
        elif func_name == "calculate_discount":
            print(f"💰 折扣价：{calculate_discount(args['price'], args['rate']):.2f}")
    else:
        print(f"💬 回答：{result['response']}")

# bonus2_function_calling.py
import requests
import json

# === 第 1 步：定义工具函数 ===
def search_weather(city: str) -> str:
    """查询城市天气"""
    mock_data = {"北京": "晴，20°C", "上海": "多云，22°C", "杭州": "小雨，18°C"}
    return mock_data.get(city, "未知城市")

def calculate_discount(price: float, rate: float) -> float:
    """计算折扣价"""
    return price * (1 - rate)

# === 第 2 步：定义函数签名 ===
functions = [
    {
        "name": "search_weather",
        "description": "查询指定城市的天气",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名称"}
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate_discount",
        "description": "计算商品折扣价",
        "parameters": {
            "type": "object",
            "properties": {
                "price": {"type": "number", "description": "原价"},
                "rate": {"type": "number", "description": "折扣率（0～1）"}
            },
            "required": ["price", "rate"]
        }
    }
]

# === 第 3-5 步：发送请求并处理结果 ===
url = "http://127.0.0.1:11434/api/generate"

test_questions = [
    "北京今天天气怎么样？",
    "买一台 5000 元的手机打 8 折多少钱？",
    "你能帮我做什么？"
]

for q in test_questions:
    print(f"\n🔍 问题：{q}")
    payload = {
        "model": "qwen2:7b",
        "prompt": q,
        "stream": False,
        "tools": functions,
        "tool_choice": "auto"
    }

    response = requests.post(url, json=payload)
    result = response.json()

    if "error" in result:
        print(f"❌ 错误：{result['error']}")
    elif "tool_calls" in result:
        tool_call = result["tool_calls"][0]
        func_name = tool_call["function"]["name"]
        args = tool_call["function"]["arguments"]
        print(f"🔧 调用：{func_name}({args})")

        if func_name == "search_weather":
            print(f"🌤️ 天气：{search_weather(args['city'])}")
        elif func_name == "calculate_discount":
            print(f"💰 折扣价：{calculate_discount(args['price'], args['rate']):.2f}")
    else:
        print(f"💬 回答：{result['response']}")

from langchain_community.llms import Ollama

# 启动 Ollama 并拉取微调模型
# 示例：使用 qwen2:7b + 客服领域 LoRA
llm = Ollama(
    model="qwen2:7b",
    request_timeout=600.0,
    base_url="http://127.0.0.1:11434",
    streaming=True,
    temperature=0.7,  # 控制创造性
    top_p=0.9,         # 样本多样性
    repeat_penalty=1.1 # 防止重复
)

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", """
你是一名专业的电商客服，名叫小智。请遵循以下规则：
1. 语气亲切、简洁，避免啰嗦。
2. 回答必须基于事实，不编造信息。
3. 若无法回答，请说：“我正在查询，请稍等。”
4. 支持中文和英文双语回复。
"""),
    ("human", "{input}")
])

from langchain_core.output_parsers import StrOutputParser

# 构建 Runnable 链
chain = prompt | llm | StrOutputParser()

import asyncio

async def stream_response(question: str):
    print(f"\n👤 用户：{question}")
    print("🤖 小智：", end="", flush=True)

    async for chunk in chain.astream({"input": question}):
        print(chunk, end="", flush=True)
    print()  # 换行

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

memory = ConversationBufferMemory(
    memory_key="history",
    max_len=5,
    return_messages=True
)

conversation_chain = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=False
)

# 测试多轮对话
questions = [
    "你们支持货到付款吗？",
    "退货怎么操作？",
    "能开发票吗？"
]

for q in questions:
    response = conversation_chain.predict(input=q)
    print(f"👤 用户：{q}")
    print(f"🤖 AI：{response}\n")

# lesson10_streaming_and_finetuning.py
import asyncio
from langchain_community.llms import Ollama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# === 第 1 步：初始化模型（支持 LoRA 微调）===
llm = Ollama(
    model="qwen2:7b",
    request_timeout=600.0,
    base_url="http://127.0.0.1:11434",
    streaming=True,
    temperature=0.7,
    top_p=0.9,
    repeat_penalty=1.1
)

# === 第 2 步：角色化提示 ===
prompt = ChatPromptTemplate.from_messages([
    ("system", """
你是一名专业的电商客服，名叫小智。请遵循以下规则：
1. 语气亲切、简洁，避免啰嗦。
2. 回答必须基于事实，不编造信息。
3. 若无法回答，请说：“我正在查询，请稍等。”
4. 支持中文和英文双语回复。
"""),
    ("human", "{input}")
])

# === 第 3 步：构建流式链 ===
chain = prompt | llm | StrOutputParser()

# === 第 4 步：流式输出函数 ===
async def stream_response(question: str):
    print(f"\n👤 用户：{question}")
    print("🤖 小智：", end="", flush=True)
    async for chunk in chain.astream({"input": question}):
        print(chunk, end="", flush=True)
    print()

# === 第 5 步：多轮对话测试 ===
if __name__ == "__main__":
    # 测试流式输出
    test_questions = [
        "你们支持货到付款吗？",
        "退货怎么操作？",
        "能开发票吗？"
    ]

    for q in test_questions:
        asyncio.run(stream_response(q))

from datasets import load_dataset

dataset = load_dataset("json", data_files="customer_service.jsonl")
train_dataset = dataset["train"]

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_name = "./qwen2-7b"  # 或 "Qwen/Qwen2-7B"

# 4-bit 量化配置（大幅降低显存）
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

# 启用梯度检查点（节省显存）
model.gradient_checkpointing_enable()

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# 准备模型用于 k-bit 训练
model = prepare_model_for_kbit_training(model)

# 定义 LoRA 配置
lora_config = LoraConfig(
    r=8,                          # 秩（rank）
    lora_alpha=16,                # 缩放因子
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # Qwen2 的注意力层
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# 应用 LoRA
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 查看可训练参数量（应 < 1%）

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./qwen2-lora-customer-service",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    num_train_epochs=3,
    logging_steps=10,
    save_strategy="epoch",
    evaluation_strategy="no",
    fp16=False,  # 使用 bf16 已在 bnb 中设置
    optim="paged_adamw_8bit",
    lr_scheduler_type="cosine",
    warmup_ratio=0.03,
    report_to="none"  # 关闭 wandb
)

def formatting_prompts_func(example):
    output_texts = []
    for i in range(len(example['instruction'])):
        text = f"<|im_start|>system\n你是一名专业客服<|im_end|>\n<|im_start|>user\n{example['instruction'][i]}<|im_end|>\n<|im_start|>assistant\n{example['output'][i]}<|im_end|>"
        output_texts.append(text)
    return output_texts

# 使用 SFTTrainer（推荐）
from trl import SFTTrainer

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    formatting_func=formatting_prompts_func,
    max_seq_length=512,
    tokenizer=tokenizer
)

trainer.train()

# 保存 LoRA 适配器
model.save_pretrained("./qwen2-lora-customer-service-final")
tokenizer.save_pretrained("./qwen2-lora-customer-service-final")

from peft import PeftModel
from transformers import AutoModelForCausalLM

# 加载原始模型（非量化版，需足够内存）
base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2-7B",
    trust_remote_code=True,
    device_map="auto"
)

# 加载 LoRA 适配器
model = PeftModel.from_pretrained(base_model, "./qwen2-lora-customer-service-final")

# 合并权重
merged_model = model.merge_and_unload()

# 保存完整模型
merged_model.save_pretrained("./qwen2-7b-customer-service-merged")
tokenizer.save_pretrained("./qwen2-7b-customer-service-merged")