Spring AI，一个让Spring应用轻松拥抱AI的统一框架

<!-- 在pom.xml中添加Spring AI依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>0.8.0</version>
</dependency>

<!-- 如果需要向量存储 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-pinecone-store-spring-boot-starter</artifactId>
    <version>0.8.0</version>
</dependency>

<!-- 基本Spring Boot依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

# Deepseek配置
spring.ai.openai.api-key=your-api-key
spring.ai.openai.chat.model=gpt-3.5-turbo
spring.ai.openai.chat.temperature=0.7

# 可选：向量存储配置（使用Pinecone时需要）
# spring.ai.pinecone.api-key=your-pinecone-api-key
# spring.ai.pinecone.environment=your-pinecone-environment
# spring.ai.pinecone.index=your-index-name

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class SpringCloudAiDemoApplication {

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

    @RestController
    static class ChatController {

        private final ChatClient chatClient;

        public ChatController(ChatClient chatClient) {
            this.chatClient = chatClient;
        }

        @GetMapping("/chat")
        public String chat(@RequestParam String message) {
            return chatClient.call(message);
        }
    }
}

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import reactor.core.publisher.Flux;
import java.io.IOException;
import java.util.concurrent.CompletableFuture;

@RestController
@RequestMapping("/stream")
public class StreamingController {
    
    private final ChatClient chatClient;
    
    public StreamingController(ChatClient chatClient) {
        this.chatClient = chatClient;
    }
    
    @GetMapping(value = "/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public SseEmitter streamChat(@RequestParam String message) {
        SseEmitter emitter = new SseEmitter();
        
        // 异步处理流式响应
        CompletableFuture.runAsync(() -> {
            try {
                // 获取流式响应
                chatClient.stream(message).subscribe(
                    chunk -> {
                        try {
                            emitter.send(SseEmitter.event().data(chunk));
                        } catch (IOException e) {
                            emitter.completeWithError(e);
                        }
                    },
                    error -> emitter.completeWithError(error),
                    () -> emitter.complete()
                );
            } catch (Exception e) {
                emitter.completeWithError(e);
            }
        });
        
        return emitter;
    }
}

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class RagService {
    
    private final ChatClient chatClient;
    private final VectorStore vectorStore;
    
    public RagService(ChatClient chatClient, VectorStore vectorStore) {
        this.chatClient = chatClient;
        this.vectorStore = vectorStore;
    }
    
    public String answerWithRag(String question) {
        // 搜索相关文档
        List<Document> relevantDocs = vectorStore.similaritySearch(question, 3);
        
        // 构建包含相关文档的提示
        StringBuilder promptBuilder = new StringBuilder();
        promptBuilder.append("根据以下信息回答问题：\n");
        
        for (Document doc : relevantDocs) {
            promptBuilder.append("- ").append(doc.getContent()).append("\n");
        }
        
        promptBuilder.append("\n问题：").append(question);
        promptBuilder.append("\n请基于提供的信息回答，不要添加额外信息。");
        
        // 获取AI响应
        return chatClient.call(promptBuilder.toString());
    }
}

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.HashMap;

// 自定义模型路由器类
class ModelRouter {
    private final Map<String, ChatClient> clientMap = new HashMap<>();
    private ChatClient defaultModel;
    
    public void addRule(String key, ChatClient client) {
        clientMap.put(key, client);
    }
    
    public void setDefaultModel(ChatClient client) {
        this.defaultModel = client;
    }
    
    public ChatClient getClient(String type) {
        return clientMap.getOrDefault(type, defaultModel);
    }
}

@Configuration
public class ModelRoutingConfig {
    
    @Bean
    public ModelRouter modelRouter(ChatClient chatClient) {
        // 注意：在实际项目中，您可能需要配置多个不同的ChatClient实例
        ModelRouter router = new ModelRouter();
        
        // 配置路由规则 - 这里为简化示例，两个规则都使用同一个客户端
        router.addRule("simple-query", chatClient);
        router.addRule("complex-query", chatClient);
        
        // 设置默认模型
        router.setDefaultModel(chatClient);
        
        return router;
    }
}

@Service
public class RoutingService {
    
    private final ModelRouter modelRouter;
    
    public RoutingService(ModelRouter modelRouter) {
        this.modelRouter = modelRouter;
    }
    
    public String routeRequest(String type, String message) {
        // 根据请求类型选择合适的模型
        ChatClient client = modelRouter.getClient(type);
        return client.call(message);
    }
}