《LangChain入门指南》代码实践

本次内容基于《LangChain入门指南》代码实践课程内容
下载文件

import requests

# 定义云端文件的 URL
url = 'https://unlimiai-prod-public.oss-cn-shanghai.aliyuncs.com/jupyter/Langchain_ai360labs.zip'

# 定义本地文件保存路径
local_file_path = './Langchain_ai360labs.zip'

# 发送 HTTP GET 请求下载文件
response = requests.get(url)

# 检查响应状态码是否为 200 (成功)
if response.status_code == 200:
    # 以二进制写入模式打开本地文件
    with open(local_file_path, 'wb') as f:
        # 将响应内容写入本地文件
        f.write(response.content)
    print("文件下载成功！")
else:
    print("文件下载失败。")

解压

import zipfile
import os

# 定义 ZIP 文件路径
zip_file_path = './Langchain_ai360labs.zip'

# 定义解压缩目标文件夹路径
extract_folder_path = './'

# 创建解压缩目标文件夹
os.makedirs(extract_folder_path, exist_ok=True)

# 打开 ZIP 文件
with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
    # 解压缩 ZIP 文件到指定目录
    zip_ref.extractall(extract_folder_path)

print("ZIP 文件解压缩完成。")

# 硬编码传参方式
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    openai_api_key= "填入你的key",
    base_url="填入你的base_url"
)

res = llm.invoke("hello")
print(res.content)

这段代码是一个Python脚本的示例，用于演示如何使用库langchain_openai来与OpenAI的API进行交互。下面是对代码的逐行解释：

1. from langchain_openai import ChatOpenAI：
   这行代码从langchain_openai模块中导入了ChatOpenAI类。这个类可能是用于创建与OpenAI API交互的客户端实例。

2. llm = ChatOpenAI(...)：
   这行代码创建了一个ChatOpenAI类的实例，并将其赋值给变量llm。创建实例时需要提供两个参数：

   • openai_api_key：这是一个字符串，用于提供OpenAI API的访问密钥。在这个示例中，它被标记为“填入你的key”，意味着用户需要将这个占位符替换为实际的OpenAI API密钥。
   • base_url：这是OpenAI API的基础URL。示例中将其标记为“填入你的base_url”，意味着用户需要替换为实际的API基础URL。对于OpenAI的官方API，基础URL通常是https://api.openai.com/v1。也可以填入你的中转API的URL

3. res = llm.invoke("hello")：
   这行代码调用llm实例的invoke方法，并将字符串"hello"作为参数传递给它。这个方法的作用是发送一个请求到OpenAI API，并接收响应。在这个示例中，发送的请求内容是"hello"。

4. print(res.content)：
   这行代码打印出响应对象res的content属性。这个属性包含了API调用的返回内容，通常是文本形式的响应。

from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)

chat = ChatOpenAI(
    openai_api_base=os.getenv("OPENAI_API_BASE_URL"),
    openai_api_key=os.getenv("OPENAI_API_KEY"),
)
chat.predict_messages([
    HumanMessage(
        content=(
            "Translate this sentence from English to French. "
            "I love programming."
        )
    )
])

在这段代码中，我们正在使用LangChain库中的ChatOpenAI类来创建一个聊天模型实例，这个实例将与OpenAI的API进行交互。以下是代码的逐步解释：

1. 导入LangChain的schema模块：

   • 导入了AIMessage、HumanMessage和SystemMessage类，这些类用于创建不同类型的消息对象，以表示不同来源的消息。

2. 创建ChatOpenAI实例：

   • 使用os.getenv函数从环境变量中获取OpenAI的API基础URL和API密钥。这是为了安全地存储和使用敏感信息，如API密钥。
   • 创建ChatOpenAI实例，这个实例将用于发送请求到OpenAI的API，并接收响应。

3. 调用predict_messages方法：

   • predict_messages方法接受一个消息列表作为输入，并返回一个ChatMessage对象作为输出。
   • 在这个例子中，我们创建了一个HumanMessage实例，它包含用户想要翻译的句子：“I love programming.”。

4. 传递消息给模型：

   • 将HumanMessage实例作为列表传递给predict_messages方法。这个方法将发送这个请求到OpenAI的API，并期望得到一个翻译后的法语句子作为响应。

5. 预期输出：

   • 根据ChatOpenAI模型的配置和OpenAI API的能力，预期的输出将是一个AIMessage实例，其中包含翻译后的法语句子。

请注意，这段代码中的ChatOpenAI实例假设已经正确配置了OpenAI API的访问权限，并且LangChain已经安装并正确设置了所需的依赖项。此外，实际的翻译结果将取决于OpenAI API的响应。

invoke 是一个更通用的方法，适用于各种类型的链和模型，而 predict_messages 特别适用于处理聊天模型的输入和输出。

from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

template = (
    "You are a helpful assistant that translates {input_language} to "
    "{output_language}."
)
system_message_prompt = SystemMessagePromptTemplate.from_template(template)

human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

chat_prompt = ChatPromptTemplate.from_messages([
    system_message_prompt,
    human_message_prompt
])

chat_prompt.format_messages(
    input_language="English",
    output_language="French",
    text="I love programming."
)

这段代码是Python语言编写的，它使用了langchain库来创建一个聊天提示模板，用于翻译任务。下面是对代码的逐行解释：

1. from langchain.prompts.chat import ...：这行代码从langchain库的prompts.chat模块导入了三个类：ChatPromptTemplate、SystemMessagePromptTemplate和HumanMessagePromptTemplate。这些类用于创建聊天提示模板。

2. template = ("You are a helpful assistant that translates {input_language} to {output_language}.")：定义了一个字符串模板，其中包含了一个翻译助手的描述。模板中使用了两个占位符{input_language}和{output_language}，它们将被实际的语言代码替换。

3. system_message_prompt = SystemMessagePromptTemplate.from_template(template)：使用SystemMessagePromptTemplate类和上面定义的模板创建了一个系统消息提示模板实例。

4. human_template = "{text}"：定义了另一个字符串模板，这次是用于表示用户输入的消息。模板中使用了占位符{text}，它将被用户的实际输入替换。

5. human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)：使用HumanMessagePromptTemplate类和上面定义的用户输入模板创建了一个人类消息提示模板实例。

6. chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])：使用ChatPromptTemplate类和之前创建的系统消息提示模板以及人类消息提示模板创建了一个聊天提示模板实例。

7. chat_prompt.format_messages(input_language="English", output_language="French", text="I love programming.")：这行代码调用了chat_prompt实例的format_messages方法，将模板中的占位符替换为实际的值。这里，input_language被设置为"English"，output_language被设置为"French"，text被设置为"I love programming."。

最终，这段代码的输出将是一个格式化的字符串，表示一个翻译助手将英语翻译成法语，并翻译了句子"I love programming."。格式化后的字符串可能看起来像这样：“You are a helpful assistant that translates English to French. I love programming.”。

from langchain import LLMChain
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

# 初始化 ChatOpenAI 聊天模型
chat = ChatOpenAI(
        openai_api_base=os.getenv("OPENAI_API_BASE_URL"),
        openai_api_key=os.getenv("OPENAI_API_KEY"),
    )

# 定义系统消息的模板
template = (
    "You are a helpful assistant that translates {input_language} to "
    "{output_language}."
)
system_message_prompt = SystemMessagePromptTemplate.from_template(template)

# 定义人类消息的模板
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

# 将这两种模板组合到聊天提示词模板中
chat_prompt = ChatPromptTemplate.from_messages([
    system_message_prompt, 
    human_message_prompt
])

# 使用 LLMChain 包装模型和提示词模板
chain = LLMChain(llm=chat, prompt=chat_prompt)

# 运行模型链，传入参数
chain.run(
    input_language="English",
    output_language="French",
    text="I love programming."
)

import os

# 设置谷歌搜索的API密钥
# 注册 https://serpapi.com 并获取密钥
os.environ["SERPAPI_API_KEY"] = "28d38……128a1"
import langchain_community.agent_toolkits.load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain_openai import ChatOpenAI

这段代码是Python语言编写的，目的是设置环境变量并初始化一个使用SerpApi和OpenAI的聊天代理。下面是对代码的逐行解释：

1. import os：导入Python的os模块，这个模块提供了与操作系统交互的功能。

2. # 设置谷歌搜索的API密钥：这一行是注释，说明接下来的代码是设置谷歌搜索API的密钥。

3. # 注册 https://serpapi.com 并获取密钥：这是另一行注释，提示用户需要访问SerpApi官网注册账户并获取API密钥。

4. os.environ["SERPAPI_API_KEY"] = "28d38……128a1"：这行代码设置了环境变量SERPAPI_API_KEY，其值为用户的SerpApi API密钥。注意，这里显示的API密钥是被省略号替代的，实际使用时需要填入完整的密钥。

5. import langchain_community.agent_toolkits.load_tools：导入langchain社区的load_tools模块，这个模块可能用于加载一些工具包。

6. from langchain.agents import initialize_agent：从langchain库的agents模块导入initialize_agent函数，这个函数可能用于初始化代理。

7. from langchain.agents import AgentType：从langchain库的agents模块导入AgentType枚举，这个枚举可能定义了不同类型的代理。

8. from langchain_openai import ChatOpenAI：从langchain_openai模块导入ChatOpenAI类，这个类可能是用于创建与OpenAI聊天功能的代理。

这段代码主要是为了配置环境并准备使用langchain库中的代理功能，通过设置API密钥和导入所需的模块和函数，为创建具有搜索和聊天功能的代理做准备。实际使用时，需要替换掉API密钥占位符，并根据需要调用相关函数来初始化代理。

from langchain.agents import load_tools
llm = ChatOpenAI(
    openai_api_base=os.getenv("OPENAI_API_BASE_URL"),
    openai_api_key=os.getenv("OPENAI_API_KEY"),
)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
agent =initialize_agent(tools, llm=llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("什么是机器学习？")
agent.run("6的15次方等于多少?")

这段代码是使用Python编写的，它演示了如何使用langchain库来创建一个具有特定功能的代理（agent），这个代理可以执行与机器学习和数学计算相关的任务。下面是对代码的逐行解释：

1. from langchain.agents import load_tools：从langchain库的agents模块导入load_tools函数，这个函数用于加载代理可以使用的工具。

2. llm = ChatOpenAI(...)：创建一个ChatOpenAI实例，这个实例用于与OpenAI的API进行交互。它需要两个参数：openai_api_base和openai_api_key，这两个参数从环境变量中获取。

3. tools = load_tools(["serpapi", "llm-math"], llm=llm)：调用load_tools函数来加载名为"serpapi"和"llm-math"的工具，并将之前创建的llm实例传递给这些工具。

4. agent = initialize_agent(tools, llm=llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)：使用initialize_agent函数来初始化一个代理，这个代理使用加载的工具和llm实例。agent参数设置为AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION，这指定了代理的类型。verbose=True表示在执行过程中打印额外的详细信息。

5. agent.run("什么是机器学习？")：调用代理的run方法来执行一个任务，这个任务是回答“什么是机器学习？”这个问题。

6. agent.run("6的15次方等于多少?")：再次调用run方法来执行另一个任务，这个任务是计算6的15次方的结果。

这段代码展示了如何配置和使用langchain库中的代理来处理自然语言查询，包括定义代理使用的API密钥、加载工具、初始化代理以及执行具体的查询任务。需要注意的是，代码中的环境变量（如OPENAI_API_BASE_URL和OPENAI_API_KEY）需要用户根据实际情况进行设置。此外，"serpapi"和"llm-math"工具的具体实现和功能没有在代码中给出，它们可能是langchain库提供的或者需要用户自定义实现。

from langchain.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate
)
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory

prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template(
    """	
    The following is a friendly conversation between a human and an AI.
    The AI istalkative and provides lots of specific details from its
    context. If the AI does not know the answer to a question,
    it truthfully says it does not know.
    """
    ),
    MessagesPlaceholder(variable_name="history"),
    HumanMessagePromptTemplate.from_template("{input}")
])

llm = ChatOpenAI(temperature=0,openai_api_base=os.getenv("OPENAI_API_BASE_URL"),
    openai_api_key=os.getenv("OPENAI_API_KEY"),)
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)
conversation.predict(input="你好，我是李特丽!")

这段代码是使用Python编写的，它演示了如何使用langchain库和langchain_openai模块创建一个基于OpenAI的聊天机器人。以下是对代码的逐行解释：

1. from langchain.prompts import ...：从langchain库的prompts模块导入了一些类，这些类用于创建和管理聊天机器人的提示模板。

2. from langchain.chains import ConversationChain：从langchain库导入ConversationChain类，这个类用于创建能够进行对话的链式处理流程。

3. from langchain_openai import ChatOpenAI：从langchain_openai模块导入ChatOpenAI类，这个类封装了与OpenAI聊天模型的交互。

4. from langchain.memory import ConversationBufferMemory：从langchain库导入ConversationBufferMemory类，这个类用于存储对话历史。

5. prompt = ChatPromptTemplate.from_messages([...])：创建一个聊天提示模板，它由系统消息、对话历史占位符和人类消息组成。

6. SystemMessagePromptTemplate.from_template(...)：定义了一个系统消息模板，这个模板描述了AI的性格和行为准则。

7. MessagesPlaceholder(variable_name="history")：创建一个消息占位符，用于在提示中插入对话历史。

8. HumanMessagePromptTemplate.from_template("{input}")：定义了一个人类消息模板，它简单地将输入作为提示的一部分。

9. llm = ChatOpenAI(...)：创建一个ChatOpenAI实例，配置了OpenAI的API基础URL和API密钥，这些信息从环境变量中获取。

10. memory = ConversationBufferMemory(return_messages=True)：创建一个对话缓冲区记忆实例，它配置为返回对话消息。

11. conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)：创建一个ConversationChain实例，它使用前面创建的记忆和提示模板，以及ChatOpenAI实例作为底层的语言模型。

12. conversation.predict(input="你好，我是李特丽!")：使用ConversationChain实例的predict方法来进行对话预测，输入是"你好，我是李特丽!"。

这段代码展示了如何配置聊天机器人的提示、创建聊天链、设置记忆，并使用OpenAI的语言模型来进行对话预测。需要注意的是，代码中的环境变量（如OPENAI_API_BASE_URL和OPENAI_API_KEY）需要用户根据实际情况进行设置。此外，temperature=0参数意味着生成的回复将具有确定性，即每次生成的回复都将是相同的。

from langchain.prompts import ChatPromptTemplate
# from langchain.chat_models import ChatOpenAI
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

# 实例化提示词模板和聊天模型包装器
prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
model = llm

# 定义处理链
chain = prompt | model | StrOutputParser()

# 调用处理链
# response = chain.invoke({"foo": "bears"})
response = chain.invoke({"topic": "bears"})
print(response)  
# 输出："Why don't bears wear shoes?\n\nBecause they have bear feet!"