Feat/mcp

app/src/main/java/com/tinyengine/it/TinyEngineApplication.java

@@ -13,18 +13,24 @@
 package com.tinyengine.it;
 
 import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.ai.tool.ToolCallbackProvider;
+import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 
+import java.util.Map;
+
 /**
  * The type Tiny engine application.
  *
  * @since 2024-10-20
  */
 @SpringBootApplication
 @EnableAspectJAutoProxy
-@MapperScan({"com.tinyengine.it.mapper","com.tinyengine.it.dynamic.dao"})
+@MapperScan({"com.tinyengine.it.mapper","com.tinyengine.it.dynamic.dao","com.tinyengine.it.mcp.tools"})
 public class TinyEngineApplication {
     /**
      * The entry point of application.
@@ -34,4 +40,7 @@ public class TinyEngineApplication {
     public static void main(String[] args) {
         SpringApplication.run(TinyEngineApplication.class, args);
     }
+
+
+
 }

app/src/main/resources/application-alpha.yml

@@ -28,6 +28,24 @@ spring:
       min-evictable-idle-time-millis: 300000 # 连接在池中保持空闲的最小时间（单位：毫秒）。如果空闲时间超过这个值，连接将被回收，默认值为 1800000。
       pool-prepared-statements: true # 是否缓存 PreparedStatement 对象，默认值为 true。
       max-open-prepared-statements: 20 # 最大缓存的 PreparedStatement 数量，默认值为 -1，表示无限制。如果 `pool-prepared-statements` 设置为 true，设置此值以限制缓存数量。
+  ai:
+    mcp:
+      server:
+        enabled: true
+        protocol: STREAMABLE
+        version: 1.0.0
+        tool-change-notification: true
+        type: SYNC
+        annotation-scanner:
+          enabled: false
+        capabilities:
+          tool: true
+        streamable-http:
+          mcp-endpoint: /mcp
+        name: tiny-engine-mcp
+
+
+
   # 清空任务配置
 cleanup:
   enabled: false
@@ -89,3 +107,19 @@ logging:
 cors:
   allowed-origins: "*"
 
+
+openai:
+  api-key: your-api-key
+  base-url: https://api.deepseek.com/v1/chat/completions
+  default-model: deepseek-chat
+  timeout-seconds: 300
+  streamable-tools:
+    doc_tools: https://agent.opentiny.design/servers/doc-tools-mcp/mcp  # 工具名 -> SSE服务URL
+
+
+  streamable-http:
+    max-connections: 10
+    connection-timeout-seconds: 30
+    request-timeout-seconds: 60
+    protocol-version: 2025-06-18
+

base/src/main/java/com/tinyengine/it/config/OpenAIConfig.java

@@ -13,18 +13,38 @@
 package com.tinyengine.it.config;
 
 import lombok.Data;
-import org.springframework.context.annotation.Configuration;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * The type Open AI config.
  *
  * @since 2025-08-06
  */
 @Data
-@Configuration
+@Component
+@ConfigurationProperties(prefix = "openai")
 public class OpenAIConfig {
     private String apiKey = "your-api-key";
     private String baseUrl = "https://api.deepseek.com/chat/completions";
     private String defaultModel = "deepseek-chat";
     private int timeoutSeconds = 300;
+
+    // Streamable HTTP 工具映射（工具名 -> 服务URL）
+    private Map<String, String> streamableTools = new HashMap<>();
+
+    // Streamable HTTP 连接池配置
+    private StreamableHttpConfig streamableHttp = new StreamableHttpConfig();
+
+    @Data
+    public static class StreamableHttpConfig  {
+        private int maxConnections = 20;
+        private int connectionTimeoutSeconds = 30;
+        private int requestTimeoutSeconds = 60;
+        private String protocolVersion = "2025-06-18"; // 协议版本
+        private boolean keepAlive = true;
+    }
 }

base/src/main/java/com/tinyengine/it/mcp/annotation/MCPTool.java

@@ -0,0 +1,14 @@
+package com.tinyengine.it.mcp.annotation;
+
+import java.lang.annotation.*;
+
+/**
+ * The interface MCPTool. MCP工具注解，用于标识MCP工具方法，提供工具名称和描述信息。
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface  MCPTool {
+	String name() default "";
+	String description() default "";
+}

base/src/main/java/com/tinyengine/it/mcp/config/McpToolsConfig.java

@@ -0,0 +1,33 @@
+package com.tinyengine.it.mcp.config;
+
+import com.tinyengine.it.mcp.core.StreamableMcpClient;
+import com.tinyengine.it.mcp.tools.DemoMcpTools;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.tool.ToolCallbackProvider;
+import org.springframework.ai.tool.method.MethodToolCallbackProvider;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+@Configuration
+public class McpToolsConfig {
+	private static final Logger log = LoggerFactory.getLogger(McpToolsConfig.class);
+
+
+	/**
+	 * 方式一：通过 ToolCallbackProvider 批量注册工具
+	 */
+	@Bean
+	@Primary
+	public ToolCallbackProvider toolCallbackProvider(DemoMcpTools demoMcpTools) {
+
+
+		MethodToolCallbackProvider provider = MethodToolCallbackProvider.builder()
+			.toolObjects(demoMcpTools)
+			.build();
+		// 立即验证
+		log.info("Tool count from provider: " + provider.getToolCallbacks().length);
+		return provider;
+	}
+}

base/src/main/java/com/tinyengine/it/mcp/core/MCPToolDefinition.java

@@ -0,0 +1,40 @@
+package com.tinyengine.it.mcp.core;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+
+import java.lang.reflect.Method;
+
+@Data
+public class MCPToolDefinition {
+	private String name;
+	private String description;
+	private Object bean;
+	private Method method;
+	private JsonNode inputSchema;  // JSON Schema 格式
+
+	/**
+	 * 执行工具方法
+	 * @param arguments
+	 * @return
+	 * @throws Exception
+	 */
+	public Object execute(JsonNode arguments) throws Exception {
+		// 参数转换：根据方法参数类型从 JsonNode 中提取值
+		// 这里简化：假设方法只有一个参数，且为 JsonNode 或 String
+		Class<?>[] paramTypes = method.getParameterTypes();
+		Object[] args = new Object[paramTypes.length];
+		for (int i = 0; i < paramTypes.length; i++) {
+			Class<?> type = paramTypes[i];
+			if (type == JsonNode.class) {
+				args[i] = arguments;
+			} else if (type == String.class) {
+				args[i] = arguments.toString();
+			} else {
+				// 可以扩展更复杂的转换，例如使用 ObjectMapper 转换为指定类型
+				args[i] = null;
+			}
+		}
+		return method.invoke(bean, args);
+	}
+}

base/src/main/java/com/tinyengine/it/mcp/core/MCPToolRegistry.java

@@ -0,0 +1,82 @@
+package com.tinyengine.it.mcp.core;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.tinyengine.it.mcp.annotation.MCPTool;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Component
+public class MCPToolRegistry {
+	private final Map<String, MCPToolDefinition> tools = new ConcurrentHashMap<>();
+	private final ObjectMapper objectMapper = new ObjectMapper();
+	private final ApplicationContext applicationContext;
+	private volatile boolean initialized = false;
+
+	public MCPToolRegistry(ApplicationContext applicationContext) {
+		this.applicationContext = applicationContext;
+	}
+
+	private void initialize() {
+		if (initialized) return;
+		synchronized (this) {
+			if (initialized) return;
+			// 扫描所有 bean
+			Map<String, Object> beans = applicationContext.getBeansWithAnnotation(org.springframework.stereotype.Component.class);
+			for (Object bean : beans.values()) {
+				for (Method method : bean.getClass().getDeclaredMethods()) {
+					if (method.isAnnotationPresent(MCPTool.class)) {
+						registerTool(bean, method);
+					}
+
+				}
+			}
+			initialized = true;
+		}
+	}
+
+	public MCPToolDefinition getTool(String name) {
+		initialize();
+		return tools.get(name);
+	}
+
+	public Collection<MCPToolDefinition> getAllTools() {
+		initialize();
+		return tools.values();
+	}
+
+	private void registerTool(Object bean, Method method) {
+		MCPTool annotation = method.getAnnotation(MCPTool.class);
+		MCPToolDefinition def = new MCPToolDefinition();
+		def.setName(annotation.name().isEmpty() ? method.getName() : annotation.name());
+		def.setDescription(annotation.description());
+		def.setBean(bean);
+		def.setMethod(method);
+		def.setInputSchema(generateSchema(method));
+		tools.put(def.getName(), def);
+	}
+
+	private JsonNode generateSchema(Method method) {
+		ObjectNode schema = objectMapper.createObjectNode();
+		schema.put("type", "object");
+		ObjectNode properties = objectMapper.createObjectNode();
+		for (Parameter param : method.getParameters()) {
+			String paramName = param.getName();
+			ObjectNode prop = objectMapper.createObjectNode();
+			// 简化：假设参数都是 String
+			prop.put("type", "string");
+			properties.set(paramName, prop);
+		}
+		schema.set("properties", properties);
+		return schema;
+	}
+
+}

base/src/main/java/com/tinyengine/it/mcp/core/RemoteToolDefinition.java

@@ -0,0 +1,12 @@
+package com.tinyengine.it.mcp.core;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+
+@Data
+public class RemoteToolDefinition {
+	private String name;
+	private String description;
+	private JsonNode parameters;   // JSON Schema
+	private String serverUrl;
+}