---
title: "Neu im Kurs"
sidebar:
  label: "Neu im Kurs"
---

<span id="neu-im-kurs" />


[Kursstart](/de/)

Datierte Änderungen, die Lernende bemerken, neueste zuerst. Jeder Eintrag
verlinkt die geänderte Seite. Interne Arbeit — Tests, Werkzeuge,
Abhängigkeiten — steht nicht hier; die Git-Historie hat sie.

## 2026-09-30 — AG03: die Messungen sind neu gelaufen [#2026-09-30-ag03-die-messungen-sind-neu-gelaufen]

Jede Tabelle, jedes Raster und jedes Beispiel auf der AG03-Seite stammt aus einem neuen
Lauf auf den aktuellen Kursseiten. Beim 1.7B stoppt Spotlighting (Stufe 3) jetzt fünf
Angriffe auf einmal (7 von 8 auf 2 von 8), und `declarative-1` ist der Angriff, der
jede Stufe auf Textebene überlebt; das 4B fällt auf Stufe 0 auf einen Angriff herein
statt auf zwei und erledigt seine eigene Aufgabe in 5 von 8 Läufen statt in 6. Die
verfolgten Beispiele und die Klassifikator-Übung (81 von 370 ehrlichen Chunks für die
schlichte Frage markiert) wurden ebenfalls neu ausgeführt. Die Seite sagt, dass der
Prompt Kursseiten enthält und eine Seitenänderung eine Zelle kippen kann.
→ [AG03 — Prompt-Injection](/de/agent-injection)

## 2026-09-30 — R01 und R02: der Referenzlauf ist neu gemessen [#2026-09-30-r01-und-r02-der-referenzlauf-ist-neu-gemessen]

Die Referenz-Evaluation wurde auf den aktuellen Kursseiten neu gelaufen, und jede Zahl,
die R02 und `rag/README.md` zitieren, stammt jetzt aus ihr: `improved` erreicht
Recall@1 0,878, Recall@5 1,000 und MRR 0,935 gegenüber 0,512, 0,902 und 0,670 bei
`naive`. Unter `naive` lehnt das Modell jetzt zehn Fragen zum Thema ab statt neun, und
der Groundedness-Abstand (0,523 gegenüber 0,575) zeigt sich auf denselben 31 Fragen,
die beide Presets beantworten. R02 listet die abgelehnten Fragen mit ihren Rängen neu
auf. Die Ausgaben, die R01 einfügt (der erste Lauf mit `--show-hits`, die Break-Frage
mit beiden Presets und die Frage der eigenständigen Übung), wurden neu erzeugt und passen zu den
heutigen Seiten.
→ [R02 — Damit es nicht lügt](/de/rag-quality) · [R01 — Vom Dokument zur Antwort](/de/rag-build)

## 2026-09-29 — R01: Installationsschritt, sichtbare Treffer und ein Gate [#2026-09-29-r01-installationsschritt-sichtbare-treffer-und-ein-gate]

R01 beginnt seinen praktischen Teil jetzt mit „Installieren und herunterladen“: das
Extra `rag`, das der Track braucht, die Modell-Downloads (etwa 9,3 GB) vor dem ersten
Befehl, wie du das Walkthrough-Notebook öffnest und was bei `No module named
'sentence_transformers'` zu tun ist. `rag/ask.py --show-hits` gibt die gefundenen
Passagen mit ihren Werten aus, und „Erster Durchlauf“ sagt, was du sehen solltest,
warum deine Ränge abweichen können und wie du sie prüfst. Recall@k und MRR sind vor
den Übungen definiert, Brechen stellt eine Frage, die keine Kursseite beantwortet,
deine eigene Evaluationsfrage kommt nach `artifacts/my-work/` statt ins committete
Set, und ein Abschluss-Gate sagt, wann du fertig bist. Die Evaluationstabelle zeigt
`n/a` für „Off-topic refused“, wenn ein Lauf keine Off-Topic-Fragen enthält.
→ [R01 — Vom Dokument zur Antwort](/de/rag-build)

## 2026-09-29 — Einheit 0: sehen, warum das Modell jeden Buchstaben wählt [#2026-09-29-einheit-0-sehen-warum-das-modell-jeden-buchstaben-wahlt]

Das Beispiel „Einen Logit verstärken“ zeigt jetzt, warum jeder Buchstabe gewählt
wird: wie oft jeder Buchstabe im Trainingstext auf ein Leerzeichen folgt, mit seiner
Wahrscheinlichkeit vor und nach deiner Änderung; wie der Text Schritt für Schritt
entsteht (mit dem Gleichstand zwischen `e` und `h`, durch den das Modell `te te te`
schreibt, und dem Gleichstand zwischen `d` und `k` hinter `mode`); und die 16
Trainingssätze mit jedem Nachfolger markiert. Die Lektion erklärt die
Gleichstände hinter `te te te`, `mode` und `pa pa`.
→ [Einheit 0 — Erster Tiny-LM-Lauf](/de/unit-00)

## 2026-09-29 — F06: ein Gerüst für das Gate und eine Referenz, die jede Zeile prüft [#2026-09-29-f06-ein-gerust-fur-das-gate-und-eine-referenz-die-jede-zeile-pruft]

Der F06-Checkpoint beginnt jetzt mit `examples/checkpoint_skeleton.py`: sechs
Funktions-Stubs und zwei Diagnosesätze, Daten und Prüfungen sind vorgegeben. Es
hält beim ersten unfertigen Schritt an und nennt ihn. Die Referenz
`examples/foundations_checkpoint.py` deckt jetzt jede Zeile des Bewertungsrasters
ab, auch den MLP-Gradientencheck auf `W1[0, 0]`, einen PyTorch-Schritt mit
`SmallMLP` samt erwarteten Loss-Werten und einen zweiten Lauf, verglichen bis
`1e-7`; sie gibt je Rasterzeile eine Zeile aus, sodass du deinen Bericht Schlüssel
für Schlüssel vergleichst. Die Seite nennt eine Regel für die Reihenfolge
(Gradienten irgendwann vor `backward()` löschen, vor `step()` auf Endlichkeit
prüfen), zeigt die Zahlen, die `one_update.py` ausgibt, erklärt den Seed, ergänzt
eine aufklappbare Einführung „Eine Klasse in zehn Zeilen“ und gibt eine
Zeitangabe. Der letzte Halt des Checkpoints gibt die Zahlen aus, die deine
Diagnose zitieren muss, und ein `print()` in deinen Funktionen stört den zweiten
Lauf nicht mehr.
→ [F06 — PyTorch-Übersetzung und Grundlagen-Checkpoint](/de/foundations-06-pytorch-checkpoint)

## 2026-09-27 — F05: jede Rückwärtsformel mit echten Zahlen, dann geprüft [#2026-09-27-f05-jede-ruckwartsformel-mit-echten-zahlen-dann-gepruft]

F05 sagt jetzt vorab, dass du die Rückwärtsformeln nicht herleitest: Jede ist eine
Regel, die du mit echten Zahlen ausrechnest und dann durch Anstupsen prüfst. Ein
Beispiel läuft in zehn nummerierten Schritten durch das 2→3→2-Netz, jeder Wert wird
ausgegeben; eine Shape-Regel („ein Gradient hat den Shape seines Parameters, also
passt nur eine Multiplikation“) setzt jede Transponierung, und ein Gradient Check
deckt ganz `W1` ab und schlägt fehl, wenn die tanh-Steigung fehlt. Eine Demo in drei
Zeilen zeigt, wie zwei lineare Schichten zu einer zusammenfallen. Ein neuer
Batch-Schritt vergleicht deine Gradienten mit der Kurs-Hilfsfunktion, der Abschnitt
zur `Value`-Engine erklärt Operatoren, Aufzeichnen, Reihenfolge und den gemeinsam
genutzten Pfad `a * a`, und ein Gate-Werkzeugkasten sammelt One-hot-Ziele, Kopieren vor dem
Anstupsen und float64 für F06. Die Seite
nennt Zeiten je Lernweg.
→ [F05 — MLP, Backprop & Autograd](/de/foundations-05-mlp-autograd)

## 2026-09-27 — F04: erst anstupsen und zusehen, dann die Ableitungsregeln [#2026-09-27-f04-erst-anstupsen-und-zusehen-dann-die-ableitungsregeln]

F04 beginnt jetzt damit, `w` anzustupsen und den Loss zu beobachten; eine
Ableitung ist so zuerst eine gemessene Rate und dann eine Regel. Jede der drei
genutzten Regeln (Quadrat, Gerade, Kette) prüfst du mit einem Stups, Vorwissen in
Analysis ist nicht nötig. Den ersten Trainingsschritt rechnest du für alle vier
Punkte von Hand (der Gradient ist ein Mittelwert), die Vorgaben von
`train_scalar_neuron` stehen auf der Seite, und Gewicht und Bias jedes Schritts
werden angezeigt: So unterscheidest du ein falsches Gradienten-Vorzeichen (das
Gewicht wandert weg) von einer zu großen Lernrate (das Gewicht springt übers
Ziel). Du schreibst deine eigene Trainingsschleife über 20 Schritte und prüfst
sie gegen den Trace. Jeder Schritt nennt seine Datei in `artifacts/my-work/`, und die Seite
nennt eine Zeitangabe. Lernleitfaden und Diagnose sagen, dass F04 die
Ableitungsregeln beibringt; das Glossar erklärt Ableitung, Kettenregel, zentrale
Differenz, MLP, tanh, One-Hot und SGD.
→ [F04 — Neuron und Gradient Descent](/de/foundations-04-neuron) · [Lernleitfaden](/de/learning-guide) · [Diagnose](/de/diagnostic) · [Glossar](/de/glossary)

## 2026-09-27 — F03: Softmax und Cross-Entropy in sechs kleinen Schritten [#2026-09-27-f03-softmax-und-cross-entropy-in-sechs-kleinen-schritten]

F03 führt jetzt in sechs ausführbaren Schritten zur Aufgabe hin: `exp` und `ln`
(und warum die `log`-Taste des Taschenrechners die falsche ist), Softmax einer
Zeile von Hand, warum das Verschieben aller Scores nichts ändert, das eines Scores
aber Wahrscheinlichkeit verschiebt — die +4.0-Änderung aus Einheit 0 —, warum das
Abziehen des Maximums `inf` und `nan` verhindert, die Strafe `−ln p` als Tabelle
und ein Batch aus zwei Zeilen, der `axis=-1`, `keepdims` und
`probs[np.arange(2), targets]` erklärt. „Bauen und brechen“ nennt die sechs
Tests, das Brechen zum Ausprobieren, einen Hinweis und eine Referenzlösung; eine
Zusatzaufgabe zeigt Log-Softmax für Losses, die sonst `inf` wären. Zeitrahmen:
50–75 Minuten, wenn du programmierst, etwa 2–3 Stunden in zwei Sitzungen, wenn
alles neu ist.
→ [F03 — Wahrscheinlichkeit, Logits und Loss](/de/foundations-03-probability)

## 2026-09-27 — F02: Shapes in fünf kleinen Schritten [#2026-09-27-f02-shapes-in-funf-kleinen-schritten]

F02 lehrt jetzt eine Idee pro Schritt, jeweils zum Vorhersagen und dann Ausführen
in `artifacts/my-work/shapes.py`: eine Zeile per Broadcasting auf eine Tabelle
addieren, `*` gegen `@` mit der Regel „Eintrag (i, j) = Zeile i · Spalte j“,
Reshape gegen `.T`, ein kleines `[B, T, C]`-Array und eine lineare Schicht
`x @ W + b` mit Rechenbeispiel. Du startest einen Bias, der laut scheitert, und
einen, der still durchläuft, und siehst, warum ein transponiertes quadratisches
Gewicht durch Shape-Prüfungen rutscht. „Bauen“ nennt seine vier Tests und hat einen
Hinweis und eine Referenzantwort; die Seite nennt ein Zeitbudget für beide Wege.
→ [F02 — Tensoren und Shapes](/de/foundations-02-shapes)

## 2026-09-25 — F01: Bauen verlangt nichts mehr, was vorher fehlte [#2026-09-25-f01-bauen-verlangt-nichts-mehr-was-vorher-fehlte]

Ein neuer Schritt vor „Bauen“, „Testen, dass falsche Eingaben abgelehnt werden“,
erklärt f-Strings und `pytest.raises` mit ausführbaren Dateien und einer
Testvorlage für ungültige Eingaben. Jeder Block der Einführung nennt jetzt seine
Datei, die pytest-Datei steht vollständig da, `zip` nutzt `strict=True`, und bei
der Frage zum `if` sagst du jetzt voraus, was ohne es passiert (mit Antwort). Der
Abschlussnachweis prüft mit `ruff check artifacts/my-work` und
`python -m pytest artifacts/my-work` deine Dateien statt des Kurscodes. Die Seite
nennt getrennte Zeiten für Einführung und Bauen.
→ [F01 — Python und NumPy](/de/foundations-01-python-numpy)

## 2026-09-25 — Einheit 0: das Modell verstehen, nicht nur starten [#2026-09-25-einheit-0-das-modell-verstehen-nicht-nur-starten]

Einheit 0 zeigt jetzt den Text, aus dem das Modell gelernt hat, und wie aus 24 von
84 Leerzeichen vor `t` die 0.263 wird; macht den Korpus-Loss an einer Beispielzahl
greifbar (Überraschung −ln p); erklärt, warum fast jede Änderung den Loss
verschlechtert; nennt das Alphabet des Modells mit 33 Zeichen und welche Zeile deine
Änderung trifft; und endet mit Beispielantworten zum Vergleichen nach dem Schreiben.
Eine falsche Vorhersage liest sich nicht mehr wie ein Durchfallen, und die
Zeitangabe nennt 60 Minuten, wenn du programmierst, 90–120 in zwei Sitzungen, wenn
du neu bist. Die Zusammenfassung zeigt eine vierte Nachkommastelle, wenn drei eine
Änderung verbergen, `run_unit0.py --help` beschreibt jede Option, und die
Fehlerbehebung nennt die erlaubten Zeichen.
→ [Einheit 0 — Erster Tiny-LM-Lauf](/de/unit-00) · [Fehlerbehebung für Einheit 0](/de/unit-00-troubleshooting)

## 2026-09-24 — Einrichtung und erster Lernweg, klarer für Einsteiger [#2026-09-24-einrichtung-und-erster-lernweg-klarer-fur-einsteiger]

Die Einrichtung erklärt jetzt den Zugang zum Repository (GitHub CLI, GitHub Desktop
oder ZIP), was unter Windows, macOS und Ubuntu/Debian zu installieren ist, VS Code
als Editor, ein reines CPU-PyTorch für Linux und eine Checkliste „Jede Sitzung“; der
erste Modelllauf bleibt Einheit 0 vorbehalten, Hinweise für spätere Lektionen sind
eingeklappt. Nach der Diagnose folgt jetzt F01; die Godot-RL-Brücke sagt, dass sie
nur für Absolventen jenes Kurses gedacht ist. Der Lernleitfaden nennt grobe Zeiten,
und das Glossar erklärt Terminal, venv, JSON, Backend, Korpus, Argmax und Checkpoint.
→ [Einrichtung](/de/setup) · [Lernleitfaden](/de/learning-guide) · [Glossar](/de/glossary)

## 2026-09-24 — Einheit 0: einen Logit selbst verstärken [#2026-09-24-einheit-0-einen-logit-selbst-verstarken]

Vor „Annahme brechen“ hat Einheit 0 jetzt ein interaktives Element: Wähle den Prompt
(`"the "` oder `"a "`), ein Zielzeichen und eine Verstärkung von −6 bis +6 und sieh
zu, wie sich beim Ziehen die Wahrscheinlichkeit des Ziels, die fünf
wahrscheinlichsten nächsten Zeichen vorher und nachher, beide Greedy-Texte, der
Korpus-Loss und das Urteil ändern. Es baut dieselbe gezählte Bigram-Tabelle wie das
Skript nach, deshalb stimmen seine Zahlen mit den Zusammenfassungen der Seite
überein; drei Schaltflächen spielen die Läufe der Seite nach (+4 auf m, +3 auf t,
−4 auf t).
→ [Einheit 0 — Erster Tiny-LM-Lauf](/de/unit-00)

## 2026-09-23 — R01 und R02 jetzt auf Deutsch [#2026-09-23-r01-und-r02-jetzt-auf-deutsch]

Beide RAG-Lektionen liegen jetzt vollständig auf Deutsch vor, von der Vorbereitung
des Korpus und der Embedding-Rechnung über die Guardrails bis zum Referenzlauf und zu
den eigenständigen Übungen. Befehle, Code und Programmausgaben bleiben wie auf den
anderen deutschen Seiten englisch; die Fragen an den Index bleiben englisch, weil der Index
aus den englischen Seiten gebaut wird.
→ [R01 — Vom Dokument zur Antwort](/de/rag-build) · [R02 — Damit es nicht lügt](/de/rag-quality)

## 2026-09-23 — Einheit 0: zehn Zeilen Zusammenfassung statt eines JSON-Blocks [#2026-09-23-einheit-0-zehn-zeilen-zusammenfassung-statt-eines-json-blocks]

`run_unit0.py` gibt jetzt zehn Zeilen aus — Eingabe und Token-IDs, die
wahrscheinlichsten Kandidaten, beide Generierungen, die Zielwahrscheinlichkeit und
den Korpus-Loss vor → nach der Änderung sowie ein berechnetes Urteil — und speichert
den vollständigen Bericht unter `artifacts/unit0/report.json`; `--json` gibt ihn aus.
Die Seite erklärt jede Zeile, geht den vollständigen Bericht einmal durch und zeigt,
warum `--boost 3` eine Wahrscheinlichkeit verschiebt, ohne den Text zu ändern.
`diagnose_unit0.py` gibt eine Zeile pro Prüfung aus, und ein leerer Prompt liefert
jetzt eine einzeilige Fehlermeldung statt eines Tracebacks. AG01 startet
`run_unit0.py` jetzt ohne Umleitung der Ausgabe. Zeichen mit gleicher
Wahrscheinlichkeit stehen jetzt nach Token-ID sortiert, sodass die Kandidatenlisten
in den Berichten von Einheit 0 und T01 auf jeder Plattform gleich aussehen.
→ [Einheit 0 — Erster Tiny-LM-Lauf](/de/unit-00)

## 2026-09-23 — R01 und R02: jede Zahl auf dem heutigen Kurs gemessen [#2026-09-23-r01-und-r02-jede-zahl-auf-dem-heutigen-kurs-gemessen]

Die RAG-Lektionen zitierten einen Referenzlauf von vor der Zeit, als die Agenten-Seiten
in den Korpus kamen. Jede Zahl in R01, R02 und im RAG-README stammt jetzt aus einem
neuen Lauf auf den heutigen 41 Seiten: `improved` schlägt `naive` beim Retrieval
weiterhin (Recall@1 0,878 gegenüber 0,561), aber seine lexikalische Groundedness ist
niedriger (0,557 gegenüber 0,631), und R02 sagt das jetzt, statt sie unverändert zu
nennen. Das Offline-Beispiel in R01 zeigt eine andere erste Passage. Ein Test meldet
jetzt, wenn eine neue Seite diese Zahlen verschiebt. Die Lektionen sind weiterhin nur
auf Englisch verfügbar.
→ [R02 — Damit es nicht lügt](/de/rag-quality) · [R01 — Vom Dokument zur Antwort](/de/rag-build)

## 2026-09-23 — AG03: messen, was eine Abwehr gegen Prompt Injection bringt [#2026-09-23-ag03-messen-was-eine-abwehr-gegen-prompt-injection-bringt]

Ein Angriffs-Set und dasselbe präparierte Dokument laufen gegen R02s
Retrieval-Pipeline und AG02s Agenten durch eine kumulative Verteidigungsleiter —
delimiters, escaping, spotlighting, ein pattern filter, ingest cleaning, ein
confirmation-Schritt und zuletzt das Einschränken des Sende-Tools, sodass kein
Aufruf einen Empfänger wählen kann. Jede Messung läuft nur auf lokalen
Qwen-Modellen, nie auf einer gehosteten API. Beim kleinen
Modell fällt die Erfolgsquote beim Retrieval von 7 von 8 auf 3 von 8 und erreicht
nie null; der 4B-Agent geht auf keiner Stufe auf den Köder ein, doch dieselben
Abwehrmaßnahmen kosten ihn trotzdem die Aufgabe — von 6 von 8 erledigten Läufen
auf 0 von 8.
→ [AG03 — Prompt-Injection](/de/agent-injection)

## 2026-09-23 — R02: den Injection-Filter überlisten [#2026-09-23-r02-den-injection-filter-uberlisten]

Die eigenständige Übung verlangt kein siebtes Regex-Muster mehr. Du schreibst jetzt
zwei Formulierungen des 999-Euro-Angriffs, die an allen sechs Mustern vorbeikommen,
siehst zu, wie der Filter den Guardrails-Abschnitt von R02 selbst verwirft, und
erklärst, welcher Guardrail dich trotzdem erwischt. Die Passage-Tags werden jetzt
escaped, sodass ein Dokument sein eigenes Tag nicht mehr schließen und eine Passage
fälschen kann. Die Lektion ist weiterhin nur auf Englisch verfügbar.
→ [R02 — Damit es nicht lügt](/de/rag-quality)

## 2026-09-22 — AG02: derselbe Agent mit nativem Tool-Use [#2026-09-22-ag02-derselbe-agent-mit-nativem-tool-use]

Lass den Agenten aus AG01 auf drei Wegen an einer Frage laufen — Textprotokoll auf
Claude, Claudes natives Tool-Use und Qwen3s eigenes `<tool_call>`-Format — und lies,
was die API übernommen hat (Schema, Parsen, Aufruf-IDs) gegen das, was deine Sache
bleibt. Mit der ersten Brechen-Übung, in der die API eine kaputte Konversation ablehnt.
→ [AG02 — Native Tool-Use](/de/agent-native)

## 2026-09-21 — F01 nimmt die Python-Grundlagen eine Idee nach der anderen [#2026-09-21-f01-nimmt-die-python-grundlagen-eine-idee-nach-der-anderen]

Der Abschnitt, der Ausschnitte, Schleifen, `zip`, Funktionen, `assert` und
pytest auf einmal einführte, besteht jetzt aus fünf kurzen Schritten mit je
einer Sache zum Vorhersagen. Ein Ausschnitt-Visualizer auf der Seite lässt dich
einen Ausschnitt tippen und zeigt, welche Positionen von `["a", "b", "c", "d"]`
aufleuchten, und legt zwei Ausschnitte nebeneinander, damit du die Paare siehst,
die `zip` erzeugt — die Bigramm-Idee im Kleinen.
→ [F01 — Python & NumPy](/de/foundations-01-python-numpy)

## 2026-09-21 — AG01: eine Agentenschleife von Hand bauen [#2026-09-21-ag01-eine-agentenschleife-von-hand-bauen]

Die erste Einheit der neuen Gruppe **Angewandt: Agenten** ist da. Du baust einen
Agenten, in dem nichts versteckt ist — ein Klartext-Tool-Protokoll, das du selbst
parst, ein Schrittbudget und ein Trace, der zeigt, was das Modell tatsächlich
gesehen hat —, vergleichst zwei lokale Modelle an derselben Frage und siehst
einem kleinen Modell dabei zu, wie es eine Quelle erfindet. Zwei weitere
Agenten-Einheiten sind geplant und auf der Startseite mit *(in Kürze)* markiert.
→ [AG01 — Die Agentenschleife, von Hand](/de/agent-loop)

## 2026-09-20 — Einheit 0 setzt nichts mehr voraus, was der Kurs erst später lehrt [#2026-09-20-einheit-0-setzt-nichts-mehr-voraus-was-der-kurs-erst-spater-lehrt]

Das ganze Modell steht in drei Sätzen vor der ersten Vorhersage, jeder Fachbegriff
wird dort erklärt, wo er zuerst vorkommt, und die eintönige Ausgabe wird als
erwartetes Ergebnis erklärt, nicht als kaputter Lauf. Die Python-Prüfung bekommt
einen Weg von Hand für alle, die noch nicht programmieren.
→ [Einheit 0 — Erster Tiny-LM-Lauf](/de/unit-00)

## 2026-09-19 — Die Startseite sagt, was du danach kannst [#2026-09-19-die-startseite-sagt-was-du-danach-kannst]

Neun Fähigkeiten in klarer Sprache, jede mit der Einheit verlinkt, die sie
belegt, und eine Liste geplanter Einheiten mit *(in Kürze)*, damit du siehst,
was noch nicht geschrieben ist.
→ [Kursstart](/de/)

## 2026-09-19 — „Angewandt: RAG“ unter die Kursgruppe verschoben [#2026-09-19-angewandt-rag-unter-die-kursgruppe-verschoben]

Der Retrieval-Track steht in der Seitenleiste jetzt nach dem Kernkurs. Inhalt und
Lernweg im Lernleitfaden sind unverändert.
→ [R01 — Vom Dokument zur Antwort](/de/rag-build)

## 2026-09-17 — Der Kurs läuft unter llm.onlinekurs.training [#2026-09-17-der-kurs-lauft-unter-llmonlinekurstraining]

Die veröffentlichte Seite ist auf eine eigene Domain umgezogen. Alte Links
leiten weiter.

[Kursstart](/de/)
