示例代码

本页面提供 夜月AI应用平台 各功能模块的示例代码，帮助你快速上手开发。

工作流创建

创建简单工作流

@Service
public class WorkflowExampleService {
    
    @Autowired
    private WorkflowService workflowService;
    
    public WorkflowDefinition createSimpleWorkflow() {
        // 创建工作流定义
        WorkflowDefinition workflow = new WorkflowDefinition();
        workflow.setName("简单对话工作流");
        workflow.setDescription("一个简单的LLM对话工作流");
        
        // 添加节点
        WorkflowNode startNode = new WorkflowNode("START", "开始");
        WorkflowNode llmNode = new WorkflowNode("LLM", "AI助手");
        WorkflowNode endNode = new WorkflowNode("END", "结束");
        
        // 配置LLM节点
        llmNode.setConfig(Map.of(
            "model", "gpt-4",
            "systemPrompt", "你是一个专业的AI助手",
            "temperature", 0.7
        ));
        
        // 添加节点到工作流
        workflow.addNode(startNode);
        workflow.addNode(llmNode);
        workflow.addNode(endNode);
        
        // 连接节点
        workflow.addEdge(startNode.getId(), llmNode.getId());
        workflow.addEdge(llmNode.getId(), endNode.getId());
        
        // 保存工作流
        return workflowService.save(workflow);
    }
}

创建RAG工作流

public WorkflowDefinition createRAGWorkflow() {
    WorkflowDefinition workflow = new WorkflowDefinition();
    workflow.setName("RAG问答工作流");
    
    // 添加节点
    WorkflowNode startNode = new WorkflowNode("START", "开始");
    WorkflowNode ragNode = new WorkflowNode("KNOWLEDGE_RETRIEVAL", "知识检索");
    WorkflowNode llmNode = new WorkflowNode("LLM", "AI回答");
    WorkflowNode endNode = new WorkflowNode("END", "结束");
    
    // 配置RAG节点
    ragNode.setConfig(Map.of(
        "knowledgeBaseId", 1,
        "topK", 5,
        "similarityThreshold", 0.7
    ));
    
    // 配置LLM节点
    llmNode.setConfig(Map.of(
        "model", "gpt-4",
        "systemPrompt", "基于以下上下文回答问题：\n{{context}}",
        "temperature", 0.3
    ));
    
    // 配置输入映射
    llmNode.setRefInputs(Map.of(
        "context", "{{KNOWLEDGE_RETRIEVAL.results}}"
    ));
    
    // 添加节点和边
    workflow.addNode(startNode);
    workflow.addNode(ragNode);
    workflow.addNode(llmNode);
    workflow.addNode(endNode);
    
    workflow.addEdge(startNode.getId(), ragNode.getId());
    workflow.addEdge(ragNode.getId(), llmNode.getId());
    workflow.addEdge(llmNode.getId(), endNode.getId());
    
    return workflowService.save(workflow);
}

创建条件分支工作流

public WorkflowDefinition createConditionalWorkflow() {
    WorkflowDefinition workflow = new WorkflowDefinition();
    workflow.setName("条件分支工作流");
    
    // 添加节点
    WorkflowNode startNode = new WorkflowNode("START", "开始");
    WorkflowNode classifyNode = new WorkflowNode("LLM", "意图分类");
    WorkflowNode ifElseNode = new WorkflowNode("IF_ELSE", "条件判断");
    WorkflowNode techNode = new WorkflowNode("LLM", "技术回答");
    WorkflowNode generalNode = new WorkflowNode("LLM", "通用回答");
    WorkflowNode endNode = new WorkflowNode("END", "结束");
    
    // 配置分类节点
    classifyNode.setConfig(Map.of(
        "model", "gpt-4",
        "systemPrompt", "将用户问题分类为：技术问题、通用问题。只返回分类结果。"
    ));
    
    // 配置条件节点
    ifElseNode.setConfig(Map.of(
        "conditions", List.of(
            Map.of("field", "classify", "operator", "equals", "value", "技术问题"),
            Map.of("field", "classify", "operator", "equals", "value", "通用问题")
        )
    ));
    
    // 添加节点和边
    workflow.addNode(startNode);
    workflow.addNode(classifyNode);
    workflow.addNode(ifElseNode);
    workflow.addNode(techNode);
    workflow.addNode(generalNode);
    workflow.addNode(endNode);
    
    workflow.addEdge(startNode.getId(), classifyNode.getId());
    workflow.addEdge(classifyNode.getId(), ifElseNode.getId());
    workflow.addEdge(ifElseNode.getId(), techNode.getId(), "条件1");
    workflow.addEdge(ifElseNode.getId(), generalNode.getId(), "条件2");
    workflow.addEdge(techNode.getId(), endNode.getId());
    workflow.addEdge(generalNode.getId(), endNode.getId());
    
    return workflowService.save(workflow);
}

RAG应用

创建知识库

@Service
public class RAGExampleService {
    
    @Autowired
    private KnowledgeBaseService knowledgeBaseService;
    
    @Autowired
    private DocumentService documentService;
    
    @Autowired
    private RAGService ragService;
    
    public KnowledgeBase createKnowledgeBase() {
        // 创建知识库
        KnowledgeBase kb = new KnowledgeBase();
        kb.setName("产品文档");
        kb.setDescription("产品相关文档和FAQ");
        
        return knowledgeBaseService.save(kb);
    }
    
    public void uploadDocuments(Long kbId) throws Exception {
        // 上传单个文档
        documentService.upload(kbId, new File("product-guide.pdf"));
        
        // 批量上传文档
        List<File> files = Arrays.asList(
            new File("faq.pdf"),
            new File("api-doc.md"),
            new File("changelog.txt")
        );
        documentService.batchUpload(kbId, files);
    }
}

RAG查询

public RAGResponse queryKnowledgeBase(Long kbId, String query) {
    // 配置检索参数
    RAGConfig config = RAGConfig.builder()
        .topK(5)
        .similarityThreshold(0.7)
        .maxContextLength(4000)
        .build();
    
    // 执行查询
    return ragService.query(kbId, query, config);
}

public RAGResponse queryWithHistory(Long kbId, String query, List<ChatMessage> history) {
    // 带历史记录的查询
    return ragService.queryWithHistory(kbId, query, history);
}

流式RAG查询

public Flux<RAGChunk> queryStream(Long kbId, String query) {
    return ragService.queryStream(kbId, query)
        .doOnNext(chunk -> {
            // 处理每个chunk
            System.out.print(chunk.getContent());
        })
        .doOnComplete(() -> {
            // 查询完成
            System.out.println("\n查询完成");
        });
}

知识图谱查询

创建知识图谱

@Service
public class KGExampleService {
    
    @Autowired
    private KnowledgeGraphService kgService;
    
    @Autowired
    private EntityExtractionService entityService;
    
    @Autowired
    private RelationExtractionService relationService;
    
    public KnowledgeGraph createKnowledgeGraph() {
        KnowledgeGraph kg = new KnowledgeGraph();
        kg.setName("产品知识图谱");
        kg.setDescription("产品、技术、团队之间的关系网络");
        
        return kgService.save(kg);
    }
    
    public void buildFromDocument(Long kgId, Long documentId) {
        // 从文档构建知识图谱
        kgService.buildFromDocument(kgId, documentId);
    }
}

查询知识图谱

public KGQueryResult queryKnowledgeGraph(Long kgId, String query) {
    // 执行查询
    KGQueryResult result = kgService.query(kgId, query);
    
    // 获取实体
    List<KGEntity> entities = result.getEntities();
    entities.forEach(entity -> {
        System.out.println("实体: " + entity.getName());
        System.out.println("类型: " + entity.getType());
        System.out.println("描述: " + entity.getDescription());
    });
    
    // 获取关系
    List<KGRelation> relations = result.getRelations();
    relations.forEach(relation -> {
        System.out.println("关系: " + relation.getSourceName() 
            + " -> " + relation.getType() 
            + " -> " + relation.getTargetName());
    });
    
    return result;
}

图遍历查询

public List<KGEntity> findNeighbors(Long entityId, int hops) {
    // 查找邻居实体
    return kgService.findNeighbors(entityId, hops);
}

public List<KGRelation> findPath(Long startId, Long endId) {
    // 查找两个实体之间的路径
    return kgService.findPath(startId, endId);
}

数字人交互

创建数字人

@Service
public class HumanExampleService {
    
    @Autowired
    private DigitalHumanService humanService;
    
    @Autowired
    private TtsService ttsService;
    
    public DigitalHuman createDigitalHuman() {
        DigitalHuman human = new DigitalHuman();
        human.setName("小助手");
        human.setVoice("zh-CN-Neural");
        human.setTtsProvider("volcengine");
        human.setSpeed(1.0);
        human.setPitch(1.0);
        
        return humanService.save(human);
    }
}

语音合成

public byte[] synthesizeSpeech(Long humanId, String text) {
    // 获取数字人配置
    DigitalHuman human = humanService.findById(humanId);
    
    // 获取TTS服务
    TtsService ttsService = ttsProviderFactory.getProvider(human.getTtsProvider());
    
    // 合成语音
    return ttsService.synthesize(human.getVoice(), text);
}

public void saveAudioFile(byte[] audioData, String fileName) throws Exception {
    // 保存音频文件
    Path path = Paths.get("audio/" + fileName);
    Files.write(path, audioData);
}

流式语音合成

public Flux<byte[]> synthesizeSpeechStream(Long humanId, String text) {
    DigitalHuman human = humanService.findById(humanId);
    TtsService ttsService = ttsProviderFactory.getProvider(human.getTtsProvider());
    
    return ttsService.synthesizeStream(human.getVoice(), text);
}

AI Excel生成

生成Excel报表

@Service
public class ExcelExampleService {
    
    @Autowired
    private AiExcelService excelService;
    
    public ExcelFile generateReport(String request) {
        // 通过自然语言生成Excel
        return excelService.generate(request);
    }
    
    public ExcelFile generateFromTemplate(Long templateId, Map<String, Object> data) {
        // 使用模板生成Excel
        return excelService.generateFromTemplate(templateId, data);
    }
}

对话式生成

public ExcelChatResponse chatGenerate(String sessionId, String message) {
    // 对话式生成Excel
    return excelChatService.chat(sessionId, message);
}

完整示例：智能客服系统

@Service
public class SmartCustomerServiceExample {
    
    @Autowired
    private WorkflowService workflowService;
    
    @Autowired
    private KnowledgeBaseService kbService;
    
    @Autowired
    private RAGService ragService;
    
    @Autowired
    private ChatService chatService;
    
    /**
     * 初始化智能客服系统
     */
    public void init() {
        // 1. 创建知识库
        KnowledgeBase kb = kbService.create("客服知识库", "常见问题和解决方案");
        
        // 2. 上传FAQ文档
        documentService.upload(kb.getId(), new File("faq.pdf"));
        
        // 3. 创建客服工作流
        WorkflowDefinition workflow = createCustomerServiceWorkflow(kb.getId());
        
        // 4. 保存工作流
        workflowService.save(workflow);
    }
    
    /**
     * 创建客服工作流
     */
    private WorkflowDefinition createCustomerServiceWorkflow(Long kbId) {
        WorkflowDefinition workflow = new WorkflowDefinition();
        workflow.setName("智能客服工作流");
        
        // 添加节点
        WorkflowNode start = new WorkflowNode("START", "开始");
        WorkflowNode intent = new WorkflowNode("LLM", "意图识别");
        WorkflowNode rag = new WorkflowNode("KNOWLEDGE_RETRIEVAL", "知识检索");
        WorkflowNode answer = new WorkflowNode("LLM", "生成回答");
        WorkflowNode end = new WorkflowNode("END", "结束");
        
        // 配置节点
        intent.setConfig(Map.of(
            "model", "gpt-4",
            "systemPrompt", "识别用户意图，返回：退货、咨询、投诉、其他"
        ));
        
        rag.setConfig(Map.of(
            "knowledgeBaseId", kbId,
            "topK", 3
        ));
        
        answer.setConfig(Map.of(
            "model", "gpt-4",
            "systemPrompt", "基于以下知识库内容回答用户问题：\n{{context}}"
        ));
        
        // 连接节点
        workflow.addEdge(start, intent);
        workflow.addEdge(intent, rag);
        workflow.addEdge(rag, answer);
        workflow.addEdge(answer, end);
        
        return workflow;
    }
    
    /**
     * 处理客户消息
     */
    public String handleCustomerMessage(String conversationId, String message) {
        // 执行工作流
        WorkflowExecution execution = workflowService.execute(
            workflowId,
            Map.of("userQuery", message)
        );
        
        return execution.getResult();
    }
}

相关链接

• 快速开始
• API文档
• 技术架构