Stavíme první MCP server

# TypeScript — scaffold nového serveru
npx @modelcontextprotocol/create-server my-app-server
cd my-app-server
npm install
npm run build

# Python — scaffold nového serveru
uvx create-mcp-server
# Následujte výzvy: název, popis atd.
cd my-app-server
uv sync

my-app-server/
  package.json          # Závislosti a skripty
  tsconfig.json         # TypeScript konfigurace
  src/
    index.ts            # Váš MCP server — tady píšete kód

// package.json
{
  "name": "my-app-server",
  "version": "1.0.0",
  "type": "module",
  "bin": {
    "my-app-server": "./build/index.js"
  },
  "scripts": {
    "build": "tsc && chmod +x build/index.js",
    "dev": "tsc --watch",
    "start": "node build/index.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.12.0",
    "zod": "^3.24.0"
  },
  "devDependencies": {
    "typescript": "^5.8.0",
    "@types/node": "^22.0.0"
  }
}

#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Vytvoření serveru
const server = new McpServer({
  name: "my-app-server",
  version: "1.0.0",
});

// Přidání resource — data ke čtení
server.resource(
  "greeting",
  "myapp://greeting",
  async (uri) => ({
    contents: [{
      uri: uri.href,
      mimeType: "text/plain",
      text: "Ahoj z mého prvního MCP serveru!"
    }]
  })
);

// Přidání toolu — akce, kterou AI může provést
server.tool(
  "greet",
  "Vygeneruje personalizovaný pozdrav",
  { name: z.string().describe("Jméno osoby k pozdravu") },
  async ({ name }) => ({
    content: [{ type: "text", text: `Ahoj, ${name}! Vítej v MCP.` }]
  })
);

// Spuštění serveru se stdio transportem
const transport = new StdioServerTransport();
await server.connect(transport);
console.error("Server běží na stdio");

my-app-server/
  pyproject.toml        # Závislosti a konfigurace projektu
  src/
    my_app_server/
      __init__.py
      server.py          # Váš MCP server

# pyproject.toml
[project]
name = "my-app-server"
version = "1.0.0"
requires-python = ">=3.10"
dependencies = [
    "mcp[cli]>=1.6.0",
]

[project.scripts]
my-app-server = "my_app_server.server:main"

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

# src/my_app_server/server.py
from mcp.server.fastmcp import FastMCP

# Vytvoření serveru
mcp = FastMCP("my-app-server")


# Přidání resource — data ke čtení
@mcp.resource("myapp://greeting")
def get_greeting() -> str:
    """Jednoduchý pozdrav ze serveru."""
    return "Ahoj z mého prvního MCP serveru!"


# Přidání toolu — akce, kterou AI může provést
@mcp.tool()
def greet(name: str) -> str:
    """Vygeneruje personalizovaný pozdrav.

    Args:
        name: Jméno osoby k pozdravu
    """
    return f"Ahoj, {name}! Vítej v MCP."


def main():
    mcp.run(transport="stdio")


if __name__ == "__main__":
    main()

# Nejdřív build TypeScript serveru
cd my-app-server
npm run build

# Přidání do Claude Code (spusťte z adresáře vašeho projektu)
claude mcp add my-app -- node /absolutni/cesta/k/my-app-server/build/index.js

# Nebo pro Python
claude mcp add my-app -- uv run --directory /absolutni/cesta/k/my-app-server my-app-server

// .mcp.json (kořen projektu)
{
  "mcpServers": {
    "my-app": {
      "command": "node",
      "args": ["/absolutni/cesta/k/my-app-server/build/index.js"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    }
  }
}

# Spuštění MCP Inspectoru (TypeScript server)
npx @modelcontextprotocol/inspector node build/index.js

# Spuštění MCP Inspectoru (Python server)
npx @modelcontextprotocol/inspector uv run my-app-server

# Otevře webové UI na http://localhost:6274
# Můžete procházet resources, volat tools a testovat prompts

// .cursor/mcp.json
{
  "mcpServers": {
    "my-app": {
      "command": "node",
      "args": ["./my-app-server/build/index.js"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    }
  }
}

// TypeScript — čtení environment proměnných
const DATABASE_URL = process.env.DATABASE_URL;
if (!DATABASE_URL) {
  console.error("DATABASE_URL je povinný");
  process.exit(1);
}

server.tool(
  "query-users",
  "Spočítá uživatele v databázi",
  {},
  async () => {
    const pool = new Pool({ connectionString: DATABASE_URL });
    const result = await pool.query("SELECT COUNT(*) FROM users");
    return {
      content: [{ type: "text", text: `Celkem uživatelů: ${result.rows[0].count}` }]
    };
  }
);

# Python — čtení environment proměnných
import os

DATABASE_URL = os.environ.get("DATABASE_URL")
if not DATABASE_URL:
    raise RuntimeError("DATABASE_URL je povinný")


@mcp.tool()
def query_users() -> str:
    """Spočítá uživatele v databázi."""
    import psycopg
    with psycopg.connect(DATABASE_URL) as conn:
        count = conn.execute("SELECT COUNT(*) FROM users").fetchone()[0]
    return f"Celkem uživatelů: {count}"