// 1. 删除缓存
redis.del(key);
// 2. 更新数据库
db.update(data);
// 3. 延迟一段时间再次删除缓存
Thread.sleep(500);
redis.del(key);

RLock lock = redisson.getLock("myLock");
try {
    // 尝试加锁，最多等待10秒，锁30秒后自动释放
    boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
    if (locked) {
        // 执行业务逻辑
    }
} finally {
    lock.unlock();
}

redisTemplate.executePipelined(new RedisCallback<Object>() {
    @Override
    public Object doInRedis(RedisConnection connection) {
        for (int i = 0; i < 10000; i++) {
            connection.set(("key" + i).getBytes(), ("value" + i).getBytes());
        }
        return null;
    }
});

// 使用ZSet记录每次请求的时间戳
ZADD rate_limit:user:123 current_timestamp current_timestamp
// 移除窗口外的记录
ZREMRANGEBYSCORE rate_limit:user:123 0 (current_timestamp - 60)
// 统计当前窗口内的请求数
ZCARD rate_limit:user:123
// 设置过期时间
EXPIRE rate_limit:user:123 60

// 依赖
// spring-session-data-redis

// 配置
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800)
public class SessionConfig {
    @Bean
    public LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory();
    }
}

// 添加位置
redisTemplate.opsForGeo().add("locations", 
    new Point(116.3974, 39.9092), "user1");

// 查询附近
GeoResults<RedisGeoCommands.GeoLocation<String>> results = 
    redisTemplate.opsForGeo().radius("locations",
        new Circle(new Point(116.3974, 39.9092), 
                   new Distance(5, Metrics.KILOMETERS)),
        RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
            .includeDistance().includeCoordinates().limit(10));

@Service
public class ChatService {
    
    private final ChatClient chatClient;
    
    public ChatService(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }
    
    // 基础对话
    public String chat(String message) {
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
    
    // 带系统提示的对话
    public String chatWithSystem(String message) {
        return chatClient.prompt()
                .system("你是一位Java专家")
                .user(message)
                .call()
                .content();
    }
    
    // 流式响应
    public Flux<String> streamChat(String message) {
        return chatClient.prompt()
                .user(message)
                .stream()
                .content();
    }
    
    // 结构化输出
    public MovieRecommendation getRecommendation(String genre) {
        return chatClient.prompt()
                .user("推荐一部" + genre + "电影")
                .call()
                .entity(MovieRecommendation.class);
    }
}

@Service
public class RAGService {
    
    private final ChatClient chatClient;
    private final VectorStore vectorStore;
        
    简洁版 RAG 实现
    public String ragQuery(String query) {
        // QuestionAnswerAdvisor 会自动完成：
        // 1. 使用 vectorStore 进行相似性检索
        // 2. 将检索到的文档内容注入到系统提示词中
        // 3. 调用 LLM 生成回答
        return chatClient.prompt()
                .user(query)
                .advisors(new QuestionAnswerAdvisor(vectorStore))
                .call()
                .content();
    }

    自定义参数
    public String ragQuery(String query) {
        // 自定义检索参数：TopK=5，相似度阈值=0.7
        return chatClient.prompt()
                .user(query)
                .advisors(new QuestionAnswerAdvisor(
                    vectorStore, 
                    SearchRequest.query(query).withTopK(5).withSimilarityThreshold(0.7)
                ))
                .call()
                .content();
    }

    自定义提示词模板
    public String ragQuery(String query) {
        // 自定义系统提示词模板
        String systemPromptTemplate = """
            你是一个专业的AI助手，请严格基于以下上下文信息回答用户的问题。
            如果上下文中没有相关信息，请直接说"抱歉，我无法从提供的资料中找到答案"。
            
            【上下文信息】
            {question_answer_context}
            
            【回答要求】
            1. 回答要准确、简洁
            2. 不要编造上下文之外的信息
            """;
        
        return chatClient.prompt()
                .user(query)
                .advisors(new QuestionAnswerAdvisor(vectorStore, systemPromptTemplate))
                .call()
                .content();
    }
}

public class CustomAdvisor implements CallAdvisor {
    
    @Override
    public AdvisedRequest adviseCall(AdvisedRequest request) {
        // 在请求前修改提示词
        Map<String, Object> context = new HashMap<>(request.context());
        context.put("timestamp", System.currentTimeMillis());
        
        return AdvisedRequest.from(request)
                .withContext(context)
                .build();
    }
    
    @Override
    public int getOrder() {
        return 0; // 执行顺序
    }
}

@Service
public class OpenAIService {
    
    @Autowired
    private OpenAiChatClient chatClient;
    
    public String generateCode(String requirement) {
        return chatClient.call("生成Java代码: " + requirement);
    }
}

@Component
public class ModelRouter {
    
    private final Map<String, ChatClient> modelRegistry = new HashMap<>();
    
    public ModelRouter(
            OpenAiChatClient openAiClient,
            OllamaChatClient ollamaClient,
            ZhiPuAiChatClient zhipuClient) {
        modelRegistry.put("gpt-4", openAiClient);
        modelRegistry.put("llama3", ollamaClient);
        modelRegistry.put("glm-4", zhipuClient);
    }
    
    public String chat(String modelName, String message) {
        ChatClient client = modelRegistry.get(modelName);
        if (client == null) {
            throw new IllegalArgumentException("Unknown model: " + modelName);
        }
        return client.call(message);
    }
    
    // 智能路由：根据任务复杂度选择模型
    public String smartChat(String message) {
        // 简单任务使用轻量级模型
        if (isSimpleTask(message)) {
            return modelRegistry.get("llama3").call(message);
        }
        // 复杂任务使用大模型
        return modelRegistry.get("gpt-4").call(message);
    }
}

@Service
public class DocumentService {
    
    @Autowired
    private VectorStore vectorStore;
    
    @Autowired
    private EmbeddingClient embeddingClient;
    
    // 添加文档
    public void addDocument(String content) {
        Document doc = new Document(content);
        vectorStore.add(List.of(doc));
    }
    
    // 相似度搜索
    public List<Document> search(String query, int topK) {
        return vectorStore.similaritySearch(
            SearchRequest.query(query).withTopK(topK)
        );
    }
}

@Bean
public VectorStore vectorStore(EmbeddingClient embeddingClient) {
    return PgVectorStore.builder(embeddingClient)
            .indexType(PgVectorStore.PgIndexType.HNSW)
            .distanceType(PgVectorStore.PgDistanceType.COSINE_DISTANCE)
            .dimensions(1536)
            .build();
}

public List<String> overlappingChunks(String text, int chunkSize, int overlap) {
    List<String> chunks = new ArrayList<>();
    int step = chunkSize - overlap;
    
    for (int i = 0; i < text.length(); i += step) {
        int end = Math.min(i + chunkSize, text.length());
        chunks.add(text.substring(i, end));
        if (end == text.length()) break;
    }
    return chunks;
}

@RestController
public class ChatController {
    
    @Autowired
    private ChatClient chatClient;
    
    @GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<String>> streamChat(@RequestParam String message) {
        return chatClient.prompt()
                .user(message)
                .stream()
                .content()
                .map(content -> ServerSentEvent.builder(content).build());
    }
}

@Component
public class RAGEvaluator {
    
    public double calculateRecallAtK(List<Document> retrieved, 
                                      Set<String> relevantDocs, int k) {
        long relevantRetrieved = retrieved.stream()
            .limit(k)
            .filter(doc -> relevantDocs.contains(doc.getId()))
            .count();
        return (double) relevantRetrieved / relevantDocs.size();
    }
    
    public double calculateMRR(List<List<Document>> queriesResults,
                                List<Set<String>> relevantDocsList) {
        double sumRR = 0;
        for (int i = 0; i < queriesResults.size(); i++) {
            List<Document> results = queriesResults.get(i);
            Set<String> relevant = relevantDocsList.get(i);
            
            for (int rank = 0; rank < results.size(); rank++) {
                if (relevant.contains(results.get(rank).getId())) {
                    sumRR += 1.0 / (rank + 1);
                    break;
                }
            }
        }
        return sumRR / queriesResults.size();
    }
}

@Component
public class AIClientWrapper {
    
    private final ChatClient chatClient;
    private final RateLimiter rateLimiter;
    private final CircuitBreaker circuitBreaker;
    
    public AIClientWrapper(ChatClient chatClient) {
        this.chatClient = chatClient;
        // 令牌桶限流：每秒10个请求
        this.rateLimiter = RateLimiter.create(10.0);
        // 熔断器配置
        this.circuitBreaker = CircuitBreaker.ofDefaults("ai-client");
    }
    
    public String safeCall(String message) {
        // 限流检查
        if (!rateLimiter.tryAcquire()) {
            throw new RateLimitException("请求过于频繁，请稍后重试");
        }
        
        // 熔断保护
        return circuitBreaker.executeSupplier(() -> {
            try {
                return chatClient.call(message);
            } catch (Exception e) {
                throw new AIClientException("AI服务调用失败", e);
            }
        });
    }
}

@Service
public class MultiTenantKnowledgeService {
    
    @Autowired
    private VectorStore vectorStore;
    
    // 添加文档（带租户隔离）
    public void addDocument(String tenantId, String content) {
        Document doc = new Document(content);
        // 添加租户ID到元数据
        doc.getMetadata().put("tenant_id", tenantId);
        vectorStore.add(List.of(doc));
    }
    
    // 租户隔离的搜索
    public List<Document> search(String tenantId, String query, int topK) {
        // 使用filter表达式实现租户隔离
        String filterExpr = String.format("tenant_id == '%s'", tenantId);
        
        return vectorStore.similaritySearch(
            SearchRequest.query(query)
                .withTopK(topK)
                .withFilterExpression(filterExpr)
        );
    }
}

@Service
public class ChatMemoryService {
    
    @Autowired
    private ChatClient chatClient;
    
    // 使用Redis存储对话历史
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    private static final int MAX_HISTORY = 10;
    private static final String KEY_PREFIX = "chat:history:";
    
    public String chatWithMemory(String sessionId, String message) {
        String key = KEY_PREFIX + sessionId;
        
        // 获取历史对话
        List<String> history = redisTemplate.opsForList().range(key, 0, -1);
        
        // 构建带上下文的提示词
        Prompt prompt = buildPromptWithHistory(history, message);
        
        // 调用模型
        String response = chatClient.call(prompt);
        
        // 保存对话记录
        redisTemplate.opsForList().rightPushAll(key, 
            "User: " + message, 
            "AI: " + response
        );
        
        // 限制历史长度
        redisTemplate.opsForList().trim(key, -MAX_HISTORY * 2, -1);
        
        return response;
    }
    
    private Prompt buildPromptWithHistory(List<String> history, String message) {
        StringBuilder context = new StringBuilder();
        if (history != null) {
            history.forEach(h -> context.append(h).append("\n"));
        }
        context.append("User: ").append(message).append("\nAI:");
        
        return new Prompt(new UserMessage(context.toString()));
    }
}

@Bean
public ChatClient chatClient(ChatClient.Builder builder) {
    return builder
        .defaultAdvisors(
            new MessageChatMemoryAdvisor(new InMemoryChatMemory()),
            new SimpleLoggerAdvisor()
        )
        .build();
}

@Component
public class ContentSafetyFilter {
    
    private final List<String> sensitiveWords = Arrays.asList(
        "敏感词1", "敏感词2"
    );
    
    // 输入过滤
    public boolean validateInput(String input) {
        if (input == null || input.length() > 4000) {
            return false;
        }
        return !containsSensitiveWords(input);
    }
    
    // 输出过滤
    public String filterOutput(String output) {
        // 脱敏处理
        String filtered = maskSensitiveInfo(output);
        // 添加免责声明
        return addDisclaimer(filtered);
    }
    
    private boolean containsSensitiveWords(String text) {
        return sensitiveWords.stream().anyMatch(text::contains);
    }
    
    private String maskSensitiveInfo(String text) {
        // 身份证号脱敏
        return text.replaceAll("\\d{17}[\\dXx]", "***身份证已脱敏***")
                   .replaceAll("1[3-9]\\d{9}", "***手机号已脱敏***");
    }
    
    private String addDisclaimer(String text) {
        return text + "\n\n【免责声明：以上内容由AI生成，仅供参考】";
    }
}

@Configuration
public class FunctionConfiguration {
    
    @Bean
    @Description("获取指定城市的天气信息")
    public Function<WeatherRequest, WeatherResponse> weatherFunction() {
        return request -> {
            // 调用天气API
            return weatherService.getWeather(request.city(), request.date());
        };
    }
    
    @Bean
    @Description("查询订单信息")
    public Function<OrderQueryRequest, OrderResponse> orderQueryFunction() {
        return request -> orderService.queryOrder(request.orderId());
    }
}

// 请求/响应定义
public record WeatherRequest(String city, String date) {}
public record WeatherResponse(String city, String temperature, String condition) {}

@Service
public class AssistantService {
    
    @Autowired
    private ChatClient chatClient;
    
    public String chat(String message) {
        return chatClient.prompt()
                .user(message)
                .functions("weatherFunction", "orderQueryFunction")
                .call()
                .content();
    }
}

@Component
public class SimpleAgent {
    
    @Autowired
    private ChatClient chatClient;
    
    private final List<Tool> tools = new ArrayList<>();
    
    public String execute(String goal) {
        StringBuilder memory = new StringBuilder();
        int maxSteps = 5;
        
        for (int i = 0; i < maxSteps; i++) {
            // 规划下一步
            String plan = chatClient.call(buildPlanningPrompt(goal, memory.toString()));
            
            // 解析计划，决定是调用工具还是返回结果
            Action action = parseAction(plan);
            
            if (action.isComplete()) {
                return action.getResult();
            }
            
            // 执行工具调用
            ToolResult result = executeTool(action.getToolName(), action.getParams());
            memory.append("Step ").append(i + 1)
                  .append(": ").append(result).append("\n");
        }
        
        return "达到最大执行步数，任务未完成";
    }
}

@Service
public class MultimodalService {
    
    @Autowired
    private OpenAiChatClient chatClient;
    
    public String analyzeImage(String imageUrl, String question) {
        // 构建多模态消息
        UserMessage message = new UserMessage(
            question,
            List.of(new Media(MimeTypeUtils.IMAGE_PNG, imageUrl))
        );
        
        return chatClient.call(new Prompt(message));
    }
    
    public String analyzeLocalImage(MultipartFile file, String question) {
        try {
            // 将图片转为Base64
            String base64Image = Base64.getEncoder().encodeToString(file.getBytes());
            String dataUri = "data:image/png;base64," + base64Image;
            
            return analyzeImage(dataUri, question);
        } catch (IOException e) {
            throw new RuntimeException("图片处理失败", e);
        }
    }
}

// 通过Ollama加载本地微调模型
ollama run my-custom-embedding:latest

@Service
public class AITestService {
    
    private final ChatClient modelA;  // GPT-4
    private final ChatClient modelB;  // Claude
    
    @Autowired
    private ExperimentTracker tracker;
    
    public String chat(String userId, String message) {
        // 根据用户ID分流
        String variant = assignVariant(userId);
        
        long startTime = System.currentTimeMillis();
        String response;
        boolean success = true;
        
        try {
            if ("A".equals(variant)) {
                response = modelA.call(message);
            } else {
                response = modelB.call(message);
            }
        } catch (Exception e) {
            response = "服务异常";
            success = false;
        }
        
        // 记录实验数据
        long latency = System.currentTimeMillis() - startTime;
        tracker.record(userId, variant, latency, success, response.length());
        
        return response;
    }
    
    private String assignVariant(String userId) {
        // 一致性哈希，确保同一用户始终分配到同一组
        int hash = userId.hashCode();
        return hash % 2 == 0 ? "A" : "B";
    }
}

@Component
public class AIMetricsCollector {
    
    private final MeterRegistry meterRegistry;
    
    public void recordMetrics(String model, long latency, int inputTokens, 
                              int outputTokens, boolean success) {
        // 延迟指标
        meterRegistry.timer("ai.request.latency", "model", model)
                     .record(latency, TimeUnit.MILLISECONDS);
        
        // Token使用量
        meterRegistry.counter("ai.tokens.input", "model", model)
                     .increment(inputTokens);
        meterRegistry.counter("ai.tokens.output", "model", model)
                     .increment(outputTokens);
        
        // 成功率
        meterRegistry.counter("ai.request.total", "model", model).increment();
        if (success) {
            meterRegistry.counter("ai.request.success", "model", model).increment();
        }
        
        // 估算成本（以OpenAI GPT-4为例）
        double cost = (inputTokens * 0.03 + outputTokens * 0.06) / 1000;
        meterRegistry.counter("ai.cost", "model", model).increment(cost);
    }
}