环境准备

  • 依赖(Python >= 3.11):langchain、langchain-openai、dotenv
  • .env 环境变量:
    • OPENAI_API_KEY:模型供应商密钥
    • OPENAI_BASE_URL:模型供应商请求地址
    • OPENAI_MODEL:模型名称

检查环境变量

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

import langchain
from dotenv import load_dotenv

# 读取环境变量
load_dotenv()

# 模型供应商
api_key = {
"OPENAI_API_KEY": os.getenv("OPENAI_API_KEY"),
"OPENAI_BASE_URL": os.getenv("OPENAI_BASE_URL")
}

print(f"LangChain 版本:{langchain.__version__}")
print("OPENAI_API_KEY:", "已配置" if api_key["OPENAI_API_KEY"] else "未配置")
print("OPENAI_BASE_URL:", "已配置" if api_key["OPENAI_BASE_URL"] else "未配置")

模型调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

llm = ChatOpenAI(
base_url=os.getenv("OPENAI_BASE_URL"),
api_key=os.getenv("OPENAI_API_KEY"),
model=os.getenv("OPENAI_MODEL")
)

response = llm.invoke("做个自我介绍让我认识你")

print(response)

后续示例均使用以下模型初始化:

1
2
3
4
5
6
model = ChatOpenAI(
base_url=os.getenv("OPENAI_BASE_URL"),
api_key=os.getenv("OPENAI_API_KEY"),
model=os.getenv("OPENAI_MODEL"),
temperature=0.7,
)

提示词模板

PromptTemplate 提示词模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from langchain_core.prompts import PromptTemplate

# 创建提示词模板
template = PromptTemplate.from_template("你是{domain}专家,你擅长{skill},问题:{query}")

# 创建链
chain = template | model

# 调用链
response = chain.invoke({
"domain": "金融",
"skill": "金融知识",
"query": "你知道哪些金融机构?"
})

print(response)

PromptTemplate format 格式化

1
2
3
4
5
6
7
8
9
10
11
# 格式化提示词
formatted_template = template.format_prompt( # format_prompt 可以换为 format 对比 response
domain="数学",
skill="计算",
query="100+125=?"
)

# 调用模型
response = model.invoke(formatted_template)

print(response.content)

ChatPromptTemplate 提示词对话模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from langchain_core.prompts import ChatPromptTemplate

# 创建提示词对话模板
chat_template = ChatPromptTemplate.from_messages(
[
("system", "你是{domain}专家,你擅长{skill}"),
("human", "{input}")
]
)

# 链
chain = chat_template | model

# 调用链
response = chain.invoke({
"domain": "金融",
"skill": "金融知识",
"input": "你知道哪些金融机构?"
})

print(response.content)

ChatPromptTemplate format_messages 格式化

1
2
3
4
5
6
7
8
9
10
11
# 格式化对话提示词
format = chat_template.format_messages( # format_messages 可以换为 format 对比 response
domain="金融",
skill="金融知识",
input="你知道哪些金融机构?"
)

# 调用模型
response = model.invoke(format)

print(response.content)

输出解析器

不使用输出解析器

链的输出为 Message 对象,需要 .content 取内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
# 格式化对话提示词
chain = chat_template | model

reviews = [
{"domain": "数学", "skill": "计算", "input": "110 * 3 - 100"},
{"domain": "数学", "skill": "计算", "input": "100 * 2 - 100"},
{"domain": "数学", "skill": "计算", "input": "30 * 3 - 100"}
]

for review in reviews:
response = chain.invoke(review)
print(f"问题:{review}")
print(f"内容:{response.content}")

StrOutputParser

StrOutputParser 将模型的输出转换为字符串:

1
2
3
4
5
6
7
8
9
from langchain_core.output_parsers import StrOutputParser

# 格式化对话提示词,StrOutputParser 将模型的输出转换为 字符串
chain = chat_template | model | StrOutputParser()

for review in reviews:
response = chain.invoke(review)
print(f"问题:{review}")
print(f"内容:{response}")

CommaSeparatedListOutputParser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from langchain_core.output_parsers import CommaSeparatedListOutputParser

list_parser = CommaSeparatedListOutputParser()

# 把解析器要求的格式放进提示词里面
format_instrurtions = list_parser.get_format_instructions()
print(format_instrurtions)

# 创建提示词对话模板
list_prompt = ChatPromptTemplate.from_template(
"你是{domain}专家,你擅长{skill},输出:\n{format_instrurtions}"
)

# 链 管道符
list_chain = list_prompt | model | list_parser

result = list_chain.invoke(
{
"domain": "信息收集",
"skill": "在互联网查询信息,找出五门热门编程语言",
"format_instrurtions": format_instrurtions
}
)
print(result) # ['Python', 'JavaScript', 'Java', 'C++', 'C#']

并行链 RunnableParallel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from langchain_core.runnables import RunnableParallel

translate_prompt = ChatPromptTemplate.from_template("将下面的中文翻译成英文:{text}")
summarize_prompt = ChatPromptTemplate.from_template("将下面的内容总结为一句话,不超过50字:{text}")

step1 = translate_prompt | model | StrOutputParser()
step2 = summarize_prompt | model | StrOutputParser()

# 并行链
parallel_chain = RunnableParallel[dict](
{
"translate": step1,
"summary": step2
}
)

results = parallel_chain.invoke(
{
"text": "黄金今年大起大落"
}
)
print(results)

记忆

InMemoryChatMessageHistory

1
2
3
4
5
6
7
8
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.messages import HumanMessage

chat_history = InMemoryChatMessageHistory()
chat_history.add_message(HumanMessage(content="你好"))
chat_history.add_message(HumanMessage(content="做个自我介绍"))
chat_history.add_message(HumanMessage(content="具体说说"))
print(chat_history.messages)