Spring AI vs LangChain4j：Java生态中的AI框架选择指南

在AI应用开发日益普及的今天，Java开发者面临着多种AI框架的选择。其中，Spring AI和LangChain4j作为两个主要的Java AI框架，各有其特色和优势。本文将深入对比这两个框架的特点、用法和适用场景，帮助开发者做出更好的技术选择。

框架概述

Spring AI

Spring AI是Spring生态系统的最新成员，专注于为Java应用程序提供AI集成能力。它延续了Spring框架一贯的设计理念，提供了简洁的API和强大的自动配置功能，让开发者能够轻松地将AI能力集成到现有的Spring应用中。

LangChain4j

LangChain4j是流行的Python框架LangChain的Java版本，专门为构建复杂的AI应用程序而设计。它提供了丰富的工具链和抽象层，支持多种AI模型和服务的集成。

核心特性对比

Spring AI 使用示例

1. 项目配置

首先在pom.xml中添加Spring AI依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>0.8.1</version>
</dependency>

2. 配置文件设置

在application.yml中配置API密钥：

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-3.5-turbo
          temperature: 0.7

3. 基础聊天功能

@RestController
public class ChatController {
    
    private final ChatClient chatClient;
    
    public ChatController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }
    
    @PostMapping("/chat")
    public String chat(@RequestBody String message) {
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
}

4. 结构化输出

@Service
public class ProductAnalysisService {
    
    private final ChatClient chatClient;
    
    public ProductAnalysisService(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }
    
    public ProductReview analyzeProduct(String productDescription) {
        return chatClient.prompt()
                .user("分析以下产品：" + productDescription)
                .call()
                .entity(ProductReview.class);
    }
}

record ProductReview(String summary, int rating, List<String> pros, List<String> cons) {}

5. RAG（检索增强生成）实现

@Service
public class DocumentSearchService {
    
    private final ChatClient chatClient;
    private final VectorStore vectorStore;
    
    public DocumentSearchService(ChatClient.Builder chatClientBuilder, 
                               VectorStore vectorStore) {
        this.chatClient = chatClientBuilder.build();
        this.vectorStore = vectorStore;
    }
    
    public String searchAndAnswer(String question) {
        List<Document> similarDocuments = vectorStore.similaritySearch(
            SearchRequest.query(question).withTopK(3)
        );
        
        String context = similarDocuments.stream()
                .map(Document::getContent)
                .collect(Collectors.joining("\n"));
        
        return chatClient.prompt()
                .system("基于以下上下文回答问题：\n" + context)
                .user(question)
                .call()
                .content();
    }
}

LangChain4j 使用示例

1. 项目配置

在pom.xml中添加LangChain4j依赖：

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j</artifactId>
    <version>0.25.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>0.25.0</version>
</dependency>

2. 基础聊天功能

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class ChatService {
    
    private final ChatLanguageModel model;
    
    public ChatService() {
        this.model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-3.5-turbo")
                .temperature(0.7)
                .build();
    }
    
    public String chat(String message) {
        return model.generate(message);
    }
}

3. AI服务接口

import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.UserMessage;

interface ProductAnalyzer {
    
    @UserMessage("分析以下产品并提供评分（1-10）和建议：{{product}}")
    ProductAnalysis analyze(String product);
}

// 使用
public class ProductService {
    
    private final ProductAnalyzer analyzer;
    
    public ProductService() {
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .build();
                
        this.analyzer = AiServices.create(ProductAnalyzer.class, model);
    }
    
    public ProductAnalysis analyzeProduct(String productDescription) {
        return analyzer.analyze(productDescription);
    }
}

4. 工具使用（Function Calling）

import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.service.AiServices;

public class WeatherService {
    
    @Tool("获取指定城市的当前天气")
    public String getCurrentWeather(String city) {
        // 实际的天气API调用
        return "今天" + city + "的天气是晴天，温度25°C";
    }
}

interface WeatherAssistant {
    String chat(String message);
}

// 配置助手
public class WeatherApp {
    
    public static void main(String[] args) {
        WeatherService weatherService = new WeatherService();
        
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .build();
        
        WeatherAssistant assistant = AiServices.builder(WeatherAssistant.class)
                .chatLanguageModel(model)
                .tools(weatherService)
                .build();
        
        String response = assistant.chat("北京今天天气怎么样？");
        System.out.println(response);
    }
}

5. RAG实现

import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.inmemory.InMemoryEmbeddingStore;

public class RAGService {
    
    private final ChatLanguageModel chatModel;
    private final EmbeddingModel embeddingModel;
    private final EmbeddingStore<TextSegment> embeddingStore;
    
    public RAGService() {
        this.chatModel = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .build();
                
        this.embeddingModel = OpenAiEmbeddingModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .build();
                
        this.embeddingStore = new InMemoryEmbeddingStore<>();
    }
    
    public void addDocument(String content) {
        TextSegment segment = TextSegment.from(content);
        Embedding embedding = embeddingModel.embed(segment).content();
        embeddingStore.add(embedding, segment);
    }
    
    public String queryWithContext(String question) {
        Embedding questionEmbedding = embeddingModel.embed(question).content();
        
        List<EmbeddingMatch<TextSegment>> matches = embeddingStore.findRelevant(
                questionEmbedding, 3);
        
        String context = matches.stream()
                .map(match -> match.embedded().text())
                .collect(Collectors.joining("\n"));
        
        String prompt = String.format(
                "基于以下上下文回答问题：\n%s\n\n问题：%s", 
                context, question);
        
        return chatModel.generate(prompt);
    }
}

详细对比分析

开发体验

Spring AI 优势：

• 自动配置减少样板代码
• 与Spring Boot无缝集成
• 熟悉的Spring编程模型
• 强大的测试支持

LangChain4j 优势：

• 更灵活的配置选项
• 丰富的AI服务抽象
• 声明式编程风格
• 更多的工具和插件

性能表现

Spring AI：

• 利用Spring的优化特性
• 连接池和缓存支持
• 响应式编程支持

LangChain4j：

• 轻量级核心设计
• 高效的向量操作
• 流式处理支持

社区和生态

Spring AI：

• 背靠强大的Spring生态
• 活跃的Spring社区支持
• 与Spring Cloud集成

LangChain4j：

• 快速发展的独立社区
• 与Python LangChain概念一致
• 丰富的第三方集成

适用场景建议

选择Spring AI的场景：

• 现有Spring Boot项目需要AI功能
• 企业级应用开发
• 需要微服务架构支持
• 团队熟悉Spring生态

选择LangChain4j的场景：

• 复杂的AI代理应用
• 需要丰富的工具链
• 多模型集成需求
• 快速原型开发

结论

Spring AI和LangChain4j都是优秀的Java AI框架，选择哪个主要取决于你的具体需求：

• 如果你正在开发Spring应用，Spring AI提供了最自然的集成体验
• 如果你需要构建复杂的AI应用或代理系统，LangChain4j提供了更多的工具和灵活性
• 对于企业级应用，Spring AI的稳定性和生态支持更有优势
• 对于创新性项目，LangChain4j的快速迭代和丰富功能更适合

无论选择哪个框架，都能帮助你快速构建强大的AI应用。建议根据项目的具体需求、团队的技术栈和长期维护考虑来做出选择。