中间件 (Middlewares) 系统

中间件概念与作用

中间件是在请求和响应之间执行的组件，它可以：

• 日志记录：记录请求和响应信息
• 监控与追踪：监控系统运行状态和性能
• 错误处理：处理和捕获错误
• 请求/响应修改：修改请求和响应内容
• 认证与授权：验证用户身份和权限
• 缓存：缓存请求和响应

中间件的工作流程

1. 请求阶段：在发送请求到模型之前执行
2. 响应阶段：在收到模型响应之后执行
3. 错误处理阶段：在发生错误时执行

内置中间件

LangChain 4J 提供了多种内置中间件：

日志中间件

import dev.langchain4j.middleware.LoggingMiddleware;

// 创建日志中间件
LoggingMiddleware loggingMiddleware = LoggingMiddleware.builder()
        .logRequests(true)
        .logResponses(true)
        .logErrors(true)
        .build();

监控中间件

import dev.langchain4j.middleware.MonitoringMiddleware;

// 创建监控中间件
MonitoringMiddleware monitoringMiddleware = MonitoringMiddleware.builder()
        .metricsEnabled(true)
        .tracingEnabled(true)
        .build();

错误处理中间件

import dev.langchain4j.middleware.ErrorHandlingMiddleware;

// 创建错误处理中间件
ErrorHandlingMiddleware errorHandlingMiddleware = ErrorHandlingMiddleware.builder()
        .retryAttempts(3)
        .retryDelayMs(1000)
        .build();

缓存中间件

import dev.langchain4j.middleware.CachingMiddleware;

// 创建缓存中间件
CachingMiddleware cachingMiddleware = CachingMiddleware.builder()
        .cacheSize(1000)
        .expirationTimeMs(3600000) // 1小时
        .build();

自定义中间件开发

您可以通过实现 Middleware 接口来创建自定义中间件：

基本自定义中间件

import dev.langchain4j.middleware.Middleware;
import dev.langchain4j.middleware.MiddlewareChain;

public class CustomMiddleware implements Middleware {
    @Override
    public String processRequest(String request, MiddlewareChain chain) {
        // 请求处理逻辑
        System.out.println("处理请求: " + request);
        
        // 调用下一个中间件
        String response = chain.processRequest(request);
        
        // 响应处理逻辑
        System.out.println("处理响应: " + response);
        
        return response;
    }
    
    @Override
    public void processError(Throwable error, MiddlewareChain chain) {
        // 错误处理逻辑
        System.err.println("处理错误: " + error.getMessage());
        
        // 调用下一个中间件的错误处理
        chain.processError(error);
    }
}

高级自定义中间件

public class RequestModifyingMiddleware implements Middleware {
    private final String prefix;
    
    public RequestModifyingMiddleware(String prefix) {
        this.prefix = prefix;
    }
    
    @Override
    public String processRequest(String request, MiddlewareChain chain) {
        // 修改请求
        String modifiedRequest = prefix + " " + request;
        System.out.println("修改请求: " + modifiedRequest);
        
        // 调用下一个中间件
        String response = chain.processRequest(modifiedRequest);
        
        return response;
    }
    
    @Override
    public void processError(Throwable error, MiddlewareChain chain) {
        chain.processError(error);
    }
}

中间件链配置

中间件链按顺序执行多个中间件：

基本中间件链

import dev.langchain4j.middleware.MiddlewareChain;

// 创建中间件链
MiddlewareChain middlewareChain = MiddlewareChain.builder()
        .addMiddleware(new LoggingMiddleware())
        .addMiddleware(new MonitoringMiddleware())
        .addMiddleware(new ErrorHandlingMiddleware())
        .addMiddleware(new CachingMiddleware())
        .build();

带自定义中间件的链

// 创建包含自定义中间件的链
MiddlewareChain middlewareChain = MiddlewareChain.builder()
        .addMiddleware(new LoggingMiddleware())
        .addMiddleware(new RequestModifyingMiddleware("请用中文回答："))
        .addMiddleware(new ErrorHandlingMiddleware())
        .build();

中间件应用场景

日志记录

功能：记录请求和响应信息，便于调试和监控

配置：

LoggingMiddleware loggingMiddleware = LoggingMiddleware.builder()
        .logRequests(true)
        .logResponses(true)
        .logErrors(true)
        .build();

应用：

• 调试应用程序
• 监控用户交互
• 分析模型性能

监控与追踪

功能：监控系统运行状态和性能指标

配置：

MonitoringMiddleware monitoringMiddleware = MonitoringMiddleware.builder()
        .metricsEnabled(true)
        .tracingEnabled(true)
        .build();

应用：

• 跟踪请求响应时间
• 监控模型调用频率
• 分析系统瓶颈

错误处理

功能：处理和捕获错误，提高系统稳定性

配置：

ErrorHandlingMiddleware errorHandlingMiddleware = ErrorHandlingMiddleware.builder()
        .retryAttempts(3)
        .retryDelayMs(1000)
        .build();

应用：

• 处理网络错误
• 处理模型 API 错误
• 提供友好的错误提示

请求/响应修改

功能：修改请求和响应内容，实现特定需求

配置：

RequestModifyingMiddleware modifyingMiddleware = new RequestModifyingMiddleware("请用中文回答：");

应用：

• 添加特定前缀或后缀
• 格式化请求内容
• 过滤敏感信息

中间件与模型集成

将中间件与模型集成：

与聊天模型集成

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.middleware.MiddlewareChain;
import dev.langchain4j.model.chat.ChatLanguageModelWithMiddleware;

// 创建模型
OpenAiChatModel model = OpenAiChatModel.builder()
        .apiKey(System.getenv("OPENAI_API_KEY"))
        .build();

// 创建中间件链
MiddlewareChain middlewareChain = MiddlewareChain.builder()
        .addMiddleware(new LoggingMiddleware())
        .addMiddleware(new ErrorHandlingMiddleware())
        .build();

// 创建带中间件的模型
ChatLanguageModel modelWithMiddleware = ChatLanguageModelWithMiddleware.builder()
        .chatLanguageModel(model)
        .middlewareChain(middlewareChain)
        .build();

// 使用模型
String response = modelWithMiddleware.generate("请解释量子计算的概念");
System.out.println(response);

与链集成

import dev.langchain4j.chain.llm.LLMChain;
import dev.langchain4j.prompt.PromptTemplate;

// 创建带中间件的模型
ChatLanguageModel modelWithMiddleware = ChatLanguageModelWithMiddleware.builder()
        .chatLanguageModel(model)
        .middlewareChain(middlewareChain)
        .build();

// 创建链
LLMChain chain = LLMChain.builder()
        .promptTemplate(PromptTemplate.from("请解释 {topic} 的概念"))
        .model(modelWithMiddleware)
        .build();

// 运行链
String response = chain.run("量子计算");
System.out.println(response);

最佳实践

1. 中间件顺序：

   • 日志中间件应该在最前面
   • 错误处理中间件应该在适当位置
   • 缓存中间件应该在靠近模型的位置

2. 中间件职责：

   • 每个中间件应该只负责一项功能
   • 中间件应该保持简单和专注
   • 中间件应该处理自己的错误

3. 性能考虑：

   • 避免添加过多中间件
   • 中间件应该快速执行
   • 考虑中间件的内存使用

4. 可测试性：

   • 中间件应该易于测试
   • 提供配置选项
   • 支持禁用特定功能

5. 安全性：

   • 中间件应该处理敏感信息
   • 避免日志中包含敏感数据
   • 实现适当的访问控制