Erstellen von agentischen Workflows mit LangGraph und Granite

In diesem Tutorial untersuchen wir, wie Sie solche KI-Agenten-Workflows mithilfe von zwei wichtigen Tools erstellen können: LangGraph, ein Framework zum Erstellen graphbasierter Argumentationspfade und IBM Granite Modelle, ein robustes Modell, das diese Struktur ergänzt. Jeder Schritt im Workflow – ein sogenannter „Knoten“ – wird von einem Agenten bearbeitet, der in der Regel von großen Sprachmodellen unterstützt wird. Diese Agenten verändern ihren Status basierend auf Modell-Ausgaben oder bedingter Logik und bilden ein dynamisches, entscheidungsgesteuertes Diagramm.

Um diese Agenten-Workflows zum Leben zu erwecken, werden wir uns zwei wesentliche Komponenten genauer ansehen: LangGraph und das Granite-Modell.

LangGraph ist ein leistungsstarkes Framework, das die Entwicklung von KI-gestützten Workflows rationalisiert, indem es KI-Modelle als zustandsabhängige Agenten innerhalb eines Berechnungsdiagramms darstellt. Es ermöglicht Entwicklern, skalierbare, modulare Systeme aufzubauen, bei denen jeder Verhaltens- oder Entscheidungspunkt als Knoten im Graphen definiert wird.

Mit LangGraph können Sie:

• Das Verhalten jedes Agenten als eigenen Knoten definieren
• Algorithmen oder Modell-Ausgaben verwenden, um die nächsten Schritte zu bestimmen
• Den Status zwischen Knoten übertragen, um Speicher und Kontext zu erhalten
• Visualisieren, debuggen und kontrollieren Sie den Ablauf der Argumentation mit Leichtigkeit

Multi-Agent-Systeme und Frameworks wie LangGraph strukturieren bei der Anwendung für Aufgaben der generativen KI (gen AI) die Aufgabenausführung in der Regel entweder als sequenzielle oder bedingte Workflows. Egal, ob Sie mit LangChain, IBM Granite-Modellen, den GPT-Modellen von OpenAI oder anderen künstlichen Intelligenztools arbeiten, LangGraph hilft Ihnen, Ihren Workflow zur verbesserten Skalierbarkeit und Leistung zu optimieren.

LangGraph setzt einen modernen Ansatz zur Orchestrierung von KI-Technologien ein, indem es komplexe Workflows in modulare, intelligente Komponenten aufteilt. Im Gegensatz zu traditioneller Automatisierung oder Robotic Process Automation (RPA) ermöglicht LangGraph die dynamische, kontextsensitive Aufgabenausführung durch die Verwendung von Echtzeitlogik und -speicher. Hier sind die vier Schlüsselkomponenten, die dieses Framework ausmachen:

• Knoten: Knoten stellen einzelne Logik- oder Aktionseinheiten dar, z. B. das Aufrufen eines KI-Tools, das Abfragen von Datenquellen oder das Ausführen einer bestimmten Aufgabe. Sie sind ideal für die Automatisierung sich wiederholender Aufgaben innerhalb größerer Geschäftsprozesse.
• Edges: Edges definieren den Ablauf zwischen den Knoten und leiten an, wie Aufgaben verbunden und ausgeführt werden. Diese Struktur unterstützt eine flexible Entscheidungsfindung und ermöglicht die Anpassung von Workflows an die Ergebnisse.
• Bedingte Edges (zyklische Graphen): Zyklische Graphen ermöglichen Schleifen und bedingte Verzweigungen, sodass das System Knoten basierend auf Logik- oder Modellausgaben erneut aufrufen kann. Diese Funktion ist entscheidend für die Bewältigung iterativer Aufgaben und das Treffen fundierter Entscheidungen in dynamischen Umgebungen.
• Zustand (zustandsabhängige Graphen): Der Zustand fungiert als gemeinsam genutzter Speicher, der den Kontext beibehält und die Nutzung von Echtzeitdaten über Knoten hinweg ermöglicht. Diese Fähigkeit ermöglicht es LangGraph, über statische Abläufe hinauszugehen und adaptive, intelligente Fortschritte in der Workflow-Automatisierung zu unterstützen.

Zusammen befähigen diese Komponenten LangGraph dazu, die Art und Weise zu verändern, wie Unternehmen KI-gestützte Workflows entwerfen und ausführen, um die Lücke zwischen KI und realen Geschäftsprozessen zu schließen.

Granite-4.0-Tiny-Preview, wurde von IBM Research entwickelt und ist ein leichtgewichtiges und dennoch leistungsfähiges Open-Source-Sprachmodell, das zur Lösung komplexer Probleme und praktischer Aufgaben der Verarbeitung natürlicher Sprache (NLP) entwickelt wurde. Granite ist zwar kleiner als kommerzielle Modelle wie GPT-4, aber schnell, effizient und vollständig mit Hugging Face kompatibel, was es zu einer großartigen Wahl für Entwickler macht, die betriebliche Effizienz ohne Leistungseinbußen anstreben.

Granite zeichnet sich aus durch:

• Absichtsklassifizierung – Identifizierung von Benutzerzielen in Chatbots oder aufgabenbasierten Systemen
• Kreative Generation – Erstellung von Zusammenfassungen, Dialogen oder kurzen Inhalten
• Argumentation und Zusammenfassung – ideal für Workflows mit RAG oder Datenanalyse

In diesem Tutorial spielt das Granite-Modell eine wichtige Rolle in verschiedenen Phasen des agentischen Workflows und unterstützt sowohl die Problemlösung als auch die Inhaltserstellung. Aufgrund seines leichtgewichtigen Designs eignet es sich für reale Anwendungen, bei denen menschliche Eingriffe begrenzt und skalierbare Entwurfsmuster für die Erstellung effektiver KI-Lösungen für verschiedene Datensätze und Anbieter unerlässlich sind.

In diesem Tutorial erstellen wir einen agentischen Workflow, der als kreativer Assistent für das Schreiben kurzer animierter Drehbücher dient.

Ziel

Je nach Geschichtenentwurf des Benutzers kann der Agent:

• Identifizieren Sie das Genre und den Ton, der zur Geschichte passt
• Einen kurzen Handlungsentwurf erstellen
• Ihn auf eine Schlüsselszene erweitern (z. B. Höhepunkt oder Wendepunkt)
• Den Dialog für diese Szene im Drehbuchformat verfassen

Dieser Anwendungsfall veranschaulicht sowohl die Argumentationsfunktionen als auch die generativen Fähigkeiten eines Sprachmodells, das durch den kompositorischen Workflow von LangGraph strukturiert ist.

So funktioniert der Workflow

Jeder der folgenden Schritte wird als LangGraph-Knoten implementiert:

• Benutzereingabe: Der Benutzer liefert eine allgemeine Idee für eine Geschichte, um den Workflow zu initiieren.
• Stilerkennung (node_name – select_genre): Ein LLM analysiert die Eingabe, um das passende Thema und den passenden Ton für die Geschichte abzuleiten.
• Gliederungsgenerierung (node_name – generate_outline): Das LLM generiert eine kurze Zusammenfassung der Handlung, basierend auf dem ausgewählten Genre.
• Szenenschreiben (node_name – generate_scene):  Das LLM schreibt eine zentrale Szene in Prosa und erweckt die Geschichte zum Leben.
• Dialogschreiben (node_name – write_dialogue): Das LLM schreibt die Szene als formatierten Drehbuchdialog um, der für die Produktion oder weitere Bearbeitung geeignet ist.

Diese Knoten sind sekundär in einem LangGraph verbunden und das Modell bewegt sich durch sie, während es ein veränderliches Zustandsverzeichnis verschiebt.

Dieser Workflow schafft ein Gleichgewicht zwischen kreativer Generierung und struktureller Planung. Es werden die folgenden Beispiele demonstriert:

• LLM-Koordination durch LangGraph
• Mehrstufiges Storytelling mit minimalem manuellen Eingriff
• Kreative Automatisierung in einem Bereich, in dem die menschliche Vorstellungskraft unerlässlich ist

Es lässt sich auch gut skalieren. Sie können es leicht erweitern, indem Sie Überarbeitungsschritte, mehrere Szenengeneratoren oder sogar zeichenbasierte Verzweigungen hinzufügen.

Sie benötigen ein IBM Cloud-Konto für das Erstellen eines watsonx.ai Projekts.

Sie können zwar aus mehreren Tools wählen, aber dieses Tutorial führt Sie durch die Einrichtung eines IBM Kontos für die Verwendung eines Jupyter Notebook.

1. Melden Sie sich mit Ihrem IBM Cloud-Konto bei watsonx.ai an.
2. Erstellen Sie ein watsonx.ai-Projekt. Sie können Ihre Projekt-ID in Ihrem Projekt abrufen. Klicken Sie auf die Registerkarte Verwalten. Kopieren Sie dann die Projekt-ID aus dem Abschnitt Details der Seite Allgemein. Sie benötigen diese ID für dieses Tutorial.
3. Erstellen Sie ein Jupyter Notebook.

Dieser Schritt öffnet eine Notebook-Umgebung, in die Sie den Code aus diesem Tutorial kopieren können. Alternativ können Sie dieses Notebook auf Ihr lokales System herunterladen und als Asset in Ihr watsonx.ai Projekt hochladen. Weitere Granite-Tutorials finden Sie in der IBM Granite-Community. Dieses Tutorial ist auch auf GitHub verfügbar.

1. Erstellen Sie eine Instanz des watsonx.ai Runtime Service (wählen Sie den Lite-Plan als kostenlose Instanz).
2. Generieren Sie einen Schlüssel für eine Programmierschnittstelle (API).
3. Verknüpfen Sie den watsonx.ai Runtime Service mit dem Projekt, das Sie in watsonx.ai erstellt haben.

Diese Zelle installiert die Kernbibliotheken, die für die Verwendung des auf Hugging Face gehosteten IBM Granite-Modells erforderlich sind:

• transformers: Dies ist die Hauptbibliothek zum Laden und Interagieren mit vortrainierten Sprachmodellen, einschließlichgranite-4.0-tiny-preview .
• accelerate:  Hilft beim effizienten Laden von Modellen und der Geräteplatzierung, besonders nützlich für die nahtlose Nutzung von GPUs.

Die-q führt die Installation im Hintergrund aus und unterdrückt die ausführliche Ausgabe, um eine übersichtlichere Notebook-Oberfläche zu erzielen. Diese Bibliotheken sind für das Herunterladen des Modells und die effiziente Handhabung der Inferenz in diesem Tutorial unerlässlich.

Hinweis: Wenn Sie dieses Tutorial in einer virtuellen Umgebung ausführen und langgrapg nicht vorinstalliert haben, verwenden Sie pip install langgraph , um es in Ihrer lokalen Umgebung zu installieren.

Diese Zelle importiert alle Kernbibliotheken, die zum Erstellen und Ausführen des Agenten-Workflows benötigt werden:

AutoTokenizer undAutoModelForCausalLM vontransformers : Wird verwendet, um das Granite-Modell zu laden und Eingabe-Prompts für die Generierung in Token zu umwandeln.

torch : Bietet GPU-Beschleunigung und Tensoroperationen, die für die Modellinferenz erforderlich sind.

time: : Aktiviert optionale Zeitverfolgung und Leistungsüberwachung.

StateGraph undEND vonlanggraph.graph : Diese werden verwendet, um das agentische Workflow-Diagramm zu definieren und zu kompilieren.

IPython.display ,base64: Wird verwendet, um die Ausgabe sauber darzustellen und optionale Download-Funktionen für generierte Inhalte in Jupyter Notebooks zu aktivieren.

Zusammen bereiten diese Importe die Umgebung für die Modellinteraktion, die Strukturierung von Workflows und die Ausgabepräsentation vor.

Diese Zelle lädt das IBMgranite-4.0-tiny-preview -Modell und den entsprechenden Tokenizer von Hugging Face:

model_id: Gibt die Kennung für das vortrainierte Modell an, das auf Hugging Face gehostet wird.

AutoTokenizer.from_pretrained(model_id): Lädt den Tokenizer, der mit dem Granite-Modell verknüpft ist. Der Tokenizer ist dafür verantwortlich, von Menschen lesbaren Text in Token für das Modell umzuwandeln.

AutoModelForCausalLM.from_pretrained(...): Lädt das eigentliche Sprachmodell für die kausale (d. h. generative) Sprachmodellierung. Dieses Modell kann Ausgaben auf der Grundlage von Eingaben vorhersagen und generieren.

Dietorch_dtype=torch.float32 Das Argument setzt den Datentyp explizit auf float32, was speichereffizienter und allgemein kompatibler ist – besonders nützlich in GPU-beschränkten Umgebungen.

In diesem Schritt wird das Granite-Modell als „Argumentations-Engine“ hinter unserem agentischen Workflow initialisiert.

Diese Funktiongenerate_with_granite schließt den Textgenerierungsprozess unter Verwendung des Granite-Modells ab. Es akzeptiert den Prompt, also den Eingabetext, um die Antwort des Modells zu steuern.

max_tokens : Die maximale Anzahl von Token, die in der Ausgabe generiert werden sollen (Standard: 200).

use_gpu : Ein Flag, das angibt, ob Rückschlüsse auf der GPU ausgeführt werden sollen (falls verfügbar).

Wesentliche Details:

device = torch.device(...): Wählt dynamisch GPU (cuda) aus, falls angefordert und verfügbar. Andernfalls wird standardmäßig die CPU verwendet.

model.to(device): Lädt das Modell zur richtigen Zeit auf das entsprechende Gerät und hilft so dabei, Speicherplatz zu sparen.

tokenizer(prompt, return_tensors="pt"): Wandelt die Eingabezeichenfolge zur Modellverarbeitung in Token-Tensoren um.

model.generate(...): Startet die Textgenerierung mit Sampling-Strategien, die Folgendes umfassen:

• do_sample=True: Ermöglicht Zufälligkeit für kreativere Ausgaben.

• temperature=0.7 undtop_p=0.9: Steuert die Vielfalt des generierten Textes.

tokenizer.decode(...): Wandelt generierte Token wieder in lesbaren Text um und entfernt dabei alle speziellen Token.

Diese Funktion wird im gesamten agentischen Workflow wiederverwendet, um das Granite-Modell an verschiedenen Entscheidungs- oder Generierungsknoten aufzurufen.

Diese Funktionselect_genre_node definiert den ersten Knotenpunkt in unserem agentischen Workflow zum Verfassen des Drehbuchs. Es verwendet das Granite-Modell, um das Genre und den Ton der Geschichte auf der Grundlage der Eingaben des Benutzers zu bestimmen.

Eingabe:state , ein Wörterbuch, das Folgendes umfasst"user_input" (z. B. „Ich möchte eine skurrile Fantasy-Geschichte für Kinder schreiben“).

Prompt-Erstellung: Der Prompt fordert das Modell auf:

• Agieren Sie als kreativer Assistent.
• Analysieren Sie die Eingabe des Benutzers.
• Empfehlen Sie ein Genre und einen Ton, indem Sie ein bestimmtes Ausgabeformat verwenden:Genre: <genre> undTone: <tone>

Textgenerierung: Der Prompt wird an diegenerate_with_granite() Dienstprogrammfunktion weitergegeben, um eine kreative Antwort zu generieren.

Output-Parsing: Eine einfache Schleife extrahiert das Genre und den Ton aus der Antwort des Modells auf der Grundlage von Zeilenpräfixen ("Genre:" und"Tone:" ).

Statusaktualisierung: Die extrahiertengenre undtone Werte werden wieder in das Zustandsverzeichnis eingefügt, das an den nächsten Knoten weitergegeben wird.

Dieser Knotenpunkt fungiert als kreatives Klassifikationsmerkmal und ermöglicht es nachfolgenden Knotenpunkten, kontextuell abgestimmte Umrisse, Strukturen und Szenen zu erzeugen, indem Stil und Ton als grundlegende Parameter verwendet werden.

Diegenerate_outline_node Funktion definiert den zweiten Knoten im Workflow der Drehbuchverfassung. Er baut auf dem gewählten Genre und dem Ton auf, um eine prägnante Handlungsskizze für die Geschichte zu generieren.

Eingabe: Die Funktion empfängt das Zustandsverzeichnis mit:

• user_input: Die ursprüngliche Idee zur Geschichte.
• genre: Ausgewählt im vorherigen Knoten.
• ton: Ausgewählt im vorherigen Knoten.

Prompt-Erstellung: Das Modell wird angewiesen:

• Fungieren Sie als kreativer Schreibassistent.
• Berücksichtigen Sie die Idee, das Stil und den Tonfall des Benutzers.
• Erstellen Sie einen kurzen Handlungsentwurf (3–5 Sätze), der sich für ein kurzes animiertes Drehbuch eignet.

Textgenerierung: Der Prompt wird gesendet angenerate_with_granite() mit einem höherentoken limit (max_tokens=250) um Platz für eine Gliederung mit mehreren Sätzen zu schaffen.

Statusaktualisierung: Der generierte Handlungsüberblick wird dem Zustand unter dem Schlüssel hinzugefügt"outline" , um für die Nutzung in der nächsten Phase der Strukturerweiterung bereit zu sein.

Dieser Knotenpunkt übersetzt die abstrakte kreative Absicht in eine erzählerische Skizze und bietet ein Gerüst für die folgende detaillierte Drei-Akt-Struktur. Er stellt sicher, dass die nachgelagerten Knoten von einer kohärenten, einfallsreichen Ausgangsbasis arbeiten.

Diegenerate_scene_node Funktion definiert den dritten Schritt im Workflow, in dem die Handlungsübersicht in eine reichhaltige, erzählende Szene umgewandelt wird. Diese Szene dient als lebendige Dramatisierung eines Wendepunkts in der Geschichte und verlagert die Idee von der Zusammenfassung zur Erzählung.

Eingabe: Der Knoten verwendet das Zustandsverzeichnis, das nun Folgendes enthält:

• genre undtone
• Dieplot outline vom vorherigen Knoten

Prompt-Erstellung: Das Modell wird angewiesen:

• Fungieren Sie als Drehbuchautor
• Generieren Sie einen Wendepunkt oder einen Höhepunkt unter Verwendung dergenre ,tone undoutline
• Schreiben Sie im Prosaformat, um die Lesbarkeit und die animationsfreundliche Beschreibung zu erhalten

Szenenanforderungen:

• Anschaulich und beschreibend (geeignet für Animationen)
• Im Mittelpunkt des emotionalen oder erzählbaren Handlungsbogens (z. B. Entdeckung, Konflikt oder Lösung)

Textgenerierung:generate_with_granite wird aufgerufen mitmax_tokens=300 , wodurch genügend Platz für den immersiven Aufbau der Szene bleibt.

Zustandsaktualisierung: Die generierte Szene wird dem Zustandsverzeichnis unter dem"scene" Schlüssel hinzugefügt.

Es integriert narrative Immersion und visuelles Storytelling in den Workflow. Anstatt die Geschichte nur zusammenzufassen, erweckt dieser Knoten sie mit sensorischen und emotionalen Details zum Leben – eine wichtige Voraussetzung für das Schreiben von animierten Kurzfilmen.

Diewrite_dialogue_node Funktion definiert den vierten kreativen Schritt im Workflow des Storytellings: die Umwandlung einer erzählerischen Szene in einen formatierten Charakterdialog. Dieser Schritt überbrückt die Lücke zwischen der Prosa und dem Drehbuch und verleiht den Figuren eine Stimme.

Eingabe: Der Knoten erwartet, dass der Zustandscene einen lebhaften Moment der Geschichte enthält (in der Regel ein Wendepunkt oder Höhepunkt).

Prompt-Erstellung: Das Modell wird angewiesen:

• Fungieren Sie als Dialogautor
• Extrahieren und passen Sie Dialoge aus der Szene an
• Formatieren Sie die Ausgabe im Drehbuchstil, indem Sie Folgendes verwenden:CHARACTER: Dialogue line

Richtlinien für den Dialog:

• Kurz und ausdrucksstark
• Sicherstellen, dass es für die Animation geeignet ist (visuell, emotional, prägnant)
• Erfinden Sie gegebenenfalls Namen zur Verbesserung der Eindeutigkeit

Generieren: Diegenerate_with_granite() Aufrufverwendungmax_tokens=300 , die Ausdruckskraft mit Kürze in Einklang bringt – ideal für kurze animierte Drehbücher.

Zustandsaktualisierung: Der Dialog wird in dem Zustand unter demdialogue Schlüssel für weitere Schritte gespeichert (z. B. Anzeige oder Bearbeitung).

Diese Hilfsfunktionwith_progress wurde entwickelt, um jeden Workflow-Knoten mit Echtzeit-Fortschrittsindikatoren zu versehen. Die Logik der ursprünglichen Funktion wird nicht geändert – sie verfolgt lediglich den Ausführungsstatus und den Zeitplan und gibt sie aus, um lange Workflows transparenter zu gestalten.

Zweck der Funktion: Umschließen Sie einen Knoten (z. B. generat_scene_node) mit einem Decorator, der Folgendes protokolliert:

• Welcher Schritt wird gerade ausgeführt?
• Schrittindex und Gesamtanzahl
• Wie lange der Schritt dauert

Parameter

• fn : Die tatsächliche Knotenfunktion (z. B. write_dialogue_node)
• label : Eine von Menschen lesbare Bezeichnung für diese Funktion
• index : Schrittnummer in der Sequenz (z.B. 2)
• total : Gesamtzahl der Schritte im Workflow

Interner Wrapper:

• Druckt eine Startnachricht aus
• Zeichnet die Startzeit auf
• Ruft die ursprüngliche Funktion auf
• Druckt eine Abschlussmeldung mit verstrichener Dauer aus

Gibt zurück: Eine modifizierte Version der Funktion, die Fortschrittsmeldungen hinzufügt, sich aber ansonsten identisch verhält.

Wenn Workflows wachsen, ist es wichtig, zu verfolgen, welcher Schritt ausgeführt wird, insbesondere wenn einige Schritte (wie das Generieren oder Bearbeiten) länger dauern oder Probleme wie Speicherüberlastung verursachen können. Dieser Fortschrittswrapper sorgt für Transparenz und ist hilfreich für das Debugging und die Laufzeitdiagnose.

Diese Zelle definiert die Workflow-Logik für die Erstellung einer kurzen animierten Geschichte mithilfe von LangGraph, einem auf kompositorischen Diagrammen basierenden Programmier-Framework, das für LLM-Workflows entwickelt wurde. Jeder Schritt in der Grafik stellt eine kreative Aufgabe dar und wird in einer bestimmten Reihenfolge ausgeführt, um das endgültige Szenario zu produzieren.

Komponenten des Workflows:StateGraph(dict)  – Initialisiert den Workflow mit einem verzeichnisbasierten Zustand (d. h. das Arbeitsspeicher ist ein Wörterbuch, das von Knoten zu Knoten weitergegeben wird).

Knotenregistrierung mit Fortschrittsverfolgung: Jeder Schritt (Genreauswahl, Übersichtsgenerierung, Szenenschreiben, Dialogschreiben) wird als Knoten mit dem with_progress() Wrapper hinzugefügt - 

Dieser Ansatz stellt sicher, dass jeder Knoten bei der Ausführung seine Laufzeit und seinen Fortschritt protokolliert.

Workflow-Edges (Knotensequenz): Die Abfolge der kreativen Pipeline ist klar definiert:

set_entry_point() undset_finish_point(): Diese definieren die Start- und Endknoten des Workflows.

graph.compile(): Kompiliert den Workflow in eine ausführbare Form (Workflow), die nun mit einem ursprünglichen Zustand aufgerufen werden kann.

Diese Struktur ermöglicht einen modularen, lesbaren und fehlerbeseitigenden LLM-Workflow. Jede Phase in Ihrem kreativen Prozess ist isoliert, kann separat profiliert und später ausgetauscht oder erweitert werden (z. B. durch Hinzufügen eines Schritts „Szene überarbeiten“ oder eines Knotens „Ausgabe zusammenfassen“). Dieworkflow ist jetzt mit einem Prompt einsatzbereit, führt Ihre kreative Pipeline Schritt für Schritt aus und zeigt den Live-Fortschritt an.

In dieser letzten Codezelle führen Sie den gesamten kreativen Workflow aus und zeigen die Ergebnisse jeder Phase der Geschichtenverfassung an.

initial_state: Dieser Befehl ist der Ausgangspunkt des Workflows, bei dem der Benutzer eine kreative Idee oder ein kreatives Thema angibt. Die Benutzereingabe dient als Startwert für die Story-Pipeline.

final_state: Dieser Befehl löst die vollständige LangGraph-Pipeline aus. Die Eingabe wird nacheinander durch jeden registrierten Knoten (select_genre, generate_outline, generate_scene und write_dialogue) geleitet.

Ergebnisse anzeigen: Das Endzustandsverzeichnis enthält nun Schlüssel, die von verschiedenen Knoten aufgefüllt wurden:

• "genre": Das identifizierte Genre basierend auf Benutzereingaben.
• "tone": Die tonale Qualität der Geschichte.
• "outline": eine Inhaltszusammenfassung in drei bis fünf Sätzen.
• "scene": Eine anschauliche, in Prosa geschriebene Wendepunktszene.
• "dialogue": Charakterdialog, formatiert als Drehbuch.

Dieser Abschnitt zeigt, wie die Absicht des Benutzers durch einen schrittweisen, modularen LLM-Workflow in ein vollständiges Minidrehbuch umgewandelt wird. Es handelt sich um eine durchgängige kreative Pipeline, die interaktiv, interpretierbar und anpassbar ist.

Hinweis: Die Ausführung des Codes dauert etwa 15–17 Minuten, wenn Sie GPU oder TPU verwenden. In einer lokalen virtuellen Umgebung wird es etwa 65 bis 70 Minuten dauern, bis die Ausgabe ausgeführt und generiert ist, basierend auf der für die Ausführung des Cedes verwendeten Infrastruktur.

Sehen wir uns an, wie das System den Prompt des Benutzers – „Ich möchte eine skurrile Fantasy-Geschichte für Kinder schreiben über einen verlorenen Drachen, der wieder nach Hause findet“ – in eine vollständige animierte Geschichte umwandelt. Jeder Schritt baut auf dem vorherigen auf, wird von den kreativen Knotenpunkten des Workflows gesteuert und durch das Granite-Modell unterstützt.

1. Genre und Tonfall. Der Workflow beginnt mit der Interpretation der ursprünglichen Prompts des Benutzers: Ich möchte eine skurrile Fantasy-Geschichte für Kinder über einen verlorenen Dritten schreiben, der wieder nach Hause findet. Basierend auf dieser Eingabe klassifiziert der select_genre_node die Erzählung korrekt als skurrile Fantasy und ermittelt den passenden bezaubernden und herzlichen Ton. Dieses Ergebnis ist korrekt und auf den Kontext abgestimmt, da die Verwendung von Ausdrücken wie „skurril“ „für Kinder“ und „verlorener Drache findet wieder nach Hause“ eindeutig auf einen magischen und dennoch sanften Erzählstil hindeutet. Stilrichtung und Ton sind grundlegende Parameter, die jeden weiteren Schritt im Workflow prägen.

2. Inhaltsgliederung und Charakterbeschreibungen. Im nächsten Schritt wird das Modell gebeten, einen Handlungsentwurf zu erstellen, der auf dem identifizierten Stil, dem Ton und der ursprünglichen Idee des Benutzers basiert. Die Ausgabe beinhaltet nicht nur eine Zusammenfassung der Geschichte in 3–5 Sätzen, sondern auch zusätzliche Charakterbeschreibungen, wahrscheinlich aufgrund eines Prompt-Lecks oder der Beibehaltung der Formatierung von Anweisungen aus früheren Iterationen.

Die Handlung dreht sich um ein Mädchen namens Lily, das einen verwundeten Dritten entdeckt und ihm mithilfe eines alten Kräuterkundigen bei der Rückkehr in den Zauberwald hilft. Diese Handlung spiegelt genau die Absicht des Nutzers wider – sie konzentriert sich auf eine kinderfreundliche magische Reise mit emotionalen Untertönen über Heilung, Zugehörigkeit und Freundschaft. Die Charakterskizzen des Drachens, Lilys und des Kräuterkundigen sorgen für Tiefe und verwandeln eine vage Idee in ein strukturiertes Konzept mit definierten Rollen, Persönlichkeiten und erzählbaren Verantwortlichkeiten. Dieser Schritt stellt sicher, dass sich die Geschichte von der abstrakten Absicht zu einer konkreten Struktur verschiebt, die sich für die Adaption für die Leinwand eignet.

3. Schlüsselszene. Angesichts der vollständigen Handlungsübersicht würde dasgenerate_scene_node schreibt eine lebendige Szene im Prosaformat, die einen Wendepunkt in der Geschichte darstellt – ein weiteres Element, das in der ursprünglichen Absicht des Benutzers explizit gewünscht wurde, um ein kurzes Animationsdrehbuch zu entwickeln.

Der gewählte Moment ist der, in dem Lily den verwundeten Drachen im verzauberten Wald pflegt und so eine emotionale Beziehung und gegenseitiges Verständnis zwischen den Figuren herstellt. Dieser Moment ist kritisch, da er die Geschichte auf die Heimkehr des Drachen ausrichtet. Die Szene ist voller Bildern und Emotionen, hält sich an die „verspielten“ und „herzerwärmenden“ Beschränkungen und ist gleichzeitig visuell ausdrucksstark – perfekt geeignet für ein kurzes animiertes Format.

Die Fähigkeit des Modells, die Konstanz von Ton und Stil über alle Phasen hinweg beizubehalten, zeigt den Wert des Workflows von LangGraph und die Funktionen des Granite-Modells.

4. Dialog im Drehbuchformat. Schließlich wird diewrite_dialogue_node Prosaszene in einen strukturierten Dialog im Drehbuchformat umgewandelt. Der Prompt, der sich auf die Erstellung einer Geschichte für die Animation konzentriert, verlangt implizit, dass die Erzählung in einem Format präsentiert wird, das für die Produktion oder Visualisierung geeignet ist. Dieser Knoten erfüllt dieses Ziel, indem er einen gut formatierten Dialog zwischen Lily, Drago (dem Drachen) und dem alten Kräuterkenner in zwei verschiedenen Szenen bereitstellt: In der Hütte und im Zauberwald. Der Dialog behält emotionale Merkmale und die Absicht der Figuren bei und ist so formatiert, dass er den Konventionen zum Schreiben von Animationsdrehbüchern entspricht (z. B. Figurennamen in Großbuchstaben, Szenenüberschriften wie[INT. LILY’S COTTAGE - DAY]) Die Ausgabe bleibt kurz, ausdrucksstark und emotional ansprechend, was unerlässlich ist, um eine Zielgruppe in einer animierten Umgebung anzusprechen.

Jede Phase des Workflows übersetzt den ursprünglichen Prompt – „eine skurrile Fantasy-Geschichte für Kinder über einen verlorenen Drachen, der wieder nach Hause findet“ – in eine strukturierte, kreative und ausdrucksstarke narrative Ausgabe. Von der Genreauswahl bis zur Dialogformatierung baut das System schrittweise einen kohärenten Erzählbogen auf. Das LangGraph-Framework stellt sicher, dass die Übergänge zwischen den Aufgaben logisch miteinander verbunden sind, und das IBM Granite-Modell ermöglicht eine kontextabhängige Texterstellung mit einem einheitlichen Ton. Das Ergebnis ist eine kompakte, bildschirmtaugliche kurze Animationsgeschichte, die vollständig aus einer einzeiligen Benutzereingabe entsteht und die praktische Nutzbarkeit von agentischen Workflows in kreativen KI-Anwendungen demonstriert.

Um das Erzählen noch spannender zu machen, finden Sie hier eine einfache HTML-basierte Visualisierung, die generierte Story-Elemente – Genre, Ton, Handlung, Szene und Dialog – ansprechend formatiert. Außerdemkönnen Sie mit nur einem Klick das gesamte Skript als Textdatei zur späteren Verwendung oder Weitergabe herunterladen. Lassen Sie uns die Geschichte auf der Leinwand zum Leben erwecken!

Dieses Tutorial verwendet das Granite-4.0-Tiny-Preview Modell für die Textgenerierung. Obwohl es sich um eines der kleineren Modelle der Granite-Familie handelt, ist eine GPU-fähige Umgebung erforderlich, damit es effizient funktioniert – insbesondere bei der Ausführung mehrerer Knoten in einem LangGraph-Workflow.

Empfohlene Einrichtung:

• Mindestens eine NVIDIA V100- oder A100-GPU
• 16 GB GPU-Speicher oder mehr für effektive Leistung
• Python 3.8+ mit installierter Torch, Transformern und Langgraph

Leistungshinweise:

• Es kann zu CUDA-Out-of-Memory-Fehlern kommen, wenn Sie alle Knoten nacheinander ausführen, ohne den GPU-Speicher zu löschen.
• So minimieren Sie Speicherprobleme:
  • Verschieben Sie das Modell nur während der Generierung auf die GPU und anschließend zurück zur CPU.
  • Die Anzahl der generierten Token sollte moderat sein (max_tokens=200–300).
  • Optional können Knoten wie eine Überarbeitung oder eine detaillierte Szenenerweiterung entfernt oder vereinfacht werden.

Wenn Sie dieses Tutorial in einer gehosteten Notebook-Umgebung (z. B. IBM watsonx.ai oder Google Colab Pro) ausführen, stellen Sie sicher, dass die GPU in den Laufzeiteinstellungen aktiviert ist.

Berücksichtigen Sie bei ressourcenarmen Umgebungen Folgendes:

• Auslagerung der Modellinferenz an die Hugging Face Inference API.
• Reduzierung der Workflow-Komplexität.
• Verwendung der CPU (mit längeren Generierungszeiten).

In diesem Tutorial haben wir einen modularen, agentischen Storytelling-Workflow mit LangGraph und IBMs Granite-4.0-Tiny-Preview Sprachmodell erstellt. Ausgehend von einem einfachen kreativen Prompt haben wir Schritt für Schritt eine Pipeline entwickelt, die Stil und Ton klassifiziert, einen Handlungsentwurf entwickelt, eine Schlüsselszene schreibt und mit einem Dialog im Drehbuchstil endet. Auf dem Weg dorthin haben wir gezeigt, wie Sie:

• Dynamische Workflows mit LangGraph strukturieren
• Schlanke LLMs wie Granite für kreative Schlussfolgerungen integrieren
• GPU-Speicherbeschränkungen durch Ad-hoc-Laden von Modellen bewältigen
• Story-Ausgaben in einem benutzerfreundlichen Format anzeigen und exportieren

Dieses Framework eignet sich nicht nur für das Verfassen von Drehbüchern, sondern kann auch auf eine Vielzahl kreativer oder aufgabenbezogener Anwendungsfälle erweitert werden. Mit nur wenigen Knotenpunkten haben Sie einen Miniatur-Schreibassistenten entwickelt, der eine skurrile Idee in eine drehbuchreife Geschichte verwandelt.

Egal, ob Sie Entwickler, Geschichtenerzähler oder Forscher sind – dieses Tutorial bietet Ihnen eine praktische Grundlage, um LLM-basiertes Workflow-Engineering in kreativen Bereichen zu erkunden.

Sind Sie bereit, Ihre eigenen Agenten zu erstellen? Lassen Sie Ihrer Kreativität freien Lauf mit IBM Granite-Modellen und IBM watsonx Orchestrate.