LangChain4J 整合多 AI 模型核心实现步骤

一、基础前提：统一依赖管理（核心）

无论整合 OpenAI、DeepSeek 还是 Ollama，先通过BOM 统一管理 LangChain4J 版本，避免依赖冲突，再按需引入对应 Starter（SpringBoot 场景）或核心包（手动构建场景）。

1. SpringBoot 场景（推荐，含自动装配）

xml

<!-- 1. 统一管理LangChain4J所有依赖版本（核心，避免版本冲突） -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-bom</artifactId>
            <version>1.0.0-beta3</version> <!-- 按需指定版本，所有子依赖自动对齐 -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- 2. 按需引入对应模型Starter（自动装配，无需手动写配置类） -->
<!-- OpenAI/DeepSeek（兼容OpenAI接口）：共用此Starter -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
</dependency>
<!-- Ollama本地模型：单独Starter -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-ollama-spring-boot-starter</artifactId>
</dependency>

<!-- 测试依赖（必加，JUnit5） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

2. 手动构建场景（快速测试，无 SpringBoot）

仅引入核心包，适用于非 Spring 环境快速验证模型调用：

xml

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId> <!-- OpenAI/DeepSeek核心包 -->
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-ollama</artifactId> <!-- Ollama核心包 -->
</dependency>

二、方式 1：手动构建模型实例（快速测试，无 SpringBoot）

核心：Builder 模式灵活配置参数，手动创建模型实例，适用于快速验证 API 可用性、非 Spring 项目，步骤统一（所有模型均适用）。

通用步骤（3 步）

1. 调用模型类的builder()方法，初始化构建器；
2. 配置模型专属核心参数（base-url、密钥、模型名）；
3. 调用build()创建实例，通过chat()方法发起对话。

实战示例（3 大模型全覆盖）

1. OpenAI（演示环境，无真实密钥即可测试）

java

运行

import dev.langchain4j.model.openai.OpenAiChatModel;

// 快速测试OpenAI
@Test
public void testOpenAiManual() {
    // 1. 构建模型实例（Builder模式）
    OpenAiChatModel model = OpenAiChatModel.builder()
            .baseUrl("http://langchain4j.dev/demo/openai/v1") // 演示环境地址，无需真实密钥
            .apiKey("demo") // 演示密钥
            .modelName("gpt-4o-mini") // 模型名称
            .temperature(0.7) // 可选：温度，控制结果随机性
            .build();
    // 2. 发起对话+处理结果
    String answer = model.chat("你好");
    System.out.println("OpenAI响应：" + answer);
}

2. DeepSeek（兼容 OpenAI 接口，复用 OpenAiChatModel）

核心原理：DeepSeek 遵循 OpenAI 接口标准，无需单独模型类 ，直接用OpenAiChatModel，仅修改base-url和model-name即可。

java

运行

import dev.langchain4j.model.openai.OpenAiChatModel;

// 快速测试DeepSeek（手动构建）
@Test
public void testDeepSeekManual() {
    OpenAiChatModel model = OpenAiChatModel.builder()
            .baseUrl("https://api.deepseek.com") // DeepSeek专属API地址
            .apiKey(System.getenv("DEEP_SEEK_API_KEY")) // 环境变量获取密钥，避免硬编码
            .modelName("deepseek-chat") // 可选：deepseek-reasoner（推理模型）
            .temperature(0.9)
            .build();
    String answer = model.chat("你好，介绍一下自己");
    System.out.println("DeepSeek响应：" + answer);
}

3. Ollama 本地模型（如 DeepSeek-R1:1.5b/7b）

java

运行

import dev.langchain4j.model.ollama.OllamaChatModel;

// 快速测试本地Ollama+DeepSeek-R1
@Test
public void testOllamaManual() {
    OllamaChatModel model = OllamaChatModel.builder()
            .baseUrl("http://localhost:11434") // Ollama默认本地地址，固定
            .modelName("deepseek-r1:1.5b") // 与ollama list查询的模型名完全一致
            .timeout(30000) // 可选：超时时间，适配本地模型慢响应
            .build();
    String answer = model.chat("你好，介绍一下DeepSeek-R1");
    System.out.println("本地DeepSeek-R1响应：" + answer);
}

三、方式 2：SpringBoot 自动装配（生产推荐，核心）

核心：利用LangChain4J Starter 机制 ，配置文件集中管理参数 ，SpringBoot 启动时自动创建模型 Bean 并注册到容器，开发者直接@Autowired注入使用，无需手动构建，实现配置与代码分离，便于维护和扩展。

通用核心步骤（4 步，所有模型通用）

1. 引入对应模型 Starter 依赖（已在基础前提中配置）；
2. application.properties/yml中配置模型专属参数（前缀区分模型）；
3. 确保 SpringBoot 启动类加@SpringBootApplication（激活自动配置）；
4. 业务 / 测试类中@Autowired注入模型实例，调用chat()方法。

实战示例（3 大模型并行配置，可同时使用）

步骤 1：配置文件集中配置（application.properties）

用不同前缀区分模型，可同时配置 OpenAI、DeepSeek、Ollama，无冲突，Spring 自动创建对应 Bean。

properties

# ========== 1. OpenAI配置（演示环境） ==========
# 前缀：langchain4j.open-ai.chat-model
langchain4j.open-ai.chat-model.base-url=http://langchain4j.dev/demo/openai/v1
langchain4j.open-ai.chat-model.api-key=demo
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini
langchain4j.open-ai.chat-model.temperature=0.7
# 可选：开启请求/响应日志，便于调试
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true

# ========== 2. DeepSeek配置（兼容OpenAI，单独前缀避免冲突） ==========
# 核心：通过 qualifier 区分Bean，避免与OpenAI的OpenAiChatModel冲突
langchain4j.open-ai.chat-model.deepseek.base-url=https://api.deepseek.com
langchain4j.open-ai.chat-model.deepseek.api-key=${DEEP_SEEK_API_KEY} # 环境变量获取密钥
langchain4j.open-ai.chat-model.deepseek.model-name=deepseek-chat
langchain4j.open-ai.chat-model.deepseek.temperature=0.9

# ========== 3. Ollama+本地DeepSeek-R1配置 ==========
# 前缀：langchain4j.ollama.chat-model（固定）
langchain4j.ollama.chat-model.base-url=http://localhost:11434
langchain4j.ollama.chat-model.model-name=deepseek-r1:1.5b
langchain4j.ollama.chat-model.timeout=30000
langchain4j.ollama.chat-model.log-requests=true

步骤 2：SpringBoot 启动类（激活自动配置，缺一不可）

java

运行

package com.qcby; // 与项目包名一致
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// 核心：激活所有Starter的自动配置，创建模型Bean
@SpringBootApplication
public class AiApplication {
    public static void main(String[] args) {
        SpringApplication.run(AiApplication.class, args);
    }
}

步骤 3：注入并使用模型（测试 / 业务类通用）

• 单模型：直接@Autowired注入；
• 多模型（如同时有 OpenAI 和 DeepSeek，均为OpenAiChatModel）：用@Qualifier指定 Bean 名称（与配置文件中自定义前缀一致）区分。

java

运行

package com.qcby;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.ollama.OllamaChatModel;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

// 核心：@SpringBootTest 加载Spring测试容器，激活自动装配
@SpringBootTest
public class AiMultiModelTest {

    // 1. 注入OpenAI模型（默认前缀，直接注入）
    @Autowired
    private OpenAiChatModel openAiChatModel;

    // 2. 注入DeepSeek模型（多实例，用@Qualifier指定配置前缀，区分Bean）
    @Autowired
    @Qualifier("deepseekOpenAiChatModel") // 规则：配置前缀 + OpenAiChatModel
    private OpenAiChatModel deepSeekChatModel;

    // 3. 注入Ollama本地模型（单独类，无冲突）
    @Autowired
    private OllamaChatModel ollamaChatModel;

    // 测试OpenAI
    @Test
    public void testOpenAi() {
        String answer = openAiChatModel.chat("你好");
        System.out.println("OpenAI：" + answer);
    }

    // 测试DeepSeek
    @Test
    public void testDeepSeek() {
        String answer = deepSeekChatModel.chat("你好，介绍一下DeepSeek");
        System.out.println("DeepSeek：" + answer);
    }

    // 测试本地Ollama+DeepSeek-R1
    @Test
    public void testLocalDeepSeekR1() {
        String answer = ollamaChatModel.chat("你好，说说你的推理能力");
        System.out.println("本地DeepSeek-R1：" + answer);
    }
}

四、DeepSeek 专属配置与使用（核心重点）

DeepSeek 是特殊且重要的适配项 ，其核心优势是中文能力强、推理优秀，且遵循 OpenAI 接口标准，因此整合时无需额外依赖，核心要点如下：

1. 核心接入逻辑

• 复用langchain4j-open-ai-spring-boot-starter依赖，无需单独引入 Starter；
• 复用OpenAiChatModel类，无需新增模型类，仅修改base-url和model-name；
• 多实例场景（同时用 OpenAI 和 DeepSeek）：通过配置文件自定义前缀 +@Qualifier注解区分 Bean，避免冲突。

2. 关键配置项（必配）

配置项	取值	说明
base-url	https://api.deepseek.com	DeepSeek 官方 API 地址，固定
api-key	环境变量 / 配置中心	避免硬编码，Windows 用setx DEEP_SEEK_API_KEY 你的密钥，Linux/Mac 用export DEEP_SEEK_API_KEY=你的密钥
model-name	deepseek-chat/deepseek-reasoner	二选一：聊天模型（通用对话）/ 推理模型（逻辑计算、复杂思考）

3. 模型版本选择建议

• deepseek-chat：通用场景（智能客服、内容生成、日常问答），中文处理流畅；
• deepseek-reasoner：专业场景（数学计算、代码生成、逻辑推理、企业级复杂问题），推理能力强。

五、Ollama + 本地 DeepSeek-R1 补充步骤（本地部署）

Ollama 是本地模型部署工具，整合前需先完成本地服务部署 + 模型拉取，再进行 SpringBoot 配置，核心前置步骤（Windows/Linux/Mac 通用）：

1. 安装 Ollama：官网下载安装包（Windows）或执行curl -fsSL https://ollama.com/install.sh | sh（Linux/Mac），安装后自动启动服务（默认端口 11434）；
2. 拉取 DeepSeek-R1 模型：终端执行ollama pull deepseek-r1:1.5b（低配置）/deepseek-r1:7b（平衡性能）；
3. 验证部署：执行ollama list查看模型，执行ollama run deepseek-r1:1.5b本地对话测试，确保模型可用；
4. 验证服务：访问http://localhost:11434/api/tags，返回模型列表即服务正常。

六、核心对比：手动构建 vs SpringBoot 自动装配

维度	手动构建（Builder 模式）	SpringBoot 自动装配（Starter）
核心优势	快速测试、无 Spring 依赖、灵活修改参数	配置集中管理、代码无侵入、自动装配、可复用、易维护
适用场景	接口验证、非 Spring 项目、临时测试	生产环境、SpringBoot 项目、多模型集成、团队协作
代码量	每次使用需重复构建实例	一次配置、多处@Autowired注入使用
维护性	参数散落在代码中，修改需改代码	配置文件集中管理，修改无需改代码
扩展性	新增模型需手动添加构建代码	新增模型仅需引入 Starter + 添加配置，无代码修改

七、生产环境关键注意事项

1. 密钥管理：所有 API 密钥（OpenAI/DeepSeek）通过 ** 环境变量 / 配置中心（Nacos/Apollo）** 管理，绝对禁止硬编码在代码 / 配置文件中；
2. 日志控制 ：测试环境开启log-requests=true/log-responses=true调试，生产环境关闭，避免日志泄露敏感信息；
3. 参数优化 ：根据业务场景调整temperature（0~2，精准场景设 0.3~0.5，创作场景设 0.7~0.9）、timeout（本地模型设 30000ms 以上）、max-tokens（控制响应长度）；
4. 错误处理：生产环境添加异常捕获（如网络超时、API 限流、模型调用失败），避免服务崩溃；
5. 多模型隔离 ：同时集成多个模型时，通过@Qualifier严格区分 Bean，避免注入错误；
6. 资源限制：Ollama 本地模型需根据硬件配置选择版本（1.5b 需 4GB + 内存，7b 需 8GB + 内存），无 GPU 则纯 CPU 运行，建议关闭其他高内存程序。

八、核心总结

LangChain4J 整合多 AI 模型的核心精髓是 **「接口标准化 + 配置可插拔 + Starter 自动化」**：

1. 所有聊天模型均提供统一的chat()方法，调用逻辑完全一致，降低学习成本；
2. DeepSeek 兼容 OpenAI 接口标准，实现「零依赖扩展」，复用现有 OpenAI 整合代码；
3. SpringBoot 场景通过BOM 统一版本 + Starter 自动装配，实现「配置与代码分离」，最大化提升可维护性和扩展性；
4. 本地模型（Ollama+DeepSeek-R1）通过专属 Starter 整合，兼顾数据隐私（本地处理）和使用便捷性（与云端模型相同调用方式）。