Skip to content
Projekte

rohitg00/ai-engineering-from-scratch

Auf GitHub ansehen

rohitg00/ai-engineering-from-scratch has 78,173 GitHub stars and 13,896 forks. GitHot measured +321 stars in 24 hours, +1,710 in 7 days, and +3,925 in 15 days. Last checked 2026-11-10 03:19 UTC. Last push 2026-10-29.

So werden diese Zahlen gemessen

Lerne KI-Engineering! Lerne es, baue es und liefere es für andere aus.

Gemessener Sternzuwachs

in 24h
+321
in 7 days
+1.710
in 15 days
+3.925
in 1 month
Aktualisierung verzögert

Nettoänderungen in überlappenden Zeiträumen, keine Tagessummen. Fehlende Messwerte bleiben leer. Sterne zeigen Interesse, nicht Qualität.

i18n/de/README.md

Original

KI-gestützte Übersetzung; Struktur und Terminologie geprüft. Das englische Original ist maßgeblich.

KI-Engineering von Grund auf

Implementiere Modellinterna, Retrieval-Pipelines und Agenten-Laufzeitumgebungen. Teste sie, untersuche Fehler und behalte Code und Evaluationsergebnisse.

Mit dem Lernen beginnen · Lernpfad wählen · Ein Labor ausprobieren · Ein Projekt bauen · Lehrplan durchsuchen

Kostenlos, quelloffen, MIT-lizenziert. Lerne auf der Webseite, mit einem Programmieragenten oder durch lokal ausgeführten Code.

542 Lektionen. 20 Phasen. Python, TypeScript, Rust, Julia.

MIT-Lizenz 542 Lektionen 20 Phasen GitHub-Sterne Webseite

In deiner Sprache lesen

🇬🇧 English · 🇨🇳 简体中文 · 🇹🇼 繁體中文(台灣) · 🇯🇵 日本語 · 🇰🇷 한국어 · 🇵🇹 Português · 🇧🇷 Português (Brasil) · 🇪🇸 Español · 🇩🇪 Deutsch · 🇫🇷 Français · 🇮🇹 Italiano · 🇳🇱 Nederlands · 🇵🇱 Polski · 🇨🇿 Čeština · 🇷🇴 Română · 🇭🇺 Magyar · 🇬🇷 Ελληνικά · 🇸🇪 Svenska · 🇩🇰 Dansk · 🇳🇴 Norsk · 🇫🇮 Suomi · 🇷🇺 Русский · 🇺🇦 Українська · 🇹🇷 Türkçe · 🇮🇱 עברית · 🇸🇦 العربية · 🇮🇷 فارسی · 🇮🇳 हिन्दी · 🇧🇩 বাংলা · 🇵🇰 اردو · 🇹🇭 ไทย · 🇻🇳 Tiếng Việt · 🇮🇩 Bahasa Indonesia · 🇵🇭 Tagalog

Sponsoren

SerpApi. Websuch-API für KI-Anwendungen, verfügbar in Markdown und JSON für jede Integration.

Dank eurer Unterstützung bleiben alle Lektionen kostenlos und Open Source. Alle Unterstützer ansehen · Sponsor werden

Lernpfade

Lernpfad Erste Lektion
Modellgrundlagen Einrichtung und Werkzeuge
LLM-Systeme Prompt-Entwicklung
Agenten und Auslieferung Die Agentenschleife

Berufliche Lernpfade vergleichen · Voraussetzungen und Lernzeit

Gradientenabstieg

Zwanzig Startpunkte folgen dem Gradientenabstieg auf einer quadratischen Verlustfunktion. Die Grafik zeigt ihre Positionen und den mittleren Verlust nach jedem Aktualisierungsschritt.

Gradientenabstieg bewegt verstreute Startpunkte zum Minimum der Verlustfunktion. Der mittlere Verlust sinkt mit jedem Aktualisierungsschritt.

Lernrate in der Lektion anpassen · GD, Momentum und Adam im Code vergleichen

Projekte

Drei Projekte mit stufenweisen Startgerüsten, Referenzimplementierungen und lokalen Prüfern. Führe Befehle nach der Einrichtung im Repository-Stamm aus. Die Startgerüste bestehen die Prüfungen erst, wenn du die Stufen implementiert hast.

01 · Labor zur Retrieval-Evaluation · Python · Rangmetriken und Regressionsprüfungen

Ein Kandidat verbessert den mittleren NDCG, während eine Anfrage ihren relevantesten Beleg niedriger einordnet. Baue einen Vergleich je Anfrage, der die Regression meldet und eine Freigabeprüfung fehlschlagen lassen kann.

Nutze Python 3.10+. Wiederhole RAG und Modellevaluation. Implementiere die Rangfolgenvalidierung, Präzision und Recall, rangabhängige Metriken und anschließend den Systemvergleich.

python3 scripts/project_test.py retrieval-evaluation-lab \
  --init learning-artifacts/retrieval-evaluation-lab
python3 scripts/project_test.py retrieval-evaluation-lab \
  --stage 1 --path learning-artifacts/retrieval-evaluation-lab --strict
python3 scripts/project_test.py retrieval-evaluation-lab \
  --all --path learning-artifacts/retrieval-evaluation-lab --strict

Behalte: einen reproduzierbaren Vergleich mit Änderungen je Anfrage und den zugrunde liegenden Relevanzurteilen. Die Metriken beschreiben diese Urteile; sie belegen nicht die Korrektheit der Antworten.

Projekt starten · Referenz untersuchen · Mit eigenen Eingaben ausführen

02 · Debugger für Agenten-Traces · TypeScript · Trace-Parsing und Zeitmessung

Ein bereitgestellter Trace dauert weiterhin 100 ms, aber der gesamte Tokenverbrauch steigt um 200 und ein Span beginnt fehlzuschlagen. Trenne überlappende Arbeit der Kind-Spans von der Ausführungszeit des Eltern-Spans und erstelle einen Bericht, der die Änderung sichtbar macht.

Nutze Node.js 22.18+ und Python 3 für den Prüfer. Implementiere JSONL-Parsing, die Validierung der Elternbeziehungen, Intervallarithmetik und anschließend eine einsehbare Zeitleiste.

python3 scripts/project_test.py agent-trace-debugger \
  --init learning-artifacts/agent-trace-debugger
python3 scripts/project_test.py agent-trace-debugger \
  --stage 1 --path learning-artifacts/agent-trace-debugger --strict
python3 scripts/project_test.py agent-trace-debugger \
  --all --path learning-artifacts/agent-trace-debugger --strict

Behalte: den Eingabe-Trace, eine HTML-Zeitleiste und einen JSON-Regressionsbericht. Bewahre exklusive Tokenzahlen je Span, damit der Verbrauch von Eltern- und Kind-Spans nicht doppelt gezählt wird.

Projekt starten · Referenz untersuchen · Zeitverhalten interaktiv untersuchen

03 · Firewall für Werkzeugaufrufe · Rust · Rollenprüfungen und Freigabebelege

Ein Schreibvorgang ändert sich nach der Prüfung oder eine Freigabe wird erneut verwendet. Validiere die Aufrufhülle, prüfe Rolle und Pfad des Aufrufers und verbrauche dann eine Freigabe, die an die genaue Anfrage und ihren Inhalt gebunden ist.

Nutze Rust und Python 3.10+. Wiederhole das Design von Werkzeugschemata und Sicherheitsgrenzen. Die aufrufende Anwendung liefert die Identität; das Modell schlägt eine Operation vor.

python3 scripts/project_test.py tool-call-firewall \
  --init learning-artifacts/tool-call-firewall
python3 scripts/project_test.py tool-call-firewall \
  --stage 1 --path learning-artifacts/tool-call-firewall --strict
python3 scripts/project_test.py tool-call-firewall \
  --all --path learning-artifacts/tool-call-firewall --strict

Behalte: einen Audit-Beleg mit der angeforderten Operation und der Richtlinienentscheidung. Freigaben sind innerhalb eines Aufrufs einmalig nutzbar; dieses Projekt bietet weder dauerhafte Autorisierung noch eine Betriebssystem-Sandbox.

Projekt starten · Referenz untersuchen · Freigabegrenzen untersuchen

Alle Projekte durchsuchen · Leitfaden zur beruflichen Praxis

Wähle, wie du lernen möchtest

Auf der Webseite

Öffne eine beliebige abgeschlossene Lektion auf aiengineeringfromscratch.com oder klappe unter Inhalt eine Phase auf. Keine Einrichtung, kein Klonen.

Mit einem KI-Tutor

Wenn Node.js, npx und ein Coding-Agent mit Skills-Unterstützung bereits installiert sind, kannst du ihn zu deinem Tutor machen. Zum Installieren oder Lesen des Tutors brauchst du kein Repository zu klonen. Ausführbare Labs für die fokussierten Lernpfade benötigen python3. Für Agent-Skills-Labs brauchst du außerdem einen unterstützten Host und einen beschreibbaren Skill-Bereich für Benutzer oder Projekt.

npx skills add rohitg00/ai-engineering-from-scratch

Wähle Host und Geltungsbereich, wenn der Installer danach fragt. Nutze start-learning in Codex, /start-learning in Claude Code oder bitte deinen Host, den Skill namentlich zu verwenden.

Tutor einrichten und Host-Befehle nutzen

Prüfe zuerst, ob die nötigen Werkzeuge installiert sind:

node --version
npx --version
python3 --version

Das Installationsprogramm schreibt die Skills in den Host und Speicherbereich, die du bei der Installation ausgewählt hast, zum Beispiel in .claude/skills/, .cursor/skills/, .codex/skills/ oder einen anderen unterstützten Skill-Ordner. Prüfe, ob der Host genau diesen Speicherort erkennt.

Die Aufrufsyntax hängt vom Host ab; sie gehört nicht zum portablen Format SKILL.md:

Host-Anwendung Kurs starten Model Context Protocol (MCP) starten Agent Skills starten Quiz zu einer Phase starten
Codex start-learning oder über /skills auswählen learn-mcp oder über /skills auswählen learn-agent-skills oder über /skills auswählen check-understanding 13 oder über /skills auswählen
Claude Code /start-learning /learn-mcp /learn-agent-skills /check-understanding 13
Andere kompatible Hosts Use start-learning to begin the course. Use learn-mcp to start the Model Context Protocol (MCP) path. Use learn-agent-skills to start the Agent Skills Engineering path. Use check-understanding to quiz me on Phase 13.

Ein Einstufungstest mit zehn Fragen ermittelt, was du bereits weißt, ordnet dich einer Einstiegsphase zu und speichert einen persönlichen Lernplan in LEARNING.md. Danach vermittelt der Skill learn pro Sitzung eine Lektion: Konzept, Mathematik, Code und Quiz. Der Skill course-guide verweist dich direkt auf die Lektion, die bei einem Thema oder Problem weiterhilft. In Codex rufst du die Skills mit learn und course-guide auf, in Claude Code mit /learn und /course-guide. Bei anderen kompatiblen Hosts bittest du darum, den jeweiligen Skill zu verwenden.

Du möchtest nur Model Context Protocol (MCP) lernen? Verwende den MCP-Aufruf für deinen Host. Er erstellt MCP-LEARNING.md und führt dich durch einen 17-Lektionen-Pfad: zustandslose Anfragen, Transport, bidirektionale Abläufe, Sicherheit, Zuverlässigkeit, Registry-Governance und Konformitätsnachweise. Die genaue Reihenfolge und die Meilensteine stehen im MCP-Manifest.

Du möchtest nur Agent Skills lernen? Verwende den Aufruf für Agent Skills auf deinem Host. Er erstellt AGENT-SKILLS-LEARNING.md und führt dich durch fünf zusammenhängende Lektionen: Spezifikation, Auffinden, Aufruf, Sandbox-Grenzen und anschließend Release-Evaluierungen sowie Portabilität zwischen echten Hosts. Starte im Web mit dem Pfad zu Agent Skills.

Das Installationsprogramm zeigt die Hosts an, die es konfigurieren kann, und fragt, wo die Skills installiert werden sollen. Wenn dir Node.js, npx, python3, ein unterstützter Host oder ein beschreibbarer Speicherbereich noch fehlt, nutze die Website oder lies docs/en.md von Hand. So lernst du die Konzepte; die Nachweise für Auffinden, Aufrufen, Skripte und Deinstallation auf einem echten Host musst du nachholen, sobald die Vorabprüfung verfügbar ist. Die Lektionen findest du auf aiengineeringfromscratch.com.

Lern-Skills

Fähigkeit Funktion
start-learning Einmaliger Einstieg: Lernziel klären, Einstufungstest absolvieren und persönlichen Lernplan in LEARNING.md speichern.
learn Der Tutor-Ablauf: Wissen zum Einstieg auffrischen, die nächste Lektion interaktiv bearbeiten, das Quiz absolvieren und Fortschritt sowie Wiederholungsbedarf festhalten.
course-guide Themen-Navigator: „Wo lerne ich Attention?“ oder „Mein Loss ist NaN“ führt mit Links direkt zu den passenden Lektionen.
learn-mcp Tutor für Model Context Protocol (MCP). Erstellt MCP-LEARNING.md, folgt dem Manifest mit 17 Lektionen und dokumentiert Wire-Format, Sicherheit, Zuverlässigkeit und Konformität.
learn-agent-skills Tutor für Agent Skills. Erstellt AGENT-SKILLS-LEARNING.md, behandelt die Lektionen 22 und 24–27 und dokumentiert Nachweise auf einem echten Host.
learn-reverse-engineering Tutor für Reverse Engineering. Erstellt REVERSE-ENGINEERING-LEARNING.md, behandelt die Lektionen 32 bis 45 aus Phase 13 an Programmen, die du selbst baust, und dokumentiert Nachweise aus dem Labor.
claude-certification Zertifizierungstutor: wählt CCAO-F, CCDV-F, CCAR-F oder CCAR-P, unterrichtet die Lektionen, führt Labs aus, prüft Artefakte, verwaltet Diagnose- und Übungsprüfungen und speichert den Fortschritt.
mcpa-certification MCPA-Tutor: folgt dem 34-Lektionen-Pfad mcpa-f für das Protokoll vom 2026-07-28, führt Labs und Wire-Format-Prüfer aus, verwaltet den Diagnosetest und drei Übungsprüfungen und speichert den Fortschritt.
find-your-level Einstufungstest mit zehn Fragen: ermittelt deine Startphase und erstellt einen persönlichen Lernpfad mit Zeitangaben.
check-understanding <phase> Quiz mit acht Fragen pro Phase, Feedback und konkreten Lektionen zur Wiederholung. Verwende den Codex-, Claude-Code- oder natürlichsprachlichen Aufruf aus der obigen Tabelle.

Code lokal ausführen

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
python3 phases/00-setup-and-tooling/01-dev-environment/code/verify.py --route beginner
python3 phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

Die Vorabprüfung trennt die Anforderungen, die du sofort brauchst, von den Werkzeugen, die erst später nötig sind. Bei jedem erforderlichen Schritt, der fehlschlägt, werden die erkannte Ursache und ein Korrekturbefehl angezeigt. Der Befehl vectors.py startet eine Lektion ohne zusätzliche Abhängigkeiten und zeigt, dass eine Matrix-Vektor-Multiplikation den Vorgang innerhalb einer neuronalen Netzwerkschicht darstellt. Speichere die Terminalausgabe als deinen ersten Nachweis.

Arbeite jede Lektion nach demselben Muster durch

Arbeite jede Lektion nach demselben Muster durch

  1. Lies docs/en.md und erkläre die Grundidee mit eigenen Worten.
  2. Tippe den wichtigen Code selbst und baue ihn nach, statt den Codeblock nur als Dekoration zu betrachten.
  3. Führe den Befehl für die Lektion vom Repository-Stammverzeichnis aus – dem Ordner mit README.md und phases/.
  4. Halte die Ergebnisse fest: den Befehl, das Arbeitsverzeichnis, den Exit-Code, die aussagekräftige Ausgabe und das Artefakt, das du geändert oder erstellt hast.
  5. Mach erst weiter, wenn du die Ausgabe erklären und ohne zu raten eine kleine Änderung vornehmen kannst.

Befehle auf den Lektionsseiten verwenden Pfade relativ zum Repository-Stammverzeichnis, sofern die Lektion nicht ausdrücklich zum Wechsel in einen anderen Ordner auffordert. Wenn eine Lektion mehrere Sprachen anbietet, führe die Implementierung in der Sprache aus, die du lernst.

Wähle einen Lernpfad

Du musst nicht erst alle 542 Lektionen durchsehen. Wähle ein Ziel. Jeder Link führt zum selben Lehrplan auf GitHub oder auf der Website; beide Fassungen verwenden denselben Lektionencode.

Dein Ziel Auf GitHub lernen Auf der Website lernen
Ich bin neu und möchte die Grundlagen vollständig lernen Phase 0: Einrichtung und Werkzeuge Entwicklungsumgebung
Ich kenne Python und möchte mathematische Grundlagen und ML lernen Phase 1: Mathematische Grundlagen Lineare Algebra intuitiv verstehen
Ich möchte produktive LLM-Anwendungen entwickeln Phase 11: LLM-Engineering Prompt Engineering
Ich möchte Agenten entwickeln Phase 14: Agent-Engineering Die Agent-Schleife
Ich möchte Coding-Agenten in echten Repositories einsetzen Pfad für agentengestütztes Engineering Agentengestütztes Engineering
Ich möchte vor der Implementierung festlegen, was gebaut werden soll Pfad für Produktentscheidungen und Umsetzung Produktentscheidungen und Umsetzung

Du weißt nicht, wo du anfangen sollst? Nutze den Einstufungstutor start-learning oder den Leitfaden zu den Voraussetzungen.

Vergleiche vier Kerndomänen und sechs Karrierepfade in den Lernpfaden für AI Engineering.

Gezielte Lernpfade für MCP, Agent Skills und Reverse Engineering
Dein Ziel Auf GitHub lernen Auf der Website lernen
Ich möchte mit dem Model Context Protocol (MCP) entwickeln Pfad zum Model Context Protocol (MCP) Pfad zum Model Context Protocol (MCP)
Ich möchte Agent Skills schreiben und veröffentlichen Kompakter Pfad zu Agent Skills Pfad zu Agent Skills
Ich möchte kompilierte Programme lesen Pfad zu Reverse Engineering Pfad zu Reverse Engineering
Voraussetzungen und Lernzeit

Voraussetzungen

  • Du kannst programmieren (in einer beliebigen Sprache; Python ist hilfreich).
  • Du möchtest verstehen, wie KI wirklich funktioniert, statt nur APIs aufzurufen.

Wo du anfangen kannst

Vorkenntnisse Einstieg Geschätzte Zeit
Neu in Programmierung und KI Phase 0 — Einrichtung und Werkzeuge ~306 Stunden
Python-Kenntnisse, neu in ML Phase 1 — Mathematische Grundlagen ~270 Stunden
ML-Kenntnisse, neu im Deep Learning Phase 3 — Kern des Deep Learning ~200 Stunden
Deep-Learning-Kenntnisse, Ziel LLMs und Agenten Phase 10 — LLMs von Grund auf ~100 Stunden
Senior Engineer, nur Agent-Engineering Phase 14 — Agent-Engineering ~60 Stunden
Nur produktive MCP-Systeme entwickeln Pfad zum Model Context Protocol (MCP) ~23 Stunden 15 Minuten
Nur produktive Agent Skills entwickeln Pfad für Agent-Skills-Engineering ~9,5 Stunden
Nur Reverse Engineering lernen Pfad zu Reverse Engineering ~32,5 Stunden

Der Aufbau des Lehrplans

Die 20 Phasen bauen aufeinander auf. Mathematik bildet das Fundament, Agenten und Produktionssysteme das Dach. Wenn du die Grundlagen schon kennst, kannst du vorausgehen. Überspringe sie aber nicht, wenn du danach nicht verstehen willst, warum es weiter oben hakt.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#fafaf5','primaryTextColor':'#1a1a1a','primaryBorderColor':'#3553ff','lineColor':'#3553ff','fontFamily':'JetBrains Mono','fontSize':'12px'}}}%%
flowchart TB
  P0["Phase 0: Einrichtung und Werkzeuge"] --> P1["Phase 1 : Mathematische Grundlagen"]
  P1 --> P2["Phase 2 : ML-Grundlagen"]
  P2 --> P3["Phase 3 : Kern des Deep Learning"]
  P3 --> P4["Phase 4 : Computer Vision"]
  P3 --> P5["Phase 5 : NLP: Grundlagen bis zum fortgeschrittenen Niveau"]
  P3 --> P6["Phase 6 : Sprache und Audio"]
  P3 --> P9["Phase 9 : Reinforcement Learning"]
  P5 --> P7["Phase 7 : Transformer im Detail"]
  P7 --> P8["Phase 8 : Generative KI"]
  P7 --> P10["Phase 10 : LLMs von Grund auf"]
  P10 --> P11["Phase 11 : LLM-Engineering"]
  P10 --> P12["Phase 12 : Multimodale KI"]
  P11 --> P13["Phase 13 : Werkzeuge und Protokolle"]
  P13 --> P14["Phase 14 : Agent-Engineering"]
  P14 --> P15["Phase 15 : Autonome Systeme"]
  P15 --> P16["Phase 16 : Multi-Agenten-Systeme und Schwärme"]
  P14 --> P17["Phase 17 : Infrastruktur und Produktion"]
  P15 --> P18["Phase 18 : Ethik, Sicherheit und Alignment"]
  P16 --> P19["Phase 19 : Abschlussprojekte"]
  P17 --> P19
  P18 --> P19

Inhalt

20 Phasen. Klappe eine Phase auf, um die zugehörigen Lektionen zu sehen.

Phase 0: Einrichtung und Werkzeuge 13 Lektionen

Mach deine Arbeitsumgebung startklar für alles, was folgt.

# Lektion Typ Sprachen
01 Entwicklungsumgebung Umsetzen Python
02 Git und Zusammenarbeit Lernen —
03 GPU-Setup und Cloud Umsetzen Python
04 APIs und Zugangsschlüssel Umsetzen Python
05 Jupyter-Notebooks Umsetzen Python
06 Python-Umgebungen Umsetzen Shell
07 Docker für KI Umsetzen Docker
08 Editor einrichten Umsetzen —
09 Datenverwaltung Umsetzen Python
10 Terminal und Shell Lernen —
11 Linux für KI Lernen —
12 Debugging und Profiling Umsetzen Python
13 Python für AI Engineering Umsetzen Python
Phase 1 — Mathematische Grundlagen  22 Lektionen  Verstehe die Grundlagen hinter KI-Algorithmen durch Programmieren.
# Lektion Typ Sprachen
01 Lineare Algebra intuitiv verstehen Lernen Python, Julia
02 Vektoren, Matrizen und Operationen Umsetzen Python, Julia
03 Matrizen-Transformationen und Eigenwerte Umsetzen Python, Julia
04 Analysis für ML: Ableitungen und Gradienten Lernen Python
05 Kettenregel und automatische Differenzierung Umsetzen Python
06 Wahrscheinlichkeit und Verteilungen Lernen Python
07 Satz von Bayes und statistisches Denken Umsetzen Python
08 Optimierung: Familie der Gradientenabstiegsverfahren Umsetzen Python
09 Informationstheorie: Entropie und KL-Divergenz Lernen Python
10 Dimensionsreduktion: PCA, t-SNE, UMAP Umsetzen Python
11 Singulärwertzerlegung Umsetzen Python, Julia
12 Tensoroperationen Umsetzen Python
13 Numerische Stabilität Umsetzen Python
14 Normen und Abstände Umsetzen Python
15 Statistik für ML Umsetzen Python
16 Stichprobenverfahren Umsetzen Python
17 Lineare Gleichungssysteme Umsetzen Python
18 Konvexe Optimierung Umsetzen Python
19 Komplexe Zahlen für KI Lernen Python
20 Fourier-Transformation Umsetzen Python
21 Graphentheorie für ML Umsetzen Python
22 Stochastische Prozesse Lernen Python
Phase 2 — ML-Grundlagen  21 Lektionen  Klassisches ML bildet noch immer das Rückgrat der meisten KI-Systeme in Produktion.
# Lektion Typ Sprachen
01 Was ist maschinelles Lernen? Lernen Python
02 Lineare Regression von Grund auf Umsetzen Python
03 Logistische Regression und Klassifikation Umsetzen Python
04 Entscheidungsbäume und Random Forests Umsetzen Python
05 Support-Vector-Machines Umsetzen Python
06 KNN und Distanzmetriken Umsetzen Python
07 Unüberwachtes Lernen: K-Means und DBSCAN Umsetzen Python
08 Feature Engineering und Auswahl Umsetzen Python
09 Modellevaluierung: Metriken und Kreuzvalidierung Umsetzen Python
10 Bias, Varianz und Lernkurve Lernen Python
11 Ensemble-Methoden: Boosting, Bagging, Stacking Umsetzen Python
12 Hyperparameter-Abstimmung Umsetzen Python
13 ML-Pipelines und Experimentverfolgung Umsetzen Python
14 Naiver Bayes-Klassifikator Umsetzen Python
15 Grundlagen der Zeitreihen Umsetzen Python
16 Anomalieerkennung Umsetzen Python
17 Umgang mit unausgewogenen Daten Umsetzen Python
18 Merkmalsauswahl Umsetzen Python
19 ML-Systemdesign: vom Problem zum produktiven Modell Umsetzen Python
20 Modelle in der Produktion überwachen: Data Drift und Concept Drift Umsetzen Python
21 Feature Stores und Training-Serving-Skew Umsetzen Python
Phase 3 — Kern des Deep Learning  13 Lektionen  Neuronale Netze von Grund auf. Kein Framework, bevor du selbst eines baust.
# Lektion Typ Sprachen
01 Das Perzeptron: Die Anfänge Umsetzen Python
02 Mehrschichtige Netze und Vorwärtsdurchlauf Umsetzen Python
03 Backpropagation von Grund auf Umsetzen Python
04 Aktivierungsfunktionen: ReLU, Sigmoid, GELU und warum Umsetzen Python
05 Loss-Funktionen: MSE, Kreuzentropie und kontrastiver Loss Umsetzen Python
06 Optimierer: SGD, Momentum, Adam, AdamW Umsetzen Python
07 Regularisierung: Dropout, Weight Decay, BatchNorm Umsetzen Python
08 Gewichtsinitialisierung und Trainingsstabilität Umsetzen Python
09 Lernratenpläne und Warm-up Umsetzen Python
10 Baue dein eigenes Mini-Framework Umsetzen Python
11 Einführung in PyTorch Umsetzen Python
12 Einführung in JAX Umsetzen Python
13 Neuronale Netze debuggen Umsetzen Python
Phase 4 — Computer Vision  28 Lektionen  Von Pixeln zum Verständnis: Bilder, Videos, 3D, VLMs und Weltmodelle.
# Lektion Typ Sprachen
01 Bildgrundlagen: Pixel, Kanäle und Farbräume Lernen Python
02 Faltungen von Grund auf Umsetzen Python
03 CNNs: von LeNet zu ResNet Umsetzen Python
04 Bildklassifikation Umsetzen Python
05 Transfer Learning und Fine-Tuning Umsetzen Python
06 Objekterkennung: YOLO von Grund auf Umsetzen Python
07 Semantische Segmentierung: U-Net Umsetzen Python
08 Instanzsegmentierung: Mask R-CNN Umsetzen Python
09 Bildgenerierung: GANs Umsetzen Python
10 Bildgenerierung: Diffusionsmodelle Umsetzen Python
11 Stable Diffusion: Architektur und Fine-Tuning Umsetzen Python
12 Videoverstehen: zeitliche Modellierung Umsetzen Python
13 3D-Vision: Punktwolken und NeRFs Umsetzen Python
14 Vision Transformer (ViT) Umsetzen Python
15 Echtzeit-Vision: Deployment am Edge Umsetzen Python
16 Eine vollständige Vision-Pipeline bauen Umsetzen Python
17 Selbstüberwachtes Lernen für Vision: SimCLR, DINO, MAE Umsetzen Python
18 Vision mit offenem Vokabular: CLIP Umsetzen Python
19 OCR und Dokumentenverständnis Umsetzen Python
20 Bildsuche und metrisches Lernen Umsetzen Python
21 Keypoint-Erkennung und Pose-Schätzung Umsetzen Python
22 3D Gaussian Splatting von Grund auf Umsetzen Python
23 Diffusion-Transformer und Rectified Flow Umsetzen Python
24 SAM 3 und Segmentierung mit offenem Vokabular Umsetzen Python
25 Vision-Language-Modelle (ViT-MLP-LLM) Umsetzen Python
26 Monokulare Tiefen- und Geometrieschätzung Umsetzen Python
27 Multi-Object-Tracking und Video-Memory Umsetzen Python
28 Weltmodelle und Video-Diffusion Umsetzen Python
Phase 5 — NLP: Grundlagen bis zum fortgeschrittenen Niveau  29 Lektionen  Sprache ist die Schnittstelle zur Intelligenz.
# Lektion Typ Sprachen
01 Textverarbeitung: Tokenisierung, Stemming und Lemmatisierung Umsetzen Python
02 Bag of Words, TF-IDF und Textrepräsentation Umsetzen Python
03 Word Embeddings: Word2Vec von Grund auf Umsetzen Python
04 GloVe, FastText und Subword-Embeddings Umsetzen Python
05 Sentimentanalyse Umsetzen Python
06 Erkennung benannter Entitäten (NER) Umsetzen Python
07 POS-Tagging und syntaktisches Parsing Umsetzen Python
08 Textklassifikation: CNNs und RNNs für Text Umsetzen Python
09 Sequenz-zu-Sequenz-Modelle Umsetzen Python
10 Attention-Mechanismus: der Durchbruch Umsetzen Python
11 Maschinelle Übersetzung Umsetzen Python
12 Textzusammenfassung Umsetzen Python
13 Frage-Antwort-Systeme Umsetzen Python
14 Information Retrieval und Suche Umsetzen Python
15 Themenmodellierung: LDA, BERTopic Umsetzen Python
16 Textgenerierung Umsetzen Python
17 Chatbots: regelbasiert bis neuronal Umsetzen Python
18 Mehrsprachiges NLP Umsetzen Python
19 Subword-Tokenisierung: BPE, WordPiece, Unigram, SentencePiece Lernen Python
20 Strukturierte Ausgaben und eingeschränktes Decoding Umsetzen Python
21 NLI und textuelle Implikation Lernen Python
22 Embedding-Modelle im Detail Lernen Python
23 Chunking-Strategien für RAG Umsetzen Python
24 Koreferenzauflösung Lernen Python
25 Entity Linking und Disambiguierung Umsetzen Python
26 Relationsextraktion und Aufbau von Wissensgraphen Umsetzen Python
27 LLM-Evaluierung: RAGAS, DeepEval, G-Eval Umsetzen Python
28 Langkontext-Evaluierung: NIAH, RULER, LongBench, MRCR Lernen Python
29 Dialogzustandsverfolgung Umsetzen Python
Phase 6 — Sprache und Audio  17 Lektionen  Hören, verstehen, sprechen.
# Lektion Typ Sprachen
01 Audio-Grundlagen: Wellenformen, Abtastung, FFT Lernen Python
02 Spektrogramme, Mel-Skala und Audio-Features Umsetzen Python
03 Audioklassifikation Umsetzen Python
04 Spracherkennung (ASR) Umsetzen Python
05 Whisper: Architektur und Fine-Tuning Umsetzen Python
06 Sprechererkennung und -verifikation Umsetzen Python
07 Text-to-Speech (TTS) Umsetzen Python
08 Stimmenklonen und Stimmkonvertierung Umsetzen Python
09 Musikgenerierung Umsetzen Python
10 Audio-Sprachmodelle Umsetzen Python
11 Echtzeit-Audioverarbeitung Umsetzen Python
12 Eine Sprachassistenten-Pipeline bauen Umsetzen Python
13 Neuronale Audio-Codecs: EnCodec, SNAC, Mimi, DAC Lernen Python
14 Spracherkennung und Sprecherwechsel Umsetzen Python
15 Sprach-zu-Sprache-Streaming: Moshi, Hibiki Lernen Python
16 Erkennung von Stimmenfälschungen und Audio-Wasserzeichen Umsetzen Python
17 Audio-Evaluierung: WER, MOS, MMAU, Leaderboards Lernen Python
Phase 7 — Transformer im Detail  16 Lektionen  Die Architektur, die alles verändert hat.
# Lektion Typ Sprachen
01 Warum Transformer? Die Probleme mit RNNs Lernen Python
02 Self-Attention von Grund auf Umsetzen Python
03 Multi-Head-Attention Umsetzen Python
04 Positionskodierung: Sinusoidal, RoPE, ALiBi Umsetzen Python
05 Der vollständige Transformer: Encoder und Decoder Umsetzen Python
06 BERT: Masked Language Modeling Umsetzen Python
07 GPT: Causal Language Modeling Umsetzen Python
08 T5, BART: Encoder-Decoder-Modelle Lernen Python
09 Vision Transformer (ViT) Umsetzen Python
10 Audio-Transformer: Whisper-Architektur Lernen Python
11 Mixture of Experts (MoE) Umsetzen Python
12 KV-Cache, Flash Attention und Inferenzoptimierung Umsetzen Python
13 Skalierungsgesetze Lernen Python
14 Einen Transformer von Grund auf bauen Umsetzen Python
15 Attention-Varianten: Sliding Window, Sparse, Differential Umsetzen Python
16 Speculative Decoding: Entwurf, Prüfung, Wiederholung Umsetzen Python
Phase 8 — Generative KI  15 Lektionen  Erzeuge Bilder, Videos, Audio, 3D und mehr.
# Lektion Typ Sprachen
01 Generative Modelle: Taxonomie und Geschichte Lernen Python
02 Autoencoder und VAE Umsetzen Python
03 GANs: Generator und Diskriminator Umsetzen Python
04 Conditional GANs und Pix2Pix Umsetzen Python
05 StyleGAN Umsetzen Python
06 Diffusionsmodelle: DDPM von Grund auf Umsetzen Python
07 Latente Diffusion und Stable Diffusion Umsetzen Python
08 ControlNet, LoRA und Conditioning Umsetzen Python
09 Inpainting, Outpainting und Bearbeitung Umsetzen Python
10 Videogenerierung Umsetzen Python
11 Audiogenerierung Umsetzen Python
12 3D-Generierung Umsetzen Python
13 Flow Matching und Rectified Flows Umsetzen Python
14 Evaluierung: FID, CLIP-Score Umsetzen Python
19 Visuelles autoregressives Modellieren (VAR): Vorhersage der nächsten Skala Umsetzen Python
Phase 9 — Reinforcement Learning  12 Lektionen  Die Grundlage für RLHF und spielende KI.
# Lektion Typ Sprachen
01 MDPs, Zustände, Aktionen und Belohnungen Lernen Python
02 Dynamische Programmierung Umsetzen Python
03 Monte-Carlo-Methoden Umsetzen Python
04 Q-Learning und SARSA Umsetzen Python
05 Deep Q-Networks (DQN) Umsetzen Python
06 Policy Gradients: REINFORCE Umsetzen Python
07 Actor-Critic: A2C, A3C Umsetzen Python
08 PPO Umsetzen Python
09 Reward-Modellierung und RLHF Umsetzen Python
10 Multi-Agent-RL Umsetzen Python
11 Sim-to-Real-Transfer Umsetzen Python
12 RL für Spiele Umsetzen Python
Phase 10 — LLMs von Grund auf  24 Lektionen  Baue, trainiere und verstehe große Sprachmodelle.
# Lektion Typ Sprachen
01 Tokenizer: BPE, WordPiece, SentencePiece Umsetzen Python, Rust
02 Einen Tokenizer von Grund auf bauen Umsetzen Python
03 Datenpipelines für das Pretraining Umsetzen Python
04 Ein Mini-GPT vortrainieren (124M) Umsetzen Python
05 Verteiltes Training, FSDP, DeepSpeed Umsetzen Python
06 Instruction Tuning: SFT Umsetzen Python
07 RLHF: Reward Model und PPO Umsetzen Python
08 DPO: Direct Preference Optimization Umsetzen Python
09 Constitutional AI und Selbstverbesserung Umsetzen Python
10 Evaluierung: Benchmarks und Evals Umsetzen Python
11 Quantisierung: INT8, GPTQ, AWQ, GGUF Umsetzen Python
12 Inferenzoptimierung Umsetzen Python
13 Eine vollständige LLM-Pipeline bauen Umsetzen Python
14 Offene Modelle: Architektur im Überblick Lernen Python
15 Speculative Decoding und EAGLE-3 Umsetzen Python
16 Differential Attention (V2) Umsetzen Python
17 Native Sparse Attention (DeepSeek NSA) Umsetzen Python
18 Multi-Token Prediction (MTP) Umsetzen Python
19 DualPipe-Parallelisierung Lernen Python
20 DeepSeek-V3: Architektur im Überblick Lernen Python
21 Jamba: hybrider SSM-Transformer Lernen Python
22 Asynchrone und Hogwild!-Inferenz Umsetzen Python
25 Speculative Decoding und EAGLE Umsetzen Python
34 Gradient Checkpointing und Activation Recomputation Umsetzen Python
Phase 11 — LLM-Engineering  17 Lektionen  Setze LLMs produktiv ein.
# Lektion Typ Sprachen
01 Prompt Engineering: Techniken und Muster Umsetzen Python
02 Few-Shot, CoT, Tree-of-Thought Umsetzen Python
03 Strukturierte Ausgaben Umsetzen Python
04 Embeddings und Vektorrepräsentationen Umsetzen Python
05 Context Engineering Umsetzen Python
06 RAG: Retrieval-Augmented Generation Umsetzen Python
07 Fortgeschrittenes RAG: Chunking und Reranking Umsetzen Python
08 Fine-Tuning mit LoRA und QLoRA Umsetzen Python
09 Function Calling und Tool-Nutzung Umsetzen Python
10 Evaluierung und Tests Umsetzen Python
11 Caching, Rate Limiting und Kosten Umsetzen Python
12 Guardrails und Sicherheit Umsetzen Python
13 Eine produktionsreife LLM-Anwendung bauen Umsetzen Python
14 Model Context Protocol (MCP) Umsetzen Python
15 Prompt- und Context-Caching Umsetzen Python
16 Agenten-Zustandsmaschinen: Graphen, Knoten, Checkpoints Umsetzen Python
17 Abwägungen bei Agent-Frameworks Lernen Python
Phase 12 — Multimodale KI  25 Lektionen  Sehen, hören, lesen und über Modalitäten hinweg schlussfolgern – von ViT-Patches bis zu Computer-Use-Agenten.
# Lektion Typ Sprachen
01 Vision Transformer und das Patch-Token-Primitiv Lernen Python
02 CLIP und kontrastives Vision-Language-Pretraining Umsetzen Python
03 BLIP-2 Q-Former als Brücke zwischen Modalitäten Umsetzen Python
04 Flamingo und gated cross-attention Lernen Python
05 LLaVA und visuelles Instruction Tuning Umsetzen Python
06 Vision in beliebiger Auflösung: Patch-n'-Pack und NaFlex Umsetzen Python
07 Rezepte für VLMs mit offenen Gewichten: Worauf es wirklich ankommt Lernen Python
08 LLaVA-OneVision: Einzelbild, mehrere Bilder, Video Umsetzen Python
09 Qwen-VL-Familie und Video mit dynamischer FPS Lernen Python
10 InternVL3: natives multimodales Pretraining Lernen Python
11 Chameleon: frühe Fusion mit ausschließlich Tokens Umsetzen Python
12 Emu3: Next-Token-Prediction für Generierung Lernen Python
13 Transfusion: autoregressiv und Diffusion Umsetzen Python
14 Show-o: vereinheitlichte diskrete Diffusion Lernen Python
15 Janus-Pro: entkoppelte Encoder Umsetzen Python
16 MIO: Any-to-Any-Streaming Lernen Python
17 Zeitliche Verankerung in Video und Sprache Umsetzen Python
18 Langvideos mit einem Kontext von einer Million Tokens Umsetzen Python
19 Audio-Language-Modelle: von Whisper bis AF3 Umsetzen Python
20 Omni-Modelle: Thinker-Talker-Streaming Umsetzen Python
21 Verkörperte VLA: RT-2, OpenVLA, π0, GR00T Lernen Python
22 Dokumente und Diagramme verstehen Umsetzen Python
23 ColPali: Vision-natives Document RAG Umsetzen Python
24 Multimodales RAG und modalitätenübergreifende Suche Umsetzen Python
25 Multimodale Agenten und Computer-Use (Abschlussprojekt) Umsetzen Python
Phase 13 — Werkzeuge und Protokolle  45 Lektionen  Die Schnittstellen zwischen KI und der realen Welt.
# Lektion Typ Sprachen
01 Die Tool-Schnittstelle Lernen Python
02 Function Calling im Detail Umsetzen Python
03 Parallele und gestreamte Tool-Aufrufe Umsetzen Python
04 Strukturierte Ausgabe Umsetzen Python
05 Tool-Schema-Design Lernen Python
06 MCP-Grundlagen: zustandslose Anfragen und JSON-RPC Lernen Python
07 Einen MCP-Server bauen: zustandslos mit Python und TypeScript Umsetzen Python, TypeScript
08 Einen MCP-Client bauen: Entdeckung, Routing und Fallback zwischen Protokollgenerationen Umsetzen Python
09 MCP-Transporte: stdio und zustandsloses Streamable HTTP Lernen Python
10 MCP-Ressourcen und Prompts: adressierbarer Kontext für zustandslose Server Umsetzen Python
11 MCP-Modelleingabe: Migration von Sampling und zustandsloses MRTR Umsetzen Python
12 Explizite Scopes und zustandslose Elicitation Umsetzen Python
13 MCP Tasks Extension: dauerhafte Arbeit auf zustandslosem Kern Umsetzen Python
14 MCP Apps auf dem zustandslosen Protokoll Umsetzen Python
15 MCP-Sicherheit: vergiftete Metadaten, Routing und MRTR-Zustand Lernen Python
16 MCP-Autorisierung: CIMD, Issuer Binding, PKCE und Step-Up Umsetzen Python
17 Zustandslose MCP-Gateways und Registry-Zulassung Lernen Python
18 MCP-Auth in Produktion: Issuer-gebundene Registrierung und Tokens Umsetzen Python
19 A2A-Protokoll Umsetzen Python
20 OpenTelemetry GenAI Umsetzen Python
21 LLM-Routing-Schicht Lernen Python
22 Agent Skills: portabler Vertrag und Laufzeitgrenze Umsetzen Python
23 Abschlussprojekt: zustandsloses Tool-Ökosystem Umsetzen Python
24 Skill Discovery und progressive Offenlegung Umsetzen Python
25 Skill-Aufruf und Routing Umsetzen Python
26 Skill-Berechtigungen, Sandboxes und Vertrauen Umsetzen Python
27 Skill-Evaluierungen, Packaging und Portierbarkeit Umsetzen Python
28 MCP-Tool-Verträge und Inhalte Umsetzen Python
29 MCP-Zuverlässigkeit, Abbruch und Flow Control Umsetzen Python
30 MCP-Registry-Lieferkette: Zulassung, Drift und Rollback Umsetzen Python
31 MCP-Konformitätsengineering: Versionierung, Nachweise und Betrieb Umsetzen Python
32 Programmanatomie: ELF von Grund auf lesen Umsetzen Python
33 Disassemblierung und Kontrollflussgraphen Umsetzen Python
34 Maschinencode zu Pseudocode anheben Umsetzen Python
35 Nachweise, Konfidenz und Unbekannte in der Binäranalyse Umsetzen Python
36 Neu bauen und Gleichheit beweisen Umsetzen Python
37 Die Landschaft des Reverse Engineering Umsetzen Python
38 Aufrufkonventionen und Stack-Frames Umsetzen Python
39 Compiler-Idiome und Optimierung Umsetzen Python
40 Linken, Laden und gestrippte Binärdateien Umsetzen Python
41 Daten und Typen rekonstruieren Umsetzen Python
42 Dynamische Analyse des eigenen Programms Umsetzen Python
43 Bytecode und verwaltete Formate Umsetzen Python
44 Binär-Diffing und symbolische Ausführung Umsetzen Python
45 KI-gestütztes Reverse Engineering Umsetzen Python

Die Lektionen 06–18 und 28–31 bilden den fokussierten MCP-Lernpfad. Das Manifest legt diese Reihenfolge fest: 06, 07, 08, 09, 10, 11, 12, 13, 14, 15, 16, 18, 17, 28, 29, 30, 31. Starte über den hostabhängigen Aufruf für learn-mcp. Lektion 23 ist das einzige optionale Abschlussprojekt und setzt zusätzlich die Lektionen 19 und 20 voraus.

Die Lektionen 22 und 24–27 bilden den fokussierten Lernpfad zu Agent Skills, vom Paketvertrag bis zu den Release-Prüfungen auf einem echten Host. Starte über den oben gezeigten hostabhängigen Aufruf für learn-agent-skills. Folge nicht der numerischen Weiterleitung von Lektion 22 zu Lektion 23.

Phase 14 — Agent-Engineering  54 Lektionen  Baue Agenten von Grund auf, nutze Coding-Agenten zuverlässig und gestalte die Arbeit vor der Implementierung.
# Lektion Typ Sprachen
01 Die Agent-Schleife Umsetzen Python
02 ReWOO und Planen-und-Ausführen Umsetzen Python
03 Reflexion und verbales bestärkendes Lernen Umsetzen Python
04 Tree of Thoughts und LATS Umsetzen Python
05 Self-Refine und CRITIC Umsetzen Python
06 Tool-Nutzung und Function Calling Umsetzen Python
07 Agentengedächtnis: virtueller Kontext und Memory Paging Umsetzen Python
08 Memory-Blöcke und Berechnung in Leerlaufzeiten Umsetzen Python
09 Hybrides Gedächtnis: Vektor + Graph + KV Umsetzen Python
10 Skill-Bibliotheken und lebenslanges Lernen (Voyager) Umsetzen Python
11 Planung mit HTN und evolutionärer Suche Umsetzen Python
12 Workflow-Muster von Anthropic Umsetzen Python
13 Zustandsbehaftete Graph-Orchestrierung: dauerhafte Ausführung und Checkpoints Umsetzen Python
14 Actor-Modell für Agenten Umsetzen Python
15 Rollenbasierte Agententeams: Rollen, Aufgaben, Prozesse Umsetzen Python
16 OpenAI Agents SDK: Übergaben, Guardrails, Tracing Umsetzen Python
17 Harness als Bibliothek: Subagenten und Session Store Umsetzen Python
18 Laufzeitumgebungen für Produktionsagenten Lernen Python
19 Benchmarks: SWE-bench, GAIA, AgentBench Lernen Python
20 Benchmarks: WebArena und OSWorld Lernen Python
21 Computer-Use: Claude, OpenAI CUA, Gemini Umsetzen Python
22 Sprachagenten: Pipecat und LiveKit Umsetzen Python
23 OpenTelemetry GenAI: semantische Konventionen Umsetzen Python
24 Agent-Observability: Langfuse, Phoenix, Opik Lernen Python
25 Multi-Agent-Debatte und Zusammenarbeit Umsetzen Python
26 Fehlermodi: Warum Agenten scheitern Umsetzen Python
27 Prompt Injection und die PVE-Abwehr Umsetzen Python
28 Orchestrierungsmuster: Supervisor, Swarm, hierarchisch Umsetzen Python
29 Laufzeitumgebungen für die Produktion: Queue, Event, Cron Lernen Python
30 Eval-getriebene Agentenentwicklung Umsetzen Python
31 Agent Workbench: Warum leistungsfähige Modelle trotzdem scheitern Lernen Python
32 Die minimale Agent Workbench Umsetzen Python
33 Agent-Anweisungen als ausführbare Einschränkungen Umsetzen Python
34 Repository-Gedächtnis und dauerhafter Zustand Umsetzen Python
35 Initialisierungsskripte für Agenten Umsetzen Python
36 Scope-Verträge und Aufgabengrenzen Umsetzen Python
37 Feedback-Schleifen zur Laufzeit Umsetzen Python
38 Verifizierungsschranken Umsetzen Python
39 Reviewer-Agent: Builder und Bewerter trennen Umsetzen Python
40 Übergabe zwischen mehreren Sitzungen Umsetzen Python
41 Die Workbench in einem echten Repository Umsetzen Python
42 Abschlussprojekt: ein wiederverwendbares Agent-Workbench-Paket veröffentlichen Umsetzen Python
43 Aufgabe klären, bevor der Agent Code schreibt Umsetzen Python
44 Einen ausführungsplan mit Nachweisen erstellen Umsetzen Python
45 Agentenarbeit mit Isolation und Merge-Verträgen delegieren Umsetzen Python
46 Jede Agent-Korrektur in eine Systemverbesserung umwandeln Umsetzen Python
47 Das Ergebnis definieren, bevor du die Ausgabe auswählst Umsetzen Python
48 Den tatsächlich gelebten Arbeitsablauf ermitteln Umsetzen Python
49 Annahmen erfassen und zuerst die riskanteste klären Umsetzen Python
50 Den kleinsten Ausschnitt wählen, der die Entscheidung ändern kann Umsetzen Python
51 Spezifikationen schreiben, die Urteilsvermögen bewahren Umsetzen Python
52 Erfolgsmetriken festlegen, bevor Ergebnisse vorliegen Umsetzen Python
53 Bewusst zwischen Prototyp, Pilot und Produktion wählen Umsetzen Python
54 Eine Feedback-Schleife mit klarer Zuständigkeit und Abschaltung einrichten Umsetzen Python

Jede Workbench-Lektion der Phase 14 (31–42) enthält eine mission.md, die den Agenten einweist, bevor er die vollständigen Lektionsunterlagen öffnet.

Die Lektionen 31–46 bilden den Pfad für agentengestütztes Engineering. Das Manifest verbindet die Grundlagen der Workbench mit Aufgabenklärung, Planung, Delegation und dauerhaftem Feedback. Die Lektionen 47–54 bilden den Pfad für Produktentscheidungen und Umsetzung: vom gewünschten Ergebnis über Nachweise, Risiken, Umfang und Messung bis zur schrittweisen Einführung und Zuständigkeit für Feedback.

Phase 15 — Autonome Systeme  22 Lektionen  Agenten für lange Aufgaben, Selbstverbesserung und der Safety-Stack von 2026.
# Lektion Typ Sprachen
01 Von Chatbots zu Agenten mit langem Planungshorizont (METR) Lernen Python
02 STaR, V-STaR, Quiet-STaR: selbstüberwachtes Schlussfolgern Lernen Python
03 AlphaEvolve: evolutionäre Coding-Agenten Lernen Python
04 Darwin-Gödel-Maschine: selbstmodifizierende Agenten Lernen Python
05 AI Scientist v2: Forschung auf Workshop-Niveau Lernen Python
06 Automatisierte Alignment-Forschung (Anthropic AAR) Lernen Python
07 Rekursive Selbstverbesserung: Fähigkeiten vs. Alignment Lernen Python
08 Begrenzte Selbstverbesserungsarchitekturen Lernen Python
09 Landschaft autonomer Coding-Agenten (SWE-bench, CodeAct) Lernen Python
10 Berechtigungsmodi für autonome Agenten Lernen Python
11 Browser-Agenten und indirekte Prompt Injection Lernen Python
12 Dauerhafte Ausführung für lang laufende Agenten Lernen Python
13 Aktionsbudgets, Iterationsgrenzen und Kostensteuerung Lernen Python
14 Notausschalter, Circuit Breaker und Canary Tokens Lernen Python
15 HITL: erst vorschlagen, dann bestätigen Lernen Python
16 Checkpoints und Rollback Lernen Python
17 Constitutional AI und Regelüberschreibungen Lernen Python
18 Llama Guard und Klassifikation von Ein- und Ausgaben Lernen Python
19 Anthropics Responsible Scaling Policy v3.0 Lernen Python
20 OpenAI Preparedness Framework und DeepMind FSF Lernen Python
21 METR-Zeithorizonte und externe Evaluierung Lernen Python
22 CAIS, CAISI und Risiken auf gesellschaftlicher Ebene Lernen Python
Phase 16 — Multi-Agenten-Systeme und Schwärme  25 Lektionen  Koordination, Emergenz und kollektive Intelligenz.
# Lektion Typ Sprachen
01 Warum Multi-Agent-Systeme? Lernen TypeScript
02 FIPA-ACL: Ursprünge und Sprechakte Lernen Python
03 Kommunikationsprotokolle Umsetzen TypeScript
04 Das Grundmodell von Multi-Agent-Systemen Lernen Python
05 Supervisor-/Orchestrator-Worker-Muster Umsetzen Python
06 Hierarchische Architektur und Drift bei der Zerlegung Lernen Python
07 Society of Mind und Multi-Agent-Debatten Umsetzen Python
08 Rollenspezialisierung: Planer, Kritiker, Ausführer, Prüfer Umsetzen Python
09 Parallele Schwärme und vernetzte Architekturen Umsetzen Python
10 Gruppenchats und Auswahl des Sprechers Umsetzen Python
11 Übergaben und Routinen (zustandslose Orchestrierung) Umsetzen Python
12 A2A: das Agent-to-Agent-Protokoll Umsetzen Python
13 Gemeinsamer Speicher und Blackboard-Muster Umsetzen Python
14 Konsens und byzantinische Fehlertoleranz Umsetzen Python
15 Abstimmung, Selbstkonsistenz und Debattentopologie Umsetzen Python
16 Verhandlung und Aushandlung Umsetzen Python
17 Generative Agenten und emergente Simulation Umsetzen Python
18 Theory of Mind und emergente Koordination Umsetzen Python
19 Schwarmoptimierung (PSO, ACO) Umsetzen Python
20 MARL: MADDPG, QMIX, MAPPO Lernen Python
21 Agentenökonomien, Token-Anreize und Reputation Lernen Python
22 Skalierung in der Produktion: Queues, Checkpoints, Dauerhaftigkeit Umsetzen Python
23 Fehlermodi: MAST, Gruppendenken und Monokultur Lernen Python
24 Evaluierung und Koordinations-Benchmarks Lernen Python
25 Fallstudien und Stand der Technik 2026 Lernen Python
Phase 17 — Infrastruktur und Produktion  29 Lektionen  Bringe KI in die echte Welt.
# Lektion Typ Sprachen
01 Verwaltete LLM-Plattformen: Bedrock, Azure OpenAI, Vertex AI Lernen Python
02 Ökonomie von Inferenzplattformen: Fireworks, Together, Baseten, Modal Lernen Python
03 GPU-Autoskalierung auf Kubernetes: Karpenter, KAI Scheduler Lernen Python
04 Interna von Serving-Engines: PagedAttention, Continuous Batching, Chunked Prefill Lernen Python
05 EAGLE-3-Speculative-Decoding in der Produktion Lernen Python
06 Serving mit Prefix-Cache: RadixAttention und KV-Wiederverwendung Lernen Python
07 Hardware-spezialisierte Inferenzkompilierung: FP8 und NVFP4 auf Blackwell Lernen Python
08 Inferenzmetriken: TTFT, TPOT, ITL, Goodput, P99 Lernen Python
09 Quantisierung in der Produktion: AWQ, GPTQ, GGUF, FP8, NVFP4 Lernen Python
10 Kaltstart für serverlose LLMs abmildern Lernen Python
11 Multi-Region-LLM-Serving und KV-Cache-Lokalität Lernen Python
12 Edge-Inferenz: ANE, Hexagon, WebGPU, Jetson Lernen Python
13 LLM-Observability-Stack auswählen Lernen Python
14 Ökonomie von Prompt-Caching und semantischem Caching Lernen Python
15 Batch-APIs: 50 % Rabatt als Industriestandard Lernen Python
16 Model-Routing als Hebel zur Kostensenkung Lernen Python
17 Disaggregiertes Prefill/Decode: NVIDIA Dynamo und llm-d Lernen Python
18 Serving-Stack für die Produktion: KV-Offloading und Cache-bewusstes Routing Lernen Python
19 AI-Gateways: LiteLLM, Portkey, Kong, Bifrost Lernen Python
20 Shadow-, Canary- und schrittweise Deployments Lernen Python
21 A/B-Tests für LLM-Funktionen: GrowthBook und Statsig Lernen Python
22 Lasttests für LLM-APIs: k6, LLMPerf, GenAI-Perf Umsetzen Python
23 SRE für KI: Multi-Agent-Incident-Response Lernen Python
24 Chaos Engineering für LLM-Produktionssysteme Lernen Python
25 Sicherheit: Secrets, PII-Bereinigung, Audit-Logs Lernen Python
26 Compliance: SOC 2, HIPAA, GDPR, EU AI Act, ISO 42001 Lernen Python
27 FinOps für LLMs: Stückkosten und mandantenübergreifende Zuordnung Lernen Python
28 Self-Hosted-Serving auswählen: Engine, Hardware und Skalierung aufeinander abstimmen Lernen Python
29 Demo-Oberflächen für Modelle: von der Funktion zur teilbaren App Umsetzen Python
Phase 18 — Ethik, Sicherheit und Alignment  30 Lektionen  Baue KI, die der Menschheit nützt. Das ist keine Option.
# Lektion Typ Sprachen
01 Anweisungen befolgen als Alignment-Signal Lernen Python
02 Reward Hacking und Goodharts Gesetz Lernen Python
03 Familie der Direct-Preference-Optimization-Verfahren Lernen Python
04 Schmeichelei als Verstärkung durch RLHF Lernen Python
05 Constitutional AI und RLAIF Lernen Python
06 Mesa-Optimierung und täuschendes Alignment Lernen Python
07 Schlafende Agenten: dauerhafte Täuschung Lernen Python
08 Verdeckte Planung in Frontier-Modellen im In-Context Lernen Python
09 Vortäuschung von Alignment Lernen Python
10 KI-Steuerung: Sicherheit trotz Umgehungsversuchen Lernen Python
11 Skalierbare Überwachung: von schwachen zu starken Modellen Lernen Python
12 Red Teaming: PAIR und automatisierte Angriffe Umsetzen Python
13 Many-Shot-Jailbreaks Lernen Python
14 ASCII-Art und visuelle Jailbreaks Umsetzen Python
15 Indirekte Prompt Injection Umsetzen Python
16 Red-Team-Werkzeuge: Garak, Llama Guard, PyRIT Umsetzen Python
17 WMDP und Evaluierung von Dual-Use-Fähigkeiten Lernen Python
18 Safety-Frameworks für Frontier-Modelle: RSP, PF, FSF Lernen Python
19 Forschung zum Wohlergehen von Modellen Lernen Python
20 Bias und Schaden durch verzerrte Repräsentation Umsetzen Python
21 Fairness-Kriterien: Gruppen-, Individual- und kontrafaktische Fairness Lernen Python
22 Differential Privacy für LLMs Umsetzen Python
23 Wasserzeichen: SynthID, Stable Signature, C2PA Umsetzen Python
24 Regulierungsrahmen: EU, USA, Großbritannien, Korea Lernen Python
25 EchoLeak und CVEs für KI Lernen Python
26 Model-, System- und Dataset-Cards Umsetzen Python
27 Datenherkunft und Governance von Trainingsdaten Lernen Python
28 Ökosystem der Alignment-Forschung: MATS, Redwood, Apollo, METR Lernen Python
29 Moderationssysteme: OpenAI, Perspective, Llama Guard Umsetzen Python
30 Dual-Use-Risiken: Cyber, Bio, Chemie, Nuklear Lernen Python
Phase 19 — Abschlussprojekte  85 Lektionen  17 durchgängige Produkte plus 9 Tracks, in denen ein vollständiges System von Grund auf entsteht. 20–40 Stunden pro Projekt; 4–12 Lektionen pro Track.
# Projekt Kombiniert Sprachen
01 Terminal-nativer Coding-Agent P0 P5 P7 P10 P11 P13 P14 P15 P17 P18 Python
02 RAG über eine Codebasis (semantische Suche über mehrere Repositories hinweg) P5 P7 P11 P13 P17 Python
03 Sprachassistent in Echtzeit (ASR → LLM → TTS) P6 P7 P11 P13 P14 P17 Python
04 Multimodale Dokumentenfragen (Vision zuerst) P4 P5 P7 P11 P12 P17 Python
05 Autonomer Forschungsagent (Klasse AI Scientist) P0 P2 P3 P7 P10 P14 P15 P16 P18 Python
06 DevOps-Agent zur Fehlerbehebung in Kubernetes P11 P13 P14 P15 P17 P18 Python
07 End-to-End-Fine-Tuning-Pipeline P2 P3 P7 P10 P11 P17 P18 Python
08 Produktionsreifer RAG-Chatbot (regulierte Branche) P5 P7 P11 P12 P17 P18 Python
09 Code-Migrationsagent (Upgrade auf Repository-Ebene) P5 P7 P11 P13 P14 P15 P17 Python
10 Multi-Agent-Team für Softwareentwicklung P11 P13 P14 P15 P16 P17 Python
11 LLM-Observability- und Evaluierungs-Dashboard P11 P13 P17 P18 Python
12 Pipeline zum Videoverständnis (Szene → Fragen und Antworten) P4 P6 P7 P11 P12 P17 Python
13 Zustandsloser MCP-Server mit Registry und Governance P11 P13 P14 P17 P18 Python
14 Inferenzserver für Speculative Decoding P3 P7 P10 P17 Python
15 Constitutional-Safety-Harness und Red-Team-Umgebung P10 P11 P13 P14 P18 Python
16 Autonomer GitHub-Agent von Issue bis PR P11 P13 P14 P15 P17 Python
17 Persönlicher KI-Tutor (adaptiv, multimodal) P5 P6 P11 P12 P14 P17 P18 Python

Tracks für Eigenentwicklungen — mehrteilige Reihen, in denen du ein vollständiges Teilsystem von Grund auf baust.

# Projekt Kombiniert Sprachen
20 Agent-Harness-Loop-Vertrag A. Agent-Harness Python
21 Tool-Registry mit Schema-Validierung A. Agent-Harness Python
22 JSON-RPC 2.0 über zeilengetrenntes stdio A. Agent-Harness Python
23 Dispatcher für Funktionsaufrufe A. Agent-Harness Python
24 Kontrollfluss für Planen und Ausführen A. Agent-Harness Python
25 Verifizierungsschranken und Beobachtungsbudget A. Agent-Harness Python
26 Sandbox-Runner mit Denylist und Pfad-Isolation A. Agent-Harness Python
27 Eval-Harness mit Fixture-Aufgaben A. Agent-Harness Python
28 Observability mit OTel-GenAI-Spans und Prometheus-Metriken A. Agent-Harness Python
29 End-to-End-Coding-Agent auf Basis des Harness A. Agent-Harness Python
30 BPE-Tokenizer von Grund auf B. NLP und LLM Python
31 Tokenisiertes Dataset mit Sliding Window B. NLP und LLM Python
32 Token- und Positions-Embeddings B. NLP und LLM Python
33 Multi-Head-Self-Attention B. NLP und LLM Python
34 Transformer-Block von Grund auf B. NLP und LLM Python
35 GPT-Modell zusammensetzen B. NLP und LLM Python
36 Trainingsschleife und Evaluierung B. NLP und LLM Python
37 Vortrainierte Gewichte laden B. NLP und LLM Python
38 Klassifikator durch Austausch des Heads feinabstimmen B. NLP und LLM Python
39 Instruction Tuning durch Supervised Fine-Tuning B. NLP und LLM Python
40 Direct Preference Optimization von Grund auf B. NLP und LLM Python
41 Vollständige Evaluierungspipeline B. NLP und LLM Python
42 Downloader für große Korpora C. End-to-End-Training Python
43 Tokenisiertes HDF5-Korpus C. End-to-End-Training Python
44 Cosine-Lernrate mit linearem Warm-up C. End-to-End-Training Python
45 Gradient Clipping und gemischte Präzision C. End-to-End-Training Python
46 Gradientenakkumulation C. End-to-End-Training Python
47 Checkpoint speichern und fortsetzen C. End-to-End-Training Python
48 Distributed Data Parallel und FSDP von Grund auf C. End-to-End-Training Python
49 Evaluierungsharness für Sprachmodelle C. End-to-End-Training Python
50 Hypothesengenerator D. Automatisierte Forschung Python
51 Literaturabruf D. Automatisierte Forschung Python
52 Experiment-Runner D. Automatisierte Forschung Python
53 Ergebnisevaluator D. Automatisierte Forschung Python
54 Paper verfassen D. Automatisierte Forschung Python
55 Kritiker-Schleife D. Automatisierte Forschung Python
56 Iterationsplaner D. Automatisierte Forschung Python
57 End-to-End-Forschungsdemo D. Automatisierte Forschung Python
58 Patches des Vision Encoders E. Multimodale VLMs Python
59 Vision Transformer Encoder E. Multimodale VLMs Python
60 Projektionsebene zur Ausrichtung der Modalitäten E. Multimodale VLMs Python
61 Fusion per Cross-Attention E. Multimodale VLMs Python
62 Vision-Language-Pretraining E. Multimodale VLMs Python
63 Multimodale Evaluierung E. Multimodale VLMs Python
64 Chunking-Strategien im Vergleich F. Fortgeschrittenes RAG Python
65 Hybrider Abruf mit BM25 und dichten Embeddings F. Fortgeschrittenes RAG Python
66 Cross-Encoder-Reranker F. Fortgeschrittenes RAG Python
67 Query Rewriting: HyDE, Multi-Query und Zerlegung F. Fortgeschrittenes RAG Python
68 RAG-Evaluierung: Precision, Recall, MRR, nDCG, Faithfulness, Answer Relevance F. Fortgeschrittenes RAG Python
69 End-to-End-RAG-System F. Fortgeschrittenes RAG Python
70 Format für Aufgabenspezifikationen G. Evaluierungs-Framework Python
71 Klassische Metriken G. Evaluierungs-Framework Python
72 Metrik für Code-Ausführung G. Evaluierungs-Framework Python
73 Perplexity und Kalibrierung G. Evaluierungs-Framework Python
74 Aggregation eines Leaderboards G. Evaluierungs-Framework Python
75 End-to-End-Eval-Runner G. Evaluierungs-Framework Python
76 Collective Ops von Grund auf H. Verteiltes Training Python
77 Datenparalleles DDP von Grund auf H. Verteiltes Training Python
78 ZeRO: Sharding des Optimizer-Zustands H. Verteiltes Training Python
79 Pipeline-Parallelität und Analyse der Bubble H. Verteiltes Training Python
80 Geshardeter Checkpoint und atomare Wiederaufnahme H. Verteiltes Training Python
81 Verteiltes Training von Anfang bis Ende H. Verteiltes Training Python
82 Jailbreak-Taxonomie I. Sicherheits-Harness Python
83 Prompt-Injection-Detektor I. Sicherheits-Harness Python
84 Evaluierung von Ablehnungen I. Sicherheits-Harness Python
85 Content-Classifier integrieren I. Sicherheits-Harness Python
86 Engine für Constitutional Rules I. Sicherheits-Harness Python, YAML
87 End-to-End-Sicherheitsschranke I. Sicherheits-Harness Python

Bücher und Zertifizierungen

Den Kernlehrplan als Buch lesen

Der 20-phasige Kernlehrplan unter phases/ wird zu einer sechsbändigen Buchreihe. CI erstellt EPUB- und PDF-Dateien aus denselben Lektionen und hängt sie an jedes GitHub-Release an; die Links unten führen immer zum neuesten Release. Die Bandnummern bezeichnen die Reihenfolge in der Reihe, keine Versionen: Jedes Exemplar trägt ein datiertes Auflagendatum, und ältere Ausgaben bleiben über ihr jeweiliges Release verfügbar.

Die Zertifizierungslehrpläne werden bewusst nicht in die Bücher übernommen. Ihr KI-Tutor-Fortschritt, die ausführbaren Labs, interaktiven Abbildungen, Diagnosetests und zeitlich begrenzten Übungsprüfungen bleiben auf GitHub und der Website verfügbar.

Vol. Titel Phasen Herunterladen
1 Grundlagen · Mathematik, Werkzeuge und klassisches maschinelles Lernen 00-02 EPUB · PDF
2 Deep Learning · Netze, Computer Vision und Sprache 03, 04, 06 EPUB · PDF
3 Sprache · NLP-Grundlagen und Transformer 05, 07 EPUB · PDF
4 Große Sprachmodelle · Generierung, Reinforcement Learning, Pretraining und Engineering 08-11 EPUB · PDF
5 Agenten · Multimodalität, Protokolle, Autonomie und Schwärme 12-16 EPUB · PDF
6 Produktion · Infrastruktur, Sicherheit und Abschlussprojekte 17-19 EPUB · PDF

Das Buch ist eine Momentaufnahme; dieses Repository ist die fortlaufend aktualisierte Ausgabe. Jedes Kapitel verweist zurück auf die animierten Abbildungen, das Quiz und den ausführbaren Code der Lektion. Erstelle das Buch lokal mit python3 scripts/build_book.py (Pandoc erforderlich); Einzelheiten zur Pipeline stehen in book/README.md.

Vorbereitung auf Claude-Zertifizierungen

Die Claude Certification Academy ist ein kostenloses Vorbereitungsprogramm mit offenem Quellcode für alle vier offiziellen Claude-Zertifizierungspfade: Associate Foundations, Developer Foundations, Architect Foundations und Architect Professional. Jeder Pfad kombiniert an den Prüfungsplan angelehnte Lektionen, ausführbare Labs, einen Diagnosetest, ein Abschlussprojekt und eine vollständige eigens erstellte Übungsprüfung.

Verwende den GitHub-Einstiegsleitfaden für KI-native Nutzung mit Claude Code, Codex, ChatGPT, Cursor oder einem anderen Agenten. Führe in Codex claude-certification oder in Claude Code /claude-certification aus; bei einem anderen Host bittest du ihn, claude-certification zu verwenden. Der Tutor wählt einen Pfad, speichert den fortlaufenden Lernpfad in CLAUDE-CERTIFICATION.md, unterrichtet Schritt für Schritt, führt die echten Labs aus und gibt Feedback zu deinen Artefakten. Der Lehrplan ist auch auf der Zertifizierungswebsite verfügbar.

Die Akademie ist ein unabhängiges Lernangebot auf Grundlage öffentlich zugänglicher Prüfungsziele. Sie ist nicht mit Anthropic verbunden, gibt keine echten Prüfungsfragen wieder und garantiert kein Bestehen.

Vorbereitung auf die MCP-Associate-Zertifizierung (MCPA)

Der MCPA-Zertifizierungslehrplan ist ein kostenloses Vorbereitungsprogramm mit offenem Quellcode für die Prüfung zum Model Context Protocol Associate der Agentic AI Foundation, die über Linux Foundation Training angeboten wird. Die 34 Lektionen behandeln die zustandslose Protokollversion vom 2026-07-28 und die fünf Prüfungsbereiche: _meta pro Anfrage und server/discover anstelle des früheren Handshakes, Anfragen mit mehreren Roundtrips, Subscriptions, Caching, die Erweiterungen Tasks und MCP Apps, OAuth-Autorisierung sowie Registry- und SDK-Stufen. Zu jeder Lektion gehört ein ausführbares Lab mit Standardbibliotheken; sein Protokoll wird gegen das aktuelle Wire-Format geprüft. Der Pfad umfasst außerdem einen Diagnosetest, ein Abschlussprojekt und drei vollständige, eigens erstellte Übungsprüfungen, deren Fragenverteilung den veröffentlichten Gewichten des Prüfungsplans folgt.

Verwende den GitHub-Einstiegsleitfaden für KI-native Nutzung mit Claude Code, Codex, ChatGPT, Cursor oder einem anderen Agenten. Führe in Codex mcpa-certification oder in Claude Code /mcpa-certification aus; bei einem anderen Host bittest du ihn, mcpa-certification zu verwenden. Der Tutor speichert den fortlaufenden Lernpfad in MCPA-CERTIFICATION.md, unterrichtet Schritt für Schritt, führt die Labs aus und gibt Feedback zu deinen Artefakten. Der Lehrplan ist auch auf der MCPA-Lernpfadseite verfügbar.

Dieser Lehrplan ist ein unabhängiges Lernangebot auf Grundlage öffentlicher Prüfungsziele. Er ist weder mit der Agentic AI Foundation noch mit der Linux Foundation verbunden, gibt keine echten Prüfungsfragen wieder und garantiert kein Bestehen.

Werkzeugkasten

Jede Lektion erzeugt ein wiederverwendbares Ergebnis. Installiere es in deinem Agenten oder führe die folgenden Skripte vom Repository-Stamm aus aus.

Lektionsaufbau und wiederverwendbare Ergebnisse

Aufbau einer Lektion

Jede Lektion hat einen eigenen Ordner mit derselben Struktur wie im übrigen Lehrplan:

phases/<NN>-<phase-name>/<NN>-<lesson-name>/
├── code/      ausführbare Implementierungen (Python, TypeScript, Rust, Julia)
├── docs/
│   └── en.md  Lektionstext
└── outputs/   Prompts, Skills, Agenten oder MCP-Server, die diese Lektion erstellt

Jede Lektion folgt sechs Schritten. Das Prinzip Build It / Use It bildet das Rückgrat: Zuerst implementierst du den Algorithmus von Grund auf, dann führst du denselben Vorgang mit einer Produktionsbibliothek aus. Weil du selbst eine kleinere Version geschrieben hast, verstehst du, was das Framework tut.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#fafaf5','primaryTextColor':'#1a1a1a','primaryBorderColor':'#3553ff','lineColor':'#3553ff','fontFamily':'JetBrains Mono','fontSize':'13px'}}}%%
flowchart LR
  M["LEITGEDANKE<br/><sub>die Kernidee in einem Satz</sub>"] --> Pr["PROBLEMSTELLUNG<br/><sub>eine konkrete Schwierigkeit</sub>"]
  Pr --> C["KONZEPT<br/><sub>Diagramme und Intuition</sub>"]
  C --> B["SELBST BAUEN<br/><sub>reine Mathematik, keine Frameworks</sub>"]
  B --> U["ANWENDEN<br/><sub>dasselbe in PyTorch / sklearn</sub>"]
  U --> S["VERÖFFENTLICHEN<br/><sub>Anweisung · Fähigkeit · Agent · MCP</sub>"]

Jede Lektion liefert etwas

Andere Lehrpläne enden mit „Glückwunsch, du hast X gelernt.“ Jede Lektion hier endet mit einem wiederverwendbaren Werkzeug, das du installieren oder in deinen täglichen Arbeitsablauf übernehmen kannst.

FIG_001.A Anweisungen
FIG_001 · A
ANWEISUNGEN
FIG_001.B Fähigkeiten
FIG_001 · B
FÄHIGKEITEN
FIG_001.C Agenten
FIG_001 · C
AGENTEN
FIG_001.D MCP-Server
FIG_001 · D
MCP-SERVER
Füge ihn in einen beliebigen KI-Assistenten ein, um bei einer eng umrissenen Aufgabe fachkundige Hilfe zu erhalten. Binde ihn in Claude, Cursor, Codex, OpenClaw, Hermes oder einen anderen Agenten ein, der SKILL.md liest. Setze sie als autonome Worker ein – die Schleife hast du in Phase 14 selbst geschrieben. Binde sie in jeden MCP-kompatiblen Client ein. Der vollständige Ablauf wurde in Phase 13 umgesetzt.
Lektionsergebnisse installieren

Die Lektionsartefakte. Das Repository enthält 414 Skills und 100 Prompts unter phases/**/outputs/. Installiere sie mit scripts/install_skills.py. Dafür musst du das Repository klonen. Das Skript unterstützt Tag-Filter, Probeläufe und agentenspezifische Layouts:

python3 scripts/install_skills.py <target>                                 # every skill, default --layout skills (nested)
python3 scripts/install_skills.py <target> --layout skills                 # same as above, explicit
python3 scripts/install_skills.py <target> --type all                      # skills + prompts + agents
python3 scripts/install_skills.py <target> --phase 14                      # one phase only
python3 scripts/install_skills.py <target> --tag rag                       # filter by tag
python3 scripts/install_skills.py <target> --layout flat                   # flat files
python3 scripts/install_skills.py <target> --dry-run                       # preview without writing
python3 scripts/install_skills.py <target> --force                         # overwrite existing files

<target> ist das Skill-Verzeichnis deines Agenten (zum Beispiel ~/.claude/skills/, ~/.cursor/skills/, ~/.config/openclaw/skills/, .skills/ oder ein anderer Ordner, den dein Agent liest).

Standardmäßig überschreibt das Skript kein vorhandenes Ziel. Es listet alle kollidierenden Pfade auf und beendet sich mit Exit-Code 1. Nutze --dry-run, um Kollisionen vorab anzuzeigen, oder --force, um vorhandene Dateien zu überschreiben. Jeder echte Lauf schreibt eine manifest.json mit dem vollständigen Bestand nach Typ und Phase in das Zielverzeichnis. Wähle das Layout, das dein Agent liest:

--layout Layout und Speicherpfad
skills <target>/<name>/SKILL.md (verschachtelte Ordnerstruktur; unterstützt von Claude, Cursor, Codex, OpenClaw und Hermes)
by-phase <target>/phase-NN/<name>.md
flat <target>/<name>.md
Übertrage die Agent Workbench in dein eigenes Repository

Das Abschlussprojekt in Phase 14 liefert ein wiederverwendbares Agent-Workbench-Paket mit AGENTS.md, Schemas sowie Init-, Verify- und Handoff-Skripten. Übertrage es mit den Befehlen unten in ein Repository:

python3 scripts/scaffold_workbench.py path/to/your-repo            # full pack + seeds
python3 scripts/scaffold_workbench.py path/to/your-repo --minimal  # skip docs/
python3 scripts/scaffold_workbench.py path/to/your-repo --dry-run  # preview only
python3 scripts/scaffold_workbench.py path/to/your-repo --force    # overwrite

Das Paket richtet sieben Workbench-Bereiche ein, erstellt eine Startdatei task_board.json und eine neue agent_state.json mit schema_version: 1. Bearbeite anschließend die Aufgabe und AGENTS.md, führe scripts/init_agent.py aus und übergib deinem Agenten den Vertrag. Der Paketquellcode liegt unter phases/14-agent-engineering/42-agent-workbench-capstone/outputs/agent-workbench-pack/.

Den gesamten Kurs als JSON durchsuchen

scripts/build_catalog.py durchsucht alle Phasen, Lektionen und Artefakte auf der Festplatte und schreibt catalog.json in das Repository-Stammverzeichnis. Eine Datei enthält alle Kursdaten.

python3 scripts/build_catalog.py               # writes <repo>/catalog.json
python3 scripts/build_catalog.py --stdout      # to stdout, do not touch repo
python3 scripts/build_catalog.py --out path/to/file.json

Der Katalog wird aus dem Dateisystem erzeugt, nicht aus der README. Daher stimmen die Zählungen mit dem tatsächlichen Bestand überein. Nutze ihn für den Website-Build, nachgelagerte Werkzeuge oder um zu prüfen, ob die Zählungen in der README noch aktuell sind. Das Schema ist am Anfang des Skripts dokumentiert.

Der Curriculum-Workflow erstellt catalog.json als temporäres, von Git ignoriertes Artefakt. Committe es nicht. Derselbe Workflow führt audit_lessons.py als blockierende Prüfung aus.

Python-Code jeder Lektion kurz prüfen

scripts/lesson_run.py kompiliert alle Python-Dateien im code/-Ordner jeder Lektion byteweise. Im Standardmodus wird nur die Syntax geprüft: Es wird nichts ausgeführt, es werden keine API-Schlüssel benötigt und es sind keine umfangreichen ML-Abhängigkeiten erforderlich. Das Skript findet häufige Fehler wie falsche Einrückungen, kaputte f-Strings und versehentliche Änderungen.

python3 scripts/lesson_run.py                  # syntax-check the whole curriculum
python3 scripts/lesson_run.py --phase 14       # one phase only
python3 scripts/lesson_run.py --json           # JSON report on stdout
python3 scripts/lesson_run.py --strict         # exit 1 if any lesson fails
python3 scripts/lesson_run.py --execute        # actually run, 10s timeout per lesson

--execute führt code/main.py jeder Lektion aus (oder, falls die Datei fehlt, die erste .py-Datei) und bricht nach 10 Sekunden ab. Lektionen, deren Einstiegsdatei mit einem # requires: pkg1, pkg2-Kommentar auf externe Pakete hinweist, werden mit needs übersprungen. Das Skript ist optional und nicht in CI eingebunden.

Das Skript benötigt nur die Standardbibliothek und Python 3.10 oder höher. Setze LINK_CHECK_SKIP=domain1,domain2, um die Standardliste zu überschreiben (twitter.com, x.com, linkedin.com, instagram.com, medium.com – Domains, die automatisierte HEAD-/GET-Anfragen häufig blockieren).

Grundlegende Fachartikel und Protokolle
  • Attention Is All You Need — Vaswani et al., 2017 → Phase 7
  • Language Models are Few-Shot Learners (GPT-3) → Phase 10
  • Denoising Diffusion Probabilistic Models → Phase 8
  • InstructGPT / RLHF → Phase 10
  • Direct Preference Optimization → Phase 10
  • Chain-of-Thought Prompting → Phase 11
  • ReAct: Reasoning + Acting in LLMs → Phase 14
  • Model Context Protocol — Anthropic → Phase 13

Mitwirken

Ziel Lesen Sie
Eine Lektion oder eine Lösung CONTRIBUTING.md
Fork für Ihr Team oder Ihre Schule FORKING.md
Lehrvorlage LESSON_TEMPLATE.md
Verfolgung der Fortschritte ROADMAP.md
Glossar Glossar/terms.md
Verhaltenskodex CODE_OF_CONDUCT.md

Führe vor dem Einreichen einer Lektion die Invariantenprüfung aus:

python3 scripts/audit_lessons.py           # full curriculum
python3 scripts/audit_lessons.py --phase 14  # single phase
python3 scripts/audit_lessons.py --json    # CI-friendly output

Der Exit-Code ist ungleich null, wenn eine Regel fehlschlägt. Die Regeln L001–L010 prüfen die Verzeichnisstruktur, das Vorhandensein von docs/en.md samt H1, nicht leere code/-Ordner, das Schema von quiz.json (und weisen die veralteten Schlüssel q/choices/answer zurück, die Issue #102 verursacht haben) sowie relative Links in den Lektionsunterlagen.

Die Arbeit unterstützen

114,584 Leser  ·  181,995 Seitenaufrufe in den letzten 30 Tagen  ·  Stand: 2026-08-29

Kostenlos, MIT-lizenziert, 542 Lektionen. Vielen Dank an die Sponsoren und Unterstützer, die diese Arbeit ermöglichen. Alle Sponsoren und Unterstützer ansehen.

Möchtest du die Arbeit unterstützen? Sieh dir die Sponsoring-Optionen einschließlich Hardware-Sponsoring an oder unterstütze das Projekt auf GitHub.

Wenn dir dieses Handbuch geholfen hat, gib dem Repository einen Stern. Das hält das Projekt am Leben.

Lizenz

MIT. Nutze es, wie du möchtest: forke es, unterrichte damit, verkaufe es oder veröffentliche es. Namensnennung ist willkommen, aber nicht erforderlich.

Betreut von Rohit Ghumare und der Community.

@ghumare64  ·  aiengineeringfromscratch.com  ·  Bericht / Vorschlag

Ähnliche Projekte entdecken