Model Context Protocol (MCP) Guide 2026

Úvod: Prečo vôbec potrebujeme jednotný štandard pre AI integrácie

Ak ste čítali naše predchádzajúce články o Agentic RAG pipeline a multi-agentných systémoch, viete, že moderné AI aplikácie nie sú izolované ostrovy. Agenti potrebujú pristupovať k databázam, volať API, čítať súbory, komunikovať so Slackom, spravovať kalendáre — a robiť pritom stovky ďalších vecí. A práve tu začína problém. Každá integrácia bola doposiaľ unikátna, manuálna a (úprimne povedané) dosť náchylná na chyby.

Predstavte si túto situáciu: vyvíjate AI asistenta pre zákaznícku podporu. Potrebuje pristupovať k CRM systému, čítať dokumentáciu z Confluence, prehľadávať tickety v Jira a komunikovať cez Slack. Pre každú z týchto integrácií musíte napísať vlastný adaptér, definovať vlastné schémy, ošetriť autentifikáciu a udržiavať kód pri každej zmene API. Znásobte to počtom nástrojov a máte nočnú moru údržby.

Model Context Protocol (MCP) je odpoveďou na tento problém. Je to otvorený štandard vytvorený spoločnosťou Anthropic, ktorý definuje jednotný spôsob, akým AI aplikácie komunikujú s externými nástrojmi a zdrojmi dát. Dá sa to prirovnať k USB-C portu pre AI — tak ako USB-C štandardizoval pripojenie periférií k zariadeniam, MCP štandardizuje pripojenie AI modelov k dátovým zdrojom a nástrojom.

V decembri 2025 Anthropic daroval MCP nadácii Agentic AI Foundation (AAIF) pod Linux Foundation, spoločne s partnermi ako OpenAI a Block. V roku 2026 je MCP de facto priemyselným štandardom — adoptovali ho Microsoft Copilot Studio, Google, LangChain a tisíce ďalších projektov. Oficiálne SDK existujú pre Python, TypeScript, Java, Go, Kotlin aj C#.

V tomto sprievodcovi si prejdeme MCP od základov po produkčné nasadenie. Architektúru, primitívy, transportné protokoly, praktickú implementáciu serverov aj klientov, integráciu s frameworkmi a bezpečnostné aspekty. Tak poďme na to.

Problém fragmentovaných integrácií

Skôr než sa ponoríme do MCP, poďme si jasne pomenovať problém, ktorý rieši. Tradičné AI integrácie fungujú zhruba takto:

Každý nástroj = vlastný kód: Pre každé externé API píšete unikátny wrapper s vlastnou logikou volania, parsovaním odpovede a ošetrením chýb
Duplicitná práca: Ak máte tri rôzne AI aplikácie a desať nástrojov, potrebujete tridsať integrácií. Každý tím rieši rovnaký problém odznova
Nestabilita: Keď sa zmení API niektorého nástroja, musíte aktualizovať kód vo všetkých aplikáciách, ktoré ho používajú
Chýbajúca štandardizácia: Každá integrácia definuje nástroje inak — iné schémy, iné pomenovanie, iná granularita
Bezpečnostné riziká: Bez jednotného modelu oprávnení je ťažké zabezpečiť, že AI agent pristupuje len k tomu, k čomu má

MCP tieto problémy rieši elegantne. Namiesto M×N integrácií (M aplikácií × N nástrojov) potrebujete len M+N implementácií — každá aplikácia implementuje jedného MCP klienta a každý nástroj jeden MCP server. A keďže protokol je štandardizovaný, akýkoľvek MCP klient vie komunikovať s akýmkoľvek MCP serverom. Presne tak, ako funguje USB.

Architektúra MCP: Host, klient a server

MCP využíva architektúru typu klient–server s tromi kľúčovými rolami. Pochopenie tejto hierarchie je základ pre správnu implementáciu — a verím, že keď uvidíte, ako jednotlivé časti do seba zapadajú, začne vám to dávať veľký zmysel.

MCP Host

Host je aplikácia, v ktorej beží LLM — chatbot, IDE s AI asistentom, automatizačný systém alebo akákoľvek iná AI aplikácia. Host orchestruje MCP schopnosti a koordinuje prístup LLM k relevantnému kontextu. Príklady hostov sú Claude Desktop, VS Code s Copilotom alebo vaša vlastná aplikácia.

MCP klient

Klient je ľahký proces, ktorý host spúšťa pre komunikáciu so servermi. Každý klient udržiava vyhradené spojenie 1:1 s jedným MCP serverom. Host môže paralelne spúšťať viacero klientov — jeden pre každý server. Klient sa stará o nízkoúrovňové protokolové správy, objavovanie schopností servera a spravovanie interakcií.

MCP server

Server je služba, ktorá poskytuje špecializovaný kontext pre LLM. Exponuje svoje schopnosti (nástroje, zdroje a prompt šablóny) štandardizovaným spôsobom. Server môže byť lokálny proces komunikujúci cez stdio, alebo vzdialená HTTP služba.

A tu je to podstatné — server nemusí vedieť vôbec nič o konkrétnom LLM modeli. Stačí mu implementovať MCP protokol.

Táto modulárna architektúra zabezpečuje jasné oddelenie zodpovedností. Host vynucuje oprávnenia a schvaľovanie akcií používateľom, takže LLM nikdy nemá nekontrolovaný prístup k externým systémom.

Tri základné primitívy MCP

MCP definuje tri základné typy schopností, ktoré server môže exponovať. Každý primitív má jasný účel a odlišný model interakcie. Prejdime si ich.

1. Tools (Nástroje)

Nástroje sú konkrétne akcie, ktoré MCP server sprístupňuje klientom — funkcie alebo API volania, ktoré LLM môže spustiť počas konverzácie. Keď používateľ žiada niečo, čo vyžaduje akciu (získanie dát, spustenie výpočtu, odoslanie e-mailu), model si vyberie príslušný nástroj.

Kľúčové vlastnosti nástrojov:

Sú riadené modelom — LLM sa sám rozhodne, kedy a aký nástroj použiť na základe kontextu konverzácie
Majú definovanú schému — vstupy a výstupy sú typované pomocou JSON Schema
Vyžadujú schválenie — každé vykonanie nástroja vyžaduje explicitný súhlas používateľa
Sú objaviteľné — klient ich dynamicky objaví cez endpoint tools/list

2. Resources (Zdroje)

Zdroje sú dátové entity, ktoré server zdieľa s AI modelom — súbory, databázové schémy, konfigurácie, dokumenty alebo akékoľvek informácie poskytujúce kontext. Ak si nástroje predstavíte ako POST endpointy (vykonávajú akcie), zdroje sú ako GET endpointy (poskytujú dáta). Takáto analógia mi osobne pomohla pochopiť ten rozdiel najrýchlejšie.

Kľúčové vlastnosti zdrojov:

Sú riadené aplikáciou — hostiteľská aplikácia rozhoduje, ako zdroje začleniť do kontextu
Majú MIME typy — text, JSON, binárne dáta s jasne definovaným obsahom
Podporujú subscripcie — klient môže dostávať aktualizácie v reálnom čase
Používajú URI šablóny — dynamické adresovanie zdrojov, napríklad file:///docs/{path}

3. Prompts (Prompt šablóny)

Prompty sú preddefinované šablóny pre interakciu s LLM — opakovateľné vzory, ktoré pomáhajú používateľom dosiahnuť konkrétne úlohy konzistentne a efektívne.

Kľúčové vlastnosti promptov:

Sú explicitne vyvolané — používateľ alebo klient ich musia aktívne zvoliť
Obsahujú premenné — dynamicky napĺňané hodnoty podľa kontextu
Sú centrálne spravované — aktualizácia šablóny na serveri sa prejaví vo všetkých klientoch
Sú kontextovo citlivé — môžu dynamicky odkazovať na dostupné zdroje a nástroje

Tieto tri primitívy spolupracujú: Prompt štruktúruje zámer, Tool vykoná operáciu a Resource poskytne alebo zachytí dáta. Spoločne vytvárajú modulárnu interakčnú slučku, kde AI agent môže dynamicky objavovať, používať a kombinovať schopnosti ľubovoľného MCP servera.

Transportné protokoly: Ako komunikujú klient a server

MCP definuje viacero transportných protokolov, z ktorých každý je vhodný pre iný scenár. Správna voľba transportu zásadne ovplyvňuje výkon, škálovateľnosť a celkovú architektúru vášho riešenia.

STDIO — lokálna komunikácia

Predvolený transport pre lokálne MCP servery. Komunikácia prebieha cez štandardný vstup a výstup (stdin/stdout). Klient spúšťa server ako podproces a spravuje jeho životný cyklus. Tento transport je ideálny pre desktopové aplikácie ako Claude Desktop alebo príkazové nástroje.

Výhody: Jednoduchosť, žiadna sieťová konfigurácia, natívna izolácia procesov.

Nevýhody: Len lokálne spojenie, jeden klient na server, nie je vhodný pre viacpoužívateľské scenáre.

Streamable HTTP — produkčný štandard

Od verzie špecifikácie 2026-03-26 je Streamable HTTP odporúčaným transportom pre sieťové nasadenia. Nahrádza starší SSE transport. Využíva jeden HTTP endpoint pre obojsmernú komunikáciu, čo výrazne zjednodušuje architektúru oproti predchádzajúcemu prístupu s dvomi oddelenými endpointmi.

Výhody: Plná obojsmerná komunikácia, podpora viacerých klientov súčasne, streamovanie odpovedí, produkčne pripravený.

Nevýhody: Vyššia zložitosť nasadenia, vyžaduje HTTP server.

SSE — len pre spätnú kompatibilitu

Server-Sent Events transport existuje výlučne pre kompatibilitu so staršími klientmi. Nové projekty by mali používať Streamable HTTP. SSE servery sú štandardne dostupné na ceste /sse, zatiaľ čo Streamable HTTP na /mcp.

Praktická implementácia: MCP server v Pythone

Dosť bolo teórie — teraz prejdeme k praxi. Ukážeme si, ako vytvoriť kompletný MCP server v Pythone pomocou oficiálneho SDK a rozhrania FastMCP. Náš server bude poskytovať nástroje pre prácu s databázou SQLite. Je to praktický scenár, ktorý si ľahko prispôsobíte pre vlastné potreby.

Inštalácia a základná štruktúra

# Inštalácia MCP SDK
pip install mcp

# Štruktúra projektu
# mcp-db-server/
# ├── server.py
# └── requirements.txt

Kompletný MCP server s databázovými nástrojmi

import sqlite3
import json
from mcp.server.fastmcp import FastMCP

# Vytvorenie MCP servera
mcp = FastMCP(
    "DatabaseServer",
    json_response=True
)

DB_PATH = "data/knowledge.db"

def get_connection():
    """Vytvorí pripojenie k SQLite databáze."""
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    return conn


# === NÁSTROJE (Tools) ===

@mcp.tool()
def query_database(sql: str, params: list[str] | None = None) -> str:
    """Vykoná SQL SELECT dopyt na databáze a vráti výsledky ako JSON.
    
    Podporuje len SELECT dopyty pre bezpečnosť.
    Parametre sa odovzdávajú ako zoznam hodnôt pre prepared statements.
    """
    if not sql.strip().upper().startswith("SELECT"):
        return json.dumps({"error": "Povolené sú len SELECT dopyty"})
    
    conn = get_connection()
    try:
        cursor = conn.execute(sql, params or [])
        rows = [dict(row) for row in cursor.fetchall()]
        return json.dumps(rows, ensure_ascii=False, default=str)
    except Exception as e:
        return json.dumps({"error": str(e)})
    finally:
        conn.close()


@mcp.tool()
def list_tables() -> str:
    """Vypíše všetky tabuľky v databáze aj s počtom riadkov."""
    conn = get_connection()
    try:
        tables = conn.execute(
            "SELECT name FROM sqlite_master WHERE type='table'"
        ).fetchall()
        
        result = []
        for table in tables:
            count = conn.execute(
                f"SELECT COUNT(*) as cnt FROM [{table['name']}]"
            ).fetchone()
            result.append({
                "table": table["name"],
                "row_count": count["cnt"]
            })
        return json.dumps(result, ensure_ascii=False)
    finally:
        conn.close()


@mcp.tool()
def describe_table(table_name: str) -> str:
    """Vráti schému zadanej tabuľky vrátane stĺpcov a ich typov."""
    conn = get_connection()
    try:
        columns = conn.execute(
            f"PRAGMA table_info([{table_name}])"
        ).fetchall()
        
        schema = [{
            "name": col["name"],
            "type": col["type"],
            "nullable": not col["notnull"],
            "primary_key": bool(col["pk"])
        } for col in columns]
        
        return json.dumps(schema, ensure_ascii=False)
    finally:
        conn.close()


# === ZDROJE (Resources) ===

@mcp.resource("db://schema")
def get_database_schema() -> str:
    """Kompletná schéma databázy pre kontextuálne pochopenie štruktúry."""
    conn = get_connection()
    try:
        tables = conn.execute(
            "SELECT sql FROM sqlite_master WHERE type='table'"
        ).fetchall()
        return "\n\n".join(t["sql"] for t in tables if t["sql"])
    finally:
        conn.close()


@mcp.resource("db://stats")
def get_database_stats() -> str:
    """Štatistiky databázy — veľkosť, počet tabuliek, celkový počet riadkov."""
    conn = get_connection()
    try:
        tables = conn.execute(
            "SELECT name FROM sqlite_master WHERE type='table'"
        ).fetchall()
        
        total_rows = 0
        for table in tables:
            count = conn.execute(
                f"SELECT COUNT(*) FROM [{table['name']}]"
            ).fetchone()
            total_rows += count[0]
        
        stats = {
            "tables_count": len(tables),
            "total_rows": total_rows,
            "database_path": DB_PATH
        }
        return json.dumps(stats, ensure_ascii=False)
    finally:
        conn.close()


# === PROMPT ŠABLÓNY (Prompts) ===

@mcp.prompt()
def analyze_table(table_name: str) -> str:
    """Prompt pre analýzu konkrétnej databázovej tabuľky."""
    return f"""Analyzuj tabuľku '{table_name}' v databáze.

Postupuj nasledovne:
1. Najprv použi nástroj describe_table na získanie schémy
2. Potom použi query_database na zobrazenie prvých 5 riadkov
3. Identifikuj vzory, anomálie a zaujímavé štatistiky
4. Navrhni optimalizácie alebo vylepšenia schémy

Výsledky prezentuj štruktúrovane a zrozumiteľne."""


@mcp.prompt()
def data_report(question: str) -> str:
    """Prompt pre vytvorenie dátového reportu na základe otázky."""
    return f"""Vytvor dátový report, ktorý odpovedá na otázku: {question}

Postupuj nasledovne:
1. Použi list_tables na prehľad dostupných dát
2. Navrhni a vykonaj príslušné SQL dopyty
3. Analyzuj výsledky a prezentuj ich prehľadne
4. Uveď aj limitácie alebo upozornenia k dátam"""


# Spustenie servera
if __name__ == "__main__":
    mcp.run(transport="streamable-http")

Tento server exponuje tri nástroje (dopytovanie, zoznam tabuliek, popis schémy), dva zdroje (schéma a štatistiky) a dve prompt šablóny (analýza tabuľky a dátový report). Všetko je automaticky objaviteľné cez MCP protokol — klient nemusí vopred vedieť, aké schopnosti server poskytuje. To je tá krása celého prístupu.

Dôležité poznámky k implementácii

Pri implementácii MCP servera si dajte pozor na pár vecí, ktoré vás môžu potrápiť (hovorím z vlastnej skúsenosti):

Logovanie: Pre STDIO transport nikdy nepoužívajte print() ani console.log(), pretože to zapisuje na stdout a poruší JSON-RPC správy. Používajte sys.stderr alebo logovací framework zapisujúci do súboru
Typové anotácie: FastMCP automaticky generuje JSON Schema z typových anotácií vašich funkcií — preto je dôležité používať presné typy
Docstringy: Reťazce dokumentácie slúžia ako popisy nástrojov pre LLM — píšte ich jasne a informatívne
Bezpečnosť: Vždy validujte vstupy, obzvlášť SQL dopyty. V produkčnom prostredí použite whitelisty povolených operácií

MCP server v TypeScripte

Pre tých, ktorí preferujú TypeScript, tu je ekvivalentná implementácia. TypeScript SDK ponúka podobne príjemné API.

Nastavenie projektu

# Inicializácia projektu
mkdir mcp-weather-server && cd mcp-weather-server
npm init -y
npm install @modelcontextprotocol/sdk zod@3
npm install -D @types/node typescript

# tsconfig.json — target ES2022, module Node16

Implementácia weather servera

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "WeatherServer",
  version: "1.0.0"
});

// Definícia nástroja s validáciou vstupu pomocou Zod
server.tool(
  "get_weather",
  "Získa aktuálne počasie pre zadané mesto",
  {
    city: z.string().describe("Názov mesta"),
    units: z.enum(["celsius", "fahrenheit"])
      .default("celsius")
      .describe("Jednotky teploty")
  },
  async ({ city, units }) => {
    // V produkcii by sme volali reálne weather API
    const response = await fetch(
      `https://api.weather.example/v1/current?q=${city}`
    );
    const data = await response.json();
    
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          city: city,
          temperature: data.temp,
          units: units,
          condition: data.condition,
          humidity: data.humidity
        }, null, 2)
      }]
    };
  }
);

// Definícia zdroja
server.resource(
  "weather://supported-cities",
  "Zoznam podporovaných miest",
  async () => ({
    contents: [{
      uri: "weather://supported-cities",
      text: JSON.stringify([
        "Bratislava", "Košice", "Žilina",
        "Banská Bystrica", "Nitra", "Prešov"
      ])
    }]
  })
);

// Definícia prompt šablóny
server.prompt(
  "weather_report",
  "Generuje report počasia pre zvolené mesto",
  [{ name: "city", description: "Mesto", required: true }],
  async ({ city }) => ({
    messages: [{
      role: "user",
      content: {
        type: "text",
        text: `Vytvor podrobný report počasia pre ${city}.
Použi nástroj get_weather na získanie aktuálnych dát.
Zahrň odporúčania pre oblečenie a aktivity.`
      }
    }]
  })
);

// Spustenie servera
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Weather MCP server running on stdio");
}

main().catch(console.error);

Tento TypeScript server demonštruje rovnaké tri primitívy — nástroj pre počasie, zdroj so zoznamom miest a prompt šablónu pre report. Zod schémy zabezpečujú validáciu vstupov na úrovni typov, čo je v TypeScripte obzvlášť elegantné riešenie.

MCP klient: Prepojenie s AI agentmi

Server máme vytvorený — teraz potrebujeme klienta, ktorý ho prepojí s AI modelom. Existuje niekoľko prístupov, od priameho použitia MCP SDK po integráciu cez LangChain.

Priamy MCP klient v Pythone

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    # Parametre pre pripojenie k lokálnemu serveru
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"]
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # Inicializácia spojenia
            await session.initialize()
            
            # Objavenie schopností servera
            tools = await session.list_tools()
            print("Dostupné nástroje:")
            for tool in tools.tools:
                print(f"  - {tool.name}: {tool.description}")
            
            resources = await session.list_resources()
            print("\nDostupné zdroje:")
            for res in resources.resources:
                print(f"  - {res.uri}: {res.name}")
            
            # Volanie nástroja
            result = await session.call_tool(
                "list_tables",
                arguments={}
            )
            print(f"\nTabuľky: {result.content[0].text}")
            
            # Čítanie zdroja
            schema = await session.read_resource("db://schema")
            print(f"\nSchéma DB: {schema.contents[0].text}")

import asyncio
asyncio.run(main())

Integrácia s LangChain cez MCP adaptéry

Pre reálne AI aplikácie je ale najefektívnejšie integrovať MCP servery s agentným frameworkom ako LangChain. Knižnica langchain-mcp-adapters automaticky konvertuje MCP nástroje na LangChain nástroje, čo umožňuje ich priame použitie v LangGraph agentoch.

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic

# Konfigurácia viacerých MCP serverov
async def create_agent():
    client = MultiServerMCPClient({
        "database": {
            "transport": "stdio",
            "command": "python",
            "args": ["db_server.py"],
        },
        "weather": {
            "transport": "streamable_http",
            "url": "http://localhost:8000/mcp",
        }
    })
    
    # Načítanie všetkých nástrojov zo všetkých serverov
    tools = await client.get_tools()
    
    # Vytvorenie agenta s Claude modelom
    model = ChatAnthropic(model="claude-sonnet-4-5-20250929")
    agent = create_react_agent(model, tools)
    
    return agent, client

async def main():
    agent, client = await create_agent()
    
    # Agent automaticky vyberie správne nástroje
    response = await agent.ainvoke({
        "messages": [{
            "role": "user",
            "content": "Aké tabuľky máme v databáze a aké je počasie v Bratislave?"
        }]
    })
    
    print(response["messages"][-1].content)

import asyncio
asyncio.run(main())

Toto je neuveriteľne silný vzor. Agent s prístupom k viacerým MCP serverom dokáže dynamicky objavovať a kombinovať nástroje z rôznych domén — databázy, počasie, kalendáre, e-mail — všetko cez jednotný protokol. A čo je kľúčové: pridanie nového MCP servera nevyžaduje žiadnu zmenu v kóde agenta. Nula. Proste pridáte konfiguráciu a je to.

Konfigurácia pre Claude Desktop

Claude Desktop je jedným z najpopulárnejších MCP hostov. Konfigurácia MCP serverov prebieha cez jednoduchý JSON súbor, čo umožňuje rýchle pridávanie nových schopností bez programovania.

{
  "mcpServers": {
    "database": {
      "command": "python",
      "args": ["/cesta/k/db_server.py"],
      "env": {
        "DB_PATH": "/cesta/k/databaze.db"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/dovoleny/adresar"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_vas_token"
      }
    }
  }
}

Po uložení konfigurácie a reštarte Claude Desktop budú všetky tri servery k dispozícii. Claude automaticky objaví ich nástroje a bude ich využívať podľa kontextu konverzácie. Ekosystém MCP serverov na GitHube obsahuje tisíce hotových serverov pre populárne služby — od Slacku cez Google Drive až po Docker.

Bezpečnosť a produkčné nasadenie

MCP prináša obrovskú flexibilitu, ale — a to je dôležité — s veľkou mocou prichádza aj veľká zodpovednosť. Bezpečnosť je kritická téma, ktorú musíte vyriešiť pred akýmkoľvek produkčným nasadením.

Bezpečnostné riziká MCP

V apríli 2025 bezpečnostní výskumníci identifikovali viacero problémov protokolu, o ktorých by ste mali vedieť:

Prompt injection: Škodlivé vstupy môžu manipulovať správanie agenta cez MCP nástroje
Kombinovanie nástrojov pre exfiltráciu: Útočník môže zreťaziť nástroje na únik citlivých dát (napríklad nástroj na čítanie databázy + nástroj na odosielanie HTTP požiadaviek)
Lookalike nástroje: Falošné nástroje s názvami podobnými dôveryhodným, ktoré ich môžu ticho nahradiť
Nadmerné oprávnenia: Servery s príliš širokými oprávneniami umožňujúce nežiaduce akcie

Odporúčané bezpečnostné opatrenia

# Príklad bezpečného MCP servera s validáciou a auditom

from mcp.server.fastmcp import FastMCP
import logging
import re

# Konfigurácia audítneho logu
audit_logger = logging.getLogger("mcp.audit")
audit_logger.setLevel(logging.INFO)
handler = logging.FileHandler("mcp_audit.log")
audit_logger.addHandler(handler)

mcp = FastMCP("SecureDBServer", json_response=True)

# Whitelist povolených tabuliek
ALLOWED_TABLES = {"articles", "categories", "tags"}

# Regex pre detekciu nebezpečných SQL konštrukcií
DANGEROUS_PATTERNS = re.compile(
    r"\b(DROP|DELETE|UPDATE|INSERT|ALTER|CREATE|EXEC)\b",
    re.IGNORECASE
)

@mcp.tool()
def safe_query(sql: str) -> str:
    """Bezpečné vykonanie SQL dopytu s validáciou."""
    
    # Kontrola nebezpečných vzorcov
    if DANGEROUS_PATTERNS.search(sql):
        audit_logger.warning(f"Blokovaný dopyt: {sql}")
        return '{"error": "Nebezpečný SQL dopyt bol blokovaný"}'
    
    # Kontrola, že dopyt pristupuje len k povoleným tabuľkám
    if not sql.strip().upper().startswith("SELECT"):
        return '{"error": "Povolené sú len SELECT dopyty"}'
    
    # Audit log
    audit_logger.info(f"Vykonaný dopyt: {sql}")
    
    # Vykonanie dopytu s limitom výsledkov
    conn = get_connection()
    try:
        # Pridanie LIMIT ak chýba
        if "LIMIT" not in sql.upper():
            sql = sql.rstrip(";") + " LIMIT 100"
        
        cursor = conn.execute(sql)
        rows = [dict(row) for row in cursor.fetchall()]
        return json.dumps(rows, ensure_ascii=False, default=str)
    except Exception as e:
        audit_logger.error(f"Chyba dopytu: {e}")
        return json.dumps({"error": "Chyba pri vykonávaní dopytu"})
    finally:
        conn.close()

Zásady pre produkčné nasadenie

Princíp minimálnych oprávnení: Každý MCP server by mal mať prístup len k tomu, čo nevyhnutne potrebuje
Audit logging: Zaznamenávajte každé volanie nástroja vrátane parametrov a výsledkov
Rate limiting: Obmedzte počet volaní nástrojov za časovú jednotku
Validácia vstupov: Nikdy nedôverujte vstupom od LLM — vždy ich validujte
Izolácia serverov: Spúšťajte MCP servery v izolovaných prostrediach (kontajnery, sandboxe)
Schvaľovanie používateľom: Kritické akcie by mali vždy vyžadovať explicitné schválenie
Monitoring: Sledujte latenciu, chybovosť a neobvyklé vzory používania

Ekosystém a adopcia MCP v roku 2026

MCP prešiel za necelé dva roky od experimentálneho protokolu k priemyselnému štandardu. Je to úctyhodná rýchlosť a stojí za to pozrieť sa na najdôležitejšie míľniky.

Kľúčové adopcie

Microsoft Copilot Studio: Plná podpora MCP — používatelia môžu pridávať MCP servery do Copilot agentov niekoľkými kliknutiami
Google: Spolupráca na oficiálnom Go SDK, integrácia s Gemini ekosystémom
OpenAI: Spoluzakladateľ Agentic AI Foundation, podpora MCP v Agents SDK
LangChain: Natívne MCP adaptéry pre bezšvovú integráciu s LangGraph agentmi
JetBrains: Oficiálny Kotlin SDK, integrácia s IntelliJ platformou
Vývojárske nástroje: Zed, Replit, Codeium a Sourcegraph aktívne integrujú MCP

Čo nás čaká v roku 2026

Multimodálna podpora: MCP začne podporovať obrázky, video, audio a ďalšie mediálne typy — agenti budú nielen čítať a písať, ale aj vidieť a počúvať
Pokročilé správy: Chunked messages umožnia agentom streamovať dlhé výstupy postupne namiesto čakania na kompletný výsledok
Elicitation: Nový mechanizmus, ktorý umožní serveru žiadať dodatočné informácie od používateľa priamo počas spracovania
Štruktúrované výstupy nástrojov: Typované odpovede namiesto voľného textu, čo zlepší spoľahlivosť celého reťazca
Otvorená správa: Transparentné rozhodovanie o budúcnosti protokolu cez komunitu pod Linux Foundation

Komunita a ekosystém

Python SDK má na GitHube vyše 21 700 hviezdičiek a ekosystém serverov rastie exponenciálne. Microsoft vydal otvorený kurz MCP for Beginners, ktorý pokrýva implementáciu v šiestich jazykoch. Tisíce hotových MCP serverov sú k dispozícii pre populárne služby — od GitHub cez Slack, Google Drive, PostgreSQL až po Docker a Kubernetes.

Kedy použiť MCP a kedy nie

MCP nie je strieborná guľka a nie každý projekt ho potrebuje. Osobne som sa stretol s projektmi, kde bol MCP presne to, čo sme potrebovali, aj s takými, kde by bol zbytočnou komplikáciou. Tu je praktický rámec na rozhodovanie.

MCP sa oplatí, keď:

Budujete AI aplikáciu, ktorá potrebuje pristupovať k viacerým externým systémom
Chcete zdieľať nástroje medzi viacerými AI aplikáciami alebo tímami
Potrebujete štandardizovaný spôsob pridávania nových schopností bez zmeny kódu aplikácie
Bezpečnosť a audit sú prioritou — MCP poskytuje jasný model oprávnení
Pracujete v prostredí, kde rôzne tímy vyvíjajú rôzne nástroje nezávisle

MCP pravdepodobne nepotrebujete, keď:

Máte jednu AI aplikáciu s jedným alebo dvoma jednoduchými nástrojmi
Nástroje sa nemenia a nie je potreba ich zdieľať
Váš framework (napríklad OpenAI function calling) pokrýva vaše potreby bez zbytočnej abstrakcie
Prototypujete a rýchlosť iterácie je dôležitejšia než štandardizácia

Záver: MCP ako základ budúcich AI systémov

Model Context Protocol predstavuje fundamentálnu zmenu v tom, ako budujeme AI aplikácie. Namiesto monolitických systémov s pevne zadrôtovanými integráciami smerujeme k modulárnej architektúre, kde AI agenti dynamicky objavujú a používajú nástroje cez štandardizovaný protokol.

Ak ste čítali celú našu sériu — od Agentic RAG pipeline cez multi-agentné systémy až po tento sprievodca MCP — máte teraz celkom kompletný obraz modernej AI infraštruktúry:

Agentic RAG vám umožňuje budovať inteligentné systémy, ktoré sa dokážu samy korigovať a iteratívne zlepšovať odpovede
Multi-agentné systémy vám umožňujú koordinovať tímy špecializovaných agentov pre komplexné úlohy
MCP vám poskytuje štandardizovaný spôsob, ako týmto agentom sprístupniť reálne nástroje a dáta

Spoločne tieto tri piliere tvoria základ pre budovanie produkčných AI systémov, ktoré sú spoľahlivé, škálovateľné a bezpečné. MCP je momentálne v bode, kde boli kontajnery pred desiatimi rokmi — štandard, ktorý sa rýchlo stáva neoddeliteľnou súčasťou každej AI infraštruktúry.

Začnite jednoducho. Nainštalujte MCP SDK, vytvorte jednoduchý server s jedným nástrojom a pripojte ho ku Claude Desktop. Uvidíte, ako rýchlo oceníte eleganciu tohto prístupu. A keď budete pripravení, škálujte na viacero serverov, integrujte s LangChain a nasaďte do produkcie. Ekosystém je pripravený — a vy teraz viete ako na to.