Langflow: een gids met demoproject

Hoe installeer je Langflow?

We kunnen Langflow gratis gebruiken, ofwel op hun officiële website via hun web-UI of door het lokaal te installeren.

In deze tutorial gebruiken we een lokale setup met Docker. Je hoeft geen Docker te kennen om deze tutorial te volgen. Maar als je meer wilt leren, bekijk dan deze Docker-gids voor beginners en deze Docker-cursus.

Docker is een tool waarmee we applicaties kunnen draaien in geïsoleerde omgevingen, containers genaamd. Dat maakt ontwikkelen, testen en uitrollen consistent en eenvoudig. In ons geval gebruiken we Docker omdat het meer flexibiliteit biedt voor het bouwen van aangepaste componenten met Python: we kunnen een lokale database gebruiken en hoeven niet te verbinden met een externe service.

Langflow levert een vooraf gebouwd voorbeeld dat klaar is om te draaien, dus we hoeven het niet zelf op te zetten.

Langflow lokaal draaien met Docker

Volg deze stappen om Langflow lokaal met Docker te draaien:

1. Installeer Docker door de stappen te volgen hier.
2. Clone of download de officiële Langflow-repository.
3. Open een terminal in de map docker_example.
4. Voer het commando docker compose up uit.

Nu zou Langflow op onze lokale machine moeten draaien. In de terminal zouden we dit bericht moeten zien:

We kunnen de applicatie openen via de URL die in de terminal wordt getoond, http://0.0.0.0:7860 in het bovenstaande voorbeeld.

De Simple Agent verkennen met Langflow

In deze sectie verkennen we hoe Langflow werkt door de eenvoudige AI-agenttemplate van Langflow te bekijken. Kies hiervoor "Simple Agent" op het eerste scherm.

Dit maakt een agentworkflow zoals deze:

De belangrijkste component in deze workflow is de "Agent"-component in het midden:

Deze agentcomponent gebruikt het gpt-4.1-model van OpenAI. Om dit te gebruiken, moeten we een OpenAI API-sleutel plakken. Als je er nog geen hebt, kun je er hier een aanmaken.

Links van de agentcomponent zien we de inputs en tools die beschikbaar zijn (zie de afbeelding hieronder). In dit geval zijn er twee tools en één input:

• Een Chat Input die een bericht van de gebruiker in de chatinterface als input gebruikt.
• Een Calculator-tool om berekeningen uit te voeren.
• Een URL-tool om informatie van een specifieke URL op te halen.

De chatinput betekent dat we bij het uitvoeren van de workflow de ingebouwde chatinterface van Langflow kunnen gebruiken om berichten naar het model te sturen. Bovenaan elke tool zien we een beschrijving. Het model gebruikt deze informatie om te bepalen of het de tool wel of niet moet aanroepen.

Rechts zien we de outputs. In dit geval is er één uitvoercomponent, namelijk een Chat Output-component, wat aangeeft dat het antwoord van de Agent naar de chat moet worden gestuurd.

Componenten begrijpen

Voordat we de Simple Agent uitvoeren, gebruiken we de URL-component om te begrijpen hoe componenten in het algemeen werken. Laten we er een kopie van maken om mee te experimenteren.

1. Selecteer de URL-component.
2. Kopieer en plak deze.
3. Verbind hem nergens mee.

Bovenaan de nieuwe component staat een schakelaar "Tool Mode"; zet die uit.

Vul in het veld URLs bijvoorbeeld https://en.wikipedia.org/wiki/Data_science in, de Wikipedia-pagina over Data Science. Voer de component uit door op de pijl rechtsboven te klikken.

De component voert uit en laadt de inhoud van de opgegeven URL. We kunnen dit bekijken door op de inspector naast de uitvoerkoppelingen te klikken. Elk icoon staat voor een ander uitvoerformaat.

Achter de schermen is elke node een Python-script. We leren hier later meer over wanneer we aangepaste nodes bouwen. We kunnen de code bekijken door bovenaan op de knop "Code" te klikken:

In de oorspronkelijke Simple Agent-workflow is de URL-node geconfigureerd als een tool. Dit betekent dat hij bedoeld is om door een Agent te worden gebruikt. In dit geval worden de URLs niet expliciet opgegeven. De agent levert de URLs zelf aan.

De Simple Agent uitvoeren

Terug naar de Simple Agent: we kunnen deze uitvoeren door rechtsboven op de knop "Playground" te klikken. Dit opent de chatinterface zodat we met de Agent kunnen chatten.

Laten we vragen om de Wikipedia-pagina over Data Science samen te vatten:

Als we het vak bovenaan het antwoord uitklappen, zien we de stappen die in de workflow zijn uitgevoerd.

Hier zien we bijvoorbeeld dat de functie fetch_content_text() wordt gebruikt, die is gedefinieerd in de URL-tool die we aan de agent hebben gegeven.

We kunnen het gebruik van de Calculation-tool testen door te vragen om een berekening uit te voeren. De expressie wordt geparsed en naar de tool gestuurd voor evaluatie. Dit geeft een betrouwbaarder antwoord dan uitsluitend vertrouwen op de LLM.

Een aangepaste component maken in Langflow met Python

In deze sectie leren we hoe we aangepaste componenten maken. Klik om te beginnen linksonder op de knop "New Custom Component":

Standaard wordt hiermee een component gemaakt die een tekstwaarde als input neemt en diezelfde tekst als output geeft. De standaardinput is "Hello, World!" en als we deze uitvoeren en de output inspecteren, zien we dat we precies dat terugkrijgen.

Als we de code bekijken, zien we het volgende:

1. Deze velden zijn configuratiewaarden voor de component. De beschrijving is belangrijk omdat AI-agents die gebruiken om te weten wanneer ze deze component moeten inzetten als tool. Het documentatieveld is een optionele URL naar de documentatie van de component, dus daar hoeven we ons hier niet druk om te maken.
2. De lijst inputs specificeert de soorten inputs die beschikbaar zijn voor de component. In dit geval bevat deze één input van de klasse MessageTextInput met de naam input_value, die overeenkomt met het tekstveld. De naam moet een geldige Python-variabelenaam zijn, omdat deze een attribuut van de klasse wordt. Wanneer een component als tool is ingesteld, worden deze inputs automatisch ingevuld door de AI-agent. Die gebruikt het veld info om te bepalen wat de input moet zijn. Langflow ondersteunt verschillende soorten inputs. Hier vind je een volledige lijst met ondersteunde inputs.
3. Dit deel definieert de outputs. Het veld method specificeert de functie die wordt uitgevoerd om de output te genereren. De functie heeft via self toegang tot de input. In dit geval heet de input input_value, dus we kunnen die benaderen met self.input_value. De returnwaarde moet een klasse zijn uit de ondersteunde outputklassen.

Meer informatie over het maken van een aangepaste component vind je in de officiële documentatie over Langflow-componenten.

Hier is een voorbeeld van hoe we een component kunnen maken die twee getallen optelt:

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

Een taalcoach bouwen met Langflow

Laten we een AI-agent bouwen die ons helpt onze leesvaardigheid te oefenen bij het leren van een nieuwe taal.

Uit mijn ervaring is lezen een van de manieren om je vaardigheden te verbeteren bij het leren van een nieuwe taal. Natuurlijk ken je in het begin maar een paar woorden, dus een boek lezen is onmogelijk. Daarom willen we leesmateriaal dat focust op de woordenschat die we nu al kennen.

We gebruiken een LLM om korte verhaaltjes te genereren die we kunnen lezen. Maar om het persoonlijk te maken, willen we dat de verhalen focussen op de woordenschat die we al beheersen.

Dit hebben we nodig:

1. Een database met bekende woorden (woordenschat).
2. De AI-agent heeft toegang nodig tot de database om de bekende woorden op te halen en een verhaal te genereren.
3. De AI-agent heeft toegang nodig tot de database om nieuwe woorden toe te voegen.

Component voor databasesetup

Wanneer we Docker gebruiken om Langflow te draaien, wordt er een Postgres-database opgestart. We kunnen hierop aansluiten met het pakket psycopg2. Wil je meer leren over Postgres, bekijk dan deze PostgreSQL-tutorial.

We gaan een node maken waarmee we een CSV-bestand met bekende woorden kunnen uploaden om de database te initialiseren. Mijn CSV-bestand ziet er zo uit:

Ik heb een component gemaakt met twee inputs.

1. Een kolomnaam om aan te geven welke kolom de woorden bevat die we willen opnemen.
2. Een bestandsinput voor het CSV-bestand met de woorden.

Hier is de code van de component:

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)}"

De component ziet er zo uit:

Hij is bedoeld om los te gebruiken en niet te worden verbonden met een andere component. We kunnen hem gebruiken om handmatig woorden in de database te uploaden.

Tool om woorden toe te voegen

Hier maken we een tool die de AI-agent kan gebruiken om nieuwe woorden aan de database toe te voegen. Zo kan de gebruiker eenvoudig nieuwe woorden toevoegen door een bericht naar de agent te sturen.

Deze code hergebruikt de functies connect_to_database() en add_word() uit de vorige node. Met een betere Docker-setup kunnen we codeherhaling vermijden, maar voor deze tutorial houden we het simpel.

Hier is de code voor deze tool:

# 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}"

Let op: deze tool gaat ervan uit dat de database al eerder is aangemaakt. Hij werkt niet zonder dat de vorige component minimaal één keer is uitgevoerd.

Vergeet niet om hem in toolmodus te zetten:

Tool voor verhalen maken

Voor het maken van een verhaal gebruiken we een AI-agentcomponent. Dit is de structuur:

In de agentinstructies hebben we in plaats van de prompt direct in de component te zetten een Prompt-component gebruikt, omdat we daarmee parameters aan de prompt kunnen toevoegen. Dit is de prompt die we gebruikten:

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

{words}

De prompt heeft twee parameters, {language} en {words}. Als je op deze manier parameters toevoegt, komt er voor elk daarvan een veld in de component bij.

Voor de taalwaarde vullen we simpelweg de tekstbox in. De woorden moeten uit de database worden geladen, dus we hebben een aangepaste component gemaakt die alle woorden uit de database laadt en de output van die node verbonden met het words-veld.

Hier is de code van de woordladercomponent:

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()))

Vervolgens zetten we de agent in toolmodus. Zo kan de hoofdagent (die we hierna maken) deze gebruiken om een verhaal te genereren wanneer dat nodig is.

Tot slot hernoemen we de agent en passen we de toolbeschrijving aan zodat de AI weet wanneer deze tool te gebruiken:

Taalagent

Voor de hoofdagent gebruiken we een gewone AI-agentnode die is gekoppeld aan de twee tools die we hebben gemaakt. Deze agent gebruikt een chatinput- en chatoutputcomponent zodat we ermee kunnen communiceren via de chatinterface.

Dit is de uiteindelijke architectuur:

De prompt die we gebruikten was:

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.

We kunnen de volledige workflow uitvoeren door op de knop “Playground” te klikken. Hier is een voorbeeldinteractie:

Conclusie

We hebben de basis van Langflow verkend en hoe je het kunt gebruiken om een AI-agentworkflow te bouwen die gebruikers helpt bij het oefenen van hun leesvaardigheid. Door Python te gebruiken om aangepaste componenten te maken, ontgrendel je meer mogelijkheden. 

Deze hybride aanpak combineert het beste van twee werelden: de flexibiliteit van Python-scripts, waarmee je elke gewenste taak kunt uitvoeren, en de intuïtieve grafische interface van Langflow, die het bouwen van workflows vereenvoudigt zonder dat je in complexe code hoeft te duiken.

Wil je meer leren over AI-agents, lees dan deze blogs:

• OpenAI’s Codex: een gids met 3 praktische voorbeelden
• n8n: een gids met praktische voorbeelden
• Haystack AI-tutorial: agentische workflows bouwen
• Google’s Agent Development Kit (ADK): een gids met demoproject
• Agent2Agent (A2A): definitie, voorbeelden, vergelijking met MCP