Membangun alur kerja agen dengan LangGraph dan Granite

Dalam tutorial ini, kita akan menggali cara membangun alur kerja AI agen seperti itu menggunakan dua alat utama: LangGraph, kerangka kerja untuk membangun jalur penalaran berbasis bagan dan model IBM Granite, model tangguh yang melengkapi struktur ini. Setiap langkah dalam alur kerja—disebut "node"—ditangani oleh agen, biasanya didukung oleh model bahasa besar. Semua agen ini berganti status berdasarkan output atau logika bersyarat, membentuk bagan yang dinamis dan berbasis keputusan.

Untuk mewujudkan alur kerja agen ini, kita akan melihat lebih dekat dua komponen penting: LangGraph dan model Granite.

LangGraph adalah kerangka kerja efisien yang dirancang untuk merampingkan pengembangan alur kerja berbasis AI dengan menggambarkan model AI sebagai agen yang mempertahankan status percakapan dalam bagan komputasional. Hal ini memungkinkan pengembang untuk membangun sistem modular yang dapat diskalakan, di mana setiap perilaku atau titik keputusan ditetapkan sebagai sebuah node dalam bagan.

Dengan LangGraph, Anda dapat:

• Menentukan setiap perilaku agen sebagai node yang berbeda
• Menggunakan algoritma atau output untuk menentukan langkah selanjutnya
• Memberikan status di antara node untuk menjaga memori dan konteks
• Visualisasikan, debug, dan kendalikan alur penalaran dengan mudah

Sistem dan kerangka kerja multiagen seperti LangGraph, ketika diterapkan pada tugas AI generatif (gen AI), biasanya menyusun eksekusi tugas sebagai alur kerja berurutan atau bersyarat. Baik Anda bekerja dengan LangChain, model IBM Granite, model GPT dari OpenAI atau alat kecerdasan buatan lainnya, LangGraph membantu mengoptimalkan alur kerja Anda untuk skalabilitas dan kinerja yang lebih baik.

LangGraph memperkenalkan pendekatan modern untuk mengatur teknologi AI dengan memecah alur kerja yang kompleks menjadi komponen cerdas dan modular. Tidak seperti otomatisasi tradisional atau Otomatisasi proses Robotik (RPA), LangGraph memungkinkan eksekusi tugas yang dinamis dan sadar konteks dengan menggunakan logika dan memori real-time. Berikut adalah empat komponen kunci yang memberdayakan kerangka kerja ini:

• Node: Node menunjukkan tiap unit logika atau tindakan, seperti memanggil alat AI, menanyakan sumber data, atau melakukan tugas tertentu. Mereka ideal untuk mengotomatiskan tugas berulang dalam proses bisnis yang lebih besar.
• Garis penghubung: Garis penghubung menentukan alur antara node, memandu bagaimana tugas terhubung dan dijalankan. Struktur ini mendukung proses pengambilan keputusan yang fleksibel dan memungkinkan alur kerja beradaptasi berdasarkan hasil.
• Garis penghubung bersyarat (bagan siklus): Bagan siklus memungkinkan siklus dan percabangan bersyarat, sehingga sistem dapat meninjau kembali node berdasarkan logika atau output model. Kemampuan ini sangat penting untuk menangani tugas-tugas berulang dan membuat keputusan berdasarkan informasi dalam lingkungan yang dinamis.
• Status (bagan yang mempertahankan status percakapan): Status bertindak sebagai memori bersama, menjaga konteks, dan memungkinkan penggunaan data real-time di seluruh node. Kemampuan ini memungkinkan LangGraph melampaui aliran statis dan mendukung kemajuan cerdas yang adaptif dalam otomatisasi alur kerja.

Bersama-sama, komponen ini memungkinkan LangGraph mengubah cara organisasi merancang dan menjalankan alur kerja berbasis AI—menjembatani kesenjangan antara alat AI dan proses bisnis dunia nyata.

Granite-4.0-Tiny-Preview, dikembangkan oleh IBM Research, adalah model bahasa sumber terbuka yang ringan namun cakap yang dirancang untuk memecahkan masalah yang kompleks dan tugas pemrosesan bahasa alami (NLP) praktis. Meskipun lebih kecil dari model komersial seperti GPT-4, Granite cepat, efisien, dan sepenuhnya kompatibel dengan Hugging Face—menjadikannya pilihan tepat bagi pengembang yang mencari efisiensi operasional tanpa mengorbankan kinerja.

Granite unggul dalam:

• Klasifikasi niat–mengidentifikasi tujuan pengguna di chatbot atau sistem berbasis tugas
• Pembuatan yang kreatif–membuat rangkuman, dialog, atau konten bentuk pendek
• Penalaran dan peringkasan—ideal untuk alur kerja yang melibatkan RAG atau analisis data

Dalam tutorial ini, model Granite memainkan peran kunci dalam berbagai tahap alur kerja agen, mendukung pemecahan masalah dan pembuatan konten. Desainnya yang ringan membuatnya cocok untuk aplikasi dunia nyata di mana intervensi manusia mungkin terbatas, dan di mana pola desain dapat diskalakan sangat penting untuk membangun solusi AI yang kuat di berbagai kumpulan data dan penyedia.

Dalam tutorial ini, kita akan membuat alur kerja agen yang bertindak sebagai asisten kreatif untuk menulis skenario animasi pendek.

Tujuan

Dengan ide cerita dari pengguna, agen akan:

• Identifikasi genre dan nada yang cocok untuk cerita
• Membuat garis besar plot singkat
• Memperluasnya menjadi adegan utama (misalnya, klimaks atau titik balik)
• Menulis dialog untuk adegan tersebut dalam format skenario

Contoh penggunaan ini dirancang untuk menampilkan kemampuan penalaran dan generatif model bahasa, yang disusun melalui alur kerja komposisi LangGraph.

Cara alur kerja beroperasi

Setiap langkah berikut diimplementasikan sebagai node LangGraph:

• Input pengguna: Pengguna memberikan ide cerita tingkat tinggi untuk memulai alur kerja.
• Deteksi genre (node_name - select_genre): LLM menganalisis input untuk menyimpulkan genre dan intonasi yang sesuai untuk cerita tersebut.
• Pembuatan garis besar (node_name - generate_outline): LLM menghasilkan ringkasan plot singkat berdasarkan genre yang dipilih.
• Penulisan adegan (node_name - generate_scene): LLM menulis adegan penting dalam bentuk prosa, menghidupkan cerita.
• Penulisan dialog (node_name - write_dialogue): LLM menulis ulang adegan sebagai dialog skenario yang diformat, cocok untuk produksi atau penyuntingan lebih lanjut.

Semua node ini terhubung secara berurutan di LangGraph dan model bergerak melaluinya seraya meneruskan kamus status yang dapat diubah.

Alur kerja ini mencapai keseimbangan antara pembuatan yang kreatif dan perencanaan struktural. Ini menunjukkan:

• Koordinasi LLM melalui LangGraph
• Bercerita dalam banyak langkah dengan intervensi manual minimal
• Otomatisasi kreatif dalam domain di mana imajinasi manusia sangat penting

Ini juga dapat diskalakan dengan baik, Anda dapat dengan mudah memperluasnya dengan menambahkan langkah revisi, beberapa pembuat adegan, atau bahkan percabangan berbasis karakter.

Anda memerlukan akun IBM Cloud untuk membuat proyek watsonx.ai .

Meskipun terdapat pilihan beberapa alat, tutorial ini akan memandu Anda untuk menyiapkan akun IBM menggunakan Jupyter Notebook.

1. Masuk ke watsonx.ai dengan menggunakan akun IBM Cloud Anda.
2. Buat proyek watsonx.ai. Anda bisa mendapatkan ID proyek dari dalam proyek Anda. Klik tab Kelola. Kemudian, salin ID proyek dari bagian Detail di halaman Umum. Anda memerlukan ID ini untuk tutorial ini.
3. Buat Jupyter Notebook.

Langkah ini akan membuka lingkungan notebook tempat Anda dapat menyalin kode dari tutorial ini. Sebagai alternatif, Anda dapat mengunduh notebook ini ke sistem lokal Anda dan mengunggahnya ke proyek watsonx.ai Anda sebagai aset. Untuk melihat tutorial Granite lain, lihat Komunitas IBM Granite. Tutorial ini juga tersedia di GitHub

1. Buat instans layanan Waktu proses watsonx.ai (pilih paket Lite, yang merupakan instans gratis).
2. Buat kunci antarmuka pemrograman aplikasi (Kunci API).
3. Kaitkan layanan watsonx.ai Runtime ke proyek yang Anda buat di watsonx.ai.

Sel ini menginstal pustaka inti yang diperlukan untuk menggunakan model IBM® Granite yang dihosting di Hugging Face:

• transformers: Ini adalah pustaka utama untuk memuat dan berinteraksi dengan model bahasa terlatih, termasukgranite-4.0-tiny-preview .
• accelerate:  Membantu pemuatan model dan penempatan perangkat yang efisien, terutama berguna untuk menggunakan GPU dengan cara yang lancar.

Kemampuan-q tanda menjalankan instalasi dengan senyap, menekan output berlebihan untuk antarmuka notebook yang lebih bersih. Pustaka ini sangat penting untuk mengunduh model dan menangani inferensi secara efisien dalam tutorial ini.

Catatan: Jika Anda menjalankan tutorial ini di lingkungan virtual dan tidak memiliki langgrapg yang sudah terinstal, gunakan pip install langgraph untuk menginstalnya di lingkungan lokal Anda.

Sel ini mengimpor semua pustaka inti yang diperlukan untuk membangun dan menjalankan alur kerja agen:

AutoTokenizer danAutoModelForCausalLM daritransformers : Digunakan untuk memuat model Granite dan mengubah prompt input menjadi token untuk pembuatan.

torch : Menyediakan akselerasi GPU dan operasi tensor yang diperlukan untuk inferensi model.

time: Memungkinkan pelacakan waktu dan pemantauan kinerja opsional.

StateGraph danEND darilanggraph.graph : Ini digunakan untuk menetapkan dan menyusun bagan alur kerja agen.

IPython.display ,base64: Digunakan untuk merender output dengan rapi dan mengaktifkan fitur unduhan opsional untuk konten yang dihasilkan di Jupyter Notebook.

Bersama-sama, impor ini mempersiapkan lingkungan untuk interaksi model, penyusunan alur kerja, dan presentasi output.

Sel ini memuatgranite-4.0-tiny-preview model IBM dan pembuat token yang sesuai dari Hugging Face:

model_id: Menentukan pengenal untuk model terlatih yang dihosting di Hugging Face.

AutoTokenizer.from_pretrained(model_id): Memuat pembuat token yang terhubung dengan model Granite. Pembuat token bertanggung jawab untuk mengubah teks yang dapat dibaca manusia menjadi token input untuk model.

AutoModelForCausalLM.from_pretrained(...): Memuat model bahasa aktual untuk pemodelan bahasa sebab akibat (yaitu, generatif). Model ini dapat memprediksi dan menghasilkan output teks berdasarkan input.

Kemampuantorch_dtype=torch.float32 parameter secara eksplisit mengatur jenis data ke float32 yang lebih hemat memori dan kompatibel secara luas—terutama berguna dalam lingkungan yang dibatasi GPU.

Langkah ini secara efektif mengawali model Granite sebagai "mesin penalaran" di balik alur kerja agen kami.

Fungsi ini,generate_with_granite , membungkus proses pembuatan teks dengan menggunakan model Granite. Fungsi ini menerima prompt yang merupakan teks input untuk memandu respons model.

max_tokens : Jumlah maksimum token yang dihasilkan dalam output (default: 200).

use_gpu : Tanda yang menunjukkan apakah akan menjalankan inferensi pada GPU (jika tersedia).

Detail utama:

device = torch.device(...): Memilih GPU (cuda) secara dinamis jika diminta dan tersedia; jika tidak, CPU adalah pilihan default.

model.to(device): Memuat model ke perangkat yang sesuai tepat waktu, membantu menghemat memori.

tokenizer(prompt, return_tensors="pt"): Mengonversi string input menjadi tensor token untuk pemrosesan model.

model.generate(...): Memulai pembuatan teks dengan strategi pengambilan sampel termasuk:

• do_sample=True: Memungkinkan keacakan untuk output yang lebih kreatif.

• temperature=0.7 dantop_p=0.9: Mengontrol keberagaman teks yang dihasilkan.

tokenizer.decode(...): Mengonversi token yang dihasilkan kembali menjadi teks yang dapat dibaca, menghapus token khusus apa pun.

Fungsi ini akan digunakan kembali di seluruh alur kerja agen untuk memanggil model Granite di berbagai node keputusan atau pembuatan.

Fungsi ini,select_genre_node , menetapkan node pertama dalam alur kerja pembuatan skenario agen kami. Fungsi ini menggunakan model Granite untuk menentukan genre dan intonasi cerita berdasarkan input pengguna.

Input:state , kamus yang mencakup"user_input" (misalnya, "Saya ingin menulis cerita fantasi unik untuk anak-anak").

Konstruksi prompt: Prompt meminta model untuk:

• Bertindak sebagai asisten kreatif.
• Menganalisis input pengguna.
• Merekomendasikan genre dan intonasi dengan menggunakan format output tertentu:Genre: <genre> danTone: <tone>

Pembuatan teks: Prompt diberikan kegenerate_with_granite() fungsi utilitas untuk menghasilkan respons kreatif.

Penguraian output: Siklus sederhana mengekstrak genre dan intonasi dari respons model berdasarkan awalan baris ("Genre:" dan"Tone:" ).

Pembaruan status: Nilaigenre dantone yang diekstrak dimasukkan kembali ke kamus status yang akan diteruskan ke node berikutnya.

Node ini bertindak sebagai pengklasifikasi kreatif, sehingga node berikutnya dapat menghasilkan garis besar, struktur, dan adegan yang selaras dengan konteks, menggunakan genre dan intonasi sebagai parameter dasar.

Kemampuangenerate_outline_node fungsi menetapkan node kedua dalam alur kerja pembuatan skenario. Fungsi ini dibangun di atas genre dan intonasi yang dipilih untuk menghasilkan garis besar plot ringkas untuk cerita.

Input: Fungsi menerima kamus status yang berisi:

• user_input: Ide cerita asli.
• genre: Dipilih di node sebelumnya.
• tone: Dipilih di node sebelumnya.

Konstruksi prompt: Model diinstruksikan untuk:

• Bertindak sebagai asisten penulisan kreatif.
• Mempertimbangkan ide, genre, dan intonasi dari pengguna.
• Membuat garis besar plot singkat (3-5 kalimat) yang cocok untuk skenario animasi pendek.

Pembuatan teks: Prompt dikirim kegenerate_with_granite() dengantoken limit (max_tokens=250) lebih tinggi untuk memberikan ruang bagi garis besar dengan banyak kalimat.

Pembaruan status: Garis besar plot yang dibuat ditambahkan ke status di bawah kunci"outline" , siap digunakan dalam fase ekspansi struktur berikutnya.

Node ini menerjemahkan maksud kreatif yang abstrak ke dalam sketsa naratif, menjadi penopang bagi struktur tiga babak yang terperinci setelahnya. Ini memastikan bahwa node hilir bekerja dari garis dasar yang koheren dan imajinatif.

Kemampuangenerate_scene_node fungsi menetapkan langkah ketiga dalam alur kerja di mana garis besar plot diubah menjadi adegan naratif yang lengkap. Adegan ini berfungsi sebagai dramatisasi yang jelas dari titik balik dalam cerita, mengalihkan gagasan dari ringkasan ke penceritaan.

Input: Node mengambil kamus status yang sekarang mencakup:

• genre dantone
• Kemampuanplot outline dari node sebelumnya

Konstruksi prompt: Model diinstruksikan untuk:

• Bertindak sebagai penulis skenario
• Membuat titik balik atau adegan klimaks menggunakan kisahgenre ,tone danoutline
• Menulis dalam format prosa untuk menjaga keterbacaan dan deskripsi yang sesuai dengan animasi

Persyaratan adegan:

• Jelas dan deskriptif (cocok untuk animasi)
• Merupakan inti bagi perjalanan emosional atau naratif (misalnya, penemuan, konflik, atau resolusi)

Pembuatan teks:generate_with_granite dipanggil denganmax_tokens=300 , memungkinkan ruang yang cukup untuk pembuatan skenario yang membuat terpana.

Pembaruan status: Adegan yang dihasilkan ditambahkan ke kamus status di bawah kunci"scene" .

Status ini memasukkan penyertaan narasi dan penceritaan visual ke alur kerja. Alih-alih hanya meringkas cerita, node ini menghidupkannya dengan detail sensorik dan emosional—yang penting untuk membuat naskah film pendek animasi.

Kemampuanwrite_dialogue_node menetapkan langkah kreatif keempat dalam alur kerja penceritaan: mengubah adegan narasi menjadi dialog karakter yang diformat. Langkah ini menjembatani kesenjangan antara prosa dan penulisan naskah yang siap tayang, dengan memberikan suara pada karakter.

Input: Node mengharapkan statusscene memuat momen cerita yang jelas (biasanya berupa titik balik atau klimaks).

Pembuatan prompt: Model ini dipandu untuk:

• Bertindak sebagai penulis dialog
• Mengekstrak dan menyesuaikan dialog dari adegan
• Memformat output dalam gaya skenario dengan menggunakan:CHARACTER: Dialogue line

Pedoman untuk dialog:

• Menjaganya tetap singkat dan ekspresif
• Memastikan kesesuaian untuk animasi (visual, emosional, ringkas)
• Ciptakan nama jika diperlukan untuk kejelasan

Pembuatan: Pemanggilangenerate_with_granite() menggunakanmax_tokens=300 , yang menyeimbangkan ekspresi dengan karakter ringkas—ideal untuk naskah animasi pendek.

Pembaruan status: Dialog disimpan ke status di bawah kuncidialogue untuk langkah selanjutnya (misalnya tampilan atau pengeditan).

Fungsi pembantu iniwith_progress dirancang untuk membungkus setiap node alur kerja dengan indikator kemajuan real-time. Ini tidak mengubah logika fungsi aslinya—hanya melacak dan mencetak status eksekusi dan waktu untuk membuat alur kerja yang panjang menjadi lebih transparan.

Tujuan fungsi: Membungkus node (misalnya generate_scene_node) dengan dekorator yang mencatat:

• Langkah mana yang sedang berjalan
• Indeks langkah dan jumlah total
• Durasi langkah

Parameter:

• fn Fungsi node yang sebenarnya (misalnya write_dialogue_node)
• label : Label yang dapat dibaca manusia untuk fungsi tersebut
• index : Nomor langkah dalam urutan (misalnya 2)
• total : Jumlah total langkah dalam alur kerja

Pembungkus internal:

• Mencetak pesan awal
• Mencatat waktu mulai
• Memanggil fungsi asli
• Mencetak pesan penyelesaian dengan durasi yang telah berlalu

Hasil: Versi modifikasi dari fungsi yang menambahkan pesan kemajuan tetapi berperilaku identik.

Seiring dengan berkembangnya alur kerja, penting untuk melacak langkah mana yang sedang dieksekusi, terutama jika beberapa langkah (seperti pembuatan atau pengeditan) membutuhkan waktu lebih lama atau dapat menyebabkan masalah seperti kelebihan beban pada memori. Pembungkus kemajuan ini memastikan transparansi dan berguna untuk debug dan diagnostik waktu proses.

Sel ini mendefinisikan logika alur kerja untuk menghasilkan cerita animasi pendek dengan menggunakan LangGraph, kerangka kerja berbasis grafik komposisi yang dirancang untuk alur kerja LLM. Setiap langkah dalam grafik mewakili tugas kreatif dan dieksekusi dalam urutan tertentu untuk menghasilkan skenario akhir.

Komponen alur kerja:StateGraph(dict)  - Mengawali alur kerja dengan status berbasis kamus (yaitu memori kerja adalah sebuah kamus yang diteruskan di antara node).

Pencatatan node dengan pelacakan kemajuan: Setiap langkah (pemilihan genre, pembuatan garis besar, penulisan adegan, penulisan dialog) ditambahkan sebagai sebuah node dengan pembungkus with_progress() - 

Pendekatan ini memastikan bahwa setiap node mencatat waktu proses dan kemajuannya saat dieksekusi.

Garis penghubung alur kerja (urutan node): Urutan saluran kreatif ditetapkan dengan jelas:

set_entry_point() danset_finish_point(): Ini menentukan node awal dan akhir dari alur kerja.

graph.compile(): Menyusun alur kerja ke dalam bagan yang dapat dijalankan (alur kerja) yang sekarang dapat dipanggil dengan status awal.

Struktur ini memungkinkan alur kerja LLM yang modular, dapat dibaca, dan dapat dilakukan debug. Setiap tahap dalam proses kreatif Anda dipisahkan, dapat dibuat profilnya secara terpisah, dan kemudian dapat ditukar atau diperpanjang (misalnya, menambahkan langkah “revisi adegan” atau node “ringkas output”).  workflow sekarang siap dijalankan dengan prompt dan akan menjalankan alur saluran kreatif Anda langkah demi langkah, menampilkan kemajuan langsung.

Sel kode akhir ini adalah tempat Anda menjalankan alur kerja kreatif lengkap dan menampilkan hasil dari setiap tahap pembuatan cerita.

initial_state: Perintah ini adalah titik awal alur kerja, di mana pengguna memberikan ide atau tema kreatif. user_input berfungsi sebagai benih untuk saluran cerita.

final_state: Perintah ini memicu saluran LangGraph lengkap. Input diteruskan melalui setiap node yang tercatat (select_genre, generate_outline, generate_scene, dan write_dialogue) secara berurutan.

Menampilkan hasil: Kamus status akhir sekarang berisi kunci yang diisi oleh berbagai node:

• "genre": Genre yang diidentifikasi berdasarkan input pengguna.
• "tone": Kualitas nada cerita.
• "outline": ringkasan plot 3-5 kalimat.
• "scene": Adegan titik balik yang jelas ditulis dalam prosa.
• "dialogue": Dialog karakter diformat sebagai skenario.

Bagian ini menunjukkan bagaimana maksud pengguna diubah menjadi sebuah skrip kecil lengkap melalui alur kerja LLM yang modular dan bertahap. Ini adalah saluran yang sepenuhnya kreatif serta interaktif, dapat ditafsirkan, dan dapat disesuaikan.

Catatan: Menjalankan kode akan memakan waktu sekitar 15-17 menit jika Anda menggunakan GPU atau TPU. Diperlukan waktu sekitar 65-70 menit pada lingkungan virtual lokal untuk menjalankan dan menghasilkan output berdasarkan infrastruktur yang digunakan untuk menjalankan cede.

Mari kita pahami bagaimana sistem mengubah prompt pengguna—"Saya ingin menulis cerita fantasi unik untuk anak-anak tentang naga yang tersesat dan menemukan rumahnya"—menjadi sebuah cerita animasi yang lengkap. Setiap langkah dibangun di atas langkah sebelumnya, dipandu oleh node kreatif alur kerja dan didukung oleh model Granite.

1. Genre dan intonasi. Alur kerja dimulai dengan menafsirkan prompt asli pengguna: Saya ingin menulis cerita fantasi unik untuk anak-anak tentang naga yang tersesat dan menemukan rumahnya. Berdasarkan input ini, node select_genre_node mengklasifikasikan narasi dengan benar sebagai fantasi unik dan mengidentifikasi intonasi yang menawan dan menghangatkan hati yang sesuai. Hasil ini akurat dan selaras dengan konteks, karena penggunaan frasa seperti "unik," "untuk anak-anak" dan "naga yang tersesat menemukan rumahnya" dengan jelas menandakan gaya penceritaan yang magis namun lembut. Genre dan intonasi berfungsi sebagai parameter dasar yang membentuk setiap langkah pembuatan berikutnya dalam alur kerja.

2. Garis besar plot dan deskripsi karakter. Pada langkah selanjutnya, model diminta untuk membuat garis besar plot berdasarkan genre, intonasi, dan ide asli pengguna yang telah diidentifikasi. Output tidak hanya mencakup ringkasan cerita 3-5 kalimat tetapi juga deskripsi karakter bonus, kemungkinan karena kebocoran prompt atau pemformatan instruksi yang dipertahankan dari iterasi sebelumnya.

Garis besar cerita berpusat pada seorang gadis bernama Lily yang menemukan seekor naga yang terluka dan membantunya kembali ke hutan ajaib dengan bimbingan seorang dukun yang mengobati penyakit. Alur cerita ini mencerminkan maksud pengguna dengan tepat—berfokus pada perjalanan magis yang cocok untuk anak-anak dengan intonasi emosional tentang penyembuhan, rasa memiliki, dan persahabatan. Sketsa karakter naga, Lily, dan dukun menambah kedalaman, mengubah ide yang tidak jelas menjadi konsep yang terstruktur dengan peran, kepribadian, dan tanggung jawab narasi yang jelas. Langkah ini memastikan cerita beralih dari niat abstrak ke struktur nyata yang cocok untuk adaptasi layar.

3. Adegan kunci. Mengingat seluruh garis besar plot,generate_scene_node menulis adegan yang jelas dalam format prosa yang menangkap titik balik dalam cerita—elemen lain yang secara eksplisit diminta dalam tujuan awal pengguna untuk mengembangkan naskah animasi pendek.

Momen yang dipilih adalah saat Lily merawat naga yang terluka di hutan ajaib, membangun hubungan emosional dan saling pengertian di antara para karakter. Momen ini sangat penting karena memutar cerita menuju kepulangan naga. Adegan ini kaya akan citra dan emosi, mengikuti batasan "unik" dan "menghangatkan hati" namun juga ekspresif secara visual—sangat cocok untuk format animasi pendek.

Kemampuan model untuk mempertahankan konsistensi intonasi dan genre di seluruh tahapan menunjukkan kehebatan dari alur kerja LangGraph yang meneruskan status dan kemampuan penalaran model Granite.

4. Dialog dalam format skenario. Terakhir,write_dialogue_node mengubah adegan prosa menjadi dialog terstruktur dalam format skenario. Permintaan pengguna—yang berfokus pada membuat sebuah cerita untuk animasi—secara implisit menuntut agar narasi disajikan dalam format yang siap untuk produksi atau visualisasi. Node ini memenuhi tujuan tersebut dengan menyampaikan dialog yang diformat dengan baik antara Lily, Drago (naga), dan dukun tua di dua adegan yang berbeda: pondok dan hutan ajaib. Dialog mempertahankan isyarat emosional dan maksud karakter, dan diformat agar sesuai dengan konvensi penulisan naskah animasi (misalnya nama karakter dalam huruf besar, tajuk adegan seperti[INT. LILY’S COTTAGE - DAY]) . Output tetap pendek, ekspresif, dan menggugah perasaan, yang sangat penting untuk melibatkan audiens muda dalam suasana yang hidup.

Setiap tahap alur kerja menerjemahkan prompt aslinya— "sebuah cerita fantasi unik untuk anak-anak tentang naga yang tersesat menemukan rumahnya" —menjadi output narasi yang terstruktur, kreatif, dan ekspresif. Dari pemilihan genre hingga pemformatan dialog, sistem secara bertahap membangun perkembangan penceritaan yang koheren. Kerangka kerja LangGraph memastikan bahwa transisi antara tugas terhubung secara logis, dan model IBM Granite memungkinkan pembuatan teks yang peka konteks dengan intonasi yang konsisten. Hasilnya adalah cerita animasi pendek yang ringkas dan siap untuk layar yang seluruhnya muncul dari input pengguna satu baris—menunjukkan kekuatan praktis dari alur kerja agen dalam aplikasi AI kreatif.

Untuk membuat pengalaman bercerita menjadi lebih menarik, berikut ini adalah visualisasi berbasis HTML sederhana yang memformat elemen cerita yang dihasilkan dengan indah—genre, intonasi, plot, adegan, dan dialog. Selain itu, hanya dengan satu klik, Anda dapat mengunduh seluruh skrip sebagai file teks untuk digunakan atau dibagikan pada masa mendatang. Mari kita menghidupkan cerita di layar!

Tutorial ini menggunakan model Granite-4.0-Tiny-Preview untuk pembuatan teks. Meskipun ini adalah salah satu model yang lebih kecil dalam keluarga Granite, model ini masih membutuhkan lingkungan yang mendukung GPU untuk berjalan secara efisien—terutama saat menjalankan beberapa node dalam alur kerja LangGraph.

Pengaturan yang disarankan:

• Setidaknya satu GPU NVIDIA V100 atau A100
• Memori GPU 16 GB atau lebih untuk kinerja yang stabil
• Python 3.8+ dengan torch, transformator, dan langgraph terinstal

Catatan kinerja:

• Anda mungkin mengalami kesalahan kehabisan memori CUDA jika menjalankan semua node secara berurutan tanpa menghapus memori GPU.
• Untuk meminimalkan masalah memori:
  • Pindahkan model ke GPU hanya selama pembuatan dan kembali ke CPU setelahnya.
  • Pertahankan token pembuatan tetap sederhana (max_tokens=200–300).
  • Pilihan lain adalah menghapus atau menyederhanakan node seperti revisi atau perluasan adegan terperinci.

Jika Anda menjalankan tutorial ini di lingkungan notebook yang dihosting (misalnya, IBM watsonx.ai atau Google Colab Pro), pastikan GPU diaktifkan dalam pengaturan waktu proses.

Untuk lingkungan dengan sumber daya rendah, pertimbangkan:

• Memindahkan inferensi model ke API Hugging Face Inference.
• Mengurangi kompleksitas alur kerja.
• Menggunakan CPU (dengan waktu pembuatan yang lebih lama).

Dalam tutorial ini, kami membuat alur kerja penceritaan modular dan agentik dengan menggunakan LangGraph dan model bahasa Granite-4.0-Tiny-Preview dari IBM. Dimulai dari prompt kreatif yang sederhana, kami membuat alur langkah demi langkah yang mengklasifikasikan genre dan intonasi, membuat garis besar plot, menulis adegan utama dan menyelesaikannya dengan dialog bergaya skenario. Selama prosesnya, kami menunjukkan cara:

• Menyusun alur kerja yang dinamis dengan menggunakan LangGraph
• Mengintegrasikan LLM ringan seperti Granite untuk penalaran kreatif
• Menangani kendala memori GPU dengan pemuatan model sementara
• Menampilkan dan mengekspor output cerita dalam format yang mudah digunakan

Kerangka kerja ini tidak hanya efektif untuk penulisan layar, tetapi dapat diperluas ke berbagai contoh penggunaan kreatif atau pengarahan tugas. Hanya dengan beberapa node, Anda telah membangun asisten penulisan miniatur yang mampu mengubah ide unik menjadi cerita yang siap pakai.

Baik Anda seorang pengembang, pendongeng, atau peneliti—tutorial ini memberi Anda landasan praktis untuk menjelajahi rekayasa alur kerja berbasis LLM di domain kreatif.

Siap membangun agen Anda sendiri? Biarkan kreativitas mengalir dengan model IBM Granite dan IBM watsonx Orchestrate.