Tutorial Langflow: Membangun Aplikasi LLM Secara Visual

Langflow adalah platform open-source yang memungkinkan Anda membangun aplikasi berbasis Large Language Model (LLM) secara visual menggunakan antarmuka drag-and-drop. Dikembangkan oleh DataStax, Langflow menyederhanakan proses pembuatan pipeline AI yang kompleks tanpa harus menulis banyak kode. Dalam tutorial ini, kita akan mempelajari cara menginstal, mengkonfigurasi, dan membangun berbagai aplikasi AI menggunakan Langflow, mulai dari chatbot sederhana hingga pipeline RAG (Retrieval-Augmented Generation) yang lebih canggih.

Mengapa Langflow?

Membangun aplikasi LLM seringkali membutuhkan penulisan kode yang kompleks untuk menghubungkan berbagai komponen: model bahasa, vector store, prompt template, memory, dan lain-lain. Langflow menyelesaikan masalah ini dengan menyediakan antarmuka visual di mana Anda cukup menarik dan menghubungkan komponen-komponen tersebut layaknya menyusun diagram alur.

Beberapa keunggulan Langflow:

• Visual Builder: Drag-and-drop komponen tanpa perlu menulis kode boilerplate
• Integrasi Luas: Mendukung OpenAI, Anthropic, Google, Ollama, HuggingFace, dan puluhan provider lainnya
• Export ke Python: Flow yang dibuat secara visual dapat diekspor menjadi kode Python
• API Otomatis: Setiap flow otomatis mendapatkan REST API endpoint
• Komponen Custom: Anda bisa membuat komponen sendiri menggunakan Python
• Open Source: Gratis dan bisa di-deploy di infrastruktur sendiri

Instalasi

Prasyarat

Sebelum menginstal Langflow, pastikan sistem Anda memenuhi persyaratan berikut:

• Python 3.10 atau lebih baru
• pip (Python package manager)
• Minimal 4GB RAM (disarankan 8GB untuk flow yang kompleks)

Instalasi via pip

Cara paling mudah untuk menginstal Langflow adalah menggunakan pip:

pip install langflow

Untuk versi terbaru langsung dari repository:

pip install langflow --pre

Instalasi via Docker

Jika Anda lebih suka menggunakan Docker:

docker pull langflowai/langflow:latest
docker run -d -p 7860:7860 langflowai/langflow:latest

Untuk penggunaan dengan volume persisten agar data tidak hilang saat container di-restart:

docker run -d \
  -p 7860:7860 \
  -v langflowdata:/app/langflow \

  langflowai/langflow:latest

# docker-compose.yml
version: "3.8"

services:
  langflow:
    image: langflowai/langflow:latest
    ports:
"7860:7860"
    environment:

LANGFLOWDATABASEURL=postgresql://langflow:langflow@db:5432/langflow

LANGFLOWAUTOLOGIN=true

    dependson:

db
    volumes:

langflowdata:/app/langflow


  db:
    image: postgres:16
    environment:
      POSTGRESUSER: langflow
      POSTGRESPASSWORD: langflow

      POSTGRESDB: langflow
    volumes:
postgresdata:/var/lib/postgresql/data


volumes:
  langflowdata:
  postgresdata:

docker compose up -d

langflow run

langflow run --port 3000

You are a helpful AI assistant. Answer the user's question clearly and concisely.

User: {usermessage}

• Model: gpt-4o-mini (atau model lain yang Anda inginkan)
• API Key: Masukkan API key OpenAI Anda
• Temperature: 0.7

Langkah 4: Hubungkan Komponen

Hubungkan komponen-komponen tersebut:

Answer the question based only on the following context:

Context:
{context}

Question: {question}

If the answer is not found in the context, say "I don't have enough information to answer that question."

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


class WebScraperComponent(Component):
    displayname = "Web Scraper"
    description = "Scrape content from a web page"
    icon = "globe"

    inputs = [
        MessageTextInput(
            name="url",
            displayname="URL",

            info="The URL to scrape",
            required=True,
        ),
    ]

    outputs = [
        Output(displayname="Scraped Content", name="content", method="scrape"),
    ]

    def scrape(self) -> Data:
        url = self.url
        response = requests.get(url, timeout=10)
        soup = BeautifulSoup(response.text, "html.parser")

        for script in soup(["script", "style"]):
            script.decompose()

        text = soup.gettext(separator="\n", strip=True)


        return Data(text=text)

import requests

LANGFLOWURL = "http://localhost:7860"
FLOWID = "your-flow-id-here"


def queryflow(message: str) -> str:
    apiurl = f"{LANGFLOWURL}/api/v1/run/{FLOWID}"


    payload = {
        "inputvalue": message,
        "outputtype": "chat",

        "inputtype": "chat",
    }

    response = requests.post(apiurl, json=payload)

    result = response.json()

    output = result["outputs"][0]["outputs"][0]["results"]["message"]["text"]
    return output


answer = queryflow("Apa itu machine learning?")
print(answer)

curl -X POST "http://localhost:7860/api/v1/run/YOURFLOWID" \
  -H "Content-Type: application/json" \
  -d '{
    "inputvalue": "Apa itu machine learning?",

    "outputtype": "chat",
    "inputtype": "chat"

  }'

# Memastikan Ollama berjalan
import requests

response = requests.get("http://localhost:11434/api/tags")
models = response.json()
print("Available models:", [m["name"] for m in models["models"]])

from langflow.load import runflowfromjson

result = runflowfromjson(

    flow="path/to/exportedflow.json",
    inputvalue="Hello, how are you?",

    fallbacktoenvvars=True,
)

print(result[0].outputs[0].results["message"].text)

Tweaks dan Override

Anda bisa mengubah parameter komponen saat runtime menggunakan tweaks:

import requests

LANGFLOWURL = "http://localhost:7860"

FLOWID = "your-flow-id"

payload = {
    "inputvalue": "Explain quantum computing",

    "outputtype": "chat",
    "inputtype": "chat",

    "tweaks": {
        "OpenAI-xxxxx": {
            "modelname": "gpt-4o",
            "temperature": 0.3,
        },
        "Prompt-xxxxx": {
            "template": "Answer in Bahasa Indonesia: {usermessage}",

        },
    },
}

response = requests.post(
    f"{LANGFLOWURL}/api/v1/run/{FLOWID}",

    json=payload,
)
print(response.json())

# /etc/nginx/sites-available/langflow
server {
    listen 80;
    servername langflow.yourdomain.com;

    location / {
        proxypass http://127.0.0.1:7860;

        proxyhttpversion 1.1;

        proxysetheader Upgrade $httpupgrade;
        proxysetheader Connection "upgrade";
        proxysetheader Host $host;
        proxysetheader X-Real-IP $remoteaddr;

        proxyreadtimeout 300s;

        proxysendtimeout 300s;

    }
}

# Database
export LANGFLOWDATABASEURL="postgresql://user:pass@host:5432/langflow"


Security
export LANGFLOWAUTOLOGIN=false

export LANGFLOWSUPERUSER=admin
export LANGFLOWSUPERUSERPASSWORD=your-secure-password

Performance
export LANGFLOWWORKERS=4

export LANGFLOWMAXFILESIZEUPLOAD=100


API Keys (agar tidak perlu input manual di UI)
export OPENAIAPIKEY="sk-..."

export ANTHROPICAPI_KEY="sk-ant-..."

Best Practices

1. Organisasi Flow

• Beri nama yang deskriptif untuk setiap flow dan komponen
• Kelompokkan komponen terkait secara visual
• Gunakan fitur Note untuk mendokumentasikan logika yang kompleks
• Simpan flow yang sudah jadi sebagai template untuk penggunaan ulang

2. Pengelolaan API Key

• Jangan hardcode API key di dalam flow
• Gunakan Global Variables di Langflow untuk menyimpan API key
• Untuk production, gunakan environment variables
• Rotasi API key secara berkala

3. Optimasi Performa

• Gunakan chunk size yang sesuai untuk dokumen Anda (biasanya 500-1500 karakter)
• Pilih embedding model yang tepat sesuai kebutuhan dan budget
• Aktifkan caching untuk mengurangi panggilan API berulang
• Monitor penggunaan token untuk mengontrol biaya

4. Error Handling

• Selalu sediakan fallback response jika LLM gagal merespons
• Gunakan timeout yang wajar untuk API calls
• Log error untuk debugging
• Test flow secara menyeluruh sebelum deploy ke production

5. Keamanan

• Aktifkan autentikasi untuk deployment production
• Batasi akses API menggunakan API key
• Validasi input pengguna sebelum dikirim ke LLM
• Jangan expose internal error messages ke end user

Troubleshooting

Masalah Umum

• Pastikan semua komponen terhubung dengan benar
• Periksa apakah API key sudah diisi
• Cek log di terminal tempat Langflow berjalan

• Kurangi jumlah komponen yang tidak perlu
• Gunakan model yang lebih kecil untuk task sederhana
• Periksa koneksi internet

• Install dependensi yang diperlukan: pip install langflow[all]
• Restart Langflow setelah instalasi

• Untuk SQLite (default), pastikan direktori memiliki write permission
• Untuk PostgreSQL, verifikasi connection string

Kesimpulan

Langflow adalah alat yang memudahkan pengembangan aplikasi LLM dengan pendekatan visual. Dengan Langflow, Anda bisa membangun pipeline AI yang kompleks tanpa harus menulis banyak kode, sekaligus tetap memiliki fleksibilitas untuk membuat komponen custom dan mengekspor flow sebagai kode Python.

Beberapa poin penting yang telah kita pelajari:

• Langflow menyediakan antarmuka drag-and-drop untuk membangun aplikasi LLM
• Mendukung berbagai provider AI termasuk OpenAI, Anthropic, Google, dan model lokal via Ollama
• Pipeline RAG dapat dibangun secara visual dengan document loader, text splitter, vector store, dan LLM
• Custom component memungkinkan Anda memperluas fungsionalitas Langflow
• Setiap flow otomatis mendapatkan REST API endpoint untuk integrasi
• Multi-agent system bisa dibangun menggunakan komponen Agent dan Sequential Task
• Deployment bisa dilakukan secara self-hosted maupun menggunakan layanan cloud DataStax

Langflow cocok digunakan untuk prototyping cepat, membangun chatbot, sistem RAG, pipeline agentic, dan berbagai aplikasi AI lainnya. Mulailah dengan flow sederhana, lalu tingkatkan kompleksitasnya sesuai kebutuhan proyek Anda.