Quarkus MCP Server

<dependency>
    <groupId>io.quarkiverse.mcp</groupId>
    <artifactId>quarkus-mcp-server-stdio</artifactId>
    <version>1.3.1</version>
</dependency>

<dependency>
    <groupId>io.quarkiverse.mcp</groupId>
    <artifactId>quarkus-mcp-server-sse</artifactId>
    <version>1.3.1</version>
</dependency>

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

// @Singleton (1)
public class MyPrompts {

    @Inject (2)
    FooService fooService;

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

}

import io.quarkiverse.mcp.server.Resource;
import jakarta.inject.Inject;
import java.nio.file.Files;

// @Singleton (1)
public class MyResources {

    @Inject (2)
    FooService fooService;

    @Resource(uri = "file:///project/alpha") (3)
    BlobResourceContents alpha() {
        return BlobResourceContents.create("file:///project/alpha", Files.readAllBytes(Paths.ALPHA));
    }

}

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

import jakarta.inject.Inject;

// @Singleton (1)
public class MyResourceTemplates {

    @Inject (2)
    ProjectService projectService;

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

}

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

// @Singleton (1)
public class MyTools {

    @Inject (2)
    FooService fooService;

    @Tool(description = "Put you description here.") (3)
    ToolResponse foo(@ToolArg(description = "The name", defaultValue = "Andy") String name) { (4)
        return ToolResponse.success(
                new TextContent(fooService.ping(name)));
    }

}

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

public class MyNotifications {

    @Notification(Type.INITIALIZED) (1)
    void init(McpConnection connection) { (2) (3)
       Log.infof("New client connected: %s", connection.initialRequest().implementation().name());
    }
}

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");
      }
   }
}

quarkus.http.auth.permission.mcp-endpoints.paths=/mcp/sse,/mcp/messages/* (1)
quarkus.http.auth.permission.mcp-endpoints.policy=authenticated (2)

package org.acme;

import jakarta.annotation.security.RolesAllowed;
import io.quarkus.security.Authenticated;

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

@Authenticated (1)
public class MyTools {

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

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

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.server-info.name=Alpha server (1)
quarkus.mcp.server.bravo.server-info.name=Bravo server (2)

quarkus.mcp.server.sse.root-path=/alpha/mcp (3)
quarkus.mcp.server.bravo.sse.root-path=/bravo/mcp (4)

package org.acme;

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

public class MyTools {

   // No @McpServer annotation means the default server configuration
   @Tool(description = "Put you description here.")
   String atool() {
      return "...some content";
   }

   @McpServer("bravo") (1)
   @Tool(description = "Put you description here.")
   String btool() {
      return "...some content";
   }
}

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