---
title: ""
canonical: "https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen"
language: de
publisher: "StudioMeyer Academy, https://studiomeyer.academy (llms.txt: https://studiomeyer.academy/llms.txt)"
---

[← Alle Playbooks](https://studiomeyer.academy/playbooks)

Playbook· lokal

# MCP mit lokalen Modellen, Werkzeuge ohne Cloud

Ein lokales Modell, das nicht nur redet, sondern Dateien liest, im Kalender nachsieht und Dein Gedächtnis benutzt. Zehn Schritte zum vollständig eigenen Aufbau, inklusive der Stelle an der kleine Modelle beim Tool-Calling scheitern.

Ein Sprachmodell allein ist ein Gesprächspartner ohne Hände. Es kann nicht nachsehen, nicht rechnen, nichts abrufen, es kann nur aus dem antworten, was im Gespräch steht. Interessant wird es, wenn es Werkzeuge bekommt, und das Protokoll dafür ist MCP.

Was bei Claude oder ChatGPT selbstverständlich ist, geht auch komplett lokal. Modell auf Deinem Rechner, Werkzeuge auf Deinem Rechner, Daten auf Deinem Rechner. Dieses Playbook zeigt den Weg dahin und sagt an der richtigen Stelle, wo es hakt, weil es an einer Stelle wirklich hakt.

## 1\. Klär, welche drei Teile Du brauchst

Das Protokoll kennt drei Rollen, und die Verwirrung entsteht meistens, weil man sie mit dem Modell durcheinanderwirft.

Der **Host** ist die Anwendung, in der Du sitzt, etwa Claude Desktop oder eine lokale Weboberfläche. Er startet pro Verbindung einen **Client**, und jeder Client spricht mit genau einem **Server**. Der Server stellt die Werkzeuge bereit, etwa Dateizugriff oder eine Datenbank.

Das Modell ist in dieser Aufzählung bewusst nicht dabei. Es ist kein Teilnehmer am Protokoll. Der Host holt sich die Werkzeugliste von den Servern, legt sie dem Modell vor, und wenn das Modell eines aufrufen will, führt der Host den Aufruf aus. Das klingt nach Haarspalterei, ist aber der Grund, warum derselbe Server hinter beliebigen Modellen funktioniert.

Bei Claude Desktop stecken Host und Modellzugang in einer Anwendung. Bei einem lokalen Aufbau trennst Du sie: Ollama liefert das Modell, eine Oberfläche oder ein eigenes Skript ist der Host. Es ist dieselbe Server-Software wie bei Claude, das ist der ganze Punkt eines offenen Protokolls. Welche Server Du in welcher Umgebung tatsächlich einträgst, ist davon unabhängig und eine Sicherheitsfrage, dazu Schritt 10.

**Tipp:** Wenn Dir das Protokoll selbst noch fremd ist, lies zuerst die Lesson [Was ist MCP](https://studiomeyer.academy/levels/4/02-was-ist-mcp). Der Rest hier setzt sie voraus.

## 2\. Prüf, ob Dein Modell überhaupt Werkzeuge kann

Nicht jedes lokale Modell beherrscht Tool-Calling. Manche wurden nie darauf trainiert, andere können es nur formal und benutzen es dann falsch. Das ist die erste Hürde, und sie sortiert einen guten Teil der Kandidaten aus.

In der Ollama-Bibliothek sind Modelle mit Werkzeug-Unterstützung entsprechend gekennzeichnet. Halt Dich daran, statt es auszuprobieren und dann eine halbe Stunde lang zu suchen, warum nichts passiert.

**Tipp:** Nimm für Tool-Calling nicht das kleinste Modell, das Du finden kannst. Unterhalb von etwa sieben Milliarden Parametern fehlt die Fähigkeit weitgehend, dort kommen häufig fehlerhaft formatierte Aufrufe heraus. Darüber entscheidet aber nicht die Größe, sondern ob das Modell gezielt darauf trainiert wurde: in Vergleichstests liegen 8B- und 14B-Modelle mit Tool-Training nah beieinander, während deutlich größere Modelle ohne dieses Training schlechter abschneiden. Größer ist hier also nicht automatisch besser.

## 3\. Nimm eine Oberfläche, die MCP schon kann

Der schnellste Weg führt über eine Oberfläche, die das Protokoll mitbringt. Open WebUI unterstützt MCP nativ seit Version 0.6.31 und ist auf lokale Modelle ausgelegt. Damit sparst Du Dir, den Client selbst zu schreiben.

Der Aufbau ist dann: Ollama läuft im Hintergrund, Open WebUI verbindet sich damit, und in dessen Einstellungen trägst Du Deine MCP-Server ein.

Ein Detail, das beim ersten Versuch fast jeden erwischt: die Server sind dieselben, die Eintragung ist es nicht. Was in Claude Desktop als lokal gestarteter Prozess konfiguriert wird (stdio, also ein Befehl plus Argumente), braucht in einer Weboberfläche eine erreichbare Adresse. Manche Server können beides, andere nur eines.

Wenn Du für einen stdio-Server eine Brücke brauchst, ist das kein reiner Formatwechsel, sondern eine neue offene Tür. Bind sie auf `127.0.0.1`, gib ihr ein Zugangstoken, und stell sie nicht ins Netz. Ein per Brücke exponierter Dateiserver ohne Anmeldung ist Dateizugriff für jeden, der die Adresse kennt.

**Tipp:** Bevor Du einen eigenen Client baust, probier den fertigen. Die meisten merken dabei, dass sie den eigenen gar nicht brauchen.

## 4\. Fang mit einem harmlosen Server an

Nimm als erstes einen Server, der nur liest. Ein Dateizugriff mit Beschränkung auf ein einziges Testverzeichnis ist ideal. Damit siehst Du, ob die Kette funktioniert, ohne dass ein Fehlgriff etwas anrichtet.

Stell dem Modell dann eine Frage, die es ohne das Werkzeug nicht beantworten kann. "Was steht in der Datei notizen.txt" ist ein guter Test, weil die Antwort eindeutig richtig oder falsch ist.

**Tipp:** Wenn das Modell antwortet, ohne das Werkzeug benutzt zu haben, hat es sich die Antwort ausgedacht. Genau deshalb ist ein Test mit eindeutiger Antwort besser als ein offener.

## 5\. Rechne damit, dass das Modell Werkzeuge übersieht

Hier ist die Stelle, an der lokale Aufbauten sich von Claude unterscheiden, und sie ist wichtiger als alles Technische.

Ein großes Modell entscheidet zuverlässig, wann ein Werkzeug nötig ist. Ein kleines lokales Modell tut das nicht immer. Es antwortet manchmal aus dem Bauch, obwohl das passende Werkzeug bereitsteht. Es ruft manchmal das falsche auf. Und es kann bei einer Kette aus mehreren Schritten den Faden verlieren.

Bevor Du das dem Modell anlastest: es kann auch an der Einrichtung liegen. Ein falsches Chat-Template, ein Server der seine Werkzeuge nicht sauber beschreibt, eine zu grobe Quantisierung, eine Oberfläche die Werkzeug-Aufrufe gar nicht durchreicht. Prüf das zuerst. Bleibt das Verhalten danach, ist es eine Fähigkeitsgrenze des Modells, und die bekommst Du nicht wegkonfiguriert.

**Tipp:** Je weniger Werkzeuge gleichzeitig aktiv sind, desto zuverlässiger wird die Auswahl. Drei gut beschriebene Werkzeuge schlagen zwanzig, bei kleinen Modellen sehr deutlich.

## 6\. Schreib die Werkzeug-Beschreibungen für ein schwächeres Modell

Bei einem starken Modell darf eine Werkzeug-Beschreibung knapp sein, es versteht den Zusammenhang von selbst. Bei einem lokalen Modell ist die Beschreibung Dein wichtigster Hebel.

Schreib hinein, wann das Werkzeug zu benutzen ist, nicht nur was es tut. Statt "sucht in der Datenbank" also "benutze das, wenn nach einem Kunden, einer Rechnung oder einem Vorgang gefragt wird". Der Unterschied in der Trefferquote ist erheblich.

**Tipp:** Wenn Du eigene Server baust, ist das ohnehin die bessere Praxis. Die Regeln für gutes Tool-Design stehen in [Tool Design](https://studiomeyer.academy/levels/6/03-tool-design), und sie zahlen sich bei lokalen Modellen doppelt aus.

## 7\. Häng Dein Gedächtnis an

Der wertvollste Server in einem lokalen Aufbau ist der, der sich Dinge merkt. Ein kleines Modell weiß wenig über die Welt und noch weniger über Dich. Ein Gedächtnis gleicht beides teilweise aus, weil das Wissen dann nicht im Modell stecken muss, sondern nachgeschlagen wird.

Das ist auch der Punkt, an dem die Größenfrage sich entschärft. Ein 8-Milliarden-Modell mit Zugriff auf Deine Notizen ist bei Fragen zu Deinem Projekt besser als ein großes Modell ohne diesen Zugriff.

**Tipp:** Genau darum geht es in der Kernthese dieser Academy. Ein Modell, das Deinen Kontext kennt, schlägt ein stärkeres, das raten muss. Der Aufbau steht in [Memory einrichten](https://studiomeyer.academy/levels/4/03-memory-einrichten).

## 8\. Halt die schreibenden Werkzeuge kurz an der Leine

Schreibende Werkzeuge sind das offensichtliche Risiko. Ein Modell, das Dateien löschen, Mails senden oder Datensätze ändern kann und gelegentlich das falsche Werkzeug greift, ist eine unangenehme Kombination. Die brauchen eine Bestätigung, immer.

Lesen ist deswegen aber nicht harmlos, und das ist der Fehler, den man in Anleitungen ständig liest. Ein Lesewerkzeug mit zu weitem Zugriff holt SSH-Schlüssel, Zugangsdaten, Steuerunterlagen oder Kundendaten in den Modellkontext, und von dort in Protokolle und Verläufe. Wenn Du später dieselbe Oberfläche einmal gegen ein Cloud-Modell laufen lässt, ist das genau der Weg nach draußen, den Du eigentlich vermeiden wolltest. Dazu kommt: was im Namen "read" heißt, muss nicht nebenwirkungsfrei sein, das Protokoll erzwingt das nicht.

Die Regel ist deshalb nicht "lesen frei, schreiben gesperrt", sondern so wenig Zugriff wie möglich auf beiden Seiten. Gib dem Dateiserver ein einzelnes Verzeichnis statt des Benutzerordners, und lass Dir Schreibaktionen bestätigen.

**Tipp:** Fang mit einem einzigen Verzeichnis im Lesezugriff an und erweitere erst, wenn Du weißt, was der Aufbau tatsächlich anfasst. Nicht andersherum.

## 9\. Prüf fremde Server, bevor Du sie anschließt

Ein MCP-Server ist ausführbarer Code auf Deinem Rechner. Dass Dein Modell lokal läuft, macht einen fremden Server nicht sicherer. Der Datenschutzgewinn aus dem lokalen Modell ist dahin, wenn der angeschlossene Server nach Hause telefoniert.

**Tipp:** Der Prüf-Ablauf dafür steht in [Fremde MCP-Server sicher prüfen](https://studiomeyer.academy/playbooks/fremde-mcp-server-sicher-pruefen). Bei einem Aufbau, der ausdrücklich wegen Datenschutz lokal ist, ist dieser Schritt nicht optional.

## 10\. Entscheide ehrlich, ob es reicht

Nach einer Woche im Alltag weißt Du, ob der Aufbau trägt. Zwei Ergebnisse sind normal und beide in Ordnung.

Entweder es reicht, dann hast Du einen Assistenten mit Werkzeugen, bei dem nichts das Haus verlässt. Oder es reicht nicht, weil das Modell zu oft danebengreift. Dann ist die Antwort nicht "lokal taugt nichts", sondern ein gemischter Aufbau: das Lokale für alles mit sensiblen Daten, das große Modell für die schweren Fälle.

Dabei gilt aber genau das, wovor Schritt 8 warnt. Wenn Du im selben Profil zwischen lokalem und Cloud-Modell hin- und herschaltest, gehen die Werkzeuge und der bisherige Verlauf mit, und damit auch alles, was ein Lesewerkzeug vorher hereingeholt hat. Trenn deshalb auf der Ebene, die wirklich trennt: zwei **getrennte Installationen** beziehungsweise getrennte Konfigurationsverzeichnisse. Ein zweites Fenster reicht nicht, und ein zweites Benutzerprofil in derselben Oberfläche auch nicht: die MCP-Server und die Modell-Zugänge sind dort in aller Regel global hinterlegt, also aus beiden Profilen erreichbar. In der lokalen Installation stehen die sensiblen Server und kein Cloud-Zugang; in der anderen steht der Cloud-Zugang und diese Server stehen dort schlicht nicht drin.

**Tipp:** Dass ein MCP-Server auf beiden Seiten laufen KÖNNTE, heißt nicht, dass er es soll. Die Portabilität spart Dir die Einarbeitung beim Aufsetzen der zweiten Umgebung, nicht die Entscheidung, welche Server dort überhaupt eingetragen werden. Mehr zum Prinzip in [Tool-Portabilität](https://studiomeyer.academy/levels/4/05-tool-portabilitaet).

## Was als nächstes

Wenn das Modell selbst noch fehlt, fang mit [Dein erstes lokales KI-Modell in 30 Minuten](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) an. Die Größenfrage klärt [Welches lokale Modell zu Deiner Hardware passt](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware). Und wenn Du irgendwann einen eigenen Server bauen willst, statt fremde anzuschließen, ist Level 6 mit [MCP-Server planen](https://studiomeyer.academy/levels/6/01-mcp-server-planen) der Einstieg.

## Quellen

- Model Context Protocol, offizielle Spezifikation: https://modelcontextprotocol.io
- Ollama, Modelle mit Werkzeug-Unterstützung: https://ollama.com/search?c=tools
- Open WebUI, Dokumentation zur MCP-Anbindung: https://docs.openwebui.com

[← Lokale KI und die DSGVO, was s](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) [Lokal oder Cloud, die ehrliche →](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung)

Alle Playbooks

[01. Von ChatGPT zu Claude. Anleitung in 10 Schritten](https://studiomeyer.academy/playbooks/von-chatgpt-zu-claude) [02. Von ChatGPT zu Codex. Anleitung in 10 Schritten](https://studiomeyer.academy/playbooks/von-chatgpt-zu-codex) [03. Dein erster MCP-Server in 90 Minuten](https://studiomeyer.academy/playbooks/erster-mcp-server-in-90-minuten) [04. Memory portabel nutzen, gleiches Gedächtnis in Claude, Codex und Cursor](https://studiomeyer.academy/playbooks/memory-portabel-nutzen) [05. DACH-Legal. EU AI Act und DSGVO für AI-Operator](https://studiomeyer.academy/playbooks/dach-legal-eu-ai-act-und-dsgvo) [06. Dein erster Sub-Agent in 30 Minuten](https://studiomeyer.academy/playbooks/erster-sub-agent-in-30-min) [07. MCP-Server publishen Schritt für Schritt](https://studiomeyer.academy/playbooks/mcp-server-publishen) [08. Hooks gegen Halluzinationen](https://studiomeyer.academy/playbooks/hooks-gegen-halluzinationen) [09. Git für KI, Quickstart in 30 Minuten](https://studiomeyer.academy/playbooks/git-fuer-ki-quickstart) [10. Scheduled Agents mit Claude Code Routines](https://studiomeyer.academy/playbooks/scheduled-agents-mit-routines) [11. Tool-Sprawl vermeiden, von 530 auf 30 MCP-Tools pro Session](https://studiomeyer.academy/playbooks/tool-sprawl-vermeiden) [12. Claude Code Update-Strategie, ohne dass Dein Workflow plotzlich kaputt ist](https://studiomeyer.academy/playbooks/claude-code-update-strategie) [12. Subagent-Team strukturieren, welche sechs Rollen Du im Daily-Driver brauchst](https://studiomeyer.academy/playbooks/subagent-team-strukturieren) [13. Claude Code Cost Controls für Daily Driver, in 10 Schritten unter 30 Dollar pro Tag bleiben](https://studiomeyer.academy/playbooks/claude-code-cost-controls-fuer-daily-driver) [14. Eigene Slash-Commands für Claude Code, in 30 Minuten produktiv](https://studiomeyer.academy/playbooks/eigene-slash-commands-fuer-claude-code) [15. Claude Code headless in CI/CD, ein Setup das morgen schon läuft](https://studiomeyer.academy/playbooks/claude-code-headless-in-ci-cd) [16. Agent-Eval in 60 Minuten, wie Du herausfindest ob Dein Agent gut ist](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) [17. Plan Mode in Claude Code, der unsichtbare Sicherheitsgurt, wann Du ihn brauchst und wie Du ihn drin lässt](https://studiomeyer.academy/playbooks/plan-mode-richtig-nutzen) [18. MCP debuggen wenn nichts geht, die 10 Checks die 90 Prozent der Fälle lösen](https://studiomeyer.academy/playbooks/mcp-debuggen-wenn-nichts-geht) [18. Prompt-Caching meistern, in 10 Schritten von Cache-Miss zu 80 Prozent Hit-Rate](https://studiomeyer.academy/playbooks/prompt-caching-meistern) [19. Memory Drift reparieren, wenn das Gedächtnis kippt](https://studiomeyer.academy/playbooks/memory-drift-reparieren) [20. MCP-STDIO-Sicherheit, was die OX-Security-Story für Dich bedeutet](https://studiomeyer.academy/playbooks/mcp-stdio-sicherheit) [21. Opus 4.7 Migration, was sich für API-Builder geändert hat](https://studiomeyer.academy/playbooks/opus-4-7-migration) [22. Erste eigene Skill in 30 Minuten, wenn Slash-Commands nicht mehr reichen](https://studiomeyer.academy/playbooks/erste-eigene-skill-in-30-min) [23. Context-Window managen in langen Claude-Code-Sessions](https://studiomeyer.academy/playbooks/context-window-managen-claude-code) [24. Advisor Tool, Opus als Berater und Sonnet als Executor in einem API-Call](https://studiomeyer.academy/playbooks/advisor-tool-opus-als-berater-sonnet-als-executor) [25. MCP-Server mit OAuth 2.1 absichern, in 60 Minuten produktiv](https://studiomeyer.academy/playbooks/mcp-server-auth-mit-oauth-2-1) [26. Plugin-Bundles per URL teilen, --plugin-url in 30 Minuten](https://studiomeyer.academy/playbooks/plugin-bundle-via-url-distribution) [27. Claude Code im Team, wie ihr CLAUDE.md gemeinsam pflegt ohne dass es zur Mülltonne wird](https://studiomeyer.academy/playbooks/claude-code-im-team-claude-md-gemeinsam-pflegen) [27. Fremde Claude-Code-Plugins aus ZIP und URL laden, sicher in 20 Minuten](https://studiomeyer.academy/playbooks/claude-code-plugins-aus-zip-und-url-laden) [28. Confused-Deputy-Audit für Claude Code, in 25 Minuten durchziehen](https://studiomeyer.academy/playbooks/confused-deputy-audit-fuer-claude-code) [28. Dein erstes Claude Code Plugin in 60 Minuten, vom leeren Folder zum installierbaren Bundle](https://studiomeyer.academy/playbooks/dein-erstes-claude-code-plugin) [29. Pull Request Reviews mit Claude Code, 10 Schritte für den PR-Workflow den keiner mehr blockiert](https://studiomeyer.academy/playbooks/pull-request-reviews-mit-claude-code) [30. Claude Projects für Nicht-Coder, ein produktiver Workspace in 30 Minuten](https://studiomeyer.academy/playbooks/claude-projects-fuer-nicht-coder) [31. Promptbibliothek aufbauen, Lieblings-Prompts wiederverwenden ohne Copy-Paste](https://studiomeyer.academy/playbooks/prompt-bibliothek-aufbauen) [32. Output Styles für Claude Code, in 20 Minuten ein eigener Ton](https://studiomeyer.academy/playbooks/output-styles-fuer-claude-code) [33. Statusline für Claude Code, in 15 Minuten Kontext im Blick](https://studiomeyer.academy/playbooks/statusline-fuer-claude-code) [34. Claude Code Checkpoints und /rewind: dein Sicherheitsnetz für riskante Edits](https://studiomeyer.academy/playbooks/claude-code-checkpoints-und-rewind) [34. Discovery-Files konsistent halten, damit AI-Crawler nicht alte Bullshit-Bios zitieren](https://studiomeyer.academy/playbooks/discovery-files-konsistent-halten) [34. Hooks debuggen wenn nichts feuert](https://studiomeyer.academy/playbooks/hooks-debuggen-wenn-nichts-feuert) [34. Parallele Claude-Code-Sessions mit git worktrees, zwei Branches gleichzeitig ohne Konflikt](https://studiomeyer.academy/playbooks/parallele-claude-sessions-mit-worktrees) [34. Skill triggert nicht, was Du in 10 Schritten prüfst bevor Du wieder /befehl tippst](https://studiomeyer.academy/playbooks/skill-trigger-debugging) [34. Sub-Agent oder Skill oder MCP-Tool, was wählst Du wann](https://studiomeyer.academy/playbooks/sub-agent-oder-skill-oder-mcp-tool) [35. Mit Git Worktrees parallele Claude-Code-Sessions fahren](https://studiomeyer.academy/playbooks/claude-code-mit-git-worktrees) [35. Memory-Backup vor Update, damit Du nach einem Schema-Migrations-Bug nicht weinst](https://studiomeyer.academy/playbooks/memory-backup-vor-update) [36. AGENTS.md neben CLAUDE.md, ein Repo-Kontext für mehrere AI-Tools](https://studiomeyer.academy/playbooks/agents-md-neben-claude-md) [47. Generative Engine Optimization für kleine Sites, damit Perplexity und ChatGPT-Search Dich zitieren](https://studiomeyer.academy/playbooks/geo-fuer-kleine-sites) [50. Opus 4.8 Migration, das erste Opus-Update ohne Breaking Changes](https://studiomeyer.academy/playbooks/opus-4-8-migration) [51. Background-Sessions mit Claude Agents: lange Tasks laufen lassen ohne dein Terminal zu blockieren](https://studiomeyer.academy/playbooks/background-sessions-mit-claude-agents) [52. Claude Code Bash-Sandbox einrichten: Befehle isolieren statt blind freigeben](https://studiomeyer.academy/playbooks/claude-code-bash-sandbox-einrichten) [53. Vom Skript zum eigenen Agent: der Claude Agent SDK in 90 Minuten](https://studiomeyer.academy/playbooks/claude-agent-sdk-erster-eigener-agent) [54. MCP App bauen: interaktive UI in deinem MCP-Tool statt Text-Wand](https://studiomeyer.academy/playbooks/mcp-app-interaktive-ui-bauen) [55. Mythos teure Modellklasse: Wann sich das teuerste KI-Modell wirklich lohnt](https://studiomeyer.academy/playbooks/mythos-klasse-wann-lohnt-sich-das) [56. Fallback-Modelle einrichten, damit Claude Code bei Overload nicht stehenbleibt](https://studiomeyer.academy/playbooks/claude-code-fallback-modelle) [57. Dynamic Workflows in Claude Code, dein erstes orchestriertes Multi-Agent-Skript](https://studiomeyer.academy/playbooks/dynamic-workflows-in-claude-code) [58. Security-Guidance Plugin für Claude Code, automatischer Sicherheits-Review während du baust](https://studiomeyer.academy/playbooks/claude-code-security-guidance-plugin) [59. Claude Code spinnt nach einer Config-Änderung, so findest du die Ursache](https://studiomeyer.academy/playbooks/claude-code-safe-mode-diagnose) [60. MCP ist stateless, was die 2026-07-28 Spec ändert und was Du jetzt tun musst](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich) [61. Dein erster echter n8n-Flow, Automatisierung für Leute die nicht programmieren](https://studiomeyer.academy/playbooks/mein-erster-n8n-flow-fuer-nicht-coder) [62. Agentic Payments mit x402, was Du als Builder über maschinen-bezahlte APIs wissen musst](https://studiomeyer.academy/playbooks/agentic-payments-x402) [63. GPT-5.6 oder Opus 5, welches Modell für welche Aufgabe](https://studiomeyer.academy/playbooks/gpt-5-oder-opus-4-8-welches-modell) [64. Subagents die Subagents spawnen, die 5-Ebenen-Regel von Claude Code](https://studiomeyer.academy/playbooks/subagents-die-subagents-spawnen) [65. Claude Code Agent Teams einrichten, mehrere Sessions die sich gegenseitig zuarbeiten](https://studiomeyer.academy/playbooks/claude-code-agent-teams-einrichten) [66. Modell-Verfügbarkeit tracken, wenn ein Modell über Nacht verschwindet](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken) [67. Datenschutz beim Arbeiten mit KI-Tools: zehn Gewohnheiten, die dich schützen](https://studiomeyer.academy/playbooks/datenschutz-mit-ki-tools) [68. Auto Mode in Claude Code sicher nutzen, in 10 Schritten ohne Selbstmord-Kommandos](https://studiomeyer.academy/playbooks/claude-code-auto-mode-sicher-nutzen) [69. KI für die Jobsuche: In 10 Schritten durch den ATS-Filter](https://studiomeyer.academy/playbooks/ki-fuer-jobsuche) [70. In 10 Schritten ein AI-Portfolio bauen das dir einen Job bringt](https://studiomeyer.academy/playbooks/ai-portfolio-fuer-den-job) [71. AI-Skills im Lebenslauf und Interview glaubwürdig belegen](https://studiomeyer.academy/playbooks/ai-skills-belegen-lebenslauf-interview) [72. Effort-Level in Claude Code, wann low reicht und wann Du max brauchst](https://studiomeyer.academy/playbooks/effort-level-in-claude-code-einstellen) [73. Vom Academy-Skill zum ersten bezahlten KI-Auftrag](https://studiomeyer.academy/playbooks/erster-bezahlter-ki-auftrag) [74. Eine KI-Antwort faktenchecken: 10 Schritte gegen falsche Auskünfte](https://studiomeyer.academy/playbooks/ki-antwort-faktenchecken) [75. KI-Bilder für deine Marke, vom ersten Prompt zum fertigen Set](https://studiomeyer.academy/playbooks/ki-bilder-fuer-deine-marke) [76. KI für Selbstständige, Angebote und Kundenmails in der halben Zeit schreiben](https://studiomeyer.academy/playbooks/ki-fuer-selbststaendige-angebote-und-mails) [77. KI-Inhalte erkennen und richtig kennzeichnen](https://studiomeyer.academy/playbooks/ki-inhalte-erkennen-und-kennzeichnen) [78. KI-Notizen für Meetings, die wirklich brauchbar sind](https://studiomeyer.academy/playbooks/ki-notizen-fuer-meetings) [79. Lokale KI auf dem eigenen Rechner, damit deine Daten nie das Haus verlassen](https://studiomeyer.academy/playbooks/lokale-ki-auf-dem-eigenen-rechner) [80. Die drei MCP-Primitive verstehen, Tools, Resources und Prompts](https://studiomeyer.academy/playbooks/mcp-primitives-tools-resources-prompts) [81. Verlässliches JSON aus jeder AI, damit Deine Automation nicht bricht](https://studiomeyer.academy/playbooks/verlaessliches-json-aus-ai) [82. Was KI-Tools wirklich kosten, und wo die versteckten Rechnungen lauern](https://studiomeyer.academy/playbooks/was-kostet-ki-wirklich) [83. Prompt Injection verstehen, die drei Fallen wenn dein KI-Assistent fremde Texte liest](https://studiomeyer.academy/playbooks/prompt-injection-erkennen) [84. Dich vor KI-Betrug schützen, Fake-Anrufe, Phishing und falsche Job-Angebote](https://studiomeyer.academy/playbooks/dich-vor-ki-betrug-schuetzen) [85. Opus 5 Migration, wenn Denken plötzlich der Standard ist](https://studiomeyer.academy/playbooks/opus-5-migration) [86. Die KI-Richtlinie für kleine Teams, auf einer Seite](https://studiomeyer.academy/playbooks/ki-richtlinie-fuer-kleine-teams) [87. Agenten die abdriften stoppen](https://studiomeyer.academy/playbooks/agenten-die-abdriften-stoppen) [88. Sehen was Dein Agent wirklich getan hat, Tracing in 10 Schritten mit OpenTelemetry](https://studiomeyer.academy/playbooks/agent-tracing-mit-opentelemetry) [89. Lange Dokumente von KI zusammenfassen lassen, ohne dass sie Sachen erfindet](https://studiomeyer.academy/playbooks/lange-dokumente-sicher-zusammenfassen) [90. Fremde MCP-Server sicher prüfen, bevor Du sie installierst](https://studiomeyer.academy/playbooks/fremde-mcp-server-sicher-pruefen) [91. KI als Lern-Coach: ein neues Feld lernen für den Berufswechsel](https://studiomeyer.academy/playbooks/ki-lern-coach-berufswechsel) [92. Berufsbild AI-Operator: was macht man da eigentlich?](https://studiomeyer.academy/playbooks/berufsbild-ai-operator) [93. KI nutzen ohne selbst zu verlernen](https://studiomeyer.academy/playbooks/ki-nutzen-ohne-selbst-zu-verlernen) [94. Warum dein Screenshot schrumpft, und wie du das steuerst](https://studiomeyer.academy/playbooks/bilder-und-screenshots-an-die-ki-geben) [95. Einen Deep-Research-Auftrag formulieren, damit der Bericht auch was taugt](https://studiomeyer.academy/playbooks/deep-research-auftrag-formulieren) [96. Zahlen und Tabellen mit KI auswerten, ohne dass am Ende Unsinn rauskommt](https://studiomeyer.academy/playbooks/zahlen-und-tabellen-mit-ki-auswerten) [97. KI-Benchmarks lesen ohne dich verarschen zu lassen](https://studiomeyer.academy/playbooks/ki-benchmarks-richtig-lesen) [98. KI als Sparringspartner, bessere Entscheidungen statt netter Zustimmung](https://studiomeyer.academy/playbooks/ki-als-sparringspartner-fuer-entscheidungen) [99. Mit KI eine neue Fähigkeit lernen, der ehrliche Weg](https://studiomeyer.academy/playbooks/mit-ki-neue-faehigkeit-lernen) [100. Deinen MCP-Server ändern ohne die Nutzer zu brechen](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [101. Dein erstes lokales KI-Modell in 30 Minuten](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [102. Welches lokale Modell zu Deiner Hardware passt](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware) [103. Lokale KI und die DSGVO, was sie wirklich löst und was nicht](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) [104. MCP mit lokalen Modellen, Werkzeuge ohne Cloud](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) [105. Lokal oder Cloud, die ehrliche Rechnung](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung) [106. Wenn ein fremdes Repo Deine KI konfiguriert. Der ChainDrop-Fall](https://studiomeyer.academy/playbooks/agent-konfiguration-als-angriffsweg) [107. Gespräche offline transkribieren, ohne dass sie das Haus verlassen](https://studiomeyer.academy/playbooks/gespraeche-offline-transkribieren) [108. n8n mit einem lokalen Modell verbinden](https://studiomeyer.academy/playbooks/n8n-mit-lokalem-modell-verbinden) [109. Dokumente offline auslesen, wenn der Scan nicht hochgeladen werden darf](https://studiomeyer.academy/playbooks/dokumente-offline-auslesen) [→ Zur Academy](https://studiomeyer.academy/levels/1)

## Sitemap

Öffentliche Seiten dieser Website als Markdown: [Sitemap](https://studiomeyer.academy/sitemap.md). Kuratierter Einstieg: [llms.txt](https://studiomeyer.academy/llms.txt), Volltext: [llms-full.txt](https://studiomeyer.academy/llms-full.txt).