MCP — Model Context Protocol

Model Context Protocol (MCP) představuje nový standard pro propojení AI agentů s externími systémy a daty. Tento protokol umožňuje bezpečnou a efektivní komunikaci mezi jazykovými modely a různými zdroji informací, od databází po cloudové služby.

Co je Model Context Protocol (MCP)¶

Model Context Protocol (MCP) je nový standardizovaný protokol vyvinutý společností Anthropic, který umožňuje velkojazykovým modelům (LLM) bezpečně a efektivně interagovat s externími systémy a nástroji. Protokol řeší dlouhodobý problém v oblasti AI agentů – jak poskytnout modelům přístup k real-time datům a funkcionalitám, aniž bychom ohrozili bezpečnost nebo kontrolu nad systémem.

MCP funguje jako most mezi AI modely a externími zdroji dat, databázemi, API nebo lokálními nástroji. Na rozdíl od tradičních přístupů, kde každý nástroj vyžaduje vlastní integraci, MCP poskytuje jednotné rozhraní pro všechny typy resources a tools.

Architektura a komponenty MCP¶

MCP staví na client-server architektuře s jasně definovanými rolemi:

MCP Client – obvykle AI aplikace nebo agent, který potřebuje přístup k externím zdrojům
MCP Server – poskytuje specifické funkcionality nebo přístup k datům
Transport Layer – zajišťuje komunikaci mezi klientem a serverem (JSON-RPC, WebSockets)

Každý MCP server může exponovat tři hlavní typy capabilities:

Resources – statická nebo semi-statická data (soubory, dokumenty, konfigurační data)
Tools – vykonatelné funkce, které může model volat
Prompts – předpřipravené prompt templates pro specifické úkoly

Implementace MCP serveru v Pythonu¶

Vytvoření vlastního MCP serveru je překvapivě jednoduché. Anthropic poskytuje oficiální SDK, které značně zjednodušuje proces:

from mcp import McpServer, Tool
from mcp.types import TextContent
import asyncio
import json

app = McpServer("file-manager")

@app.tool("read_file")
async def read_file(path: str) -> TextContent:
    """Načte obsah souboru ze zadané cesty"""
    try:
        with open(path, 'r', encoding='utf-8') as file:
            content = file.read()
        return TextContent(
            type="text",
            text=f"Obsah souboru {path}:\n{content}"
        )
    except Exception as e:
        return TextContent(
            type="text", 
            text=f"Chyba při čtení souboru: {str(e)}"
        )

@app.tool("list_directory")
async def list_directory(path: str = ".") -> TextContent:
    """Seznam souborů v adresáři"""
    import os
    try:
        files = os.listdir(path)
        file_list = "\n".join(files)
        return TextContent(
            type="text",
            text=f"Soubory v {path}:\n{file_list}"
        )
    except Exception as e:
        return TextContent(
            type="text",
            text=f"Chyba při listování: {str(e)}"
        )

if __name__ == "__main__":
    asyncio.run(app.run())

Konfigurace a registrace serverů¶

MCP servery se konfigurují prostřednictvím JSON konfiguračního souboru. V případě Claude Desktop se konfigurace ukládá do:

{
  "mcpServers": {
    "file-manager": {
      "command": "python",
      "args": ["path/to/file_server.py"],
      "env": {
        "PYTHONPATH": "/path/to/mcp/sdk"
      }
    },
    "database-connector": {
      "command": "node",
      "args": ["db-server.js"],
      "env": {
        "DB_CONNECTION": "postgresql://user:pass@localhost:5432/mydb"
      }
    }
  }
}

Tato konfigurace umožňuje Claude automaticky spustit a připojit MCP servery při startu aplikace.

Resources vs Tools: Praktické použití¶

Rozlišení mezi Resources a Tools je klíčové pro správné navržení MCP serveru:

Resources – pro čtení dat¶

@app.resource("config://database")
async def get_database_config() -> dict:
    """Vrací konfiguraci databáze"""
    return {
        "host": "localhost",
        "port": 5432,
        "database": "production",
        "tables": ["users", "orders", "products"]
    }

@app.resource("logs://application/{date}")
async def get_application_logs(date: str) -> TextContent:
    """Načte aplikační logy pro konkrétní datum"""
    log_path = f"/var/log/app/{date}.log"
    # implementace čtení logů
    return TextContent(type="text", text=log_content)

Tools – pro akce a změny¶

@app.tool("deploy_application")
async def deploy_application(
    environment: str, 
    version: str
) -> TextContent:
    """Nasadí aplikaci do specifikovaného prostředí"""

    if environment not in ["staging", "production"]:
        return TextContent(
            type="text",
            text="Chyba: Nepodporované prostředí"
        )

    # Logika nasazení
    result = await deploy_to_environment(environment, version)

    return TextContent(
        type="text",
        text=f"Aplikace verze {version} úspěšně nasazena do {environment}"
    )

Bezpečnostní aspekty¶

MCP klade velký důraz na bezpečnost. Každý server běží v izolovaném procesu a komunikace probíhá přes standardizované rozhraní. Důležité bezpečnostní principy zahrnují:

Principle of Least Privilege – každý server má přístup pouze k nezbytným zdrojům
Validace vstupů – všechny parametry musí být validovány před zpracováním
Rate limiting – omezení počtu požadavků za časovou jednotku
Auditování – logování všech operací pro debugging a security monitoring

@app.tool("execute_sql")
async def execute_sql(query: str) -> TextContent:
    """Bezpečné vykonání SQL dotazu"""

    # Whitelist povolených operací
    allowed_operations = ["SELECT", "SHOW", "DESCRIBE"]

    query_upper = query.strip().upper()
    if not any(query_upper.startswith(op) for op in allowed_operations):
        return TextContent(
            type="text",
            text="Chyba: Povoleny jsou pouze SELECT dotazy"
        )

    # Další validace a sanitizace
    # ...

    result = await execute_readonly_query(query)
    return TextContent(type="text", text=str(result))

Integrace s existujícími systémy¶

MCP lze snadno integrovat s existující infrastrukturou. Příklad integrace s Redis cache a PostgreSQL databází:

import redis
import asyncpg
from mcp import McpServer

app = McpServer("data-services")

# Připojení k externím službám
redis_client = redis.Redis(host='localhost', port=6379, db=0)
pg_pool = None

async def init_db():
    global pg_pool
    pg_pool = await asyncpg.create_pool(
        "postgresql://user:password@localhost/mydb"
    )

@app.tool("cache_get")
async def cache_get(key: str) -> TextContent:
    """Načte hodnotu z Redis cache"""
    try:
        value = redis_client.get(key)
        if value is None:
            return TextContent(type="text", text=f"Klíč '{key}' nenalezen")

        return TextContent(
            type="text", 
            text=f"Hodnota pro '{key}': {value.decode('utf-8')}"
        )
    except Exception as e:
        return TextContent(type="text", text=f"Redis error: {str(e)}")

@app.tool("db_query")
async def db_query(sql: str) -> TextContent:
    """Vykoná SELECT dotaz na PostgreSQL"""
    async with pg_pool.acquire() as connection:
        try:
            rows = await connection.fetch(sql)
            result = [dict(row) for row in rows]
            return TextContent(
                type="text",
                text=json.dumps(result, indent=2, ensure_ascii=False)
            )
        except Exception as e:
            return TextContent(type="text", text=f"DB error: {str(e)}")

Shrnutí¶

Model Context Protocol představuje významný krok vpřed v oblasti AI agentů a tool use. Poskytuje standardizovaný, bezpečný a škálovatelný způsob, jak propojit LLM modely s externími systémy. Pro vývojáře znamená MCP možnost rychle vytvářet mocné AI aplikace bez nutnosti řešit komplexní integrační problémy. Protokol je stále v aktivním vývoji, ale už nyní ukazuje obrovský potenciál pro automatizaci a zlepšení efektivity v enterprise prostředí. Očekáváme, že MCP se stane standardem pro AI tool integration v nadcházejících měsících.

mcpprotocoltool use