AI大模型企业应用实战(15)-langchain核心组件_langchain工作原理

1 Langchain的核心组件

那肯定就是Chain 当然！

Langchain是一种功能强大且灵活的链式处理框架，广泛应用于各种数据处理和分析任务中。它的核心组件是Chain，这是所有处理流程的基石。

1.1 什么是Chain？

在Langchain中，Chain是一个处理单元，负责接收输入数据、执行特定操作并输出结果。每个Chain可以独立工作，也可以与其他Chain组合，形成复杂的处理流程。

Chain 组件图示：

Chain的设计使得数据处理变得模块化和可复用。你可以将不同的Chain拼接在一起，轻松实现数据的传递和处理。

1.2 Chain的工作原理

每个Chain都有三个核心步骤：

1. 输入：接收数据输入，数据可以来自用户输入、文件或其他Chain的输出。
2. 处理：执行特定的操作，如数据清洗、转换、分析等。
3. 输出：将处理后的结果输出，供后续Chain使用或返回给用户。

这种设计模式确保了数据处理流程的高效性和可维护性。

1.3 Chain基类

在Langchain中，所有的Chain都继承自一个基类。这个基类定义了Chain的基本行为和接口：

class Chain:
    def __init__(self):
        pass

    def input(self, data):
        pass

    def process(self, data):
        pass

    def output(self, result):
        pass
1
2
3
4
5
6
7
8
9
10
11

方法详解

• __init__: 初始化Chain实例，通常用于设置初始参数或状态。
• input: 接收输入数据，准备进行处理。
• process: 核心处理逻辑，在这里实现具体的数据操作。
• output: 返回处理结果，供下一个Chain或最终用户使用。

示例

处理一组文本数据，首先进行分词，然后统计词频：

class TokenizeChain(Chain):
    def process(self, data):
        return data.split()

class WordCountChain(Chain):
    def process(self, data):
        from collections import Counter
        return Counter(data)

# 实例化并连接Chain
tokenizer = TokenizeChain()
word_counter = WordCountChain()

# 数据处理流程
data = "Langchain makes data processing modular and reusable"
tokens = tokenizer.process(data)
word_counts = word_counter.process(tokens)

print(word_counts)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

以上示例展示了如何通过组合不同的Chain来完成复杂的数据处理任务。每个Chain专注于特定的操作，使整个流程清晰且易于维护。

结语

Langchain的设计使得数据处理变得简单高效。通过合理利用Chain组件，可以轻松构建和维护复杂的数据处理流程。希望这篇博客能帮助你更好地理解和使用Langchain。

2 常用的chain

在Langchain中，Chain是一个处理单元，负责接收输入数据、执行特定操作并输出结果。每个Chain可以独立工作，也可以与其他Chain组合，形成复杂的处理流程。

2.1 LLMChain

• 最常用的链式
• 提示词模板+(LLM/chatModes)+输出格式化器(可选)
• 支持多种调用方式

这段代码首先导入了所需的库，然后初始化了 OpenAI 的 LLM（语言模型）对象，并设置了温度为 0 以生成最可能的输出。接着，它创建了一个提示模板，用于引导 LLM 生成域名建议。然后，它使用 PromptTemplate 类从模板字符串创建了一个具体的 Prompt 对象。最后，它创建了一个 LLMChain 对象，将 LLM、提示和日志选项作为参数传入。

# 导入所需的库
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# 初始化 OpenAI 的 LLM（语言模型）对象，设置温度为 0（生成最可能的输出）
llm = OpenAI(temperature=0)

# 创建一个提示模板，用于引导 LLM 生成域名建议
prompt_template = "帮我给{product}想三个可以注册的域名?"

# 使用 PromptTemplate 类从模板字符串创建一个具体的 Prompt 对象
prompt = PromptTemplate.from_template(prompt_template)

# 创建一个 LLMChain 对象，将 LLM、提示和日志选项作为参数传入
llm_chain = LLMChain(llm=llm, prompt=prompt, verbose=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2 顺序链

顺序执行

将前一个LLM的输出作为下一个LLM的输入

SimpleSequentialChain

这段代码首先导入了所需的库，然后初始化了 ChatOpenAI 对象，并设置了温度为 0 以生成最可能的输出。接着，它创建了两个提示模板，分别用于引导 LLM 生成公司名称和用五个词描述公司名称。然后，它创建了两个 LLMChain 对象，将 LLM、提示和日志选项作为参数传入。最后，它创建了一个 SimpleSequentialChain 对象，将两个链串联起来，并设置日志选项

from langchain.chains import LLMChain
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import SimpleSequentialChain

# 初始化 ChatOpenAI 对象，设置温度为 0（生成最可能的输出）
chat_model = ChatOpenAI(
    temperature=0,
    model="gpt-3.5-turbo",
)

# 创建第一个提示模板，用于引导 LLM 生成公司名称
first_prompt = ChatPromptTemplate.from_template("帮我给{product}的公司起一个响亮容易记忆的名字?")

# 创建第一个 LLMChain 对象，将 LLM、提示和日志选项作为参数传入
chain_one = LLMChain(
    llm=chat_model,
    prompt=first_prompt,
    verbose=True,
)

# 创建第二个提示模板，用于引导 LLM 用五个词描述公司名称
second_prompt = ChatPromptTemplate.from_template("用5个词来描述一下这个公司名字：{company_name}")

# 创建第二个 LLMChain 对象，将 LLM、提示和日志选项作为参数传入
chain_two = LLMChain(
    llm=chat_model,
    prompt=second_prompt,
    verbose=True,
)

# 创建一个 SimpleSequentialChain 对象，将两个链串联起来，并设置日志选项
overall_simple_chain = SimpleSequentialChain(
    chains=[chain_one, chain_two],
    verbose=True,
)
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

SequentialChain

2.3 RouterChain

路由链支持创建一个非确定性链，由LLM来选择下一步。

链内的多个prompts模板描述了不同的提示请求

Transformation

支持对传递部件的转换。如将一个超长文本过滤转换为仅包含前三个段落，然后提交给LLM。

with open("letter.txt") as f:
    letters = f.read()
1

from langchain.prompts import PromptTemplate
from langchain.chains import (
    LLMChain,
    SimpleSequentialChain,
    TransformChain
)
from langchain.llms import OpenAI

def transform_func(inputs:dict) -> dict:
    text = inputs["text"]
    shortened_text = "\n\n".join(text.split("\n\n")[:3])
    return {"output_text":shortened_text}

#文档转换链
transform_chain = TransformChain(
    input_variables=["text"],
    output_variables=["output_text"],
    transform=transform_func
)

template = """对下面的文字进行总结:
{output_text}

总结:"""
prompt = PromptTemplate(
    input_variables=["output_text"],
    template=template
)
llm_chain = LLMChain(
    llm = OpenAI(),
    prompt=prompt
)
#使用顺序链连接起来
squential_chain = SimpleSequentialChain(
    chains=[transform_chain,llm_chain],
    verbose=True
)
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

#print(letters)
squential_chain.run(letters)
1

结语

Langchain的设计使得数据处理变得简单高效。通过合理利用常用的Chain组件，可以轻松构建和维护复杂的数据处理流程。希望这篇博客能帮助你更好地理解和使用Langchain。

关注我，紧跟本系列专栏文章，咱们下篇再续！

作者简介：魔都架构师，多家大厂后端一线研发经验，在分布式系统设计、数据平台架构和AI应用开发等领域都有丰富实践经验。

各大技术社区头部专家博主。具有丰富的引领团队经验，深厚业务架构和解决方案的积累。

负责：

• 中央/分销预订系统性能优化

• 活动&券等营销中台建设

• 交易平台及数据中台等架构和开发设计

• 车联网核心平台-物联网连接平台、大数据平台架构设计及优化

• LLM应用开发

  目前主攻降低软件复杂性设计、构建高可用系统方向。

参考：

• 编程严选网

  本文由博客一文多发平台 OpenWrite 发布！