Our Blog

Sharing Our Experiences

Introductie in Spring AI

Generatieve AI integreren in een Java-applicatie kan heel eenvoudig starten: je roept een model aan, geeft een prompt mee en krijgt een antwoord terug. Maar zodra use cases rijker worden, met domeincontext, documentatie, conversatiegeschiedenis of koppelingen met externe systemen, verschuift de uitdaging van een losse prompt naar applicatiearchitectuur. Dan gaat het niet alleen meer om tekstgeneratie, maar ook om retrieval, tools, MCP-integraties en, waar relevant, verdergaande orchestratie via agents of workflows.

Spring AI sluit daar goed op aan. Het biedt een set bouwstenen die past binnen vertrouwde Spring-principes zoals abstractie, dependency injection, portability, werken met POJO’s en een duidelijke scheiding van verantwoordelijkheden. Tegelijk voorziet het een abstractielaag over AI-modellen, ondersteuning voor verschillende providers en componenten zoals ChatClient, structured output, advisors, embeddings en vector stores.

Die combinatie maakt het mogelijk om AI-functionaliteit op te nemen in een bestaande applicatie zonder het ontwerp volledig te herdenken. In plaats van de logica hard te koppelen aan één model of aanbieder, blijft de applicatie opgebouwd rond herkenbare Spring-concepten. Dat verlaagt de instap, maar laat tegelijk voldoende ruimte om door te groeien van eenvoudige modelinteracties naar meer geavanceerde scenario’s waarin context, retrieval en externe capabilities een centrale rol spelen.

Een eenvoudige start met ChatClient

Een eerste integratie kan bewust klein blijven. Een basisopzet vertrekt van een standaard Spring Boot-project, modelconfiguratie in de properties en een controller of service die een ChatClient.Builder injecteert. Van daaruit kan een eenvoudige prompt naar het model gestuurd worden en het antwoord rechtstreeks teruggegeven worden aan de frontend. De centrale bouwsteen daarin is de ChatClient API, aangevuld met de mogelijkheid om een defaultSystem message mee te geven om de context van de client af te bakenen.

Die aanpak is vooral interessant omdat ze geen uitzonderlijk programmeermodel introduceert. Een AI-integratie voelt hier niet aan als een los experiment naast de applicatie, maar als een extra capability binnen een vertrouwde service- en controllerstructuur. Door ook logging of advisors toe te voegen, wordt het makkelijker om de onderliggende flow zichtbaar te maken en het gedrag van prompts en responses te analyseren.

Prompt stuffing: gerichte context meegeven

Een eenvoudige prompt volstaat zelden zodra een toepassing meer domeinspecifieke antwoorden moet geven. Een voor de hand liggende eerste stap is dan extra context meesturen met de vraag. Spring AI ondersteunt dat via prompt templates waarin een instructie, variabele context en een variabele vraag gecombineerd worden. Ook expliciete guardrails zoals “If you don’t know…” zijn nuttig om hallucinaties te beperken en het model af te remmen wanneer de nodige informatie ontbreekt.

Dat is relevant omdat LLM’s pre-trained zijn en een cut-off date hebben. Recente gebeurtenissen, productinformatie, bedrijfsspecifieke gegevens en actuele documentatie zitten dus niet vanzelf in het model. Door die context expliciet toe te voegen, verhoog je de kans op een antwoord dat inhoudelijk beter aansluit op de toepassing. Tegelijk blijft dit vooral geschikt voor eenvoudige scenario’s. Zodra de hoeveelheid context groeit, komen beperkingen rond context windows, tokens en kost onvermijdelijk in beeld.

Chat memory: geschiedenis als context, niet als leren

Een terugkerend misverstand bij generatieve AI is dat een model “bijleert” uit een gesprek. In de praktijk zijn LLM’s stateless. Wat voor een gebruiker als geheugen aanvoelt, is meestal conversational history die opnieuw als extra context wordt meegestuurd. Dat onderscheid is belangrijk, omdat het meteen duidelijk maakt wat chat memory wel en niet oplost. Het maakt gesprekken consistenter, maar verandert niets aan het onderliggende karakter van het model.

Spring AI ondersteunt dit via advisors. Voorbeelden daarvan zijn MessageChatMemoryAdvisor, InMemoryChatMemory en de default advisors die aan een ChatClient gekoppeld kunnen worden. Op die manier kan een client bijvoorbeeld de laatste berichten uit een gesprek meenemen, zodat vervolgvraag en antwoord beter op elkaar aansluiten. Dat levert een natuurlijkere interactie op, zonder te suggereren dat het model zelf permanent nieuwe kennis heeft opgeslagen.

Wanneer prompt stuffing niet meer volstaat

Zolang het om beperkte hoeveelheden context gaat, werkt prompt stuffing vaak goed. Die aanpak wordt minder houdbaar zodra een toepassing grote hoeveelheden documentatie moet raadplegen. Denk aan honderden of duizenden pagina’s tekst, productinformatie of interne kennisbronnen. In zulke gevallen wordt het inefficiënt om alle context rechtstreeks in de prompt te stoppen. Niet alleen het context window vormt dan een grens, ook het tokenverbruik en de kost lopen snel op.

Dat is het punt waarop retrieval een logisch alternatief wordt. In plaats van alle informatie telkens mee te sturen, wordt enkel die context opgehaald die inhoudelijk relevant is voor de vraag. Die verschuiving van “alles in de prompt” naar “gericht relevante informatie ophalen” maakt AI-integratie veel beter schaalbaar.

RAG met embeddings en vector stores

Retrieval Augmented Generation, of RAG, vertrekt vanuit het idee dat grote hoeveelheden tekst eerst worden omgezet naar vectors. Die vectors worden opgeslagen in een vector store, die vervolgens gequeryd wordt om enkel de relevante stukken context te selecteren. Zo krijgt het model niet de volledige documentcollectie mee, maar alleen de fragmenten die het meest aansluiten bij de vraag.

Daarvoor zijn embeddings nodig: numerieke vectorrepresentaties van tekst. Spring AI voorziet hiervoor een Embeddings API en een EmbeddingModel interface. Op die manier wordt tekst omgezet naar een vorm waarop similarity search mogelijk wordt. De presentatie noemt ook verschillende mogelijke implementaties voor de opslaglaag, waaronder Azure Vector Search, Amazon S3 Vectors, Neo4jVectorStore, PgVectorStore en SimpleVectorStore.

In een typische flow wordt de vector store gekoppeld aan de chatclient via een advisor, zodat relevante fragmenten tijdens het beantwoorden van een vraag automatisch als extra context kunnen worden toegevoegd. Een configuratieklasse kan daarnaast de logica bevatten om een aangeleverde bron, zoals een PDF, in te lezen en om te zetten naar een vector store. Zo verschuift retrieval van een los experiment naar een expliciet onderdeel van de applicatiearchitectuur.

Een praktisch voordeel is dat die vector store niet noodzakelijk bij elke opstart opnieuw opgebouwd moet worden. Ze kan ook bewaard worden in een file, zodat de applicatie sneller kan starten en het indexeringswerk niet telkens opnieuw uitgevoerd moet worden. Dat maakt het verschil tussen een demo-opzet en een aanpak die in de praktijk vlot bruikbaar blijft.

Tool calling

Zodra een model meer moet doen dan alleen tekst genereren, komt tool calling in beeld. Het gaat dan om interactie met een of meerdere externe capabilities, bijvoorbeeld om informatie op te halen uit systemen of om een actie te laten uitvoeren. Denk aan het raadplegen van een databank of webservice, maar ook aan het starten van een workflow, het invullen van een formulier of het versturen van een e-mail. In Spring AI gebeurt dat via tools die je beschikbaar maakt aan het model, bijvoorbeeld via @Tool of via de tool-calling API.

Het belangrijke nuanceverschil is dat het model die actie niet zelf uitvoert. De clientapplicatie blijft eigenaar van de logica. Het model kan hoogstens aangeven dat een tool nodig is en de input daarvoor voorstellen. De applicatie voert die tool vervolgens uit en koppelt het resultaat terug naar het model. Net dat onderscheid is belangrijk: het model krijgt geen rechtstreekse toegang tot de onderliggende API’s of systemen.

Dat maakt tool calling vooral interessant als orkestratiemechanisme. Het model wordt niet de actor die rechtstreeks systemen aanstuurt, maar een component die helpt bepalen welke capability op dat moment nodig is. De applicatie bewaart daarmee de controle over toegang, validatie en uitvoering, terwijl het model ingezet wordt om intentie, context en vervolgstappen te helpen bepalen.

MCP als uitbreidingslaag

Een bredere manier om capabilities beschikbaar te maken is het Model Context Protocol, of MCP. De essentie is eenvoudig: een server biedt capabilities aan, een client maakt daar gebruik van. Die capabilities kunnen verschillende vormen aannemen, zoals resources voor read-only file- of data-access, tools voor AI-executed functions of prompts als vooraf gedefinieerde templates. Voorbeelden daarvan zijn file system, Jira/Confluence, PostgreSQL, Google Drive en web searches.

MCP is model-agnostic en werd mee ondersteund door een Java SDK die door het Spring-team geschreven werd. Dat maakt het interessant als uitbreidingslaag voor toepassingen die meerdere externe capabilities op een meer gestandaardiseerde manier willen ontsluiten. In plaats van voor elke integratie afzonderlijk een los patroon te bouwen, ontstaat er een uniformere manier om resources, tools en prompts beschikbaar te maken aan een AI-gedreven client.

Een bijkomend voordeel is dat ook de mapping naar domeinobjecten expliciet kan gebeuren. Door resultaatdata om te zetten naar typed Java-objecten blijft de integratie niet hangen op losse strings, maar wordt ze deel van een type-safe applicatieflow. Dat maakt MCP relevant voor toepassingen die AI niet alleen willen gebruiken om tekst te genereren, maar ook om concrete capabilities op een beheersbare manier te combineren.

Meer dan tekst: image generation en text-to-speech

Spring AI beperkt zich niet tot chat en retrieval. Ook image generation en text-to-speech maken deel uit van het bredere landschap. Voor image generation is er ondersteuning mogelijk voor DALL-E via OpenAI, met een ImageModel als centrale interface, ImagePrompt voor instructie en opties, en een ImageResponse dat meerdere ImageGenerations kan bevatten. Die vorm van generatie verbruikt wel meer tokens dan een klassieke tekstinteractie.

Voor text-to-speech zijn er integratiepunten voor onder meer OpenAI en Eleven Labs. De centrale interface is TextToSpeechModel, met een eenvoudige call(text)-aanroep of een TextToSpeechPrompt waarin boodschap en opties gecombineerd worden. Daarbij kunnen onder meer model, voices en outputformaat geconfigureerd worden. Tegelijk zijn er duidelijke limieten, zoals een maximaal aantal input characters, ondersteuning voor verschillende talen en een optimalisatie voor Engels.

Die multimodale uitbreidingen zullen niet in elke toepassing de eerste prioriteit zijn, maar ze tonen wel aan dat dezelfde integratieprincipes verder doorgetrokken kunnen worden. Een applicatie die start met tekstuele interactie kan later uitbreiden naar beelden of gesproken output zonder fundamenteel van richting te moeten veranderen.

Spring AI 2.0.0

Spring AI 2.0 werd op 12 juni 2026 uitgebracht en is een grote stap vooruit in volwassenheid. Het bouwt voort op Spring Boot 4 en Spring Framework 7, gebruikt Jackson 3 voor JSON-verwerking en voegt null-safety-annotaties toe aan de volledige codebase. Ook het model voor opties en configuratie werd herwerkt: het is duidelijker en onveranderlijk, met builders in plaats van constructors.

De grootste conceptuele verandering is de betere ondersteuning voor agentic use cases. De uitvoering van tools zit niet langer in de ChatModel-klassen, maar verloopt via ChatClient met een ToolCallingAdvisor die de volledige tool-call-cyclus afhandelt. Wie dat liever zelf aanstuurt, kan elke iteratie manueel beheren. Tool calling is bovendien uniform geworden, en progressive tool disclosure helpt wanneer je een groot aantal tools aanbiedt.

Het kernproject richt zich nu op OpenAI, Anthropic en Google GenAI, gebouwd op de SDK’s van de aanbieders. De Azure OpenAI- en Vertex AI-modules zijn verwijderd, dus gebruikers van Azure OpenAI stappen best over op de standaard OpenAI-module. Ook de MCP-ondersteuning werd verbeterd: ze gebruikt nu de officiële Java SDK, ondersteunt annotatiegestuurd programmeren en voegt nieuwe transports toe, zoals streamable HTTP.

Conclusie

De echte uitdaging bij generatieve AI zit zelden in het eerste antwoord van een model. Die zit in alles wat daarna komt: context correct beheren, domeininformatie selecteren, conversaties laten doorlopen, externe systemen gecontroleerd aanspreken en het geheel onderbrengen in een onderhoudbare applicatiearchitectuur. Spring AI is vooral sterk omdat het voor elk van die stappen een herkenbare bouwsteen aanreikt, van ChatClient en advisors tot vector stores, tools en MCP.

Daardoor blijft AI-integratie niet hangen op demo’s of losse promptexperimenten, maar krijgt ze een plaats in het ontwerp van de toepassing zelf. Net daar zit de echte meerwaarde: niet in het model op zich, maar in de manier waarop het ingebed wordt in een systeem dat begrijpelijk, uitbreidbaar en beheersbaar blijft.

Share this post