Spring AI与主流AI模型集成实战

最新推荐文章于 2025-10-13 04:33:09 发布
原创 最新推荐文章于 2025-10-13 04:33:09 发布 · 417 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Spring AI与主流AI模型集成实战

本文全面介绍了Spring AI框架与多种主流AI模型的集成实践，包括OpenAI、Azure OpenAI、Google Vertex AI、Amazon Bedrock以及本地模型Ollama和Transformers。文章详细讲解了各平台的配置方法、依赖设置、核心架构设计以及高级功能实现，为开发者提供了完整的AI集成解决方案。

OpenAI与Azure OpenAI集成配置

Spring AI为开发者提供了与OpenAI和Azure OpenAI服务的无缝集成能力，通过统一的API抽象层简化了AI模型的调用过程。本节将深入探讨如何在Spring应用中配置和使用这两种服务。

核心依赖配置

首先需要在项目的pom.xml中添加相应的依赖：

<!-- OpenAI 依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

<!-- Azure OpenAI 依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-azure-openai</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

配置文件设置

在application.properties或application.yml中配置API密钥和端点：

# OpenAI 配置
spring.ai.openai.api-key=${OPENAI_API_KEY}
spring.ai.openai.base-url=https://api.openai.com/v1

# Azure OpenAI 配置
spring.ai.azure.openai.api-key=${AZURE_OPENAI_API_KEY}
spring.ai.azure.openai.endpoint=${AZURE_OPENAI_ENDPOINT}
spring.ai.azure.openai.deployment-name=gpt-4

核心模型类结构

Spring AI为OpenAI和Azure OpenAI提供了统一的模型抽象：

mermaid

配置Bean定义

在Spring配置类中定义模型Bean：

@Configuration
public class AiConfiguration {
    
    @Bean
    @ConditionalOnProperty(name = "spring.ai.openai.api-key")
    public OpenAiChatModel openAiChatModel(OpenAiApi openAiApi) {
        OpenAiChatOptions options = OpenAiChatOptions.builder()
            .withModel("gpt-4")
            .withTemperature(0.7f)
            .withMaxTokens(1000)
            .build();
        
        return new OpenAiChatModel(openAiApi, options);
    }
    
    @Bean
    @ConditionalOnProperty(name = "spring.ai.azure.openai.api-key")
    public AzureOpenAiChatModel azureOpenAiChatModel(OpenAIClient openAIClient) {
        AzureOpenAiChatOptions options = AzureOpenAiChatOptions.builder()
            .withDeploymentName("gpt-4")
            .withTemperature(0.7f)
            .withMaxTokens(1000)
            .build();
        
        return new AzureOpenAiChatModel(openAIClient, options);
    }
}
高级配置选项

两种服务都支持丰富的配置选项：

配置项OpenAIAzure OpenAI描述
模型选择modeldeploymentName指定使用的模型或部署
温度控制temperaturetemperature控制输出的随机性
最大令牌数maxTokensmaxTokens限制响应长度
频率惩罚frequencyPenaltyfrequencyPenalty减少重复内容
存在惩罚presencePenaltypresencePenalty鼓励新话题
停止序列stopstop指定停止生成的序列

服务调用流程

Spring AI的服务调用遵循统一的流程：

mermaid

错误处理与重试机制

Spring AI内置了完善的错误处理机制：

@Configuration
public class RetryConfiguration {
    
    @Bean
    public RetryTemplate openAiRetryTemplate() {
        return RetryTemplate.builder()
            .maxAttempts(3)
            .exponentialBackoff(1000, 2, 5000)
            .retryOn(OpenAiApiException.class)
            .build();
    }
}

多模型切换策略

在实际应用中，可能需要根据环境切换不同的AI服务：

@Service
public class AiService {
    
    private final ChatModel chatModel;
    
    public AiService(
        @Qualifier("openAiChatModel") Optional<ChatModel> openAiChatModel,
        @Qualifier("azureOpenAiChatModel") Optional<ChatModel> azureOpenAiChatModel) {
        
        this.chatModel = openAiChatModel.orElseGet(() -> 
            azureOpenAiChatModel.orElseThrow(() -> 
                new IllegalStateException("No AI service configured")));
    }
    
    public String generateResponse(String prompt) {
        return chatModel.call(new Prompt(prompt))
            .getResult()
            .getOutput()
            .getContent();
    }
}

性能优化建议

  1. 连接池配置：调整HTTP客户端连接池大小
  2. 超时设置：根据网络状况设置合理的超时时间
  3. 批量处理：对于embeddings等操作使用批量API
  4. 缓存策略：对频繁查询的结果实施缓存

监控与日志

启用详细的日志记录来监控AI服务调用：

logging.level.org.springframework.ai.openai=DEBUG
logging.level.org.springframework.ai.azure.openai=DEBUG
logging.level.org.springframework.web.client=DEBUG

通过以上配置，开发者可以轻松地在OpenAI和Azure OpenAI服务之间切换，同时享受Spring AI提供的统一API和丰富的功能特性。这种设计使得应用具备更好的可移植性和维护性，能够适应不同的部署环境和业务需求。

Google Vertex AI与Gemini接入指南

Spring AI框架为开发者提供了与Google Vertex AI Gemini模型的无缝集成能力，让您能够轻松地在Spring应用中接入强大的多模态AI能力。Gemini作为Google最新一代的多模态大语言模型，支持文本、图像、音频等多种输入格式，为构建智能应用提供了强大的基础。

环境配置与依赖设置

要在Spring Boot项目中集成Vertex AI Gemini，首先需要在pom.xml中添加相应的依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-vertex-ai-gemini</artifactId>
    <version>1.0.0</version>
</dependency>

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-spring-boot-starter-vertex-ai-gemini</artifactId>
    <version>1.0.0</version>
</dependency>

配置属性详解

Spring AI提供了灵活的配置选项来连接Vertex AI服务。在application.properties或application.yml中进行如下配置：

spring:
  ai:
    vertex:
      ai:
        gemini:
          project-id: your-gcp-project-id
          location: us-central1
          credentials-uri: classpath:service-account-key.json
          transport: GRPC # 可选：GRPC 或 REST
          chat:
            options:
              model: gemini-pro-vision
              temperature: 0.7
              candidate-count: 1
              max-output-tokens: 2048
              top-p: 0.95

配置属性说明：

配置项类型默认值描述
project-idString无GCP项目ID
locationString无Vertex AI服务区域
credentials-uriResource无服务账号密钥文件路径
transportTransportGRPC传输协议：GRPC或REST
options.modelStringgemini-pro-visionGemini模型名称
options.temperatureFloat0.7生成温度，控制随机性
options.candidate-countInteger1生成候选数量
options.max-output-tokensInteger2048最大输出token数

核心组件架构

Spring AI的Vertex AI Gemini集成采用了清晰的分层架构：

mermaid

基础使用示例

1. 文本生成示例
@Service
public class GeminiTextService {
    
    private final VertexAiGeminiChatModel chatModel;
    
    public GeminiTextService(VertexAiGeminiChatModel chatModel) {
        this.chatModel = chatModel;
    }
    
    public String generateText(String prompt) {
        Prompt chatPrompt = new Prompt(new UserMessage(prompt));
        ChatResponse response = chatModel.call(chatPrompt);
        return response.getResult().getOutput().getContent();
    }
}
2. 多模态输入处理

Gemini支持处理图像和文本的混合输入：

public String analyzeImageWithText(String imageUrl, String question) {
    var imageMessage = new UserMessage(question, 
        List.of(new Media(MimeType.IMAGE_JPEG, imageUrl)));
    
    Prompt prompt = new Prompt(imageMessage);
    ChatResponse response = chatModel.call(prompt);
    
    return response.getResult().getOutput().getContent();
}

高级功能配置

函数调用支持

Spring AI Gemini集成支持函数调用，让模型能够与外部系统交互：

@Bean
public FunctionCallback weatherFunction() {
    return new FunctionCallbackWrapper<>("getCurrentWeather", 
        "获取指定城市的当前天气", 
        (String location) -> weatherService.getWeather(location));
}

// 配置函数调用选项
@Bean
public VertexAiGeminiChatOptions geminiOptions() {
    return VertexAiGeminiChatOptions.builder()
        .withModel("gemini-pro")
        .withFunctionCallbacks(List.of(weatherFunction()))
        .build();
}
流式响应处理

对于需要实时响应的场景，可以使用流式API：

public Flux<String> streamResponse(String prompt) {
    return Flux.create(sink -> {
        Prompt chatPrompt = new Prompt(new UserMessage(prompt));
        chatModel.stream(chatPrompt)
            .doOnNext(response -> {
                String content = response.getResult().getOutput().getContent();
                if (content != null) {
                    sink.next(content);
                }
            })
            .doOnComplete(sink::complete)
            .doOnError(sink::error)
            .subscribe();
    });
}

错误处理与重试机制

Spring AI提供了内置的错误处理和重试机制：

spring:
  ai:
    retry:
      max-attempts: 3
      backoff:
        initial-interval: 1000ms
        multiplier: 2.0
        max-interval: 5000ms

自定义错误处理：

@ControllerAdvice
public class GeminiExceptionHandler {
    
    @ExceptionHandler(VertexAiException.class)
    public ResponseEntity<String> handleVertexAiException(VertexAiException ex) {
        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
            .body("Vertex AI服务暂时不可用: " + ex.getMessage());
    }
}

性能优化建议

  1. 连接池配置：调整GRPC连接池大小以提高并发性能
  2. 批量处理：对于批量请求，使用异步处理提高吞吐量
  3. 缓存策略：对频繁查询的结果实施缓存机制
  4. 监控指标：集成Micrometer监控模型调用指标
@Configuration
public class GeminiPerformanceConfig {
    
    @Bean
    public MeterBinder vertexAiMetrics(VertexAiGeminiChatModel chatModel) {
        return registry -> {
            // 监控调用次数、延迟、错误率等指标
        };
    }
}

安全最佳实践

  1. 凭据管理：使用GCP Secret Manager管理服务账号密钥
  2. 访问控制：通过IAM角色限制模型访问权限
  3. 数据加密：确保传输中和静态数据的安全
  4. 审计日志：记录所有模型调用用于安全审计

通过Spring AI的Vertex AI Gemini集成，开发者可以快速构建基于多模态AI的智能应用，同时享受Spring生态系统的完整支持，包括依赖注入、配置管理、监控指标等企业级特性。

Amazon Bedrock多模型支持实践

Amazon Bedrock作为AWS提供的全托管生成式AI服务，为开发者提供了访问多个顶级AI模型的统一接口。Spring AI通过Bedrock模块实现了对Amazon Bedrock服务的全面集成，支持包括Anthropic Claude、Cohere、Llama 2、Titan、Jurassic-2在内的多种主流AI模型。本文将深入探讨Spring AI如何实现对Amazon Bedrock多模型的支持，并提供详细的实践指南。

Bedrock多模型架构设计

Spring AI的Bedrock模块采用了分层架构设计，为每种支持的模型提供了独立的API层和模型层。这种设计确保了代码的模块化和可扩展性，使得新增模型支持变得简单高效。

mermaid

支持的模型类型及特性

Spring AI Bedrock模块目前支持以下主流AI模型，每种模型都有其独特的特性和适用场景：

模型提供商模型名称主要特性适用场景
AnthropicClaude 2/3长上下文、强推理能力复杂对话、文档分析
CohereCommand指令跟随、代码生成文本生成、编程辅助
MetaLlama 2开源模型、多语言支持研究开发、多语言应用
AmazonTitanAWS原生、成本优化企业应用、成本敏感场景
AI21 LabsJurassic-2创意写作、内容生成营销文案、创意内容

多模型配置实践

1. 依赖配置

首先需要在项目的pom.xml中添加Spring AI Bedrock依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-bedrock</artifactId>
    <version>1.0.0-M1</version>
</dependency>
2. AWS凭证配置

配置AWS访问凭证，可以通过环境变量或AWS配置文件：

export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
export AWS_REGION=us-east-1
3. 多模型Bean配置

在Spring配置类中配置多个Bedrock模型Bean：

@Configuration
public class BedrockConfig {

    @Bean
    public CohereChatBedrockApi cohereApi() {
        return new CohereChatBedrockApi(
            CohereChatModel.COHERE_COMMAND_V14.id(),
            EnvironmentVariableCredentialsProvider.create(),
            Region.US_EAST_1.id(),
            new ObjectMapper(),
            Duration.ofMinutes(2)
        );
    }

    @Bean
    public AnthropicChatBedrockApi anthropicApi() {
        return new AnthropicChatBedrockApi(
            AnthropicChatModel.CLAUDE_V2.id(),
            EnvironmentVariableCredentialsProvider.create(),
            Region.US_EAST_1.id(),
            new ObjectMapper(),
            Duration.ofMinutes(2)
        );
    }

    @Bean
    public BedrockCohereChatModel cohereChatModel(CohereChatBedrockApi cohereApi) {
        return new BedrockCohereChatModel(cohereApi);
    }

    @Bean
    public BedrockAnthropicChatModel anthropicChatModel(AnthropicChatBedrockApi anthropicApi) {
        return new BedrockAnthropicChatModel(anthropicApi);
    }
}

模型特性深度解析

Anthropic Claude模型特性

Anthropic的Claude模型以其强大的推理能力和长上下文处理著称。Spring AI提供了专门的配置选项：

public class AnthropicChatOptions {
    private Float temperature;          // 生成多样性控制
    private Integer maxTokensToSample;  // 最大生成token数
    private Integer topK;               // Top-K采样
    private Float topP;                 // Top-P采样
    private List<String> stopSequences; // 停止序列
    private String anthropicVersion;    // API版本
}

使用示例：

AnthropicChatOptions options = AnthropicChatOptions.builder()
    .withTemperature(0.7f)
    .withMaxTokensToSample(1000)
    .withTopP(0.9f)
    .build();

Prompt prompt = new Prompt("解释量子计算的基本原理", options);
ChatResponse response = anthropicChatModel.call(prompt);
Cohere模型指令跟随能力

Cohere模型特别擅长指令跟随任务，Spring AI提供了丰富的配置选项：

public class BedrockCohereChatOptions {
    private Float temperature;
    private Float topP;
    private Integer topK;
    private Integer maxTokens;
    private List<String> stopSequences;
    private ReturnLikelihoods returnLikelihoods;
    private Integer numGenerations;
    private LogitBias logitBias;
    private Truncate truncate;
}

代码生成示例：

String promptText = """
    请用Java编写一个方法，接收字符串列表，
    返回按长度排序后的新列表。
    只返回代码，不要解释。
    """;

Prompt prompt = new Prompt(new UserMessage(promptText));
ChatResponse response = cohereChatModel.call(prompt);
多模型路由策略

在实际应用中，可以根据任务类型动态选择最合适的模型：

@Service
public class ModelRouterService {
    
    private final BedrockCohereChatModel cohereModel;
    private final BedrockAnthropicChatModel anthropicModel;
    private final BedrockLlamaChatModel llamaModel;

    public ChatResponse routeToModel(String taskType, String promptText) {
        switch (taskType) {
            case "code_generation":
                return cohereModel.call(new Prompt(promptText));
            case "complex_reasoning":
                return anthropicModel.call(new Prompt(promptText));
            case "multilingual":
                return llamaModel.call(new Prompt(promptText));
            default:
                return cohereModel.call(new Prompt(promptText));
        }
    }
}

高级特性与最佳实践

1. 流式响应处理

所有Bedrock模型都支持流式响应，适合实时交互场景：

Flux<ChatResponse> responseStream = chatModel.stream(
    new Prompt("实时生成一篇关于人工智能的文章")
);

responseStream.subscribe(response -> {
    System.out.print(response.getResult().getOutput().getContent());
}, error -> {
    System.err.println("Error: " + error.getMessage());
}, () -> {
    System.out.println("\n生成完成");
});
2. 输出解析器集成

Spring AI提供了多种输出解析器，可以将模型输出转换为结构化数据：

// List输出解析器
ListOutputConverter listConverter = new ListOutputConverter(conversionService);
String listPrompt = "列出5种编程语言\n" + listConverter.getFormat();
List<String> languages = listConverter.convert(
    chatModel.call(new Prompt(listPrompt)).getResult().getOutput().getContent()
);

// Bean输出解析器
record Person(String name, int age, String city) {}
BeanOutputConverter<Person> beanConverter = new BeanOutputConverter<>(Person.class);
String beanPrompt = "生成一个人物信息\n" + beanConverter.getFormat();
Person person = beanConverter.convert(
    chatModel.call(new Prompt(beanPrompt)).getResult().getOutput().getContent()
);
3. 提示词模板化

使用Spring AI的提示词模板功能实现动态内容生成：

PromptTemplate template = new PromptTemplate("""
    作为{role}，请用{style}风格回答以下问题：
    {question}
    """);

Map<String, Object> variables = Map.of(
    "role", "资深技术专家",
    "style", "专业且易懂",
    "question", "解释微服务架构的优势和挑战"
);

Prompt prompt = new Prompt(template.createMessage(variables));
ChatResponse response = chatModel.call(prompt);

性能优化与监控

1. 连接超时配置

针对不同的使用场景配置合适的超时时间：

@Bean
public CohereChatBedrockApi cohereApiWithTimeout() {
    return new CohereChatBedrockApi(
        CohereChatModel.COHERE_COMMAND_V14.id(),
        EnvironmentVariableCredentialsProvider.create(),
        Region.US_EAST_1.id(),
        new ObjectMapper(),
        Duration.ofSeconds(30) // 缩短超时时间用于实时应用
    );
}
2. 使用量监控

通过BedrockUsage类监控token使用情况：

ChatResponse response = chatModel.call(prompt);
BedrockUsage usage = response.getUsage();

System.out.println("Prompt tokens: " + usage.getPromptTokens());
System.out.println("Generation tokens: " + usage.getGenerationTokens());
System.out.println("Total tokens: " + (usage.getPromptTokens() + usage.getGenerationTokens()));

错误处理与重试机制

实现健壮的错误处理策略：

@Service
public class RobustChatService {
    
    private final List<ChatModel> fallbackModels;
    
    public ChatResponse robustCall(Prompt prompt, ChatModel primaryModel) {
        try {
            return primaryModel.call(prompt);
        } catch (Exception e) {
            // 主模型失败时使用备用模型
            for (ChatModel fallback : fallbackModels) {
                try {
                    return fallback.call(prompt);
                } catch (Exception ex) {
                    // 记录日志，继续尝试下一个
                }
            }
            throw new RuntimeException("所有模型调用失败", e);
        }
    }
}

通过上述实践，开发者可以充分利用Amazon Bedrock的多模型优势，根据具体业务需求选择最合适的AI模型，构建高效、可靠的AI应用。Spring AI的Bedrock模块提供了统一的API接口和丰富的配置选项，使得多模型管理和切换变得简单直观。

本地模型Ollama与Transformers部署

在Spring AI框架中，本地模型部署提供了强大的离线AI能力，让开发者能够在完全本地化的环境中运行大型语言模型和嵌入模型。Ollama和Transformers是两个核心的本地模型集成方案，分别针对聊天对话和文本嵌入场景提供了完整的解决方案。

Ollama本地大语言模型部署

Ollama是一个开源的本地大语言模型运行框架，支持多种主流开源模型。Spring AI通过spring-ai-ollama模块提供了与Ollama的无缝集成。

环境准备与依赖配置

首先需要在项目中添加Ollama依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-ollama</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

同时需要安装并启动Ollama服务：

# 安装Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# 启动Ollama服务
ollama serve

# 下载模型（例如mistral模型）
ollama pull mistral
Spring Boot自动配置

Spring AI提供了完整的自动配置支持，只需在application.properties中进行简单配置：

# Ollama连接配置
spring.ai.ollama.base-url=http://localhost:11434

# 聊天模型配置
spring.ai.ollama.chat.enabled=true
spring.ai.ollama.chat.options.model=mistral
spring.ai.ollama.chat.options.temperature=0.7

# 嵌入模型配置  
spring.ai.ollama.embedding.enabled=true
spring.ai.ollama.embedding.options.model=nomic-embed-text
编程式配置与使用

除了自动配置，也可以编程式创建Ollama客户端：

@Configuration
public class OllamaConfig {

    @Bean
    public OllamaApi ollamaApi() {
        return new OllamaApi("http://localhost:11434");
    }

    @Bean
    public OllamaChatModel ollamaChatModel(OllamaApi ollamaApi) {
        OllamaOptions options = OllamaOptions.create()
            .withModel("mistral")
            .withTemperature(0.7f)
            .withTopP(0.9f);
        return new OllamaChatModel(ollamaApi, options);
    }

    @Bean
    public OllamaEmbeddingModel ollamaEmbeddingModel(OllamaApi ollamaApi) {
        OllamaOptions options = OllamaOptions.create()
            .withModel("nomic-embed-text");
        return new OllamaEmbeddingModel(ollamaApi, options);
    }
}
高级配置选项

Ollama提供了丰富的模型参数配置：

OllamaOptions options = OllamaOptions.create()
    .withModel("mistral")
    .withTemperature(0.7f)          // 生成温度
    .withTopP(0.9f)                // 核心采样
    .withTopK(40)                  // 前K个token采样
    .withNumPredict(100)           // 最大生成长度
    .withRepeatPenalty(1.1f)       // 重复惩罚
    .withNumCtx(4096)              // 上下文窗口大小
    .withNumGPU(1)                 // GPU数量
    .withMainGPU(0)                // 主GPU设备
    .withLowVRAM(false)            // 低显存模式
    .withUseNUMA(true)             // NUMA优化
    .withNumThread(8);             // CPU线程数

Transformers ONNX嵌入模型部署

Transformers模块基于ONNX Runtime提供了本地文本嵌入能力，支持多种预训练的sentence-transformers模型。

依赖配置与模型准备

添加Transformers依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-transformers</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

Spring AI默认使用sentence-transformers/all-MiniLM-L6-v2模型，该模型会自动下载到缓存目录。

自动配置与属性设置
# 启用Transformers嵌入模型
spring.ai.embedding.transformer.enabled=true

# 模型配置
spring.ai.embedding.transformer.onnx.model-uri=classpath:/onnx/all-MiniLM-L6-v2.onnx
spring.ai.embedding.transformer.onnx.gpu-device-id=0  # 使用GPU加速

# Tokenizer配置
spring.ai.embedding.transformer.tokenizer.uri=classpath:/onnx/tokenizer.json
spring.ai.embedding.transformer.tokenizer.options.padding=true
spring.ai.embedding.transformer.tokenizer.options.truncation=true

# 缓存配置
spring.ai.embedding.transformer.cache.enabled=true
spring.ai.embedding.transformer.cache.directory=/tmp/spring-ai-onnx
编程式模型配置
@Configuration
public class TransformersConfig {

    @Bean
    public TransformersEmbeddingModel transformersEmbeddingModel() {
        TransformersEmbeddingModel embeddingModel = new TransformersEmbeddingModel();
        
        // 设置模型路径
        embeddingModel.setModelResource("classpath:/onnx/all-MiniLM-L6-v2.onnx");
        embeddingModel.setTokenizerResource("classpath:/onnx/tokenizer.json");
        
        // 配置GPU加速
        embeddingModel.setGpuDeviceId(0);
        
        // 配置Tokenizer选项
        Map<String, String> tokenizerOptions = new HashMap<>();
        tokenizerOptions.put("padding", "true");
        tokenizerOptions.put("truncation", "true");
        tokenizerOptions.put("maxLength", "512");
        embeddingModel.setTokenizerOptions(tokenizerOptions);
        
        // 禁用缓存（适用于开发环境）
        embeddingModel.setDisableCaching(false);
        embeddingModel.setResourceCacheDirectory("/tmp/spring-ai-onnx");
        
        return embeddingModel;
    }
}
模型使用示例
@Service
public class EmbeddingService {

    @Autowired
    private TransformersEmbeddingModel embeddingModel;

    public void demonstrateEmbedding() {
        // 单个文本嵌入
        List<Double> embedding = embeddingModel.embed("Hello, world!");
        System.out.println("Embedding dimensions: " + embedding.size());
        System.out.println("First 5 values: " + embedding.subList(0, 5));

        // 批量文本嵌入
        List<String> texts = Arrays.asList(
            "Spring AI is a framework for AI engineering",
            "Ollama provides local LLM execution",
            "Transformers offer local embedding capabilities"
        );
        
        List<List<Double>> batchEmbeddings = embeddingModel.embed(texts);
        System.out.println("Batch size: " + batchEmbeddings.size());
        
        // 文档嵌入（包含元数据）
        Document document = new Document(
            "Spring AI supports multiple AI models",
            Map.of("source", "technical documentation", "language", "en")
        );
        List<Double> docEmbedding = embeddingModel.embed(document);
    }
}

性能优化与最佳实践

GPU加速配置

对于支持CUDA的环境，可以启用GPU加速：

# 启用GPU加速
spring.ai.embedding.transformer.onnx.gpu-device-id=0

# Ollama GPU配置
spring.ai.ollama.chat.options.num-gpu=1
spring.ai.ollama.chat.options.main-gpu=0
内存优化策略
// 针对低内存环境的配置
OllamaOptions lowMemoryOptions = OllamaOptions.create()
    .withLowVRAM(true)
    .withNumCtx(2048)      // 减少上下文窗口
    .withNumBatch(512)     // 减小批处理大小
    .withNumThread(4);     // 减少CPU线程

// Transformers内存优化
TransformersEmbeddingModel embeddingModel = new TransformersEmbeddingModel();
embeddingModel.setTokenizerOptions(Map.of(
    "maxLength", "256",    // 限制输入长度
    "truncation", "true"
));
模型缓存与持久化
# 配置模型缓存目录
spring.ai.embedding.transformer.cache.directory=/app/models/cache
spring.ai.embedding.transformer.cache.enabled=true

# 自定义模型路径（支持本地文件和远程URL）
spring.ai.embedding.transformer.onnx.model-uri=file:/models/custom/model.onnx
spring.ai.embedding.transformer.tokenizer.uri=https://huggingface.co/model/tokenizer.json

完整应用示例

下面是一个完整的Spring Boot应用示例，展示如何同时使用Ollama和Transformers：

@SpringBootApplication
public class LocalAiApplication {

    public static void main(String[] args) {
        SpringApplication.run(LocalAiApplication.class, args);
    }

    @Bean
    public CommandLineRunner demo(OllamaChatModel chatModel, 
                                 TransformersEmbeddingModel embeddingModel) {
        return args -> {
            // 使用Ollama进行对话
            Prompt prompt = new Prompt("Explain the benefits of local AI models");
            ChatResponse response = chatModel.call(prompt);
            System.out.println("Ollama response: " + response.getResult().getOutput().getContent());

            // 使用Transformers计算文本相似度
            List<Double> embedding1 = embeddingModel.embed("local AI models");
            List<Double> embedding2 = embeddingModel.embed("offline machine learning");
            
            double similarity = cosineSimilarity(embedding1, embedding2);
            System.out.println("Text similarity: " + similarity);
        };
    }

    private double cosineSimilarity(List<Double> vec1, List<Double> vec2) {
        double dotProduct = 0.0;
        double norm1 = 0.0;
        double norm2 = 0.0;
        
        for (int i = 0; i < vec1.size(); i++) {
            dotProduct += vec1.get(i) * vec2.get(i);
            norm1 += Math.pow(vec1.get(i), 2);
            norm2 += Math.pow(vec2.get(i), 2);
        }
        
        return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
    }
}

部署架构与工作流程

本地模型部署的架构遵循清晰的流程模式：

mermaid

这种架构设计确保了：

  1. 模块化分离：聊天和嵌入功能完全独立，可以单独启用或禁用
  2. 资源优化：根据硬件能力动态配置GPU/CPU资源
  3. 弹性扩展：支持多种模型文件和配置选项
  4. 生产就绪：包含完整的错误处理和性能监控

通过Spring AI的本地模型集成，开发者可以构建完全离线、数据隐私安全的AI应用，同时享受Spring框架的便利性和企业级特性。这种方案特别适合对数据安全性要求高的企业环境、网络受限的场景以及需要低成本AI解决方案的项目。

总结

通过本文的全面介绍，我们可以看到Spring AI框架为开发者提供了与多种主流AI模型的无缝集成能力。从云端服务如OpenAI、Azure OpenAI、Google Vertex AI、Amazon Bedrock，到本地部署的Ollama和Transformers，Spring AI都提供了统一的API抽象层和丰富的配置选项。这种设计不仅简化了AI模型的调用过程，还使得应用具备更好的可移植性和维护性，能够适应不同的部署环境和业务需求。无论是需要云端强大算力还是本地数据隐私保护，Spring AI都能提供合适的解决方案，帮助开发者快速构建高效、可靠的AI应用。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值