from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage

llm = ChatOllama(model="qwen3:8b", temperature=0.8)
response = llm.invoke([HumanMessage(content="你好，请介绍一下自己")])

print(response.content)

from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama

# 创建模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位专业的{role}，用中文回答问题。"),
    ("human", "{question}")
])

# 模型
llm = ChatOllama(model="qwen3:8b", temperature=0.8)

# 组合成 Chain（管道操作符 |）
chain = prompt | llm

# 运行
result = chain.invoke({
    "role": "Python 导师",
    "question": "有哪些基础变量？"
})

print(result.content)

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama

# 模型
llm = ChatOllama(model="qwen3:8b", temperature=0.8)

# 完整链条：Prompt -> LLM -> 字符串输出
chain = (
    ChatPromptTemplate.from_template("用一句话解释{concept}")
    | llm
    | StrOutputParser()  # 提取纯文本
)

output = chain.invoke({"concept": "递归函数"})

print(output)
# 递归函数是一种通过调用自身来解决问题的方法，通常包含一个终止条件以防止无限循环。

from langchain.chains import ConversationChain
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_ollama import ChatOllama

# 1. 初始化模型
llm = ChatOllama(model="qwen3:8b", temperature=0.8)

# 2. 定义提示模板（使用 MessagesPlaceholder 注入历史）
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有用的助手。请用中文回答。"),
    MessagesPlaceholder(variable_name="history"),  # 历史消息占位符
    ("human", "{input}")
])

# 3. 构建基础 chain
chain = prompt | llm | StrOutputParser()

# 4. 存储历史会话
store = {}

# 创建对话链
def get_session_history(session_id: str) -> InMemoryChatMessageHistory:
    """根据 session_id 获取或创建对话历史"""
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

# 5. 包装为带历史记录的 Runnable
conversation = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",  # 输入消息的键名
    history_messages_key="history"  # 历史消息的键名（与 MessagesPlaceholder 对应）
)

# 6. 使用方式（必须传入 config 指定 session_id）
config = {"configurable": {"session_id": "user_123"}}

# 第一次对话
response1 = conversation.invoke(
    {"input": "你好，我叫张三"},
    config=config
)

# 第二次对话（能记住名字）
response2 = conversation.invoke(
    {"input": "我叫什么名字？"},
    config=config
)

print(response2)
# 你好，张三！我刚刚确认了你的名字，很高兴认识你。有什么我可以帮你的吗？

from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.prompts import PromptTemplate
from langchain_ollama import ChatOllama
import os

# 设置 Tavily API Key（https://tavily.com 免费注册获取）
os.environ["TAVILY_API_KEY"] = "tvly-dev-key"

# 初始化工具（中文描述帮助模型理解工具用途）
tools = [
    TavilySearchResults(
        max_results=3,
        description="搜索引擎，用于查找实时信息、新闻、百科知识等网络内容"
    )
]

# 初始化本地模型
llm = ChatOllama(model="qwen3:8b", temperature=0)

# 中文 ReAct 提示模板
# 注意：Thought/Action/Action Input/Observation/Final Answer 必须保持英文
# 这些是 Agent 的解析标记，改为中文会导致识别失败
template = """尽可能回答用户问题。你可以使用以下工具：

{tools}

使用以下格式：

Question: 需要回答的输入问题
Thought: 思考应该采取什么行动
Action: 要执行的行动，必须是 [{tool_names}] 之一
Action Input: 行动的输入（直接的问题或关键词）
Observation: 行动执行后的返回结果
...（Thought/Action/Action Input/Observation 可以重复多次）
Thought: 我现在知道最终答案了
Final Answer: 对原始问题的最终回答（用中文回答）

重要提示：当前年份是2026年，如果问题涉及最新事件，必须使用工具搜索，不要依赖预训练知识。

开始回答！

Question: {input}
Thought:{agent_scratchpad}"""

# 创建提示模板
prompt = PromptTemplate.from_template(template)

# 创建 Agent
agent = create_react_agent(llm, tools, prompt)

# 创建执行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=False,  # 关闭详细日志避免乱码
    handle_parsing_errors=True,  # 自动处理解析错误
    max_iterations=5  # 最多思考5步，防止死循环
)

# 运行查询
if __name__ == "__main__":
    question = "2024年春晚节目单？"
    print(f"问题：{question}")
    print("-" * 50)

    try:
        response = agent_executor.invoke({"input": question})
        print(f"答案：{response['output']}")
    except Exception as e:
        print(f"执行出错：{e}")

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_ollama import ChatOllama, OllamaEmbeddings

# 1. 加载 & 切分（不变）
loader = TextLoader("company_manual.txt", encoding="utf-8")

documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
texts = text_splitter.split_documents(documents)

# 2. 向量数据库（使用本地 Ollama 嵌入，无需 OpenAI API Key）
embeddings = OllamaEmbeddings(model="shaw/dmeta-embedding-zh:latest")
vectorstore = FAISS.from_documents(texts, embeddings)

# 3. 构建 LCEL RAG 链
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

template = """基于以下上下文回答问题。如果不知道，就说"根据资料无法确定"。

上下文：
{context}

问题：{question}

请用中文回答："""

prompt = ChatPromptTemplate.from_template(template)

def format_docs(docs):
    """将检索到的文档格式化为字符串"""
    return "\n\n".join(f"[来源{i+1}] {doc.page_content}"
                      for i, doc in enumerate(docs))

# 构建链：输入 → 检索+格式化 → 填充模板 → LLM → 输出
rag_chain = (
    {
        "context": retriever | format_docs,  # 检索并格式化文档
        "question": RunnablePassthrough()     # 直接传递用户问题
    }
    | prompt
    | ChatOllama(model="qwen3:8b")
    | StrOutputParser()
)

# 4. 提问（新版用 invoke，不再传字典）
result = rag_chain.invoke("公司的年假政策是什么？")
print(result)

# 5. 如需查看来源（手动获取）
docs = retriever.invoke("公司的年假政策是什么？")
print("\n参考片段：")
for i, doc in enumerate(docs, 1):
    print(f"{i}. {doc.page_content[:100]}...")