Mein erster lokaler Agent

Was heute entsteht

Dein erster Agent — bewusst als Stufe-4-System (KI-gestützter Workflow, siehe KM6): Der Ablauf ist fest verdrahtet und damit vorhersehbar, nur das Zusammenfassen übernimmt die KI. Die Sicherheitsausstattung ist trotzdem die volle: eigene Ordner, Originale bleiben unangetastet, Protokoll, Not-Aus.

Keine Sorge wegen Python: Das Skript hat rund 80 Zeilen, jede Gruppe wird erklärt, und du tippst nichts ab — alles ist kopierbar.

Schritt 1: Python installieren

1. Lade Python von der offiziellen Quelle python.org (Download-Grundregeln aus KM4!) und starte den Installer.
2. Wichtig: Setze im ersten Dialog den Haken «Add python.exe to PATH» — sonst findet die PowerShell den Befehl nicht.
3. Prüfen (neues PowerShell-Fenster öffnen):

python --version

Erwartetes Ergebnis: eine Versionsnummer (Python 3.x). Rücksetzweg: Python lässt sich wie jedes Programm über Einstellungen → Apps wieder entfernen.

Schritt 2: Vorbereitung

Der Agent nutzt deine Ordnerstruktur aus KM4 (Eingang, Ausgang) — und deine lokale API: Starte LM Studio, lade dein Standardmodell, Server an (Kontrolle wie in KM4, Lektion 2).

Schritt 3: Das Agenten-Skript

Speichere den folgenden Code als ordner-agent.py in KI-Experimente (PowerShell-Weg: notepad "$HOME\KI-Experimente\ordner-agent.py" — Notepad fragt, ob es die Datei anlegen soll).

# ordner-agent.py — Dein erster lokaler Agent (Kurs-Mission 5)
# Ueberwacht den Eingangsordner, fasst neue .txt-Dateien mit der lokalen KI
# zusammen und speichert das Ergebnis im Ausgangsordner. Originale werden
# NIE veraendert. Not-Aus: Datei "STOP.txt" in den Eingangsordner legen.
import json
import time
import urllib.request
from pathlib import Path

# --- Einstellungen (bewusst am Anfang, damit du sie leicht anpassen kannst) ---
BASIS = Path.home() / "KI-Experimente"
EINGANG = BASIS / "Eingang"        # hier wird beobachtet (nur gelesen!)
AUSGANG = BASIS / "Ausgang"        # hier werden Zusammenfassungen abgelegt
PROTOKOLL = BASIS / "agent-protokoll.txt"
NOT_AUS = EINGANG / "STOP.txt"     # existiert diese Datei, stoppt der Agent
API = "http://localhost:1234/v1/chat/completions"   # deine lokale KI (KM4)
PRUEF_INTERVALL = 10               # Sekunden zwischen zwei Kontrollgaengen
MAX_ZEICHEN = 6000                 # Schutz: nicht mehr als ~2 Seiten ans Modell

def protokollieren(text: str) -> None:
    """Jede Aktion landet mit Zeitstempel im Protokoll UND auf dem Bildschirm."""
    zeile = time.strftime("%Y-%m-%d %H:%M:%S") + "  " + text
    print(zeile)
    with open(PROTOKOLL, "a", encoding="utf-8") as p:
        p.write(zeile + "\n")

def zusammenfassen(inhalt: str) -> str:
    """Schickt den Text an die lokale KI und gibt die Zusammenfassung zurueck."""
    anfrage = {
        "messages": [
            {"role": "system", "content": "Fasse den folgenden Text auf Deutsch in "
             "hoechstens fuenf Saetzen zusammen. Erfinde nichts dazu."},
            {"role": "user", "content": inhalt[:MAX_ZEICHEN]},
        ],
        "temperature": 0.3,
    }
    daten = json.dumps(anfrage).encode("utf-8")
    req = urllib.request.Request(API, data=daten,
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=300) as antwort:
        ergebnis = json.load(antwort)
    return ergebnis["choices"][0]["message"]["content"].strip()

def hauptschleife() -> None:
    AUSGANG.mkdir(parents=True, exist_ok=True)
    schon_verarbeitet = set()
    protokollieren("Agent gestartet. Beobachte: " + str(EINGANG))
    protokollieren("Not-Aus: Datei STOP.txt in den Eingangsordner legen.")

    while True:
        if NOT_AUS.exists():
            protokollieren("STOP.txt gefunden — Agent beendet sich sauber.")
            break

        for datei in sorted(EINGANG.glob("*.txt")):
            ziel = AUSGANG / (datei.stem + "-zusammenfassung.txt")
            # Nur neue Dateien; bereits vorhandene Ergebnisse nie ueberschreiben
            if datei.name in schon_verarbeitet or ziel.exists():
                continue
            protokollieren("Neue Datei erkannt: " + datei.name)
            try:
                inhalt = datei.read_text(encoding="utf-8", errors="replace")
                if not inhalt.strip():
                    protokollieren("Uebersprungen (leer): " + datei.name)
                    schon_verarbeitet.add(datei.name)
                    continue
                zusammenfassung = zusammenfassen(inhalt)
                ziel.write_text("Zusammenfassung von: " + datei.name + "\n"
                                + "Erstellt: " + time.strftime("%Y-%m-%d %H:%M") + "\n\n"
                                + zusammenfassung + "\n", encoding="utf-8")
                protokollieren("Zusammenfassung gespeichert: " + ziel.name)
            except Exception as fehler:
                # Fehler stoppen den Agenten nicht — sie werden gemeldet
                protokollieren("FEHLER bei " + datei.name + ": " + repr(fehler))
            schon_verarbeitet.add(datei.name)

        time.sleep(PRUEF_INTERVALL)

if __name__ == "__main__":
    hauptschleife()

Schritt 4: Verstehen, was du da laufen lässt

Die fünf Sicherheitsentscheidungen im Code — sie sind das eigentliche Lernziel:

1. Minimale Berechtigungen: Der Agent kennt genau zwei Ordner. Er liest nur Eingang, schreibt nur nach Ausgang — nirgendwo sonst hin.
2. Originale sind tabu: datei.read_text(...) liest nur. Es gibt im ganzen Skript keinen Befehl, der eine Eingangsdatei verändert oder löscht. Und if ziel.exists(): continue verhindert selbst das Überschreiben eigener Ergebnisse.
3. Protokollpflicht: Jede Aktion, jeder Fehler landet mit Zeitstempel in agent-protokoll.txt — dein Audit-Log im Kleinen.
4. Not-Aus: Eine Datei namens STOP.txt in Eingang legen — der Agent beendet sich beim nächsten Kontrollgang sauber. (Sofort-Stopp geht immer mit Ctrl + C im PowerShell-Fenster.)
5. Fehler brechen nichts: Eine kaputte Datei wird gemeldet und übersprungen — der Agent arbeitet weiter, statt mitten in der Nacht stehenzubleiben.

Schritt 5: Testlauf

1. Agent starten:

python "$HOME\KI-Experimente\ordner-agent.py"

2. Lege eine harmlose Textdatei in Eingang (z. B. einen kopierten Zeitungsartikel als test1.txt).
3. Beobachte das PowerShell-Fenster: Innert ~10 Sekunden meldet der Agent die Datei, kurz darauf die gespeicherte Zusammenfassung.
4. Öffne Ausgang\test1-zusammenfassung.txt — und vergleiche mit dem Original.
5. Not-Aus üben: Lege STOP.txt in Eingang. Der Agent verabschiedet sich sauber. Lies danach das Protokoll: Jeder Schritt ist nachvollziehbar.

Fehlerbehebung

• python wird nicht erkannt: PATH-Haken bei der Installation vergessen → Installer nochmals ausführen («Modify») oder py statt python versuchen.
• Fehler mit urlopen / Verbindung verweigert: Läuft der LM-Studio-Server? Stimmt der Port in der API-Zeile? Test: Invoke-RestMethod http://localhost:1234/v1/models.
• Zusammenfassungen sind wirr: Kleines Modell + langer Text. MAX_ZEICHEN verkleinern oder besseres Modell laden — der Agent selbst ist unschuldig (Beweis: Protokoll).
• Umlaute kaputt in der Ausgabe: Die Eingangsdatei war nicht UTF-8 — in Notepad «Speichern unter» → Codierung UTF-8 wählen.

Rücksetzweg

Ctrl + C bzw. STOP.txt → Skriptdatei löschen → fertig. Es gibt keine Installation, keinen Autostart, keine versteckten Reste. (Python selbst kannst du behalten — Kernmodul 7 und die Abschlussprojekte nutzen es wieder.)

Vertiefung: Warum Abfragen statt «echter» Ordnerüberwachung?

Profis nutzen oft Ereignis-Schnittstellen des Betriebssystems («sag mir sofort, wenn eine Datei kommt») statt regelmässigem Nachschauen (Polling). Für den Einstieg ist Polling die bessere Wahl: kein Zusatzpaket, glasklar nachvollziehbar, und zehn Sekunden Verzögerung spielen hier keine Rolle. Merke trotzdem den Begriff — bei grossen Datenmengen oder vielen Ordnern wird Ereignissteuerung zum Thema.

Kurz geprüft

3 Fragen zum Festigen — Feedback kommt sofort.

Warum ist dieser Agent «Stufe 4» und kein autonomer Agent?

Der Ablauf ist fest programmiert — nur das Zusammenfassen macht die KI.Niedrigste ausreichende Stufe (KM6): vorhersehbar und trotzdem intelligent.Weil er auf einem Notebook läuft.Die Hardware bestimmt die Stufe nicht — die Entscheidungshoheit tut es.

Was garantiert, dass Originaldateien unversehrt bleiben?

Der Code enthält schlicht keinen Schreib- oder Löschbefehl für den Eingangsordner.Die stärkste Sicherheit ist eine Fähigkeit, die gar nicht existiert.Die KI wurde angewiesen, vorsichtig zu sein.Anweisungen an Modelle sind keine Garantien — fehlende Befugnisse schon.

Der Agent meldet nachts einen FEHLER bei einer Datei. Was ist passiert?

Er hat die Datei übersprungen, den Fehler protokolliert und weitergearbeitet.Fehlertoleranz by design — und morgens liest du im Protokoll, welche Datei Aufmerksamkeit braucht.Er hat sich beendet und alles verworfen.Genau das verhindert der try/except-Block.

Das kann ich jetzt

• Ich habe einen lokalen Agenten gebaut, gestartet, beobachtet und sauber gestoppt.
• Ich kann die fünf Sicherheitsentscheidungen im Code zeigen — von minimalen Rechten bis Fehlertoleranz.
• Ich lese das Protokoll als das, was es ist: die Wahrheit darüber, was mein Agent getan hat.

Nächster Schritt: Kernmodul 7 seziert die Architektur und zeigt Testmodus, Erweiterungen und das Berechtigungsmodell im Detail.