AI大模型接口封装

在当今的AI应用场景中，许多企业和开发者面临一个共同的挑战：如何在不修改代码的情况下灵活调用不同的大模型（如OpenAI的GPT和Google的Bard），并且让这些调用尽可能简洁、可维护。这篇博客将介绍如何使用Spring Boot结合多种设计模式，实现一个屏蔽大模型差异的统一接口，从而使大模型应用更加容易落地。

需求分析

目标：实现一个统一的API接口，可以对接不同的大模型，并且支持对话历史记录等附加功能。

需求：

1. 通过同一接口调用不同的大模型。
2. 统一处理对话历史的记录与管理。
3. 可扩展性强，能轻松添加新的大模型支持。
4. 代码结构清晰，维护方便。

架构设计

1. 策略模式 (Strategy Pattern)

使用原因：不同的大模型有着各自独特的API和实现方式。为了避免在代码中写死模型的选择逻辑，我们可以通过策略模式来实现。这样，模型的选择可以在运行时灵活进行，而不会影响代码的其他部分。

优势：

• 灵活性：可以在运行时根据需要选择合适的大模型。
• 可扩展性：增加新模型支持时，只需添加新的策略类即可，无需修改现有代码。

2. 工厂模式 (Factory Pattern)

使用原因：当需要根据输入参数（如模型名称）来创建不同的大模型实例时，工厂模式可以很好地实现对象的创建与使用分离，保持代码的简洁性。

优势：

• 解耦：将对象的创建逻辑封装在工厂类中，使调用者无需关心具体实现细节。
• 维护性：通过工厂模式，可以方便地对对象的创建逻辑进行修改而不影响调用者。

3. 装饰器模式 (Decorator Pattern)

使用原因：在生成模型响应的过程中，我们可能需要附加功能，如记录对话历史、生成日志等。通过装饰器模式，这些功能可以被动态地添加，而无需修改原有的模型实现。

优势：

• 功能扩展灵活：在不改变原有代码的基础上，动态增加功能，如对话历史记录。
• 复用性强：装饰器可以独立开发，并在不同上下文中复用。

4. 适配器模式 (Adapter Pattern)

使用原因：不同的大模型API可能存在接口不兼容的问题（如输入输出格式不同）。适配器模式可以用于转换这些不兼容的接口，使它们能够通过统一的方式进行调用。

优势：

• 兼容性：使不同模型的API能够兼容统一的调用接口。
• 降低耦合：减少修改现有代码的需求，适应新旧系统的协作。

项目结构及部分示例代码

1、项目结构

└── src
    └── main
        └── java
            └── com
                └── example
                    ├── model
                    ├── service
                    ├── controller
                    ├── factory
                    ├── strategy
                    └── history

2. 定义模型接口

public interface LargeModel {
    String generateResponse(String prompt);
}

3. 实现不同的大模型类

public class OpenAIModel implements LargeModel {
    @Override
    public String generateResponse(String prompt) {
        // 调用OpenAI API的实现
        return "Response from OpenAI";
    }
}

public class GoogleBardModel implements LargeModel {
    @Override
    public String generateResponse(String prompt) {
        // 调用Google Bard API的实现
        return "Response from Google Bard";
    }
}

4. 创建模型工厂

public class LargeModelFactory {
    public static LargeModel getModel(String modelName) {
        if (modelName.equalsIgnoreCase("openai")) {
            return new OpenAIModel();
        } else if (modelName.equalsIgnoreCase("googlebard")) {
            return new GoogleBardModel();
        }
        throw new IllegalArgumentException("Unknown model: " + modelName);
    }
}

5. 封装对话历史（装饰器模式）

public class HistoryDecorator implements LargeModel {
    private LargeModel largeModel;
    private List<String> history;

    public HistoryDecorator(LargeModel largeModel) {
        this.largeModel = largeModel;
        this.history = new ArrayList<>();
    }

    @Override
    public String generateResponse(String prompt) {
        history.add(prompt);
        String response = largeModel.generateResponse(prompt);
        history.add(response);
        return response;
    }

    public List<String> getHistory() {
        return history;
    }
}

6. 实现策略模式

public class LargeModelService {
    private LargeModel largeModel;

    public LargeModelService(String modelName) {
        this.largeModel = new HistoryDecorator(LargeModelFactory.getModel(modelName));
    }

    public String getResponse(String prompt) {
        return largeModel.generateResponse(prompt);
    }

    public List<String> getHistory() {
        if (largeModel instanceof HistoryDecorator) {
            return ((HistoryDecorator) largeModel).getHistory();
        }
        return Collections.emptyList();
    }
}

7. 创建API控制器

@RestController
@RequestMapping("/api/v1/chat")
public class ChatController {
    @PostMapping("/{modelName}")
    public ResponseEntity<String> chat(@PathVariable String modelName, @RequestBody String prompt) {
        LargeModelService service = new LargeModelService(modelName);
        String response = service.getResponse(prompt);
        return ResponseEntity.ok(response);
    }

    @GetMapping("/{modelName}/history")
    public ResponseEntity<List<String>> getHistory(@PathVariable String modelName) {
        LargeModelService service = new LargeModelService(modelName);
        return ResponseEntity.ok(service.getHistory());
    }
}

总结

在本文中，我们探讨了如何使用Spring Boot结合策略模式、工厂模式、装饰器模式和适配器模式，实现一个统一的接口来调用不同的大模型。通过这种方式，我们不仅能简化大模型的调用，还能大大提高系统的灵活性和可扩展性。

这种设计方法特别适合需要支持多个AI大模型的应用场景，能够帮助开发者有效应对复杂的模型调用逻辑，使大模型应用更加容易落地。

希望这篇文章能为你在构建大模型应用时提供一些思路和参考。如果你有任何问题或建议，欢迎在评论区交流讨论！