Java programátor expert
Spring AI: Ako pridať chat modely, RAG a AI agentov do Java aplikácie
Spring AI tutorial ťa prevedie integráciou LLM do Spring Boot aplikácie: od prvého chat requestu cez pamäť konverzácie a RAG nad vlastnými dátami až po tool-calling a agentické patterny. Súčasťou je funkčný kód, porovnanie s LangChain4j aj rozhodnutie medzi verziami 1.x a 2.0.
V článku sa dozvieš:
Čo je Spring AI a na čo ho použiješ
Spring AI je projekt zo Spring ekosystému, ktorý umožňuje integrovať modely umelej inteligencie do Java aplikácií. Cez jednotné ChatClient API môžeš pracovať s modelmi od rôznych providerov, ako sú OpenAI, Anthropic alebo Ollama, bez toho, aby bola aplikačná logika priamo naviazaná na jedno konkrétne API.
Spring AI prináša tri hlavné výhody:
- zjednodušuje prácu s rôznymi modelmi,
- prirodzene zapadá do Spring Boot aplikácie,
- poskytuje hotové abstrakcie pre bežné AI scenáre – konverzačnú pamäť, prácu s vlastnými dátami pomocou RAG alebo volanie vlastného kódu z modelu prostredníctvom tools.
Pri jednoduchých prípadoch môžeš providera zmeniť najmä úpravou dependency a konfigurácie. Nie všetky možnosti jednotlivých modelov sú však rovnaké, takže pri využití špecifických funkcií môže byť potrebná aj ďalšia konfigurácia. Spring AI preto rozdiely medzi providermi zjednodušuje, ale úplne ich neskrýva.
Výhodou je aj integrácia so Spring Bootom. AI komponenty môžeš konfigurovať rovnakým spôsobom ako ostatné časti aplikácie a využívať pritom dependency injection, properties či observability. AI vrstva tak nemusí byť oddeleným systémom, ale môže sa stať prirodzenou súčasťou existujúcej aplikácie postavenej na Spring Framework.
Spring AI stojí na niekoľkých stavebných blokoch:
- ChatClient – fluent API na volanie modelu, posielanie promptov, prijímanie odpovedí a streamovanie,
- Advisors – komponenty, ktoré rozširujú spracovanie požiadavky a odpovede, napríklad o konverzačnú pamäť, RAG alebo ďalšiu logiku,
- VectorStore – abstrakcia nad vektorovým úložiskom používaným pri RAG,
- Tools (@Tool) – spôsob, ktorým môže model vyžiadať vykonanie vlastného kódu aplikácie,
- MCP (Model Context Protocol) – štandardizovaný protokol na sprístupňovanie nástrojov, zdrojov a promptov AI aplikáciám.
Odporúčame ti…
MCP sa venujeme podrobnejšie v samostatnom článku MCP server: Ako sprístupniť nástroje a dáta AI agentovi v Spring Boot.
Kedy siahnuť po Spring AI namiesto priameho SDK providera? Ak už staviaš na Spring Boote a chceš, aby AI časť aplikácie zapadla do existujúcej architektúry, Spring AI ti poskytne jednotné API a integráciu so Spring ekosystémom. Ak potrebuješ model zavolať iba raz alebo dvakrát bez ďalších plánov na rozširovanie, priame SDK môže byť jednoduchšou voľbou a ďalšiu abstrakciu nepotrebuješ.
V msg life pristupujeme k AI podobne aj pri rozširovaní existujúcich Spring aplikácií. AI vrstva tak nemusí fungovať ako samostatný systém vedľa aplikácie, ale môže byť jej prirodzenou súčasťou.
Ako začať: nastavenie a prvý chat request
Príklady nižšie postupne skladajú jednu hypotetickú aplikáciu, jednoduchého AI asistenta pre zákaznícku podporu poisťovne. Začneme obyčajným chatom a postupne pridáme pamäť konverzácie, možnosť prepínať medzi providermi, RAG nad poistnými podmienkami aj vyhľadanie stavu nahlásenej poistnej udalosti. Jednotlivé časti sú kvôli prehľadnosti oddelené do samostatných príkladov, stále však pracujú s rovnakým scenárom.
Spring AI stavia na Spring Boote. Ak s ním ešte len začínaš, prejdi si najprv základný Spring Boot tutorial.
Spring AI tutorial preto začína s pripravenou Spring Boot aplikáciou. Integrácia modelu potom pozostáva z troch základných krokov: pridáš starter pre konkrétneho providera, nastavíš API kľúč v application.yml a vytvoríš ChatClient.
Dependency
Spring AI používa BOM (Bill of Materials), ktorý zabezpečuje kompatibilné verzie jednotlivých Spring AI modulov. Do projektu preto pridáš BOM a starter pre providera, s ktorým chceš pracovať. V tomto príklade použijeme OpenAI.
xml
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>AKTUALNA_VERZIA</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-openai</artifactId>
</dependency>
</dependencies>
Odporúčame ti…
Keďže Spring AI vydáva patch verzie pomerne často, over si aktuálnu verziu na Maven Central alebo docs.spring.io tesne pred tým, než si definuješ vlastnú hodnotu za AKTUALNA_VERZIA.
Verzia BOM riadi verzie jednotlivých spring-ai-* modulov. Názov startera určuje providera, napríklad spring-ai-starter-model-openai, spring-ai-starter-model-anthropic alebo spring-ai-starter-model-ollama.
Konfigurácia
API kľúč nevkladaj priamo do zdrojového kódu. Praktickejšie je načítať ho napríklad z environmentálnej premennej.
yaml
spring:
ai:
openai:
api-key: ${OPENAI_API_KEY}
chat:
options:
model: gpt-4o-mini
temperature: 0.7
Spring Boot dosadí hodnotu environmentálnej premennej OPENAI_API_KEY pri štarte aplikácie. Nastavenie modelu a temperature predstavuje predvolené nastavenie pre chatové požiadavky. Konkrétne parametre môžeš podľa potreby meniť aj pre jednotlivé requesty.
Prvý chat request
ChatClient je hlavné aplikačné API Spring AI na komunikáciu s chat modelom. Spring Boot automaticky nakonfiguruje ChatClient.Builder, ktorý môžeš použiť na vytvorenie vlastného klienta.
java
@RestController
class ChatController {
private final ChatClient chatClient;
ChatController(ChatClient.Builder builder) {
this.chatClient = builder
.defaultSystem("Si stručný technický asistent. Odpovedz vecne, bez zbytočných úvodných fráz.")
.build();
}
@GetMapping("/chat")
String chat(@RequestParam String message) {
return chatClient.prompt()
.user(message)
.call()
.content();
}
}defaultSystem() nastaví predvolený system prompt pre všetky požiadavky vytvorené týmto ChatClient. Nemusíš ho preto opakovať pri každom volaní. Ak potrebuješ system prompt meniť podľa konkrétnej požiadavky, môžeš ho zadať priamo v reťazci prompt() pomocou .system(…).
Samotné volanie je zámerne jednoduché. prompt() vytvorí požiadavku, .user(…) pridá používateľský vstup, .call() odošle požiadavku modelu a .content() vráti text jeho odpovede.
Od jedného promptu k rozhovoru: pamäť a štruktúrovaný výstup
Predchádzajúci príklad rieši jeden request a jednu odpoveď. Pri reálnej aplikácii však čoskoro narazíš na dve bežné potreby. Aplikácia si má pamätať predchádzajúcu konverzáciu a odpoveď od modelu chceš niekedy dostať ako dáta, nie ako text, ktorý budeš ručne parsovať.
Pamäť konverzácie
Aby aplikácia dokázala viesť súvislý rozhovor, potrebuje modelu pri ďalšej požiadavke sprístupniť aj relevantnú históriu predchádzajúcej konverzácie. Spring AI na to poskytuje ChatMemory a advisor, ktorý túto históriu pridá do kontextu požiadavky odosielanej modelu.
java
@RestController
class ChatController {
private final ChatClient chatClient;
ChatController(ChatClient.Builder builder) {
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.maxMessages(20)
.build();
this.chatClient = builder
.defaultAdvisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
.build();
}
@GetMapping("/chat")
String chat(@RequestParam String message, @RequestParam String conversationId) {
return chatClient.prompt()
.user(message)
.advisors(a -> a.param(ChatMemory.CONVERSATION_ID, conversationId))
.call()
.content();
}
}conversationId umožňuje oddeliť jednotlivé rozhovory. Aplikácia tak môže mať napríklad samostatnú konverzáciu pre každého používateľa alebo session.
V príklade používame MessageWindowChatMemory s limitom 20 správ. Staršie správy sa po prekročení nastaveného limitu z kontextu odstránia. Je to dôležité nielen kvôli veľkosti kontextového okna modelu, ale aj kvôli množstvu tokenov odosielaných pri jednotlivých požiadavkách.
Konkrétne triedy a API pre prácu s pamäťou sa medzi verziami Spring AI vyvíjali, preto je pri použití konkrétnej verzie dobré overiť aktuálnu dokumentáciu.
Štruktúrovaný výstup
Model nemusíš používať iba na generovanie textu. V mnohých aplikáciách potrebuješ z používateľského vstupu extrahovať konkrétne údaje a ďalej s nimi pracovať v Java kóde. Spring AI umožňuje výsledok namapovať priamo na Java typ pomocou .entity().
java
record ClaimRequest(
String policyNumber,
String incidentType,
String description
) {}
ClaimRequest claim = chatClient.prompt()
.user("Nahlasujem poistnú udalosť: v garáži mi vytieklo palivo z auta a poškodilo podlahu. Číslo zmluvy je PZ-2024-8831.")
.call()
.entity(ClaimRequest.class);Spring AI použije štruktúru Java typu na prípravu požadovaného formátu odpovede a výsledok následne skonvertuje na ClaimRequest. Namiesto surového textu tak v aplikácii pracuješ priamo s typovaným objektom.
Tento prístup sa hodí napríklad pri extrakcii údajov z textu, klasifikácii požiadaviek alebo spracovaní formulárov. V našom príklade z textu získame údaje potrebné na vytvorenie ClaimRequest, s ktorými môže aplikácia neskôr ďalej pracovať.
Pri produkčnom použití však treba počítať s tým, že výsledok stále generuje jazykový model. Namapovanie na Java typ preto samo o sebe neznamená, že údaje budú vždy správne alebo úplné. Pri dôležitých operáciách je vhodné výsledok validovať.
Providers: OpenAI, Anthropic, Ollama a prepínanie modelov
Jednou z hlavných výhod Spring AI je, že aplikáciu nemusíš pri použití ChatClient pevne naviazať na jedného providera. Pri jednoduchom použití môžeš providera zmeniť výmenou starter dependency a konfigurácie, zatiaľ čo aplikačný kód zostane prakticky nezmenený.
Spring AI podporuje viacero providerov vrátane OpenAI, Anthropic, Amazon Bedrock, Google GenAI, Mistral AI, DeepSeek a Ollama. Konkrétny zoznam integrácií sa medzi verziami mení, preto je pri použití konkrétnej verzie dobré overiť aktuálny stav v dokumentácii Spring AI.
Prepnutie z OpenAI na lokálneho providera Ollama môže napríklad vyzerať takto. V pom.xml nahradíš starter pre OpenAI za spring-ai-starter-model-ollama a v application.yml upravíš konfiguráciu:
yml
spring:
ai:
ollama:
base-url: http://localhost:11434
chat:
options:
model: llama3.1
ChatController z predchádzajúcej kapitoly pritom môže zostať nezmenený. Stále injektuje rovnaký ChatClient.Builder a používa rovnaké API. Z pohľadu aplikačného kódu tak nemusíš riešiť, či požiadavka smeruje na cloudový model alebo lokálne bežiacu Ollamu.
To však neznamená, že všetci provideri ponúkajú úplne rovnaké možnosti. Jednotné API abstrahuje spoločný základ, no jednotlivé modely a integrácie sa môžu líšiť podporovanými funkciami, parametrami alebo spôsobom práce s nástrojmi a multimodálnymi dátami. Pri prepínaní providera preto treba overiť aj konkrétne schopnosti modelu, ktorý chceš použiť.
Odporúčame ti…
Pre citlivé dáta, napríklad poistné alebo osobné údaje klientov, zvažuj lokálny model ako alternatívu ku cloudovému API. Dáta pritom môžu zostať v infraštruktúre firmy. Ak sa neskôr ukáže, že konkrétnu úlohu lepšie zvláda cloudový model, zmena providera nevyžaduje prepis celej AI vrstvy aplikácie.
Prompt caching
Rozdiely medzi providermi sa prejavujú aj v pokročilejších funkciách. Príkladom je prompt caching, ktorý Spring AI podporuje pri vybraných integráciách.
Pri opakovanom odosielaní rovnakého kontextu, napríklad dlhého system promptu alebo stabilnej časti vstupu, môže caching znížiť množstvo opakovane spracovávaných tokenov a tým aj náklady a čas odpovede. Konkrétne možnosti, cena a životnosť cache však závisia od providera a jeho API.
Spring AI tak poskytuje spoločnú aplikačnú vrstvu, ale zároveň umožňuje využívať aj špecifické schopnosti jednotlivých modelov. Aj preto je dobré vnímať ChatClient ako abstrakciu nad providermi, nie ako záruku, že všetky modely sú navzájom plne zameniteľné.
Vieš, že…
…Spring AI 1.1 pridal prompt caching pre Anthropic Claude a AWS Bedrock? Pri opakovaných promptoch (napríklad rovnaký dlhý system prompt alebo kontext naprieč requestami) to dokáže znížiť náklady až o 90 % a zrýchliť odpoveď. Cache TTL je pri AWS Bedrock pevný na 5 minút, pri priamom Anthropic API si vieš voliteľne nastaviť až 1 hodinu.
RAG so Spring AI: pripoj vlastné dáta
RAG (Retrieval-Augmented Generation) umožňuje modelu pracovať aj s dátami, ktoré neboli súčasťou jeho tréningu. Pri požiadavke sa z VectorStore najprv vyhľadajú relevantné časti dokumentov a Spring AI ich pridá do kontextu odosielaného modelu. Model tak môže pri odpovedi využívať napríklad internú dokumentáciu, databázu znalostí alebo poistné podmienky.
RAG má dve hlavné časti. Najprv musíš dokumenty spracovať a uložiť do VectorStore. Tento proces sa označuje ako ingestion a zvyčajne prebieha mimo samotného používateľského requestu, napríklad ako batch job. Dokument sa načíta, rozdelí na menšie časti, pre každú časť sa vytvorí embedding a výsledok sa uloží do vektorového úložiska.
java
@Bean
ApplicationRunner loadDocuments(VectorStore vectorStore) {
return args -> {
var reader = new TikaDocumentReader("classpath:docs/poistne-podmienky.pdf");
var splitter = TokenTextSplitter.builder().build();
vectorStore.accept(splitter.apply(reader.get()));
};
}
TikaDocumentReader dokáže načítať PDF, Word a ďalšie bežné formáty. TokenTextSplitter následne dokument rozdelí na menšie časti vhodné na ďalšie spracovanie.
Pri uložení dokumentov Spring AI zabezpečí vytvorenie embeddingov prostredníctvom nakonfigurovaného embedding modelu a ich uloženie do konkrétnej implementácie VectorStore. Tou môže byť napríklad PostgreSQL s rozšírením pgvector, ale Spring AI podporuje aj ďalšie vektorové databázy. PostgreSQL pritom poznáš aj z bežnej perzistencie cez Hibernate.
Až teraz prichádza na rad druhá časť RAG, teda retrieval. Tá prebieha pri používateľskej požiadavke. Aplikácia podľa otázky vyhľadá relevantné časti dokumentov a pridá ich do kontextu pre model.
java
@RestController
class RagController {
private final ChatClient chatClient;
RagController(ChatClient.Builder builder, VectorStore vectorStore) {
this.chatClient = builder
.defaultAdvisors(QuestionAnswerAdvisor.builder(vectorStore).build())
.build();
}
@GetMapping("/ask")
String ask(@RequestParam String question) {
return chatClient.prompt()
.user(question)
.call()
.content();
}
}
QuestionAnswerAdvisor pri požiadavke vyhľadá vo VectorStore relevantné časti dokumentov a použije ich ako kontext pre model. Samotný controller pritom zostáva veľmi jednoduchý. Okrem pridania advisora sa volanie ChatClient prakticky nelíši od prvého príkladu v tomto článku.
Práve tu dobre vidieť jednu z výhod Spring AI. Komplexnejšia logika RAG sa nemusí dostať priamo do aplikačného kódu. ChatClient spolu s advisorom sa postará o retrieval a ty naďalej pracuješ s rovnakým API na komunikáciu s modelom.
Vieš, že…
…RAG nemení samotný model ani jeho tréningové dáta? Dokumenty zostávajú mimo modelu a pri konkrétnej otázke sa mu relevantné časti iba dočasne pridajú do kontextu.
AI agenti v Spring AI: agentické patterny a tool-calling
AI agent si môžeš predstaviť ako aplikáciu, v ktorej jazykový model nielen generuje odpoveď, ale dokáže podľa zadania rozhodovať o ďalších krokoch a využívať pritom nástroje, ktoré mu sprístupníš. Spring AI na to poskytuje podporu pre tool-calling a ďalšie stavebné bloky, z ktorých sa dajú agentické riešenia skladať.
Dôležité je rozlíšiť medzi workflow a agentom. Pri workflow je postup vopred určený vývojárom. Naprogramuješ, čo sa má stať po čom, a aplikácia tento postup vykoná.
Pri agentickom prístupe dostáva model väčšiu mieru rozhodovania. Na základe aktuálneho kontextu môže vybrať ďalší krok, napríklad zavolať konkrétny tool, vyhodnotiť jeho výsledok a rozhodnúť sa, čo urobiť ďalej.
Tool-calling v Spring AI
Tool-calling je jeden zo základných mechanizmov agentických aplikácií. Metódu, ktorú chceš sprístupniť modelu, označíš anotáciou @Tool a pridáš jej popis. Model potom môže podľa potreby požiadať aplikáciu o jej zavolanie.
java
@Component
class ClaimTools {
private final ClaimRepository claimRepository;
ClaimTools(ClaimRepository claimRepository) {
this.claimRepository = claimRepository;
}
@Tool(description = "Vráti aktuálny stav poistnej udalosti podľa jej čísla")
String claimStatus(String claimNumber) {
return claimRepository.findByNumber(claimNumber)
.map(claim -> claim.status().toString())
.orElse("Poistná udalosť s týmto číslom neexistuje.");
}
}
Tool následne sprístupníš pri volaní ChatClient:
java
@RestController
class ClaimAssistantController {
private final ChatClient chatClient;
private final ClaimRepository claimRepository;
ClaimAssistantController(
ChatClient.Builder builder,
ClaimRepository claimRepository) {
this.claimRepository = claimRepository;
this.chatClient = builder.build();
}
@GetMapping("/ask")
String ask(@RequestParam String question) {
return chatClient.prompt()
.user(question)
.tools(new ClaimTools(claimRepository))
.call()
.content();
}
}
Ak používateľ položí otázku, z ktorej model usúdi, že potrebuje stav poistnej udalosti, môže vybrať claimStatus, určiť potrebný parameter a požiadať aplikáciu o vykonanie toolu. Výsledok potom dostane späť do kontextu a použije ho pri vytvorení odpovede.
Dôležité je, že samotný model nevykonáva Java metódu. Model iba navrhne volanie nástroja. Spring AI následne zavolá príslušnú Java metódu v aplikácii a výsledok vráti modelu.
Agentické patterny
Pri návrhu agentických aplikácií sa často používa päť patternov, ktoré vo svojej publikácii Building Effective Agents opisuje Anthropic: chaining, routing, parallelization, orchestrator-workers a evaluator-optimizer. Nejde pritom o päť špeciálnych API, ktoré musíš v Spring AI použiť. Sú to skôr architektonické vzory, ktoré môžeš implementovať pomocou jeho základných stavebných blokov.
- Chaining znamená, že výstup jedného kroku sa stáva vstupom ďalšieho. Model môže napríklad najprv vytiahnuť štruktúrované údaje z textu a ďalší krok z nich vytvorí report. V jednoduchom prípade ide v Java aplikácii jednoducho o dve po sebe idúce volania chatClient.prompt()…call().
- Routing najprv klasifikuje vstup a následne ho nasmeruje na špecializovaný handler. Support požiadavku môžeš napríklad rozdeliť na billing, technický problém alebo ostatné požiadavky. Samotné tool-calling je podobný princíp, pretože model si podľa zadania vyberá medzi dostupnými nástrojmi.
- Parallelization spúšťa viacero nezávislých krokov súčasne a následne ich výsledky skombinuje. V Jave môžeš jednotlivé volania spustiť paralelne napríklad pomocou CompletableFuture a výsledky spracovať v ďalšom kroku.
- Orchestrator-workers používa hlavný model, ktorý rozdelí komplexnú úlohu na menšie podúlohy a deleguje ich ďalším špecializovaným volaniam. Každý worker môže mať vlastný prompt a zameranie.
- Evaluator-optimizer kombinuje generovanie a hodnotenie. Jeden krok vytvorí výstup, ďalší ho skontroluje a poskytne spätnú väzbu. Proces sa môže opakovať, kým výstup nesplní stanovené kritériá.
Spring AI ti pritom neposkytuje jednu magickú metódu na vytvorenie agenta. Agentické riešenie skladáš z dostupných mechanizmov, ako sú ChatClient, tools, advisors a vlastná aplikačná logika. Práve táto skladateľnosť je pri Spring AI dôležitá, pretože môžeš začať jednoduchým tool-callingom a postupne pridávať zložitejšie workflow. Kvalita výsledku pritom veľmi závisí od toho, ako sú napísané prompty, ktoré modelu posielaš.
MCP a agenti
Ak chceš rovnaké nástroje sprístupniť viacerým AI klientom alebo aplikáciám prostredníctvom štandardizovaného protokolu, prichádza na rad Model Context Protocol (MCP). MCP oddeľuje nástroj od konkrétnej aplikácie, ktorá ho používa.
Komunitné rozšírenia Spring AI
Ak chceš ísť nad rámec základných stavebných blokov Spring AI, existujú aj komunitné projekty rozširujúce jeho možnosti o vyššiu úroveň agentických abstrakcií. Príkladom je spring-ai-agent-utils z projektu spring-ai-community, ktorý poskytuje nástroje a ďalšie mechanizmy inšpirované agentickými aplikáciami typu Claude Code.
Keďže ide o komunitný a rýchlo sa vyvíjajúci projekt, jeho aktuálny stav a kompatibilitu s konkrétnou verziou Spring AI si pred použitím over v dokumentácii.
Bežné úskalia pri nasadení Spring AI
Pred porovnaním Spring AI s alternatívami sa oplatí pozrieť aj na niekoľko praktických problémov, ktoré sa objavia pri reálnom nasadení.
Blokujúce volania pri dlhších odpovediach
.call() čaká na dokončenie celej odpovede. Pri chatovom rozhraní môže byť príjemnejšie streamovanie pomocou .stream(), ktoré umožňuje spracovávať odpoveď priebežne.
chatClient.prompt().user(message).stream().content();
Výsledkom je Flux<String>, takže jednotlivé časti odpovede môžeš odosielať používateľovi postupne.
Rate limity a timeouty
Každý provider má vlastné limity a pravidlá pre timeouty. V produkčnej aplikácii preto potrebuješ počítať s dočasnou nedostupnosťou služby, retry mechanizmom a vhodným timeoutom.
Konflikty pri konfigurácii modelu
Ak si vytváraš vlastné ChatModel alebo súvisiace Spring beany, treba si dať pozor na konflikt s auto-konfiguráciou Spring Bootu. Pri testovaní alebo vlastnej konfigurácii je preto dobré skontrolovať, ktoré beany Spring v skutočnosti vytvoril.
Citlivé údaje v logoch
Pri debugovaní sa môže do logov dostať prompt, odpoveď alebo iné citlivé údaje. Pri produkčnom nasadení treba observability a logging nastaviť tak, aby sa citlivé hodnoty nezapisovali alebo maskovali.
Nedeterministické odpovede
Unit test založený na presnom texte odpovede modelu je krehký. Pri testovaní je vhodnejšie mockovať model alebo overovať konkrétne správanie aplikácie, napríklad či bol správne zavolaný tool alebo či výsledok zodpovedá očakávanej štruktúre.
Náklady a výkon
AI aplikácia môže jednou používateľskou požiadavkou vytvoriť viacero volaní modelu, najmä pri tool-callingu a agentických workflow. Preto sa oplatí sledovať počet tokenov, latenciu, počet volaní a súvisiace náklady od začiatku.
Spring AI vs. LangChain4j: ktorý použiť?
Spring AI a LangChain4j riešia podobný problém, ale pristupujú k nemu z trochu inej perspektívy. Spring AI je prirodzenou súčasťou Spring ekosystému, zatiaľ čo LangChain4j sa snaží zostať nezávislejší od konkrétneho Java frameworku.
Preto nie je otázkou, ktorý z nich je všeobecne lepší. Dôležitejšie je, v akej aplikácii ho chceš použiť a koľko kontroly nad AI vrstvou potrebuješ.
Kedy Spring AI zatiaľ nepoužiť
Skôr než oba frameworky porovnáme, stojí za to povedať otvorene, kedy Spring AI nemusí byť najvhodnejšia voľba:
- Nepoužívaš Spring Boot – Spring AI je úzko integrované so Spring ekosystémom a jeho hlavné výhody vychádzajú práve z tejto integrácie. Ak aplikácia beží napríklad na Quarkuse, Micronaute alebo v plain Jave, pridávať Spring len kvôli AI vrstve nemusí dávať zmysel.
- Chceš maximálnu priamu kontrolu – abstrakcia Advisors zjednodušuje prácu, no zároveň časť implementačných detailov skrýva. Ak potrebuješ presne riadiť, čo sa posiela modelu a ako jednotlivé kroky prebiehajú, vhodnejšie môže byť priame SDK providera alebo explicitnejšie používanie LangChain4j.
- Potrebuješ konkrétnu integráciu, ktorú Spring AI nepodporuje – zoznam providerov a vector store integrácií sa rozširuje, no pred výberom frameworku sa oplatí overiť, či podporuje technológie, ktoré chceš použiť.
- Chceš komponenty skladať úplne podľa vlastnej architektúry – Spring AI prináša vlastné abstrakcie, napríklad Advisors a Spring Beans pre tools. LangChain4j ponecháva v niektorých oblastiach viac rozhodnutí priamo na vývojárovi.
Ak sa ťa žiadny z týchto bodov netýka a aplikácia už stojí na Spring Boote, Spring AI je prirodzený kandidát.
Zaujímavé je aj to, že oba frameworky dosiahli verziu 1.0 GA prakticky v rovnakom období: Spring AI 20. mája 2025 a LangChain4j 12. mája 2025. Ani jeden teda nemá výrazný náskok v podobe dlhšej histórie stabilného API.
LangChain4j vs. Spring AI: porovnanie v tabuľke
Porovnanie Spring AI vs. LangChain4j sa dá zhrnúť do niekoľkých kritérií, ktoré rozhodujú v praxi najčastejšie:
| Kritérium | Spring AI 2.0 | LangChain4j |
|---|---|---|
| Governance | Oficiálny Spring projekt | Nezávislý komunitný projekt |
| Runtime | Spring Boot a Spring ekosystém | Spring Boot, Quarkus, Micronaut aj plain Java |
| API štýl | ChatClient fluent API + Advisors | AiServices alebo explicitné builder API |
| RAG | DocumentReader, Transformer, Writer, QuestionAnswerAdvisor | DocumentSplitter, EmbeddingStore, ContentRetriever a ďalšie komponenty |
| Providers a vector stores | Kurátorská sada integrácií | Širšia paleta integrácií |
| Observability | Prirodzená integrácia so Spring Boot Actuator a Micrometer | Integrácia prostredníctvom vlastných možností a Spring Boot podpory |
Stav jednotlivých integrácií a API sa medzi verziami mení pomerne rýchlo. Tabuľku preto treba chápať ako stav ekosystému v čase písania článku, nie ako trvalú vlastnosť oboch frameworkov.
Praktické vysvetlenie rozdielov:
Prvým je štýl API a architektúra aplikácie. Spring AI ťa prostredníctvom ChatClient a Advisors prirodzene vedie k tomu, aby si spoločné správanie, napríklad pamäť, RAG alebo observability, riešil ako samostatné komponenty integrované do Spring kontextu.
V LangChain4j môžeš podobné správanie poskladať explicitnejšie. AiServices navyše umožňuje definovať AI službu ako Java rozhranie, čo môže byť veľmi prirodzené v aplikáciách, ktoré chcú AI funkcionalitu oddeliť od samotnej implementácie.
Druhým rozdielom je agentické tooling. LangChain4j má AiServices a @Tool ako zavedený spôsob práce s tool-callingom. Spring AI 2.0 priniesol nový kompozovateľný ToolCallingAdvisor, ktorý presúva tool-calling do všeobecnejšej architektúry Advisors.
Ak sú agenti a komplexné agentické workflow jadrom tvojej aplikácie, má preto zmysel vyskúšať si oba prístupy na menšej úlohe ešte predtým, ako na jednom z frameworkov postavíš celú aplikáciu.
Čo v skutočnosti rozhoduje o výkone?
Pri samotnom frameworku nebude rozdiel v režijnej záťaži pravdepodobne tým, čo rozhodne o výkone aplikácie. Oveľa väčší vplyv má sieťová komunikácia s providerom, použitý model, počet volaní a predovšetkým množstvo tokenov, ktoré posielaš v kontexte.
Pri aplikáciách s konverzačnou pamäťou alebo RAG preto stojí za to sledovať, koľko kontextu framework pridáva ku každému requestu. Zbytočne veľká história alebo príliš veľké množstvo dokumentov môže zvýšiť cenu aj latenciu bez ohľadu na to, ktorý framework používaš.
Spring AI alebo LangChain4j: rýchly výber
Ak už aplikácia používa Spring Boot a chceš, aby AI vrstva využívala rovnaký ekosystém, konfiguráciu, dependency injection a observability ako zvyšok aplikácie, Spring AI je prirodzená voľba.
Ak potrebuješ širšiu paletu integrácií, aplikácia beží mimo Springu alebo chceš mať jednotlivé AI komponenty poskladané explicitnejšie, vhodnejší môže byť LangChain4j.
Ani jeden prístup však nie je univerzálne správny. Pri výbere je dôležitejšie pozerať sa na architektúru konkrétnej aplikácie, dostupné integrácie a spôsob, akým chce tím AI funkcionalitu dlhodobo vyvíjať a udržiavať.
Spring AI 1.x vs. 2.0: Ktorú verziu použiť
Pri výbere verzie Spring AI je najdôležitejšie najprv pozrieť sa na verziu Spring Bootu, ktorú používa tvoja aplikácia.
Spring AI 2.0, vydané ako GA 12. júna 2026, je postavené na Spring Boot 4.0/4.1 a Spring Framework 7. Ak teda aplikácia stále používa Spring Boot 3.x, prirodzenou voľbou zostáva vetva Spring AI 1.1.x, kým neprejdeš na Boot 4.
Toto je v praxi dôležitejšie než jednotlivé nové funkcie Spring AI 2.0. Upgrade AI frameworku totiž nedáva veľký zmysel riešiť oddelene od hlavného Spring Boot upgradu.
Pôvodne bolo vydanie Spring AI 2.0 plánované na 28. mája 2026, GA sa však posunulo na 12. júna. Ide teda o pomerne čerstvú hlavnú verziu, pri ktorej je pri produkčnom nasadení rozumné počítať s kratšou históriou používania než pri stabilnejšej vetve 1.x.
Čo prináša Spring AI 2.0
Rozdiel medzi 1.x a 2.0 nie je iba v požadovanej verzii Spring Bootu.
Nový baseline prináša Jakarta EE 11, Jackson 3 a JSpecify null-safety anotácie naprieč API. Options buildery sú po novom immutable, mení sa aj zoznam providerov podporovaných priamo v core a výraznou zmenou prešla práca s tool-callingom.
Spring AI 2.0 zjednocuje tool-calling do kompozovateľného ToolCallingAdvisor, ktorý nahrádza pôvodný prístup z vetvy 1.x, kde mal každý model (OpenAI, Anthropic, Ollama a ďalšie) vlastnú, oddelenú tool-calling slučku. Práve túto architektúru využívame aj v kapitole o AI agentoch. ToolCallingAdvisor sa na ChatClient registruje automaticky, akonáhle použiješ .tools(…), takže ho v kóde nikde priamo nevidíš inštanciovaný. Je to iné správanie než pri QuestionAnswerAdvisor alebo MessageChatMemoryAdvisor z predchádzajúcich kapitol, ktoré si do ChatClient registruješ explicitne cez .defaultAdvisors(…), tie sa však medzi vetvou 1.1.x a 2.0 nezmenili, preto ich API v článku vyzerá rovnako.
Súčasťou verzie 2.0 je aj upgrade na MCP SDK 2.0.0.
Migrácia na 2.0 nie je iba zmena verzie
Pri prechode z 1.x na 2.0 preto nestačí zmeniť číslo verzie v pom.xml.
Oficiálne migračné poznámky uvádzajú premenované moduly, presunuté triedy, odstránené options aj zmenené správanie niektorých advisorov. Napríklad ToolCallAdvisor z 1.x bol v 2.0 premenovaný na ToolCallingAdvisor, ktorý sme použili v kapitole o agentoch.
Pri reálnej aplikácii treba preto počítať nielen s opravami chýb pri kompilácii, ale aj s regresným testovaním. Zvláštnu pozornosť si zaslúži tool-calling, pamäť konverzácie, streamovanie a konfigurácia jednotlivých providerov.
Ktorú verziu Spring AI zvoliť?
Výber sa dá zjednodušiť na tri najčastejšie situácie:
- Nový projekt na Spring Boote 4.x – Spring AI 2.0 je prirodzená voľba, pretože využiješ aktuálny Spring baseline a nemusíš riešiť neskoršiu migráciu z 1.x.
- Existujúca aplikácia na Spring Boote 3.x bez plánovaného upgradu – zostaň na Spring AI 1.1.x a migráciu rieš spolu s prechodom na Spring Boot 4.
- Práve migruješ zo Spring Boot 3 na 4 – prechod na Spring AI 2.0 naplánuj ako súčasť rovnakej migrácie. Vyhneš sa tak tomu, že budeš rovnakú aplikáciu migrovať dvakrát.
Spring Boot 3.5 a Spring Framework 6.2 dosiahli 30. júna 2026 koniec štandardnej podpory. Pri aplikáciách, ktoré potrebujú viac času na migráciu, však môžu existovať možnosti predĺženej komerčnej podpory. Samotný koniec štandardnej podpory preto nemusí znamenať, že je potrebné migráciu urobiť narýchlo.
Praktické pravidlo je jednoduché: ak už máš Spring Boot 4, začni s Spring AI 2.0. Ak zostávaš na Spring Boot 3, zostaň zatiaľ na Spring AI 1.1.x a obe migrácie spoj do jedného kroku.
FAQ: Často kladené otázky o Spring AI
Čo je Spring AI?
Spring AI je oficiálny projekt Spring ekosystému, ktorý cez jednotné ChatClient API umožňuje Java aplikáciám volať LLM od rôznych providerov, napríklad OpenAI, Anthropic alebo Ollama. Integruje AI funkcionalitu do Spring Boot aplikácie rovnako ako ostatné časti Spring ekosystému, vrátane auto-konfigurácie, dependency injection a konfigurácie cez application.yml.
Aký je rozdiel medzi Spring AI a LangChain4j?
Spring AI je úzko integrované so Spring Boot a využíva jeho mechanizmy, napríklad Advisors, Spring Beans pre tools alebo Actuator a Micrometer pre observability. LangChain4j je nezávislý od konkrétneho Java frameworku a ponúka granulárnejšie komponenty, ktoré si môžeš skladať podľa vlastnej architektúry, spolu so širšou paletou niektorých providerov a vector store integrácií. Voľba preto závisí najmä od architektúry aplikácie a technológií, ktoré už používaš.
Podporuje Spring AI RAG?
Áno. Spring AI poskytuje nástroje na načítanie a spracovanie dokumentov, VectorStore abstrakciu nad vektorovými databázami a QuestionAnswerAdvisor na retrieval. Pri requeste advisor vyhľadá relevantné časti dokumentov a pridá ich do kontextu odosielaného modelu.
Vie si Spring AI pamätať kontext konverzácie?
Áno. ChatMemory spolu s príslušným advisorom umožňuje uchovávať históriu správ a pridávať ju do kontextu ďalších requestov. Pomocou conversationId môže aplikácia rozlišovať jednotlivé paralelné konverzácie, napríklad medzi používateľmi alebo session.
Ako postaviť AI agenta v Jave so Spring AI?
Základom je tool-calling. Metódu označíš anotáciou @Tool a sprístupníš ju modelu cez ChatClient. Model sa podľa aktuálneho kontextu rozhodne, či tool potrebuje zavolať, a aké parametre mu odovzdá. Nad tool-callingom môžeš následne skladať komplexnejšie agentické workflow, napríklad pomocou patternov chaining, routing, parallelization, orchestrator-workers alebo evaluator-optimizer.
Ktorú verziu Spring AI mám použiť?
Ak aplikácia používa Spring Boot 4.0/4.1, vhodnou voľbou je Spring AI 2.0. Ak zostávaš na Spring Boote 3.x a upgrade zatiaľ neplánuješ, zostaň na vetve 1.1.x. Migráciu na Spring AI 2.0 je potom rozumnejšie spojiť s migráciou na Spring Boot 4 než ju robiť samostatne.
Spring AI v Java aplikácii: S čím začať
Spring AI ti dáva jednotné API na volanie modelov, konverzačnú pamäť, prácu s vlastnými dátami cez RAG aj nástroje na stavbu agentických aplikácií. To všetko pritom zapadá do Spring ekosystému, ktorý zo Spring Bootu poznáš: auto-konfigurácia, dependency injection, konfigurácia cez properties a observability.
Nie je to jediná cesta, ako dostať AI do Java aplikácie. LangChain4j je plnohodnotná alternatíva, ktorá môže dávať väčší zmysel mimo Spring Bootu alebo v aplikáciách, kde chceš mať jednotlivé AI komponenty podrobnejšie pod kontrolou. Ak už však na Spring Boote staviaš, Spring AI je prirodzený kandidát, ktorý stojí za vyskúšanie.
Než sa pustíš do vlastnej aplikácie, zapamätaj si zo Spring AI tutoriálu dve základné veci: akú verziu Spring Bootu používaš a akú mieru kontroly potrebuješ nad modelmi, promptami a AI workflow. Od toho sa odvíja nielen výber verzie Spring AI, ale aj to, či je pre teba Spring AI vôbec vhodnejšia voľba než priame SDK alebo LangChain4j.
