Ollama mit Datenbanken und APIs über MCP verbinden: Lokale Agent-Einrichtung 2026

Schnelle Fakten

• Protokoll: JSON-RPC 2.0 über stdio (lokaler Subprozess) oder HTTP/SSE (remote). Lokale Agenten nutzen fast ausschließlich stdio.
• Gepflegt von: Anthropic (Open-Source-Spezifikation); Referenz-Server werden in modelcontextprotocol/servers auf GitHub gepflegt, plus ein wachsendes Drittanbieter-Ökosystem.
• Lokale Clients in 2026: Goose (Block), Cline (VS-Code-Erweiterung), Continue.dev (VS Code/JetBrains), LM Studio (Desktop-App), plus mehrere CLI-Tools.
• Kompatible Ollama-Modelle: jedes Modell mit nativem Tool-Call-Training. Im Mai 2026: Gemma 4 27B, GLM-5.1 32B, Qwen3 32B, Qwen3-Coder 30B, Llama 3.3 70B.
• Standard-Transports: stdio für lokale Prozesse; HTTP/SSE nur, wenn ein Server über Maschinen oder Agenten hinweg geteilt werden muss.
• Konfiguration in einer Datei: ~/.config/goose/config.yaml (Goose), der MCP-Block von ~/.continue/config.json (Continue.dev) oder mcpServers in der Settings-UI von Cline. Gleiche Form überall: Servername, Command, Args, Env-Vars.
• Kein Claude Desktop nötig. Das Protokoll ist älter als Claude Desktops Exklusivitätsanspruch; jeder Referenz-Server ist MIT/Apache-lizenziert und läuft gegen jeden konformen Client.

Was MCP für ein lokales Modell tatsächlich freischaltet

• **„Finde jedes TODO in diesem Repo, gruppiere sie nach Datei und schreibe eine Markdown-Zusammenfassung in notes/todos.md."** — der filesystem-Server liest, das Modell gruppiert, derselbe Server schreibt. Ein einziger Round-Trip von Anfang bis Ende.
• „Zeig mir die Top-10-Kunden nach Umsatz in diesem Quartal und visualisiere es." — der postgres-Server führt das SQL aus (read-only-Rolle), das Modell fasst zusammen, das Modell schreibt eine CSV über filesystem für Ihr Charting-Tool.
• „Öffne die Hacker-News-Startseite, finde die drei wichtigsten KI-Stories, fasse sie zusammen und füge sie meiner Leseliste hinzu." — der puppeteer-Server steuert einen Headless-Browser, das Modell extrahiert und fasst zusammen, filesystem hängt an.
• **„Öffne einen Draft-PR mit dem Titel chore: bump deps gegen meinen Fork und verlinke den fehlgeschlagenen CI-Run."** — der github-Server erstellt den PR, holt den Run und schreibt den Link in die Beschreibung.
• **„Schau dir die letzten 100 Zeilen von events.db an und sag mir, welche User-IDs für den neuen Error-Spike verantwortlich sind."** — der sqlite-Server fragt ab; das Modell schließt; Sie lesen die Antwort im Chat-Panel.
• Jeder dieser Vorgänge ist ein Satz-zu-Aktion-Workflow, der zuvor entweder ein Cloud-Modell mit gehosteten Tools oder ein selbst geschriebenes Skript erforderte. MCP ist die Schicht, die es Ihnen ermöglicht, dieselben Server über Clients hinweg und dasselbe Modell über Server hinweg wiederzuverwenden.

Wie die vier am häufigsten verwendeten MCP-Server abschneiden

Wie die Teile zusammenpassen

• Ollama läuft als Hintergrunddienst auf 127.0.0.1:11434 und liefert das Modell über eine OpenAI-kompatible API. Es weiß nicht, was MCP ist — es beantwortet einfach Chat-Completions und gibt Tool-Calls aus, wenn das Modell sie anfordert.
• MCP-Client (Goose, Cline, Continue.dev, LM Studio) ist die Brücke. Er spricht mit Ollama für das Modell und mit MCP-Servern für die Tools. Wenn das Modell einen Tool-Call ausgibt, leitet der Client ihn an den richtigen Server, holt das Ergebnis und füttert es zurück in das Gespräch.
• MCP-Server sind unabhängige Subprozesse, einer pro Fähigkeit. Sie sprechen JSON-RPC 2.0 über stdio. Jeder Server bewirbt eine Liste von Tools, Resources und Prompts; der Client führt sie zur Tool-Oberfläche zusammen, die dem Modell präsentiert wird.
• Stdio-Transport hält alles lokal. Ein Server wird vom Client gestartet, kommuniziert über seine stdin/stdout und beendet sich, wenn der Client beendet wird. Nichts geht über das Netzwerk, sofern der Server nicht selbst eine Verbindung öffnet (der Browser-Server tut das; Filesystem- und Datenbankserver nicht).
• Das Modell sieht eine flache Tool-Liste. Aus Sicht des Modells gibt es keine Server — nur eine Liste von Tool-Namen wie filesystem.read_file, sqlite.query, puppeteer.navigate. Der Client übernimmt das Routing.

Setup: Ollama + Goose in 15 Minuten

• Schritt 1 — Ollama installieren. Download von ollama.com/download (macOS/Windows/Linux). Bestätigen Sie, dass der Dienst läuft, mit curl http://127.0.0.1:11434/api/tags.
• Schritt 2 — ein Tool-Calling-Modell ziehen. Wählen Sie aus Gemma 4 27B (gemma4:27b), GLM-5.1 32B (glm5:32b), Qwen3 32B (qwen3:32b) oder Llama 3.3 70B (llama3.3:70b). 16 GB Unified Memory oder 12 GB VRAM bewältigen 27B–32B bei Q4_K_M komfortabel.
• Schritt 3 — Goose installieren. pipx install goose-ai (macOS, Linux) oder Installer von der Goose-Releases-Seite herunterladen. Die CLI installiert sich als goose.
• Schritt 4 — Ollama als Provider konfigurieren. Führen Sie goose configure aus, wählen Sie ollama als Provider, setzen Sie das Modell auf das gezogene und den Host auf http://127.0.0.1:11434. Goose schreibt das in ~/.config/goose/config.yaml.
• Schritt 5 — den Filesystem-MCP-Server hinzufügen. Bearbeiten Sie ~/.config/goose/config.yaml, um einen mcpServers-Block zu ergänzen (Konfigurationsbeispiel unten). Starten Sie goose session neu und bitten Sie es, Dateien in Ihrem Test-Verzeichnis aufzulisten. Der erste Turn bestätigt, dass der Server angebunden ist.
• Schritt 6 — mit einer echten Aufgabe verifizieren. Probieren Sie goose session und fragen Sie „Erstelle eine Liste jeder Markdown-Datei in notes/, mit Titel und Wortanzahl, und schreibe das Ergebnis in notes/index.md." Wenn der Agent liest, zusammenfasst und zurückschreibt, funktioniert der Loop.

# 1. Pull a tool-calling model
ollama pull gemma4:27b

# 2. Install Goose
pipx install goose-ai

# 3. Configure Ollama as the provider
goose configure
# Provider: ollama
# Model:    gemma4:27b
# Host:     http://127.0.0.1:11434

# 4. Start a session — Goose reads ~/.config/goose/config.yaml
goose session

Filesystem-Server: Lesen und Schreiben in einem isolierten Verzeichnis

• Installation: Der Referenz-Server ist @modelcontextprotocol/server-filesystem, ausgeführt über npx -y (keine globale Installation nötig). Goose, Cline und Continue.dev starten ihn alle automatisch aus dem Config-Block heraus.
• Pfade allow-listen: Der Server akzeptiert ein oder mehrere Verzeichnis-Argumente und verweigert Operationen außerhalb davon. Geben Sie immer einen expliziten, schmalen Pfad an — niemals ~ oder /.
• Bereitgestellte Tools: read_file, read_multiple_files, write_file, edit_file (zeilenbasierte Ersetzungen), list_directory, search_files, move_file, create_directory, directory_tree. Das Modell sieht das als filesystem.read_file und so weiter.
• Quality-of-Life: directory_tree liefert einen JSON-Baum; ideal, damit das Modell sich orientiert, bevor es bestimmte Dateien liest. search_files macht eine grep-ähnliche rekursive Suche.
• Risikoprofil: Der Server respektiert die Allow-List, aber innerhalb dieser Liste hat er vollen Lese-/Schreibzugriff. Behandeln Sie die Allow-List als die einzige Barriere und wählen Sie ein dediziertes Workspace-Verzeichnis statt Ihres Home-Ordners.

# ~/.config/goose/config.yaml
mcpServers:
  filesystem:
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-filesystem"
      - "/Users/you/agent-workspace"
    env: {}

SQLite- und Postgres-Server: Echte Daten abfragen

• **SQLite-Server (@modelcontextprotocol/server-sqlite)** akzeptiert einen Pfad zu einer .db-Datei. Nützlich für Log-Analyse, Schema-Prototyping und das Erkunden von Exporten ohne Datenbank-Aufsetzen.
• **Postgres-Server (@modelcontextprotocol/server-postgres)** akzeptiert einen Connection-String. Das empfohlene Muster ist, eine dedizierte read-only-Rolle für den Agenten zu erstellen und deren Connection-String zu nutzen.
• Bereitgestellte Tools: query (nur SELECT, wenn read-only konfiguriert), list_tables, describe_table. Der Postgres-Server ergänzt list_schemas. Manche Forks fügen write_query hinzu — lassen Sie es deaktiviert, sofern Sie dem Modell auf dieser Datenbank nicht vertrauen.
• Schema-Awareness: Bitten Sie den Agenten „liste die Tabellen auf und beschreibe die fünf am häufigsten genutzten", bevor Sie analytische Fragen stellen — das Modell ist viel präziser, wenn es describe_table aufgerufen hat, als wenn es Spaltennamen rät.
• Kosten: Abfragen treffen Ihre Datenbank direkt. Ein schlecht formuliertes SELECT * aus einer 100-Mio.-Zeilen-Tabelle ist hier derselbe Unfall, wie er von einem Menschen wäre — halten Sie die Rolle in einem separaten Connection-Pool mit einem Statement-Timeout.

# ~/.config/goose/config.yaml
mcpServers:
  sqlite:
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-sqlite"
      - "--db-path"
      - "/Users/you/data/events.db"
    env: {}

  postgres:
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-postgres"
      - "postgresql://agent_ro@127.0.0.1:5432/analytics"
    env:
      PGPASSWORD: "${PG_AGENT_PASSWORD}"

Browser-Server: Chromium mit Puppeteer oder Playwright steuern

• Referenz-Server: @modelcontextprotocol/server-puppeteer (leichter, standardmäßig headless) und @modelcontextprotocol/server-playwright (schwerer, unterstützt mehrere Browser). Für lokale Agenten reicht Puppeteer.
• Bereitgestellte Tools: navigate, screenshot, click, fill, select, evaluate (JavaScript ausführen), get_page_content. Das Modell nutzt get_page_content, um strukturierten Text zu lesen, und screenshot zur visuellen Bestätigung.
• Latenz: Echte Browser-Sessions brauchen 1–5 Sekunden pro Aktion. Ein mehrstufiger Browse-Vorgang verbraucht leicht 30–60 Sekunden und Zehntausende Tokens, weil Seiteninhalte groß sind. Nutzen Sie ein Context-Fenster von 32K+.
• Selektoren: Das Modell muss CSS-Selektoren auswählen. Kleinere Modelle raten oft falsch; ein 27B+-Tool-Calling-Modell beherrscht gängige Muster zuverlässig. Halten Sie Aufgaben fokussiert — „extrahiere den Titel und den ersten Absatz dieser URL" ist viel zuverlässiger als „navigiere die Seite und finde die Kontaktseite".
• Die richtigen Use Cases: Recherche (Seite öffnen, zusammenfassen, an Notizen anhängen), Regressionstests (navigieren, klicken, screenshot) und Formularausfüllen auf Seiten, die Sie kontrollieren. Die falschen Use Cases: alles, wo ein Fehlklick im Live-Web Konsequenzen hat.

# ~/.config/goose/config.yaml
mcpServers:
  puppeteer:
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-puppeteer"
    env:
      PUPPETEER_HEADLESS: "true"
      # Block obviously dangerous endpoints at the OS firewall level
      # rather than relying on the agent to refuse them.

GitHub-Server: Repos, Issues und PRs aus einem lokalen Modell

• Installation: @modelcontextprotocol/server-github, ausgeführt mit einem PAT in der Env-Var GITHUB_PERSONAL_ACCESS_TOKEN. Das Token ist die einzige Authentifizierung — der Server selbst hat keine separate Konfiguration.
• Bereitgestellte Tools: search_repositories, get_file_contents, create_or_update_file, create_pull_request, list_issues, create_issue, add_issue_comment, merge_pull_request, plus Dutzende weitere. Die volle Oberfläche ist groß; die meisten Aufgaben nutzen 5–10 Tools.
• Scopen Sie das PAT. Verwenden Sie ein Fine-Grained-PAT, gescopet auf bestimmte Repos mit den minimal nötigen Berechtigungen (Read zum Browsen, Write für PR-/Issue-Erstellung). Verwenden Sie kein klassisches PAT mit repo für einen experimentellen Agenten.
• Reale Workflows: Triage („lies die letzten 20 offenen Issues, gruppiere sie, entwirf Labels"), Drafting („lies die README und öffne einen PR, der Tippfehler behebt"), Reporting („welche PRs sind diese Woche stale").
• Risikoprofil: Der Agent kann Issues und PRs erstellen, kommentieren und (mit Schreibrechten) Commits pushen. Deaktivieren Sie Merge-Tools, sofern Sie nicht sowohl dem Modell als auch dem Workflow vertrauen — ein versehentlich gemergter PR in einem Fine-Grained-PAT-Repo ist wiederherstellbar, aber nur, wenn Sie es schnell bemerken.

# ~/.config/goose/config.yaml
mcpServers:
  github:
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-github"
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "${GH_AGENT_PAT}"
      # Fine-grained PAT scoped to one or two test repos,
      # not your personal account-wide classic token.

Ein Sicherheitsmodell, das dem Modell nicht vertraut

• Filesystem-Server auf ein Verzeichnis beschränken. Niemals ~ oder /. Wählen Sie einen agent-workspace/-Ordner und legen Sie Kopien der Dateien hinein, die der Agent berühren muss. Wenn der Agent etwas falsch macht, ist der schlimmste Fall ein Ordner.
• Datenbankserver standardmäßig read-only betreiben. Eine dedizierte agent_ro-Rolle mit SELECT-only-Grants und einem 30-Sekunden-Statement-Timeout entfernt eine ganze Klasse von Vorfällen.
• Jeden Schreib- oder Shell-Tool-Aufruf hinter eine explizite Freigabe stellen. Goose, Cline und Continue.dev unterstützen jeweils Per-Tool-Freigaberegeln. Lese-Tools standardmäßig erlauben; Freigabe verlangen für write_file, edit_file, execute_command, create_pull_request und jede Browser-Aktion, die Formulare absendet.
• Audit-Log nutzen. Jeder MCP-Client loggt Tool-Calls und Ergebnisse. Nach einer langen Session den Log scannen: Sie werden das Modell dabei erwischen, wie es Dinge versucht, die Sie nicht erwartet haben (manchmal harmlos, manchmal eine Berechtigungsverschärfung wert).
• Token-Zugriff für Drittanbieter eng beschränken. GitHub-PATs auf zwei Test-Repos gescopet. Postgres-Rollen read-only. Browser-Sessions ohne Anmeldedaten. Das Modell wird irgendwann Dinge versuchen, die Sie nicht antizipiert haben; die Grenzen dessen, was es tun kann, sollten nicht davon abhängen, dass das Modell es richtig macht.
• Air-Gap den Agenten für sensible Datenarbeit. Deaktivieren Sie Netzwerkzugriff auf dem Host während des Agent-Laufs (oder nutzen Sie einen Network-Namespace), wenn Sie mit privaten Daten arbeiten. Der lokale Stack hat zwar nichts, was die Maschine verlässt, aber Defense-in-Depth fängt Fehler in Drittanbieter-Servern.
• Behandeln Sie die MCP-Server-Auswahl wie jede Dependency-Wahl. Die Referenz-Server sind gut gepflegt; viele Drittanbieter-Server sind es nicht. Lesen Sie den Code eines Servers, bevor Sie einen mit Anmeldedaten installieren.

Lokales MCP vs. Claude Desktop: Was sich ändert, was bleibt

Auswahl eines Tool-Calling-Modells für lokales MCP

• **Gemma 4 27B (gemma4:27b)** — Googles Tool-Call-Training ist Best-in-Class für die Größe. Passt in 16 GB Unified Memory oder 24 GB VRAM bei Q4_K_M. Gutes allgemeines Reasoning; etwas konservativ bei verketteten Tool-Calls.
• **GLM-5.1 32B (glm5:32b)** — Zhipus Modell hat sehr starke Tool-Call-Zuverlässigkeit und ein 128K-Context-Fenster ab Werk. Etwas schwerer als Gemma 4; passt komfortabel auf eine 24-GB-GPU.
• **Qwen3 32B (qwen3:32b) — gut ausbalanciert; das dichte 32B verarbeitet MCP sauber und ist in einer langen Agent-Schleife glücklich. Qwen3-Coder 30B (qwen3-coder:30b)** ist die beste Wahl, wenn Ihre Agent-Arbeit codeförmig ist.
• **Llama 3.3 70B (llama3.3:70b)** — die höchste Decke, aber die schwerste. 48 GB+ Unified Memory oder 2× 24 GB GPUs bei Q4_K_M. Nur einsetzen, wenn Ihre Hardware das verträgt; die kleineren Modelle reichen meist.
• Vermeiden Sie für MCP-Arbeit: alles unter 7B und jedes general-purpose-Modell ohne explizites Tool-Call-Training. Sie geben fehlerhafte Calls aus, der Loop blockiert, und Sie werden den Harness beschuldigen — aber der Harness ist in Ordnung.
• Für strukturierte Prompting-Techniken, die die Tool-Call-Qualität bei jedem Modell verbessern, siehe Chain-of-Thought Prompting.
• Für Head-to-Head-Daten siehe Beste lokale Modelle für Tool Calling 2026.

MCP vs. einfaches Function Calling: Was ist der Unterschied

• Function Calling ist die LLM-seitige Fähigkeit: Das Modell gibt ein strukturiertes JSON-Objekt aus, das Tool-Namen und Argumente beschreibt. OpenAI Tools, Anthropic Tools und die Tool-Call-API von Ollama nutzen alle dieselbe Idee mit leicht unterschiedlichen Wire-Formaten.
• MCP sitzt darüber: Es standardisiert, wie Tools beschrieben, entdeckt, aufgerufen und zurückgegeben werden, prozessübergreifend. Ein Function-Calling-Modell allein weiß nichts über Ihr Filesystem; ein MCP-Server stellt Filesystem-Operationen bereit, der Client mappt sie auf die Function-Calling-API des Modells, und das Modell kann sie aufrufen.
• Der Vorteil ist Interop. Schreiben Sie den Filesystem-Server einmal; Claude Desktop, Goose, Cline, Continue.dev und LM Studio nutzen ihn alle unverändert. Wechseln Sie das Modell von Claude zu Gemma 4; der Server ändert sich nicht.
• Sie können Agenten mit reinem Function Calling bauen. Sie reimplementieren Filesystem-, Datenbank- und Browser-Handler pro Projekt. Mit MCP sind das Out-of-the-Box-Abhängigkeiten.
• Für One-off-Skripte ist reines Function Calling einfacher. Für alles, was Sie über Projekte oder Modelle hinweg wiederverwenden möchten, ist MCP innerhalb weniger Tage der aufwandsärmere Weg.

Im DACH-Kontext: DSGVO, BSI und Mittelstand

• DSGVO Art. 28 (Auftragsverarbeitung): Bei einem Cloud-Agent ist der Anbieter Auftragsverarbeiter — mit AVV, technisch-organisatorischen Maßnahmen, Drittland-Bewertung und allem, was dazugehört. Bei einem lokalen MCP-Stack entfällt diese Vertragsbeziehung, weil keine personenbezogenen Daten an einen Dritten übermittelt werden.
• BSI-Grundschutz-Kataloge: Für Behörden und IT-Sicherheits-zertifizierte Organisationen passt der lokale Stack sauber in die Bausteine SYS.1.1 (Allgemeiner Server), SYS.1.5 (Virtualisierung) und APP.5.4 (Webanwendungen). Der Browser-Server ist hier der heikelste Baustein — separater User, eigener Network-Namespace, kein Zugriff auf Produktiv-Credentials.
• Mittelstand-Use Cases: Steuerberatung, Notariat, Arztpraxis, Maschinenbau-Konstruktion, Personalakten — überall dort, wo Mandanten- oder Patientendaten nicht an OpenAI, Anthropic oder Google gehen dürfen. Ein Mac mini M5 oder ein Workstation-PC mit RTX 4090 reicht für ein 27B–32B-Modell, das Akten zusammenfasst, Verträge prüft oder Code-Snippets gegen interne Datenbanken testet.
• Schweiz und Österreich: revDSG (Schweiz, in Kraft seit September 2023) und das österreichische DSG verfolgen denselben Ansatz wie die DSGVO bezüglich Datenresidenz. Lokale Inferenz erfüllt die Anforderungen ohne zusätzliche Verträge mit US-Anbietern.
• Audit-Trail-Pflichten: Das Audit-Log des MCP-Clients (Goose, Cline, Continue.dev) ist Ihr primärer Nachweis, dass der Agent nichts Unerwartetes getan hat. Sichern Sie es revisionssicher auf einem WORM-Speicher oder zumindest in einem Git-Repository, das Sie nicht aus dem Agenten heraus überschreiben können.
• Drittanbieter-Server prüfen. Behandeln Sie jeden nicht-offiziellen MCP-Server wie jede andere Open-Source-Dependency: Code-Review vor dem Einsatz, keine geheimen Credentials in nicht geprüften Servern, keine Verbindung zu Produktivsystemen ohne Sandbox.

Häufige Fehler beim Einrichten von lokalem MCP

• Fehler 1: Verwendung eines kleinen general-purpose-Modells. Modelle unter 7B (und die meisten 7B–13B-general-purpose-Modelle ohne Tool-Call-Fine-Tuning) geben fehlerhafte Tool-Calls aus. Verwenden Sie ein 27B+-Tool-Call-getuntes Modell und hören Sie auf, gegen den Harness zu kämpfen.
• Fehler 2: Allow-Listing Ihres Home-Verzeichnisses. „Nur zum Testen"-Allow-Listings von ~ überleben in den Routine-Einsatz. Erstellen Sie von Anfang an einen dedizierten agent-workspace.
• Fehler 3: Datenbankserver im Read/Write-Modus belassen. Eine DELETE-Abfrage, die ein selbstbewusster Agent auf einer echten Tabelle verfasst, ist genau der Vorfall, den dies vermeidet. Machen Sie agent_ro zu Ihrem Standard; richten Sie eine separate beschreibbare Rolle nur für Aufgaben ein, die das ausdrücklich brauchen, und nur für die Dauer dieser Aufgaben.
• Fehler 4: Auto-Approval für jedes Tool. Der „Alles genehmigen"-Schalter ist bequem und gefährlich. Auto-Approval für Lese-Tools (read_file, list_directory, query); immer Freigabe verlangen für Schreib-/Shell-/PR-Tools.
• Fehler 5: Ein 32K-Context-Modell für mehrstufige Browser-Arbeit. Seiteninhalte sind groß; ein Agent, der drei Seiten browst, kann 32K Tokens verbrauchen, bevor er zum Reasoning kommt. Nutzen Sie ein 128K-Context-Modell für browser-lastige Aufgaben.
• Fehler 6: Annahme, dass der Agent Urteilsvermögen hat. Hat er nicht. Das Modell hat kein Konzept von „das ist die Produktionsdatenbank" oder „dieser PR wird deployen". Berechtigungen sind Ihre einzige Barriere.
• Fehler 7: Alle Referenz-Server vorab installieren. Mehr Tools = größerer System-Prompt = langsamere und unzuverlässigere Tool-Auswahl. Beginnen Sie mit filesystem. Fügen Sie die anderen erst hinzu, wenn Sie einen Workflow haben, der sie braucht.

Quellen

• Model Context Protocol Spezifikation — Offizielle Spezifikation, JSON-RPC-Schema, Transport- und Lifecycle-Definitionen.
• modelcontextprotocol/servers GitHub-Repository — Referenz-Server (filesystem, sqlite, postgres, github, puppeteer, etc.) und ihre Konfigurationsdokumentation.
• Goose-Projekt-Dokumentation — CLI-Installation, Ollama-Provider-Konfiguration, MCP-Server-Config-Syntax.
• Ollama Model Library — Verfügbare lokale Modelle, Tool-Call-Support-Flags und in diesem Leitfaden referenzierte Quantisierungsstufen.
• Cline GitHub-Repository — VS-Code-MCP-Client-Implementierung, MCP-Server-Panel.
• Continue.dev-Dokumentation — mcpServers-Config-Block-Referenz für den Continue.dev-Client.

FAQ

Weiterführende Literatur

• Beste lokale Modelle für Tool Calling 2026 — Head-to-Head-Benchmarks für die oben empfohlenen Modelle (Gemma 4, GLM-5.1, Qwen3, Llama 3.3).
• Autonome lokale Agenten funktionieren wirklich — ein Realitätscheck, was ein lokaler MCP-Agent über eine langlaufende Aufgabe zuverlässig kann und was nicht.
• Continue.dev vs. Cline vs. Aider: Bester lokaler Coding-Agent 2026 — angrenzender Agent-Kontext für codeförmige Arbeit; Cline und Continue.dev sind ebenfalls MCP-Clients.
• Beste lokale LLMs in 2026 — Modell-Autorität für die breitere Open-Weights-Landschaft.
• Zapier durch lokale KI-Agenten ersetzen — Workflow-Automatisierungs-Framing für denselben MCP-Stack.
• Power Local LLM Hub — vollständige Leitfaden-Bibliothek.