Apps programmieren mit LLMs: RAG, Agenten, Deployment – Kurs

Large Language Models haben die Art, wie Software gebaut wird, grundlegend verändert. Entwicklerinnen und Entwickler können heute in Stunden Anwendungen bauen, für die früher Monate an ML-Expertise nötig gewesen wären — vorausgesetzt, sie beherrschen die spezifischen Werkzeuge und Konzepte der LLM-App-Entwicklung. Dieser Kurs richtet sich an Personen mit Grundkenntnissen in Softwareentwicklung, die lernen möchten, LLM-APIs systematisch einzusetzen: angefangen bei Chat-Completion-Endpunkten und strukturiertem Prompt Engineering über Retrieval-Augmented Generation und Vektordatenbanken bis zu Function Calling, Agenten-Architekturen und dem Deployment produktionsreifer KI-Anwendungen.

Modul 1 — LLM-API-Grundlagen und Prompt Engineering: Bevor komplexe Anwendungen entstehen können, muss das Fundament sitzen. Dieser Block behandelt, wie LLM-APIs funktionieren, was Tokenisierung bedeutet und wie Prompts systematisch entwickelt werden. Unterschiedliche Prompt-Strategien — Chain of Thought, Few-Shot, System-Prompts — werden praktisch verglichen und bewertet.

• Chat-Completion-API: Request-Struktur, Parameter (Temperature, Top-p, Max Tokens) verstehen
• Tokenisierung: Wie LLMs Text lesen und warum Token-Counts wichtig sind
• Zero-Shot, Few-Shot und Chain-of-Thought Prompting im Vergleich
• System-Prompts und User-Prompts gezielt einsetzen
• Structured Output: JSON-Mode und Formaterzwingung via Pydantic/Zod
• Prompt-Bibliotheken anlegen und versionieren

Modul 2 — Retrieval-Augmented Generation (RAG): RAG ist das Standardmuster für LLM-Anwendungen, die über das Wissen des Basismodells hinaus auf eigene Daten zugreifen müssen. Dieser Block behandelt die vollständige RAG-Pipeline: Daten-Chunking, Embedding-Generierung, Vektordatenbank-Integration und kontextuelle Abfrage.

• Dokumenten-Preprocessing und Text-Chunking-Strategien
• Embedding-Modelle: Auswahl, Trade-offs und Qualitätsbewertung
• Vektordatenbanken einrichten: Pinecone, Chroma, Weaviate, pgvector im Vergleich
• Ähnlichkeitssuche: Cosine Similarity, Approximate Nearest Neighbor
• RAG-Pipeline bauen: Retrieval, Augmentation, Generation im Zusammenspiel
• Erweiterte RAG-Patterns: Hybrid Search, Re-Ranking, HyDE (Hypothetical Document Embeddings)

Modul 3 — Function Calling und Agenten-Architekturen: LLM-Anwendungen, die eigenständig handeln — Daten abfragen, APIs aufrufen, Entscheidungen treffen — sind der nächste Reifegrad. Dieser Block führt in Function Calling als Schnittstelle zwischen Sprachmodell und externen Systemen ein und zeigt, wie Agenten-Schleifen aufgebaut werden.

• Function Calling: Tool-Definitionen schreiben und LLM-Antworten parsen
• Multi-Step-Agenten: ReAct-Pattern und Plan-and-Execute-Architekturen
• Tool-Integration: Websuche, Code-Ausführung, Datenbankabfragen
• Memory-Systeme für Agenten: Short-Term-Context vs. externem Langzeitspeicher
• Frameworks im Vergleich: LangChain, LlamaIndex, direkte API-Nutzung
• Sicherheits-Überlegungen bei autonomen Agenten: Prompt Injection, Tool-Missbrauch

Modul 4 — Deployment, Monitoring und Kostenmanagement: Eine LLM-App, die lokal funktioniert, aber in der Produktion versagt, nutzt nichts. Dieser Block behandelt die technischen und wirtschaftlichen Aspekte des produktionssicheren Betriebs: Containerisierung, Observability, Fehlerbehandlung und Kostenkontrolle.

• Anwendungen mit FastAPI oder ähnlichen Frameworks als API bereitstellen
• Docker-Containerisierung für LLM-Apps und Deployment auf Cloud-Plattformen
• Token-Kosten berechnen und Budget-Limits implementieren
• Logging, Tracing und Monitoring für LLM-Calls (Langfuse, Helicone oder ähnliche Tools)
• Fehlerbehandlung: Rate Limits, Timeouts, Fallback-Strategien
• A/B-Testing für Prompts und Modelle in der Produktion

Praxis-Block — Eigene LLM-Anwendungen bauen

• Chatbot mit persistentem Gesprächsverlauf und System-Prompt implementieren
• RAG-System über eine eigene Dokumentensammlung aufbauen
• Tool-verwendenden Agenten für eine konkrete Aufgabe entwickeln
• Vektordatenbank mit eigenen Texten befüllen und Suchanfragen optimieren
• API-Endpunkt für eine LLM-gestützte Funktion mit FastAPI bereitstellen
• Token-Budget-Tracking in eine bestehende Anwendung einbauen
• Einfachen Prompt-Evaluierungsrahmen entwickeln und Ergebnisse vergleichen
• Streaming-Responses in eine Web-Oberfläche integrieren
• Containerisiertes Deployment auf einer Cloud-Plattform durchführen
• Monitoring-Dashboard für API-Calls und Latenzen einrichten
• Capstone-Projekt: Vollständige LLM-App von der Anforderung bis zum Deployment

Der Kurs richtet sich an Personen mit Grundkenntnissen in Softwareentwicklung oder Product Engineering, die LLM-APIs gezielt in Anwendungen einsetzen wollen. Auch technikaffine Quereinsteiger, die bereits erste Berührungspunkte mit Code und APIs haben, können den Kurs erfolgreich absolvieren.

• Softwareentwickler, die KI-Features in bestehende Anwendungen integrieren wollen
• Product Engineers, die eigenständig LLM-gestützte Produkte bauen möchten
• Technische Gründer, die KI-Anwendungen ohne großes ML-Forschungsteam entwickeln
• Quereinsteiger mit digitalem Hintergrund und ersten Programmierkenntnissen
• Fachkräfte aus dem Bereich Product Management oder Data, die technische LLM-Konzepte verstehen wollen

Der Kurs ist konsequent projekt- und codegetrieben. Statt Theorie-Blöcken mit angehängten Übungen wird jedes Konzept sofort in Code umgesetzt — Teilnehmende schreiben von der ersten Stunde an echte LLM-Anwendungen. Code-Reviews, Peer-Feedback und Live-Coding-Sessions sind feste Bestandteile des Formats. Die Entwicklungsumgebung ist Python-basiert; Colab-Notebooks oder lokale Setups sind beide möglich.

Die genaue Laufzeit hängt vom jeweiligen Anbieter und der Durchführungsform ab. Das Curriculum ist modular aufgebaut: Die vier Kernmodule bauen aufeinander auf und münden in einem abschließenden Capstone-Projekt, das den gesamten Entwicklungszyklus einer LLM-Anwendung abdeckt. Vollzeitformate von mehreren Wochen sind ausreichend; berufsbegleitende Teilzeitvarianten sind je nach Anbieter ebenfalls möglich.

Nach Abschluss erhalten Teilnehmende ein Zertifikat des jeweiligen Anbieters, das die Qualifikation im Bereich LLM-Applikationsentwicklung belegt. Das Capstone-Projekt — eine selbst entwickelte LLM-Anwendung — ist der greifbarste Kompetenznachweis und kann in eigenen Projekten, Repositories oder Portfolios eingesetzt werden. Anders als reine Theorie-Zertifikate beweist dieses Portfolio-Stück konkret, was technisch umsetzbar ist.

LLM-App-Entwicklung ist eine der gefragtesten Fähigkeiten im Softwaremarkt. Unternehmen aller Branchen suchen Entwicklerinnen und Entwickler, die KI-Funktionalität nicht nur beschreiben, sondern tatsächlich implementieren können — von der API-Integration bis zum produktionsfähigen Deployment. Wer diesen Kurs absolviert, kann sofort produktive Beiträge in realen Projekten leisten, weil alle behandelten Patterns direkt auf echte Codebases übertragbar sind. Der Kurs setzt bewusst auf technische Tiefe statt oberflächlicher Prompting-Tipps. RAG-Implementierung, Agenten-Architekturen und Monitoring-Strategien sind Fähigkeiten, die über das Niveau einfacher Chatbot-Wrapper hinausgehen und am Arbeitsmarkt entsprechend höher bewertet werden. Wer diese Konzepte beherrscht, kann auch komplexe KI-Produktanforderungen strukturiert angehen und anderen Teammitgliedern erklären, warum bestimmte Architekturentscheidungen getroffen wurden. Das Capstone-Projekt ist dabei mehr als eine Abschlussaufgabe: Es ist ein konkretes Artefakt, das zeigt, was entstanden ist. Ob Dokument-Chat-System, interner Wissensassistent oder API-basierter Datenanalyst — das Endprodukt ist ein reales Beispiel für eigene LLM-Entwicklungskompetenz und ein Gesprächsthema in jedem technischen Einstellungsgespräch.