Zum Hauptinhalt springen

Claude mit lokalen Tools & Agenten über MCP verbinden

Fortgeschritten

Du willst, dass Claude das Gehirn ist und deine Maschine die Hände liefert — deine Dateien lesen, deine Datenbank abfragen, dein Skript ausführen, sogar ein lokales Modell oder einen lokalen Agenten aufrufen, alles ohne dass deine Daten den Laptop verlassen. Für diese Synergie gibt es bereits einen Standard: das Model Context Protocol (MCP). In einem Atemzug: MCP ist ein offener Standard, der einem KI-Client erlaubt, externe Tools und Daten über kleine Programme namens MCP-Server aufzurufen — und diese Server können privat, lokal, auf deiner eigenen Maschine laufen. Diese Seite zeigt, was MCP ist, wie die lokale Architektur zusammenpasst, wie du Claude einen lokalen Server hinzufügst und wie du selbst einen winzigen baust.

What you'll learn
  • MCP in einem Satz erklären — ein offener Standard, damit ein KI-Client externe Tools und Daten über MCP-Server aufrufen kann
  • Die lokale Architektur sehen: ein MCP-Client (Claude Code / Claude Desktop), der über stdio mit einem lokalen MCP-Server spricht
  • Verstehen, warum genau DAS die Synergie aus Claude-als-Gehirn + lokalen Fähigkeiten ist, die du willst
  • Claude mit einem einzigen Befehl einen lokalen MCP-Server hinzufügen
  • Einen winzigen MCP-Server bauen, der ein Tool bereitstellt
  • Die Vertrauensgrenze kennen — MCP-Server handeln mit DEINEN Rechten, also installiere nur, was du vertraust

Was MCP ist (in einem Atemzug)​

MCP ist ein offener Standard zur Verbindung von KI-Anwendungen mit externen Systemen. Ein KI-Client (wie Claude) spricht ein Protokoll; jeder MCP-Server, der es spricht, kann sich einklinken und dem Client neue Fähigkeiten anbieten. Die offizielle Analogie ist ein USB-C-Anschluss für KI: statt einer maßgeschneiderten Integration pro Tool baust du für einen Anschluss, und er funktioniert überall.

Anthropic hat MCP eingeführt und als Open Source veröffentlicht, und vom ersten Tag an wurde es mit lokaler MCP-Server-Unterstützung ausgeliefert, sodass Claude sich mit internen Systemen und Datensätzen verbinden konnte, die auf deiner eigenen Maschine laufen.

Ein MCP-Server kann dem Client drei Arten von Dingen bereitstellen:

  • Tools — Aktionen, die das Modell aufrufen kann (eine Datei lesen, eine Abfrage ausführen, eine API aufrufen). Das hat dieselbe Form wie die native Tool-Nutzung des Modells: eine benannte Fähigkeit mit typisierten Eingaben.
  • Resources — Daten, die der Client lesen kann (Dateien, Datensätze, Dokumente).
  • Prompts — wiederverwendbare, parametrisierte Prompt-Vorlagen, die der Server anbietet.

Für diese Seite lautet die Schlagzeile Tools: Ein lokaler MCP-Server ist die Art, wie du Claude eine neue, private Fähigkeit übergibst.

Warum das die Synergie ist, die du willst​

Was die Leute mit „Claude als Gehirn, mein Computer als Körper“ meinen, ist genau die MCP-Client/Server-Aufteilung:

  • Claude ist der Orchestrator. Es liest dein Ziel, entscheidet, welches Tool aufzurufen ist, ruft es auf, liest das Ergebnis und entscheidet über den nächsten Schritt.
  • Lokale MCP-Server sind die Fähigkeiten. Jeder ist ein kleines Programm, das du auf deiner Maschine ausführst: ein Dateisystem-Server, ein Datenbank-Server, ein Wrapper um ein lokales Skript, sogar ein Server, der ein lokales Modell aufruft oder Arbeit an einen lokalen Agenten übergibt.

Weil der Server lokal läuft und Claude über die standardmäßige Ein-/Ausgabe deiner eigenen Maschine mit ihm spricht, bleiben deine Daten und Aktionen auf deiner Hardware — das Modell orchestriert, aber das Lesen von Dateien, das SQL, die Skript-Ausführung passieren lokal. Das ist die datenschutzwahrende Version agentischer Arbeit: Gehirn in der Cloud (oder auch lokal), Hände strikt auf deiner Kiste.

Und weil MCP ein offener Standard ist, der über viele Clients hinweg adoptiert wurde, ist ein Server, den du baust, nicht an eine einzige App gebunden. Derselbe lokale Server, den du in Claude Code einbindest, kann von anderen MCP-sprechenden Clients genutzt werden — einmal bauen, überall wiederverwenden.

Die lokale Architektur​

Das kleinste nützliche Bild hat zwei Teile und einen Kanal:

  • MCP-Client (Host). Die KI-App — zum Beispiel Claude Code oder Claude Desktop. Sie hält das Modell und entscheidet, welche Tools aufzurufen sind.
  • MCP-Server. Ein separater Prozess, der Tools/Resources/Prompts anbietet und sie auf Anforderung ausführt.
  • Transport. Bei lokalen Servern startet der Client den Server als Subprozess, und sie sprechen über stdio (Standard-Ein-/Ausgabe) mit JSON-RPC-Nachrichten. Kein Netzwerk, kein Port — nur eine lokale Pipe zwischen zwei Prozessen auf deiner Maschine. (Es gibt auch Remote-Server, über HTTP; diese Seite behandelt den lokalen stdio-Fall.)
┌─────────────────────────┐         stdio (JSON-RPC)        ┌──────────────────────────┐
│  MCP CLIENT / HOST       │ ──── launches as subprocess ──▶ │  LOCAL MCP SERVER         │
│  Claude Code / Desktop   │ ◀── tools/resources/prompts ─── │  filesystem · db · script │
│  (the model = the brain) │                                 │  · local model / agent    │
└─────────────────────────┘                                  └──────────────────────────┘
                                                              runs on YOUR machine, YOUR data

Das Modell berührt deine Festplatte nie direkt — es fragt den lokalen Server, und der Server (der mit deinen Berechtigungen läuft) erledigt die Arbeit und gibt ein Ergebnis zurück.

Claude einen lokalen MCP-Server hinzufügen​

Der schnellste Weg ist der Befehl claude mcp add von Claude Code, der einen Server registriert, den der Client über stdio startet. Die allgemeine Form ist ein Name, dann der Befehl, der den Server startet.

Guided walkthrough1 of 4
  1. Beginne mit einem offiziellen Referenz-Server (z. B. dem Dateisystem-Server), damit das Verhalten bekannt ist. Anthropic pflegt eine Sammlung von Referenz-MCP-Servern, die du lokal ausführen kannst — filesystem, git, memory, fetch und mehr.

Ein minimales claude mcp add für einen lokalen Dateisystem-Server (alles nach -- ist der Startbefehl):

Einen lokalen Dateisystem-MCP-Server zu Claude Code hinzufügen

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

Wenn du die Konfiguration lieber direkt bearbeitest, wird ein stdio-Server durch den Befehl deklariert, der ihn startet. Die Form sieht so aus:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    }
  }
}

Einen winzigen MCP-Server bauen​

Ein Server ist einfach ein Programm, das ein MCP-SDK verwendet, ein Tool deklariert und einen stdio-Transport startet. Hier ist die ganze Idee in TypeScript — ein Tool, das zwei Zahlen addiert (tausche den Rumpf gegen „führe mein Skript aus“, „frage meine DB ab“, „rufe mein lokales Modell auf“):

npm install @modelcontextprotocol/sdk zod
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: "my-local-tools", version: "0.1.0" });

// Declare ONE tool. Inputs are typed; the body runs locally with your privileges.
server.registerTool(
  "add",
  {
    description: "Add two numbers",
    inputSchema: { a: z.number(), b: z.number() },
  },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }],
  }),
);

// Talk to the client over stdio — this is what makes it a LOCAL server.
await server.connect(new StdioServerTransport());

Registriere ihn bei Claude genau wie jeden anderen stdio-Server — richte den Startbefehl auf deine Datei aus:

Deinen eigenen lokalen Server zu Claude Code hinzufügen

claude mcp add my-local-tools -- node /abs/path/to/server.js

Das ist die vollständige Schleife: Claude (Gehirn) sieht ein neues Tool, ruft es bei Bedarf auf, und dein Code (Hände) läuft lokal und gibt das Ergebnis zurück. Weil er dasselbe offene Protokoll spricht, funktioniert dieser Server auch ohne Änderungen in anderen MCP-Clients.

Watch out
  • MCP-Server laufen mit deinen Rechten und können echte Aktionen ausführen — installiere nur Server, denen du vertraust, und achte auf Prompt-Injection über Tool-Ergebnisse.

Überprüfe dich selbst​

Überprüfe dich selbst

0/4
  1. Was ist MCP, in einem Satz?
  2. Wie spricht der Client bei einem LOKALEN MCP-Server üblicherweise mit ihm?
  3. Warum zahlt sich der Bau eines MCP-Servers über Tools hinweg aus?
  4. Was ist der Hauptgrund, einen Server vor der Installation zu prüfen?
Drücke Enter oder die Leertaste, um die Karte umzudrehen. Nutze die Pfeiltasten links und rechts, um zwischen den Karten zu wechseln.Begriff angezeigt.
1 / 8
Key takeaways
  • MCP ist ein offener Standard, damit ein KI-Client externe Tools und Daten über MCP-Server aufrufen kann — Anthropic hat es von Anfang an mit lokaler Server-Unterstützung eingeführt.
  • Die lokale Architektur ist einfach: ein MCP-Client (Claude Code / Desktop) startet einen lokalen MCP-Server als Subprozess und spricht mit ihm über stdio — deine Daten bleiben auf deiner Maschine.
  • Das ist die Synergie aus Claude-als-Gehirn + lokalen Fähigkeiten: Claude orchestriert; lokale Server (Dateisystem, DB, ein Skript, sogar ein lokales Modell oder ein Agent) liefern die Hände.
  • Füge einen Server mit einem einzigen Befehl hinzu (claude mcp add ... -- <Startbefehl>); baue einen mit einem MCP-SDK, indem du ein Tool registrierst und einen stdio-Transport verbindest.
  • MCP ist breit adoptiert, sodass ein lokaler Server, den du baust, über viele Clients hinweg funktioniert — einmal bauen, überall wiederverwenden.
  • Server handeln mit deinen Rechten: installiere nur, was du vertraust, und behandle Tool-Ergebnisse als möglichen Prompt-Injection-Vektor.

Weiter​

Quellen & weiterführende Literatur​