Java programátor expert
MCP server: Ako sprístupniť nástroje a dáta AI agentovi v Spring Boot
MCP server je most medzi jazykovým modelom a tvojím reálnym prostredím: sprístupní AI agentovi súbory, databázy aj interné nástroje cez jeden otvorený protokol. Nižšie nájdeš, ako Model Context Protocol funguje pod kapotou a ako si vlastný MCP server postavíš v Spring Boot s Java 25 a Spring AI 2.0.
V článku sa dozvieš:
Prečo vznikol MCP server a aký problém rieši
Veľké jazykové modely sa za posledné roky výrazne posunuli. Dnes dokážu generovať kvalitný kód, analyzovať architektúru aplikácií alebo navrhovať optimalizácie. Stále však narážajú na jedno dôležité obmedzenie. Nemajú priamy prístup k tvojmu lokálnemu prostrediu a aktuálnym dátam.
Štandardný LLM pozná iba informácie zo svojich trénovacích dát a to, čo mu poskytneš v rámci konverzácie. Keď potrebuje pracovať s lokálnym projektom, internou databázou, produkčnými logmi alebo poznámkami uloženými na disku, chýba mu potrebný kontext. Je to podobné, ako keby mal architekt navrhnúť rekonštrukciu domu bez toho, aby videl jeho aktuálny stav.
Prečo proprietárne integrácie nestačia
Tento problém sa doteraz riešil rôznymi proprietárnymi integráciami. Každé IDE alebo AI asistent mal vlastný spôsob, ako sa pripojiť k databázam, súborom alebo interným službám. Pri prepojení modelu s firemným systémom bolo často potrebné vytvoriť vlastné API, napísať špecifický integračný kód alebo prispôsobiť plugin pre konkrétneho klienta. Pri zmene modelu alebo klientskej aplikácie sa veľká časť tejto práce musela opakovať.
Takýto prístup bol z dlhodobého hľadiska neefektívny. Vývojári namiesto riešenia reálnych problémov trávili čas budovaním a údržbou prepojení medzi AI nástrojmi a existujúcimi systémami. S rastúcim počtom modelov a klientskych aplikácií bolo čoraz zložitejšie udržiavať kompatibilitu medzi jednotlivými integráciami.
MCP server ako jednotné rozhranie pre AI nástroje
Podobne ako SQL zjednotilo prácu s relačnými databázami a HTTP/REST komunikáciu webových služieb, aj AI ekosystém potreboval jednotný spôsob, ako bezpečne a konzistentne pristupovať k externým dátam a nástrojom. Vývojári potrebovali univerzálne rozhranie, ktoré by fungovalo nezávisle od konkrétneho modelu alebo klienta.
Túto úlohu rieši Model Context Protocol (MCP). Ide o otvorený štandard, ktorý oddeľuje samotný jazykový model od zdrojov dát a vykonateľných funkcií. Namiesto množstva nekompatibilných integrácií vzniká architektúra, v ktorej aplikácia komunikuje s okolím cez jasne definovaný MCP server. Ten zabezpečuje riadený prístup k lokálnym súborom, databázam, API alebo ďalším nástrojom a zároveň ponecháva kontrolu nad tým, čo môže model vidieť a vykonávať.
Vďaka tomu môže AI asistent pracovať s aktuálnym stavom projektu, analyzovať reálne logy, spúšťať vybrané nástroje alebo pristupovať k internej dokumentácii bez potreby vytvárať samostatnú integráciu pre každý model a každý systém zvlášť. MCP tak predstavuje štandardizovaný komunikačný kanál medzi AI asistentom a prostredím, v ktorom reálne pracuješ.
Čo je MCP server a ako funguje?
Model Context Protocol (MCP) je otvorený štandard pre bezpečnú obojsmernú komunikáciu medzi AI aplikáciami a externými systémami. Jeho úlohou je umožniť modelu pracovať s dátami a nástrojmi mimo samotného chatu bez potreby vytvárať samostatnú integráciu pre každý model a aplikáciu.
Zjednodušene si môžeš MCP predstaviť ako univerzálne rozhranie medzi AI asistentom a okolím, v ktorom pracuješ. Model tak nemusí vedieť, či komunikuje so súborovým systémom, databázou alebo cloudovou službou. Všetko prebieha cez jednotný protokol.
Architektúra MCP: klient, server a dáta
Architektúra je pomerne jednoduchá. Na jednej strane je klientska aplikácia, napríklad Claude Desktop, Cursor alebo VS Code s podporou MCP. S touto aplikáciou komunikuješ priamo ty. Klient riadi konverzáciu s jazykovým modelom a zároveň sprostredkováva komunikáciu s MCP serverom.
MCP server je samostatne bežiaci proces, ktorý sprístupňuje konkrétne dáta a funkcie. Neobsahuje samotný jazykový model. Jeho úlohou je bezpečne poskytovať prístup k lokálnym súborom, databázam, logom, build nástrojom alebo externým API.
Za serverom sa nachádzajú reálne systémy a dáta, teda všetko, s čím chceš modelu umožniť pracovať. Môže ísť o zdrojové kódy projektu, konfiguračné súbory, produkčné logy, PostgreSQL databázu alebo interné firemné služby.
Ako prebieha komunikácia medzi modelom a MCP serverom
Keď položíš otázku, klient ju odošle modelu spolu so zoznamom možností, ktoré poskytuje pripojený MCP server. Model si tieto možnosti vie prezrieť a rozhodnúť sa, či ich potrebuje použiť. Ak napríklad požiadaš asistenta, aby našiel chybu v poslednom build logu, model zistí, že potrebuje načítať konkrétny súbor. Požiada klienta o jeho načítanie, klient odošle požiadavku serveru a server vráti obsah logu späť modelu na analýzu.
Dôležité je, že model nikdy nepristupuje k súborom alebo databáze priamo. Všetko sa vykonáva cez MCP server, ktorý určuje, čo je povolené a čo nie.
Protokol MCP definuje tri základné typy objektov, pomocou ktorých server komunikuje s okolím: prompty, zdroje a nástroje.
Prompts
Prompts predstavujú predpripravené šablóny a inštrukcie, ktoré pomáhajú modelu správne pochopiť úlohu. Môže ísť napríklad o šablónu pre code review, generovanie dokumentácie alebo analýzu logov. Výhodou je, že používateľ nemusí zakaždým formulovať zložité zadanie a model dostane konzistentné inštrukcie.
Resources
Resources sú dátové zdroje určené iba na čítanie. Slúžia ako kontext pre odpovede modelu. Typickým príkladom sú Markdown súbory s dokumentáciou, konfiguračné súbory, logy aplikácie, výpisy z databázy alebo údaje získané z externého API.
Tieto dáta sa načítavajú až v momente, keď ich model potrebuje. Nemusia byť teda súčasťou každého promptu, čo šetrí miesto v kontextovom okne (context window) a znižuje množstvo prenášaných dát.
Tools
Tools sú vykonateľné funkcie, ktoré umožňujú modelu robiť reálne akcie. Môže ísť o spustenie build procesu, testov, vytvorenie alebo úpravu súboru, vyhľadanie záznamov v databáze alebo volanie interného API.
Keď model potrebuje vykonať akciu, vytvorí štruktúrovanú požiadavku. Klient ju odošle MCP serveru, server vykoná príslušný lokálny kód a výsledok vráti späť modelu. Model tak rozhoduje o logike operácie, ale samotné vykonanie zostáva pod kontrolou servera a tvojej aplikácie.
Práve toto oddelenie logiky od vykonávania je jeden z najdôležitejších princípov MCP. Model môže navrhovať a riadiť operácie, ale nemá neobmedzený prístup k systému. O tom, ktoré súbory môže čítať, aké príkazy môže spúšťať a ku ktorým službám sa môže pripojiť, rozhoduje výhradne konfigurácia MCP servera.
Vieš, že…
…MCP Java SDK vzniklo v decembri 2024 a udržiava ho tím Spring AI spolu s Anthropic? Java tak dostala oficiálnu cestu k MCP v rovnakom čase ako Python a TypeScript.
Architektúra protokolu: Transportné vrstvy a JSON-RPC 2.0
Pre pochopenie stability a flexibility celého systému potrebuješ vidieť spôsob, akým sa prenášajú správy medzi klientom a serverom. Model Context Protocol je postavený na overenom štandarde JSON-RPC 2.0. Tento formát zabezpečuje, že všetky požiadavky na čítanie zdrojov, spúšťanie nástrojov alebo zasielanie šablón majú striktnú dátovú štruktúru, ktorú dokáže jednoducho validovať ako klientská, tak aj serverová strana.
Komunikácia prebieha asynchrónne pomocou jasne definovaných požiadaviek (Requests) a odpovedí (Responses). Protokol definuje dva primárne spôsoby transportu správ.
Lokálna komunikácia cez štandardný vstup a výstup (stdio)
Toto je najbežnejší a z hľadiska konfigurácie najjednoduchší spôsob prepojenia. Klient (napríklad Claude Desktop) spustí MCP server ako samostatný podproces v tvojom operačnom systéme. Komunikácia potom prebieha priamo cez štandardný vstup (stdin) a štandardný výstup (stdout) tohto procesu.
Tento prístup má podstatnú výhodu v bezpečnosti. Server beží kompletne lokálne na tvojom počítači, nemá žiadne otvorené sieťové porty na internet a komunikuje výhradne s aplikáciou, ktorá ho naštartovala. Z hľadiska sieťovej infraštruktúry nevzniká žiadne riziko neautorizovaného prístupu zvonku.
Sieťová komunikácia cez Streamable HTTP
Ak potrebuješ, aby server bežal na vzdialenom serveri, v docker kontajneri v rámci firemnej infraštruktúry, alebo ak chceš zdieľať nástroje medzi viacerými vývojármi, lokálne prepojenie cez stdio nestačí. Pre tieto prípady špecifikácia MCP definuje transportnú vrstvu Streamable HTTP, ktorá od revízie protokolu z marca 2025 nahradila pôvodný transport založený na Server-Sent Events (SSE). Staršie SSE ostáva v niektorých klientoch dostupné len kvôli spätnej kompatibilite, no nové implementácie by sa už naň nemali spoliehať.
V tomto režime beží server ako samostatná HTTP služba a vystavuje jediný endpoint (napríklad /mcp), ktorý prijíma HTTP POST aj GET požiadavky. Klient posiela požiadavky, napríklad volania nástrojov, pomocou POST požiadaviek. Server na ne môže odpovedať buď priamo vo formáte JSON, ak ide o jednoduchú a rýchlu odpoveď, alebo prejsť do streamovacieho režimu a posielať výsledky postupne cez SSE, ak operácia trvá dlhšie alebo generuje viacero čiastkových správ. Vďaka tejto flexibilite zvláda táto transportná vrstva jednoduché synchrónne volania rovnako dobre ako scenáre s priebežnými notifikáciami smerom od servera ku klientovi.
Pohľad na štruktúru správ JSON-RPC 2.0
Pre lepšiu predstavu, ako táto komunikácia vyzerá v praxi, pozri sa na surovú štruktúru správ. Keď klientska aplikácia naštartuje server, ako prvú vec pošle požiadavku na zoznam dostupných nástrojov (tools/list).
JSON-RPC požiadavka od klienta vyzerá takto:
JSON
{
"jsonrpc": "2.0",
"method": "tools/list",
"params": {},
"id": 1
}
Server zachytí túto metódu na svojom štandardnom vstupe a okamžite odpovie štruktúrovaným zoznamom. V odpovedi musí presne popísať schému parametrov (JSON Schema), aby model vedel, aké dátové typy môže do nástroja poslať.
JSON-RPC odpoveď z nášho servera vyzerá nasledovne:
JSON
{
"jsonrpc": "2.0",
"result": {
"tools": [
{
"name": "createNewNote",
"description": "Vytvorenie novej Markdown poznámky",
"inputSchema": {
"type": "object",
"properties": {
"title": {
"type": "string",
"description": "Titulok poznámky"
},
"content": {
"type": "string",
"description": "Samotný textový obsah poznámky"
}
},
"required": ["title", "content"]
}
}
]
},
"id": 1
}
Keď používateľ zadá v chate príkaz na vytvorenie poznámky, model zanalyzuje túto schému a klient pošle serveru požiadavku na vykonanie nástroja (tools/call):
JSON
{
"jsonrpc": "2.0",
"method": "tools/call",
"params": {
"name": "createNewNote",
"arguments": {
"title": "Konfigurácia Spring Boot",
"content": "Obsah poznámky o nastavení aplikácie."
}
},
"id": 2
}
Kedy a prečo nasadiť MCP server?
MCP server má význam najmä v situáciách, keď chceš, aby AI asistent nepracoval iba s informáciami z konverzácie, ale aby dokázal bezpečne pristupovať k reálnym dátam a nástrojom.
Softvérový vývoj sa postupne posúva od jednoduchého generovania jednotlivých úryvkov kódu k práci s celými projektmi. Moderný AI asistent už nemusí iba odpovedať na otázky, ale môže analyzovať zdrojové kódy, pracovať s dokumentáciou, kontrolovať logy alebo spúšťať vybrané operácie.
Práve v tomto momente vzniká potreba riešenia, ktoré dokáže prepojiť jazykový model s existujúcim prostredím. MCP server sa hodí najmä v troch hlavných oblastiach.
Integrácia s internými firemnými systémami
Každá softvérová firma používa množstvo interných nástrojov. Môžu to byť databázy, systémy na správu úloh, interná dokumentácia, CI/CD pipeline alebo centralizované logovacie služby. Tieto systémy často nie sú dostupné priamo z internetu alebo neposkytujú rozhranie vhodné na komunikáciu s AI modelmi. Pomocou MCP servera je možné tieto zdroje sprístupniť kontrolovaným spôsobom.
Vývojár sa tak nemusí manuálne prepínať medzi rôznymi nástrojmi a kopírovať informácie do chatu. Môže sa napríklad opýtať AI asistenta, prečo zlyhal posledný build, a MCP server dokáže načítať príslušné logy, vyhľadať relevantnú chybu a poskytnúť modelu potrebný kontext. AI asistent tak nepracuje iba so všeobecnými znalosťami, ale aj s aktuálnym stavom konkrétneho projektu.
Rovnaký princíp môže nájsť využitie aj v poisťovníctve. Predstav si napríklad interný systém, ktorý obsahuje logiku na výpočet poistného alebo informácie o poistných produktoch. Pomocou MCP servera môže byť takáto funkcionalita sprístupnená AI agentovi štandardizovaným spôsobom bez toho, aby agent musel priamo pristupovať k interným systémom. Spôsob spracovania dát, oprávnenia a bezpečnostné pravidlá však zostávajú na konkrétnej implementácii riešenia.
Kontrola nad bezpečnosťou a ochranou dát
Jednou z najväčších otázok pri používaní AI v podnikoch je bezpečnosť citlivých údajov. Zdrojový kód, údaje zákazníkov, finančné informácie alebo interné dokumenty často nemôžu byť jednoducho odosielané do externých služieb.
MCP server rieši bezpečnosť tým, že vytvára kontrolovanú vrstvu medzi modelom a dátami. Model nemusí dostať priamy prístup k celej databáze alebo kompletnému súborovému systému. Vie iba to, aké možnosti a nástroje má k dispozícii. Keď potrebuje konkrétnu informáciu, požiada o jej získanie. MCP server následne vykoná potrebnú operáciu, spracuje dáta a poskytne modelu iba výsledok, ktorý potrebuje pre aktuálnu úlohu. Citlivé dáta tak môžu zostať v internej infraštruktúre a zároveň ich môže AI asistent využívať pri práci.
Štandardizácia a odstránenie duplicitného integračného kódu
Pred vznikom štandardov ako MCP bolo potrebné vytvárať samostatné integrácie pre jednotlivé nástroje. Pri pripojení vlastného systému k jednému AI asistentovi alebo editoru bolo často potrebné vytvoriť špecifický plugin alebo vlastné API rozhranie. Pri použití iného klienta bolo potrebné rovnakú funkcionalitu implementovať znova.
MCP tento problém rieši štandardizovaným rozhraním. Logiku napíšeš iba raz do MCP servera a následne ju môže používať viacero kompatibilných klientov. Rovnaký server môže byť dostupný napríklad z AI asistenta, vývojového prostredia alebo automatizovaného skriptu. Výsledkom je jednoduchšia údržba a menšie množstvo integračného kódu, ktorý musí vývojár dlhodobo spravovať.
Ako vytvoriť MCP server v Spring Boot (Java 25)
Prejdime k praktickej implementácii. Vytvoríme si funkčnú aplikáciu (typu MCP server) určenú na lokálnu správu vývojárskych poznámok v Markdown formáte. Tento systém umožní AI asistentovi prehľadávať lokálny adresár, čítať špecifické poznámky a priamo generovať nové štruktúrované súbory na základe prebiehajúcej konverzácie.
Využijeme ekosystém Spring Boot s podporou Spring AI a moderné prvky, ktoré prináša Java 25. Komunikáciu nastavíme cez štandardný vstup a výstup (stdio), čo umožní priame prepojenie s aplikáciou Claude Desktop.
Stav ekosystému k roku 2026: MCP v prostredí Java sa stále rýchlo vyvíja. Prvé Java implementácie MCP sa objavili koncom roka 2024 a odvtedy prešli viacerými zmenami. Spring AI je vo verzii 2.0.0 a medzi jednotlivými verziami sa menili názvy artefaktov, balíkov aj spôsob konfigurácie. Pred použitím ukážok z internetu si preto vždy over aktuálne verzie závislostí a konfiguráciu v dokumentácii alebo na Maven Central.
Príprava prostredia a závislostí
Začneme podobne ako pri každom novom projekte v Spring Frameworku. Cez Spring Initializr si vytvoríme prázdny Maven projekt, ktorý si naimportujeme do vývojového prostredia IntelliJ.
Na zostavenie projektu použi nástroj Maven. V projekte je nevyhnutné nastaviť verziu jazyka Java 25 a naimportovať Spring AI BOM (Bill of Materials), z ktorého sa odvíja presná verzia MCP starteru.
Do súboru pom.xml pridaj nasledujúcu konfiguračnú štruktúru (ak ju tam už nemáš):
XML
<properties>
<java.version>25</java.version>
<spring-ai.version>2.0.0</spring-ai.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- Spring AI BOM riadi verzie všetkých AI/MCP artefaktov -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>${spring-ai.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- Spring Boot starter pre základnú konfiguráciu -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Spring AI 2.0 MCP server starter - variant pre STDIO/SSE (bez webovej vrstvy) -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-mcp-server</artifactId>
</dependency>
</dependencies>
Vo verzii Spring AI 2.0.0 sa MCP štartéry delia podľa transportu: spring-ai-starter-mcp-server (STDIO/SSE – presne to, čo potrebujeme), spring-ai-starter-mcp-server-webmvc (Streamable-HTTP, blokujúci) a spring-ai-starter-mcp-server-webflux (Streamable-HTTP, reaktívny).
Dátový model pomocou Java Records
Na reprezentáciu poznámok využijeme records (záznamy). Tie nám umožňujú deklarovať čisté dátové štruktúry bez zbytočného boilerplate kódu. Použijeme pokročilú validáciu priamo v kompaktnom konštruktore, čo garantuje integritu dát pri prenose medzi serverom a modelom.
Java
package sk.msgprogramator.mcpserver.model;
import java.time.Instant;
public record Note(
String id,
String title,
String content,
Instant createdAt
) {
// Kompaktný konštruktor pre validáciu dátových polí
public Note {
if (id == null || id.isBlank()) {
throw new IllegalArgumentException("Identifikátor poznámky nesmie byť prázdny.");
}
if (title == null || title.isBlank()) {
throw new IllegalArgumentException("Titulok poznámky je povinný.");
}
}
}
Biznis logika: Správa súborov cez Java Streams API
Vytvoríme servisnú vrstvu, ktorá bude priamo manipulovať s lokálnym úložiskom. Využijeme moderné Java Streams API na efektívne filtrovanie a spracovanie súborov na disku. Ide o čistú biznis logiku nezávislú od MCP protokolu.
Java
package sk.msgprogramator.mcpserver.service;
import org.springframework.stereotype.Service;
import sk.msgprogramator.mcpserver.model.Note;
import java.io.IOException;
import java.nio.file.*;
import java.time.Instant;
import java.util.List;
import java.util.stream.Stream;
@Service
public class NoteService {
private final Path storageDirectory = Paths.get(System.getProperty("user.home"), "mcp-notes");
public NoteService() throws IOException {
if (!Files.exists(storageDirectory)) {
Files.createDirectories(storageDirectory);
}
}
public List<Note> getAllNotes() throws IOException {
try (Stream<Path> stream = Files.walk(storageDirectory, 1)) {
return stream
.filter(Files::isRegularFile)
.filter(path -> path.toString().endsWith(".md"))
.map(this::readNoteFromFile)
.toList();
}
}
public String saveNote(String title, String content) throws IOException {
String fileName = title.toLowerCase().replaceAll("\\s+", "-") + ".md";
Path targetPath = storageDirectory.resolve(fileName);
String fileContent = """
# %s
Vytvorené: %s
%s
""".formatted(title, Instant.now().toString(), content);
Files.writeString(targetPath, fileContent, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
return "Poznámka s názvom " + title + " bola úspešne uložená na lokálny disk.";
}
private Note readNoteFromFile(Path path) {
try {
String id = path.getFileName().toString();
String title = id.replace(".md", "").replace("-", " ");
String content = Files.readString(path);
Instant lastModified = Files.getLastModifiedTime(path).toInstant();
return new Note(id, title, content, lastModified);
} catch (IOException e) {
throw new RuntimeException("Chyba pri čítaní súboru poznámky", e);
}
}
}
Defenzívne programovanie a registrácia nástrojov
Umelá inteligencia občas trpí halucináciami a môže do parametrov nástrojov poslať neúplné štruktúry, prázdne texty alebo nesprávne dátové typy. Ak náš server neošetrí robustne tieto stavy, hrozí pád celého podprocesu.
V Spring AI 2.0.0 stačí označiť bežnú metódu Spring beanu anotáciou @McpTool, parametre sú štandardné typované Java parametre a JSON schéma sa z nich vygeneruje automaticky. Vďaka tomu odpadáva ručné pretypovávanie.
V konfigurácii nástrojov využijeme silu moderného prepínača switch s priraďovaním vzorov (pattern matching) z Javy 21. Vďaka tomu dokážeš v jedinom výraze elegantne skontrolovať typovú príslušnosť, prítomnosť hodnoty (null-safety) a splnenie logických podmienok pomocou klauzuly case.
Poznámka: Určite je vhodné sa trochu pohrať aj s vyčistením oddeľovačov ciest a iných neželaných a bielych znakov zo vstupných dát. Ak model (alebo používateľ) pošle title s ”/” alebo “..”, teoreticky sa dá zapisovať mimo mcp-notes adresára, čo určite nechceš. Toto si tiež radšej precvič.
Java
package sk.msgprogramator.mcpserver.config;
import org.springframework.ai.mcp.annotation.McpTool;
import org.springframework.ai.mcp.annotation.McpToolParam;
import org.springframework.stereotype.Component;
import sk.msgprogramator.mcpserver.service.NoteService;
import java.io.IOException;
@Component
public class NoteMcpTools {
private final NoteService noteService;
public NoteMcpTools(NoteService noteService) {
this.noteService = noteService;
}
@McpTool(
name = "searchNotes",
description = "Vyhľadávanie v poznámkach podľa kľúčového slova"
)
public Object searchNotes(
@McpToolParam(description = "Hľadaný výraz", required = true)
String keyword) {
// Aj pri povinnom parametri sa môže stať, že model pošle null alebo prázdny text.
// Java switch s pattern matching to elegantne odchytí v jednom výraze.
return switch (keyword) {
case null -> "Chyba: Vyžadovaný parameter 'keyword' kompletne chýba.";
case String kw when kw.isBlank() -> "Chyba: Vyhľadávacie kľúčové slovo nesmie byť prázdne.";
case String kw -> {
try {
yield noteService.getAllNotes().stream()
.filter(note -> note.content().toLowerCase().contains(kw.toLowerCase()))
.toList();
} catch (IOException e) {
yield "Chyba: Zlyhalo prehľadávanie lokálneho disku.";
}
}
};
}
@McpTool(
name = "createNewNote",
description = "Vytvorenie novej Markdown poznámky"
)
public String createNewNote(
@McpToolParam(description = "Titulok poznámky", required = true) String title,
@McpToolParam(description = "Obsah poznámky", required = true) String content) {
if (title == null || title.isBlank() || content == null || content.isBlank()) {
return "Chyba: Titulok ani obsah poznámky nesmú byť prázdne textové reťazce.";
}
try {
return noteService.saveNote(title, content);
} catch (IOException e) {
return "Chyba: Zlyhal fyzický zápis súboru na disk.";
}
}
}
Zdroj (resource) evidencie poznámok sa v novej verzii tiež registruje deklaratívne a anotovaná metóda priamo vracia dáta, ktoré má MCP klient k dispozícii na čítanie.
package sk.msgprogramator.mcpserver.config;
import org.springframework.ai.mcp.annotation.McpResource;
import org.springframework.stereotype.Component;
import sk.msgprogramator.mcpserver.model.Note;
import sk.msgprogramator.mcpserver.service.NoteService;
import java.io.IOException;
import java.util.List;
@Component
public class NoteMcpResources {
private final NoteService noteService;
public NoteMcpResources(NoteService noteService) {
this.noteService = noteService;
}
@McpResource(
uri = "mcp://notes/list",
name = "Zoznam vývojárskych poznámok",
description = "Poskytuje kompletný prehľad všetkých dostupných lokálnych Markdown súborov s poznámkami."
)
public List<Note> listAllNotes() throws IOException {
return noteService.getAllNotes();
}
}
Spustenie aplikácie v režime stdio
V súbore src/main/resources/application.properties nastavíme identifikáciu servera a aktivujeme STDIO transport.
Properties
# Vypnutie webového servera a úvodného Spring Boot bannera – oboje by inak
# zapisovalo znaky priamo do stdout a rozbilo by JSON-RPC komunikáciu
spring.main.web-application-type=none
spring.main.banner-mode=off
# Identifikácia servera – klient si ju vyžiada pri handshake-i
spring.ai.mcp.server.name=developer-notes-server
spring.ai.mcp.server.version=1.0.0
# Aktivácia STDIO transportu v Spring AI 2.0
spring.ai.mcp.server.stdio=true
# Automatické skenovanie tried s anotáciami @McpTool / @McpResource
spring.ai.mcp.server.annotation-scanner.enabled=true
Hlavná trieda ostáva minimalistická.
Java
package sk.msgprogramator.mcpserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class McpServerApplication {
public static void main(String[] args) {
SpringApplication.run(McpServerApplication.class, args);
}
}
Kritická pasca s názvom stdout a správne debugovanie
Pri vývoji bežných aplikácií v Spring Boot sledujeme dianie pomocou konzolových výpisov. Používame logovacie frameworky alebo priame volanie System.out.println().
V prostredí lokálneho MCP servera je takéto konanie fatálnou chybou.
Keďže transportná vrstva stdio využíva štandardný výstup (stdout) ako čistý komunikačný kanál pre správy JSON-RPC 2.0, akýkoľvek iný znak zapísaný do tohto streamu ho kompletne znehodnotí. Ak tvoja aplikácia pri štarte vypíše grafické logo Spring Boot (ASCII banner) alebo vygeneruje informačný log o pripojení k databáze, klientska aplikácia Claude Desktop sa pokúsi tieto riadky parsovať ako JSON objekt. Výsledkom je okamžité zlyhanie parsovania, prerušenie komunikácie a pád servera.
Preto sme v application.properties vyššie okrem web-application-type=none explicitne vypli aj banner-mode, banner sa totiž vypisuje priamo cez System.out nezávisle od logovacieho frameworku, takže samotné presmerovanie logov by ho nezachytilo.
Bezpečné presmerovanie logovania
Riešením nie je úplné vypnutie logov, pretože bez nich by debugovanie chýb v produkčnom prostredí nebolo možné. Musíme prinútiť Spring Boot, aby všetky diagnostické informácie posielal buď do fyzického súboru na disku, alebo na štandardný chybový výstup (System.err). Protokol chybový výstup ignoruje a Claude Desktop ho bezpečne ukladá do svojich lokálnych diagnostických logov.
Vytvor súbor src/main/resources/logback-spring.xml a vlož doň nasledujúcu konfiguráciu:
XML
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- Appender pre zápis do fyzického súboru v domovskom adresári -->
<appender name="FILE" class="ch.qos.logback.core.FileAppender">
<file>${user.home}/logs/mcp-server.log</file>
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<!-- Appender pre bezpečný chybový výstup, ktorý nenaruší JSON stream -->
<appender name="STDERR" class="ch.qos.logback.core.ConsoleAppender">
<target>System.err</target>
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<!-- Globálne nastavenie smerovania logov -->
<root level="INFO">
<appender-ref ref="FILE" />
<appender-ref ref="STDERR" />
</root>
</configuration>
Týmto krokom sme zabezpečili, že stdout zostane exkluzívne vyhradený pre dáta Spring AI protokolu, zatiaľ čo kompletné logy aplikácie nájdeš prehľadne usporiadané v priečinku ${user.home}/logs/mcp-server.log.
Ako otestovať a pripojiť vlastný MCP server
Máš kompletne pripravenú lokálnu aplikáciu v Spring Boot. Teraz ju prepojíme s používateľským prostredím Claude Desktop. Výhodou transportnej vrstvy stdio je, že klientska aplikácia dokáže sama spustiť tvoj skompilovaný program na pozadí operačného systému. Nasledujúci postup ťa prevedie kompiláciou, konfiguráciou aj testovaním v reálnom prostredí.
1. Zostavenie aplikácie do JAR súboru (vyžaduje Maven)
Najskôr musíme projekt skompilovať a zabaliť do spustiteľného archívu. V koreňovom adresári tvojho projektu spusti príkaz pre nástroj Maven: ./mvnw clean package.
Tento príkaz vymaže staré zostavenia a v priečinku target vytvorí súbor s názvom napríklad McpServer-0.0.1-SNAPSHOT.jar. Poznač si presnú absolútnu cestu k tomuto súboru.
2. Lokalizácia konfiguračného súboru Claude Desktop (závisí od operačného systému)
Claude Desktop ukladá nastavenia pre externé moduly v súbore s názvom claude_desktop_config.json. Jeho umiestnenie sa líši podľa platformy:
- Windows: %APPDATA%\Claude\claude_desktop_config.json
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Ak tento súbor na danej ceste neexistuje, vytvor nový textový súbor s týmto presným názvom.
3. Úprava konfigurácie na MCP server (editácia JSON štruktúry)
Otvor konfiguračný súbor v textovom editore a pridaj doň na začiatok definíciu pre tvoj nový server. Využijeme príkaz java z tvojho lokálneho vývojového prostredia, ktoré spúšťa prostredie Java 25. Štruktúra súboru musí vyzerať nasledovne:
JSON
"mcpServers": {
"developer-notes-server": {
"command": "java",
"args": [
"-jar",
"C:\\Users\\JojoW\\IdeaProjects\\McpServer\\target\\McpServer-0.0.1-SNAPSHOT.jar"
]
}
},
Nezabudni nahradiť vzorovú cestu k jar súboru skutočnou cestou v tvojom súborovom systéme. Súbor ulož.
Odporúčame ti…
Po zmene konfigurácie MCP serverov nestačí iba zavrieť okno Claude Desktop. Aplikácia zostáva aktívna v systémovej lište. Je potrebné ju úplne ukončiť cez ikonu v tray a následne znova spustiť, aby sa načítala nová konfigurácia.
4. Reštart klienta a overenie integrácie (kontrola grafického rozhrania)
Úplne ukonči aplikáciu Claude Desktop (použi reálnu možnosť Quit v menu) a znova ju naštartuj. V pravom dolnom rohu vstupného textového poľa pre zadávanie správ uvidíš malú ikonu montážneho kľúča.
Keď na túto ikonu klikneš, zobrazí sa zoznam dvoch registrovaných nástrojov: searchNotes a createNewNote. To znamená, že klient úspešne naštartoval tvoju Spring Boot aplikáciu.
5. Praktické testovanie interakcie v chate
Keď je prepojenie aktívne, môžeš začať písať príkazy priamo v prirodzenom jazyku. Celé čaro spočíva v tom, že model sám vyhodnotí, kedy má použiť tvoj MCP server.
Vyskúšaj do chatu zadať nasledujúci príkaz:
Vytvor mi novú poznámku o konfigurácii MCP serveru pre Spring Boot aplikácie. Napíš tam základné pravidlá.V tom momente uvidíš v rozhraní vizuálnu indikáciu, že Claude volá externý nástroj createNewNote s parametrami, ktoré sám vygeneroval z tvojho textu. Ak sa pozrieš do svojho domovského priečinka do adresára mcp-notes, nájdeš tam čerstvo vytvorený Markdown súbor.
Následne môžeš otestovať vyhľadávanie:
Pozri sa do mojich poznámok a zisti, či som si niekde nepísal o nastavení MCP servera.Model automaticky použije nástroj searchNotes, pošle kľúčové slovo, tvoja Spring Boot aplikácia pomocou Java Streams API prehľadá diskové úložisko, vráti surový text a model ho následne interpretuje priamo v odpovedi.
Pripravili sme pre teba súbory so spomínaným príkladom vo forme zdrojového kódu, ktorý si môžeš vyskúšať. Stiahni si kód MCP Server tu.
Hotové MCP servery: oficiálny ekosystém a komunitné katalógy
Keď už máš jasnú predstavu, ako postaviť vlastný MCP server od úplného základu, nemusíš všetko programovať sám. Ekosystém okolo Model Context Protocol rastie rýchlo a globálna komunita už vytvorila desiatky predpripravených integrácií, ktoré môžeš okamžite začať používať alebo sa nimi inšpirovať pri písaní vlastnej biznis logiky v Spring Boot.
Pre ďalšie štúdium a rozširovanie možností tvojho asistenta odporúčam sledovať tieto kľúčové zdroje:
- Oficiálna špecifikácia protokolu: Kompletnú technickú dokumentáciu, detailný popis životného cyklu správ a architektonické novinky priamo od tvorcov štandardu nájdeš na oficiálnom webe modelcontextprotocol.io alebo v repozitároch organizácie na platforme GitHub.
- Komunitný katalóg Smithery: Ak hľadáš inšpiráciu pre hotové riešenia, projekt smithery.ai funguje ako verejný register, kde vývojári z celého sveta zdieľajú svoje open-source servery. Nájdeš tam hotové integrácie pre databázy PostgreSQL, platformy GitHub a GitLab, prípadne rôzne cloudové služby.
- Referenčné servery od Anthropic: Tvorcovia protokolu spravujú repozitár s názvom mcp-servers, ktorý obsahuje referenčné implementácie pre systémy ako Google Drive, Slack, Kubernetes alebo lokálne vývojárske nástroje. Hoci sú tieto príklady väčšinou napísané v jazykoch TypeScript alebo Python, poskytnú ti presný prehľad o tom, ako správne štruktúrovať JSON schémy pre zložité vstupné parametre.
- Oficiálny Azure DevOps MCP server: Microsoft ho vydal ako open-source projekt microsoft/azure-devops-mcp a sprístupňuje cez neho work items, pull requesty, buildy, test plans aj dokumentáciu z tvojej Azure DevOps organizácie. Existuje v dvoch podobách, ktoré zodpovedajú transportným vrstvám opísaným vyššie: lokálny server cez stdio (balík @azure-devops/mcp, vyžaduje Node.js 20+) a vzdialený hostovaný endpoint cez Streamable HTTP s autentifikáciou cez Microsoft Entra. Ak tím pracuje v Microsoft ekosystéme, je to najrýchlejší spôsob, ako dať agentovi kontext z reálneho projektu bez písania jediného riadku vlastného servera.
Tieto platformy ti pomôžu rýchlo sa zorientovať v tom, čo už komunita úspešne vyriešila, a ušetria ti desiatky hodín času pri navrhovaní dátových štruktúr pre tvoje vlastné podnikové aplikácie.
FAQ: Často kladené otázky o MCP serveri
Je Model Context Protocol viazaný len na modely od Anthropic?
Nie, Model Context Protocol (MCP) nie je viazaný len na modely od Anthropic. Hoci tento otvorený štandard predstavila práve táto spoločnosť, protokol je od začiatku navrhnutý ako agnostický voči konkrétnemu poskytovateľovi AI modelu. Podporuje ho rastúci ekosystém klientov vrátane vývojových prostredí ako Cursor či Cline, ako aj frameworkov na tvorbu autonómnych agentov. Rovnako dobre ho vieš prepojiť s modelmi od OpenAI, Google Gemini alebo s lokálnymi modelmi bežiacimi cez Ollama, pokiaľ klientska aplikácia implementuje MCP rozhranie.
Aký je rozdiel medzi klasickým REST API a MCP serverom?
Hlavný rozdiel je v tom, kto rozhoduje, kedy sa daná funkcionalita zavolá. Klasické REST API je navrhnuté pre deterministickú komunikáciu medzi dvoma programami, kde vývojár vopred presne definuje, kedy a aký endpoint sa má zavolať. MCP server funguje na vyššej úrovni abstrakcie: namiesto pevne daných dátových ciest poskytuje jazykovému modelu popis svojich schopností (nástrojov, zdrojov a promptov) vo forme metadát. O tom, kedy, prečo a s akými parametrami sa konkrétny nástroj vykoná, rozhoduje na základe kontextu konverzácie samotný LLM, nie vopred napísaná aplikačná logika.
Ako zabezpečiť MCP server pri prístupe k citlivým dátam?
Spôsob zabezpečenia závisí od zvoleného transportu. Pri lokálnom prepojení cez štandardný vstup a výstup (stdio) preberá MCP server rovnaké prístupové práva, aké má používateľ, pod ktorým beží klientska aplikácia, takže osobitná autentifikácia zvyčajne nie je potrebná. Pri nasadení cez sieťový transport Streamable HTTP, ktorý dnes nahradil starší a už deprecated SSE transport, je potrebné bezpečnosť riešiť na úrovni HTTP vrstvy. Framework Spring Boot v kombinácii so Spring Security umožňuje štandardne vynútiť autentifikáciu pomocou API kľúčov, protokolu OAuth2 alebo JWT tokenov, čím zaistíš, že k nástrojom získajú prístup iba autorizovaní klienti. Nezávisle od transportu vždy validuj a sanitizuj vstupné parametre, ktoré do nástrojov posiela model, a loguj volania nástrojov: o použití konkrétneho nástroja rozhoduje model autonómne.
Môže jedna Spring Boot aplikácia fungovať zároveň ako REST API aj ako MCP server?
Áno, jedna Spring Boot aplikácia môže súčasne slúžiť ako klasické REST API aj ako MCP server. V našom praktickom príklade sme webový server vypli, aby sme ušetrili systémové zdroje pri čisto lokálnom vývoji cez stdio transport. Ak však webový kontajner necháš zapnutý a namiesto stdio transportu nakonfiguruješ Streamable HTTP koncový bod (pomocou starterov spring-ai-starter-mcp-server-webmvc alebo -webflux), tvoja aplikácia môže bez problémov slúžiť ako bežné backendové REST rozhranie pre frontend a zároveň poskytovať tú istú biznis logiku modelom cez Model Context Protocol.
Aké programovacie jazyky podporujú tvorbu MCP serverov?
Model Context Protocol nie je naviazaný na žiadny konkrétny jazyk. Oficiálne SDK existujú napríklad pre TypeScript, Python, Javu, C# alebo Kotlin, a keďže ide o otvorenú špecifikáciu postavenú na JSON-RPC 2.0, MCP server sa dá napísať prakticky v ktoromkoľvek jazyku, ktorý dokáže spracovať komunikáciu cez štandardný vstup/výstup alebo HTTP. V tomto článku sme si to ukázali na Jave a Spring Boote, princíp však ostáva rovnaký naprieč ekosystémami.
Je Model Context Protocol to isté ako function calling (tool calling) v LLM?
Nie, aj keď tieto dva koncepty úzko súvisia a navzájom sa dopĺňajú. Function calling je schopnosť samotného jazykového modelu rozpoznať, že na splnenie úlohy potrebuje zavolať externú funkciu, a vygenerovať k tomu štruktúrovanú požiadavku. MCP je štandardizovaný spôsob, akým sa takéto funkcie (nástroje), dáta (zdroje) a šablóny (prompty) sprístupňujú modelu naprieč rôznymi klientmi a aplikáciami. Zjednodušene, function calling je mechanizmus, MCP je protokol, ktorý ho robí prenositeľným a znovupoužiteľným.
Budúcnosť MCP a ekosystému okolo neho
Štandardizácia je historicky overeným indikátorom toho, že technológia dospieva. Podobne ako príchod SQL zjednotil prácu s relačnými databázami, otvorený štandard Model Context Protocol prináša chýbajúci poriadok do rýchlo rastúceho sveta umelej inteligencie. Ukončuje éru, kedy bol vývojár nútený písať desiatky nekompatibilných integračných mostov pre každého nového asistenta či platformu zvlášť.
Prepojenie moderného ekosystému, ktorý reprezentuje framework Spring Boot, najnovšej verzie jazyka Java 25 a rozhrania Spring AI, predstavuje pre podnikové aplikácie výraznú výhodu. Umožňuje firmám premeniť ich existujúcu biznis logiku, zabezpečené dátové úložiská a interné API systémy na okamžite dostupný kontext pre akýkoľvek kompatibilný LLM. To všetko s plnou kontrolou nad bezpečnosťou, kedy citlivé informácie vôbec nemusia opustiť lokálnu infraštruktúru a filter v podobe architektúry MCP server prepustí smerom von len presne vyžiadané minimum dát.
Budúcnosť tohto protokolu smeruje k plne autonómnym agentom. Asistenti sa už nebudú obmedzovať iba na pasívne čítanie textu v rámci limitov, ktoré im určuje context window, ale budú schopní reálne a bezpečne vykonávať komplexné operácie v lokálnom aj cloudovom prostredí. Ekosystém okolo tejto technológie sa dynamicky rozširuje, pribúdajú predpripravené integrácie pre populárne vývojárske nástroje a databázy, čo zjednodušuje ich nasadenie do každodennej praxe.
Implementácia vlastného riešenia nie je len experimentom s novou technológiou. Je to strategický krok smerom k budovaniu softvérovej architektúry, ktorá je pripravená na novú éru vývoja poháňaného umelou inteligenciou. Vývojári, ktorí dokážu efektívne prepojiť existujúce backendové systémy s možnosťami moderných modelov, získajú zásadnú konkurenčnú výhodu v rýchlosti a kvalite dodávaných riešení.
Zdroje:
- https://modelcontextprotocol.io/specification/latest/basic/transports/streamable-http
- https://modelcontextprotocol.io/docs/getting-started/intro
- https://github.com/modelcontextprotocol/servers
- https://spring.io/projects/spring-ai
