Glanz: AI MOOC Plugin 3a178de04ab78102f0e2b7c17ae1cc43

2026-10-22T03:36:46Z

AI MOOC Plugin 3a178de04ab78102f0e2b7c17ae1cc43

Neue Seite

{{T}}

{{BR}}
= Einleitung =
'''Zielgruppe:''' Auszubildende im 1. bis 2. Ausbildungsjahr. '''Voraussetzungen:''' Dateien und Einheiten verstehen; Programmierkenntnisse sind nicht nötig. '''Zeitbedarf:''' etwa 5–7 Unterrichtseinheiten mit Wahlvertiefungen.

Du erstellst ein '''lesendes Lernprodukt''': einen kleinen Client, der synthetische Prüfwerte eines ungefährlichen Lehrbauteils ausschließlich von einem lokalen Testdienst abfragt. Am Ende zeigst du anhand eigener Tests, dass die Anwendung bei einer Zeitüberschreitung, beschädigtem JSON und wiederholten Fehlern kontrolliert reagiert. '''Kein Maschinenzugang, keine reale Steuerung, keine Sicherheitsfreigabe.''' Das Angebot ist unabhängig; es ist weder eine offizielle Liebherr-Schulung noch eine IHK-Zertifizierung.

'''Aktivierung der Grundlage:''' Der vorhandene Einstieg [https://moocwiki.org/index.php?curid=60654 MOOCwiki-Grundlage] wird hier nur kurz aufgegriffen: Dateien speichern, Zahlen und Einheiten unterscheiden, Eingaben und Ausgaben benennen. Der Seiteninhalt war zum Recherchezeitpunkt nicht zuverlässig abrufbar; deshalb behauptet dieser Kurs keine dortigen Einzelaussagen. Schätze vorab ein: Was ist eine Datei? Was unterscheidet 23,4 von 23,4 mm? Wie erkennst du einen Fehler?

'''Dein Lernweg:''' verstehen → angeleitet beobachten → lokal erproben → Fehler gezielt provozieren → selbstständig entscheiden und begründen. Alle Beispiele sind erfunden und offline mit lokal installierbarem Python oder auf Papier bearbeitbar; kein bezahltes KI-Konto erforderlich.

{{BR}}
= Schnittstellen, HTTP und REST lesen =

{{BR}}
== Eine API ist ein vereinbarter Datenweg ==
Eine '''API''' (Application Programming Interface, Programmierschnittstelle) legt fest, welche Daten oder Funktionen ein anderes Programm anfragen darf und wie die Antwort aussieht. Der '''Client''' fragt an; der '''Server''' beantwortet die Anfrage. Die '''Schnittstellenbeschreibung''' vereinbart Pfade, erlaubte Methoden, Felder, Einheiten und Fehlermeldungen. Eine KI kann beim Formulieren einer Anfrage helfen, aber sie kennt nicht automatisch den wirklichen Vertrag: Du prüfst jede Annahme gegen die Dokumentation.

[[File:Client-server model.svg|500px|frameless|center|alt=Skizze: Client sendet Anfrage an Server und empfängt Antwort]]
''Bild: Anfrage und Antwort im Client-Server-Modell; Lubaochuan, CC BY-SA 4.0. Ohne Bild: Der Client stellt eine Frage, der Server liefert Daten oder einen Fehler zurück.''

{{BR}}
== Eine HTTP-Nachricht entschlüsseln ==
'''HTTP''' ist ein Kommunikationsprotokoll. Eine Anfrage enthält unter anderem '''Methode''' (beispielsweise GET), '''Pfad''' (beispielsweise /api/v1/werte), optionale '''Header''' und manchmal einen '''Body''' (Inhalt). Eine Antwort besteht aus '''Statuscode''', Headern und gegebenenfalls einem Body. '''GET''' ist für lesende Abfragen vorgesehen; '''POST''' übermittelt typischerweise neue Daten zur Verarbeitung. Unsere Schulübung verwendet nur GET.

Beispiel aus dem lokalen, erfundenen Dienst:
<pre>
GET /api/v1/werte HTTP/1.1
Host: 127.0.0.1:8765
Accept: application/json

HTTP/1.1 200 OK
Content-Type: application/json

{"bauteil":"LEHR-01","wert":23.4,"einheit":"mm"}
</pre>
'''127.0.0.1''' bezeichnet den eigenen Rechner (Loopback); '''Port 8765''' ist eine lokale Anschlussnummer. '''200''' bedeutet erfolgreiche Bearbeitung, '''404''' nicht gefunden, '''503''' vorübergehend nicht verfügbar. '''408''' ist ein HTTP-Status, während eine lokale Client-Zeitüberschreitung auch ohne HTTP-Antwort entstehen kann. Verwechsle diese beiden Fehler nicht.

[[File:HTTP-Anfrage.svg|500px|frameless|center|alt=Beschriftete Beispielansicht einer HTTP-Anfrage und ihrer Antwort]]
''Bild: Bestandteile einer HTTP-Anfrage und Antwort; Sébastien Santoro/Dereckson und Kulandru mor, gemeinfrei. Ohne Bild: Methode und Pfad stehen in der Anfrage, Status und Inhalt in der Antwort.''

{{BR}}
== REST: Ressourcen statt magische Befehle ==
'''REST''' ist ein Architekturstil für verteilte Systeme, kein eigenes Datenformat. Eine '''Ressource''' ist über eine Adresse erreichbar; eine '''Repräsentation''' beschreibt sie. REST strebt unter anderem eine einheitliche Schnittstelle und zustandslose Interaktionen an. Nicht jede HTTP-API erfüllt alle REST-Bedingungen. Unsere einfache Übungs-API orientiert sich an REST: GET /api/v1/werte liefert Messwerte; eine alternative Rückgabe kann einen Fehlerstatus besitzen. '''Version v1''' im Pfad kennzeichnet hier eine vereinbarte Schnittstellenversion, keine allgemeine Pflicht.

'''Mini-Kontrolle:''' Markiere im Beispiel die Methode, den Pfad, den Statuscode und die Einheit. Erkläre einem Lernpartner, warum eine GET-Abfrage keine Maschine starten darf.

{{BR}}
= Strukturierte Daten und sichere Abfragen =

{{BR}}
== JSON verstehen und prüfen ==
'''JSON''' (JavaScript Object Notation) ist ein textbasiertes Format für strukturierte Daten. Ein Objekt verwendet Schlüssel und Werte; Texte stehen in doppelten Anführungszeichen, Zahlen nicht. Eine Liste steht in eckigen Klammern. JSON ist nur ein Format, kein Beweis für die Richtigkeit eines Messwerts.

<pre>
{
"bauteil": "LEHR-01",
"wert": 23.4,
"einheit": "mm",
"status": "synthetisch"
}
</pre>
Prüfe in dieser Reihenfolge: (1) Ist die Antwort erfolgreich? (2) Ist sie syntaktisch gültiges JSON? (3) Sind erwartete Felder vorhanden und haben sie den richtigen Typ? (4) Ist die Einheit erlaubt? (5) Ist der Wert plausibel? '''Syntaxprüfung''' und '''Fachprüfung''' sind verschiedene Schritte: Der Text {"wert":"viel"} kann formal gültiges JSON sein, obwohl er keinen verwendbaren Zahlenwert enthält.

[[File:Web API diagram.svg|430px|frameless|center|alt=Web-API-Skizze: Anfragender Client, Server und Antwort im JSON-Format]]
''Bild: Web-API überträgt strukturierte Antwort; I.hate.spam.mail.here, CC0 1.0. Ohne Bild: Der Server gibt nach einer Anfrage ein JSON-Objekt an den Client zurück.''

[[File:JSON vector logo.svg|180px|frameless|center|alt=Schwarz-graues JSON-Logo als visuelles Erkennungszeichen]]
''Bild: JSON-Wortbildmarke, Douglas Crockford zugeschrieben, einfache Formen als gemeinfrei gekennzeichnet; Logo ist keine Qualitätsgarantie.''

{{BR}}
== Sicherheit begrenzt die Befugnis des Clients ==
Der Lehr-Client darf nur einen festen lokalen Host und die im Unterricht freigegebenen '''GET-Endpunkte''' ansprechen. Das ist '''Allowlisting''': Nur vorher festgelegte Ziele sind erlaubt. Nutze synthetische Werte, keine realen Zugangsdaten oder personenbezogenen Messdaten. Prüfe auch bei vermeintlich vertrauenswürdigen KI-Ausgaben Pfad, Methode, erlaubte Aktion, Datentypen und Folgen. Eine KI kann irrtümlich einen Schreibaufruf vorschlagen, ohne dafür befugt zu sein.

Für echte externe Dienste wären unter anderem angemessene Authentifizierung, Transportverschlüsselung, Berechtigungen, Datenminimierung und Protokollierung zu prüfen; diese lokale Übung benötigt keine Tokens. '''MCP''' kann KI-Anwendungen mit Werkzeugen verbinden; dabei gelten zusätzliche Risiken wie übertragene Berechtigungen, Angriffe auf lokale Dienste und unzulässige Weiterleitung von Tokens. Dieser Kurs benutzt MCP nur als '''Recherche- und Reflexionsthema''', nicht als Verbindung zu Maschinen.

{{BR}}
== Medieneinstieg mit Alternative ==
'''Deutschsprachiges Lernvideo zu JSON:''' {{#ev:youtube|https://www.youtube.com/watch?v=BUFN0WMVW3k|500|center}}
''Programmieren Starten, „Was ist JSON? Einfach und schnell erklärt!“, veröffentlicht 18.11.2019. Die Metadaten sind recherchiert; eine durchgehende Wiedergabe konnte nicht unabhängig getestet werden. Rechte am Video verbleiben beim Urheber; keine OER-Lizenz behauptet. Alternative ohne Video: Lies die beiden JSON-Beispiele, unterstreiche Schlüssel und markiere Zahlenwerte.''

{{BR}}
= Geführter Modellfall: Lokaler Messdaten-Testdienst =

{{BR}}
== Die Lernaufgabe und der Vertrag ==
Ein rein erfundenes Kunststoff-Lehrbauteil trägt die Kennung LEHR-01. Sein synthetischer Testwert beträgt 23,4 mm; er darf niemals mit einem realen Prüfprotokoll verwechselt werden. Du arbeitest ausschließlich auf deinem eigenen Computer. Ein bereits eingerichteter lokaler Dienst kann mit vier GET-Pfaden antworten:

{| class="wikitable"
! Lokaler Pfad !! Erwartete Antwort !! Geplanter Test
|-
| /api/v1/werte || Status 200, gültiges JSON mit 23,4 mm || Normalfall
|-
| /api/v1/ungueltig || Status 200, beschädigter JSON-Text || Parsingfehler
|-
| /api/v1/langsam || Antwort nach 2 Sekunden || Timeout bei Limit 1 Sekunde
|-
| /api/v1/nichtbereit || Status 503 || Vorübergehend nicht verfügbar
|}

'''Lehrvertrag v1:''' Der Client kennt ausschließlich den Host 127.0.0.1 und Port 8765, fordert die oben definierten Daten über GET an, nutzt ein Zeitlimit von 1 Sekunde, wiederholt nur begrenzt und meldet jeden Abbruch. Ein Status 200 allein gilt nicht als fachlicher Erfolg. Der sichtbare Messwert ist niemals eine Freigabe.

{{BR}}
== Schrittfolge ohne Programmierkenntnisse ==
# [[Anforderung]]: Zeichne vier Kästchen: Client → GET-Anfrage → lokaler Dienst → Antwort. Beschrifte den erlaubten Datenfluss.
# [[Datensatz]]: Schreibe drei Spalten auf: Feld, Typ, erwartete Bedeutung. Beispiel „wert – Zahl – synthetische Länge“.
# [[Testfall]]: Ziehe für jeden Pfad eine Karte. Notiere vorher erwartete Reaktion und danach beobachtete Reaktion. Ohne Computer darfst du vorgegebene Antwortkarten verwenden.
# [[Fehlerbehandlung]]: Schreibe einen Wenn-dann-Satz je Fall: Bei Timeout abbrechen oder nur begrenzt erneut lesen; bei defektem JSON keine Zahl ausgeben; bei wiederholtem 503 endgültig stoppen.

{{BR}}
== Optional: Lokalen Testdienst selbst starten ==
Wenn Python 3 bereits auf dem Schulrechner installiert ist, speichere folgenden '''öffentlichen Lehrbeispielcode ohne Echtdaten''' als dienst.py. Er verwendet nur die Python-Standardbibliothek. Eine Lehrkraft kann ihn vorher freigeben; andernfalls bleiben die Kartenübungen vollständig nutzbar.

<pre>
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import time

class Dienst(BaseHTTPRequestHandler):
def do_GET(self):
if self.path == "/api/v1/langsam":
time.sleep(2)
if self.path == "/api/v1/nichtbereit":
status, body = 503, b'{"fehler":"nicht bereit"}'
elif self.path == "/api/v1/ungueltig":
status, body = 200, b'{"wert":23.4,'
elif self.path in ("/api/v1/werte", "/api/v1/langsam"):
status = 200
body = json.dumps({
"bauteil": "LEHR-01", "wert": 23.4,
"einheit": "mm", "status": "synthetisch"
}).encode("utf-8")
else:
status, body = 404, b'{"fehler":"unbekannt"}'
try:
self.send_response(status)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
except (BrokenPipeError, ConnectionResetError):
pass

ThreadingHTTPServer(("127.0.0.1", 8765), Dienst).serve_forever()
</pre>

Starte ihn lokal mit „python dienst.py“ beziehungsweise „python3 dienst.py“ und halte das Terminal geöffnet. Der Dienst ist nur an die Loopback-Adresse gebunden und implementiert keine POST-, PUT- oder DELETE-Funktion. Beende ihn mit Strg+C. '''Wichtig:''' Vor dem Start fremder Codes gelten lokale Schul- und IT-Regeln; kein externer Server ist Teil dieser Aufgabe.

{{BR}}
== Prüfprotokoll mit konkreten Erwartungen ==
{| class="wikitable"
! Fall !! Erwartung !! Warum?
|-
| Normalfall || 200 + JSON + Zahl 23,4 mm; als „synthetisch“ markieren || Transport, Struktur und fachliches Schema passen
|-
| Timeout || Nach höchstens etwa 1 s pro Versuch kontrollierter Fehler; maximal zwei Versuche || Ein Hänger blockiert die App nicht unbegrenzt
|-
| Ungültiges JSON || Parsingfehler melden, keine Zahl anzeigen, nicht blind wiederholen || Eine Wiederholung repariert keine sicher bekannte Formatverletzung
|-
| Dauerhaft 503 || Maximal zwei Leseversuche, dann „Dienst nicht bereit“ || Begrenzte Wiederholung schont Ressourcen
|}

Die gemessene Gesamtdauer kann geringfügig über der Summe der Zeitlimits liegen, weil Planung, Rückgabe und Pausen Zeit benötigen. Ein Zeitlimit gilt für die jeweiligen Netzoperationen, nicht automatisch als harte Gesamtdauer aller Arbeitsschritte.

{{BR}}
= Lesenden Client entwickeln und testen =

{{BR}}
== Drei Fehlerregeln statt endloser Versuche ==
'''Timeout:''' Der Client wartet nicht grenzenlos. '''Ungültiges JSON:''' Der Client darf trotz HTTP 200 keine Messzahl erfinden und muss den Unterschied zwischen erfolgreichem Transport und fehlerhaftem Inhalt zeigen. '''Wiederholungsgrenze:''' Wiederhole bei dieser Leseschnittstelle höchstens '''einmal''' nach dem ersten fehlgeschlagenen Versuch, also insgesamt höchstens '''zwei Versuche'''. Wiederhole nur festgelegte vorübergehende Fehler (Zeitüberschreitung oder 503); nicht 404, nicht beschädigtes JSON und nicht Schemafehler. In produktiven Anwendungen kommen Backoff, Jitter, serverseitige Hinweise, Idempotenz und Gesamtbudgets hinzu. Die hier gezeigte kurze Pause ist eine didaktische Vereinfachung, keine universelle Wiederholungsstrategie.

{{BR}}
== Optional: Ein ausführbarer Python-Client ==
Speichere als client.py. Der erlaubte Pfad wird intern aus einer festen Auswahl gewählt. Nutze zum Wechseln zwischen den vier Fällen ausschließlich die Variable FALL. Der Code hat keine Schnittstelle für eine frei von KI eingegebene Adresse.

<pre>
import json
import math
import socket
import time
import urllib.error
import urllib.request

PFADE = {
"normal": "/api/v1/werte",
"timeout": "/api/v1/langsam",
"json": "/api/v1/ungueltig",
"dienst": "/api/v1/nichtbereit"
}
FALL = "normal"
URL = "http://127.0.0.1:8765" + PFADE[FALL]
MAX_VERSUCHE = 2

for versuch in range(1, MAX_VERSUCHE + 1):
try:
anfrage = urllib.request.Request(
URL, method="GET",
headers={"Accept": "application/json"}
)
with urllib.request.urlopen(anfrage, timeout=1.0) as r:
roh = r.read(4096)
if r.read(1):
raise ValueError("Antwort zu gross")
daten = json.loads(roh.decode("utf-8"))
if not isinstance(daten, dict):
raise ValueError("JSON-Objekt erwartet")
wert = daten.get("wert")
if (type(wert) not in (int, float)
or not math.isfinite(wert)
or daten.get("einheit") != "mm"
or daten.get("status") != "synthetisch"
or daten.get("bauteil") != "LEHR-01"):
raise ValueError("Unpassendes Datenschema")
print("Synthetischer Lehrwert:", wert, "mm")
break
except json.JSONDecodeError:
print("STOPP: Ungueltiges JSON, keine Zahl ausgeben")
break
except (UnicodeDecodeError, ValueError) as fehler:
print("STOPP: Inhalt ungueltig:", fehler)
break
except urllib.error.HTTPError as fehler:
if fehler.code != 503 or versuch == MAX_VERSUCHE:
print("STOPP: HTTP-Status", fehler.code)
break
print("Dienst 503; ein begrenzter neuer Versuch")
except (urllib.error.URLError, TimeoutError,
socket.timeout) as fehler:
if versuch == MAX_VERSUCHE:
print("STOPP: Verbindung/Zeitlimit:", fehler)
break
print("Zeit-/Verbindungsfehler; letzter Versuch")
if versuch < MAX_VERSUCHE:
time.sleep(0.2)
</pre>

'''Ablauf:''' Starte erst dienst.py, dann client.py. Teste nacheinander FALL = "normal", "timeout", "json" und "dienst". Trage je Test ein: angefragter Pfad, beobachteter Status beziehungsweise Fehlertyp, Anzahl Versuche, Endmeldung. In einfachen Python-Versionen kann die genaue Ausnahme bei Netzfehlern variieren; wichtig sind '''begrenzter Abbruch und kein erfundener Messwert'''. Der Code setzt Python 3 mit Standardbibliothek voraus, nutzt keine externe KI und sendet nichts ins Internet. Auch eine erfolgreiche Demonstration ist kein Sicherheitstest für Maschinen.

{{BR}}
== KI-Agenten als überprüfbare Helfer ==
Ein '''KI-Agent''' ist hier ein assistierendes System, das Text oder Vorschläge für mehrere Arbeitsschritte erzeugen kann. Du darfst den folgenden Auftrag auch als Rollenspiel ohne KI bearbeiten: „Lies nur Daten aus der lokalen Lehr-API. Schlage GET-Anfragen, erwartete Statuscodes und drei Fehlerfälle vor. Fordere keine Schlüssel an, öffne keine fremden Hosts, nutze keinen Schreibzugriff. Kennzeichne Unsicherheiten.“

Prüfe einen Vorschlag mit '''fünf Leitfragen''': Stimmt der Endpunkt? Ist die Methode nur lesend? Sind Felder und Einheiten vereinbart? Sind Timeout, beschädigtes JSON und Versuchszahl berücksichtigt? Wer trägt die Verantwortung für die Entscheidung? Ein KI-Text ist '''kein''' Beleg, dass der Dienst so funktioniert. Die tatsächliche lokale Beobachtung und das Prüfprotokoll haben Vorrang. Die eigene Begründung darf nicht an den Agenten delegiert werden.

{{BR}}
= Fehler begründen und auf neue Aufgaben übertragen =

{{BR}}
== Diagnose mit Entscheidungen ==
'''Fall A:''' Der Server antwortet nach zwei Sekunden. Bei clientseitigem Zeitlimit von einer Sekunde entstehen zwei begrenzte Fehlschläge. Gute Entscheidung: keine scheinbar gültige Messzahl anzeigen; den Abbruch dokumentieren. '''Fall B:''' HTTP 200, aber Body endet mitten in einer JSON-Struktur. Gute Entscheidung: als Formatfehler markieren und nicht so tun, als sei der Wert 23,4 bestätigt. '''Fall C:''' Beide Versuche liefern 503. Gute Entscheidung: stoppen statt eine dritte Anfrage zu schicken. '''Fall D:''' HTTP 200 und gültiges JSON, aber Einheit „kg“ statt „mm“. Gute Entscheidung: Schemaprüfung verweigert die Ausgabe eines Längenwerts.

{{BR}}
== Transferauftrag: Eine robuste Schnittstelle ohne Maschinenzugang ==
Stelle dir vor, ein Betrieb möchte später verschiedene Prüfwertdateien in eine lokale Trainings-App einlesen. Entwickle einen '''reinen Lesevertrag''': zulässige Routen, dokumentierte Einheit, Status- und Fehlerfälle, maximale Antwortgröße, Timeout, Wiederholungsregel, Testnachweis und bewusst ausgeschlossene Schreibaktionen. Entscheide, warum eine konkrete neue Anforderung freigegeben oder zurückgestellt wird. Schon wenn eine KI einen Befehl wie „schalte die Maschine frei“ formuliert, ist die richtige Reaktion: '''nicht ausführen, Kompetenzgrenze erklären und fachliche Zuständigkeit klären'''. Kein Kursbeispiel ersetzt betriebliche Freigabe, Qualifizierung oder eine Risikobeurteilung.

'''Vertiefung:''' Unterscheide einen 429-Status (zu viele Anfragen), einen lokalen Timeout und einen 503-Status. Berücksichtige, dass Wiederholung von verändernden Anfragen Nebenwirkungen haben kann; das Lehrbeispiel beschränkt sich daher absichtlich auf GET. Denke über Validierung, Protokoll ohne Geheimnisse, zusätzliche Obergrenzen und unsichere Agentenwerkzeuge nach.

{{BR}}
= Interaktive Aufgaben =

Bei den Multiple-Choice-Aufgaben liefert das Quizmodul nach deiner Auswahl Rückmeldung. Die jeweils richtige Antwort ist in der Lernansicht nicht als vorausgefüllte Lösung auszugeben.

{{BR}}
== Quiz: Schnittstellen sicher verstehen ==

{{MC}}
'''Was beschreibt eine API am treffendsten?'''
(Eine vereinbarte Schnittstelle für Daten und Funktionen)
(!Eine beliebige Datei ohne Regeln)
(!Eine dauerhafte Netzwerkverbindung ohne Antworten)
(!Eine Sicherheitsfreigabe für eine Maschine)
{{E}}

{{MC}}
'''Welche HTTP-Methode nutzt der lokale Lehr-Client ausschließlich?'''
(GET)
(!DELETE)
(!PUT)
(!POST)
{{E}}

{{MC}}
'''Welche Aussage trifft auf den Status 200 zu?'''
(Die HTTP-Anfrage wurde erfolgreich bearbeitet)
(!Alle fachlichen Messwerte sind garantiert korrekt)
(!Der Client hat automatisch eine Maschinenfreigabe)
(!Jedes JSON-Feld ist garantiert vorhanden)
{{E}}

{{MC}}
'''Woran erkennst du syntaktisch fehlerhaftes JSON?'''
(Eine notwendige schliessende Klammer fehlt)
(!Ein gueltiger Zahlenwert kommt vor)
(!Ein Objektschluessel enthaelt Text)
(!Die Einheit wird als Zeichenkette geschrieben)
{{E}}

{{MC}}
'''Warum prüft der Client eine Einheit?'''
(Damit ein Zahlenwert fachlich richtig eingeordnet wird)
(!Damit der HTTP-Status automatisch auf 200 springt)
(!Damit er das Internet ohne Erlaubnis nutzen darf)
(!Damit jede Wiederholung erfolgreich wird)
{{E}}

{{MC}}
'''Was bedeutet eine lokale Zeitüberschreitung?'''
(Der Client erhielt in der festgelegten Wartezeit kein ausreichendes Ergebnis)
(!Der Server hat zwingend den HTTP-Code 408 geschickt)
(!Das JSON ist sicher syntaktisch falsch)
(!Der gelesene Zahlenwert muss null sein)
{{E}}

{{MC}}
'''Wie viele Versuche erlaubt der Lehr-Client insgesamt?'''
(Zwei)
(!Unbegrenzt viele)
(!Mindestens zehn)
(!Immer genau fuenf)
{{E}}

{{MC}}
'''Was soll der Client bei beschädigtem JSON tun?'''
(Fehler melden und keinen scheinbar gueltigen Wert anzeigen)
(!Fehlende Zeichen frei erfinden)
(!Den Inhalt als Maschinenfreigabe bewerten)
(!Jede Anfrage unendlich oft wiederholen)
{{E}}

{{MC}}
'''Welche Maßnahme begrenzt das Ziel einer Agentenabfrage?'''
(Eine feste Liste erlaubter lokaler Pfade)
(!Eine beliebige vom Agenten erfundene Internetadresse)
(!Das Abschalten der Datentyppruefung)
(!Die Freigabe aller HTTP-Methoden)
{{E}}

{{MC}}
'''Welcher Transfer bleibt innerhalb des Kursrahmens?'''
(Einen lesenden Testvertrag mit synthetischen Daten pruefen)
(!Einen echten Antrieb direkt ansteuern)
(!Eine betriebliche Sicherheitsfreigabe automatisch ausstellen)
(!Echte geheime Zugangsdaten in einen Prompt kopieren)
{{E}}

{{BR}}
== Memory: Begriffe und Erklärungen ==
<div class="memo-quiz">
{|
|-
| API || Vereinbarter Zugang zwischen Programmen
|-
| Endpunkt || Adresse einer konkreten Schnittstellenoperation
|-
| Header || Zusatzinformationen einer HTTP-Nachricht
|-
| JSON || Textformat strukturierter Daten
|-
| Timeout || Erreichen einer festgelegten Wartegrenze
|-
| Allowlist || Vorher bestimmte erlaubte Ziele
|}
{{E}}

{{BR}}
== Drag and Drop: Fehler und Reaktion ==
<div class="lueckentext-quiz">

{| class="wikitable"
! Ordne die passende Reaktion zu.
! Beobachtung
|-
| '''Keine Zahl ausgeben'''
| Beschädigte JSON-Antwort
|-
| '''Wartezeit begrenzen'''
| Sehr langsamer lokaler Dienst
|-
| '''Nach zwei Versuchen stoppen'''
| Wiederholt vorübergehend nicht bereit
|-
| '''Einheit zurückweisen'''
| Kilogramm statt Millimeter
|-
| '''Nur lokale Pfade zulassen'''
| Agent schlägt fremden Server vor
|}
{{E}}

{{BR}}
== Kreuzworträtsel: API-Fachwörter ==
<div class="kreuzwort-quiz">
{|
|-
| Client || Welches Programm startet die Abfrage?
|-
| Server || Welches Programm beantwortet die Anfrage?
|-
| Methode || Wie heißt das Anfragefeld für GET oder POST?
|-
| Header || Wie nennt man HTTP-Zusatzinformationen?
|-
| Timeout || Welcher Begriff steht für eine erreichte Wartegrenze?
|-
| Schema || Welche Beschreibung legt Felder und erwartete Typen fest?
|}
{{E}}

{{BR}}
== LearningApps: Weitere Zuordnungen ==
<iframe> https://learningapps.org/index.php?s=APIs+verstehen+und+mit+KI-Agenten+verwenden </iframe>
''Du kannst dort nach passenden Übungen suchen; einzelne Suchtreffer sind nicht vorab didaktisch oder rechtlich geprüft. Offline-Alternative: Nutze die Memory- und Drag-and-Drop-Paare dieser Seite als Papierkarten.''

{{BR}}
== Lückentext: Sichere Abfragen ==
<quiz display=simple>
{'''Setze die Fachbegriffe passend ein.'''<br>
|type="{}"}
Ein Programm, das Daten anfordert, heißt { Client }. Ein Dienst, der sie bereitstellt, heißt { Server }. Für unsere ausschließlich lesende Anfrage verwenden wir { GET }. Der HTTP-Erfolgscode unseres Normalfalls ist { 200 }. Strukturierte Daten des Testdienstes sind im Format { JSON }. Ein begrenztes Warten heißt { Timeout }. Ein fehlendes Zeichen kann einen { Syntaxfehler } verursachen. Eine fachliche Prüfung kontrolliert auch die { Einheit }. Die festgelegte Obergrenze verhindert endlose { Wiederholungen }. Ohne Maschinenzugang bleibt das Ergebnis eine reine { Simulation }.
</quiz>

{{BR}}
= Offene Aufgaben =

{{BR}}
=== Leicht ===
# [[Client-Server-Modell]]: Zeichne den Weg einer GET-Anfrage zum lokalen Testdienst und beschrifte beide Richtungen.
# [[HTTP-Statuscode]]: Schreibe für 200, 404 und 503 je einen selbst formulierten Satz mit einem erfundenen Beispiel.
# [[JSON]]: Markiere in zwei synthetischen Datenobjekten die Schlüssel, die Zahl und die Einheit; erkläre jedes Feld.
# [[Schnittstelle]]: Erstelle eine Steckkarte für /api/v1/werte mit Methode, erwarteter Antwort und Verbot von Schreibzugriff.

{{BR}}
=== Standard ===
# [[Testprotokoll]]: Teste den Normalfall und dokumentiere Erwartung, Beobachtung, Wert und Einheitenprüfung.
# [[Timeout]]: Simuliere den langsamen Pfad mit Karten oder Python und begründe die feste Wartegrenze.
# [[Fehlerbehandlung]]: Untersuche ungültiges JSON und begründe, warum der Client trotz Status 200 keine Zahl anzeigen darf.
# [[Wiederholungsstrategie]]: Zeige den zweimaligen 503-Fall und begründe, warum ein dritter Versuch unterbleibt.

{{BR}}
=== Schwer ===
# [[API-Design]]: Beschreibe einen zweiten synthetischen Lesedatensatz samt Ressourcenpfad, JSON-Schema und plausiblen Fehlern.
# [[Validierung]]: Entwickle drei Tests für gültiges JSON mit fehlendem Feld, falscher Einheit oder ungeeignetem Datentyp.
# [[KI-Agent]]: Prüfe eine selbst erfundene problematische KI-Empfehlung mit einer Allowlist und begründe deine Ablehnung.
# [[Risikomanagement]]: Vergleiche zwei Fehlerstrategien, diskutiere Timeout und Wiederholungsbudget und dokumentiere die sichere Grenze ohne Maschinenzugang.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= Lernkontrolle =
# [[Schnittstellenvertrag]]: Begründe, warum ein HTTP-Status allein keine fachlich gültige Messung nachweist.
# [[Timeout-Behandlung]]: Erkläre bei zwei langsam beantworteten GET-Abfragen die erwartete Reaktion und die Versuchszahl.
# [[JSON-Validierung]]: Vergleiche defektes JSON mit formal gültigem JSON falscher Einheit und begründe unterschiedliche Prüfungen.
# [[Fehlerstrategie]]: Entscheide bei 404, 503 und lokalem Timeout, wann eine Wiederholung im Lehrvertrag sinnvoll ist.
# [[KI-Sicherheit]]: Erkläre, warum ein Agentenvorschlag keine Berechtigung erzeugt und weshalb ein fremder Host zurückzuweisen ist.
# [[Transfer]]: Beschreibe eine neue lokale Leseschnittstelle und dokumentiere zwei Negativtests und ihre Bedeutung.

{{BR}}
= Lernnachweis =
'''Abzugeben ist ein prüfbares Portfolio''', alternativ vollständig handschriftlich mit Antwortkarten: (1) einseitiger Schnittstellenvertrag für den lokalen lesenden Dienst, (2) Ablaufdiagramm vom GET bis zur geprüften Anzeige, (3) Client als Python-Datei oder gleichwertiger ausführlicher Entscheidungsgang, (4) Tabelle mit vier Testfällen Normalfall, Timeout, defektes JSON und wiederholter 503, (5) eigene Begründung zu '''Timeout behandeln, ungültiges JSON erkennen, Wiederholungen begrenzen''' und (6) begründete Abgrenzung gegen Maschinenzugang und Agenten-Selbstfreigabe.

'''Beurteilungskriterien:''' fachlich richtige HTTP-/JSON-Begriffe; reproduzierbare Eingaben und erwartete Ausgaben; keine unerkannte Falschanzeige; maximal zwei Versuche; belegbarer Abbruch; selbstständige und verständliche Entscheidungen. Ein Screenshot allein genügt nicht. Keine realen Studierenden-, Betriebs- oder Messdaten einreichen. '''Selbstkontrolle:''' Kann eine andere Person mit denselben Testfällen deinen Ablauf nachvollziehen, ohne einen externen Dienst zu verwenden?

{{BR}}
= OER und Wikipedia =
'''Quellenstand: 22.10.2026; Versionsangaben, soweit an der Quelle ersichtlich.''' Internetseiten und Videowiedergabe können sich verändern. Die MOOCwiki-Grundlagenseite mit curid=60654 war während der Recherche nicht zuverlässig abrufbar; ihr Inhalt wird nicht ungeprüft zusammengefasst.

* [https://developer.mozilla.org/de/docs/Web/HTTP/Guides/Overview MDN: Überblick über HTTP] – deutschsprachige technische Erläuterung zu Anfrage, Antwort, GET und Statuscodes (Online-Dokumentation, laufende Pflege).
* [https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status MDN: HTTP response status codes] – Definitionen nach HTTP-Standards, insbesondere 200, 404, 503 (laufende Dokumentation).
* [https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch MDN: Using the Fetch API] – Statusprüfung und fehlerbewusster Datenabruf (laufende Dokumentation).
* [https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf NIST AI 600-1, Generative AI Profile] – Juli 2024, Risiko- und Verantwortungsrahmen, keine Softwarefreigabe.
* [https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices MCP Security Best Practices] – Dokumentationspfad 2026-07-28, zusätzliche Sicherheitsrisiken bei Agenten-Werkzeugzugriff; keine Behauptung, dass MCP selbst hier installiert sein müsse.
* [https://de.wikipedia.org/wiki/Representational_State_Transfer Wikipedia: Representational State Transfer] und [https://de.wikipedia.org/wiki/JavaScript_Object_Notation Wikipedia: JSON] – offene Vertiefungen; Artikelversionen ändern sich.
* [https://moocwiki.org/index.php?curid=60654 Vorhandener Lernbaustein] – Grundlagenanker; nicht als verifiziertes Zitat benutzt.

'''Nachgewiesene Wikimedia-Commons-Dateiseiten und Rechte:'''
{| class="wikitable"
! Eingebundene Datei !! Echte Dateiseite !! Urheber !! Kennzeichnung
|-
| File:Client-server model.svg || [https://commons.wikimedia.org/wiki/File:Client-server_model.svg Commons] || Lubaochuan || [https://creativecommons.org/licenses/by-sa/4.0/ CC BY-SA 4.0]
|-
| File:HTTP-Anfrage.svg || [https://commons.wikimedia.org/wiki/File:HTTP-Anfrage.svg Commons] || Sébastien Santoro/Dereckson; Kulandru mor || [https://commons.wikimedia.org/wiki/File:HTTP-Anfrage.svg Gemeinfrei laut Dateiseite]
|-
| File:Web API diagram.svg || [https://commons.wikimedia.org/wiki/File:Web_API_diagram.svg Commons] || I.hate.spam.mail.here || [https://creativecommons.org/publicdomain/zero/1.0/ CC0 1.0]
|-
| File:JSON vector logo.svg || [https://commons.wikimedia.org/wiki/File:JSON_vector_logo.svg Commons] || Douglas Crockford || [https://commons.wikimedia.org/wiki/File:JSON_vector_logo.svg Gemeinfreies einfaches Logo laut Commons; Markenrecht gesondert prüfen]
|}
'''Videoquelle:''' [https://www.youtube.com/watch?v=BUFN0WMVW3k Programmieren Starten: Was ist JSON?] (18.11.2019; reguläre YouTube-Nutzungsrechte, keine freie Nachnutzung zugesichert). Die Wiedergabe war beim Abruf der Videoseite nicht unabhängig bestätigbar. Die eingebettete Fremdquelle ist optional; sämtliche Lernziele und Tests funktionieren mit der Textalternative.

<iframe> https://de.m.wikipedia.org/wiki/Representational_State_Transfer </iframe>

'''Medienfreie Alternative:''' Verwende die beschriebenen Client-Server-Pfeile, die ausgeschriebene Beispielanfrage, die JSON-Textbeispiele und die vollständig lokalen Fehlerkarten. Weitere Audio- oder Animationsdateien sind nicht eingebettet, da keine ausreichend passende und verlässlich lizenzierte Quelle bestätigt wurde.

{{BR}}
= Verknüpfte Lernbereiche =
{| align=center
{{:D-Tab}}
'''[[Programmierschnittstelle|API und Datenvertrag]]'''
# [[Hypertext Transfer Protocol|HTTP und Statuscodes]]
# [[Representational State Transfer|REST und Ressourcen]]
# [[JavaScript Object Notation|JSON und Datenschema]]
# [[Fehlerbehandlung|Timeout und Wiederholungsbegrenzung]]
# [[Informationssicherheit|Berechtigungen und sichere Tests]]
# [[Künstliche Intelligenz|KI-Agenten kritisch prüfen]]
|}

[[Category:Sprache:Deutsch]]
[[Category:Locale:de-DE]]
[[Category:Informatik]]
[[Category:Berufsausbildung]]
[[Category:Anwendungsentwicklung]]
[[Category:Programmierschnittstelle]]
[[Category:IT-Sicherheit]]

{{BR}}
= aiMOOC-Projekte =
[[Category:AI_MOOC]] [[Category:GPT aiMOOC]]
{{MT}}

APIs verstehen und mit KI-Agenten verwenden - Versionsgeschichte

Glanz: AI MOOC Plugin 3a178de04ab78102f0e2b7c17ae1cc43