Training course · RAG & LLM Applications · Java & Spring

RAG & LLM Applications for Java and Spring Developers

Develop RAG and LLM applications: embeddings, vector databases, chunking, retrieval, evaluation, cost control and data protection.

Duration
2 days (14 hrs)
Format
Online or on-site
Language
German or English
Participants
open dates or exclusive for your team
Certificate
Certificate of attendance

Overview

This course connects RAG & LLM Applications with the everyday processes of Java & Spring. Participants work on realistic scenarios and leave with prompts, workflows and checklists they can use straight away.

Retrieval-augmented generation connects language models to your own knowledge: manuals, contracts, tickets, wikis or product data are made searchable and handed to the model as context at runtime. The result is assistants that give grounded answers with citations instead of hallucinating. In this two-day course you build a complete RAG pipeline, from document preparation through embeddings and a vector database to answer generation, and you learn which levers actually determine quality.

Day two takes you from prototype to robust application. You compare chunking strategies, combine semantic and lexical search, apply reranking, metadata filters and query rewriting, and measure the effect with systematic evaluations. You also cover prompt caching, cost control, latency optimisation, document-level access control and privacy-compliant operation with an eye on GDPR and the EU AI Act. By the end you know when classic RAG is enough, when a large context window or agentic retrieval is the better option, and how to justify your architecture choices.

Java and Spring carry business-critical systems in many organisations: banking back ends, ERP integrations, public-sector applications and large microservice estates. These systems have often grown over many years, and modernisation never stops. AI coding assistants and agents change the heaviest routine work in particular: major Spring Boot upgrades including the javax-to-jakarta switch, JUnit and Mockito tests for poorly covered code, refactorings towards records and modern language features, and analysis of stack traces and Hibernate issues. Clear guardrails are essential: build tool, module structure, architecture rules and test strategy all need to be in context. This course shows you how to use agents productively and in a controlled way in Maven or Gradle projects.

The course is delivered live – either online in a virtual classroom or on-site in our training rooms in Munich, Salzburg, Berlin, Augsburg, Hanover, Bremen, Stuttgart and Kaiserslautern. We can also run it exclusively for your team.

Who is this course for?

  • Java back-end developers using Spring Boot or Jakarta EE
  • Teams modernising legacy Java applications
  • Software architects for enterprise and microservice landscapes
  • Developers in banking, insurance and the public sector
  • Tech leads responsible for upgrades and technical debt

Typical challenges we address

  • Laborious framework and JDK upgrades with numerous breaking changes
  • Large legacy codebases with low test coverage and tight coupling
  • Hard-to-analyse performance issues in JPA, Hibernate and transactions
  • Heavy boilerplate in configuration, mapping and interface code

What you will be able to do

  • You build a complete RAG pipeline from document preparation to answers with citations.
  • You choose embedding model, chunking strategy and vector database on solid grounds.
  • You improve retrieval quality with hybrid search, reranking and metadata filters.
  • You measure application quality with systematic evaluations and detect regressions.
  • Use AI agents for Spring Boot upgrades, refactorings and test generation in Maven and Gradle projects.
  • Diagnose Hibernate, performance and production issues faster with AI support.
  • Embed architecture rules and quality standards so that generated Java code adheres to them reliably.

Course outline

Day 1

Module 1 Foundations of RAG and LLM applications
  • Anatomy of a RAG pipeline: ingestion, indexing, retrieval, generation
  • Understanding embeddings: semantic similarity, dimensions, model selection
  • Weighing RAG against fine-tuning and long context windows
  • Structured outputs, citations and dealing with hallucinations
Module 2 Document preparation and chunking
  • Reliably extracting PDFs, Office documents, HTML and tables
  • Chunking strategies: fixed size, structure-aware, semantic, with overlap
  • Enriching metadata and generating contextual summaries per chunk
  • Incremental updates and deletion of documents in the index
Module 3 Vector databases and retrieval strategies
  • Comparing vector databases and extensions such as pgvector, Qdrant, Weaviate or OpenSearch
  • Hybrid search combining vector and full-text search with BM25
  • Reranking, metadata filtering and query rewriting
  • Agentic retrieval: letting the model decide on search steps and tools
Module 4 Evaluation and quality assurance
  • Building and maintaining test sets from real user questions
  • Retrieval metrics such as recall and precision, and answer metrics such as faithfulness
  • Using and calibrating LLM-as-a-judge sensibly
  • Regression testing when chunking, model or prompt changes

Day 2

Module 5 Operations, cost and data protection
  • Prompt caching, batch processing and model choice to cut costs
  • Optimising latency and streaming responses
  • Document-level permissions, tenant isolation and protection against prompt injection
  • Data protection: data residency, processing agreements, deletion policies, GDPR and the EU AI Act
Module 6 Practice lab: Java & Spring
  • Driving a Spring Boot upgrade
  • Generating JUnit and Mockito tests
  • Refactoring legacy code
  • Analysing JPA and Hibernate issues
  • REST APIs and interfaces
  • Making sense of stack traces and production errors
Module 7 Data protection, quality & transfer to daily work
  • Java systems often run in regulated sectors: agree with information security and data protection which code may be sent to external models, and take requirements such as DORA, NIS2 or national banking IT rules into account. Generated code and new Maven dependencies should be checked for licences and known vulnerabilities and recorded in an SBOM.
  • Ground rules for safe AI use in your team
  • Checking results: facts, sources, tests and the four-eyes principle
  • Personal action plan for the next 30 days
  • Open questions, outlook and resources for further learning

Practical scenarios from your field

Driving a Spring Boot upgrade

The agent analyses dependencies, applies OpenRewrite recipes, switches javax packages to jakarta, adapts deprecated configuration and security setups and iterates over build and tests until the application is green again.

Generating JUnit and Mockito tests

Services and controllers get unit tests with JUnit and Mockito plus slice tests using WebMvcTest or DataJpaTest. The AI deliberately raises coverage on critical paths and documents test assumptions.

Refactoring legacy code

Large classes are split up, DTOs turned into records, null checks replaced with Optional and streams used where they help. Existing tests safeguard behaviour at every step.

Analysing JPA and Hibernate issues

The AI reads SQL logs and stack traces, spots N+1 queries, LazyInitializationExceptions and poor fetch strategies, and proposes entity graphs, projections or index changes. Each optimisation is backed by SQL logs.

REST APIs and interfaces

OpenAPI specifications are turned into controllers, DTOs, MapStruct mappers and Bean Validation, complete with consistent error handling via ControllerAdvice and integration tests. Existing package and naming conventions are respected.

Making sense of stack traces and production errors

Long stack traces, thread dumps and log excerpts are summarised, the likely root cause is narrowed down and a reproducing test case plus fix is proposed.

Possible hands-on projects

Spring Boot microservice

A REST service with Spring Data JPA, Flyway migrations, Bean Validation, Actuator endpoints and Testcontainers tests, developed entirely by an AI agent from a specification.

Dependency report for Maven and Gradle

A command-line tool that analyses build files, lists outdated and vulnerable libraries and describes upgrade paths along with expected breaking changes.

Architecture rule checks

An ArchUnit test suite that automatically enforces your project’s layering rules, package dependencies and naming conventions and runs in the CI pipeline.

Prerequisites

Solid programming skills in Python (or TypeScript as an alternative), basic knowledge of databases and REST APIs, and some experience with LLM APIs. In-depth Java knowledge and practical experience with Spring Boot or Jakarta EE, Maven or Gradle and Git.

Technical requirements

A laptop with Python, Git, Docker and a code editor, plus API access to at least one LLM and embedding provider. Credentials for the exercises can be provided if needed.

Data protection & compliance

Java systems often run in regulated sectors: agree with information security and data protection which code may be sent to external models, and take requirements such as DORA, NIS2 or national banking IT rules into account. Generated code and new Maven dependencies should be checked for licences and known vulnerabilities and recorded in an SBOM.

Suggested dates

All dates are suggestions – your preferred date is always possible.

  • Mon, 23 November 2026 – Tue, 24 November 2026 Online Request
  • Tue, 1 December 2026 – Wed, 2 December 2026 Kaiserslautern Request
  • Wed, 9 December 2026 – Thu, 10 December 2026 Online Request
  • Tue, 15 December 2026 – Wed, 16 December 2026 Bremen Request
  • Thu, 14 January 2027 – Fri, 15 January 2027 Online Request
  • Tue, 19 January 2027 – Wed, 20 January 2027 Salzburg Request

Frequently asked questions

When is RAG better than fine-tuning?

RAG is the right choice when a model needs access to current, extensive or frequently changing knowledge and should cite its sources. Fine-tuning mainly changes style, format or specialised behaviour. In many projects RAG is the faster, cheaper and more controllable route, sometimes complemented by fine-tuning for niche tasks.

Which vector database should we use?

That depends on data volume, existing infrastructure, filtering needs and operating model. If you already run PostgreSQL, pgvector often takes you a long way, while specialised systems shine with large datasets and hybrid search. In the course you compare several options hands-on and derive criteria for your own decision.

How can RAG be run in a GDPR-compliant way?

Key factors are choosing providers with suitable data residency and a data processing agreement, enforcing document-level permissions, having a deletion policy for the index and logs, and minimising personal data. For highly sensitive data, self-hosted models are also an option. We work through these choices using realistic architectures.

Can an AI agent carry out a major Spring Boot upgrade on its own?

An agent can take on much of the mechanical work – package switches, configuration changes and iteratively fixing compile and test failures – especially when combined with OpenRewrite. Architecture decisions, functional sign-off and testing in realistic environments remain the team’s job. On the course you practise this workflow on a sample project.

Is AI-assisted coding allowed in regulated environments?

In principle yes, but with clear rules. What matters is the choice of provider and operating model, contractual commitments on data use, approval processes and traceable reviews. We discuss how banks, insurers and public authorities typically approach this and which questions you should settle with your information security team.

How much does “RAG & LLM Applications for Java and Spring Developers” cost?

The course costs a flat €949 plus VAT per participant – whether online or on-site. This includes 2 training day(s) with a live trainer, course materials, a lab environment and a certificate of attendance.

Can I suggest my own date?

Yes. Our suggested dates are just a guide. In the request form you can always describe your preferred date or period in free text – we check availability and confirm within one working day.

Is the course online or on-site?

Both are possible: live online in a virtual classroom or on-site in Munich, Salzburg, Berlin, Augsburg, Hanover, Bremen, Stuttgart or Kaiserslautern. We can also run the course exclusively for your team.

More courses for Java and Spring Developers

More RAG & LLM Applications courses

All 29 RAG & LLM Applications courses

RAG & LLM Applications · MunichRAG & LLM Applications · SalzburgRAG & LLM Applications · BerlinRAG & LLM Applications · AugsburgRAG & LLM Applications · HanoverRAG & LLM Applications · BremenRAG & LLM Applications · StuttgartRAG & LLM Applications · KaiserslauternRAG & LLM Applications · Online