// 1. 定义模板 (就像定义 View)
String template = "Tell me a {adjective} joke about {content}.";

// 2. 准备数据 (就像 Model)
Map<String, Object> model = new HashMap<>();
model.put("adjective", "funny"); // 搞笑的
model.put("content", "Spring AI"); // 关于 Spring AI

// 3. 渲染 (Render)
// Spring AI 使用 StringTemplate 把数据填进去
String finalPrompt = templateEngine.render(template, model);

// 4. 结果
// finalPrompt 变成了: "Tell me a funny joke about Spring AI."
// 然后这个字符串才会被发送给 AI 模型

package com.healerjean.proj.strata.infra.config;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.ollama.OllamaChatModel;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * ChatClientConfig
 *
 * @author zhangyujin
 * @date 2025/11/18
 */

@Configuration
public class ChatClientConfig {

    /**
     * 配置 Ollama ChatClient Bean
     */
    @Bean
    public ChatClient ollamaChatClient(OllamaChatModel ollamaChatModel) {
        return ChatClient.builder(ollamaChatModel)
                // 全局系统提示（角色：专业Java技术助手）
                .defaultSystem("""
                        你是专业的Java后端技术助手，精通Spring Boot、Spring AI、Ollama技术栈。
                        回答要求：简洁、精准、可运行，提供完整代码案例，避免冗余解释。
                        """)
                // 全局默认参数（可覆盖）
                .defaultOptions(ollamaChatModel.getDefaultOptions())
                .build();
    }


}

package com.healerjean.proj.strata.web.controller;

import jakarta.annotation.Resource;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.ollama.OllamaChatModel;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * Llama3Controller
 *
 * @author zhangyujin
 * @date 2025/11/18
 */

@RestController
@RequestMapping("/ai")
public class ChatController {

    @Resource
    private ChatClient chatClient;


    // 1. 基础对话
    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg", defaultValue = "你好，请介绍一下你自己") String msg) {
        return chatClient.prompt()
                .user(msg)
                .call()
                .content();
    }


}

    /**
     * 配置 Ollama ChatClient Bean
     */
    @Bean
    public ChatClient ollamaChatClient(OllamaChatModel ollamaChatModel) {
        return ChatClient.builder(ollamaChatModel)
                // 全局系统提示（角色：专业Java技术助手）
                .defaultSystem("""
                    你是专业的Java后端技术助手，精通Spring Boot、Spring AI、Ollama技术栈。
                    回答要求：简洁、精准、可运行，提供完整代码案例，避免冗余解释。
                    """)
                // 全局默认参数（可覆盖）
                .defaultOptions(ollamaChatModel.getDefaultOptions())
                .build();
    }

/**
 * 基础同步聊天接口
 */
@GetMapping("/sync")
public String syncChat(@RequestParam String message) {
    return chatClient.prompt()
            // 用户提问
            .user(message)
            // 同步调用
            .call()
            // 获取响应文本
            .content();
}

/**
 * 带角色设定的聊天（覆盖全局系统提示）
 */
@GetMapping("/sync/role")
public String syncChatWithRole(@RequestParam String message) {
    return chatClient.prompt()
            // 临时角色
            .system("你是幽默的段子手，用搞笑风格回答问题")
            .user(message)
            .call()
            .content();
}

/**
 * 流式聊天接口（SSE 实时响应）
 */
@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE )
public Flux<String> streamChat(@RequestParam String message) {
    return chatClient.prompt()
            .user(message)
            .stream() // 流式调用
            .content(); // 逐字返回文本流
}

/**
 * 流式+自定义参数（临时调整温度、模型）
 */
@GetMapping(value = "/stream/options", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamChatWithOptions(
        @RequestParam String message,
        @RequestParam(defaultValue = "1.0") Double temperature) {
    return chatClient.prompt()
            .user(message)
            // 临时参数：温度+最大token
            .options(ChatOptions.builder()
                    .temperature(temperature)
                    .maxTokens(2000)
                    .build())
            .stream()
            .content();
}

/**
 * 动态提示模板（占位符传参）
 */
@GetMapping("/template")
public String templateChat(
        @RequestParam String topic,
        @RequestParam(defaultValue = "中文") String language) {
    // 提示模板（占位符：{language}、{topic}）
    String promptTemplate = """
                用{language}写一段关于{topic}的技术介绍，要求：
                1. 简洁明了，300字以内
                2. 包含核心特点和使用场景
                3. 提供1个可运行的小案例
                """;
    return chatClient.prompt()
            .user(user -> user
                    // 模板文本
                    .text(promptTemplate)
                    .param("language", language)
                    .param("topic", topic))
            .call()
            .content();
}

/**
 * 结构化数据
 */
@GetMapping("/structured")
public OrderVO structuredChat(@RequestParam String orderInfo) {
    return chatClient.prompt()
            .user(u -> u
                    // 修正点：先使用 String.format 格式化字符串，再传入 text()
                    .text(String.format("请分析 '%s' 并提取关键信息。", orderInfo))
            )
            .call()
            .entity(OrderVO.class);
}     
                  
public record TechInfo(
        String name,         // 技术名称
        String description,  // 简介
        Integer difficulty,  // 难度（1-5）
        String[] keyPoints   // 核心知识点
) {}

package com.healerjean.proj.strata.web.controller;

import jakarta.annotation.Resource;
import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ConversationController
 *
 * @author zhangyujin
 * @date 2026/3/30
 */
@RestController
@RequestMapping("/ai/chat")
public class ConversationController {

    @Resource
    private  ChatClient chatClient;
    
    /**
     * 会话存储（生产环境用 Redis）
     */
    private final Map<String, List<Message>> sessionStore = new ConcurrentHashMap<>();

    
    /**
     * 多轮对话接口
     */
    @GetMapping("/conversation")
    public String conversationChat(
            @RequestParam String sessionId,
            @RequestParam String message) {
        // 获取或创建会话历史
        List<Message> messages = sessionStore.getOrDefault(sessionId, new ArrayList<>());
        
        // 添加当前用户消息
        messages.add(new UserMessage(message));

        // 调用 AI（传入完整会话历史）
        String response = chatClient.prompt()
                .messages(messages)
                .call()
                .content();

        // 保存 AI 响应到会话历史
        messages.add(new AssistantMessage(response));
        sessionStore.put(sessionId, messages);

        return response;
    }
}

/**
 * 获取完整响应
 */
@GetMapping("/metadata")
public Map<String, Object> chatWithMetadata(@RequestParam String message) {
    // 1. 获取完整响应
    ChatResponse chatResponse = chatClient.prompt()
            .user(message)
            .call()
            .chatResponse();

    // 2. 提取元数据
    ChatResponseMetadata metadata = chatResponse.getMetadata();
    Usage usage = metadata.getUsage();

    // 4. 获取内容 (安全获取)
    // getResults()：返回一个列表，因为理论上 AI 可以一次生成多个备选答案（虽然通常我们只取第一个）。
    String content = "";
    if (!chatResponse.getResults().isEmpty()) {
        content = chatResponse.getResults().get(0).getOutput().getText();
    }

    // 5. 组装返回
    return Map.of(
            "content", content,            // AI 回答内容
            "model", metadata.getModel(),  // 使用的模型
            "id", metadata.getId(),        // 会话ID
            "totalTokens", usage.getTotalTokens(),    // 总Token
            "promptTokens", usage.getPromptTokens(),  // 提问Token
            "completionTokens", usage.getCompletionTokens() // 回答Token
    );
}

public class Media {
    @Nullable
    private String id; // 媒体唯一标识，模型自动生成
    private final MimeType mimeType; // 模态类型（如IMAGE_PNG、AUDIO_MP3）
    private final Object data; // 媒体数据：Resource/URI
    private String name; // 媒体名称，建议中性命名避免提示词注入
}

// 核心构造器
public UserMessage(String textContent, Collection<Media> mediaList) {
    this(MessageType.USER, textContent, mediaList, Map.of());
}
// 流式构建器（推荐）
UserMessage.builder()
    .text("文本问题") // 文本输入
    .media(media1) // 单个媒体
    .media(media2) // 多个媒体
    .build();

/**
 * 案例：解析网络图片（URI）
 *
 * @param imageUrl 网络图片URL
 */
@GetMapping("/image/url/parse")
public String parseUrlImage(String imageUrl) {
    try {
        // 1. 构建网络图片URI资源
        UrlResource urlResource = new UrlResource(imageUrl);
        // 2. 多模态交互（自动识别图片MimeType为JPEG/PNG）
        return chatClient.prompt()
                .system("你是专业的图像解析助手，简洁描述图片核心内容")
                .user(u -> u.text("请描述这张图片的核心内容")
                        .media(MediaType.IMAGE_JPEG, urlResource)) // 适配JPEG格式
                .call()
                .content();
    } catch (Exception e) {
        return "图片解析失败：" + e.getMessage();
    }
}