多模态 RAG 系统实战：使用 LangChain4j 构建支持图文混合检索的企业级知识库

配置向量数据库

使用 Docker Compose 快速部署 PostgreSQL + PgVector：

# docker-compose.yml
version: '3.8'
services:
  postgres:
    image: pgvector/pgvector:pg16
    container_name: rag-vector-db
    environment:
      POSTGRES_USER: raguser
      POSTGRES_PASSWORD: ragpass123
      POSTGRES_DB: ragdb
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata:

启动服务：

docker-compose up -d

初始化 Embedding Store

创建 LangChain4j 的 PgVector 连接配置：

@Configuration
public class VectorStoreConfig {

    @Bean
    public EmbeddingStore embeddingStore() {
        return PgVectorEmbeddingStore.builder()
            .host("localhost")
            .port(5432)
            .database("ragdb")
            .user("raguser")
            .password("ragpass123")
            .table("embeddings")
            .dimension(768)  // BGE-M3 模型维度
            .build();
    }
}

实现 PDF 解析与文本提取

使用 Apache PDFBox 提取 PDF 内容：

public class PdfProcessor {

    public List<TextSegment> processPdf(Path pdfPath) throws IOException {
        try (PDDocument document = PDDocument.load(pdfPath.toFile())) {
            PDFTextStripper stripper = new PDFTextStripper();
            String fullText = stripper.getText(document);

            // 按段落分割并进行语义分块
            return chunkBySemantics(fullText);
        }
    }

    private List<TextSegment> chunkBySemantics(String text) {
        // 使用 LangChain4j 的分块策略
        DocumentSplitter splitter = DocumentSplitters.recursive(300, 30);
        List<TextSegment> chunks = splitter.split(text);

        // 为每个 chunk 添加元数据
        return chunks.stream()
            .map(segment -> TextSegment.from(segment.text(),
                Metadata.from("source", "pdf")))
            .collect(Collectors.toList());
    }
}

实现图像描述生成

使用 Google Gemini Vision 为图像生成描述：

public class ImageProcessor {

    private final VisionModel visionModel;

    public ImageProcessor(String geminiApiKey) {
        this.visionModel = GeminiVisionModel.builder()
            .apiKey(geminiApiKey)
            .modelName("gemini-2.0-flash")
            .build();
    }

    public String generateImageDescription(Path imagePath) throws IOException {
        byte[] imageBytes = Files.readAllBytes(imagePath);

        String prompt = """
            请用中文详细描述这张图片的内容，包括：
            1. 主要物体和场景
            2. 颜色、布局等视觉特征
            3. 图片可能表达的信息或用途
            限制在 200 字以内。
            """;

        VisionContentRequest request = VisionContentRequest.builder()
            .addUserMessage(prompt)
            .addImage(imageBytes)
            .build();

        return visionModel.generate(request);
    }
}

构建向量化流水线

将文本和图像描述转换为向量并存入数据库：

@Service
public class IngestionService {

    private final EmbeddingModel embeddingModel;
    private final EmbeddingStore embeddingStore;
    private final PdfProcessor pdfProcessor;
    private final ImageProcessor imageProcessor;

    // 使用 Hugging Face BGE-M3 模型
    public IngestionService() {
        this.embeddingModel = new HuggingFaceEmbeddingModel("BAAI/bge-m3");
    }

    public void ingestDocument(Path docPath) {
        List<TextSegment> segments = new ArrayList<>();

        // 处理 PDF
        if (docPath.toString().endsWith(".pdf")) {
            segments.addAll(pdfProcessor.processPdf(docPath));
        }

        // 处理图片
        if (isImage(docPath)) {
            String description = imageProcessor.generateImageDescription(docPath);
            segments.add(TextSegment.from(description,
                Metadata.from("type", "image").add("filename", docPath.getFileName())));
        }

        // 生成向量并存入
        for (TextSegment segment : segments) {
            Embedding embedding = embeddingModel.embed(segment);
            embeddingStore.add(embedding, segment);
        }
    }
}

实现检索 - 生成流水线

创建 RAG 查询服务：

@Service
public class RagQueryService {

    private final EmbeddingStore embeddingStore;
    private final ChatLanguageModel chatModel;
    private final EmbeddingModel embeddingModel;

    public String query(String question) {
        // 1. 将查询向量化
        Embedding queryEmbedding = embeddingModel.embed(question);

        // 2. 检索最相关的文档片段
        List<EmbeddingMatch> matches = embeddingStore.findRelevant(
            queryEmbedding,
            5  // 返回 top 5 结果
        );

        // 3. 构建增强 prompt
        String context = buildContext(matches);
        String augmentedPrompt = buildRagPrompt(question, context);

        // 4. 生成回答
        return chatModel.generate(augmentedPrompt);
    }

    private String buildContext(List<EmbeddingMatch> matches) {
        return matches.stream()
            .map(match -> match.embedded().text())
            .collect(Collectors.joining("\n\n---\n\n"));
    }

    private String buildRagPrompt(String question, String context) {
        return """
            你是一个企业知识库助手。请基于以下上下文信息回答问题：

            【上下文】
            %s

            【问题】
            %s

            如果上下文中没有相关信息，请如实告知。
            """.formatted(context, question);
    }
}

提供 RESTful API

基于 Spring Boot 暴露查询接口：

@RestController
@RequestMapping("/api/rag")
public class RagController {

    @Autowired
    private RagQueryService ragQueryService;

    @Autowired
    private IngestionService ingestionService;

    @PostMapping("/query")
    public ResponseEntity<QueryResponse> query(@RequestBody QueryRequest request) {
        String answer = ragQueryService.query(request.question());
        return ResponseEntity.ok(new QueryResponse(answer));
    }

    @PostMapping("/ingest")
    public ResponseEntity<?> ingest(@RequestParam("file") MultipartFile file)
            throws IOException {
        Path tempFile = Files.createTempFile("upload", file.getOriginalFilename());
        file.transferTo(tempFile);

        ingestionService.ingestDocument(tempFile);
        Files.delete(tempFile);

        return ResponseEntity.ok(Map.of("status", "success"));
    }
}