MCP in der Praxis: Aufbau von Servern und Integrationen für KI-Agenten in Python
Workshop für Entwickler, die von der Nutzung von KI in der IDE zum Aufbau eigener MCP-Server, Tools und Integrationen für Agenten übergehen möchten. Der Kurs führt von einem lokalen Server in Python über ein zweites Beispiel in TypeScript bis hin zur Integration mit Responses API, Claude Code und einem öffentlichen Remote-MCP-Server.
Intensiver Build-along-Workshop: Die Teilnehmenden starten mit einem leeren Repository und bauen Schritt für Schritt ein funktionierendes MCP-Ökosystem für KI-Agenten auf. Unterwegs werden die Unterschiede zwischen MCP, Function Calling und klassischen API-Integrationen geklärt; die Client-Server-Architektur mit Tools, Resources und Prompts wird implementiert; ein lokaler MCP-Server in Python wird gestartet; ein zweiter Server in TypeScript erstellt; das Ganze wird im MCP Inspector getestet und debuggt; Sicherheitsmechanismen, Approval-Flows und Berechtigungsbegrenzungen werden ergänzt; ein Remote-MCP-Server wird per HTTP bereitgestellt; und am Ende wird ein Mini-Projekt eines Agenten zusammengesetzt, der Code-Repository, Dokumentation und externe APIs verbindet. Der Kurs mischt bewusst kurze Architektur-Briefings, Qualitäts-Checklisten, Vergleiche guter und schlechter Tool-Definitionen, Implementierungsaufgaben, Debugging-Sessions und Artefakt-Reviews, damit das Lernen nicht auf das Klicken durch eine UI reduziert wird. Umfang und Übungen basieren auf dem aktuellen, offiziellen MCP-Ökosystem: den offiziellen SDKs für Python und TypeScript, MCP Inspector, modernen lokalen und entfernten Transporten, Integrationen mit OpenAI Docs MCP / der OpenAI-Dokumentation, Materialien zum Aufbau von MCP für OpenAI-API-Integrationen sowie den aktuellen Möglichkeiten von Claude Code und entfernten MCP-Konnektoren.
Was Sie lernen
- Du erklärst praktisch, wann MCP gegenüber normalem Function Calling und klassischer API-Integration Vorteile bietet und wann es eine unnötige Schicht ist.
- Du entwirfst eine MCP-Architektur mit Host, Client, Server, Tools, Resources, Prompts und der Wahl eines lokalen oder entfernten Transports.
- Du baust von Grund auf einen lokalen MCP-Server in Python mit sinnvoll beschriebenen Tools, Ressourcen und Prompts.
- Du erstellst ein zweites, paralleles Beispiel eines MCP-Servers in TypeScript und vergleichst die Idiome beider SDKs.
- Du bindest den MCP-Server in einen Workflow mit der OpenAI Responses API sowie in Tools wie Claude Code und Desktop-Clients ein.
- Du testest und debugst Server mit MCP Inspector, Logs und Fehlerszenarien, statt zu raten, warum der Agent ein Tool nicht verwendet.
- Du implementierst die sichere Bereitstellung von Tools: Auth, Approval-Flow, Begrenzung des Wirkungsbereichs und Minimierung des Risikos von Datenlecks.
- Du stellst einen Remote-MCP-Server über einen öffentlichen HTTP-Endpunkt bereit und machst ihn für externe Clients nutzbar.
- Du setzt ein finales Mini-Projekt zusammen: einen Agenten, der Repository, Dokumentation und externe API in einem einzigen Workflow verbindet.
- Du lernst, die Qualität von MCP nicht danach zu bewerten, ob es „funktioniert“, sondern danach, ob der Agent die richtigen Tools auswählt, nützliche Ergebnisse liefert und produktiv wartbar ist.
Voraussetzungen
Sichere Python-Kenntnisse auf dem Niveau der täglichen Entwicklungsarbeit, grundlegende Kenntnisse in TypeScript/Node.js, Erfahrung mit REST/HTTP und JSON, die Fähigkeit, mit Terminal, Git und virtuellen Umgebungen zu arbeiten. Von Vorteil: Grundlagen von FastAPI/Express, Docker und ein beliebiger KI-Client wie Claude Code, Cursor, VS Code Agent oder ein eigenes Skript, das die API nutzt.
Kursprogramm
- MCP vs. Function Calling vs. manuell gekoppelte APIs: drei Architekturen für dieselbe Agentenaufgabe
- Fallstudie: warum ein Agent mit reinem Function Calling den Kontext von Tools und Berechtigungen verliert
- Entscheidungs-Checkliste: wann MCP die Integration vereinfacht und wann es Overengineering ist
- Anatomie des MCP-Ökosystems: Host, Client, Server, Tools, Resources, Prompts, Transports
- Entscheidungsquiz: Wähle das passende Integrationsmuster für 8 Produktszenarien
- Bootstrap-Repo: Projektstruktur, Env, Abhängigkeiten und Dev-Skripte für den MCP-Workshop
- Der erste Server in Python: ein minimales FastMCP mit stdio, das wirklich antwortet
- Nicht nur ein Tool: Resource und Prompt hinzufügen, damit der Agent mehr als nur Aktionen hat
- Vollständiges Artefakt zum Vergleichen: schlechte vs. gute Tool-Definition und Parameterbeschreibung
- Erster Start mit lokalem Client: Was du sehen solltest, bevor du weitermachst
- Quiz zu Startfehlern: Erkenne das Problem anhand von Symptom, Log und Verhalten des Clients
- Design-Framework für MCP-Tools: Name, Eingabekontrakt, Ergebnis, Fehler, Side Effects
- Workshop der Verträge: Umbau von 3 Tools von der „Demo“-Version zur „agent-friendly“-Version
- Ressourcen als Kontextschicht: Wann URI und Lesen besser sind als ein weiterer Tool
- Prompts als fertige Verfahren: Wie man Workflows verpackt, ohne die Logik hart im Modell zu kodieren
- Kritik an Artefakten: Vergleich von Before/After der Agentenantworten auf denselben Aufgaben
- Qualitätsquiz: Gib an, welche Tool-Beschreibung die Wahrscheinlichkeit erhöht, dass das Modell die richtige Auswahl trifft
- MCP Inspector von innen: Welche Fragen du dem Server stellst, bevor du den KI-Client startest
- Debugging einer lokalen Sitzung: Enumerierung von tools/resources/prompts und Verifikation des Capability-Handshakes
- Arbeit mit Fehlern: Schema-Mismatch, Ausnahme im Tool, falscher Content-Type, Timeout
- Zu große Antworten und zu viele Tokens: wie man Payloads kürzt, paginiert und sinnvolle Ergebnisse zurückgibt
- Logs, Spuren und Reproduktions-Checkliste: Wie man einen MCP-Bug so meldet, dass ihn jemand anderes behebt
- Diagnostisches Quiz: Ordne das Symptom der wahrscheinlichsten Ursache zu
- Warum das zweite Beispiel in TypeScript keine 1:1-Kopie von Python sein sollte
- Serveraufbau in TypeScript: Projektstart, SDK, Transport und erstes Tool
- Integratives Beispiel: Dokumentations-/Projektserver mit Resource Templates und Ergebnisfilterung
- Vergleich Python vs. TypeScript: Ergonomie von Decorators, Typen, Validierung und Code-Struktur
- Code Review zweier Implementierungen: Welche Entscheidungen zwischen Repositories übertragen werden sollten – und welche nicht
- Vergleichsquiz: Wähle den besseren Stack für einen lokalen Helper, einen Team-Server und einen öffentlichen Endpoint
- Integrationskarte: lokaler MCP-Client, Claude Code, Desktop-Clients und entfernte API-Connectoren
- OpenAI und MCP in der Praxis: Wie man Dokumentation und eigene Tools in einen Workflow mit der Responses API einbindet
- Claude Code + lokaler Server: Konfiguration, Tool-Auswahl und Approval-Erwartungen
- Desktop-Client-Workflow: Start desselben Servers in der Konfiguration des Endnutzers
- End-to-End-Szenario: Der Agent liest eine Resource, ruft ein Tool auf und erstellt eine Antwort mit zitierfähigem Kontext
- Integrationsquiz: Gib an, welche Einschränkungen vom Client und welche vom Server ausgehen
- Bedrohungsmodell für MCP: Was kann beim Lesen von Dateien, Repos, Geheimnissen und mutierenden Aktionen schiefgehen
- Approval-Flow in der Praxis: Welche Operationen eine menschliche Bestätigung erfordern und wie man das erzwingt
- Auth für den Remote-Server: Token, Bearer-Flow und die Trennung der Benutzeridentität vom Server
- Least privilege by design: Eingrenzung von Repo-, Endpoint-, Parameter- und Antwortformaten
- Überblick über Antimuster: Tools mit versteckten Side Effects, Geheimnisse im Payload und Vertrauen in inoffizielle Proxys
- Sicherheitsquiz: Bewerte das Risiko und wähle den minimal sicheren Werkzeugvertrag
- STDIO vs. Streamable HTTP: Transportentscheidung vor dem Deploy und Konsequenzen für die Architektur
- Bereitstellung eines Remote-MCP-Servers: öffentlicher Endpoint, Umgebungs-Konfiguration und Smoke-Test nach dem Deploy
- Produktions-Checkliste: Health Checks, Limits, Observability, Versionierung und Rollback
- Mini-Projekt Teil 1: Agent für die Arbeit mit Repo, Dokumentation und externem API — Plan und Verträge
- Mini-Projekt Teil 2: Implementierung des Ablaufs sowie Tests von Erfolgs- und Fehlerszenarien
- Mini-Projekt Teil 3: Kritik der Ergebnisse, Refactoring von Verträgen und Verbesserung der Antwortqualität des Agenten
- Abschlussquiz: architektonische und Debug-Entscheidungen auf Grundlage einer einzigen Produktions-Case-Study
Häufig gestellte Fragen
Du lernst Schritt für Schritt, ein produktionsnahes MCP-Ökosystem von einem leeren Repository bis zu einer funktionierenden Integration für KI-Agenten aufzubauen. Du ordnest die Unterschiede zwischen MCP, Function Calling und klassischen API-Integrationen ein, implementierst die Client-Server-Architektur mit Tools, Resources und Prompts, startest einen lokalen MCP-Server in Python, erstellst einen zweiten Server in TypeScript und testest sowie debugst das Ganze im MCP Inspector. Der Kurs ist als intensiver Build-along-Workshop aufgebaut, sodass du statt reiner Theorie reale Komponenten entwickelst, die sich in einem Unternehmensprojekt weiterverwenden lassen.
Weil der Markt für KI-Agenten schnell reift und Interoperabilität immer wichtiger wird. OpenAI positioniert die Responses API als Richtung für den Aufbau von Agenten und Tools, während Anthropic das Model Context Protocol als offenen Standard für die Arbeit mit Tools und Kontext für Agenten weiterentwickelt. Das bedeutet, dass Kompetenzen rund um MCP, Tool-Integrationen und sichere Agenten-Orchestrierung immer praktischer und gefragter werden, besonders in Teams, die eigene KI-Workflows bauen. Der Kurs hilft dir, in dieses Feld nicht über allgemeine Schlagworte, sondern über die Implementierung einer funktionierenden Architektur einzusteigen.
Ganz klar über die Praxis. Es ist ein Build-along-Workshop: Die Teilnehmenden starten mit einem leeren Repository und bauen gemeinsam mit dem Dozenten eine komplette Lösung. Jedes Element — von der MCP-Architektur über das Erstellen des Servers in Python und TypeScript bis hin zu Testing, Debugging, Sicherheit und Berechtigungsbegrenzung — wird live umgesetzt. Dadurch hast du nach dem Kurs nicht nur ein Verständnis der Konzepte, sondern auch Code, Projektstruktur und Implementierungsmuster, die du in eigenen KI-Agenten nutzen kannst.
Für Python-Entwickler, Backend-Developer, AI Engineers, Automatisierungsentwickler und Personen, die KI-Agenten bauen und über einfache Function-Calling-Demos hinausgehen möchten. Er eignet sich auch für Produkt- und Technikteams, die verstehen müssen, wann ein normales Funktionsaufrufen ausreicht und wann es besser ist, ein vollständiges MCP-Ökosystem mit Zugriffskontrolle, Approval-Flow und einem klaren Integrationsmodell zu entwerfen.
Nein. Der Kurs ordnet die Grundlagen von Anfang an und zeigt die praktischen Unterschiede zwischen MCP, Function Calling und klassischer API. Wenn du die Grundlagen von Python kennst und verstehst, was HTTP/API-Integrationen sind, kommst du gut in das Material hinein. Gleichzeitig sind Tempo und Umfang so konkret, dass auch fortgeschrittenere Teilnehmende fertige Implementierungsmuster und einen besseren Ansatz für das Design von Agenten mitnehmen.
Die Hauptsprache ist Python, in der du den lokalen MCP-Server startest und praktische Integrationen für KI-Agenten baust. Zusätzlich erstellst du einen zweiten Server in TypeScript, sodass du verstehst, wie man eine mehrsprachige Umgebung entwirft und Muster zwischen Stacks überträgt. Im Kurs kommen außerdem MCP Inspector für Tests und Debugging sowie Themen rund um Sicherheit, Berechtigungssteuerung und Approval-Flows vor.
Ja — und das ist eine seiner größten Stärken. Neben dem eigentlichen Starten des Servers lernst du, Sicherheitsmechanismen, Approval-Flows und Berechtigungsbegrenzungen zu ergänzen. Das ist heute besonders wichtig, da agentische Tools Aktionen in externen Systemen ausführen können und Plattformen wie OpenAI immer fortschrittlichere Tools und Orchestrierungszyklen für Agenten entwickeln. Der Kurs zeigt also nicht nur, wie man etwas verbindet, sondern wie man es verantwortungsvoll und zukunftsfähig umsetzt.
Function Calling bringt dem Modell bei, konkrete Funktionen aufzurufen, aber MCP führt ein breiteres, strukturierteres Modell der Zusammenarbeit eines Agenten mit Tools, Ressourcen und Prompts ein. In der Praxis bedeutet das bessere Skalierbarkeit von Integrationen, eine klarere Client-Server-Architektur und mehr Vorhersagbarkeit bei der Weiterentwicklung der Agentenumgebung. Dieser Kurs endet nicht bei einem einzelnen Tool-Aufruf — er zeigt, wie man ein komplettes Integrations-Ökosystem entwirft, es im MCP Inspector testet und in realen Anwendungen weiterentwickelt.
- 12 Stunden
- Fortgeschritten
- Zertifikat nach Abschluss
- Sofortiger Zugang nach Kauf