LangChain 框架教程¶

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# 聊天模型
llm = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.7,
    api_key="your-api-key"
)

# 嵌入模型
embeddings = OpenAIEmbeddings()

# 调用模型
response = llm.invoke("你好，请介绍一下自己")
print(response.content)

from langchain.prompts import ChatPromptTemplate

# 简单模板
prompt = ChatPromptTemplate.from_template(
    "你是一个{role}。请用{style}风格回答：{question}"
)

# 创建消息
messages = prompt.invoke({
    "role": "专家",
    "style": "简洁专业",
    "question": "什么是机器学习？"
})

# 格式化输出
response = llm.invoke(messages)
print(response.content)

from langchain.chains import LLMChain
from langchain.prompts import ChatPromptTemplate

# 创建链
prompt = ChatPromptTemplate.from_template(
    "请为{product}写一段营销文案"
)
chain = LLMChain(llm=llm, prompt=prompt)

# 运行链
result = chain.invoke({"product": "智能手表"})
print(result['text'])

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory

# 对话缓冲区
memory = ConversationBufferMemory()
memory.save_context(
    {"input": "你好"},
    {"output": "你好！有什么可以帮你的吗？"}
)

# 对话摘要
summary_memory = ConversationSummaryMemory(llm=llm)

from langchain.retrievers import VectorStoreRetriever

# 创建检索器
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 3}
)

# 检索文档
docs = retriever.invoke("什么是深度学习？")

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# 1. 创建向量数据库
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
docs = text_splitter.split_documents(raw_documents)
vectorstore = FAISS.from_documents(docs, OpenAIEmbeddings())

# 2. 创建检索器
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 3. 定义Prompt
prompt = PromptTemplate.from_template(
    """基于以下上下文回答问题。如果不确定，请说明。

上下文：
{context}

问题：{question}

回答："""
)

# 4. 创建QA链
qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-5.5"),
    chain_type="stuff",
    retriever=retriever,
    chain_type_kwargs={"prompt": prompt}
)

# 5. 查询
result = qa_chain.invoke({"query": "什么是机器学习？"})
print(result['result'])

from langchain.chains import RetrievalQAWithSourcesChain

# 带来源的QA链
qa_chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=ChatOpenAI(model="gpt-5.5"),
    chain_type="stuff",
    retriever=retriever
)

result = qa_chain.invoke({"query": "什么是深度学习？"})
print(f"回答: {result['answer']}")
print(f"来源: {result['sources']}")

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.tools import tool
from langchain.prompts import ChatPromptTemplate

# 定义工具
@tool
def search(query: str) -> str:
    """搜索互联网获取信息"""
    return f"搜索结果: {query}的相关信息..."

@tool
def calculator(expression: str) -> str:
    """执行数学计算"""
    return str(eval(expression))

# 创建Agent
tools = [search, calculator]

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有用的助手，可以使用工具帮助用户。"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 运行Agent
result = executor.invoke({"input": "搜索今天的天气，然后计算25度是多少华氏度"})
print(result['output'])

from langchain.agents import AgentExecutor, create_react_agent
from langchain.prompts import PromptTemplate

# ReAct提示模板
react_prompt = PromptTemplate.from_template("""
Answer the following questions as best you can. You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

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

# 创建ReAct Agent
agent = create_react_agent(llm, tools, react_prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "北京今天天气如何？"})

from langchain.chains import SequentialChain, LLMChain

# 链1：生成标题
title_prompt = LLMChain.from_string(
    llm=llm,
    template="为以下内容生成一个吸引人的标题：{content}"
)

# 链2：生成摘要
summary_prompt = LLMChain.from_string(
    llm=llm,
    template="为以下标题写一段100字的摘要：{title}"
)

# 顺序链
chain = SequentialChain(
    chains=[title_prompt, summary_prompt],
    input_variables=["content"],
    output_variables=["title", "summary"],
    verbose=True
)

result = chain.invoke({"content": "人工智能正在改变世界..."})

from langchain.chains import MultiRouteChain, RouterChain

# 路由链
router_prompt = RouterChain.from_equalizer(
    llm=llm,
    input_key="question",
    default_chain=default_chain,
    routing_chains={
        "math": math_chain,
        "code": code_chain,
        "general": general_chain
    }
)

result = router_prompt.invoke({"question": "1+1等于多少？"})

from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate
import gradio as gr

class CustomerServiceBot:
    def __init__(self, faq_docs):
        self.setup_chain(faq_docs)

    def setup_chain(self, docs):
        # 创建向量库
        embeddings = OpenAIEmbeddings()
        vectorstore = FAISS.from_documents(docs, embeddings)

        # 创建记忆
        memory = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )

        # 定义Prompt
        prompt = PromptTemplate.from_template("""
你是一个专业的客服助手。基于以下上下文和对话历史回答问题。

上下文：{context}

对话历史：
{chat_history}

当前问题：{question}

请用友好、专业的语气回答。如果不确定，请说明。
        """)

        # 创建对话检索链
        self.chain = ConversationalRetrievalChain.from_llm(
            llm=ChatOpenAI(model="gpt-5.5"),
            retriever=vectorstore.as_retriever(),
            memory=memory,
            combine_docs_chain_kwargs={"prompt": prompt}
        )

    def chat(self, question):
        result = self.chain.invoke({"question": question})
        return result['answer']

# 创建聊天界面
bot = CustomerServiceBot(faq_documents)

with gr.Blocks(title="智能客服") as demo:
    gr.Markdown("# 智能客服系统")
    chatbot = gr.Chatbot()
    msg = gr.Textbox(label="请输入问题")

    def respond(message, chat_history):
        response = bot.chat(message)
        chat_history.append((message, response))
        return "", chat_history

    msg.submit(respond, [msg, chatbot], [msg, chatbot])

demo.launch()

from langchain_community.document_loaders import (
    PyPDFLoader,           # PDF
    TextLoader,            # 文本
    UnstructuredMarkdownLoader,  # Markdown
    CSVLoader,             # CSV
    JSONLoader,            # JSON
    WebBaseLoader,         # 网页
    NotionDirectoryLoader  # Notion
)

from langchain.text_splitter import (
    RecursiveCharacterTextSplitter,  # 递归分割
    CharacterTextSplitter,           # 字符分割
    TokenTextSplitter               # Token分割
)

from langchain_community.vectorstores import (
    FAISS,        # Facebook
    Chroma,       # 轻量级
    Pinecone,     # 云服务
    Weaviate,     # GraphQL
    Milvus        # 分布式
)