feature improvements

Author: alexcheng1982

.gitignore

@@ -33,3 +33,5 @@ build/
 
 ### Mac OS ###
 .DS_Store
+
+*.log

pom.xml

@@ -35,7 +35,7 @@
     </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-starter-webflux</artifactId>
+      <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <dependency>
       <groupId>org.springframework.ai</groupId>
@@ -45,10 +45,6 @@
       <groupId>org.springframework.ai</groupId>
       <artifactId>spring-ai-mcp</artifactId>
     </dependency>
-    <dependency>
-      <groupId>org.springframework.ai</groupId>
-      <artifactId>spring-ai-autoconfigure-model-tool</artifactId>
-    </dependency>
     <dependency>
       <groupId>com.javaaidev.chatagentui</groupId>
       <artifactId>chat-agent-ui</artifactId>

sample-config/sample-config.json

@@ -20,7 +20,7 @@
       "args": [
         "-y",
         "@modelcontextprotocol/server-filesystem",
-        "/path"
+        "/tmp"
       ]
     }
   }

src/main/java/com/javaaidev/easymcpclient/AppConfiguration.java

@@ -4,20 +4,31 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.json.JsonMapper;
 import com.javaaidev.easymcpclient.chatmodel.ChatModelService;
+import com.javaaidev.easymcpclient.client.CloseableMcpSyncClients;
 import com.javaaidev.easymcpclient.client.McpClientService;
+import com.javaaidev.easymcpclient.client.McpToolCallbackResolver;
+import com.javaaidev.easymcpclient.client.NamedMcpSyncClient;
+import com.javaaidev.easymcpclient.client.SamplingService;
 import com.javaaidev.easymcpclient.config.McpClientConfig;
-import io.modelcontextprotocol.client.McpSyncClient;
+import com.javaaidev.easymcpclient.config.mcp.NamedMcpServer;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.List;
 import org.springframework.ai.chat.model.ChatModel;
-import org.springframework.ai.mcp.SyncMcpToolCallbackProvider;
-import org.springframework.ai.tool.ToolCallbackProvider;
+import org.springframework.ai.model.tool.ToolCallingManager;
+import org.springframework.ai.tool.execution.DefaultToolExecutionExceptionProcessor;
+import org.springframework.ai.tool.execution.ToolExecutionExceptionProcessor;
+import org.springframework.ai.tool.resolution.DelegatingToolCallbackResolver;
+import org.springframework.ai.tool.resolution.SpringBeanToolCallbackResolver;
+import org.springframework.ai.tool.resolution.ToolCallbackResolver;
 import org.springframework.ai.util.JacksonUtils;
-import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.ApplicationArguments;
+import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.context.support.GenericApplicationContext;
 
 @Configuration
 public class AppConfiguration {
@@ -46,18 +57,68 @@ public McpClientConfig mcpClientConfig(ApplicationArguments arguments,
   }
 
   @Bean
-  public ChatModel chatModel(McpClientConfig mcpClientConfig) {
-    return new ChatModelService().create(mcpClientConfig.chatModel());
+  public ChatModel chatModel(McpClientConfig mcpClientConfig,
+      ToolCallingManager toolCallingManager) {
+    return new ChatModelService().create(mcpClientConfig.chatModel(), toolCallingManager);
   }
 
   @Bean
-  public List<McpSyncClient> mcpSyncClients(McpClientConfig mcpClientConfig) {
-    return new McpClientService().connect(mcpClientConfig.mcpServers().values());
+  public SamplingService samplingService(ChatModel chatModel) {
+    return new SamplingService(chatModel);
   }
 
   @Bean
-  public ToolCallbackProvider mcpToolCallbacks(ObjectProvider<List<McpSyncClient>> syncMcpClients) {
-    List<McpSyncClient> mcpClients = syncMcpClients.stream().flatMap(List::stream).toList();
-    return new SyncMcpToolCallbackProvider(mcpClients);
+  public McpClientService mcpClientService(@Lazy SamplingService samplingService,
+      ApplicationEventPublisher applicationEventPublisher) {
+    return new McpClientService(samplingService, applicationEventPublisher);
+  }
+
+  @Bean
+  public List<NamedMcpSyncClient> mcpSyncClients(McpClientService mcpClientService,
+      McpClientConfig mcpClientConfig) {
+    return mcpClientService.connect(mcpClientConfig.mcpServers().entrySet().stream()
+        .map(entry -> new NamedMcpServer(entry.getKey(), entry.getValue())).toList());
+  }
+
+  @Bean
+  public McpToolCallbackResolver mcpToolCallbackResolver(List<NamedMcpSyncClient> syncMcpClients) {
+    return new McpToolCallbackResolver(syncMcpClients);
+  }
+
+  @Bean
+  public CloseableMcpSyncClients closeableMcpSyncClients(List<NamedMcpSyncClient> mcpSyncClients) {
+    return new CloseableMcpSyncClients(mcpSyncClients);
+  }
+
+  @Bean
+  public AppListener appListener() {
+    return new AppListener();
+  }
+
+  @Bean
+  public ToolExecutionExceptionProcessor toolExecutionExceptionProcessor() {
+    return new DefaultToolExecutionExceptionProcessor(false);
+  }
+
+  @Bean
+  public ToolCallingManager toolCallingManager(
+      @Qualifier("mainToolCallbackResolver") ToolCallbackResolver toolCallbackResolver,
+      ToolExecutionExceptionProcessor toolExecutionExceptionProcessor) {
+    return ToolCallingManager.builder()
+        .toolCallbackResolver(toolCallbackResolver)
+        .toolExecutionExceptionProcessor(toolExecutionExceptionProcessor)
+        .build();
+  }
+
+  @Bean
+  @Qualifier("mainToolCallbackResolver")
+  public ToolCallbackResolver toolCallbackResolver(McpToolCallbackResolver mcpToolCallbackResolver,
+      GenericApplicationContext applicationContext) {
+    var springBeanToolCallbackResolver = SpringBeanToolCallbackResolver.builder()
+        .applicationContext(applicationContext)
+        .build();
+
+    return new DelegatingToolCallbackResolver(
+        List.of(mcpToolCallbackResolver, springBeanToolCallbackResolver));
   }
 }

src/main/java/com/javaaidev/easymcpclient/AppListener.java

@@ -0,0 +1,24 @@
+package com.javaaidev.easymcpclient;
+
+import java.io.IOException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.web.context.WebServerInitializedEvent;
+import org.springframework.context.ApplicationListener;
+
+public class AppListener implements
+    ApplicationListener<WebServerInitializedEvent> {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(AppListener.class);
+
+  @Override
+  public void onApplicationEvent(WebServerInitializedEvent event) {
+    int port = event.getWebServer().getPort();
+    LOGGER.info("Server running on port {}", port);
+    try {
+      BrowserOpener.openUrl("http://localhost:%s/webjars/chat-agent-ui/index.html".formatted(port));
+    } catch (IOException e) {
+      LOGGER.error("Failed to open url", e);
+    }
+  }
+}

src/main/java/com/javaaidev/easymcpclient/BrowserOpener.java

@@ -0,0 +1,24 @@
+package com.javaaidev.easymcpclient;
+
+import java.io.IOException;
+import java.util.List;
+
+public class BrowserOpener {
+
+  public static void openUrl(String url) throws IOException {
+    var os = System.getProperty("os.name").toLowerCase();
+    String[] commands;
+    if (os.contains("win")) {
+      commands = new String[]{"rundll32", "url.dll,FileProtocolHandler", url};
+    } else if (os.contains("mac")) {
+      commands = new String[]{"open", url};
+    } else {
+      var browsers = List.of("google-chrome", "firefox", "mozilla", "epiphany", "konqueror",
+          "netscape", "opera", "links", "lynx");
+      var command = String.join(" || ",
+          browsers.stream().map(browser -> "%s \"%s\"".formatted(browser, url)).toList());
+      commands = new String[]{"sh", "-c", command};
+    }
+    Runtime.getRuntime().exec(commands);
+  }
+}

src/main/java/com/javaaidev/easymcpclient/chatmodel/ChatModelService.java

@@ -7,6 +7,7 @@
 import java.util.function.Supplier;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.ai.model.tool.ToolCallingManager;
 import org.springframework.ai.openai.OpenAiChatModel;
 import org.springframework.ai.openai.OpenAiChatOptions;
 import org.springframework.ai.openai.api.OpenAiApi;
@@ -15,14 +16,14 @@ public class ChatModelService {
 
   private final Dotenv dotenv = Dotenv.configure().ignoreIfMissing().ignoreIfMalformed().load();
 
-  public ChatModel create(ChatModelConfig config) {
+  public ChatModel create(ChatModelConfig config, ToolCallingManager toolCallingManager) {
     if (config instanceof OpenAIChatModelConfig openAIChatModelConfig) {
-      return create(openAIChatModelConfig);
+      return create(openAIChatModelConfig, toolCallingManager);
     }
     throw new IllegalArgumentException("Invalid chat model config");
   }
 
-  private ChatModel create(OpenAIChatModelConfig config) {
+  private ChatModel create(OpenAIChatModelConfig config, ToolCallingManager toolCallingManager) {
     String apiKey = "";
     if (StringUtils.isNotEmpty(config.apiKey())) {
       apiKey = config.apiKey();
@@ -43,6 +44,7 @@ private ChatModel create(OpenAIChatModelConfig config) {
     return OpenAiChatModel.builder()
         .openAiApi(openAiApiBuilder.build())
         .defaultOptions(chatOptionsBuilder.build())
+        .toolCallingManager(toolCallingManager)
         .build();
   }
 

src/main/java/com/javaaidev/easymcpclient/client/CloseableMcpSyncClients.java

@@ -0,0 +1,11 @@
+package com.javaaidev.easymcpclient.client;
+
+import java.util.List;
+
+public record CloseableMcpSyncClients(List<NamedMcpSyncClient> clients) implements AutoCloseable {
+
+  @Override
+  public void close() {
+    this.clients.forEach(client -> client.mcpSyncClient().close());
+  }
+}

src/main/java/com/javaaidev/easymcpclient/client/McpClientService.java

@@ -1,10 +1,9 @@
 package com.javaaidev.easymcpclient.client;
 
-import com.javaaidev.easymcpclient.config.mcp.McpServer;
+import com.javaaidev.easymcpclient.config.mcp.NamedMcpServer;
 import com.javaaidev.easymcpclient.config.mcp.SseServer;
 import com.javaaidev.easymcpclient.config.mcp.StdioServer;
 import io.modelcontextprotocol.client.McpClient;
-import io.modelcontextprotocol.client.McpSyncClient;
 import io.modelcontextprotocol.client.transport.HttpClientSseClientTransport;
 import io.modelcontextprotocol.client.transport.ServerParameters;
 import io.modelcontextprotocol.client.transport.StdioClientTransport;
@@ -14,41 +13,67 @@
 import java.time.Duration;
 import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.ApplicationEventPublisher;
 
 public class McpClientService {
 
-  public List<McpSyncClient> connect(Collection<McpServer> servers) {
-    return servers.stream().map(server -> {
+  private static final Logger LOGGER = LoggerFactory.getLogger(McpClientService.class);
+
+  private final SamplingService samplingService;
+  private final ApplicationEventPublisher applicationEventPublisher;
+
+  public McpClientService(SamplingService samplingService,
+      ApplicationEventPublisher applicationEventPublisher) {
+    this.samplingService = samplingService;
+    this.applicationEventPublisher = applicationEventPublisher;
+  }
+
+  public List<NamedMcpSyncClient> connect(Collection<NamedMcpServer> servers) {
+    return servers.stream().map(namedMcpServer -> {
+      var name = namedMcpServer.name();
+      var server = namedMcpServer.mcpServer();
       if (server instanceof StdioServer stdioServer) {
-        return connect(stdioServer);
+        return connect(name, stdioServer);
       } else if (server instanceof SseServer sseServer) {
-        return connect(sseServer);
+        return connect(name, sseServer);
       }
-      throw new IllegalArgumentException("Invalid MCP server");
-    }).toList();
+      return Optional.<NamedMcpSyncClient>empty();
+    }).flatMap(Optional::stream).toList();
   }
 
-  private McpSyncClient connect(SseServer server) {
-    return doConnect(HttpClientSseClientTransport.builder(server.url()).build());
+  private Optional<NamedMcpSyncClient> connect(String name, SseServer server) {
+    return doConnect(name, HttpClientSseClientTransport.builder(server.url()).build());
   }
 
-  private McpSyncClient connect(StdioServer server) {
-    return doConnect(new StdioClientTransport(
+  private Optional<NamedMcpSyncClient> connect(String name, StdioServer server) {
+    return doConnect(name, new StdioClientTransport(
         ServerParameters.builder(server.command())
             .args(server.args())
             .env(server.env())
             .build()));
   }
 
-  private McpSyncClient doConnect(McpClientTransport clientTransport) {
-    var client = McpClient.sync(clientTransport)
-        .clientInfo(new Implementation("easy-mcp-client", "0.1.0"))
-        .requestTimeout(Duration.ofSeconds(30))
-        .capabilities(ClientCapabilities.builder()
-            .sampling()
-            .build())
-        .build();
-    client.initialize();
-    return client;
+  private Optional<NamedMcpSyncClient> doConnect(String name, McpClientTransport clientTransport) {
+    try {
+      var client = McpClient.sync(clientTransport)
+          .clientInfo(new Implementation("easy-mcp-client", "0.1.0"))
+          .requestTimeout(Duration.ofSeconds(30))
+          .initializationTimeout(Duration.ofSeconds(30))
+          .capabilities(ClientCapabilities.builder()
+              .sampling()
+              .build())
+          .sampling(samplingService)
+          .toolsChangeConsumer(
+              tools -> applicationEventPublisher.publishEvent(new ToolsChangedEvent(name)))
+          .build();
+      client.initialize();
+      return Optional.of(new NamedMcpSyncClient(name, client));
+    } catch (Exception e) {
+      LOGGER.error("Failed to connect to MCP server {}", name, e);
+    }
+    return Optional.empty();
   }
 }