1.12.23

deploy.sh

@@ -3,10 +3,10 @@ pnpm run build
 cd ../erupt/erupt-web
 git add src/main/resources/public
 
-cd ../erupt-ai-web
-pnpm run build
-cd ../erupt-ai
-git add src/main/resources/static
-
-cd ../deploy/erupt-cloud-server-docker
-source deploy.sh
+#cd ../erupt-ai-web
+#pnpm run build
+#cd ../erupt-ai
+#git add src/main/resources/static
+#
+#cd ../deploy/erupt-cloud-server-docker
+#source deploy.sh

deploy/erupt-cloud-server-docker/pom.xml

@@ -6,11 +6,12 @@
     <parent>
         <groupId>xyz.erupt</groupId>
         <artifactId>erupt</artifactId>
-        <version>1.12.21</version>
+        <version>1.12.23</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
     <artifactId>erupt-cloud-server-docker</artifactId>
+    <name>erupt-cloud-server-docker</name>
 
     <properties>
         <maven.deploy.skip>true</maven.deploy.skip>
@@ -72,7 +73,14 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.sonatype.central</groupId>
+                <artifactId>central-publishing-maven-plugin</artifactId>
+                <version>0.8.0</version>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
-
 </project>

erupt-admin/pom.xml

@@ -5,11 +5,12 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>erupt-admin</artifactId>
+    <name>erupt-admin</name>
 
     <parent>
         <groupId>xyz.erupt</groupId>
         <artifactId>erupt</artifactId>
-        <version>1.12.21</version>
+        <version>1.12.23</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

erupt-ai/pom.xml

@@ -10,7 +10,7 @@
     <parent>
         <groupId>xyz.erupt</groupId>
         <artifactId>erupt</artifactId>
-        <version>1.12.21</version>
+        <version>1.12.23</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -45,6 +45,11 @@
             <groupId>org.freemarker</groupId>
             <artifactId>freemarker</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.squareup</groupId>
+            <artifactId>javapoet</artifactId>
+            <version>1.13.0</version>
+        </dependency>
     </dependencies>
 
 </project>

erupt-ai/src/main/java/xyz/erupt/ai/call/AiFunctionManager.java

@@ -1,6 +1,7 @@
 package xyz.erupt.ai.call;
 
 import com.google.gson.reflect.TypeToken;
+import lombok.Getter;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.ApplicationArguments;
@@ -36,31 +37,32 @@
 @Slf4j
 public class AiFunctionManager implements ApplicationRunner {
 
-    private final Map<String, AiFunctionCall> aiFunctionMap = new HashMap<>();
+    @Getter
+    private static final Map<String, AiFunctionCall> aiFunctions = new HashMap<>();
 
     @Override
     public void run(ApplicationArguments args) {
         EruptSpringUtil.scannerPackage(EruptApplication.getScanPackage(),
                 new TypeFilter[]{new AssignableTypeFilter(AiFunctionCall.class)}, clazz ->
-                        aiFunctionMap.put(clazz.getSimpleName(), (AiFunctionCall) EruptSpringUtil.getBean(clazz))
+                        aiFunctions.put(clazz.getSimpleName(), (AiFunctionCall) EruptSpringUtil.getBean(clazz))
         );
     }
 
     public String getFunctionCallPrompt() {
         StringBuilder sb = new StringBuilder("下面是一组 Function Call 的映射，根据情况决定是否调用，否则忽略这段提示词\n");
-        for (Map.Entry<String, AiFunctionCall> entry : aiFunctionMap.entrySet()) {
+        for (Map.Entry<String, AiFunctionCall> entry : aiFunctions.entrySet()) {
             sb.append("- 如果用户问：").append(entry.getValue().description()).append("，就只回复：").append(entry.getKey()).append("\n");
         }
         return sb.toString();
     }
 
     public boolean exist(String key) {
-        return aiFunctionMap.containsKey(key);
+        return aiFunctions.containsKey(key);
     }
 
     @SneakyThrows
     public String call(String key, LLM llm, String userMessage, List<ChatCompletionMessage> userContext) {
-        AiFunctionCall aiFunctionCall = aiFunctionMap.get(key);
+        AiFunctionCall aiFunctionCall = aiFunctions.get(key);
         Map<String, Field> params = new HashMap<>();
         for (Field field : aiFunctionCall.getClass().getDeclaredFields()) {
             Optional.ofNullable(field.getAnnotation(AiParam.class)).ifPresent(it -> {

erupt-ai/src/main/java/xyz/erupt/ai/config/AiMCPProp.java

@@ -0,0 +1,25 @@
+package xyz.erupt.ai.config;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author YuePeng
+ * date 2025/2/25 22:19
+ */
+@Getter
+@Setter
+@Component
+//@ConfigurationProperties("erupt.ai.mcp")
+public class AiMCPProp {
+
+    private boolean enable = false;
+
+    private String apiDomain;
+
+    private String name;
+
+    private String description;
+
+}

erupt-ai/src/main/java/xyz/erupt/ai/controller/IntellectController.java

@@ -0,0 +1,39 @@
+package xyz.erupt.ai.controller;
+
+import com.google.gson.reflect.TypeToken;
+import org.springframework.web.bind.annotation.*;
+import xyz.erupt.ai.service.LLMService;
+import xyz.erupt.ai.util.ClassTemplateUtil;
+import xyz.erupt.ai.util.MarkDownUtil;
+import xyz.erupt.core.config.GsonFactory;
+import xyz.erupt.core.constant.EruptRestPath;
+import xyz.erupt.core.service.EruptCoreService;
+import xyz.erupt.core.view.EruptModel;
+import xyz.erupt.core.view.R;
+
+import javax.annotation.Resource;
+import java.util.Map;
+
+/**
+ * @author YuePeng
+ * date 2025/6/4 22:10
+ */
+@RestController
+@RequestMapping(EruptRestPath.ERUPT_API + "/ai/intellect")
+public class IntellectController {
+
+    @Resource
+    private LLMService llmService;
+
+    @GetMapping("/form/fill/{erupt}")
+    public R<Map<String, Object>> formFill(@PathVariable("erupt") String eruptName,
+                                           @RequestParam(required = false) String prompt) {
+        EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
+        String promptBuilder = "根据如下面的class类结构，生成内容随机的json，注意只返回纯json\n" +
+                ClassTemplateUtil.geneEruptFormClass(eruptModel.getClazz());
+        String result = llmService.send(promptBuilder);
+        return R.ok(GsonFactory.getGson().fromJson(MarkDownUtil.extractCodeBlock(result), new TypeToken<Map<String, Object>>() {
+        }.getType()));
+    }
+
+}

erupt-ai/src/main/java/xyz/erupt/ai/controller/McpController.java

@@ -0,0 +1,101 @@
+package xyz.erupt.ai.controller;
+
+import lombok.SneakyThrows;
+import org.springframework.web.bind.annotation.*;
+import xyz.erupt.ai.annotation.AiParam;
+import xyz.erupt.ai.call.AiFunctionCall;
+import xyz.erupt.ai.call.AiFunctionManager;
+import xyz.erupt.ai.config.AiMCPProp;
+import xyz.erupt.ai.util.McpUtil;
+import xyz.erupt.ai.vo.OpenAiVo;
+import xyz.erupt.core.util.EruptInformation;
+
+import javax.annotation.Resource;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+public class McpController {
+
+    @Resource
+    private AiMCPProp mcpProp;
+
+    private static final String MCP_CALL_API = "/mcp/call";
+
+    @GetMapping("/openapi.json")
+    public OpenAiVo eruptAi() {
+        OpenAiVo openAiVo = new OpenAiVo();
+        OpenAiVo.Info info = new OpenAiVo.Info();
+        info.setTitle(mcpProp.getName());
+        info.setVersion(EruptInformation.getEruptVersion());
+        info.setDescription(mcpProp.getDescription());
+        openAiVo.setInfo(info);
+        openAiVo.setServers(new OpenAiVo.Server[]{new OpenAiVo.Server(mcpProp.getApiDomain())});
+        for (Map.Entry<String, AiFunctionCall> entry : AiFunctionManager.getAiFunctions().entrySet()) {
+            OpenAiVo.Path path = new OpenAiVo.Path();
+            openAiVo.getPaths().put(MCP_CALL_API + "/" + entry.getKey(), path);
+            OpenAiVo.PathPost post = new OpenAiVo.PathPost();
+            path.setPost(post);
+            post.setSummary(entry.getValue().description());
+            post.setOperationId(entry.getKey());
+            {
+                List<String> required = new ArrayList<>();
+                Map<String, OpenAiVo.SchemaProperties> properties = new HashMap<>();
+                for (Field field : entry.getValue().getClass().getDeclaredFields()) {
+                    AiParam aiParam = field.getDeclaredAnnotation(AiParam.class);
+                    if (null != aiParam) {
+                        if (aiParam.required()) {
+                            required.add(field.getName());
+                        }
+                        OpenAiVo.SchemaProperties schemaProperties = new OpenAiVo.SchemaProperties();
+                        schemaProperties.setType(McpUtil.toMcp(field.getType()));
+                        schemaProperties.setDescription(aiParam.description());
+                        properties.put(field.getName(), schemaProperties);
+                    }
+                }
+
+                OpenAiVo.RequestBody requestBody = new OpenAiVo.RequestBody();
+                post.setRequestBody(requestBody);
+                requestBody.setRequired(!properties.isEmpty());
+                OpenAiVo.ApplicationType applicationType = new OpenAiVo.ApplicationType();
+                requestBody.getContent().put("application/json", applicationType);
+                OpenAiVo.Schema schema = new OpenAiVo.Schema();
+                applicationType.setSchema(schema);
+                schema.setType("object");
+                schema.setRequired(required);
+                schema.setProperties(properties);
+            }
+            {
+                OpenAiVo.Response response = new OpenAiVo.Response();
+                post.getResponses().put(200, response);
+                response.setDescription("Success");
+                OpenAiVo.ApplicationType applicationType = new OpenAiVo.ApplicationType();
+                OpenAiVo.Schema schema = new OpenAiVo.Schema();
+                schema.setType(McpUtil.toMcp(String.class));
+                schema.setRequired(new ArrayList<>());
+                applicationType.setSchema(schema);
+                response.getContent().put("text/plain", applicationType);
+            }
+        }
+        return openAiVo;
+    }
+
+    @PostMapping(MCP_CALL_API + "/{code}")
+    @SneakyThrows
+    public String mcpCall(@PathVariable String code, @RequestBody(required = false) Map<String, Object> params) {
+        AiFunctionCall aiFunctionCall = AiFunctionManager.getAiFunctions().get(code);
+        if (null != params) {
+            for (Map.Entry<String, Object> entry : params.entrySet()) {
+                Field field = aiFunctionCall.getClass().getDeclaredField(entry.getKey());
+                field.setAccessible(true);
+                field.set(aiFunctionCall, entry.getValue());
+                field.setAccessible(false);
+            }
+        }
+        return aiFunctionCall.call(null);
+    }
+
+}

erupt-ai/src/main/java/xyz/erupt/ai/service/LLMService.java

@@ -22,6 +22,7 @@
 import xyz.erupt.ai.vo.SseBody;
 import xyz.erupt.core.config.GsonFactory;
 import xyz.erupt.core.context.MetaContext;
+import xyz.erupt.core.exception.EruptWebApiRuntimeException;
 import xyz.erupt.core.util.EruptSpringUtil;
 import xyz.erupt.jpa.dao.EruptDao;
 
@@ -47,7 +48,26 @@ public class LLMService {
     @Resource
     private AiFunctionManager aiFunctionManager;
 
-    public static final int MESSAGE_TS = 100;
+    private static final int MESSAGE_TS = 100;
+
+    public String send(String prompt) {
+        return send(prompt, Collections.emptyList());
+    }
+
+    public String send(String prompt, List<ChatCompletionMessage> assistantPrompt) {
+        return send(eruptDao.lambdaQuery(LLM.class).eq(LLM::getDefaultLLM, true).eq(LLM::getEnable, true).limit(1).one(), prompt, assistantPrompt);
+    }
+
+    public String send(LLM llm, String prompt) {
+        return send(llm, prompt, Collections.emptyList());
+    }
+
+    public String send(LLM llmConfig, String prompt, List<ChatCompletionMessage> assistantPrompt) {
+        if (null == llmConfig) {
+            throw new EruptWebApiRuntimeException("Not found LLM config");
+        }
+        return LlmCore.getLLM(llmConfig.getLlm()).chat(llmConfig.toLlmRequest(), prompt, assistantPrompt).getMessageStr();
+    }
 
     @SneakyThrows
     public List<ChatCompletionMessage> geneCompletionPrompt(Chat chat, LLMAgent llmAgent, Integer contextTurn) {
@@ -67,7 +87,7 @@ public List<ChatCompletionMessage> geneCompletionPrompt(Chat chat, LLMAgent llmA
                 .eq(ChatMessage::getChatId, chat.getId())
                 .isNotNull(ChatMessage::getContent)
                 .orderByDesc(ChatMessage::getCreatedAt)
-                .limit(contextTurn).list();
+                .limit(contextTurn + 1).list();
         Collections.reverse(chatMessages);
         chatMessages.forEach(it -> chatCompletionMessages.add(
                 new ChatCompletionMessage(it.getSenderType() == ChatSenderType.USER ? MessageRole.user : MessageRole.assistant, it.getContent()))

erupt-ai/src/main/java/xyz/erupt/ai/util/ClassTemplateUtil.java

@@ -0,0 +1,32 @@
+package xyz.erupt.ai.util;
+
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.TypeSpec;
+import xyz.erupt.annotation.EruptField;
+import xyz.erupt.core.util.ReflectUtil;
+
+import javax.lang.model.element.Modifier;
+import java.util.Optional;
+
+/**
+ * @author YuePeng
+ * date 2025/7/14 22:13
+ */
+public class ClassTemplateUtil {
+
+    public static String geneEruptFormClass(Class<?> erupt) {
+        // 构建类
+        TypeSpec.Builder builder = TypeSpec.classBuilder(erupt.getSimpleName()).addModifiers(Modifier.PUBLIC);
+        ReflectUtil.findClassAllFields(erupt, field -> {
+            Optional.ofNullable(field.getDeclaredAnnotation(EruptField.class)).ifPresent(eruptField -> {
+                if (!"".equals(eruptField.edit().title())) {
+                    FieldSpec.Builder fieldSpec = FieldSpec.builder(field.getType(), field.getName(), Modifier.PUBLIC);
+                    fieldSpec.addJavadoc(eruptField.edit().title());
+                    builder.addField(fieldSpec.build());
+                }
+            });
+        });
+        return builder.build().toString();
+    }
+
+}

erupt-ai/src/main/java/xyz/erupt/ai/util/McpUtil.java

@@ -0,0 +1,22 @@
+package xyz.erupt.ai.util;
+
+/**
+ * @author YuePeng
+ * date 2025/7/24 00:13
+ */
+
+public final class McpUtil {
+
+    public static String toMcp(Class<?> c) {
+        if (c.isPrimitive()) {
+            if (c == boolean.class) return "boolean";
+            if (c == float.class || c == double.class) return "number";
+            return "integer";   // byte/short/int/long
+        }
+        if (Number.class.isAssignableFrom(c)) {
+            if (c == Float.class || c == Double.class) return "number";
+            return "integer";   // Byte/Short/Integer/Long
+        }
+        return "string";
+    }
+}