打造智能路由的 LLM 应用：条件分支链详解

核心要点

掌握 LLM 应用中的动态路由策略
实现健壮的错误处理机制
构建实用的多语言内容处理系统
学习降级策略的最佳实践

动态路由机制解析

在复杂的 LLM 应用中，不同的输入往往需要不同的处理路径。动态路由可以帮助我们：

优化资源使用
提高响应准确性
增强系统可靠性
控制处理成本

路由策略设计

1. 核心组件

from langchain.chains import LLMChain
from langchain.prompts import ChatPromptTemplate
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field
from typing import Optional, List
import asyncio

class RouteDecision(BaseModel):
    route: str = Field(description="选择的处理路由")
    confidence: float = Field(description="决策的置信度")
    reasoning: str = Field(description="路由决策的解释")

class IntelligentRouter:
    def __init__(self, routes: List[str]):
        self.routes = routes
        self.parser = PydanticOutputParser(pydantic_object=RouteDecision)
        self.route_prompt = ChatPromptTemplate.from_template(
            """分析以下输入并决定最佳处理路由。
            可用路由: {routes}
            输入: {input}
            {format_instructions}
            """
        )

2. 路由选择逻辑

    async def decide_route(self, input_text: str) -> RouteDecision:
        prompt = self.route_prompt.format(
            routes=self.routes,
            input=input_text,
            format_instructions=self.parser.get_format_instructions()
        )
        
        chain = LLMChain(
            llm=self.llm,
            prompt=self.route_prompt
        )
        
        result = await chain.arun(input=input_text)
        return self.parser.parse(result)

实战案例：多语言内容处理系统

1. 系统架构

class MultiLangProcessor:
    def __init__(self):
        self.router = IntelligentRouter([
            "translation",  # 翻译
            "summarization",  # 摘要
            "sentiment_analysis",  # 情感分析
            "content_moderation"  # 内容审核
        ])
        self.processors = {
            "translation": TranslationChain(),
            "summarization": SummaryChain(),
            "sentiment_analysis": SentimentChain(),
            "content_moderation": ModerationChain()
        }
    
    async def process(self, content: str) -> Dict:
        try:
            route = await self.router.decide_route(content)
            if route.confidence < 0.8:
                return await self.handle_low_confidence(content, route)
            
            processor = self.processors[route.route]
            result = await processor.run(content)
            return {
                "status": "success",
                "route": route.route,
                "result": result
            }
        except Exception as e:
            return await self.handle_error(e, content)

2. 错误处理实现

class ErrorHandler:
    def __init__(self):
        self.fallback_llm = ChatOpenAI(
            model_name="gpt-3.5-turbo",
            temperature=0.3
        )
        self.retry_limit = 3
        self.backoff_factor = 1.5
    
    async def handle_error(
        self, 
        error: Exception, 
        context: Dict
    ) -> Dict:
        error_type = type(error).__name__
        
        if error_type in self.error_strategies:
            return await self.error_strategies[error_type](
                error, context
            )
        
        return await self.default_error_handler(error, context)
    
    async def retry_with_backoff(
        self, 
        func, 
        *args, 
        **kwargs
    ):
        for attempt in range(self.retry_limit):
            try:
                return await func(*args, **kwargs)
            except Exception as e:
                if attempt == self.retry_limit - 1:
                    raise e
                await asyncio.sleep(
                    self.backoff_factor ** attempt
                )

降级策略示例

1. 模型降级链

class ModelFallbackChain:
    def __init__(self):
        self.models = [
            ChatOpenAI(model_name="gpt-4"),
            ChatOpenAI(model_name="gpt-3.5-turbo"),
            ChatOpenAI(model_name="gpt-3.5-turbo-16k")
        ]
    
    async def run_with_fallback(
        self, 
        prompt: str
    ) -> Optional[str]:
        for model in self.models:
            try:
                return await self.try_model(model, prompt)
            except Exception as e:
                continue
        
        return await self.final_fallback(prompt)

2. 内容分块策略

class ChunkingStrategy:
    def __init__(self, chunk_size: int = 1000):
        self.chunk_size = chunk_size
    
    def chunk_content(
        self, 
        content: str
    ) -> List[str]:
        # 实现智能内容分块
        return [
            content[i:i + self.chunk_size]
            for i in range(0, len(content), self.chunk_size)
        ]
    
    async def process_chunks(
        self, 
        chunks: List[str]
    ) -> List[Dict]:
        results = []
        for chunk in chunks:
            try:
                result = await self.process_single_chunk(chunk)
                results.append(result)
            except Exception as e:
                results.append(self.handle_chunk_error(e, chunk))
        return results