🧰 Beispielserver: die offiziellen Referenzserver

Das Repository github.com/modelcontextprotocol/servers enthält sieben aktuelle Referenzserver (Stand 24.09.2026) – gedacht als Lehrbeispiele, nicht als fertige Produkte. Namen, Beschreibungen und Schemas unten stammen aus deren Quelltext; alle Argumente und Pfade sind synthetisch.

7
Referenzserver
39
Tools (ohne Everything)
TS + Python
Sprachen
stdio
Standard-Transport

🗂️Die Referenzserver im Überblick

TypeScript-Server nutzen McpServer + registerTool mit Zod, Python-Server die Low-Level-API mit Pydantic-Schemas.

📁 Filesystem secure-filesystem-server

14 Tools

Sichere Dateioperationen mit konfigurierbarer Zugriffskontrolle.

Sprache
TypeScript (Node.js)
Start
npx -y @modelcontextprotocol/server-filesystem /projekt
Transport
stdio
  • Erlaubte Verzeichnisse per Kommandozeile oder – empfohlen – dynamisch über Roots vom Client (roots/list).
  • Jedes Tool hat Annotations: lesende readOnlyHint: true, write_file/edit_file/move_file destructiveHint: true, alle openWorldHint: false.
  • Tools liefern zusätzlich structuredContent passend zu einem outputSchema ({ content: string }).
  • read_file ist als veraltet markiert (Titel „Read File (Deprecated)“) – Nachfolger read_text_file.
Alle Tools anzeigen
read_fileread_text_fileread_media_fileread_multiple_fileswrite_fileedit_filecreate_directorylist_directorylist_directory_with_sizesdirectory_treemove_filesearch_filesget_file_infolist_allowed_directories
🔗 Quelltext auf GitHub

🌐 Fetch mcp-fetch

1 Tools

Webinhalte abrufen und für LLMs in Markdown umwandeln.

Sprache
Python
Start
uvx mcp-server-fetch
Transport
stdio
Prompts
fetch
  • Bietet ein Tool UND einen gleichnamigen Prompt – Beispiel für beide Primitive.
  • Das inputSchema erzeugt Pydantic (Fetch.model_json_schema()) inkl. title, default und exclusiveMaximum.
  • Prüft vor dem Abruf robots.txt und sendet den User-Agent „ModelContextProtocol/1.0 (Autonomous; +https://github.com/modelcontextprotocol/servers)“.
  • Lange Seiten werden nach max_length abgeschnitten; der Text sagt dem Modell, mit welchem start_index es weiterlesen kann.
Alle Tools anzeigen
fetch
🔗 Quelltext auf GitHub

⏰ Time mcp-time

2 Tools

Aktuelle Zeit und Umrechnung zwischen IANA-Zeitzonen.

Sprache
Python
Start
uvx mcp-server-time
Transport
stdio
  • Nutzt die Low-Level-API des Python-SDK (@server.list_tools / @server.call_tool) statt FastMCP.
  • Die lokale Zeitzone wird zur Laufzeit in die Tool-Beschreibung eingesetzt – das Modell kennt so den Standard.
  • Ergebnis ist JSON als Text: timezone, datetime, day_of_week, is_dst.
Alle Tools anzeigen
get_current_timeconvert_time
🔗 Quelltext auf GitHub

🌿 Git mcp-git

12 Tools

Git-Repositories lesen, durchsuchen und verändern.

Sprache
Python
Start
uvx mcp-server-git --repository /projekt
Transport
stdio
  • Jedes Tool hat ein Pydantic-Modell als Schema (z. B. GitStatus mit repo_path).
  • Mischung aus lesenden (git_status, git_log) und schreibenden Tools (git_commit, git_reset).
Alle Tools anzeigen
git_statusgit_diff_unstagedgit_diff_stagedgit_diffgit_commitgit_addgit_resetgit_loggit_create_branchgit_checkoutgit_showgit_branch
🔗 Quelltext auf GitHub

🧠 Memory memory-server

9 Tools

Dauerhaftes Gedächtnis als Wissensgraph (Entitäten, Relationen, Beobachtungen).

Sprache
TypeScript (Node.js)
Start
npx -y @modelcontextprotocol/server-memory
Transport
stdio
  • Speicherort über die Umgebungsvariable MEMORY_FILE_PATH.
  • Suchbegriff in search_nodes auf 2048 Zeichen begrenzt (maxLength).
Alle Tools anzeigen
create_entitiescreate_relationsadd_observationsdelete_entitiesdelete_observationsdelete_relationsread_graphsearch_nodesopen_nodes
🔗 Quelltext auf GitHub

🪜 Sequential Thinking sequential-thinking-server

1 Tools

Probleme in nachvollziehbaren, überarbeitbaren Denkschritten lösen.

Sprache
TypeScript (Node.js)
Start
npx -y @modelcontextprotocol/server-sequential-thinking
Transport
stdio
  • Ein einziges Tool – zeigt, dass ein Server auch nur „Denkwerkzeug“ ohne externe Daten sein kann.
Alle Tools anzeigen
sequentialthinking
🔗 Quelltext auf GitHub

🧪 Everything everything

viele Demos

Referenz- und Testserver mit Prompts, Resources und Tools – zum Ausprobieren von Clients.

Sprache
TypeScript (Node.js)
Start
npx -y @modelcontextprotocol/server-everything
Transport
stdio · SSE (veraltet) · Streamable HTTP
  • Deckt möglichst viele Protokoll-Features ab – ideal, um einen eigenen Host oder Client zu testen.
  • Lässt sich laut README über alle drei Transporte starten.
🔗 Quelltext auf GitHub

🔍Tool-Katalog mit Schemas

Acht Tools der Referenzserver plus drei neutrale Beispiele (get_weather aus der Spezifikation, search_docs und create_ticket frei erfunden).

Tool-Definition (wie in tools/list)

{
  "name": "fetch",
  "description": "Fetches a URL from the internet and optionally extracts its contents as markdown.\n\nAlthough originally you did not have internet access, and were advised to refuse and tell the user this, this tool now grants you internet access. Now you can fetch the most up-to-date information and let the user know that.",
  "inputSchema": {
    "description": "Parameters for fetching a URL.",
    "properties": {
      "url": {
        "description": "URL to fetch",
        "format": "uri",
        "minLength": 1,
        "title": "Url",
        "type": "string"
      },
      "max_length": {
        "default": 5000,
        "description": "Maximum number of characters to return.",
        "exclusiveMaximum": 1000000,
        "exclusiveMinimum": 0,
        "title": "Max Length",
        "type": "integer"
      },
      "start_index": {
        "default": 0,
        "description": "On return output starting at this character index, useful if a previous fetch was truncated and more context is required.",
        "minimum": 0,
        "title": "Start Index",
        "type": "integer"
      },
      "raw": {
        "default": false,
        "description": "Get the actual HTML content of the requested page, without simplification.",
        "title": "Raw",
        "type": "boolean"
      }
    },
    "required": ["url"],
    "title": "Fetch",
    "type": "object"
  }
}

Argumente prüfen

{
  "url": "https://docs.example.org/mcp-einfuehrung",
  "max_length": 5000
}
Ajv · Draft 2020-12
✅ Passt zum Schema.

Synthetische Beispielwerte. Schemas der Referenzserver aus dem offiziellen Quelltext (Zod/Pydantic → JSON Schema); „format“ wird hier nicht geprüft.

🏗️So sieht der Code aus

Gekürzte Auszüge aus dem offiziellen Repository.

filesystem/index.ts – registerTool mit outputSchemats
const server = new McpServer({ name: "secure-filesystem-server", version: "0.2.0" }, …);

server.registerTool(
  "write_file",
  {
    title: "Write File",
    description: "Create a new file or completely overwrite an existing file with new content. …",
    inputSchema: {
      path: z.string(),
      content: z.string()
    },
    outputSchema: { content: z.string() },
    annotations: { readOnlyHint: false, idempotentHint: true, destructiveHint: true, openWorldHint: false }
  },
  async (args) => {
    const validPath = await validatePath(args.path);     // nur erlaubte Verzeichnisse
    await writeFileContent(validPath, args.content);
    const text = `Successfully wrote to ${args.path}`;
    return {
      content: [{ type: "text", text }],
      structuredContent: { content: text }
    };
  }
);
fetch/server.py – Pydantic-Schema + Low-Level-APIpy
class Fetch(BaseModel):
    """Parameters for fetching a URL."""
    url: Annotated[AnyUrl, Field(description="URL to fetch")]
    max_length: Annotated[int, Field(default=5000,
        description="Maximum number of characters to return.", gt=0, lt=1000000)]
    start_index: Annotated[int, Field(default=0, description="…", ge=0)]
    raw: Annotated[bool, Field(default=False, description="…")]

server = Server("mcp-fetch")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [Tool(name="fetch", description="…", inputSchema=Fetch.model_json_schema())]

@server.call_tool()
async def call_tool(name, arguments: dict) -> list[TextContent]:
    args = Fetch(**arguments)                       # Validierung durch Pydantic
    …
    return [TextContent(type="text", text=f"{prefix}Contents of {url}:\n{content}")]
time/server.py – Schema von Hand + Annotationspy
Tool(
    name="get_current_time",
    description="Get current time in a specific timezone",
    inputSchema={
        "type": "object",
        "properties": {
            "timezone": {
                "type": "string",
                "description": f"IANA timezone name (…). Use '{local_tz}' as local timezone …",
            }
        },
        "required": ["timezone"],
    },
    annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False,
                                idempotentHint=True, openWorldHint=False),
)
💡 Drei Wege zum Schema
Zod-Shape (Filesystem, TypeScript-SDK erzeugt das JSON Schema), Pydantic-Modell (Fetch, Git: model_json_schema()) und JSON Schema direkt von Hand (Time). Für den Client sieht alles gleich aus – ein JSON Schema im tools/list-Ergebnis.
🏷️ Wie der Host die Namen sieht
Claude Code setzt vor jedes Tool mcp__<Server-Schlüssel>__, z. B. mcp__fetch__fetch oder mcp__filesystem__read_text_file. So kollidieren gleichnamige Tools verschiedener Server nicht.

⚙️Einbinden in einen Host

Das verbreitete mcpServers-Format (Claude Desktop, Claude Code u. a.). Pfade und URL sind Beispiele.

Konfiguration (Beispiel)json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/projekt"
      ]
    },
    "fetch": {
      "command": "uvx",
      "args": [
        "mcp-server-fetch"
      ]
    },
    "time": {
      "command": "uvx",
      "args": [
        "mcp-server-time",
        "--local-timezone=Europe/Berlin"
      ]
    },
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ],
      "env": {
        "MEMORY_FILE_PATH": "/daten/memory.json"
      }
    },
    "beispiel-remote": {
      "type": "http",
      "url": "https://mcp.example.org/mcp"
    }
  }
}
per Claude-Code-CLIbash
claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /projekt
claude mcp add fetch -- uvx mcp-server-fetch
claude mcp add --transport http beispiel-remote https://mcp.example.org/mcp

claude mcp list      # → filesystem: … ✓ Connected
Drei Einbindungs-Orte in Claude Code
--scope project  →  .mcp.json im Projekt (geteilt, z. B. per Git)
--scope user     →  Benutzerkonfiguration von Claude Code (alle Projekte)
--scope local    →  Benutzerkonfiguration, nur für das aktuelle Projekt
🔒 Secrets
Zugangsdaten für stdio-Server stehen in env – im Klartext in der Konfigurationsdatei. Nie teilen oder einchecken; in geteilten.mcp.json-Dateien Platzhalter wie ${API_TOKEN} verwenden.