langchain

(本文为个人学习笔记，内容较为基础，如有错误，欢迎指正。欲了解详细信息，请参考官方文档。)
https://api.python.langchain.com/en/latest/langchain_api_reference.html

LangChain的功能比较广泛，涵盖了多个方面，主要包括以下几个方面：

链式操作（Chains）：

LangChain允许用户将多个语言模型调用组合成一个复杂的操作流程。例如，可以创建一个链式操作，其中第一个步骤是从用户获取输入，第二个步骤是处理和分析该输入，第三个步骤是生成相应的回复。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from dotenv import load_dotenv, find_dotenv
# 加载api
load_dotenv(find_dotenv())

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.chains import Chain

# 创建语言模型实例 默认3.5
llm = ChatOpenAI()

# 创建Prompt Template并引入变量
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are the technical writer"),
    ("user", "{input}")  # {input}为变量
])

# 将Prompt和LLM结合到Chain中
chain = prompt | llm
response = chain.invoke({"input": "What is the Sora model?"})
print(response)

Agents：

智能体是指能够在动态环境中做决策的实体。LangChain支持创建智能代理，这些代理可以根据具体任务选择不同的语言模型或策略来完成任务。例如，可以创建一个代理来管理和优化与用户的对话流程。

特性：

  • 解决复杂问题
  • 依赖不同tool（tool的description是agent调用它的依据）
  • 复杂问题拆分为简单问题
    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.language_models import BaseLanguageModel
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.tools import Tool
    from langchain_core.agents import create_openai_functions_agent, AgentExecutor

    # 创建语言模型实例
    llm = BaseLanguageModel()  # 使用实际的语言模型实例

    # 创建工具实例
    tools = [Tool(name="search_tool", func=search_function, description="Search the web")]  # 定义实际的工具

    # 创建Prompt Template
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a knowledgeable assistant."),
        ("user", "{input}")  # {input}为变量
    ])

    # 创建代理
    agent = create_openai_functions_agent(llm=llm, tools=tools, prompt=prompt)

    # 创建代理执行器
    agent_executor = AgentExecutor(agent=agent, tools=tools)

    # 执行代理
    response = agent_executor.invoke({"input": "Tell me about LangChain."})
    print(response)

文档检索（Document Retrieval）：

LangChain支持从各种数据源中检索和处理文档。通过与数据库或知识库的集成，用户可以检索相关信息并将其与语言模型的能力结合起来，提高模型的回答准确性和上下文相关性。

1
2
3
4
5
6
7
8
9
from langchain_community.document_loaders import CSVLoader
loader = CSVLoader(file_path="")
data = loader.load()
print(data)

from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader("./example.pdf")
pages = loader.load()
print(pages[0].page_content.replace("\n", " "))

自定义模板（Custom Templates）：

允许用户根据需要创建自定义的文本生成模板。这样可以更好地控制生成内容的格式和风格，适应不同的应用场景。
数据输入和输出处理（Data Input/Output Processing）：

提供了处理和转换输入和输出数据的功能。用户可以自定义数据预处理和后处理步骤，以便更好地适应应用需求。

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

# 创建语言模型实例
llm = ChatOpenAI()

# 定义自定义模板
template = "Dear {name},\n\nThank you for reaching out. {response}\n\nBest regards,\nYour Assistant"

# 输入变量
variables = {
    "name": "John",
    "response": "We have received your inquiry and will get back to you shortly."
}

# 使用模板生成文本
prompt = ChatPromptTemplate.from_template(template, variables)
response = llm.generate(prompt)
print(response)

API和接口集成（API and Integration Interfaces）：

LangChain能够与各种API和外部服务集成。用户可以通过这些接口获取额外的信息，或将生成的内容发送到其他系统中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from langchain_core.api_integrators import APIIntegrator
import requests

# 创建API集成器实例
api_integrator = APIIntegrator(api_url="https://api.example.com/data")

# 定义API请求参数
params = {"query": "LangChain"}

# 调用API并获取响应
response = api_integrator.call_api(params)

# 打印API响应
print(response.json())

调试和日志记录（Debugging and Logging）：

提供了调试和日志记录功能，帮助开发者监控和排除应用中的问题。

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

# 配置日志记录
logging.basicConfig(level=logging.DEBUG)

# 创建日志记录器实例
logger = Logger()

# 定义需要记录的操作
def my_function(input_text):
    logger.log_debug(f"Processing input: {input_text}")
    result = input_text.upper()
    logger.log_debug(f"Processed result: {result}")
    return result

# 调用函数并记录日志
input_text = "Hello, LangChain!"
result = my_function(input_text)
print(result)

扩展和插件支持（Extensibility and Plugins）：

LangChain的设计允许用户根据需要扩展框架的功能，可以通过插件机制添加新的功能模块或改进现有功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from langchain_core.plugins import Plugin

# 定义一个简单的插件
class MyPlugin(Plugin):
    def process(self, input_text):
        return input_text[::-1]  # 将输入文本反转

# 创建插件实例
plugin = MyPlugin()

# 输入文本
input_text = "Hello, LangChain!"

# 使用插件处理输入文本
processed_text = plugin.process(input_text)

# 打印处理后的文本
print(processed_text)