Quarkus MCP Server

import io.quarkiverse.mcp.server.ToolManager;
import io.quarkus.runtime.Startup;
import jakarta.inject.Inject;

public class MyTools {

    @Inject
    ToolManager toolManager; (1)

    @Startup (2)
    void addTool() {
       toolManager.newTool("toLowerCase") (3)
          .setDescription("Converts input string to lower case.")
          .addArgument("value", "Value to convert", true, String.class)
          .setHandler(
              ta -> ToolResponse.success(ta.args().get("value").toString().toLowerCase()))
          .register(); (4)
    }
}

import io.quarkiverse.mcp.server.Tool;
import io.quarkiverse.mcp.server.ToolArg;
import jakarta.inject.Inject;

public class MyTools {

    @Tool(description = "Put you description here.", inputSchema = @InputSchema(generator = MySchemaGenerator.class)) (1)
    String foo(@ToolArg(description = "The name", defaultValue = "Lina") String name) {
        return "Foo name is " + name;
    }
}

import io.quarkiverse.mcp.server.GlobalInputSchemaGenerator;
import jakarta.inject.Inject;
import jakarta.decorator.Decorator;
import jakarta.decorator.Delegate;
import jakarta.annotation.Priority;

@Priority(1) (1)
@Decorator (2)
public class CachingGlobalSchemaGeneratorDecorator implements GlobalInputSchemaGenerator {

   private final ConcurrentMap<String, InputSchema> cache = new ConcurrentHashMap<>();

   @Inject
   @Delegate
   GlobalInputSchemaGenerator delegate; (3)

   @Override
   public InputSchema generate(ToolInfo tool) {
      return cache.computeIfAbsent(tool.name(), k -> {
            return delegate.generate(tool); (4)
      });
   }
}

import io.quarkiverse.mcp.server.Tool;
import io.quarkiverse.mcp.server.ToolArg;
import jakarta.inject.Inject;

public class MyTools {

    @Inject
    FooService fooService;

    @Tool(description = "Put you description here.", structuredContent = true) (1) (2)
    Foo foo(@ToolArg(description = "The name", defaultValue = "Lina") String name) {
        return fooService.ping(name);
    }
}

import io.quarkiverse.mcp.server.Tool;
import io.quarkiverse.mcp.server.Tool.OutputSchema;
import io.quarkiverse.mcp.server.ToolArg;
import io.quarkiverse.mcp.server.ToolResponse;

import jakarta.inject.Inject;

public class MyTools {

    @Inject
    FooService fooService;

    @Tool(description = "Put you description here.", outputSchema = @OutputSchema(from = Foo.class)) (1)
    ToolResponse foo(@ToolArg(description = "The name", defaultValue = "Lina") String name) {
        return ToolResponse.structuredSuccess(fooService.ping(name));
    }
}

import io.quarkiverse.mcp.server.Prompt;
import io.quarkiverse.mcp.server.PromptArg;
import io.quarkiverse.mcp.server.PromptMessage;
import jakarta.inject.Inject;

public class MyPrompts {

    @Inject
    FooService fooService;

    @Prompt(description = "Put you description here.")
    PromptMessage foo(@PromptArg(description = "The name") String name) {
        return PromptMessage.withUserRole(new TextContent(fooService.ping(name)));
    }

    @CompletePrompt("foo") (1)
    List<String> completeName(@CompleteArg(name = "name") String val) { (2) (3)
        return fooService.getNames().stream().filter(n -> n.startsWith(val)).toList();
    }

}

import io.quarkiverse.mcp.server.PromptManager;
import io.quarkus.runtime.Startup;
import jakarta.inject.Inject;

public class MyPrompts {

    @Inject
    PromptManager promptManager; (1)

    @Inject
    CodeService codeService;

    @Startup (2)
    void addPrompt() {
       promptManager.newPrompt("code_assist") (3)
          .setDescription("Prompt for code assist")
          .addArgument("lang", "Language", true)
          .setHandler(
              a -> PromptResponse.withMessages(
                         List.of(PromptMessage.withUserRole(new TextContent(codeService.assist(a.args().get("lang")))))))
          .register(); (4)
    }
}

import io.quarkiverse.mcp.server.ResourceManager;
import io.quarkus.runtime.Startup;
import jakarta.inject.Inject;

public class MyResources {

    @Inject
    ResourceManager resourceManager; (1)

    @Startup (2)
    void addResource() {
       resourceManager.newResource("file:///project/alpha") (3)
          .setDescription("Alpha resource file")
          .setHandler(
              args -> new ResourceResponse(
                                    List.of(BlobResourceContents.create(args.requestUri().value(), Files.readAllBytes(Path.of("alpha.txt"))))))
          .register(); (4)
    }
}

import io.quarkiverse.mcp.server.ResourceManager;
import jakarta.inject.Inject;

public class MyResources {

    @Inject
    ResourceManager resourceManager; (1)

    void alphaUpdated() {
       resourceManager.getResource("file:///alpha.txt").sendUpdate(); (2)
    }
}

import io.quarkiverse.mcp.server.ResourceTemplate;
import io.quarkiverse.mcp.server.TextResourceContents;

import jakarta.inject.Inject;

public class MyTemplates {

    @Inject
    ProjectService projectService;

    @ResourceTemplate(uriTemplate = "file:///project/{name}")
    TextResourceContents project(String name) {
        return TextResourceContents.create(uri, projectService.readProject(name)));
    }

    @CompleteResourceTemplate("project") (1)
    List<String> completeName(String name) { (2)
        return projectService.getNames().stream().filter(n -> n.startsWith(name)).toList();
    }

}

import io.quarkiverse.mcp.server.ResourceTemplateManager;
import io.quarkus.runtime.Startup;
import jakarta.inject.Inject;

public class MyResourceTemplates {

    @Inject
    ResourceTemplateManager resourceTemplateManager; (1)

    @Inject
    FileService fileService;

    @Startup (2)
    void addResourceTemplate() {
       resourceTemplateManager.newResourceTemplate("alpha") (3)
          .setUriTemplate("file:///alpha/{foo}")
          .setDescription("Alpha file template")
          .setHandler(
              rta -> new ResourceResponse(
                                    List.of(BlobResourceContents.create(args.requestUri().value(), fileService.load(rta.args().get("foo"))))))
          .register(); (4)
    }
}

import io.quarkiverse.mcp.server.NotificationManager;
import io.quarkiverse.mcp.server.Notification.Type;
import jakarta.inject.Inject;
import io.quarkus.runtime.Startup;

public class MyNotifications {

    @Inject
    NotificationManager notificationManager; (1)

    @Startup (2)
    void addNotification() {
       notificationManager.newNotification("foo")
                    .setType(Type.INITIALIZED)
                    .setHandler(args -> {
                        Log.infof("New client connected: %s", args.connection().initialRequest().implementation().name());
                        return null;
                    }).register(); (3)
    }
}

package org.acme;

import io.quarkiverse.mcp.server.Tool;
import io.quarkiverse.mcp.server.ToolArg;
import io.quarkiverse.mcp.server.ToolResponse;
import jakarta.inject.Inject;

public class MyTools {

    @Tool
    String up(String name, McpLog log) {
        log.info("UP name accepted %s", name); (1)
        return name.toUpperCase();
    }

    @Tool
    String down(String name, McpLog log) {
        log.send(LogLevel.INFO, "DOWN name accepted %s", name); (2)
        return name.toLoweCase();
    }

}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import jakarta.annotation.PreDestroy;
import io.smallrye.mutiny.Uni;

import io.quarkiverse.mcp.server.Progress;
import io.quarkiverse.mcp.server.ProgressTracker;
import io.quarkiverse.mcp.server.Tool;

public class MyTools {

    private final ExecutorService executor;

    MyTools() {
       this.executor = Executors.newFixedThreadPool(1);
    }

    @PreDestroy
    void destroy() {
       executor.shutdownNow();
    }

    @Tool
    Uni<String> longRunning(Progress progress) { (1) (2)
       if (progress.token().isEmpty()) { (3)
          return Uni.createFrom().item("nok");
       }
       ProgressTracker tracker = progress.trackerBuilder() (4)
          .setDefaultStep(1)
          .setTotal(10.2)
          .setMessageBuilder(i -> "Long running progress: " + i)
          .build();

       CompletableFuture<String> ret = new CompletableFuture<String>();
       executor.execute(() -> {
          for (int i = 0; i < 10; i++) {
             try {
                // Do something that takes time...
                TimeUnit.MILLISECONDS.sleep(500);
             } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
             }
             tracker.advance(); (5)
          }
          ret.complete("ok");
        });
        return Uni.createFrom().completionStage(ret);
    }

}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import jakarta.annotation.PreDestroy;
import io.smallrye.mutiny.Uni;

import io.quarkiverse.mcp.server.Progress;
import io.quarkiverse.mcp.server.ProgressNotification;
import io.quarkiverse.mcp.server.Tool;

public class MyTools {

    private final ExecutorService executor;

    MyTools() {
       this.executor = Executors.newFixedThreadPool(1);
    }

    @PreDestroy
    void destroy() {
       executor.shutdownNow();
    }

    @Tool
    Uni<String> longRunning(Progress progress) { (1) (2)
       if (progress.token().isEmpty()) { (3)
          return Uni.createFrom().item("nok");
       }

       CompletableFuture<String> ret = new CompletableFuture<String>();
       executor.execute(() -> {
          for (int i = 0; i < 10; i++) {
             try {
                // Do something that takes time...
                TimeUnit.MILLISECONDS.sleep(500);
             } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
             }
             progress.notificationBuilder()
                            .setProgress(i)
                            .setTotal(10.2)
                            .setMessage("Long running progress: " + i)
                            .build()
                            .sendAndForget(); (4)
          }
          ret.complete("ok");
        });
        return Uni.createFrom().completionStage(ret);
    }

}

import io.quarkiverse.mcp.server.Roots;
import io.quarkiverse.mcp.server.Notification;
import io.quarkiverse.mcp.server.Notification.Type;

public class MyRoots {

   private final Map<String, List<Root>> rootsMap = new ConcurrentHashMap<>(); (1)

   @Notification(Type.INITIALIZED)
   void init(McpConnection connection, Roots roots) { (2)
      if (connection.initialRequest().supportsRoots()) {
         rootsMap.put(connection.id(), roots.listAndAwait());
      }
   }

   @Notification(Type.ROOTS_LIST_CHANGED)
   void change(McpConnection connection, Roots roots) { (3)
      rootsMap.put(connection.id(), roots.listAndAwait());
   }

   public List<Root> getRoots(String connectionId) {
      return rootsMap.get(connectionId);
   }

}

import io.quarkiverse.mcp.server.Sampling;
import io.quarkiverse.mcp.server.Tool;
import io.smallrye.mutiny.Uni;

public class MyTools {

   @Tool(description = "A tool that is using sampling...")
   Uni<String> samplingFoo(Sampling sampling) { (1)
      if (sampling.isSupported()) {
         SamplingRequest samplingRequest = sampling.requestBuilder() (2)
                        .setMaxTokens(100)
                        .addMessage(SamplingMessage.withUserRole("What's happening?"))
                        .build();
         return samplingRequest.send().map(resp -> resp.content().asText().text()); (3)
      } else {
         return Uni.createFrom().item("Sampling not supported");
      }
   }
}

import io.quarkiverse.mcp.server.Elicitation;
import io.quarkiverse.mcp.server.ElicitationRequest;
import io.quarkiverse.mcp.server.ElicitationResponse;
import io.quarkiverse.mcp.server.Tool;
import io.smallrye.mutiny.Uni;

public class MyTools {

   @Tool(description = "A tool that is using elicitation...")
   Uni<String> elicitationFoo(Elicitation elicitation) { (1)
      if (elicitation.isSupported()) {
         ElicitationRequest request = elicitation.requestBuilder() (2)
                .setMessage("What's your GitHub account?")
                .addSchemaProperty("username", new StringSchema())
                .build();
         return request.send().map(response -> { (3)
                    if (response.actionAccepted()) {
                        return "It's GitHub user: " + response.content().getString("username") + ".";
                    } else {
                        return "Not accepted...";
                    }
         });
     } else {
        return Uni.createFrom().item("Elicitation not supported.);
     }
  }
}

import io.quarkiverse.mcp.server.Cancellation;
import io.quarkiverse.mcp.server.Tool;

public class MyTools {

   @Tool(description = "A tool that may be cancelled")
   String myTool(Cancellation cancellation) { (1)
       while (someCondition) {
          if (cancellation.check().isRequested()) { (2) (3)
            throw new OperationCancellationException();
          }
          // do something...
          TimeUnit.MILLISECONDS.sleep(500);
       }
       return "OK";
   }
}

import io.quarkiverse.mcp.server.RawMessage;
import io.quarkiverse.mcp.server.Tool;

public class MyTools {

   @Tool(description = "A tool that can access the raw message")
   String myTool(RawMessage message, int count) { (1)
       // A raw message may look like:
       // {
       //  "jsonrpc" : "2.0",
       //  "method" : "tools/call",
       //  "id" : 2,
       //  "params" : {
       //    "name" : "foo",
       //    "arguments" : {
       //      "count" : 2
       //    }
       //   }
       // }
       // rawCount == count
       int rawCount = message.asJsonObject()
                    .getJsonObject("params")
                    .getJsonObject("arguments")
                    .getInteger("count"); (2)
       return "OK".repeat(rawCount);
   }
}

package org.acme;

import io.quarkiverse.mcp.server.InitialCheck;
import io.quarkiverse.mcp.server.InitialRequest;

// @Singleton is added automatically
public class MyCheck implements InitialCheck {

   public Uni<CheckResult> perform(InitialRequest initialRequest) {
      return initialRequest.supportsSampling() ? InitialCheck.CheckResult.successs()
               : InitialCheck.CheckResult.error("Sampling not supported");
   }
}

package org.acme;

import io.quarkiverse.mcp.server.ToolFilter;
import io.quarkiverse.mcp.server.PromptFilter;

// @Singleton is added automatically
public class MyFilters implements ToolFilter, PromptFilter {

   @Override
   public boolean test(PromptInfo prompt, McpConnection connection) {
     // Skip clients that do not support sampling
     return connection.initialRequest().supportsSampling();
   }

   @Override
   public boolean test(ToolInfo tool, McpConnection connection) {
       // Skip tools registered programmatically
       return tool.isMethod();
   }
}

quarkus.mcp.server.traffic-logging.enabled=true (1)
quarkus.mcp.server.traffic-logging.text-limit=500 (2)

$ npx @modelcontextprotocol/inspector

$ docker run --rm --network=host node:18 npx @modelcontextprotocol/inspector

$ docker run --rm -p 5173:5173 node:18 npx @modelcontextprotocol/inspector