DEV Community: Praveen Gowthaman

How to Build and Connect an MCP Server with Quarkus and Claude

Praveen Gowthaman — Sun, 08 Mar 2026 15:39:52 +0000

Introduction

In this blog, we will walk through how to create a simple MCP server using Quarkus and explore how to integrate it with Claude Desktop.

Prerequisites

Before getting started, make sure you have:

A basic understanding of Java and Quarkus
Java 17 installed on your system
Claude Desktop installed
A basic understanding of LLMs (Large Language Models)

That’s it — once these are in place, we’re ready to start building our MCP server.

Creating the Quarkus Project

To get started, we first need to create a Quarkus project.

Navigate to https://code.quarkus.io in your browser.
Configure the project with the following settings:

Build Tool: Gradle
Java Version: 17
Group: <group-id-of-ur-choice>
Artifact: mcp-tutorial-app
1. Generate and download the project.

Once the project is downloaded, extract it and open it in your preferred IDE (IntelliJ IDEA or VS Code).

Adding Required Dependencies

Next, we need to add the dependencies required to build an MCP server and call external REST APIs.

Open the build.gradle file and ensure the following dependencies are present:

dependencies {
    implementation enforcedPlatform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")
    implementation enforcedPlatform("${quarkusPlatformGroupId}:quarkus-mcp-server-bom:${quarkusPlatformVersion}")

    implementation 'io.quarkus:quarkus-rest'
    implementation 'io.quarkus:quarkus-rest-client'
    implementation 'io.quarkus:quarkus-rest-client-jackson'
    implementation 'io.quarkiverse.mcp:quarkus-mcp-server-stdio'
    implementation 'io.quarkus:quarkus-arc'

    testImplementation 'io.quarkus:quarkus-junit5'
    testImplementation 'io.rest-assured:rest-assured'
}

These dependencies enable the following:

quarkus-rest – Allows us to expose REST endpoints.
quarkus-rest-client – Helps us call external APIs.
quarkus-rest-client-jackson – Provides JSON serialization support.
quarkus-mcp-server-stdio – Enables the application to run as an MCP server.
quarkus-arc – Provides dependency injection support in Quarkus.

Creating the REST Client

For this step, we will create a REST client to call the Quarkus Extensions API. Instead of creating everything from scratch, we can reuse the starter code that comes with the project generated from code.quarkus.io.

When you download the project from code.quarkus.io, it already includes a sample REST resource (MyRemoteService). We can use this starter project as a base and extend it to implement our REST client.

Quarkus provides support for REST clients using the MicroProfile REST Client specification, which makes it easy to call external APIs using simple Java interfaces.

This interface (MyRemoteService) is annotated with @RegisterRestClient. This interface will be responsible for calling the external Quarkus Extensions API and returning the extension details.

package com.praveen.tutorial;

import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.QueryParam;
import java.util.List;
import java.util.Set;

/**
 * To use it via injection.
 *
 * {@code
 *     @Inject
 *     @RestClient
 *     MyRemoteService myRemoteService;
 *
 *     public void doSomething() {
 *         Set<MyRemoteService.Extension> restClientExtensions = myRemoteService.getExtensionsById("io.quarkus:quarkus-hibernate-validator");
 *     }
 * }
 */
@RegisterRestClient(baseUri = "https://stage.code.quarkus.io/api")
public interface MyRemoteService {

    @GET
    @Path("/extensions")
    Set<Extension> getExtensionsById(@QueryParam("id") String id);

    public class Extension {
        public String id;
        public String name;
        public String shortName;
        public List<String> keywords;

        @java.lang.Override
        public java.lang.String toString() {
            return "Extension{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", shortName='" + shortName + '\'' +
                    ", keywords=" + keywords +
                    '}';
        }
    }
}

Implementing MCP Tools

Now that we have created the REST client, the next step is to expose functionality to Claude using MCP Tools.

MCP tools allow Claude (or any MCP-compatible client) to call specific methods in our application. These methods can perform actions such as calling APIs, retrieving data, or executing business logic.

Below is the class we will use to implement our MCP tool.

package com.praveen.tutorial;

import java.util.Set;
import jakarta.inject.Inject;
import org.eclipse.microprofile.rest.client.inject.RestClient;

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

import com.praveen.tutorial.MyRemoteService.Extension;
import com.praveen.tutorial.MyRemoteService;

public class ExtensionMCP {

    @RestClient
    @Inject
    MyRemoteService remoteService;

    @Tool(description = "Get the quarkus extension details using the query param called id")
    Set<Extension> getAlerts(
        @ToolArg(description = "String field describing quarkus id name eg:io.quarkus:quarkus-hibernate-validator")
        String id
    ) {
        return remoteService.getExtensionsById(id);
    }
}

Let’s understand each part of this class.

1. Dependency Injection with `@Inject`

@Inject

@Inject is provided by CDI (Contexts and Dependency Injection) in Quarkus.
It allows Quarkus to automatically create and manage the instance of the required class.

In this case, Quarkus injects the MyRemoteService REST client into our class so we can use it to call external APIs.

2. Using `@RestClient`

@RestClient

@RestClient tells Quarkus that the injected class is a MicroProfile REST Client.

This annotation ensures that the MyRemoteService interface is treated as a REST client capable of making HTTP calls to external APIs.

So when our MCP tool runs, it can call the external Quarkus extensions API through this client.

3. Declaring the MCP Tool with `@Tool`

@Tool(description = "Get the quarkus extension details using the query param called id")

@Tool is provided by quarkus-mcp-server and is used to expose a method as an MCP tool.

Once the application runs as an MCP server, Claude can discover and call this method.

The description field is important because it helps the LLM understand what the tool does.

4. Tool Arguments with `@ToolArg`

@ToolArg(description = "String field describing quarkus id name eg:io.quarkus:quarkus-hibernate-validator")

@ToolArg describes the input parameter that the tool expects.

This metadata helps the LLM understand:

what parameter the tool requires
the type of input expected
an example value

In this example, the tool expects a Quarkus extension ID.

5. Returning the Extension Data

Set<Extension>

The method returns a Set of Extension objects.
The Extension class is defined inside the MyRemoteService interface and represents the structure of the response returned by the Quarkus extensions API.

6. Calling the REST Client

return remoteService.getExtensionsById(id);

Finally, the MCP tool calls the REST client method getExtensionsById() and returns the results.

When Claude invokes this MCP tool, the flow works like this:

Claude calls the MCP tool getExtensionsById
The tool receives the extension id
The REST client calls the external API
The API response is returned back to Claude

Building the Application as an Uber JAR

Once the MCP tool implementation is complete, the next step is to package the application as a single runnable JAR, also known as an Uber JAR.

An Uber JAR bundles the application along with all its dependencies into a single executable file. This makes it easy to distribute and run the application without needing to manage external libraries separately.

To enable Uber JAR packaging in Quarkus, add the following configuration to the application.properties file:

quarkus.package.jar.type=uber-jar

After adding this configuration, build the project using the Gradle command below:

./gradlew build

For Windows users:

gradlew build

Once the build completes successfully, the Uber JAR will be generated inside the build directory.

The generated file will look similar to:

build/mcp-tutorial-app-1.0.0-SNAPSHOT-runner.jar

This JAR file contains the entire application and can be executed using the following command:

java -jar build/mcp-tutorial-app-1.0.0-SNAPSHOT-runner.jar

At this point, our MCP server is packaged and ready to be integrated with Claude Desktop.

Integrating the MCP Server with Claude Desktop

Now that our MCP server has been packaged as an Uber JAR, the next step is to integrate it with Claude Desktop so that Claude can discover and use the MCP tools we created.

Claude Desktop loads MCP servers through a configuration file called claude_desktop_config.json. By adding an entry for our server in this file, we instruct Claude to start our MCP server when the application launches.

Locating the Configuration File

On Windows, the configuration file is located at:

C:\Users\<your-username>\AppData\Roaming\Claude\claude_desktop_config.json

Open this file using any text editor such as VS Code or Notepad.

Adding the MCP Server Entry

Inside the configuration file, add a new entry under the mcpServers section that points to the Uber JAR we built earlier.

{
  "mcpServers": {
    "mcptutorial": {
      "command": "java",
      "args": [
        "-jar",
        "C:\\Users\\<your-username>\\projects\\mcp-tutorial-app\\build\\mcp-tutorial-app-1.0.0-SNAPSHOT-runner.jar"
      ]
    }
  }
}

Understanding the Configuration

mcpServers – This section defines all MCP servers that Claude Desktop should load.
mcptutorial – A name used to identify our MCP server.
command – The command used to start the server. In this case, we run the JAR using java.
args – Arguments passed to the command. Here we provide -jar followed by the path to our Uber JAR.

Applying the Changes

After saving the configuration file:

Close Claude Desktop if it is running.
Restart Claude Desktop.

When Claude starts again, it will automatically launch the MCP server defined in the code

Now let us prompt Claude and see the toll call being made

References

https://quarkus.io/blog/mcp-server/
https://docs.quarkiverse.io/quarkus-mcp-server/dev/index.html

Exploring OpenClaw: From Multi-Bot Concept to Actionable AI Agent

Praveen Gowthaman — Wed, 25 Feb 2026 16:08:56 +0000

Recently, I spent some time exploring OpenClaw — an open-source, agentic AI assistant that goes beyond chat and actually executes tasks.

Unlike traditional LLM chat interfaces, OpenClaw operates more like an autonomous agent. It can connect to messaging platforms (like Telegram), execute commands, manage reminders, perform searches, and automate workflows.

Think of it as:

🧠 AI brain + 💻 Command layer + 📲 Messaging interface

What Makes OpenClaw Interesting?
OpenClaw started as a multi-bot framework and evolved into a more unified, agent-driven system. The core idea is simple:

Instead of asking AI questions, you assign it actions.

It runs locally or on a server and connects through APIs and messaging bots.

Running OpenClaw (Example via CMD)
Here’s what a typical startup might look like from the command line:

$ python main.py

Starting OpenClaw...
Loading agent modules...
Connecting to Telegram bot...
OpenClaw is ready to assist.

Once running, you can issue structured commands:

cmd> /agenda today

Response:

Today's Agenda:
- 10:00 AM - Team Meeting
- 1:30 PM - Client Call
- 4:00 PM - Project Deadline

Setting a reminder:

cmd> /remind 6pm "Submit timesheet"

Response:

Reminder set for 6:00 PM - Submit timesheet

Web search example:

cmd> /websearch "latest AI agent frameworks"

Telegram Integration

One powerful feature is Telegram bot integration.

Setup flow:

Create a bot using @botfather
Copy the generated bot token
Add it to your environment configuration:

export TELEGRAM_BOT_TOKEN=your_token_here

Restart OpenClaw

Now you can interact directly from Telegram:

You:

What's on my schedule today?

Bot:

Here’s your agenda:
✔ 10 AM - Team Sync
✔ 1:30 PM - Client Call
✔ 4 PM - Project Deadline

This turns Telegram into a command console for your AI agent.

Why This Matters

We’re moving from: Chatbots ➝ Task bots ➝ Autonomous agents

The real shift isn’t just AI answering questions.

It’s AI:

Managing workflows
Triggering automations
Acting on structured commands
Integrating into daily tools

That’s where systems like OpenClaw become powerful.

Important Consideration

Agent-based systems can access local environments and APIs. Always:

Use sandbox environments
Limit permissions
Protect API tokens
Avoid connecting sensitive work systems without review

Final Thought

OpenClaw represents a shift toward AI that executes, not just converses.

We’re entering an era where:

Your messaging app becomes your control panel Your AI becomes your operations assistant

Exciting space to watch.

Would love to hear if others are experimenting with agentic AI frameworks.

Java 8 - BiConsumer interface

Praveen Gowthaman — Tue, 13 Apr 2021 10:06:24 +0000

What is Bi-Consumer interface ?

Bi-Consumer interface is one of the functional interfaces that Java 8 provides. It is present in java.util.function package.

It is quite similar to consumer interface, just that it accepts two parameters.

    @FunctionalInterface
    public interface BiConsumer<T,U>

Since it is a functional interface it has only one method definition . That method is called Accept.

We all know functional interfaces can have default methods also . So here we have a default method called andThen .

What are the methods of the Bi-Consumer interface ?

Accept :

void accept(T t,U u)

The accept method accepts two input parameter and performs a user defined operation on them.

AndThen :

default BiConsumer<T,U> andThen(BiConsumer<? super T,? super U> after)

The andThen method takes in a Bi-Consumer as an input and it runs it after the Bi-Consumer it is called upon.

Let us look at few examples !!!!!!

First lets look at the example of accept method . It accepts two values and performs given operation on them .

    Class BiConsumerExample{

        public static void main(String[] args){

              BiConsumer<String,String> consumer= (s,s1)->System.out.println(s+"

                "+s1);

              consumer.accept("Hello","World");

        }

   }

   o/p = Hello World

Now let us look at an example of the andThen method of the BiConsumer interface.

Class BiConsumerExample{

        public static void main(String[] args){

              BiConsumer<String,String> consumer1= (s,s1)->System.out.println(s+" "+s1);

              BiConsumer<String,String> consumer2= (s2,s3)->System.out.println(

               s2.toUpperCase(),s3.toUpperCase());

              consumer1.andThen(consumer2).accept("Hello","World");

        }

   }

     o/p :

     Hello World

     HELLO WORLD

Let us look at above example.

First we are creating one consumer called consumer1 which takes in two strings and just prints them.

Next we are creating one more consumer called consumer2 which takes in two string converts the strings to uppercase and then prints the strings.

Next we want to make consumer1 run first and then we want to make consumer2 run.

So we do consumer1.andThen(consumer2) which achieves that .

Next we need to pass some input to perform this operation so we make use of accept method of consumer as below .

consumer1.andThen(consumer2).accept("Hello","World");

Note: Kindly correct me in any info that is wrong on above blog . I am happy to learn .

Also kindly have a look at my blog :)

[https://praveen075.blogspot.com/2021/04/introduction-to-java-8-in-laymans-terms_13.html]

Thank you

Introduction to Java 8 in Layman's terms - Functional Interface - Consumer Interface

Praveen Gowthaman — Wed, 07 Apr 2021 05:10:30 +0000

Hi All !!!!

Want to learn about Java's Consumer functional interface then check the link below .....

https://praveen075.blogspot.com/2021/04/introduction-to-java-8-in-laymans-terms_6.html

Introduction to Java 8 in Layman's terms - Lambda expression & Functional interfaces basics

Praveen Gowthaman — Mon, 05 Apr 2021 16:52:25 +0000

Here is my blog post on some basic knowledge of Lambda expression & Functional interfaces.

It's totally from a beginner's perspective. Kindly have a look. Hope you guys like it .....

Let me know if I have got something wrong ... Happy to correct it ....

introduction-to-java-8-in-laymans-terms.html