LangChain4j 集成多模型 Provider 方案：OpenAI 与本地模型混合部署

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. 总结与面试要点

在面试中回答这个问题时，可以按照以下逻辑组织你的答案：

1. 阐述核心原理：首先点明 LangChain4j 的 统一抽象接口和模块化是其支持多模型集成的基石。
2. 展示具体方法：说明可以通过独立构建模型实例、创建模型注册表来进行基础管理和切换。
3. 深入高级模式：进一步阐述通过配置中心和依赖注入来解耦配置，通过动态调度器实现策略切换，以及在多代理系统中混合使用不同模型等高级玩法。
4. 补充关键考量：最后可以提及在多模型集成中需要考虑的成本控制、监控告警、错误处理以及数据隐私（特别是使用本地模型时）等实际问题。

这样的回答既能展示你对框架的深入理解，又能体现你在复杂场景下的架构设计能力。