Langflow: Ein Leitfaden mit Demo-Projekt

Wie installiert man Langflow?

Wir können Langflow kostenlos nutzen, entweder auf der offiziellen Website über ihre Web-UI oder durch eine lokale Installation.

In diesem Tutorial werden wir ein lokales Setup mit Docker verwenden. Du musst Docker nicht kennen, um diesem Tutorial zu folgen. Wenn du mehr wissen willst, schau dir diesen Docker-Leitfaden für Anfänger und diesen Docker-Kurs.

Docker ist ein Tool, mit dem wir Anwendungen in isolierten Umgebungen, sogenannten Containern, ausführen können. Das macht es einfach, Software konsistent zu entwickeln, zu testen und einzusetzen. In unserem Fall verwenden wir Docker, weil es mehr Flexibilität für die Erstellung von benutzerdefinierten Komponenten mit Python bietet, da wir eine lokale Datenbank verwenden können und keine Verbindung zu einem externen Dienst herstellen müssen.

Langflow stellt ein vorgefertigtes Beispiel zur Verfügung, so dass wir es nicht selbst einrichten müssen.

Langflow lokal mit Docker ausführen

Um Langflow lokal mit Docker auszuführen, befolge diese Schritte:

1. Installiere Docker, indem du die Schritte hier.
2. Klone oder lade das offizielle Langflow-Repository.
3. Öffne ein Terminal im Ordner docker_example.
4. Führe den Befehl docker compose up aus.

Jetzt sollte Langflow auf unserem lokalen Rechner laufen. Im Terminal sollte diese Meldung erscheinen:

Wir können die Anwendung öffnen, indem wir die im Terminal angezeigte URL aufrufen, http://0.0.0.0:7860 im obigen Beispiel.

Den einfachen Agenten mit Langflow erforschen

In diesem Abschnitt erfahren wir, wie Langflow funktioniert, indem wir die einfache KI-Agentenvorlage von Langflow untersuchen. Dazu wählen wir auf dem ersten Bildschirm "Einfacher Agent".

Dadurch wird ein Agenten-Workflow wie dieser erstellt:

Die wichtigste Komponente in diesem Arbeitsablauf ist die Komponente "Agent" in der Mitte:

Diese Agentenkomponente verwendet das gpt-4.1 Modell von OpenAI. Um sie zu nutzen, müssen wir einen OpenAI API-Schlüssel einfügen. Wenn du noch keine hast, kannst du eine erstellen hier.

Auf der linken Seite der Agentenkomponente sehen wir die Eingaben und Werkzeuge, die ihr zur Verfügung stehen (siehe Abbildung unten). In diesem Fall hat es zwei Werkzeuge und einen Eingang:

• Ein Chat-Input, der eine Nachricht des Nutzers in der Chat-Oberfläche als Input verwendet.
• Ein Taschenrechner, mit dem du Berechnungen durchführen kannst.
• Ein URL-Tool, mit dem du Informationen von einer bestimmten URL abrufen kannst.

Die Chat-Eingabe bedeutet, dass wir bei der Ausführung des Workflows die integrierte Chat-Schnittstelle von Langflow nutzen können, um Nachrichten an das Modell zu senden. Oben auf jedem Werkzeug sehen wir eine Beschreibung. Das Modell nutzt diese Informationen, um zu entscheiden, ob die einzelnen Tools aufgerufen werden sollen oder nicht.

Auf der rechten Seite sehen wir die Ergebnisse. In diesem Fall gibt es eine einzige Ausgabekomponente, nämlich eine Chat-Ausgabekomponente, die anzeigt, dass die Antwort des Agenten an den Chat gesendet werden soll.

Komponenten verstehen

Bevor wir den einfachen Agenten ausführen, wollen wir die URL-Komponente verwenden, um zu verstehen, wie Komponenten im Allgemeinen funktionieren. Lass uns eine Kopie davon erstellen, um zu experimentieren.

1. Wähle die URL-Komponente aus.
2. Kopiere es und füge es ein.
3. Verbinde es nicht mit irgendetwas.

Oben auf der neuen Komponente gibt es einen Schalter für den "Werkzeugmodus"; schalte ihn aus.

Gib in das URL-Feld z.B. https://en.wikipedia.org/wiki/Data_science ein, die Wikipedia-Seite für Data Science. Führe die Komponente aus, indem du auf den Ausführungspfeil in der oberen rechten Ecke klickst.

Die Komponente wird ausgeführt und lädt den Inhalt von der URL, die wir angegeben haben. Wir können sie sehen, indem wir auf den Inspektor neben den Output-Links klicken. Jedes steht für ein anderes Ausgabeformat.

Hinter den Kulissen ist jeder Knoten ein Python-Skript. Wir werden mehr darüber erfahren, wenn wir später benutzerdefinierte Knotenpunkte bauen. Wir können den Code einsehen, indem wir oben auf die Schaltfläche "Code" klicken:

Im ursprünglichen Simple Agent-Workflow ist der URL-Knoten als Werkzeug konfiguriert. Das bedeutet, dass es von einem Agenten verwendet werden soll. In diesem Fall werden die URLs nicht explizit angegeben. Stattdessen wird der Agent die URLs selbst bereitstellen.

Ausführen des einfachen Agenten

Zurück zum Simple Agent: Wir können ihn ausführen, indem wir auf die Schaltfläche "Playground" in der oberen rechten Ecke klicken. Dies öffnet die Chat-Oberfläche, über die wir mit dem Agenten chatten können.

Bitten wir sie, die Wikipedia-Seite zu Data Science zusammenzufassen:

Wenn wir das Feld oben in der Antwort erweitern, sehen wir die Schritte, die im Workflow ausgeführt wurden.

Hier sehen wir zum Beispiel, dass er die Funktion fetch_content_text() verwendet, die in dem URL-Tool definiert ist, das wir dem Agenten zur Verfügung gestellt haben.

Wir können die Verwendung des Berechnungswerkzeugs testen, indem wir es bitten, eine Berechnung durchzuführen. Der Ausdruck wird geparst und zur Auswertung an das Tool gesendet. Das gibt eine verlässlichere Antwort, als sich ausschließlich auf den LLM zu verlassen.

Eine benutzerdefinierte Komponente in Langflow mit Python erstellen

In diesem Abschnitt lernen wir, wie man benutzerdefinierte Komponenten erstellt. Um zu beginnen, klicke unten links auf die Schaltfläche "Neue benutzerdefinierte Komponente":

Standardmäßig wird damit eine Komponente erstellt, die einen Textwert als Eingabe annimmt und denselben Text ausgibt. Die Standardeingabe ist "Hello, World!" und wenn wir sie ausführen und die Ausgabe untersuchen, sehen wir, dass wir genau das bekommen.

Wenn wir uns den Code ansehen, sehen wir Folgendes:

1. Diese Felder sind Konfigurationswerte für die Komponente. Die Beschreibung ist wichtig, da sie von den KI-Agenten verwendet wird, um zu wissen, wann sie diese Komponente verwenden sollen, wenn sie als Werkzeug bereitgestellt wird. Das Feld "Dokumentation" ist eine optionale URL zur Dokumentation der Komponente, daher müssen wir uns hier nicht darum kümmern.
2. Die Liste inputs gibt an, welche Arten von Eingängen für die Komponente verfügbar sind. In diesem Fall enthält sie eine einzelne Eingabe der Klasse MessageTextInput mit dem Namen input_value, die dem Textfeld entspricht. Der Name muss ein gültiger Python-Variablenname sein, da er ein Attribut der Klasse wird. Wenn eine Komponente als Werkzeug eingestellt wird, werden diese Eingaben automatisch vom KI-Agenten ausgefüllt. Es verwendet das Feld info, um zu bestimmen, wie die Eingabe aussehen soll. Langflow unterstützt mehrere Arten von Eingaben. Hier ist eine vollständige Liste der unterstützten Eingänge.
3. In diesem Teil werden die Ausgaben definiert. Das Feld method gibt die Funktion an, die ausgeführt wird, um die Ausgabe zu erzeugen. Die Funktion hat über self Zugriff auf den Eingang. Zum Beispiel heißt die Eingabe in dieser Instanz input_value, also können wir sie mit self.input_value aufrufen. Der Rückgabewert sollte eine Klasse aus den unterstützten Ausgabeklassen sein.

Weitere Informationen zur Erstellung einer benutzerdefinierten Komponente findest du in der die offizielle Dokumentation der Langflow-Komponente.

Hier ist ein Beispiel dafür, wie wir eine Komponente erstellen können, die zwei Zahlen addiert:

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

Aufbau eines Sprachlehrers mit Langflow

Lass uns einen KI-Agenten bauen, der uns beim Erlernen einer neuen Sprache hilft, unsere Lesefähigkeiten zu trainieren.

Wenn du eine neue Sprache lernst, ist meiner Erfahrung nach eine der besten Möglichkeiten, deine Fähigkeiten zu verbessern, zu lesen. Natürlich kennst du am Anfang nur ein paar Wörter, sodass es unmöglich ist, ein Buch zu lesen. Deshalb wollen wir Lesematerialien haben, die sich auf den Wortschatz konzentrieren, den wir bereits kennen.

Wir werden einen LLM nutzen, um kleine Geschichten zu erstellen, die wir lesen können. Um jedoch ein personalisiertes Lernerlebnis zu haben, wollen wir, dass sich die Geschichten, die es generiert, auf den Wortschatz konzentrieren, den wir bereits kennen.

Hier ist eine Aufschlüsselung dessen, was wir brauchen:

1. Eine Datenbank mit bekannten Vokabeln.
2. Der KI-Agent benötigt Zugriff auf die Datenbank, um das bekannte Vokabular abzurufen und eine Geschichte zu erstellen.
3. Der KI-Agent braucht Zugriff auf die Datenbank, um neue Wörter hinzuzufügen.

Komponente zur Einrichtung der Datenbank

Wenn wir Docker verwenden, um Langflow zu starten, wird eine Postgres-Datenbank hochgefahren. Wir können sie mit dem Paket psycopg2 aufrufen. Um mehr über Postgres zu erfahren, schau dir dieses PostgreSQL-Tutorial.

Wir werden einen Knotenpunkt erstellen, an dem wir eine CSV-Datei mit bekannten Wörtern hochladen können, um die Datenbank zu initialisieren. Meine CSV-Datei sieht wie folgt aus:

Ich habe eine Komponente mit zwei Eingängen erstellt.

1. Ein Spaltenname, um die Spalte anzugeben, die die Wörter enthält, die wir einschließen wollen.
2. Eine Dateieingabe, um die CSV-Datei mit den Wörtern bereitzustellen.

Hier ist der Code der Komponente:

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

Die Komponente sieht wie folgt aus:

Er ist für den alleinigen Gebrauch gedacht und nicht mit anderen Komponenten verbunden. Damit können wir Wörter manuell in die Datenbank hochladen.

Werkzeug zum Hinzufügen von Wörtern

Hier erstellen wir ein Werkzeug, mit dem der KI-Agent neue Wörter zur Datenbank hinzufügen kann. Auf diese Weise kann der Nutzer ganz einfach neue Wörter hinzufügen, indem er eine Nachricht an den Agenten schickt.

Dieser Code verwendet die Funktionen connect_to_database() und add_word() aus dem vorherigen Knotenpunkt wieder. Mit einem besseren Docker-Setup können wir die Wiederholung des Codes vermeiden, aber für dieses Tutorial wollen wir es einfach halten.

Hier ist der Code für dieses 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}"

Beachte, dass dieses Tool davon ausgeht, dass die Datenbank zuvor erstellt wurde. Es wird nicht funktionieren, ohne dass du die vorherige Komponente mindestens einmal ausgeführt hast.

Denke daran, den Werkzeugmodus zu aktivieren:

Werkzeug zum Erstellen von Geschichten

Um eine Geschichte zu erstellen, verwenden wir eine KI-Agentenkomponente. Hier ist die Struktur:

In den Anweisungen für den Agenten haben wir die Eingabeaufforderung nicht direkt in die Komponente eingefügt, sondern eine KomponentePrompt verwendet , weil wir damit Parameter zur Eingabeaufforderung hinzufügen können. Das ist die Aufforderung, die wir verwendet haben:

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

{words}

Die Eingabeaufforderung hat zwei Parameter, {language} und {words}. Wenn du auf diese Weise Parameter hinzufügst, wird der Komponente ein Feld für jeden dieser Parameter hinzugefügt.

Den Wert für die Sprache geben wir einfach in das Textfeld ein. Die Wörter müssen aus der Datenbank geladen werden, also haben wir eine benutzerdefinierte Komponente erstellt, die alle Wörter aus der Datenbank lädt und die Ausgabe dieses Knotens mit dem Feld Wörter verbindet.

Hier ist der Code der Wordloader-Komponente:

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

Als nächstes stellen wir den Agenten als Werkzeug ein. Auf diese Weise kann der Hauptagent (den wir als Nächstes erstellen) diesen Agenten nutzen, um bei Bedarf eine Geschichte zu erstellen.

Zum Schluss benennen wir den Agenten um und ändern die Werkzeugbeschreibung, damit die KI weiß, wann sie dieses Werkzeug einsetzen soll:

Sprachmittler

Für den Hauptagenten verwenden wir eine reguläre KI-Agenten-Knotenkomponente, die mit den beiden von uns erstellten Tools verknüpft ist. Dieser Agent verwendet eine Chat-Eingangs- und eine Chat-Ausgangskomponente, damit wir mit ihm über die Chat-Schnittstelle interagieren können.

Hier ist die endgültige Architektur:

Die Aufforderung, die wir benutzt haben, war:

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.

Wir können den gesamten Workflow ausführen, indem wir auf die Schaltfläche "Playground" klicken. Hier ist ein Beispiel für eine Interaktion:

Fazit

Wir haben die grundlegenden Aspekte von Langflow erforscht und herausgefunden, wie man sie nutzen kann, um einen KI-Agenten-Workflow zu entwickeln, der Nutzern beim Üben ihrer Lesefähigkeiten hilft. Indem wir Python verwenden, um eigene Komponenten zu erstellen, erschließen wir mehr Möglichkeiten. 

Dieser hybride Ansatz vereint das Beste aus beiden Welten: die Flexibilität von Python-Skripten, mit denen jede beliebige Aufgabe ausgeführt werden kann, und die intuitive grafische Oberfläche von Langflow, die die Erstellung von Arbeitsabläufen vereinfacht, ohne dass man sich in komplexen Code vertiefen muss.

Wenn du mehr über KI-Agenten erfahren möchtest, empfehle ich dir, diese Blogs zu lesen:

• Der Codex von OpenAI: Ein Leitfaden mit 3 praktischen Beispielen
• n8n: Ein Leitfaden mit praktischen Beispielen
• Haystack AI Tutorial: Agentische Workflows aufbauen
• Das Agent Development Kit (ADK) von Google: Ein Leitfaden mit Demo-Projekt
• Agent2Agent (A2A): Definition, Beispiele, MCP-Vergleich