From Hello World to AI-Ready: Quarkus Dev UI MCP Server in Action

A hands-on guide for Java developers to expose tools through Quarkus Dev UI using the Model Context Protocol (MCP).

The Model Context Protocol (MCP) is emerging as the standard way to connect tools to AI assistants. With Quarkus you can now expose your development tools directly as an MCP server through the Quarkus Dev UI. This opens the door to integrating your Quarkus applications with editors like Cursor or IDE extensions without extra glue code.

In this tutorial we’ll build a very simple Quarkus app, enable the Dev UI MCP server, and test the integration locally. No complex domain logic today. Just enough to help you understand how it works and how you can apply it to real applications later.

Prerequisites

Before you start, make sure you have:

• Java 17+

• Maven 3.9+.

• cURL for testing the MCP server.

• An editor like Cursor if you want to integrate MCP directly.

Bootstrap a Simple Quarkus Application

We’ll start with the simplest possible Quarkus app: a REST endpoint. Scaffold with the quarkus cli:

quarkus create app org.acme:very-simple-app:1.0.0 -x rest-jackson
cd very-simple-app

This generates a Quarkus project with RESTEasy Jackson support.

Open src/main/java/org/acme/GreetingResource.java and verify the endpoint:

package org.acme;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/hello")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from Quarkus REST";
    }
}

Build and run in dev mode. Start with Maven:

./mvnw quarkus:dev

Or use the quarkus cli

quarkus dev

Open http://localhost:8080/hello and you should see:

{"message":"Hello from Quarkus REST!"}

Enable the Quarkus Dev MCP Server

Quarkus Dev UI can now act as an MCP server. Configuration is simple: create a file in your home directory.

# ~/.quarkus/dev-mcp.properties
enabled=true

Restart the app in dev mode:

quarkus dev

Behind the scenes, Quarkus will now expose an MCP endpoint at:

http://localhost:8080/q/dev-mcp

Test the MCP Server with cURL

MCP uses JSON-RPC 2.0 over HTTP. You can send a request to list the available tools:

curl -X POST -H "Content-Type: application/json" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}' \
  http://localhost:8080/q/dev-mcp

Expected output (truncated for clarity):

{
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "devui-logstream_getLogger",
        "description": "The name of the logger",
        "inputSchema": {
          "required": [
            "loggerName"
          ],
          "type": "object",
          "properties": {
            "loggerName": {
              "description": "The name of the logger",
              "type": "string"
            }
          }
        }
      },

This shows your Quarkus app has been registered as an MCP tool.

Integrate with Cursor

To make this accessible in your AI-powered IDE (Cursor in this example), add the following snippet to your ~/.cursor/config.json:

"local-quarkus": {
  "transport": "http",
  "url": "http://localhost:8080/q/dev-mcp",
  "headers": {
    "Content-Type": "application/json"
  }
}

Restart Cursor and the assistant will be able to call your Quarkus MCP server.

Why This Matters

This simple setup shows how Quarkus can expose your app’s tools directly to AI-driven clients. Instead of writing one-off integrations, MCP gives you a standard way to connect:

• Developers get a consistent way to wire up Quarkus dev tools into their IDE.

• Teams can expose domain-specific tools (e.g., inventory queries, compliance checks) in the same way.

• Enterprises benefit from predictable and auditable integration patterns.

This isn’t just about toy endpoints. Imagine wiring your production observability or CI/CD checks into AI-driven workflows.

Try asking your AI assistant for the log history of your application.

You can also navigate to the Dev UI and list all the available MCP tools http://localhost:8080/q/dev-ui/devmcp/tools:

This is just the beginning. More extensions are probably going to expose tools via Quarkus. So watch this space for improvements going forward.

Next Steps

• Add your own tools by exposing more endpoints in Quarkus.

• Explore the Quarkus Dev MCP Guide.

• Watch out for releases on the quarkus.io/blog so you don’t miss a new MCP tool.

MCP turns your Quarkus app into a first-class citizen in the AI-powered developer ecosystem. Now you can experiment with real use cases in your own projects.

Quarkus is no longer just serving APIs. It’s serving context.