Langflow: Panduan dengan Proyek Demo

Cara Menginstal Langflow?

Kita bisa menggunakan Langflow secara gratis, baik di situs resmi mereka melalui antarmuka web mereka atau dengan memasangnya secara lokal.

Dalam tutorial ini, kita akan menggunakan setup lokal dengan Docker. Anda tidak perlu mengetahui Docker untuk mengikuti tutorial ini. Namun jika ingin belajar lebih lanjut, lihat panduan Docker untuk pemula ini dan kursus Docker ini.

Docker adalah alat yang memungkinkan kita menjalankan aplikasi dalam lingkungan terisolasi yang disebut container, sehingga memudahkan pengembangan, pengujian, dan penerapan perangkat lunak secara konsisten. Dalam kasus kita, kita menggunakan Docker karena menawarkan fleksibilitas lebih untuk membangun komponen kustom dengan Python, karena kita dapat menggunakan basis data lokal dan tidak perlu terhubung ke layanan eksternal.

Langflow menyediakan contoh siap pakai, jadi kita tidak perlu menyiapkannya sendiri.

Menjalankan Langflow secara lokal dengan Docker

Untuk menjalankan Langflow secara lokal dengan Docker, ikuti langkah-langkah berikut:

1. Instal Docker dengan mengikuti langkah-langkah di sini.
2. Kloning atau unduh repositori resmi Langflow.
3. Buka terminal di folder docker_example.
4. Jalankan perintah docker compose up.

Sekarang, Langflow seharusnya berjalan di mesin lokal kita. Kita akan melihat pesan ini di terminal:

Kita dapat membuka aplikasinya dengan mengunjungi URL yang ditampilkan di terminal, http://0.0.0.0:7860 pada contoh di atas.

Mengeksplorasi Simple Agent dengan Langflow

Di bagian ini, kita mengeksplorasi cara kerja Langflow dengan menelaah templat agen AI sederhana milik Langflow. Untuk melakukannya, pilih "Simple Agent" pada layar pertama.

Ini akan membuat alur kerja agen seperti berikut:

Komponen utama dalam alur kerja ini adalah komponen "Agent" di tengah:

Komponen agent ini menggunakan model gpt-4.1 dari OpenAI. Untuk menggunakannya, kita perlu menempelkan kunci API OpenAI. Jika Anda belum memilikinya, Anda dapat membuatnya di sini.

Di sebelah kiri komponen agent, kita melihat input dan alat yang tersedia untuknya (lihat gambar di bawah). Dalam kasus ini, terdapat dua alat dan satu input:

• Chat Input yang menggunakan pesan dari pengguna di antarmuka chat sebagai masukan.
• Alat Calculator yang digunakan untuk melakukan perhitungan.
• Alat URL yang digunakan untuk mengambil informasi dari URL tertentu.

Input chat berarti saat kita mengeksekusi alur kerja, kita dapat menggunakan antarmuka chat bawaan Langflow untuk mengirim pesan ke model. Di bagian atas setiap alat, terlihat deskripsi. Model menggunakan informasi ini untuk memutuskan apakah akan memanggil setiap alat atau tidak.

Di sebelah kanan, kita melihat keluarannya. Dalam kasus ini, terdapat satu komponen keluaran, yaitu komponen Chat Output, yang menunjukkan bahwa jawaban Agent harus dikirim ke chat.

Memahami komponen

Sebelum kita menjalankan Simple Agent, mari gunakan komponen URL untuk memahami cara kerja komponen secara umum. Mari buat salinannya untuk bereksperimen.

1. Pilih komponen URL.
2. Salin dan tempel.
3. Jangan hubungkan ke apa pun.

Di bagian atas komponen baru, ada sakelar "Tool Mode"; nonaktifkan.

Di kolom URLs, masukkan, misalnya, https://en.wikipedia.org/wiki/Data_science, halaman Wikipedia untuk Data Science. Eksekusi komponen dengan mengklik panah run di pojok kanan atas.

Komponen akan dieksekusi dan memuat konten dari URL yang kita berikan. Kita bisa melihatnya dengan mengklik inspector di sebelah tautan keluaran. Masing-masing mewakili format keluaran yang berbeda.

Di balik layar, setiap node adalah skrip Python. Kita akan mempelajari lebih lanjut tentang ini saat membangun node kustom nanti. Kita dapat memeriksa kodenya dengan mengklik tombol "Code" di bagian atas:

Dalam alur kerja Simple Agent asli, node URL dikonfigurasi sebagai alat. Ini berarti node tersebut dimaksudkan untuk digunakan oleh Agent. Dalam kasus ini, URL tidak diberikan secara eksplisit. Sebagai gantinya, agen akan menyediakan URL itu sendiri.

Mengeksekusi Simple Agent

Kembali ke Simple Agent, kita dapat mengeksekusinya dengan mengklik tombol "Playground" di pojok kanan atas. Ini akan membuka antarmuka chat, memungkinkan kita mengobrol dengan Agent.

Mari kita minta untuk merangkum halaman Wikipedia Data Science:

Jika kita memperluas kotak di bagian atas jawaban, kita akan melihat langkah-langkah yang dieksekusi dalam alur kerja.

Di sini kita melihat, misalnya, bahwa ia menggunakan fungsi fetch_content_text(), yang didefinisikan dalam alat URL yang kita sediakan untuk agent.

Kita dapat menguji penggunaan alat Calculation dengan memintanya melakukan perhitungan. Ekspresi akan diurai dan dikirim ke alat untuk dievaluasi. Ini memberikan jawaban yang lebih andal daripada sepenuhnya mengandalkan LLM.

Membuat Komponen Kustom di Langflow dengan Python

Di bagian ini, kita mempelajari cara membuat komponen kustom. Untuk memulai, klik tombol "New Custom Component" di kiri bawah:

Secara default, ini membuat komponen yang menerima nilai teks sebagai masukan dan mengeluarkan teks yang sama. Masukan default adalah "Hello, World!" dan jika kita menjalankannya dan memeriksa keluarannya, hasilnya memang sama persis.

Dengan memeriksa kodenya, kita melihat hal berikut:

1. Field ini adalah nilai konfigurasi untuk komponen. Deskripsi penting karena digunakan oleh agen AI untuk mengetahui kapan harus menggunakan komponen ini saat disediakan sebagai alat. Field dokumentasi adalah URL opsional ke dokumentasi komponen, jadi tidak perlu dikhawatirkan di sini.
2. Daftar inputs menentukan jenis masukan yang tersedia untuk komponen. Dalam kasus ini, termasuk satu masukan kelas MessageTextInput bernama input_value, yang sesuai dengan kolom teks. Namanya harus berupa nama variabel Python yang valid karena akan menjadi atribut kelas. Saat komponen disetel sebagai alat, masukan ini akan otomatis diisi oleh agen AI. Ia menggunakan field info untuk menentukan apa yang harus menjadi masukan. Langflow mendukung beberapa jenis masukan. Berikut daftar lengkap masukan yang didukung.
3. Bagian ini mendefinisikan keluaran. Field method menentukan fungsi yang dijalankan untuk menghasilkan keluaran. Fungsi memiliki akses ke masukan melalui self. Misalnya, masukan pada kasus ini bernama input_value, jadi kita dapat mengaksesnya menggunakan self.input_value. Nilai kembalian harus berupa kelas dari kelas keluaran yang didukung.

Untuk informasi lebih lanjut tentang membuat komponen kustom, lihat dokumentasi resmi komponen Langflow.

Berikut contoh cara membuat komponen yang menambahkan dua angka:

from langflow.custom import Component
from langflow.io import MessageTextInput, Output
from langflow.schema import Data

class AddNumbers(Component):
    display_name = "Add Numbers"
    description = "This component adds two numbers together"
    icon = "code"
    name = "AddNumbers"

    inputs = [
        IntInput(
            name="number1",
            display_name="First Number",
            info="The first number to add",
        ),
        IntInput(
            name="number2",
            display_name="Second Number",
            info="The second number to add",
        ),
    ]

    outputs = [
        Output(display_name="Output", name="output", method="add_numbers"),
    ]

    def add_numbers(self) -> Data:
        result = self.number1 + self.number2
        data = Data(value=result)
        return data

Membangun Tutor Bahasa dengan Langflow

Mari kita bangun agen AI untuk membantu kita melatih kemampuan membaca saat mempelajari bahasa baru.

Berdasarkan pengalaman saya, saat mempelajari bahasa baru, salah satu cara untuk meningkatkan kemampuan adalah dengan membaca. Tentu saja, pada awalnya, Anda hanya mengetahui beberapa kata, sehingga membaca buku menjadi mustahil. Oleh karena itu, kita menginginkan bahan bacaan yang berfokus pada kosa kata yang saat ini kita ketahui.

Kita akan menggunakan LLM untuk menghasilkan cerita pendek untuk kita baca. Namun, agar pengalaman belajar lebih personal, kita ingin cerita yang dihasilkan berfokus pada kosa kata yang sudah kita ketahui.

Berikut rincian yang kita butuhkan:

1. Basis data kosa kata yang sudah dikenal.
2. Agen AI memerlukan akses ke basis data untuk mengambil kosa kata yang dikenal dan menghasilkan cerita.
3. Agen AI memerlukan akses ke basis data untuk menambahkan kata baru.

Komponen penyiapan basis data

Saat kita menggunakan Docker untuk menjalankan Langflow, ia menyalakan basis data Postgres. Kita dapat mengaksesnya menggunakan paket psycopg2. Untuk mempelajari lebih lanjut tentang Postgres, lihat tutorial PostgreSQL ini.

Kita akan membuat sebuah node tempat kita dapat mengunggah file CSV berisi kata-kata yang sudah dikenal untuk menginisialisasi basis data. File CSV saya terlihat seperti ini:

Saya membuat komponen dengan dua masukan.

1. Nama kolom untuk menentukan kolom yang berisi kata-kata yang ingin kita sertakan.
2. Masukan file untuk menyediakan file CSV berisi kata-kata.

Berikut kode komponen tersebut:

from langflow.custom import Component
from langflow.io import MessageTextInput, Output
from langflow.schema import Message
import psycopg2
import csv

def connect_to_database():
    # Connect to the Postgres database provided by the Docker setup
    conn = psycopg2.connect(
        dbname="langflow",
        user="langflow",
        password="langflow",
        host="postgres",
        port="5432"
    )
    conn.autocommit = True    
    return conn.cursor()

def add_word(cursor, word):
    # Add a word to the database
    cursor.execute(
        "INSERT INTO words (word) VALUES (%s) ON CONFLICT (word) DO NOTHING;",
        (word,)
    )

def initialize_database(cursor):
    # Initialize the database by creating the word table if it doesn't yet exist
    create_table_query = """
        CREATE TABLE IF NOT EXISTS words (
            word TEXT PRIMARY KEY
        );
    """
    cursor.execute(create_table_query)    

class UploadWordFile(Component):
    display_name = "Upload Word File"
    description = "Upload a CSV file of words to the database."
    icon = "code"
    name = "UploadWordFile"

    inputs = [
        StrInput(
            name="column_name",
            display_name="Column Name",
            info="The name of the column containing the words",
        ),
        FileInput(
            name="csv_file",
            display_name="CSV file",
            info="CSV input file",
            file_types=["csv"]
        ),
    ]

    outputs = [
        Output(display_name="Output", name="output", method="load_words_into_database"),
    ]

    def load_words_into_database(self) -> Message:
        try:
            cursor = connect_to_database()
            initialize_database(cursor)
            with open(self.csv_file, "rt") as f:
                rows = list(csv.reader(f))
            headers = list(map(lambda header: header.lower(), rows[0]))
            column_index = headers.index(self.column_name)
            for row in rows[1:]:
                add_word(cursor, row[column_index])
            return "Success"
        except Exception as e:
            return f"Error: {str(e)}"

Komponennya terlihat seperti ini:

Komponen ini dirancang untuk digunakan sendiri dan tidak dihubungkan ke komponen lain. Kita dapat menggunakannya untuk mengunggah kata-kata ke basis data secara manual.

Alat penambah kata

Di sini kita membuat alat yang dapat digunakan agen AI untuk menambahkan kata baru ke basis data. Dengan cara ini, pengguna dapat dengan mudah menambahkan kata baru dengan mengirim pesan ke agen.

Kode ini menggunakan kembali fungsi connect_to_database() dan add_word() dari node sebelumnya. Dengan setup Docker yang lebih baik, kita dapat menghindari pengulangan kode, tetapi untuk tutorial ini kita akan tetap sederhana.

Berikut kode untuk alat ini:

# from langflow.field_typing import Data
from langflow.custom import Component
from langflow.io import MessageTextInput, Output
from langflow.schema import Message

def connect_to_database():
    # Connect to the Postgres database provided by the Docker setup
    conn = psycopg2.connect(
        dbname="langflow",
        user="langflow",
        password="langflow",
        host="postgres",
        port="5432"
    )
    conn.autocommit = True    
    return conn.cursor()

def add_word(cursor, word):
    # Add a word to the database
    cursor.execute(
        "INSERT INTO words (word) VALUES (%s) ON CONFLICT (word) DO NOTHING;",
        (word,)
    )

class AddWordTool(Component):
    display_name = "Add word tool"
    description = "Use this tool to add a new word"
    icon = "code"
    name = "AddWordTool"

    inputs = [
        MessageTextInput(
            name="word",
            display_name="Word",
            info="The word to add",
            tool_mode=True,
        ),
    ]

    outputs = [
        Output(display_name="Output", name="output", method="add_new_word"),
    ]

    def add_new_word(self) -> Message:
        cursor = connect_to_database()
        add_word(cursor, self.word)
        return f"Added word: {self.word}"

Perlu dicatat bahwa alat ini mengasumsikan basis data sudah dibuat sebelumnya. Alat ini tidak akan berfungsi tanpa menjalankan komponen sebelumnya setidaknya satu kali.

Jangan lupa untuk mengaktifkannya sebagai mode alat:

Alat pembuat cerita

Untuk membuat cerita, kita menggunakan komponen agen AI. Berikut strukturnya:

Dalam instruksi agen, alih-alih menambahkan prompt langsung di komponen, kita menggunakan komponen Prompt karena ini memungkinkan kita menambahkan parameter ke prompt. Ini adalah prompt yang kita gunakan:

Create a story in {language} using only words from the following list:

{words}

Prompt memiliki dua parameter, {language} dan {words}. Saat menambahkan parameter seperti ini, komponen akan menambahkan field untuk masing-masing parameter.

Untuk nilai bahasa, kita cukup mengisinya di kotak teks. Kata-kata perlu dimuat dari basis data, jadi kita membuat komponen kustom yang memuat semua kata dari basis data, lalu menghubungkan keluaran node tersebut ke field words.

Berikut kode komponen pemuat kata:

from langflow.custom import Component
from langflow.io import MessageTextInput, Output
from langflow.schema import Message
import psycopg2

def load_words():
    conn = psycopg2.connect(
        dbname="langflow",
        user="langflow",
        password="langflow",
        host="postgres",
        port="5432"
    )    
    cursor = conn.cursor()
    cursor.execute("""
        SELECT * FROM words;
    """)
    rows = cursor.fetchall()
    return map(lambda row: row[0], rows)

class WordLoader(Component):
    display_name = "Word Loader"
    description = "Load words from the database"
    icon = "code"
    name = "WordLoader"

    outputs = [
        Output(display_name="Output", name="output", method="build_output"),
    ]

    def build_output(self) -> Message:
        return str(", ".join(load_words()))

Selanjutnya, kita atur agen ini menjadi alat. Dengan begitu, agen utama (yang kita buat berikutnya) dapat menggunakan agen ini untuk menghasilkan cerita saat diperlukan.

Terakhir, kita ganti nama agen dan ubah deskripsi alat untuk memberi tahu AI kapan harus menggunakan alat ini:

Agen bahasa

Untuk agen utama, kita menggunakan komponen node agen AI biasa yang ditautkan ke dua alat yang telah kita buat. Agen ini menggunakan komponen chat input dan chat output sehingga kita dapat berinteraksi dengannya melalui antarmuka chat.

Berikut arsitektur finalnya:

Prompt yang kita gunakan adalah:

You will help the user practice their language skills. You will either be asked to create a story or to add a new word to the vocabulary.

- If the user asks you to create a story, use the story generation tool.  
- If the user asks you to add a word, use the word add tool.  

When using a tool, your answer should just be the result from the tool and nothing else.

Kita dapat mengeksekusi seluruh alur kerja dengan mengklik tombol “Playground”. Berikut contoh interaksinya:

Kesimpulan

Kita telah mengeksplorasi aspek-aspek mendasar Langflow dan bagaimana alat ini dapat digunakan untuk membangun alur kerja agen AI yang membantu pengguna melatih kemampuan membaca. Dengan menggunakan Python untuk membuat komponen kustom, kita membuka lebih banyak kemungkinan. 

Pendekatan hibrida ini memadukan yang terbaik dari dua dunia: fleksibilitas skrip Python, yang memungkinkan eksekusi tugas apa pun yang diinginkan, dan antarmuka grafis Langflow yang intuitif, yang menyederhanakan pembuatan alur kerja tanpa perlu terjun ke kode yang kompleks.

Untuk mempelajari lebih lanjut tentang agen AI, saya sarankan membaca blog berikut:

• Codex dari OpenAI: Panduan dengan 3 Contoh Praktis
• n8n: Panduan dengan Contoh Praktis
• Tutorial Haystack AI: Membangun Alur Kerja Agen
• Agent Development Kit (ADK) Google: Panduan dengan Proyek Demo
• Agent2Agent (A2A): Definisi, Contoh, Perbandingan MCP