MCP servery: Propojení AI modelů s reálným světem

Model Context Protocol (MCP) je otevřený standard, který umožňuje propojit AI modely s externími daty, nástroji a systémy. MCP servery fungují jako most mezi AI asistenty a reálným světem, což výrazně rozšiřuje jejich schopnosti a užitečnost. Tento návod vás provede základy MCP serverů a ukáže, jak je můžete začít používat ve svých projektech.

Co jsou MCP servery?

MCP servery jsou programy, které implementují Model Context Protocol - standardizovaný způsob, jak AI modely mohou komunikovat s externími systémy. Fungují jako "adaptéry", které překládají požadavky AI modelů do akcí v reálném světě a naopak.

Hlavní výhody MCP serverů:

1. Přístup k datům - AI modely mohou číst a pracovat s vašimi soubory, databázemi a API
2. Provádění akcí - AI modely mohou spouštět příkazy, manipulovat s daty a interagovat se systémy
3. Standardizace - Jednotný protokol pro všechny typy integrací
4. Bezpečnost - Data zůstávají pod vaší kontrolou, nejsou odesílána poskytovatelům AI
5. Flexibilita - Možnost přepínat mezi různými AI modely bez změny integrací

Jak MCP servery fungují?

MCP funguje na principu klient-server architektury:

1. MCP klient - Aplikace, která používá AI model (např. Claude Desktop, vlastní aplikace)
2. MCP server - Program, který zpřístupňuje určitou funkcionalitu (např. přístup k souborům, databázi, API)
3. Komunikační protokol - Standardizovaný způsob výměny zpráv mezi klientem a serverem

Když AI model potřebuje přístup k datům nebo provést akci:

1. MCP klient pošle požadavek na příslušný MCP server
2. MCP server zpracuje požadavek a provede požadovanou akci
3. MCP server vrátí výsledek zpět klientovi
4. Klient poskytne výsledek AI modelu

Typy MCP serverů

MCP servery můžeme rozdělit do několika kategorií podle typu funkcionality, kterou poskytují:

1. Přístup k souborům a dokumentům

• Filesystem MCP - Přístup k lokálním souborům a adresářům
• Google Drive MCP - Přístup k dokumentům v Google Drive
• Notion MCP - Přístup k dokumentům v Notion
• OneDrive MCP - Přístup k dokumentům v OneDrive

2. Přístup k databázím

• PostgreSQL MCP - Přístup k PostgreSQL databázím
• MySQL MCP - Přístup k MySQL databázím
• MongoDB MCP - Přístup k MongoDB databázím

3. Přístup k vývojářským nástrojům

• GitHub MCP - Přístup k repozitářům na GitHubu
• Git MCP - Přístup k lokálním Git repozitářům
• VS Code MCP - Integrace s Visual Studio Code

4. Přístup k webovým službám

• Slack MCP - Přístup ke Slack konverzacím a kanálům
• Jira MCP - Přístup k Jira ticketům a projektům
• Puppeteer MCP - Automatizace webových prohlížečů

5. Vlastní MCP servery

Můžete vytvořit vlastní MCP servery pro specifické potřeby vaší organizace nebo aplikace.

Začínáme s MCP servery

Předpoklady

• Základní znalost programování
• Nainstalovaný Node.js (pro většinu MCP serverů)
• MCP klient (např. Claude Desktop, vlastní aplikace)

Krok 1: Instalace Claude Desktop (nejjednodušší způsob začít)

1. Navštivte claude.ai/download
2. Stáhněte a nainstalujte Claude Desktop pro váš operační systém
3. Přihlaste se ke svému účtu Claude

Krok 2: Instalace předpřipravených MCP serverů

Claude Desktop obsahuje integrovaný správce MCP serverů:

1. Otevřete Claude Desktop
2. Klikněte na ikonu ozubeného kola v pravém horním rohu
3. Vyberte "MCP Servers"
4. Klikněte na "Add Server"
5. Vyberte z dostupných předpřipravených serverů

Krok 3: Konfigurace MCP serveru

Každý MCP server vyžaduje specifickou konfiguraci:

1. Zadejte název serveru
2. Nastavte cestu k adresáři nebo přihlašovací údaje k službě
3. Nastavte oprávnění (např. které adresáře může server číst/zapisovat)
4. Klikněte na "Save"

Krok 4: Použití MCP serveru s Claude

1. Začněte novou konverzaci s Claude
2. Klikněte na ikonu "+" vedle vstupního pole
3. Vyberte "Connect MCP Server"
4. Vyberte nakonfigurovaný server
5. Nyní můžete požádat Claude o práci s daty z tohoto serveru

Například:

• "Přečti soubor README.md z mého projektu a vysvětli, co dělá."
• "Najdi všechny Python soubory v adresáři src, které obsahují funkci 'process_data'."
• "Vytvoř nový soubor s názvem 'summary.txt' a shrň do něj obsah všech markdown souborů v adresáři docs."

Vytvoření vlastního MCP serveru

Pokud chcete vytvořit vlastní MCP server, máte několik možností:

Použití oficiálních SDK

MCP nabízí SDK pro různé programovací jazyky:

• Python SDK
• TypeScript SDK
• Java SDK
• Kotlin SDK
• C# SDK

Základní struktura MCP serveru

MCP server obvykle obsahuje:

1. Definice nástrojů (tools) - Funkce, které může AI model volat
2. Definice zdrojů (resources) - Data, ke kterým může AI model přistupovat
3. Transportní vrstva - Způsob komunikace s klientem (obvykle stdio nebo HTTP)

Příklad jednoduchého MCP serveru v TypeScriptu

import { createServer, StdioTransport } from '@modelcontextprotocol/typescript-sdk';

// Vytvoření MCP serveru
const server = createServer({
  name: 'Simple Calculator',
  description: 'A simple calculator MCP server',
});

// Definice nástroje (tool)
server.defineTool({
  name: 'add',
  description: 'Add two numbers',
  inputSchema: {
    type: 'object',
    properties: {
      a: { type: 'number', description: 'First number' },
      b: { type: 'number', description: 'Second number' },
    },
    required: ['a', 'b'],
  },
  handler: async (params) => {
    const { a, b } = params;
    return { result: a + b };
  },
});

// Spuštění serveru s stdio transportem
const transport = new StdioTransport();
server.listen(transport);

Příklad jednoduchého MCP serveru v Pythonu

from mcp import Server, StdioTransport

# Vytvoření MCP serveru
server = Server(name="Simple Calculator", description="A simple calculator MCP server")

# Definice nástroje (tool)
@server.tool(
    name="add",
    description="Add two numbers",
    input_schema={
        "type": "object",
        "properties": {
            "a": {"type": "number", "description": "First number"},
            "b": {"type": "number", "description": "Second number"},
        },
        "required": ["a", "b"],
    },
)
async def add(params):
    a = params["a"]
    b = params["b"]
    return {"result": a + b}

# Spuštění serveru s stdio transportem
transport = StdioTransport()
server.listen(transport)

Pokročilé funkce MCP serverů

Přístup k souborům

MCP servery mohou poskytovat bezpečný přístup k souborům:

@server.tool(
    name="read_file",
    description="Read a file from the allowed directory",
    input_schema={
        "type": "object",
        "properties": {
            "path": {"type": "string", "description": "Path to the file"},
        },
        "required": ["path"],
    },
)
async def read_file(params):
    path = params["path"]
    # Ověření, že cesta je v povoleném adresáři
    if not is_path_allowed(path):
        return {"error": "Path not allowed"}

    try:
        with open(path, "r") as f:
            content = f.read()
        return {"content": content}
    except Exception as e:
        return {"error": str(e)}

Přístup k API

MCP servery mohou fungovat jako proxy pro API:

@server.tool(
    name="search_github",
    description="Search for repositories on GitHub",
    input_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Search query"},
            "limit": {"type": "integer", "description": "Maximum number of results"},
        },
        "required": ["query"],
    },
)
async def search_github(params):
    query = params["query"]
    limit = params.get("limit", 10)

    # Volání GitHub API
    response = requests.get(
        f"https://api.github.com/search/repositories?q={query}&per_page={limit}"
    )

    if response.status_code == 200:
        data = response.json()
        return {"repositories": data["items"]}
    else:
        return {"error": f"API error: {response.status_code}"}

Použití MCP serverů s různými AI modely

Claude a Anthropic API

Claude byl první model, který nativně podporoval MCP. Claude Desktop poskytuje uživatelsky přívětivé rozhraní pro práci s MCP servery.

OpenAI a GPT modely

OpenAI modely nemají přímou podporu MCP, ale můžete použít adaptér, který převádí MCP na OpenAI kompatibilní formát:

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from openai import OpenAI

# Funkce pro převod MCP nástroje na OpenAI formát
def convert_tool_format(tool):
    return {
        "type": "function",
        "function": {
            "name": tool.name,
            "description": tool.description,
            "parameters": {
                "type": "object",
                "properties": tool.inputSchema["properties"],
                "required": tool.inputSchema["required"]
            }
        }
    }

# Připojení k MCP serveru
async def connect_to_mcp_server():
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
    )

    stdio_transport = await stdio_client(server_params)
    stdio, write = stdio_transport
    session = await ClientSession(stdio, write)

    # Získání dostupných nástrojů
    response = await session.list_tools()
    available_tools = [convert_tool_format(tool) for tool in response.tools]

    # Použití s OpenAI API
    client = OpenAI()
    completion = client.chat.completions.create(
        model="gpt-4",
        tools=available_tools,
        messages=[
            {"role": "user", "content": "Přečti soubor README.md a shrň jeho obsah."}
        ]
    )

    # Zpracování odpovědi a volání nástroje
    if completion.choices[0].message.tool_calls:
        tool_call = completion.choices[0].message.tool_calls[0]
        tool_name = tool_call.function.name
        tool_args = json.loads(tool_call.function.arguments)

        # Volání MCP nástroje
        result = await session.call_tool(tool_name, tool_args)

        # Pokračování konverzace s výsledkem
        # ...

OpenRouter

OpenRouter poskytuje jednotné API pro přístup k různým AI modelům a také podporuje integraci s MCP servery:

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from openai import OpenAI

# Inicializace OpenRouter klienta
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="váš_openrouter_api_klíč"
)

# Zbytek kódu je stejný jako v předchozím příkladu

Příklady použití MCP serverů

1. Asistent pro práci s kódem

MCP server může poskytnout AI modelu přístup k vašemu kódu:

1. Připojte Git MCP server k vašemu repozitáři
2. Požádejte AI o:
   • Analýzu kódu a návrhy zlepšení
   • Generování dokumentace
   • Hledání a opravování chyb
   • Implementaci nových funkcí

2. Asistent pro práci s daty

MCP server může poskytnout AI modelu přístup k vašim datům:

1. Připojte PostgreSQL MCP server k vaší databázi
2. Požádejte AI o:
   • Analýzu dat a vytvoření reportů
   • Generování SQL dotazů
   • Optimalizaci existujících dotazů
   • Návrhy na zlepšení struktury databáze

3. Asistent pro práci s dokumenty

MCP server může poskytnout AI modelu přístup k vašim dokumentům:

1. Připojte Filesystem MCP server k adresáři s dokumenty
2. Požádejte AI o:
   • Shrnutí dlouhých dokumentů
   • Extrakci klíčových informací
   • Odpovědi na otázky na základě obsahu dokumentů
   • Generování nových dokumentů na základě existujících

Bezpečnost a soukromí

MCP servery pracují s citlivými daty, proto je důležité dbát na bezpečnost:

Doporučení pro bezpečné používání MCP serverů:

1. Omezení přístupu - Povolte přístup pouze k nezbytným adresářům a souborům
2. Kontrola oprávnění - Ověřujte, že požadavky nepřistupují k datům mimo povolené oblasti
3. Nepředávejte citlivé údaje - Neukládejte přihlašovací údaje nebo API klíče přímo v kódu MCP serveru
4. Používejte HTTPS - Pro vzdálené MCP servery vždy používejte zabezpečené připojení
5. Auditování - Zaznamenávejte všechny požadavky a akce pro případnou kontrolu

Omezení MCP serverů

I když jsou MCP servery velmi užitečné, mají některá omezení:

1. Složitost implementace - Vytvoření vlastního MCP serveru vyžaduje programátorské znalosti
2. Omezená podpora modelů - Nativní podporu mají zatím pouze některé modely (především Claude)
3. Výkonnostní overhead - Komunikace přes MCP může být pomalejší než přímé volání API
4. Bezpečnostní rizika - Nesprávně implementované MCP servery mohou představovat bezpečnostní riziko

Budoucnost MCP

MCP je relativně nová technologie, která se rychle vyvíjí:

1. Širší adopce - Očekává se, že více AI modelů bude nativně podporovat MCP
2. Standardizace - Práce na formalizaci a standardizaci protokolu
3. Více předpřipravených serverů - Rostoucí ekosystém předpřipravených MCP serverů
4. Lepší nástroje - Vývoj nástrojů pro snadnější vytváření a správu MCP serverů

Závěr

MCP servery představují významný krok vpřed v propojení AI modelů s reálným světem. Díky standardizovanému protokolu mohou AI asistenti pracovat s vašimi daty, nástroji a systémy bezpečným a kontrolovaným způsobem.

Ať už jste vývojář, který chce vytvořit vlastní AI aplikaci, nebo uživatel, který chce rozšířit možnosti svého AI asistenta, MCP servery nabízejí flexibilní a výkonný způsob, jak toho dosáhnout.

Začněte s Claude Desktop a předpřipravenými MCP servery, a až získáte více zkušeností, můžete vytvořit vlastní MCP servery pro specifické potřeby vaší organizace nebo aplikace.