Langflow einrichten: 12 Schritte, 155.500 Stars [2026]

Wer heute eine RAG-Pipeline oder einen Tool-nutzenden Agenten bauen will, landet fast automatisch bei einem visuellen Builder statt bei purem Python-Code. Langflow hat sich dabei zu einem der meistgenutzten Werkzeuge in diesem Bereich entwickelt: Das Projekt zählt laut GitHub-Repository aktuell 155.543 Sterne und 10.187 Forks, steht unter MIT-Lizenz und gehört seit der Übernahme von DataStax durch IBM zum IBM-Ökosystem. Dieser Tutorial zeigt in zwölf Schritten, wie du Langflow lokal installierst, einen RAG-Flow aufbaust, eine eigene Python-Komponente schreibst und das Ergebnis als REST-API oder MCP-Server für andere Tools freigibst.

Der Zeitpunkt ist kein Zufall. Im August 2026 hat FlowiseAI sein Repository archiviert und die Weiterentwicklung eingestellt, laut Berichten wegen eines Strategiewechsels hin zu Coding-Agenten. Wer bisher auf Flowise gesetzt hat, sucht gerade nach einem Ersatz, und Langflow füllt diese Lücke mit einem Python-nativen Ansatz, integriertem MCP-Server und aktiver Release-Kadenz (zuletzt Version 1.12.4 am 29. September 2026). Rechne für die komplette Einrichtung inklusive erstem RAG-Flow und einer eigenen Komponente etwa 60 bis 90 Minuten ein, je nachdem wie vertraut du bereits mit Python-Umgebungen bist.

Anders als ein reines No-Code-Tool verspricht Langflow keine Zauberei ohne Code. Jede Komponente bleibt editierbarer Python-Code, was den Einstieg etwas technischer macht, dafür aber verhindert, dass du an eine Blackbox gebunden bist, sobald die Anforderungen über das Standardschema hinausgehen. Für Entwicklerteams, die zwischen schnellem Prototyping und produktivem Einsatz pendeln, ist das der entscheidende Unterschied zu stark vereinfachten Drag-and-drop-Baukästen.

Was ist Langflow und wofür wird es eingesetzt?

Langflow ist ein Open-Source-Framework zum visuellen Bauen von LLM-Anwendungen, Agenten und RAG-Pipelines. Statt Python-Skripte von Hand zu schreiben, ziehst du Komponenten auf eine Arbeitsfläche und verbindest sie zu einem ausführbaren Flow. Jede Komponente ist dabei tatsächlich Python-Code, den du bei Bedarf öffnen und anpassen kannst. Das unterscheidet Langflow von rein deklarativen No-Code-Tools und macht es zur ersten Wahl für Teams, die zwischen schnellem Prototyping und produktivem Code wechseln müssen.

Technisch bringt Langflow eine Reihe fertiger Bausteine mit: Dokumenten-Loader, Text-Splitter, Embeddings, Vektorspeicher, Retriever, Prompt-Templates, LLM-Aufrufe und Agenten-Komponenten mit Tool-Calling. Jeder fertige Flow lässt sich über eine REST-API oder, seit einigen Versionen, direkt als MCP-Server (Model Context Protocol) bereitstellen. Damit wird ein in Langflow gebauter Flow zu einem Tool, das Claude, andere MCP-fähige Clients oder eigene Agenten direkt aufrufen können, ohne dass du eine separate API-Schicht programmieren musst.

Unter der Haube läuft ein FastAPI-Backend, das die Flow-Logik ausführt, kombiniert mit einer React-basierten Oberfläche für den visuellen Editor. Standardmäßig speichert Langflow Flows, Nutzer und Logs in einer lokalen SQLite-Datenbank, für den Mehrbenutzerbetrieb lässt sich das auf Postgres umstellen (dazu mehr in Schritt 12). Neue Projekte starten nicht zwingend bei null: Die Oberfläche bietet vorgefertigte Templates für typische Szenarien wie einfache Chatbots, Dokumenten-Q&A oder Agenten mit Websuche, die sich direkt als Ausgangspunkt übernehmen und anpassen lassen.

In der Praxis taucht Langflow heute vor allem in vier Szenarien auf: als interner Kundenservice-Bot, der auf Produktdokumentation zugreift, als Wissenssuche über große Mengen interner PDFs und Wikis, als Vorverarbeitungs-Pipeline für Dokumentenanalyse und Klassifizierung, und als Experimentierumgebung, in der Teams verschiedene Prompt-Varianten oder Modelle gegeneinander testen, bevor eine Entscheidung in produktiven Code überführt wird. Gerade der letzte Punkt erklärt, warum auch Teams mit starker Python-Erfahrung freiwillig zum visuellen Editor greifen: Die Iterationsgeschwindigkeit beim Testen von Prompts ist im Playground schlicht höher als bei einem Skript, das nach jeder Änderung neu gestartet werden muss.

Kennzahl	Wert
GitHub-Sterne	155.543
Forks	10.187
Lizenz	MIT
Aktuelle Version	1.12.4 (29. September 2026)
Python-Anforderung	3.10 bis unter 3.15
Standard-Port	7860
Eigentümer	DataStax (Teil von IBM seit Mai 2025)

Voraussetzungen: Das brauchst du für die Installation

Bevor du startest, solltest du folgende Punkte abhaken. Die Angaben stammen aus der offiziellen Langflow-Installationsdokumentation und beziehen sich auf den Stand Oktober 2026. Die Mindestwerte reichen für einzelne Test-Flows, bei mehreren parallelen RAG-Pipelines mit lokalen Embedding-Modellen solltest du großzügiger planen.

• Python 3.10, 3.11, 3.12, 3.13 oder 3.14 (nicht 3.15 oder neuer)
• Mindestens 4 GB RAM, empfohlen werden 8 GB für parallele Flows
• Mindestens 2 GB freier Speicherplatz für Installation und Flow-Datenbank
• Windows 10 (64-Bit), macOS 10.15 oder neuer, oder eine aktuelle Linux-Distribution
• Internetzugang für den Zugriff auf externe LLM-Anbieter wie OpenAI, Anthropic oder Mistral
• Optional: Docker Desktop oder Docker Engine, falls du die Container-Variante bevorzugst
• Optional: uv als schnellerer Paketmanager statt pip

Einen API-Key brauchst du außerdem für mindestens einen LLM-Anbieter. Für dieses Tutorial reicht ein kostenloses oder günstiges Kontingent bei OpenAI, Anthropic oder einem lokalen Modell über Ollama völlig aus. Wenn du ausschließlich lokale Modelle nutzen willst, brauchst du zusätzlich genügend RAM oder eine GPU für das jeweilige Modell, das zählt dann aber als Anforderung des Modells und nicht von Langflow selbst.

Langflow im Vergleich: Dify, Flowise und n8n

Bevor du dich festlegst, lohnt ein Blick auf die Alternativen. Alle vier Tools lösen ein ähnliches Problem, setzen aber unterschiedliche Schwerpunkte. Dify positioniert sich als vollständige Plattform für den Betrieb von KI-Apps inklusive Wissensdatenbanken und Nutzerverwaltung, n8n deckt klassische Automatisierung mit Hunderten SaaS-Integrationen ab und hat LLM-Knoten nur als einen Baustein unter vielen. Flowise war technisch am nächsten an Langflow, wurde aber im August 2026 archiviert und wird nicht mehr weiterentwickelt.

Tool	GitHub-Sterne	Status	Schwerpunkt
Langflow	155.543	Aktiv, Version 1.12.4	Python-native LLM- und Agenten-Flows, MCP-Server
Dify	157.961	Aktiv	Komplettplattform für AI-Apps und Wissensdatenbanken
n8n	206.762	Aktiv	Allgemeine Automatisierung, LLM als ein Baustein von vielen
Flowise	55.484	Archiviert (August 2026)	War JavaScript-nativer Builder für LLM-Apps

Für Teams, die bereits mit LangChain oder LangGraph arbeiten, ist Langflow oft die naheliegendste Wahl, weil sich Komponenten aus beiden Welten wiederverwenden lassen. Wer eher eine fertige App-Plattform mit Nutzerverwaltung sucht, schaut sich stattdessen Dify an. Und wer ohnehin schon n8n für Geschäftsprozesse einsetzt, kann LLM-Aufrufe dort einfach als zusätzlichen Knoten ergänzen, statt ein zweites Tool zu betreiben. Die Entscheidung hängt also weniger davon ab, welches Tool objektiv besser ist, sondern davon, welchen Stack dein Team bereits kennt und wie tief die KI-Logik in bestehende Prozesse eingebettet werden muss.

Komponenten-Bibliothek: Welche Anbieter Langflow unterstützt

Bevor es an die Installation geht, lohnt ein kurzer Blick darauf, wie breit die mitgelieferte Komponenten-Bibliothek tatsächlich aufgestellt ist, denn das entscheidet, wie viel du selbst nachbauen musst. Bei den Sprachmodellen deckt Langflow unter anderem OpenAI, Anthropic, Mistral, Google, Azure OpenAI, Amazon Bedrock und lokale Modelle über Ollama ab, jeweils als fertige Drag-and-drop-Komponente. Bei Vektorspeichern stehen neben Chroma auch Anbindungen an Pinecone, Qdrant, Milvus, Weaviate und pgvector zur Auswahl, sodass du bei einer bestehenden Vektordatenbank im Unternehmen in der Regel nicht komplett neu anfangen musst.

Für Dokumente unterstützt Langflow verschiedene Loader-Komponenten für PDF, DOCX, CSV, HTML und einfache Textdateien, ergänzt um Loader für Webseiten und APIs. Welche Kombination aus Modell, Vektorspeicher und Loader für dein Projekt sinnvoll ist, hängt stark davon ab, wo deine Dokumente bereits liegen und ob du aus Datenschutzgründen auf externe Cloud-Dienste verzichten musst. Für den Einstieg in diesem Tutorial reicht die lokale Chroma-Variante völlig aus, sie benötigt keine separate Serverinstallation und läuft direkt im Langflow-Prozess mit.

Schritt 1 und 2: Python-Umgebung vorbereiten und Langflow installieren

Lege zuerst eine isolierte virtuelle Umgebung an. Das verhindert, dass sich Langflow mit anderen Python-Projekten auf deinem System in die Quere kommt, was besonders bei LangChain-Abhängigkeiten schnell zu Versionskonflikten führt. Öffne ein Terminal und führe aus:

python3 -m venv langflow-env
source langflow-env/bin/activate   # Windows: langflow-env\Scripts\activate

pip install -U pip
pip install langflow

Alternativ installierst du über uv, das deutlich schneller auflöst und installiert als klassisches pip, weil es Abhängigkeiten parallel herunterlädt und in Rust statt Python implementiert ist:

uv venv langflow-env
source langflow-env/bin/activate
uv pip install langflow -U

Der Download zieht einige Hundert Megabyte an Abhängigkeiten, darunter FastAPI, SQLModel und diverse LangChain-Pakete. Rechne je nach Verbindung mit zwei bis fünf Minuten, auf langsamen Verbindungen auch deutlich länger. Das aktuelle Paket findest du jederzeit auf PyPI, falls du eine bestimmte Version fixieren möchtest. Starte Langflow danach mit einem einzigen Befehl:

langflow run

Die Konsole zeigt nach kurzer Initialisierung eine Ausgabe ähnlich dieser:

Langflow version: 1.12.4
Starting Langflow...
INFO: Uvicorn running on http://127.0.0.1:7860 (Press CTRL+C to quit)
Access Langflow at: http://localhost:7860

Öffne die angezeigte Adresse im Browser und du siehst den Langflow-Workspace mit leerer Arbeitsfläche. Beim allerersten Start legt Langflow automatisch einen lokalen Admin-Zugang an, den du in Schritt 5 über Umgebungsvariablen gezielt überschreiben kannst.

Schritt 3: Alternative – Langflow mit Docker starten

Wenn du Python-Versionskonflikte komplett vermeiden willst oder Langflow auf einem Server ohne lokale Python-Installation betreiben möchtest, ist Docker die sauberere Variante. Das offizielle Image lässt sich mit einer Zeile starten:

docker run -d --name langflow \
  -p 7860:7860 \
  -v langflow_data:/app/langflow \
  langflowai/langflow:latest

Das Volume langflow_data sorgt dafür, dass deine Flows einen Container-Neustart überleben. Prüfe mit docker logs -f langflow, ob der Container sauber gestartet ist, und rufe anschließend ebenfalls http://localhost:7860 auf. Für Teams, die Langflow dauerhaft auf einem eigenen Server betreiben, ist diese Variante meist die pflegeleichtere, weil Updates nur noch einen neuen Image-Pull statt eines manuellen Pip-Upgrades erfordern.

Schritt 4: Erster Start – Oberfläche und Workspace kennenlernen

Nach dem ersten Login landest du auf der Projektübersicht. Lege über “New Flow” einen leeren Flow an oder wähle eines der mitgelieferten Templates als Startpunkt. Für den Einstieg lohnt sich ein leerer Flow, weil du dabei jede Komponente bewusst selbst platzierst und so ein Gefühl für die Logik bekommst. Wirf einen Blick auf die drei zentralen Bereiche: links die Komponenten-Bibliothek, in der Mitte die Arbeitsfläche (Canvas) und rechts die Konfiguration der aktuell ausgewählten Komponente.

Jede Komponente hat Ein- und Ausgänge, die du per Drag-and-drop verbindest. Ein grüner Rand bedeutet, dass die Komponente korrekt konfiguriert ist, ein roter Rand zeigt ein fehlendes Pflichtfeld an. Oben rechts findest du außerdem den Playground-Button, mit dem du jeden Flow sofort testen kannst, ohne ihn vorher zu deployen. Das beschleunigt die Entwicklung erheblich, weil du Änderungen an Prompt oder Modellparametern direkt im Browser prüfst, statt den Server neu zu starten oder eine separate Testumgebung aufzusetzen.

Schritt 5: API-Schlüssel für LLM-Anbieter hinterlegen

Bevor ein Flow sinnvoll antworten kann, braucht er Zugriff auf ein Sprachmodell. Lege dazu eine .env-Datei im Startverzeichnis an oder nutze den globalen Variablen-Manager in der Langflow-Oberfläche (Einstellungen → Global Variables). Für die Kommandozeilen-Variante:

# .env
OPENAI_API_KEY=sk-dein-schluessel
ANTHROPIC_API_KEY=sk-ant-dein-schluessel
LANGFLOW_SUPERUSER=admin
LANGFLOW_SUPERUSER_PASSWORD=ein-sicheres-passwort

Starte Langflow danach mit langflow run --env-file .env, damit die Variablen geladen werden. In der Oberfläche kannst du Schlüssel pro Komponente oder global hinterlegen, global ist sinnvoller, wenn mehrere Flows denselben Anbieter nutzen. Lege für Produktionsumgebungen niemals Schlüssel direkt im Flow-JSON ab, da dieses beim Export mitexportiert wird und sich damit leicht versehentlich in einem geteilten Repository oder einer Slack-Nachricht wiederfindet.

Schritt 6: Den ersten Chat-Flow bauen

Ziehe folgende vier Komponenten auf die Arbeitsfläche und verbinde sie in dieser Reihenfolge: Chat Input, Prompt Template, OpenAI (oder ein anderer LLM-Baustein), Chat Output. Trage im Prompt-Template einen einfachen Systemtext ein, etwa “Du bist ein hilfreicher Assistent, der kurz und präzise auf Deutsch antwortet. Frage: {input}”. Verbinde den Ausgang von Chat Input mit der Variable input im Prompt-Template.

Klicke auf Playground und stelle eine Testfrage. Eine typische Antwort im Playground-Fenster sieht so aus:

Du: Was ist der Unterschied zwischen RAG und Fine-Tuning?
Assistent: RAG ergaenzt eine Anfrage zur Laufzeit mit externen Dokumenten,
waehrend Fine-Tuning das Modell selbst durch zusaetzliches Training veraendert.
RAG ist guenstiger und schneller aktualisierbar, Fine-Tuning eignet sich
besser fuer feste Stilvorgaben oder Domaenensprache.

Damit läuft dein erster funktionierender Flow. Speichere ihn über das Diskettensymbol, bevor du weitermachst, und vergib einen aussagekräftigen Namen, damit du ihn später in der Projektübersicht wiederfindest.

Schritt 7: RAG-Pipeline mit eigenen Dokumenten aufsetzen

Für eine Retrieval-Augmented-Generation-Pipeline erweiterst du den Flow um fünf weitere Bausteine: File Loader, Split Text, Embedding Model, Vector Store (zum Beispiel Chroma oder eine lokale Variante) und Retriever. Lade über File Loader ein PDF oder eine Textdatei hoch, stelle bei Split Text eine Chunk-Größe von 500 bis 1000 Zeichen mit 100 Zeichen Überlappung ein und verbinde die Ausgabe mit dem Embedding-Baustein.

Der Vector Store speichert die Embeddings, der Retriever holt bei jeder Anfrage die passendsten Textausschnitte zurück. Verbinde den Retriever-Ausgang mit einer zweiten Prompt-Template-Variable, zum Beispiel {context}, und passe den Prompt an: “Beantworte die Frage ausschließlich anhand des folgenden Kontexts: {context}. Frage: {input}”. Dieser Aufbau ist exakt das Muster, das auch Tools wie LlamaIndex mit Qdrant verfolgen, nur eben visuell statt in Code. Der Vorteil beim visuellen Aufbau zeigt sich vor allem beim Debuggen: Du siehst in Langflow nach jedem Testlauf, welche Textausschnitte der Retriever tatsächlich zurückgegeben hat, und kannst so direkt erkennen, ob eine falsche Antwort an schlechtem Retrieval oder an einem ungünstigen Prompt liegt.

Schritt 8: Eigene Python-Komponente entwickeln

Der größte Unterschied zu rein deklarativen Buildern zeigt sich hier: Du kannst jede fehlende Funktion als eigene Python-Komponente nachbauen. Klicke auf “New Custom Component” und ersetze den Beispielcode durch eine eigene Logik, etwa einen Baustein, der Text in Großbuchstaben normalisiert und die Zeichenanzahl zählt:

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

class TextNormalizerComponent(Component):
    display_name = "Text Normalizer"
    description = "Normalisiert Text und zaehlt Zeichen."

    inputs = [
        MessageTextInput(name="text_input", display_name="Eingabetext"),
    ]
    outputs = [
        Output(display_name="Ergebnis", name="result", method="process"),
    ]

    def process(self) -> Data:
        normalized = self.text_input.strip().upper()
        return Data(data={
            "normalized_text": normalized,
            "character_count": len(normalized),
        })

Speichere die Komponente, sie erscheint danach in der Komponenten-Bibliothek unter “Custom” und lässt sich wie jeder andere Baustein auf die Arbeitsfläche ziehen. Das ist der Hebel, mit dem du Langflow über die mitgelieferten Bausteine hinaus erweiterst, etwa um eigene API-Aufrufe, Datenbankzugriffe, Validierungslogik oder die Anbindung an interne Systeme, für die es keinen fertigen Baustein gibt. In der Praxis sammeln viele Teams nach einigen Monaten eine eigene kleine Bibliothek an Komponenten, die unternehmensspezifisches Wissen kapseln und sich in jedem neuen Flow wiederverwenden lassen.

Schritt 9: Agenten und Tool-Calling konfigurieren

Statt eines einzelnen Prompt-zu-Antwort-Flows kannst du einen Agenten bauen, der selbst entscheidet, welches Werkzeug er benutzt. Ersetze dazu den einfachen LLM-Baustein durch die Komponente Agent und hänge mehrere Tool-Komponenten an, zum Beispiel eine Web-Search-Komponente und deinen Retriever aus Schritt 7. Der Agent erhält damit zwei Werkzeuge: Websuche für aktuelle Informationen und den eigenen Dokumentenbestand für firmeninternes Wissen.

Im Playground erkennst du den Unterschied an den Zwischenschritten: Der Agent zeigt an, welches Tool er aufgerufen hat und mit welchem Ergebnis, bevor er die finale Antwort formuliert. Das macht Fehlentscheidungen des Agenten sofort nachvollziehbar, etwa wenn er die Websuche nutzt, obwohl die Antwort bereits in den eigenen Dokumenten steht. Wer bereits mehrstufige Agenten-Orchestrierung mit explizitem Zustand kennt, findet in LangGraph ein textbasiertes Gegenstück zu diesem visuellen Agenten-Baustein, mit feinerer Kontrolle über einzelne Übergänge.

Schritt 10 und 11: Flow als REST-API und MCP-Server bereitstellen

Ein fertiger Flow ist erst dann nützlich, wenn andere Anwendungen ihn aufrufen können. Klicke dazu auf “API” oben rechts im Flow-Editor. Langflow generiert automatisch ein Code-Beispiel für den Aufruf in mehreren Sprachen. Ein typischer curl-Aufruf sieht so aus:

curl -X POST "http://localhost:7860/api/v1/run/DEINE-FLOW-ID" \
  -H "Content-Type: application/json" \
  -d '{
    "input_value": "Was ist der Unterschied zwischen RAG und Fine-Tuning?",
    "output_type": "chat",
    "input_type": "chat"
  }'

Die Antwort kommt als JSON-Objekt mit dem generierten Text im Feld outputs zurück, gekürzt sieht eine typische Antwort so aus:

{
  "session_id": "DEINE-FLOW-ID",
  "outputs": [
    {
      "outputs": [
        {
          "results": {
            "message": {
              "text": "RAG ergaenzt eine Anfrage zur Laufzeit mit externen Dokumenten..."
            }
          }
        }
      ]
    }
  ]
}

Für MCP-Clients gehst du einen anderen Weg: Unter “Projekte” aktivierst du für dein Projekt den Schalter “MCP Server”. Danach ist jeder Flow in diesem Projekt automatisch als MCP-Tool unter der Adresse http://localhost:7860/api/v1/mcp/sse ansprechbar. Verbinde einen MCP-fähigen Client wie Claude Desktop oder deinen eigenen MCP-Server mit dieser Adresse, und der Flow erscheint dort als aufrufbares Tool mit Namen und Beschreibung, genau wie ein klassisches Function-Calling-Tool.

Schritt 12: Produktivbetrieb mit Docker Compose und Postgres

Die Standardinstallation speichert Flows in einer lokalen SQLite-Datei, das reicht für Tests, aber nicht für mehrere gleichzeitige Nutzer oder einen Server-Neustart ohne Datenverlustrisiko. Für den Produktivbetrieb ergänzt du eine Postgres-Datenbank per Docker Compose:

services:
  langflow:
    image: langflowai/langflow:latest
    ports:
      - "7860:7860"
    environment:
      - LANGFLOW_DATABASE_URL=postgresql://langflow:langflow@postgres:5432/langflow
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=ein-sicheres-passwort
    depends_on:
      - postgres
  postgres:
    image: postgres:16
    environment:
      - POSTGRES_USER=langflow
      - POSTGRES_PASSWORD=langflow
      - POSTGRES_DB=langflow
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Starte den Stack mit docker compose up -d. Setze zusätzlich einen Reverse Proxy wie nginx oder Caddy davor, wenn Langflow über das Internet erreichbar sein soll, und aktiviere TLS. Ohne Authentifizierung ist die Langflow-API offen für jeden, der die Adresse kennt, deshalb ist ein gesetztes Superuser-Passwort hier kein optionaler Schritt, sondern die Mindestabsicherung vor dem ersten produktiven Einsatz.

Sicherheit und Datenschutz bei selbstgehosteten KI-Workflows

Für Unternehmen in Deutschland, Österreich und der Schweiz ist der Datenschutz oft der eigentliche Grund, warum ein selbstgehostetes Tool wie Langflow überhaupt infrage kommt. Da Flows, Dokumente und Embeddings standardmäßig lokal oder auf eigener Infrastruktur liegen, bleibt die Kontrolle darüber, wohin Daten fließen, vollständig beim Betreiber. Das ändert sich aber in dem Moment, in dem ein Flow externe LLM-APIs wie OpenAI oder Anthropic aufruft: Jede Anfrage, die dort hinausgeht, verlässt die eigene Infrastruktur und unterliegt den Datenschutzbedingungen des jeweiligen Anbieters.

Für Dokumente mit personenbezogenen oder vertraulichen Daten solltest du deshalb vorab klären, welche Inhalte überhaupt an externe Modelle gehen dürfen und ob ein lokales Modell über Ollama oder ein EU-gehostetes Angebot die bessere Wahl ist. Praktisch heißt das: Trenne RAG-Flows mit sensiblen Dokumenten von Flows, die unkritische Inhalte verarbeiten, und dokumentiere pro Flow, welcher Modellanbieter beteiligt ist. Zusätzlich lohnt sich ein Blick auf LangChain, falls du Logging- und Audit-Funktionen tiefer in den Code integrieren willst, als es die Langflow-Oberfläche standardmäßig erlaubt.

Technisch gehören drei Maßnahmen zur Grundausstattung: ein gesetztes Superuser-Passwort statt der Werkseinstellung, ein Reverse Proxy mit TLS vor jeder öffentlich erreichbaren Instanz und eine Trennung zwischen Test- und Produktionsumgebung mit jeweils eigenen API-Keys. Ergänzend solltest du den Zugriff auf die Admin-Oberfläche per IP-Filter oder VPN einschränken, wenn Langflow nicht für die breite Öffentlichkeit gedacht ist, da offene Admin-Oberflächen ein naheliegendes Ziel für automatisierte Scans sind. Für regulierte Branchen wie Finanzdienstleister oder Gesundheitswesen lohnt sich zusätzlich ein Blick darauf, ob und wie lange Anfragen und Antworten in den Langflow-Logs gespeichert werden, damit die eigene Löschfrist-Dokumentation zu dem passt, was tatsächlich auf dem Server liegt.

Teamarbeit: Projekte, Nutzerrollen und Zusammenarbeit

Sobald mehr als eine Person an denselben Flows arbeitet, wird die Projektstruktur in Langflow wichtig. Jeder Flow gehört zu einem Projekt, und jedes Projekt lässt sich separat mit eigenen Nutzern, eigenen globalen Variablen und einem eigenen MCP-Server-Schalter versehen. Das erlaubt eine saubere Trennung zwischen Abteilungen oder Kunden, ohne dass sich API-Keys oder Flows versehentlich vermischen. Der angelegte Superuser aus Schritt 5 hat dabei vollen Zugriff auf alle Projekte, während normale Nutzer in der Regel nur auf die ihnen zugewiesenen Projekte zugreifen.

Für die praktische Zusammenarbeit empfiehlt sich ein einfaches Muster: ein Projekt pro Anwendungsfall statt ein Projekt pro Person. So bleibt die Struktur auch dann übersichtlich, wenn das Team wächst, und neue Kolleginnen und Kollegen finden sich anhand der Projektnamen schneller zurecht als bei Dutzenden persönlichen Experimentier-Flows. Exportiere zusätzlich jeden produktiven Flow regelmäßig als JSON in ein gemeinsames Repository, damit Änderungen über eine normale Code-Review-Pull-Request-Routine laufen, statt nur in der Weboberfläche zu passieren.

Performance-Tuning: Wenn Flows langsam werden

Mit wachsender Dokumentenbasis oder mehr gleichzeitigen Nutzern wird die Antwortzeit eines Flows irgendwann zum Thema. Die größte Stellschraube ist in den meisten Fällen nicht Langflow selbst, sondern die Konfiguration der einzelnen Komponenten. Ein Embedding-Modell mit hoher Dimensionalität liefert zwar oft etwas bessere Retrieval-Qualität, kostet dafür aber messbar mehr Rechenzeit pro Anfrage. Teste deshalb, ob ein kleineres Embedding-Modell bei deinem Dokumentenbestand einen akzeptablen Kompromiss zwischen Geschwindigkeit und Treffergenauigkeit liefert.

Beim LLM-Aufruf selbst hilft Streaming, die gefühlte Wartezeit zu senken, weil der Nutzer bereits die ersten Worte der Antwort sieht, während der Rest noch generiert wird. Aktiviere diese Option im Chat-Output-Baustein, sofern der genutzte Anbieter Streaming unterstützt. Für Agenten mit mehreren Tool-Aufrufen pro Anfrage lohnt sich außerdem ein Blick auf die Reihenfolge der Tools: Platziere schnelle, günstige Tools wie einen lokalen Retriever vor langsamen externen API-Aufrufen, damit der Agent im Idealfall gar nicht erst das teurere Tool benötigt.

Updates und Versionsverwaltung bei Langflow

Mit der aktiven Release-Kadenz von Langflow kommt auch die Aufgabe, regelmäßig zu aktualisieren, ohne dabei produktive Flows zu beschädigen. Prüfe vor jedem Update das Changelog auf GitHub auf Breaking Changes, besonders wenn sich die Struktur einzelner Komponenten geändert hat. Ein typisches Update-Vorgehen bei der pip-Installation sieht so aus:

source langflow-env/bin/activate
pip install -U langflow
langflow run

Bei der Docker-Variante genügt ein neuer Image-Pull samt Neustart des Containers, da die Flow-Daten im separaten Volume liegen und einen Image-Wechsel überleben:

docker pull langflowai/langflow:latest
docker stop langflow && docker rm langflow
docker run -d --name langflow -p 7860:7860 -v langflow_data:/app/langflow langflowai/langflow:latest

Teste nach jedem Update zuerst in einer Staging-Umgebung, ob deine wichtigsten Flows noch wie erwartet laufen, bevor du das Update auf die Produktionsinstanz überträgst. Gerade bei Agenten-Komponenten ändern sich Parameter zwischen Versionen gelegentlich, sodass ein Flow nach dem Update zwar lädt, aber mit leicht veränderten Standardwerten reagiert.

Komplettes Beispielprojekt: Support-Chatbot mit RAG und MCP

Um alle Bausteine zusammenzuführen, hier der Aufbau eines vollständigen, funktionierenden Projekts: ein interner Support-Chatbot, der Firmendokumentation durchsucht und gleichzeitig als MCP-Tool für andere Agenten verfügbar ist. Dieses Projekt lässt sich in einem Nachmittag umsetzen, sobald die Schritte 1 bis 12 einmal durchlaufen sind.

1. Lade alle PDF-Handbücher und FAQ-Dokumente über File Loader in einen eigenen Flow namens “Support-Wissen”
2. Baue die RAG-Kette aus Schritt 7 mit Chunk-Größe 800 und Chroma als Vector Store
3. Ergänze den Agenten-Baustein aus Schritt 9 mit zwei Tools: dem Retriever und einer Komponente, die Tickets in ein externes System schreibt
4. Schreibe die eigene Python-Komponente aus Schritt 8, um Nutzeranfragen vor der Verarbeitung zu bereinigen und zu protokollieren
5. Aktiviere den MCP-Server für das Projekt und stelle den Flow zusätzlich über die REST-API bereit
6. Binde den Flow sowohl in ein internes Chat-Widget (per REST-API) als auch in Claude Desktop (per MCP) ein
7. Setze den gesamten Stack mit der Docker-Compose-Datei aus Schritt 12 produktiv, inklusive Postgres und TLS-Proxy

Das Ergebnis ist ein einziger gepflegter Flow, der gleichzeitig als klassischer Chatbot, als API-Endpunkt für andere Microservices und als Tool für MCP-Agenten dient, ohne dass du die Logik drei Mal implementieren musst. Änderst du später die Chunk-Größe oder tauschst das Embedding-Modell, wirkt sich das automatisch auf alle drei Zugriffswege gleichzeitig aus.

Kosten im Blick: Was ein Langflow-Setup wirklich kostet

Die Software selbst kostet unter MIT-Lizenz nichts, trotzdem entstehen beim Betrieb reale Kosten, die sich auf zwei Posten verteilen. Der erste Posten ist die Infrastruktur: ein kleiner Server, auf dem Langflow und optional Postgres laufen, reicht für Teams mit moderatem Nutzeraufkommen meist völlig aus und liegt preislich deutlich unter dem, was dieselben Teams typischerweise monatlich für LLM-API-Aufrufe ausgeben. Der zweite und in der Praxis größere Posten ist genau diese API-Nutzung: Jeder Aufruf eines externen Modells wie GPT, Claude oder Mistral wird nach Tokens abgerechnet, und ein Agent mit mehreren Tool-Aufrufen pro Anfrage kann schnell ein Vielfaches der Kosten eines einzelnen Prompt-Antwort-Zyklus verursachen.

Um die laufenden Kosten im Griff zu behalten, lohnt es sich, pro Flow ein grobes Budget zu definieren und die tatsächliche Token-Nutzung über die Logs zu beobachten, statt sie erst bei der Rechnung des Modellanbieters zu entdecken. Wer stark kostensensitiv ist, kann für weniger kritische Flows auch komplett auf lokale Modelle über Ollama umsteigen, muss dafür aber die zusätzliche Hardware-Anforderung des jeweiligen Modells selbst einplanen. Für den produktiven Support-Chatbot aus diesem Tutorial ist ein Mittelweg üblich: ein günstigeres Modell für einfache Anfragen und ein leistungsfähigeres Modell nur für komplexere Fälle, die der Agent gezielt erkennt und weiterleitet.

Die häufigsten Stolperfallen beim Einstieg

• Falsche Python-Version: Langflow verlangt mindestens Python 3.10 und läuft nicht mit Python 3.15 oder neuer. Ein System-Python 3.9 oder 3.15 führt zu einem sofortigen Installationsfehler.
• Vergessene virtuelle Umgebung: Wer Langflow direkt ins System-Python installiert, riskiert Versionskonflikte mit anderen Projekten, besonders bei LangChain-Abhängigkeiten.
• API-Key im Flow statt in Variablen: Schlüssel, die direkt in einer Komponente eingetragen werden, landen beim Export des Flow-JSON im Klartext und damit potenziell in einem geteilten Repository.
• Zu große Chunk-Größen bei RAG: Chunks über 1500 Zeichen liefern oft zu viel irrelevanten Kontext und verschlechtern die Antwortqualität, statt sie zu verbessern.
• SQLite in Produktion: Die Standarddatenbank verträgt keine parallelen Schreibzugriffe mehrerer Nutzer zuverlässig, ein Umstieg auf Postgres gehört vor dem Live-Gang dazu.
• Kein Timeout bei externen Tools: Agenten-Tools ohne gesetzten Timeout können einen ganzen Flow blockieren, wenn eine externe API nicht antwortet.
• Zu viele Tools an einem Agenten: Mehr als fünf oder sechs Tools an einem einzigen Agenten-Baustein erhöhen die Wahrscheinlichkeit, dass das Modell das falsche Werkzeug wählt, statt die Treffergenauigkeit zu verbessern.
• Fehlendes Versionsmanagement: Wer Flows nur in der Langflow-Datenbank speichert und nie als JSON exportiert, verliert bei einem Datenbankproblem den gesamten Entwicklungsstand ohne Backup.

Troubleshooting: Lösungen für die häufigsten Probleme

Problem	Wahrscheinliche Ursache	Lösung
Installation bricht mit Python-Fehler ab	Python-Version außerhalb von 3.10–3.14	Mit pyenv oder uv eine passende Version installieren
Port 7860 bereits belegt	Anderer Dienst oder zweite Langflow-Instanz läuft	langflow run --port 7861 verwenden
Flow antwortet mit Authentifizierungsfehler	API-Key fehlt oder ist falsch hinterlegt	Global Variables prüfen, Key neu eintragen
Docker-Container startet, UI bleibt leer	Browser-Cache oder falsche Port-Weiterleitung	Hard-Reload, -p 7860:7860 in der run-Zeile prüfen
RAG liefert irrelevante Antworten	Chunking zu grob oder falsches Embedding-Modell	Chunk-Größe verkleinern, Embedding-Modell wechseln
Custom Component wird nicht angezeigt	Syntaxfehler im Python-Code oder fehlender Reload	Logs mit langflow run --log-level debug prüfen
MCP-Client sieht keine Tools	MCP-Server für das Projekt nicht aktiviert	Projekteinstellungen öffnen, MCP Server-Schalter aktivieren
Hohe Latenz bei jeder Anfrage	Vector Store ohne Index oder zu großes Embedding-Modell	Index auf dem Vector Store erzwingen, kleineres Embedding-Modell testen
Postgres-Verbindung schlägt fehl	Falsche LANGFLOW_DATABASE_URL oder Container-Reihenfolge	depends_on prüfen, Connection-String einzeln testen
Agent bricht mit “Max Iterations” ab	Zu niedriges Iterationslimit oder Tool liefert Endlosschleife	Limit im Agent-Baustein erhöhen, Tool-Logik auf Abbruchbedingung prüfen

Bei den meisten dieser Fehler lohnt sich zuerst ein Blick in die Logs mit aktiviertem Debug-Level, bevor du an der Konfiguration herumprobierst. Gerade bei RAG-Problemen zeigt der Playground außerdem direkt an, welche Textausschnitte der Retriever zurückgegeben hat, was die Fehlersuche gegenüber einer reinen Code-Pipeline deutlich beschleunigt. Wenn ein Fehler nach dem Durchlesen der Logs weiterhin unklar bleibt, hilft häufig ein minimaler Testflow mit nur zwei oder drei Komponenten: Reduzierst du das Problem auf den kleinsten reproduzierbaren Fall, lässt sich meist schnell erkennen, ob die Ursache in einer einzelnen Komponente, in der Umgebungskonfiguration oder im zugrunde liegenden Modell liegt.

Qualitätssicherung: Flows systematisch testen

Ein Flow, der im Playground mit drei Testfragen gut funktioniert, kann bei der zehnten unerwarteten Nutzerfrage trotzdem versagen. Bevor ein RAG-Flow oder Agent produktiv geht, lohnt sich deshalb eine kleine, aber feste Liste von Testfragen, die typische und auch bewusst schwierige Fälle abdeckt: mehrdeutige Formulierungen, Fragen außerhalb der vorhandenen Dokumentation und Fragen, bei denen die richtige Antwort “das weiß ich nicht” lauten sollte. Gerade der letzte Fall wird oft übersehen, führt in der Praxis aber zu den unangenehmsten Situationen, wenn ein Chatbot selbstbewusst eine erfundene Antwort liefert, statt die Wissenslücke zuzugeben.

Lege diese Testfragen zusammen mit der jeweils erwarteten Antwort-Kategorie in einer einfachen Tabelle oder einem Textdokument ab und arbeite sie nach jeder größeren Änderung am Flow erneut durch. Für Teams mit höherem Qualitätsanspruch lässt sich dieser Prozess automatisieren, indem die REST-API aus Schritt 10 per Skript mit der gesamten Testfragenliste durchlaufen und die Antworten mit einem zweiten LLM-Aufruf grob bewertet werden. Das ersetzt keine menschliche Prüfung komplett, verschafft aber einen schnellen Hinweis, ob eine Änderung die Qualität insgesamt verbessert oder verschlechtert hat, bevor ein Flow seinen Weg in die Produktionsumgebung aus Schritt 12 findet.

Fortgeschrittene Tipps für den produktiven Einsatz

Sobald der erste Flow stabil läuft, lohnen sich einige zusätzliche Maßnahmen, die über das reine Tutorial hinausgehen, aber den Unterschied zwischen einem Prototyp und einem belastbaren System ausmachen.

• Nutze Flow-Versionierung über den Export als JSON und lege jede produktive Version in einem eigenen Git-Repository ab, statt nur in der Langflow-Datenbank.
• Trenne Entwicklungs- und Produktions-Instanzen komplett, inklusive eigener Datenbank und eigener API-Keys, um versehentliche Testabfragen auf Produktionskosten zu vermeiden.
• Setze bei Agenten-Tools immer ein Timeout und einen maximalen Iterationszähler, damit ein fehlerhaftes Tool keine Endlosschleife an Modellaufrufen erzeugt.
• Cache häufige Embedding-Berechnungen, wenn sich die Dokumentenbasis selten ändert, das spart bei größeren RAG-Pipelines deutliche API-Kosten.
• Überwache Modellkosten pro Flow über die eingebauten Logs, besonders bei Agenten mit mehreren Tool-Aufrufen pro Anfrage, da sich Kosten hier schnell addieren.
• Kombiniere Langflow mit CrewAI oder LangGraph für Fälle, in denen mehrere spezialisierte Agenten koordiniert zusammenarbeiten müssen, statt alles in einem einzigen Flow abzubilden.
• Richte für produktive Deployments automatisierte Backups der Postgres-Datenbank ein, da dort neben den Flows auch Nutzerkonten und Zugriffsrechte liegen.

Häufig gestellte Fragen zu Langflow

Ist Langflow kostenlos?

Die Open-Source-Version steht unter MIT-Lizenz und lässt sich kostenlos selbst hosten. Kosten entstehen nur für die eigene Infrastruktur sowie für genutzte LLM-APIs, Vektordatenbanken oder Embedding-Dienste, nicht für die Software selbst.

Was ist der Unterschied zwischen Langflow und Flowise?

Flowise war ein JavaScript-natives Gegenstück mit ähnlichem visuellem Ansatz, wurde aber im August 2026 archiviert und wird nicht mehr weiterentwickelt. Langflow ist Python-nativ, aktiv gepflegt und bringt zusätzlich einen integrierten MCP-Server mit.

Unterstützt Langflow das Model Context Protocol (MCP)?

Ja. Jedes Projekt lässt sich über einen Schalter in den Projekteinstellungen als MCP-Server freigeben, wodurch jeder enthaltene Flow automatisch als Tool für MCP-fähige Clients erscheint, ohne zusätzlichen Code.

Welche Python-Version brauche ich für Langflow?

Laut offizieller Dokumentation wird Python 3.10 bis unter 3.15 unterstützt. Ältere oder neuere Versionen führen zu Installationsfehlern, deshalb lohnt sich vor der Installation ein kurzer Check mit python3 --version.

Kann ich Langflow ohne Docker betreiben?

Ja. Die native Installation per pip oder uv ist der Standardweg und läuft auf Windows, macOS und Linux ohne Container. Docker ist lediglich eine Alternative für isolierte oder serverseitige Deployments.

Wie unterscheidet sich Langflow von Dify?

Dify positioniert sich stärker als fertige Plattform für den Betrieb von KI-Anwendungen mit Nutzerverwaltung und Wissensdatenbanken. Langflow ist stärker auf Python-Entwicklung, LangChain-nahe Komponenten und frei erweiterbare Flows ausgerichtet.

Gehört Langflow zu IBM?

Langflow wird von DataStax entwickelt, das IBM im Mai 2025 vollständig übernommen hat. Das Projekt bleibt Open Source unter MIT-Lizenz, profitiert aber von den Ressourcen des IBM-Konzerns.

Eignet sich Langflow für produktive Unternehmensanwendungen?

Mit Postgres-Anbindung, eigenem Reverse Proxy und getrennten Umgebungen für Test und Produktion lässt sich Langflow produktiv betreiben. Für sehr hohe Lastspitzen oder strenge Compliance-Anforderungen solltest du vorab testen, ob die eigene Infrastruktur die gewünschte Nutzerzahl zuverlässig trägt.

Lässt sich ein bestehender Flowise-Flow nach Langflow übertragen?

Einen automatischen Importer für Flowise-Exporte gibt es nicht, da beide Projekte unterschiedliche interne Datenmodelle verwenden. Da die grundlegenden Bausteine wie Loader, Embeddings und LLM-Aufrufe konzeptionell aber vergleichbar sind, lässt sich ein bestehender Flow meist in überschaubarer Zeit händisch in Langflow nachbauen, statt ihn eins zu eins zu migrieren.