LangChain4j 万字实战：Java生态最火大模型框架，从入门到企业级RAG与Agent落地

<!-- Spring Boot 基础依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- LangChain4j 核心依赖 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>1.0.0-beta1</version>
</dependency>

<!-- OpenAI模型适配包 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
    <version>1.0.0-beta1</version>
</dependency>

<!-- 内存向量库（测试使用，生产替换Milvus） -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-chroma</artifactId>
    <version>1.0.0-beta1</version>
</dependency>

spring:
  application:
    name: langchain4j-demo
# LangChain4j 大模型配置
langchain4j:
  open-ai:
    chat-model:
      api-key: sk-xxxxxxxxxxxxxxxxxxxxxx
      model-name: gpt-3.5-turbo
      temperature: 0.3
      timeout: 30s
    streaming-chat-model:
      api-key: sk-xxxxxxxxxxxxxxxxxxxxxx
      model-name: gpt-3.5-turbo
    embedding-model:
      api-key: sk-xxxxxxxxxxxxxxxxxxxxxx
      model-name: text-embedding-ada-002

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

@RestController
public class ChatController {

    // 普通对话模型
    @Autowired
    private OpenAiChatModel chatModel;

    // 流式对话模型
    @Autowired
    private OpenAiStreamingChatModel streamingChatModel;

    /**
     * 普通问答接口
     */
    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return chatModel.chat(message);
    }

    /**
     * 流式对话接口（前端打字机效果）
     */
    @GetMapping(value = "/stream/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> streamChat(@RequestParam String message) {
        return Flux.create(sink -> streamingChatModel.chat(message, response -> {
            if (response != null && response.content() != null) {
                sink.next(response.content());
            }
        }));
    }
}

import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.service.AiServices;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AiChatConfig {

    // 定义AI对话接口（声明式编程）
    public interface ChatAssistant {
        String chat(String message);
    }

    /**
     * 构建带记忆的AI对话Bean
     * 保留最近10轮对话，避免上下文膨胀
     */
    @Bean
    public ChatAssistant chatAssistant(OpenAiChatModel chatModel) {
        return AiServices.builder(ChatAssistant.class)
                .chatModel(chatModel)
                .chatMemory(MessageWindowChatMemory.withMaxMessages(10))
                .build();
    }
}

import dev.langchain4j.agent.tool.Tool;
import org.springframework.stereotype.Component;

/**
 * 自定义业务工具：天气查询工具
 */
@Component
public class WeatherTool {

    /**
     * 大模型可自动调用该工具查询天气
     */
    @Tool("根据城市名称查询实时天气")
    public String getWeather(String city) {
        // 模拟调用天气接口
        return city + " 当前天气：晴，25℃，微风";
    }
}

@Bean
public ChatAssistant toolChatAssistant(OpenAiChatModel chatModel, WeatherTool weatherTool) {
    return AiServices.builder(ChatAssistant.class)
            .chatModel(chatModel)
            .chatMemory(MessageWindowChatMemory.withMaxMessages(10))
            .tools(weatherTool)
            .build();
}

import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.loader.FileSystemDocumentLoader;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.retriever.EmbeddingStoreContentRetriever;
import dev.langchain4j.store.embedding.chroma.ChromaEmbeddingStore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.List;

@Configuration
public class RagConfig {

    @Autowired
    private EmbeddingModel embeddingModel;

    /**
     * 初始化向量存储（生产替换为Milvus集群）
     */
    @Bean
    public ChromaEmbeddingStore embeddingStore() {
        return ChromaEmbeddingStore.builder()
                .baseUrl("http://localhost:8000")
                .collectionName("company-knowledge")
                .build();
    }

    /**
     * 文档入库：加载本地文档、切片、向量化、存入向量库
     */
    @Bean
    public Boolean loadDocument(ChromaEmbeddingStore embeddingStore) {
        // 1. 加载本地知识库文档
        Document document = FileSystemDocumentLoader.loadDocument("doc/company-rule.txt");

        // 2. 文本切片：单段500字符，重叠100字符，保证上下文连贯
        List<TextSegment> segments = DocumentSplitters.recursive(500, 100).split(document);

        // 3. 批量向量化并入库
        List<Embedding> embeddings = embeddingModel.embedAll(segments).content();
        embeddingStore.addAll(embeddings, segments);
        return true;
    }

    /**
     * 构建检索器：控制检索精度与数量
     */
    @Bean
    public EmbeddingStoreContentRetriever retriever(ChromaEmbeddingStore embeddingStore) {
        return EmbeddingStoreContentRetriever.builder()
                .embeddingStore(embeddingStore)
                .embeddingModel(embeddingModel)
                .maxResults(5) // 最多返回5条相关片段
                .minScore(0.7)  // 相似度阈值，过滤无效低匹配内容
                .build();
    }
}

import dev.langchain4j.service.AiServices;
import dev.langchain4j.store.embedding.EmbeddingStoreContentRetriever;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RagChatConfig {

    public interface RagChatAssistant {
        String chat(String message);
    }

    @Autowired
    private EmbeddingStoreContentRetriever retriever;

    @Bean
    public RagChatAssistant ragChatAssistant(OpenAiChatModel chatModel) {
        return AiServices.builder(RagChatAssistant.class)
                .chatModel(chatModel)
                .contentRetriever(retriever)
                .build();
    }
}