LangChain4j 如何集成多个不同的 Model Provider
在 LangChain4j 中集成多个不同的 Model Provider（如同时使用 OpenAI 和本地模型）是一个非常经典且高级的面试话题。它不仅考察对框架核心设计的理解，也检验在实际复杂业务场景中构建灵活、可靠 AI 应用的架构能力。
核心答案可以概括为：LangChain4j 通过其高度模块化的架构和统一的抽象接口，使得集成、管理和动态切换多个模型提供商变得简单而优雅。开发者可以像搭积木一样，为不同的任务选择最合适的模型，无论是云端的大厂模型还是本地的私有化模型。
下面，我将从架构原理到具体实现，为你层层拆解这一过程。
1. 架构基础：统一的抽象与模块化设计
LangChain4j 能够轻松集成多模型的核心在于其设计哲学：
- 统一的抽象接口：LangChain4j 定义了一套核心接口，如
ChatModel（同步）、StreamingChatModel（流式）、EmbeddingModel（嵌入）等。所有模型提供商的集成，无论是 OpenAI、Google Gemini 还是 Ollama，最终都实现这些相同的接口。 - 模块化的依赖管理：每个模型提供商都有自己独立的 Maven 模块，如
langchain4j-open-ai、langchain4j-ollama。这意味着你可以按需引入，避免了不必要的依赖臃肿。 - 服务提供者接口（SPI）机制：框架利用 Java 的 SPI 机制，在运行时动态加载所需的提供商模块，实现了核心框架与具体实现的解耦。
2. 集成多个 Model Provider 的详细步骤
下面，我们将通过一个完整的例子，展示如何在一个项目中同时集成 OpenAI 的云端模型和通过 Ollama 运行的本地模型。
2.1 第一步：添加必要的依赖
在你的 pom.xml 中，你需要同时引入多个提供商的依赖。
<dependencies>
<!-- LangChain4j 核心库 -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>1.0.0-beta3</version>
</dependency>
<!-- OpenAI 集成 -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-open-ai</artifactId>
<version>1.0.0-beta3</version>
</dependency>
<!-- Ollama 本地模型集成 -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-ollama</artifactId>
<version>1.0.0-beta3</version>
</dependency>
</dependencies>
2.2 第二步：分别初始化不同的模型实例
你可以分别构建不同的模型实例，每个实例都有自己的配置。这是所有后续灵活调度和切换的基础。
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.ollama.OllamaChatModel;
public class MultiModelExample {
public static void main(String[] args) {
// 1. 初始化 OpenAI 模型
ChatLanguageModel openAiModel = OpenAiChatModel.builder()
.apiKey(System.getenv("OPENAI_API_KEY")) // 从环境变量读取 API Key
.modelName("gpt-4o-mini")
.temperature(0.7)
.build();
// 2. 初始化本地 Ollama 模型
ChatLanguageModel localModel = OllamaChatModel.builder()
.baseUrl("http://localhost:11434") // Ollama 默认地址
.modelName("qwen2.5:7b") // 你通过 Ollama 下载的模型
.temperature(0.5)
.build();
// 现在你可以分别使用它们
String openAiResponse = openAiModel.chat("你好，你是谁？");
System.out.println("OpenAI 回复：" + openAiResponse);
String localResponse = localModel.chat("你好，请介绍一下你自己。");
System.out.println("本地模型回复：" + localResponse);
}
}
2.3 第三步：构建模型注册表（Model Registry）
在实际应用中，你通常需要一个中心化的管理机制。模型注册表应运而生，它是一个用于存储、管理和检索不同模型实例的组件。
import dev.langchain4j.model.chat.ChatLanguageModel;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
// 模型注册表
public class ModelRegistry {
private final Map<String, ChatLanguageModel> models = new ConcurrentHashMap<>();
private final Map<String, ModelMetadata> metadata = new ConcurrentHashMap<>();
// 内部类，存储模型的元数据，用于智能调度
public static class ModelMetadata {
private final String description;
private final String capability; // e.g., "reasoning", "translation", "fast"
private final double costPerToken; // 用于成本控制
// 构造函数、getter、setter 略
}
public void register(String name, ChatLanguageModel model, ModelMetadata meta) {
models.put(name, model);
metadata.put(name, meta);
}
public ChatLanguageModel getModel(String name) {
return models.get(name);
}
public ChatLanguageModel selectModelByTask(String taskType) {
// 根据任务类型智能选择模型
return metadata.entrySet().stream()
.filter(entry -> entry.getValue().getCapability().equals(taskType))
.findFirst()
.map(entry -> models.get(entry.getKey()))
.orElseGet(() -> models.get("default"));
}
}
3. 高级集成模式与策略
掌握了基础集成后，我们来看看更高级的用法，这也是面试中的加分项。
3.1 通过配置文件和依赖注入管理（以 Payara Micro 为例）
在企业级应用（如使用 Jakarta EE 或 Spring Boot）中，硬编码配置显然不是最佳实践。你可以将模型配置外部化到配置文件中，并通过依赖注入来管理。
配置文件 (microprofile-config.properties)
# OpenAI 配置
openai.api.key=${OPENAI_API_KEY}
openai.chat.model=gpt-4o-mini
# 本地模型配置
ollama.base.url=http://localhost:11434
ollama.chat.model=qwen2.5:7b
服务类 (ModelService.java)
import jakarta.annotation.PostConstruct;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.eclipse.microprofile.config.inject.ConfigProperty;
@ApplicationScoped
public class ModelService {
@Inject
@ConfigProperty(name = "openai.api.key")
private String openAiApiKey;
@Inject
@ConfigProperty(name = "ollama.base.url")
private String ollamaBaseUrl;
private ChatLanguageModel openAiModel;
private ChatLanguageModel localModel;
@PostConstruct
public void init() {
this.openAiModel = OpenAiChatModel.builder()
.apiKey(openAiApiKey)
.modelName("gpt-4o-mini")
.build();
this.localModel = OllamaChatModel.builder()
.baseUrl(ollamaBaseUrl)
.modelName("qwen2.5:7b")
.build();
}
public ChatLanguageModel getOpenAiModel() {
return openAiModel;
}
public ChatLanguageModel getLocalModel() {
return localModel;
}
}
3.2 动态策略切换
你可以构建一个调度器，根据运行时上下文（如问题类型、成本预算、响应速度要求等）动态选择模型。
public class SmartScheduler {
private final ModelRegistry registry;
public SmartScheduler(ModelRegistry registry) {
this.registry = registry;
}
public String execute(String userQuery) {
// 1. 意图识别：用一个廉价快速的本地模型判断问题类型
String taskType = identifyTaskType(userQuery, registry.getModel("fast-local"));
// 2. 模型路由：根据任务类型选择执行模型
ChatLanguageModel selectedModel = registry.selectModelByTask(taskType);
// 3. 执行并返回
return selectedModel.chat(userQuery);
}
private String identifyTaskType(String query, ChatLanguageModel classifier) {
// 调用分类模型识别任务类型，如 "math", "creative_writing", "summarization"
String prompt = String.format("请将以下问题分类为 'math', 'creative', 或 'simple': %s", query);
return classifier.chat(prompt);
}
}
3.3 混合场景下的代理协作
在一个多代理系统中，可以让不同的 Agent 使用不同的模型，协同完成复杂任务。例如，一个用于路由的"主管"Agent 使用快速廉价的本地模型，而负责最终内容生成的"专家"Agent 则使用能力更强的云端大模型。
4. 总结与面试要点
在面试中回答这个问题时，可以按照以下逻辑组织你的答案：
- 阐述核心原理：首先点明 LangChain4j 的 统一抽象接口和模块化是其支持多模型集成的基石。
- 展示具体方法：说明可以通过独立构建模型实例、创建模型注册表来进行基础管理和切换。
- 深入高级模式：进一步阐述通过配置中心和依赖注入来解耦配置，通过动态调度器实现策略切换，以及在多代理系统中混合使用不同模型等高级玩法。
- 补充关键考量：最后可以提及在多模型集成中需要考虑的成本控制、监控告警、错误处理以及数据隐私（特别是使用本地模型时）等实际问题。
这样的回答既能展示你对框架的深入理解，又能体现你在复杂场景下的架构设计能力。
