LangChain入门教程：从零到一构建智能应用

1

pip install langchain langchain-core langchain-community langchain-experimental ollama

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from langchain_community.chat_models import ChatOllama
from langchain_core.messages import HumanMessage, SystemMessage

# 初始化模型，这里我们使用 qwen:7b-chat
# 如果你下载的是其他模型，请替换 model="qwen:7b-chat"
llm = ChatOllama(model="qwen:7b-chat")

# 准备消息
messages = [
    SystemMessage(content="你是一个专业的AI助手。"),
    HumanMessage(content="你好，请用一句话介绍一下自己。"),
]

# 调用模型
response = llm.invoke(messages)
print(response.content)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from langchain_core.prompts import ChatPromptTemplate

# 创建一个模板，其中 {topic} 是一个占位符
prompt_template = ChatPromptTemplate.from_template(
    "请给我写一首关于 {topic} 的五言绝句。"
)

# 格式化模板，传入具体的值
prompt_value = prompt_template.invoke({"topic": "月亮"})
print(prompt_value)

# 我们可以直接将模板和模型连接起来
chain = prompt_template | llm
response = chain.invoke({"topic": "长城"})
print(response.content)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

from langchain_core.output_parsers import StrOutputParser, JsonOutputParser

# 默认的字符串解析器
parser = StrOutputParser()

# 构建链
chain = prompt_template | llm | parser

# 调用链，输出将是纯字符串
result = chain.invoke({"topic": "西湖"})
print(result)

# 示例：JSON 解析器
json_prompt = ChatPromptTemplate.from_template(
    "根据用户信息 `{user_input}`，提取姓名和年龄，并以JSON格式返回。JSON格式为: {format_instructions}"
)
json_parser = JsonOutputParser()

# 将解析器的格式说明注入到提示中
chain = json_prompt | llm | json_parser

response = chain.invoke({
    "user_input": "你好，我叫张三，今年25岁。",
    "format_instructions": json_parser.get_format_instructions(),
})
print(response)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from langchain_community.chat_models import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from pydantic import BaseModel, Field

# 1. 定义我们期望的输出数据结构 (Pydantic 模型)
class Poem(BaseModel):
    title: str = Field(description="这首诗的标题")
    author: str = Field(description="这首诗的作者")
    poem_text: str = Field(description="诗的全文内容")

# 2. 初始化模型和解析器
llm = ChatOllama(model="qwen:7b-chat")
parser = JsonOutputParser(pydantic_object=Poem)

# 3. 创建提示模板，并包含格式化指令
prompt = ChatPromptTemplate.from_template(
    "请根据主题 '{topic}' 创作一首古诗。\n{format_instructions}"
)

# 4. 使用 LCEL 构建链
chain = prompt | llm | parser

# 5. 调用链
response = chain.invoke({
    "topic": "友谊",
    "format_instructions": parser.get_format_instructions()
})

print(response)
print(f"标题: {response['title']}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

import bs4
from langchain_community.chat_models import ChatOllama
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_text_splitters import RecursiveCharacterTextSplitter

# 1. 加载 (Load): 从网页加载数据
loader = WebBaseLoader(
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
    bs_kwargs=dict(
        parse_only=bs4.SoupStrainer(
            class_=("post-content", "post-title", "post-header")
        )
    ),
)
docs = loader.load()

# 2. 分割 (Split): 将文档分割成小块
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(docs)

# 3. 存储 (Store): 创建向量数据库
# 使用Ollama的嵌入功能，也可以换成其他嵌入模型
embeddings = OllamaEmbeddings(model="qwen:7b-chat")
vectorstore = FAISS.from_documents(documents=splits, embedding=embeddings)

# 4. 检索 (Retrieve): 创建检索器
retriever = vectorstore.as_retriever()

# 5. 生成 (Generate): 创建RAG链
llm = ChatOllama(model="qwen:7b-chat")
prompt = ChatPromptTemplate.from_template("""
你是一个问答机器人。请根据下面提供的上下文来回答用户的问题。
如果上下文中没有相关信息，就说你不知道。

上下文: {context}
问题: {question}
""")

# 定义RAG链
rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 调用链
question = "What is Task Decomposition?"
response = rag_chain.invoke(question)
print(response)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

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

llm = ChatOllama(model="qwen:7b-chat")
memory = ConversationBufferMemory()

# ConversationChain 是一个内置了记忆功能的链
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True # 设置为True可以看到内部的提示变化
)

print(conversation.invoke("你好，我叫李华。"))
# 第二次调用，模型会记得我的名字
print(conversation.invoke("我叫什么名字？"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from langchain_community.tools import DuckDuckGoSearchRun
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

# 1. 初始化模型和工具
llm = ChatOllama(model="qwen:7b-chat")
search = DuckDuckGoSearchRun()
tools = [search]

# 2. 获取预置的 Agent 提示模板
# "ReAct" 是一种流行的 Agent 思考模式 (Reasoning and Acting)
prompt = hub.pull("hwchase17/react")

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

# 4. 创建 Agent 执行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 5. 运行 Agent
response = agent_executor.invoke({
    "input": "今天北京的天气怎么样？最高温度是多少？"
})

print(response['output'])