LLM 链式架构基础：从入门到实践

在构建复杂的 LLM 应用时，单一的模型调用往往无法满足业务需求。本文将详细介绍如何构建一个可靠的 LLM 链式架构，包括基础设计模式、提示词工程和错误处理机制。

为什么需要链式架构？

在开始深入技术细节之前，让我们先理解为什么需要链式架构：

单一模型调用的局限性
- 输入输出格式单一
- 缺乏上下文管理
- 错误处理能力有限
复杂业务场景的挑战
- 多步骤处理需求
- 数据清洗和转换
- 结果验证和质量控制
链式架构的优势
- 模块化设计，便于维护
- 灵活的扩展性
- 统一的错误处理
- 可复用的组件

基础链式架构设计

1. 核心组件

from typing import Any, Dict, Optional
from abc import ABC, abstractmethod

class BaseProcessor(ABC):
    @abstractmethod
    def process(self, data: Any) -> Any:
        pass

class BaseChain:
    def __init__(self):
        self.preprocessor: Optional[BaseProcessor] = None
        self.prompt_manager: Optional[PromptManager] = None
        self.llm: Optional[BaseLLM] = None
        self.postprocessor: Optional[BaseProcessor] = None
        self.error_handler: Optional[ErrorHandler] = None

    def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
        try:
            # 1. 预处理
            processed_input = self._preprocess(input_data)
            
            # 2. 生成提示词
            prompt = self._generate_prompt(processed_input)
            
            # 3. LLM 调用
            response = self._call_llm(prompt)
            
            # 4. 后处理
            result = self._postprocess(response)
            
            return result
        except Exception as e:
            return self.error_handler.handle(e)

2. 组件解耦设计

class PreProcessor(BaseProcessor):
    def process(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """数据预处理逻辑"""
        # 1. 数据清洗
        cleaned_data = self._clean_data(data)
        
        # 2. 格式转换
        formatted_data = self._format_data(cleaned_data)
        
        # 3. 验证
        self._validate_data(formatted_data)
        
        return formatted_data

class PostProcessor(BaseProcessor):
    def process(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """结果后处理逻辑"""
        # 1. 结果解析
        parsed_result = self._parse_result(data)
        
        # 2. 格式化输出
        formatted_result = self._format_output(parsed_result)
        
        # 3. 质量检查
        self._quality_check(formatted_result)
        
        return formatted_result

提示词工程基础

1. 提示词模板管理

class PromptTemplate:
    def __init__(self, template: str, input_variables: List[str]):
        self.template = template
        self.input_variables = input_variables

class PromptManager:
    def __init__(self):
        self.templates: Dict[str, PromptTemplate] = {}
        self.version_control = VersionControl()

    def register_template(self, name: str, template: str, 
                         input_variables: List[str]) -> None:
        """注册提示词模板"""
        self.templates[name] = PromptTemplate(
            template=template,
            input_variables=input_variables
        )

    def generate_prompt(self, template_name: str, **kwargs) -> str:
        """生成提示词"""
        template = self.templates.get(template_name)
        if not template:
            raise ValueError(f"Template {template_name} not found")
        
        # 验证必要参数
        self._validate_inputs(template, kwargs)
        
        # 生成提示词
        return template.template.format(**kwargs)

2. 提示词优化策略

class PromptOptimizer:
    def __init__(self):
        self.few_shots: List[Dict[str, str]] = []
        self.context: Dict[str, Any] = {}

    def add_few_shot(self, example: Dict[str, str]) -> None:
        """添加少样本示例"""
        self.few_shots.append(example)

    def set_context(self, context: Dict[str, Any]) -> None:
        """设置上下文信息"""
        self.context.update(context)

    def optimize_prompt(self, base_prompt: str) -> str:
        """优化提示词"""
        # 1. 添加角色设定
        prompt = self._add_role_setting(base_prompt)
        
        # 2. 注入上下文
        prompt = self._inject_context(prompt)
        
        # 3. 添加少样本示例
        prompt = self._add_few_shots(prompt)
        
        return prompt

错误处理机制

1. 错误处理基础架构

class LLMChainError(Exception):
    """基础链错误"""
    pass

class ErrorHandler:
    def __init__(self):
        self.retry_strategy = RetryStrategy()
        self.fallback_handler = FallbackHandler()
        self.monitor = Monitor()

    def handle(self, error: Exception) -> Dict[str, Any]:
        """统一错误处理"""
        try:
            # 1. 记录错误
            self.monitor.log_error(error)
            
            # 2. 判断是否可重试
            if self.is_retryable(error):
                return self.retry_strategy.retry()
            
            # 3. 降级处理
            return self.fallback_handler.handle(error)
        finally:
            # 4. 错误通知
            self.monitor.notify(error)

2. 重试策略实现

class RetryStrategy:
    def __init__(self, max_retries: int = 3, 
                 base_delay: float = 1.0):
        self.max_retries = max_retries
        self.base_delay = base_delay
        self.current_retry = 0

    def retry(self) -> bool:
        """实现指数退避重试"""
        if self.current_retry >= self.max_retries:
            return False
        
        delay = self.base_delay * (2 ** self.current_retry)
        time.sleep(delay)
        
        self.current_retry += 1
        return True

实战案例：智能问答系统

让我们通过一个实际的智能问答系统来看看如何应用这些概念：

class QAChain(BaseChain):
    def __init__(self):
        super().__init__()
        self.setup_components()

    def setup_components(self):
        # 1. 设置预处理器
        self.preprocessor = QAPreProcessor()
        
        # 2. 配置提示词管理器
        self.prompt_manager = self._setup_prompt_manager()
        
        # 3. 配置 LLM
        self.llm = self._setup_llm()
        
        # 4. 设置后处理器
        self.postprocessor = QAPostProcessor()
        
        # 5. 配置错误处理
        self.error_handler = QAErrorHandler()

    def _setup_prompt_manager(self):
        manager = PromptManager()
        manager.register_template(
            "qa_template",
            """
            作为一个智能问答助手，请回答以下问题：
            问题：{question}
            要求：
            1. 回答要简洁明了
            2. 如果不确定，请明确说明
            3. 如果需要更多信息，请指出具体需要什么信息
            """,
            ["question"]
        )
        return manager