DEV Community: David Brown

Building a multi-step AI agent in Java with Spring AI 2.0

David Brown — Tue, 30 Jun 2026 19:02:21 +0000

I wanted to try Spring AI's agentic tooling on something that resembles a real production project rather than the usual weather-API call, so I built an example Spring Boot API: a civic research assistant. You give it a plain-English issue and a UK postcode, and it works out the most effective way to raise that issue with Parliament. It uses an LLM (ChatGPT) along with the free UK postcode and Open Parliament APIs. The flow isn't dictated in code. We register a handful of @Tool methods (resolve the postcode, find the MP, search bills, find committees and open inquiries, check the voting record) and let the model decide which to call and in what order. It chains them itself and returns a final answer with a citation on every claim. The stack is Java 25, Spring Boot 4.1 and Spring AI 2.0.
The full tutorial walks through the Spring AI 2.0 tool-calling setup and what changed since 1.x, registering the tools, getting structured typed output back instead of free text, and a small guard that checks every citation actually came from a tool call so the model can't quietly invent a source. It's all runnable, with the complete code on GitHub.

Full tutorial: https://tucanoo.com/building-an-agentic-workflow-in-java-multi-step-ai-agents-with-spring-ai-and-tool-calling/
Source: https://github.com/tucanoo/spring-ai-civic-research-assistant

If you're using Spring AI's tool calling on anything that touches real data, I'd be interested in how you're handling grounding to keep the model from citing things it never fetched.

The Big Beautiful Bot - A Spring Boot & LLM Chatbot with SSE -> Next.js

David Brown — Fri, 26 Jun 2026 07:16:09 +0000

There's not much material out there showing how to use SSE (Server-Sent Events) with a Spring Boot back end connected to an LLM to power a ChatGPT-style Next.js front end, so I put together a full tutorial on it, with the complete code repository as always.

Tutorial -> https://tucanoo.com/streaming-llm-responses-end-to-end-a-spring-boot-sse-backend-and-a-next-js-frontend/
Repo -> https://github.com/tucanoo/streaming-llm-spring-next

Virtual Threads in Spring Boot 4: I rewrote a blocking service and measured everything

David Brown — Sun, 21 Jun 2026 09:52:15 +0000

I took one realistic blocking Spring Boot 4 service — a PostgreSQL query through HikariCP plus a downstream HTTP call — flipped spring.threads.virtual.enabled=true, and benchmarked exactly what changed: throughput, tail latency, and where the bottleneck went.

TL;DR: ~6× throughput at 2,500 concurrent users from one flag — but the connection pool quietly becomes your new ceiling, so you have to resize it. I also measured the JEP 491 pinning change (the "avoid synchronized" advice is now out of date).

Full write-up, raw data, charts and a reproducible repo on the Tucanoo blog

👉 https://tucanoo.com/virtual-threads-in-spring-boot-4

Localised notifications with Firebase cloud messaging (FCM)

David Brown — Wed, 09 Nov 2022 09:08:05 +0000

If you need to send localised push notifications from a Java server side application to mobile devices with Firebase Cloud Messaging (FCM), whether your server side is Grails, Spring boot or any other Java based framework utilising the Firebase (Admin) SDK then search no more as it's not so clear in the official documentation. Most examples focus on the REST or JS implementations.

In my use case, I wanted to alert users subscribing to a specific Topic of a particular event. Users of this app are distributed globally so it was important to localise the messages depending on the users locale according to their device. From the server side, I just want to generate the notification and let Firebase's servers handle the notifications to each device subscribed to the topic and then the device it self display a locales message, both the title and subtitle, on both Android and IOS devices.

Fortunately Firebase lets us do this by specifying localised 'keys', instead of specifying the title and body. However finding an example was more of a struggle as the documentation is somewhat lacking.

What we have to do is establish Options objects for each platform, i.e. one for Android and one for Apple devices and then deep within nested Builders we can finally set the localised keys. These then can be interpreted from the resources within the mobile App itself and will be displayed to the user, both when the app is in the foreground AND also when it's in the background.

So without further ado, let's look at the code:

Note: I'm omitting the rest of the app code assuming you already know how to setup Firebase etc and just need to see how to generate the notification.

void sendLocalisedNotification(String topic, String titleKey, String bodyKey) {
        // Set localisation key for Android
        AndroidConfig androidConfig = AndroidConfig.builder()
            .setNotification(
                AndroidNotification.builder()
                    .setTitleLocalizationKey(titleKey)
                    .setBodyLocalizationKey(bodyKey)
                    .build()
            ).build()

        // Set localisation key for Apple devices
        ApnsConfig apnsConfig = ApnsConfig.builder()
            .setAps(Aps.builder()
                .setAlert(ApsAlert.builder()
                    .setTitleLocalizationKey(titleKey)
                    .setSubtitleLocalizationKey(bodyKey)
                    .build()
                ).build()
            ).build()

        Message message = Message.builder()
            .setTopic(topic)
            .setAndroidConfig(androidConfig)
            .setApnsConfig(apnsConfig)
            .build();

        // And then send the message to the devices subscribed to the provided topic.
        try {
            String response = FirebaseMessaging.getInstance().send(message);

            // Response is a message ID string.
            log.debug("Firebase message $topic sent: " + response);
        } catch (Exception ex) {
            log.warn("Firebase message $topic failed: " + ex.message);
        }
    }

So that's the gist of it, this method can be called with the topic we want to publish to, the title key and the body key.

I hope this helps save someone time discovering how to accomplish localised messages under a Java environment using the FCM SDK.

Dave / Tucanoo Solutions

Super Fast Prototyping with Grails Tutorial Available

David Brown — Wed, 12 Feb 2020 08:39:54 +0000

One of the greatest benefits of the Grails framework is how it allows you to put together a Proof Of Concept(POC) or a web app prototype in such a short period time.

In a current world where there is lots of focus on UI frameworks and microservice architectures, sometimes, you just need to build something quickly without worrying about different front and backend layers.

Grails allows you to build apps fast, but with the benefit of sitting on top of the most robust Java-based libraries in existence, Spring, Hibernate, etc. etc.

In this tutorial, you'll see how to build a simple CRM backed by a H2 in-memory database, prepopulating itself with 1000 fictitious records.

The user is provided with basic CRUD screens, create, edit, and a rich Datatables based list screen to allow filtering, sorting and ajax driven paging of the customer records.

Download full source on github Download the full source on github

and Read the full tutorial