1
package com.aippt.llm;
2

3
import dev.langchain4j.model.chat.ChatModel;
4
import dev.langchain4j.model.chat.request.ResponseFormat;
5
import dev.langchain4j.model.openai.OpenAiChatModel;
6

7
@Component
8
public class StructuredChatClient {
9

10
    private final ChatModel model;
11

12
    public StructuredChatClient(AppProperties properties) {
13
        // 构建底层的大模型客户端
14
        OpenAiChatModel.OpenAiChatModelBuilder builder = OpenAiChatModel.builder()
15
                .apiKey(properties.getLlmApiKey())
16
                .baseUrl(properties.getLlmBaseUrl())     // 对接 DeepSeek 开放平台 API 地址
17
                .modelName(properties.getLlmModel())     // 当前 .env 配置 deepseek-flash
18
                .timeout(Duration.ofMillis(60000))       // 大模型推理慢，超时设为 60s
19
                .maxRetries(2)                           // 网络抖动自动重试 2 次
20
                // 核心关键点：强制大模型以合法 JSON 格式输出，杜绝 markdown 废话
21
                .responseFormat(ResponseFormat.JSON);
22

23
        // 如果开启了思考模式（如 DeepSeek R1），注入深度思考参数
24
        if (properties.isLlmThinkingEnabled()) {
25
            builder.defaultRequestParameters(OpenAiChatRequestParameters.builder()
26
                    .customParameters(Map.of("thinking", Map.of("type", "enabled")))
27
                    .build());
28
        }
29
        this.model = builder.build();
30
    }
31
}

1
package com.aippt.deck;
2

3
import org.bsc.langgraph4j.StateGraph;
4
import org.bsc.langgraph4j.CompiledGraph;
5
import static org.bsc.langgraph4j.StateGraph.START;
6
import static org.bsc.langgraph4j.StateGraph.END;
7

8
@Component
9
public class SlideWorkflow {
10

11
    private static final int MAX_REPAIR_ROUNDS = 1; // 关键：最多允许自纠 1 次，防死循环并控 Token 成本
12
    private final CompiledGraph<SlideState> graph;
13

14
    public SlideWorkflow(SlideGenerator generator, SharedCatalog catalog, FlexPresets presets) {
15
        // 构建状态图
16
        this.graph = new StateGraph<>(SlideState.SCHEMA, SlideState::new)
17
                // 1. prepare 节点：组装提示词上下文，重置 repairs 计数为 0
18
                .addNode("prepare", node_async(state -> Map.of(
19
                        "prepared", SlideGenerator.prepare(state.input()),
20
                        "repairs", 0
21
                )))
22
                // 2. generate 节点：调用大模型生成单页草稿 draft
23
                .addNode("generate", node_async(state -> Map.of("draft", generator.generate(state.prepared()))))
24
                // 3. check 节点：执行阶段一结构化强规则质检，产出 issues 问题列表
25
                .addNode("check", node_async(this::check))
26
                // 4. repair 节点：将质检发现的问题转换为错误提示，递增 repairs 次数
27
                .addNode("repair", node_async(this::repair))
28

29
                // 编排边关系：START -> prepare -> generate -> check
30
                .addEdge(START, "prepare")
31
                .addEdge("prepare", "generate")
32
                .addEdge("generate", "check")
33

34
                // 核心条件边：check 完成后走 route 路由函数，决定是进 repair 还是直接结束 END
35
                .addConditionalEdges("check", edge_async(this::route), Map.of("repair", "repair", END, END))
36

37
                // repair 修复节点直接连回 generate 节点，重新生成
38
                .addEdge("repair", "generate")
39
                .compile();
40
    }
41

42
    // 条件边路由逻辑
43
    private String route(SlideState state) {
44
        // 达到最大重试次数，强制退出，不再自纠
45
        if (state.repairs() >= MAX_REPAIR_ROUNDS) {
46
            return END;
47
        }
48
        // 如果质检发现了结构化破坏或字数严重超阈值，进入修复环
49
        if (state.issues().stream().anyMatch(SlideValidation::isRepairWorthy)) {
50
            return "repair";
51
        }
52
        return END;
53
    }
54

55
    // repair 节点逻辑：把具体错误信息注入下一次请求的 input 中
56
    private Map<String, Object> repair(SlideState state) {
57
        List<String> messages = state.issues().stream()
58
                .filter(SlideValidation::isRepairWorthy)
59
                .map(issue -> "槽位 " + issue.slotId() + "：" + issue.message())
60
                .toList();
61
        // 将具体的错误描述（比如“卡片 2 文本字数超出上限”）追加到下一次的 input 参数里
62
        return Map.of(
63
                "prepared", state.prepared().withIssues(messages),
64
                "repairs", state.repairs() + 1
65
        );
66
    }
67
}

1
package com.aippt.shared.redis;
2

3
@Component
4
public class JobQueue {
5
    public static final String QUEUE_KEY = "aippt:jobs";
6
    private final StringRedisTemplate redis;
7

8
    // API 层：将任务 JSON 字符串从左侧推入队列
9
    public void enqueue(String payload) {
10
        redis.opsForList().leftPush(QUEUE_KEY, payload);
11
    }
12

13
    // Worker 层：阻塞拉取，超时 5 秒（避免空轮询空转 CPU）
14
    public String blockingPop(Duration timeout) {
15
        return redis.opsForList().rightPop(QUEUE_KEY, timeout);
16
    }
17
}

1
package com.aippt.deck;
2

3
@Service
4
public class DeckGenerationService {
5

6
    public void handle(JobPayload job) {
7
        Context context = loadContext(job.projectId());
8

9
        AtomicBoolean cancelled = new AtomicBoolean(false);
10
        // 受控并发：Semaphore 默认 3 个许可（slideConcurrency 可配），压住对下游大模型的并发压力
11
        Semaphore semaphore = new Semaphore(Math.max(1, properties.getSlideConcurrency()));
12
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {  // 虚拟线程：一页一任务，轻量廉价
13
            List<Future<?>> futures = new ArrayList<>();
14
            for (UUID slideId : job.slideIds()) {
15
                futures.add(executor.submit(() -> {
16
                    semaphore.acquireUninterruptibly();            // 拿不到许可就等，并发上限死死压住
17
                    try {
18
                        // 1. 软取消检查：用户中途退出/取消 → 置标记，后续页面任务直接 return 跳过，节约 Token
19
                        if (cancelled.get() || decks.isCancelled(job.projectId())) {
20
                            cancelled.set(true);
21
                            return;
22
                        }
23
                        // 2. 调用 SlideWorkflow 状态图执行单页生成与自纠
24
                        generateOne(job.projectId(), slideId, context);
25
                    } finally {
26
                        semaphore.release();
27
                    }
28
                }));
29
            }
30
            for (Future<?> future : futures) { future.get(); }     // 等全部页面完成
31
        }
32
        finish(job.projectId(), cancelled.get());                  // 收尾：广播 completed / cancelled 事件
33
    }
34

35
    // generateOne 内部：publish("slide_started") → workflow.run()（状态图）→ 落库 → publish("slide_completed")
36
    // 每页完成即经 DeckEvents → EventStreamService（Redis Pub/Sub + 快照）触发 SSE 推流，“生成一页看一页”
37
}

1
package com.aippt.shared.redis;
2

3
@Component
4
public class EventStreamService {
5
    private final StringRedisTemplate redis;
6

7
    // 发布页面完成事件并记录快照
8
    public void publish(String name, UUID key, String json) {
9
        // 1. 存入 Redis Key（带 1 小时 TTL），充当快照，防止前端网络重连后丢进度
10
        redis.opsForValue().set(name + ":" + key + ":snapshot", json, Duration.ofHours(1));
11
        // 2. 利用 Redis Pub/Sub 广播事件，触发 SSE 推流给客户端浏览器
12
        redis.convertAndSend(name + ":" + key + ":events", json);
13
    }
14
}

1
package com.aippt.deck;
2

3
import dev.langchain4j.agent.tool.ToolSpecification;
4
import dev.langchain4j.model.chat.request.json.JsonObjectSchema;
5

6
public final class SlideEditTools {
7

8
    // 组装暴露给大模型的工具列表
9
    public List<ToolSpecification> specifications() {
10
        List<ToolSpecification> tools = new ArrayList<>();
11

12
        // 工具 1：替换文本工具
13
        tools.add(spec("replace_text", "替换一个 text 块的全文。",
14
                JsonObjectSchema.builder()
15
                        .addStringProperty("block_id")    // 目标块 ID
16
                        .addStringProperty("text")        // 替换后的文本内容
17
                        .required("block_id", "text")
18
                        .build()));
19

20
        // 工具 2：替换要点列表工具
21
        tools.add(spec("replace_bullets", "替换一个 bullets 块的全部要点。",
22
                JsonObjectSchema.builder()
23
                        .addStringProperty("block_id")
24
                        .addProperty("items", JsonArraySchema.builder().items(new JsonStringSchema()).build())
25
                        .required("block_id", "items")
26
                        .build()));
27

28
        // 工具 3：替换 KPI 指标数值工具
29
        tools.add(spec("replace_kpi", "替换一个 kpi 块的数值、标签和备注。",
30
                JsonObjectSchema.builder()
31
                        .addStringProperty("block_id")
32
                        .addStringProperty("value")       // 指标数值（如 5000万）
33
                        .addStringProperty("label")       // 指标标签
34
                        .required("block_id", "value")
35
                        .build()));
36

37
        // 工具 4-6：replace_table / replace_cards / replace_callout（表格、卡片组、标注块，定义方式与上面同构）
38
        // —— 至此 6 个“常驻工具”，任何布局的页面都会注册
39

40
        // 工具 7-9：仅 flex 灵活布局页（layoutMode == "flex" 且块树非空）额外注册
41
        if ("flex".equals(layoutMode) && tree != null) {
42
            tools.add(spec("add_block", "在灵活布局页新增一个块。", ...));       // 新增块
43
            tools.add(spec("delete_block", "删除一个块。", ...));                 // 删除块
44
            tools.add(spec("change_type", "修改一个块的类型。", ...));            // 改块类型
45
        }
46
        // 合计：固定布局页 6 个工具，flex 灵活布局页 9 个 —— 全项目 ToolSpecification 共 9 个
47
        return tools;
48
    }
49
}

1
// 编辑保存前进行 revision 乐观锁校验
2
if (slide.getRevision() != clientRevision) {
3
    throw new ApiException("页面已被其他端修改，请刷新后重试");
4
}
5
slide.setRevision(slide.getRevision() + 1); // 递增版本号落库

1
package com.aippt.render;
2

3
import org.apache.poi.xslf.usermodel.*;
4
import java.awt.geom.Rectangle2D;
5

6
@Component
7
public class PptxRenderer {
8

9
    public byte[] render(SlideContent content, Theme theme) {
10
        try (XMLSlideShow ppt = new XMLSlideShow()) {
11
            // 设置 16:9 宽屏画布尺寸（960 x 540 磅）
12
            ppt.setPageSize(new Dimension(960, 540));
13
            XSLFSlide slide = ppt.createSlide();
14

15
            // 遍历内容块，将模型输出的结构化数据映射为原生文本框
16
            for (Map<String, Object> block : content.blocks()) {
17
                XSLFTextBox textBox = slide.createTextBox();
18
                // 几何映射：将前端相对坐标映射为绝对像素坐标 (x, y, width, height)
19
                textBox.setAnchor(new Rectangle2D.Double(blockX, blockY, blockW, blockH));
20

21
                // 写入文字内容并注入主题字体与颜色
22
                XSLFTextParagraph p = textBox.addNewTextParagraph();
23
                XSLFTextRun r = p.addNewTextRun();
24
                r.setText(blockText);
25
                r.setFontColor(theme.primaryColor());
26
            }
27

28
            ByteArrayOutputStream out = new ByteArrayOutputStream();
29
            ppt.write(out);
30
            return out.toByteArray();
31
        }
32
    }
33
}

1
package com.aippt.render;
2

3
public final class PptxVerify {
4

5
    // 导出前对二进制字节流执行 XML 回读与物理几何测量
6
    public static VerifyReport verify(byte[] data, List<SlideContent> slides) {
7
        try (XMLSlideShow ppt = new XMLSlideShow(new ByteArrayInputStream(data))) {
8
            List<VerifyIssue> issues = new ArrayList<>();
9
            // 1. 检查物理页数与大纲预期页数是否严格一致（issue 类型 "page_count"）
10
            if (ppt.getSlides().size() != slides.size()) {
11
                issues.add(new VerifyIssue("page_count", ...));
12
            }
13
            // 2. 几何边界容差检查：遍历每个 Shape，校验是否超出画布安全边缘（issue 类型 "bounds"）。
14
            //    宽高动态取自 ppt.getPageSize()，容差 BOUNDS_TOLERANCE_PT = 0.5 磅，含负方向越界检查
15
            for (XSLFSlide slide : ppt.getSlides()) {
16
                for (XSLFShape shape : slide.getShapes()) {
17
                    Rectangle2D bounds = shape.getAnchor();
18
                    double slideW = ppt.getPageSize().getWidth(), slideH = ppt.getPageSize().getHeight();
19
                    if (bounds.getMaxX() > slideW + 0.5 || bounds.getMaxY() > slideH + 0.5
20
                            || bounds.getMinX() < -0.5 || bounds.getMinY() < -0.5) {
21
                        issues.add(new VerifyIssue("bounds", "元素越界", ...));
22
                    }
23
                }
24
            }
25
            // 3. 其余检查项（合计 9 类 issue，必须能数全）：
26
            //    page_count       页数与大纲预期严格一致
27
            //    canvas_size      画布尺寸（16:9 基准）
28
            //    full_page_picture 拦截"整页一张图冒充正文"（保证原生可编辑的核心证据）
29
            //    bounds           元素物理越界（如上）
30
            //    native_table     校验导出的是真原生表格对象而非图片
31
            //    native_chart     校验原生图表对象
32
            //    text_frame       文本框存在性与文字内容完整性
33
            //    content_integrity 内容完整性（关键字段非空）
34
            //    open             文件可正常打开（XML 回读本身）
35
            return new VerifyReport(issues.isEmpty(), issues, ...);
36
        }
37
    }
38
}

1
【入库阶段】
2
用户输入长文本/资料 → 文本清洗
3
→ 文本切片（按语义段落拆分，每片控制在 token 上限内）
4
→ Embedding 向量化（将文本映射成高维数字向量）
5
→ 存入向量数据库
6

7
【查询阶段】
8
用户输入主题 → 主题文本 Embedding 向量化
9
→ 在向量库中做相似度检索（余弦相似度），取 Top-K 最相关片段
10
→ 将检索到的片段拼入 System Prompt
11
→ 大模型基于真实资料生成大纲/内容