LangChain基础Chain构建指南

发布时间: 2025-03-29 19:06

↑

# LangChain基础Chain构建指南

本文将详细介绍如何在LangChain中构建和使用基础Chain，帮助你理解Chain的核心概念并掌握其使用方法。

## Chain简介

Chain（链）是LangChain的核心概念之一，它允许我们将多个组件（如LLM、Prompt、Memory等）组合成一个处理流程。

## 基础Chain类型

### 1. LLMChain

最基础的Chain类型，将Prompt和LLM组合：

```python
from langchain import PromptTemplate, LLMChain
from langchain.llms import OpenAI

# 创建提示模板
template = """请为{product}写一个广告语，
要求：简短、吸引人、突出产品特点"""

prompt = PromptTemplate(
    input_variables=["product"],
    template=template
)

# 创建LLM
llm = OpenAI(temperature=0.7)

# 创建Chain
chain = LLMChain(llm=llm, prompt=prompt)

# 运行Chain
result = chain.run(product="智能手表")
print(result)
```

### 2. SimpleChain

简单的转换Chain：

```python
from langchain.chains import SimpleChain

def uppercase_transform(text: str) -> str:
    return text.upper()

# 创建转换Chain
chain = SimpleChain(transform=uppercase_transform)

# 运行Chain
result = chain.run("hello world")
print(result)  # 输出：HELLO WORLD
```

### 3. TransformChain

可自定义转换逻辑的Chain：

```python
from langchain.chains import TransformChain

def transform_func(inputs: dict) -> dict:
    text = inputs["text"]
    word_count = len(text.split())
    return {"word_count": word_count}

# 创建转换Chain
chain = TransformChain(
    input_variables=["text"],
    output_variables=["word_count"],
    transform=transform_func
)

# 运行Chain
result = chain.run(text="这是一个测试句子")
print(result)  # 输出：{'word_count': 5}
```

## Chain组合

### 1. 串联组合

```python
from langchain.chains import SimpleChain

def remove_spaces(text: str) -> str:
    return text.replace(" ", "")

def to_uppercase(text: str) -> str:
    return text.upper()

# 创建两个Chain
chain1 = SimpleChain(transform=remove_spaces)
chain2 = SimpleChain(transform=to_uppercase)

# 串联执行
text = "hello world"
result1 = chain1.run(text)
result2 = chain2.run(result1)
print(result2)  # 输出：HELLOWORLD
```

### 2. 并行组合

```python
from langchain.chains import SimpleChain
from typing import Dict

def count_chars(text: str) -> int:
    return len(text)

def count_words(text: str) -> int:
    return len(text.split())

# 创建两个Chain
chain1 = SimpleChain(transform=count_chars)
chain2 = SimpleChain(transform=count_words)

# 并行执行
text = "hello world"
results = {
    "char_count": chain1.run(text),
    "word_count": chain2.run(text)
}
print(results)
```

## 高级特性

### 1. Chain记忆

```python
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

# 创建记忆组件
memory = ConversationBufferMemory()

# 创建带记忆的Chain
chain = LLMChain(
    llm=llm,
    prompt=prompt,
    memory=memory,
    verbose=True
)

# 多次运行，保持对话上下文
chain.run("你好")
chain.run("刚才我说了什么？")
```

### 2. Chain回调

```python
from langchain.callbacks import StdOutCallbackHandler

# 创建回调处理器
handler = StdOutCallbackHandler()

# 使用回调
chain = LLMChain(
    llm=llm,
    prompt=prompt,
    callbacks=[handler],
    verbose=True
)

# 运行时会打印详细信息
chain.run("测试回调")
```

### 3. 异步执行

```python
import asyncio
from langchain.chains import LLMChain

async def run_chain_async():
    # 创建异步Chain
    chain = LLMChain(llm=llm, prompt=prompt)
    
    # 异步执行
    result = await chain.arun("异步测试")
    return result

# 运行异步函数
result = asyncio.run(run_chain_async())
```

## 最佳实践

### 1. 错误处理

```python
from langchain.chains import LLMChain

def safe_run_chain(chain, input_data):
    try:
        return chain.run(input_data)
    except Exception as e:
        print(f"Chain执行错误：{e}")
        return None
```

### 2. Chain复用

```python
class ChainFactory:
    @staticmethod
    def create_qa_chain(llm, template):
        prompt = PromptTemplate(
            input_variables=["question"],
            template=template
        )
        return LLMChain(llm=llm, prompt=prompt)
    
    @staticmethod
    def create_translation_chain(llm):
        template = "将下面的文本翻译成{target_language}：{text}"
        prompt = PromptTemplate(
            input_variables=["text", "target_language"],
            template=template
        )
        return LLMChain(llm=llm, prompt=prompt)
```

## 应用示例

### 1. 文本分类Chain

```python
from langchain import PromptTemplate, LLMChain

def create_classifier():
    template = """
    请将以下文本分类为以下类别之一：科技、文化、体育、娱乐
    文本：{text}
    分类：
    """
    
    prompt = PromptTemplate(
        input_variables=["text"],
        template=template
    )
    
    return LLMChain(llm=llm, prompt=prompt)

# 使用分类器
classifier = create_classifier()
result = classifier.run("苹果发布了最新的iPhone 15系列手机")
```

### 2. 多语言翻译Chain

```python
from langchain import PromptTemplate, LLMChain

def create_translator():
    template = """
    将以下{source_language}文本翻译成{target_language}：
    {text}
    翻译：
    """
    
    prompt = PromptTemplate(
        input_variables=["text", "source_language", "target_language"],
        template=template
    )
    
    return LLMChain(llm=llm, prompt=prompt)

# 使用翻译器
translator = create_translator()
result = translator.run({
    "text": "你好，世界",
    "source_language": "中文",
    "target_language": "英文"
})
```

## 总结

LangChain的Chain系统提供了强大的组件组合能力：
- 支持多种Chain类型
- 灵活的组合方式
- 丰富的高级特性
- 完善的错误处理

掌握Chain的使用，将帮助你构建更复杂和强大的AI应用。

元素码农