基于 Ollama 与 LangChain 集成 AI 大模型至致远 OA 实践

4. 代码集成实现

4.1 Maven 依赖配置

在致远 OA 项目的 pom.xml 中添加以下依赖，引入 LangChain4J 及相关适配器。

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <langchain4j.version>0.34.0</langchain4j.version>
</properties>

<dependencies>
    <!-- OpenAI Adapter -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
        <version>${langchain4j.version}</version>
    </dependency>
    
    <!-- Chroma DB Adapter -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-chroma</artifactId>
        <version>${langchain4j.version}</version>
    </dependency>
    
    <!-- Ollama Adapter -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-ollama</artifactId>
        <version>${langchain4j.version}</version>
    </dependency>
    
    <!-- ChromaDB Java Client -->
    <dependency>
        <groupId>io.github.amikos-tech</groupId>
        <artifactId>chromadb-java-client</artifactId>
        <version>0.1.7</version>
    </dependency>
</dependencies>

4.2 监听附件上传事件

通过实现 FileUploadEvent 监听器，在文件上传时触发处理逻辑。

/**
 * 监听附件上传事件
 */
public class RAGFileEvent {
    
    @ListenEvent(event = FileUploadEvent.class)
    public void onFileUpload(FileUploadEvent evt) throws Exception {
        // 获取上传的文件对象
        FileItem fileItem = evt.getFileItem();
        String originalFilename = fileItem.getOriginalFilename();
        
        // 仅处理 txt 文件示例，实际可根据扩展名过滤
        if (originalFilename.contains(".txt")) {
            // 保存文件到临时目录
            String systemTempFolder = SystemEnvironment.getSystemTempFolder();
            String pathname = systemTempFolder + File.separator + UUIDUtil.getUUIDString() + File.separator + originalFilename;
            CtpFile tempFile = new CtpFile(pathname);
            InputStream inputStream = fileItem.getInputStream();
            GlobalFileUtils.saveCtpFile(inputStream, tempFile);
            
            // 解析文件为 Document 对象
            Document document = LangChainUtils.getDocument(pathname);
            
            // 拆分文件内容
            List<TextSegment> segments = splitDocument(document);
            
            // 文本向量化并存入向量库
            saveToVectorStore(segments);
            
            // 清理临时文件
            deleteFile(tempFile.getPath());
        }
    }
}

4.3 文档解析与拆分

将文件加载为 LangChain4J 的 Document 对象，并根据 Token 数量进行分段。

public static Document getDocument(String fileName) {
    URL docUrl = LangChainUtils.class.getClassLoader().getResource(fileName);
    if (docUrl == null) {
        log.error("未获取到文件路径");
        return null;
    }
    Document document = null;
    try {
        Path path = Paths.get(docUrl.toURI());
        document = FileSystemDocumentLoader.loadDocument(path);
    } catch (URISyntaxException e) {
        log.error("加载文件发生异常", e);
    }
    return document;
}

// 拆分文件内容
private List<TextSegment> splitDocument(Document document) {
    // 参数说明：分段大小（Token 数）、重叠度（段之间重叠的 Token 数）、分词器
    DocumentByLineSplitter lineSplitter = new DocumentByLineSplitter(200, 0, new OpenAiTokenizer());
    List<TextSegment> segments = lineSplitter.split(document);
    log.info("segment 的数量是：{}", segments.size());
    return segments;
}

4.4 文本向量化与存储

配置 Ollama 嵌入模型和 ChromaDB 连接，将文本片段转换为向量并入库。

private static final String CHROMA_DB_NAME = "rag-oa";
private static final String CHROMA_URL = "http://localhost:8000";
private static final String OLLAMA_URL = "http://localhost:11434";
private static final String OLLAMA_NAME = "qwen2.5:3b";

private void saveToVectorStore(List<TextSegment> segments) {
    // 创建嵌入模型
    OllamaEmbeddingModel embeddingModel = OllamaEmbeddingModel.builder()
            .baseUrl(Optional.ofNullable(AppContext.getSystemProperty("rag.ollama_url")).orElse(OLLAMA_URL))
            .modelName(Optional.ofNullable(AppContext.getSystemProperty("rag.ollama_name")).orElse(OLLAMA_NAME))
            .build();

    // 创建向量数据库存储
    EmbeddingStore<TextSegment> embeddingStore = ChromaEmbeddingStore.builder()
            .baseUrl(Optional.ofNullable(AppContext.getSystemProperty("rag.chroma_url")).orElse(CHROMA_URL))
            .collectionName(Optional.ofNullable(AppContext.getSystemProperty("rag.chroma_db_name")).orElse(CHROMA_DB_NAME))
            .build();

    // 批量添加向量
    for (TextSegment segment : segments) {
        Embedding e = embeddingModel.embed(segment).content();
        embeddingStore.add(e, segment);
    }
}

4.5 向量检索与 LLM 交互

当用户提问时，先在向量库中检索最相关的片段，再将其作为上下文发送给 LLM 生成回答。

// 向量库检索
public TextSegment retrieveQuery(String qryText) {
    OllamaEmbeddingModel embeddingModel = createEmbeddingModel();
    Embedding queryEmbedding = embeddingModel.embed(qryText).content();
    
    EmbeddingSearchRequest request = EmbeddingSearchRequest.builder()
            .queryEmbedding(queryEmbedding)
            .maxResults(1)
            .build();
    
    EmbeddingSearchResult<TextSegment> result = embeddingStore.search(request);
    List<EmbeddingMatch<TextSegment>> matches = result.matches();
    
    if (!matches.isEmpty()) {
        return matches.get(0).embedded();
    }
    return null;
}

// 与 LLM 交互
public String llmChat(String question) {
    TextSegment contextSegment = retrieveQuery(question);
    String contextText = contextSegment != null ? contextSegment.text() : "无相关信息";
    
    PromptTemplate promptTemplate = PromptTemplate.from(
        "基于如下信息用中文回答:\n{{context}}\n提问:\n{{question}}"
    );
    
    Map<String, Object> variables = new HashMap<>();
    variables.put("context", contextText);
    variables.put("question", question);
    
    Prompt prompt = promptTemplate.apply(variables);
    UserMessage userMessage = prompt.toUserMessage();
    
    OllamaChatModel ollamaChatModel = createChatModel();
    Response<AiMessage> response = ollamaChatModel.generate(userMessage);
    
    return response.content().text();
}

5. 接口测试

创建一个 REST 接口用于外部调用或前端测试。

@Path("ai")
@Produces({"application/json"})
public class AIRestResource extends BaseResource {
    private static final Log log = LogFactory.getLog(AIRestResource.class);

    @POST
    @Path("/message")
    public Response message(@QueryParam("message") String message) {
        try {
            String answer = LangChainUtils.llmChat(message);
            return ok(answer);
        } catch (Exception e) {
            log.error("AI 处理失败", e);
            return error("Internal Server Error");
        }
    }
}

测试用例：

1. 上传测试文件 test.txt，内容如下：

   在致远 OA 中有 2 个待办协同，有 3 个待办公文，有 1 个 10 点的会议
   

2. 调用接口输入问题：我总共几个待办事项
3. 预期结果：

   根据你的描述，在致远 OA 中你有以下几个待办事项：
   - 两个待办协同任务
   - 三个待办公文任务
   - 一次在 10 点开始的会议
   将这些加起来，你可以得出总共的待办事项目数是：6
   所以，你总共有六个待办事项目。
   

6. 配置与优化建议

6.1 系统配置

建议在 OA 系统配置文件中设置以下属性，避免硬编码：

• rag.ollama_url: Ollama 服务地址
• rag.ollama_name: 使用的模型名称
• rag.chroma_url: ChromaDB 服务地址
• rag.chroma_db_name: 向量库集合名称

6.2 性能优化

• 内存管理：大模型推理消耗较大内存，生产环境建议独立部署 Ollama 服务，并通过网络调用。
• 缓存策略：对于高频问题，可在应用层增加缓存机制，减少重复的向量检索和 LLM 调用。
• 分段策略：根据文档类型调整 DocumentByLineSplitter 的参数，平衡检索精度与上下文完整性。

6.3 常见问题排查

• 连接超时：检查 Ollama 和 ChromaDB 服务是否正常运行，防火墙是否放行端口。
• 向量检索为空：确认文件已成功解析并入库，检查 Collection 名称是否一致。
• 模型响应慢：尝试更换参数量更小的模型，或增加 GPU 算力支持。

7. 总结

本实践展示了如何在致远 OA 中集成 AI 大模型能力，实现了从文档上传到智能问答的完整闭环。通过 LangChain4J 框架，开发者可以灵活地组合 Embedding 模型、向量数据库和 LLM，构建企业级的知识库应用。未来可进一步探索多模态支持、复杂工作流编排等功能，持续提升 OA 系统的智能化水平。