From Scratch to Scalable: Building Smarter AI Agents with Frameworks

This workshop guides Java developers from manually building a basic AI agent with LLM integration and conversational memory to transforming it into a scalable, production-ready solution using agent frameworks, highlighting the added benefits of multi-LLM support, observability, and simplified deployment for real-world applications.

Detailed Description

It doesn’t take much to build a simple AI agent — with just basic programming skills, you can create one from scratch without using any frameworks. But moving from a working prototype to a production-ready agent introduces a whole new level of complexity.

In this hands-on workshop, you’ll start by building your own AI agent in Java. You’ll implement LLM integration, tool calling, and manage conversational history — all from the ground up. This gives you a deep understanding of how agents operate under the hood.

With that foundation, you’ll then transition to using an agent framework. You’ll learn how frameworks simplify the development process by handling complexity like multi-LLM support, observability, memory, and deployment. By the end, you’ll have transformed your home-grown agent into one that’s framework-ready and production-capable.

Key Takeaways:

Understand the core components of an AI agent by building one manually.
Learn how to integrate LLMs, tools, and memory in Java.
Gain experience with agent frameworks to support scalability and production use.

Target Audience:
Java developers who are curious about AI agents and want hands-on experience creating, understanding, and scaling them for real-world applications.

Bring a crew to do your job

Everybody is talking about AGI, Artificial General Intelligence, or one AI Model that can do everything. Looking at real-world scenarios, there is not one person who can do everything. It takes teamwork to get things done. I see the exact solution for AI. You need a team, a crew, or a swarm to get things done.

Discover the power of multi-agent AI systems, where multiple agents collaborate to tackle challenges too complex for a single model. This talk will introduce core concepts of multi-agent systems, highlight some use cases, and feature a live demo showcasing agents working together in real-time. Learn how cooperative AI can create adaptive, resilient solutions to real-world problems.

Audience Takeaways: Attendees will gain a practical understanding of multi-agent AI systems, insights into real-world applications, and inspiration for how cooperative AI can address complex challenges in their work.

Build the best knowledge retriever for your Large Language Model.

Generative AI is here to stay. Tools to generate text, images, or data are now common goods. Large Language models (LLMs) only have the knowledge they acquired through learning, and even that knowledge does not include all the details. To overcome the knowledge problem, the Retrieval Augmented Generation (RAG) pattern arose. An essential part of RAG is the retrieval part. Retrieval is not new. The search or retrieval domain is rich with tools, metrics and research. The new kid on the block is semantic search using vectors. Vector search got a jump start with the rise of LLMs and RAG.
This workshop aims to build a high-quality retriever, integrate the retriever into your LLM solution and measure the overall quality of your RAG system.
The workshop uses our Rag4j/Rag4p framework, which we created especially for workshops. It is easy to learn, so you can focus on understanding and building the details of the components during the workshop. You experiment with different chunking mechanisms (sentence, max tokens, semantic). After that, you use various strategies to construct the context for the LLM (TopN, Window, Document, Hierarchical). To find the optimum combination, you'll use quality metrics for the retriever as well as the other components of the RAG system.
You can do the workshop using Python or Java. We provide access to a remote LLM. You can also run an open-source LLM on Ollama on your local machine.

The Art of Questions: Creating a Semantic Search-Based Question-Answering System with LLMs

Ever thought about building your very own question-answering system? Like the one that powers Siri, Alexa, or Google Assistant? Well, we've got something awesome lined up for you!

In our hands-on workshop, we'll guide you through the ins and outs of creating a question-answering system. We prefer using Python for the workshop. We have prepared a GUI that works with python. If you prefer another language, you can still do the workshop, but you will miss the GUI to test your application. You'll get your hands dirty with vector stores and Large Language Models, we help you combine these two in a way you've never done before.

You've probably used search engines for keyword-based searches, right? Well, prepare to have your mind blown. We'll dive into something called semantic search, which is the next big thing after traditional searches. It’s like moving from asking Google to search "best pizza places" to "Where can I find a pizza place that my gluten-intolerant, vegan friend would love?" – you get the idea, right?

We’ll be teaching you how to build an entire pipeline, starting from collecting data from various sources, converting that into vectors (yeah, it’s more math, but it’s cool, we promise), and storing it so you can use it to answer all sorts of queries. It's like building your own mini Google!

We've got a repository ready to help you set up everything you need on your laptop. By the end of our workshop, you'll have your question-answering system ready and running.

So, why wait? Grab your laptop, bring your coding hat, and let's start building something fantastic together. Trust us, it’s going to be a blast!

Some of the highlights of the workshop:

Use a vector store (OpenSearch, Elasticsearch, Weaviate)
Use a Large Language Model (OpenAI, HuggingFace, Cohere, PaLM, Bedrock)
Use a tool for content extraction (Unstructured, Llama)
Create your pipeline (Langchain, Custom)

This is a workshop

EventStorming, from Knowledge to Working Domain Model

Two brains, one domain, one laptop, and a guarantee for a day of fun and learning. You’ll go back to basics. Talking about the domain, exploring it using EventStorming with a small group and then pair up to design and code the model.

## Agenda:
The day starts with an EventStorming session to explore an interesting domain. You will work in small groups, making sure everyone in the group guards a portion of the EventStorming session by taking on specific roles. But we won't stop after we've explored the domain.
During the second part of the day you will work in pairs, together with other participants. You will use the output of the EventStorming session and all the knowledge that you've gathered about the domain. Together, you'll play around, modeling parts of the domain in code, using tests to guide your design. You can choose from several starter templates, to help you code the domain using different approaches. From a typical object oriented domain model to an event sourced domain model. Throughout the workshop, pairs will share their approach so we can all learn from each other.

All you have to bring is a laptop with a recent version of IntelliJ installed (only one laptop per pair is needed). Java or Kotlin templates will be provided, or you can choose to use your own preferred stack.

## What you will learn:
- Why you need to start by understanding the problem and exploring a domain before you start coding.
- How to 'sketch' in code and tease out a model bit by bit.
- Not to be afraid to throw away the model and sketch again.
- That there are many ways to implement a model and that there are tradeoffs to make when choosing an approach.

Especially the part where pairs share and explain their approach is really insightful and helps to realize that there are many (good) solutions to a problem. It also creates a lot of interaction between participants which always makes for many views being shared and for lively discussions.

The Good, the Bad and the Ugly data

In the cinematic masterpiece "The Good, the Bad, and the Ugly," characters mirror the nuances of data in analysis. "The Good" stands for high-quality, reliable data with a clear lineage; "The Bad" signifies anomalies in need of valorization efforts; and "The Ugly" represents unstructured data with hidden potential.

This presentation explores strategies for identifying and extracting the gold nuggets of insight from the "Ugly" data while mitigating the influence of the "Bad" data. We show data cleaning, validation, transformation, and presentation techniques to turn ugly data into good data, remove bad data and extract value from the good data.