Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Einen Langflow-Flow importieren

Diese Schritt-für-Schritt-Anleitung importiert einen aus Langflow exportierten Flow — Basic Prompting, das Starterprojekt, das Langflow 1.6.0 mitliefert — in ein Aggregate, ein Release und ein Manifest, die Langflow samt Flow für Docker Compose so bauen, wie sie geschrieben sind, baut sie anschließend und führt das Ergebnis aus. Jede Datei und jeder Ausgabeblock unten stammt aus einem echten Lauf; der Flow und jede Stufe der Anleitung liegen im Beispiel import-langflow, in dem ein Prüfskript den Import erneut ausführt, das, was er schreibt, was er ausgibt, und die Blöcke, die diese Seite zitiert, mit den dort abgelegten Dateien vergleicht und das, was der Import geschrieben hat, validiert und baut.

Das Beispiel generieren

Sie können diesen Import mit den Befehlen auf dieser Seite ausführen oder ihn von Ihrem KI-Assistenten ausführen lassen.

Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:

Terminal window
aggrega scaffold --example import-langflow

Danach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner; der folgende, unten, wechselt in den Ordner source des neuen Ordners, in dem der Import läuft. Dieser Ordner enthält die Flow-Datei, basic-prompting.json, die diese Seite beschreibt, statt sie zu zitieren:

Terminal window
cd import-langflow

Der source-Ordner des erzeugten Beispiels, geöffnet in Visual Studio Code, mit dem Langflow-Export eines einfachen Prompting-Flows.

Der Flow

Basic Prompting verkettet vier Knoten: einen Chat Input, einen Prompt, ein Language Model, das gpt-4.1 von OpenAI aufruft, und einen Chat Output. So, wie Langflow es ausliefert, ist es eine einzige JSON-Datei, basic-prompting.json, von etwa 54 KB, die neben dem Flow den Quellcode jeder Komponente enthält. Sein Language-Model-Knoten liest seinen Schlüssel aus der globalen Variable OPENAI_API_KEY, die Langflow aus seiner Umgebung liest, wenn keine Variable dieses Namens gespeichert ist.

Neben dem Flow macht eine .aggrega-config.yaml den Ordner zu einem Arbeitsbereich:

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside basic-prompting.json.
workspace: {}
# The registry the importer is fetched from the first time an import needs it.
default_registry: hub.aggrega.ai

und import-answers.yaml enthält die Antworten auf das, was kein Flow enthalten kann. Ein Import für Docker Compose braucht keine davon: Er bindet jeden geheimen Wert über eine Variablenreferenz an, die Docker Compose aus Ihrer Shell füllt. Ein Import für Kubernetes bindet jeden geheimen Wert über den Namen eines Kubernetes-Secrets an, den nur Sie nennen können, daher nennt die Datei die beiden Secrets, nach denen dieser Import fragt (siehe Auf Kubernetes):

# Values the import could not draft from the source, keyed by the drafted file and the key path inside
# it. Write each one beside its key; an import of the same source, and a sync, read them from here and
# ask nothing. A secret is never written here: its key asks where the secret comes from — a variable
# name, ${NAME}, or the name of a Kubernetes Secret.
release.yaml:
# The origin of the secret value, written by the operator in the Release. Read exactly as
# values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes
# from, never the value.
spec.components.langflow.features.admin_password.infra.origin: "langflow-admin"
# The origin of the secret value, written by the operator in the Release. Read exactly as
# values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes
# from, never the value.
spec.components.langflow.uses.model.languagemodelcomponent-kboja.features.credential.infra.origin: "openai-api-key"

Jede Antwort ist der Name eines Secrets, niemals der geheime Wert selbst, daher kann die Datei zusammen mit dem Flow aufbewahrt werden. Die Importantwortdatei beschreibt die Datei vollständig.

Der Import gleicht jeden Knoten mit den Components des Katalogs des Arbeitsbereichs ab, und --target entwirft ein Manifest aus dessen Recipes. Der Arbeitsbereich nennt keinen Katalogordner, daher liest der Import den Katalog der Standardbibliothek aus der Registry, aus der er seinen Importer holt: einen signierten Snapshot des veröffentlichten Katalogs, den der erste Import holt, verifiziert und im Inhalts-Cache des Arbeitsbereichs ablegt und den die Aufzeichnung, die der Import neben seine Entwürfe schreibt, über seinen Digest benennt. Ein Arbeitsbereich, der eigene Katalogordner nennt — in AGGREGA_CATALOG_DIRS oder unter workspace.catalog_dirs —, importiert stattdessen gegen diese. Wechseln Sie in source:

Terminal window
cd source

Den Import ausführen

Terminal window
aggrega import basic-prompting.json --target compose

Auf der Standardausgabe listet er auf, was er geschrieben hat:

wrote aggregate.yaml
wrote release.yaml
wrote manifest.yaml
wrote .aggrega-import.json

Auf der Standardfehlerausgabe, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:

[… omitted: a warning that the importer runs unverified, printed where its module is read from beside its Plugin entity in a catalog folder rather than fetched]
read as the langflow format, with drafted paths relative to <workspace>
warn: the flow is carried in values.flow_definition with the handles of all 3 of its edges written as Langflow's editor writes them — the same handles, their keys in order with no space between them — since the editor compares an edge's handles with the ones it writes for the nodes the edge joins, character for character, when it opens the flow, and drops every edge whose handles differ
warn: node LanguageModelComponent-kBOja reaches languagemodelcomponent-kboja through the model connection languagemodelcomponent-kboja of core/ai-agent/langflow: its field api_key names the variable OPENAI_API_KEY, which the platform delivers for this connection and Langflow reads as a global variable; no field of it gives its API's address, so the OpenAI client it runs takes OPENAI_BASE_URL, the address the platform delivers for this connection, from the environment
made no choice for ChatInput-SzjnT (ChatInput)
made no choice for Prompt-tOH5D (Prompt)
made no choice for ChatOutput-8ZWWB (ChatOutput)
mapped LanguageModelComponent-kBOja (LanguageModelComponent) to core/ai-model/openai as a reference, HIGH at 0.9
warning: node "langflow" (provider "compose"): artifact "langflow-flow/langflow-flow.yaml": skipped provenance label injection — the fragment declares no compose service. Compose carries build provenance as service labels, so a fragment contributing only top-level networks, volumes or configs carries none; the services this component emits elsewhere carry the full set.
Pull complete: <workspace>/release.lock (entities=8, source_artifacts=0, external_inputs=0)

Der Import, aus dem Editor ausgeführt: Das entworfene Aggregate, Release und Manifest erscheinen neben dem Flow-Export, die Aggrega-Ausgabe listet auf, wie jede Komponente des Flows zugeordnet wurde, und die geschriebenen Dateien, und eine Benachrichtigung meldet, dass der Import 3 Dateien entworfen hat, erkannt als langflow.

  • Die Zeile mapped besagt, was aus dem Language-Model-Knoten wurde: das OpenAI-Modell der Standardbibliothek, core/ai-model/openai, referenziert statt entworfen, da es in der hohen Stufe übereinstimmte, mit einem Wert von 0.9. Es ist eine eigene Komponente, verbunden mit dem Socket model der Plattform. Standardmäßig führt der Entwurf den gesamten Flow auf der Plattform aus, die Langflow ausführt, und gibt nur einem Knoten eine eigene Komponente, den ein Socket dieser Plattform aufnimmt — ein Modell, ein Tool, ein Vektorspeicher —, sofern der Knoten als solcher erkannt wird.
  • Die erste Zeile warn besagt, dass der Flow mit den Handles jeder Kante so übernommen wird, wie der Editor von Langflow sie schreibt. Langflow hält seine Starterprojekte mit einem Leerzeichen nach jedem Doppelpunkt und jedem Komma der Handles einer Kante vor; sein Editor verwirft beim Öffnen eines Flows jede Kante, deren Handles nicht genau so geschrieben sind, wie er sie schreibt, und speichert den Flow dann ohne sie. So geschrieben, öffnet sich der Flow mit seinen drei Verbindungen und läuft mit ihnen.
  • Die Zeile warn, die den Knoten nennt, besagt, wie der Flow dieses Modell erreicht. Der Knoten liest seinen Schlüssel aus der Variablen OPENAI_API_KEY und seine Adresse aus OPENAI_BASE_URL, und die Plattform liefert beide für die Modellverbindung, sodass der Flow keine Änderung braucht.
  • Die Zeilen made no choice nennen die Knoten, die kein Socket der Plattform aufnimmt: Sie bleiben innerhalb des Flows, den Langflow so ausführt, wie er exportiert wurde.
  • Die letzten beiden Zeilen sind der Pull. Es blieb nichts zu beantworten, daher hat der Import die Abhängigkeiten des entworfenen Release abgerufen, wie es aggrega pull tut, und release.lock geschrieben; der Build unten braucht nichts weiter. Die Zeile warning gibt auch der Build aus, und Validieren und bauen erklärt sie.

Die Antwortdatei nennt zwei Secrets, nach denen dieser Import nicht fragt: Für sie lässt er nichts leer, daher wendet er keines davon an und lässt die Datei, wie sie ist.

Was er schreibt

Das Aggregate, das Release und das Manifest heißen imported/basic-prompting, nach dem eigenen Namen des Flows, Basic Prompting, reduziert auf basic-prompting — ein Flow ohne Namen wird nach seiner Datei benannt —, unter dem Namespace, den die Einstellung target_namespace des Importers festlegt, imported, sofern Sie keinen anderen festlegen (Einstellungen).

aggregate.yaml — eine Instanz der Langflow-Plattform der Standardbibliothek, core/ai-agent/langflow, die den Flow so trägt, wie er exportiert wurde, bis auf die Handles seiner Kanten, die so geschrieben sind, wie der Editor von Langflow sie schreibt, wovon hier mehr als tausend Zeilen ausgelassen sind, und das Modell, das er erreicht:

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/basic-prompting
version: 0.1.0
description: Draft Aggregate imported from a source in the langflow format.
spec:
components:
langflow:
type: core/ai-agent/langflow
features:
# For the compose target, the lines below declare admin_password on langflow: a secret the Release alone attaches arrives under the key value, so each is declared with a key of its own and no two arrive under one; the Release attaches its origin, naming this type or none.
admin_password:
type: core/secret-value
values:
key: LANGFLOW_SUPERUSER_PASSWORD
values:
flow_id: '0dbee653-41ae-4e51-af2e-55757fb24be3'
flow_definition: |-
{
"data": {
"edges": [
[… omitted: the rest of the flow]
}
uses:
model:
languagemodelcomponent-kboja:
target: languagemodelcomponent-kboja
# For the compose target, the lines below declare credential on languagemodelcomponent-kboja: a secret the Release alone attaches arrives under the key value, so each is declared with a key of its own and no two arrive under one; the Release attaches its origin, naming this type or none.
features:
credential:
type: core/secret-value
values:
key: OPENAI_API_KEY
# swap to core/ai-model/azure-openai (score 0.4000) by setting type: core/ai-model/azure-openai
languagemodelcomponent-kboja:
type: core/ai-model/openai
values:
model: |-
gpt-4.1
  • Das Modell ist core/ai-model/openai, mit dem Modell, das der Knoten des Flows auswählt, gpt-4.1. Der Kommentar darüber nennt eine andere Component des Katalogs, der der Knoten ähnelt, mit ihrem Wert, für Leser, die diese bevorzugen.
  • Die beiden Secrets — das Administratorpasswort, nach dem der Editor von Langflow fragt, und der OpenAI-Schlüssel, den die Plattform dem Modell vorlegt — werden hier mit der Variablen deklariert, unter der jedes in der Umgebung von Langflow ankommt, LANGFLOW_SUPERUSER_PASSWORD und OPENAI_API_KEY. Auf Docker Compose käme ein Secret, das allein das Release anhängt, unter dem Schlüssel value an, und die beiden würden kollidieren; hier deklariert, hat jedes einen eigenen Schlüssel. Das Release sagt, woher jedes kommt.
  • flow_id ist die Kennung, die der Export dem Flow gibt.

release.yaml — das Release, das das Aggregate mit dem Manifest bereitstellt:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/basic-prompting
# environment is a drafted default, since no source names the environment this Release deploys to; change it to name the one it deploys to.
environment: development
version: 0.1.0
description: Draft Release imported from a source in the langflow format.
spec:
aggregate: imported/basic-prompting
manifest: imported/basic-prompting
components:
langflow:
infra:
# The image running core/ai-agent/langflow, at the version this importer drafts, which the catalog's Recipes for it are known to run; the import does not raise or lower it to follow the source. The source states version "1.5.0" of the platform.
image: "langflowai/langflow:1.6.0"
# Published on this machine's loopback address, 127.0.0.1: reachable from this machine only, by any process running on it. Delete this line to keep the service internal.
published_port: 7860
features:
admin_password:
type: core/secret-value
infra:
# Attached by reference, never as a value: the administrator's password, read while values.require_authentication stays true, read from the variable LANGFLOW_ADMIN_PASSWORD, which a target substituting variable references, as Docker Compose does when the stack starts, reads from the environment, so no file carries the value.
origin: "${LANGFLOW_ADMIN_PASSWORD}"
uses:
model:
languagemodelcomponent-kboja:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential langflow presents to languagemodelcomponent-kboja on its model connection, read from the variable OPENAI_API_KEY, which a target substituting variable references, as Docker Compose does when the stack starts, reads from the environment, so no file carries the value.
origin: "${OPENAI_API_KEY}"
languagemodelcomponent-kboja: {}
  • environment ist development, ein Standardwert, der laut dem Kommentar darüber auf die Umgebung zu ändern ist, in die das Release ausgerollt wird.
  • Das Image ist Langflow 1.6.0, die Version, die die Recipes des Katalogs für Langflow ausführen. Der Flow wurde zuletzt auf Langflow 1.5.0 getestet, wie der Kommentar sagt; der Import behält die Version bei, die die Recipes ausführen, statt der des Flows zu folgen.
  • published_port ist 7860, der Port, auf dem Langflow bereitstellt, sodass der Editor auf Ihrem Rechner unter http://127.0.0.1:7860 antwortet. Wie sein Kommentar sagt, kann jeder Prozess auf diesem Rechner ihn dort erreichen und nichts anderes; löschen Sie die Zeile, um Langflow allein im Netzwerk des Stacks zu halten.
  • Die beiden Secrets sind Variablenreferenzen, ${LANGFLOW_ADMIN_PASSWORD} und ${OPENAI_API_KEY}, die Docker Compose beim Start des Stacks aus Ihrer Shell füllt, sodass keine Datei einen der beiden Werte enthält.

manifest.yaml — die Compose-Recipes der Plattform und des Modells sowie die Realisierung, die die Variablenreferenz eines Geheimnisses unverändert in die Compose-Datei schreibt:

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/basic-prompting
version: 0.1.0
spec:
mappings:
components:
type:
core/ai-agent/langflow: compose/langflow
core/ai-model/openai: compose/openai
features:
type:
core/secret-value: compose/dotenv-secret

.aggrega-import.json ist die Aufzeichnung dessen, was der Import geschrieben hat, die ein späteres aggrega import --sync liest, und release.lock fixiert jede Katalogentität, zu der das Release aufgelöst wird, nach Version und Digest.

Validieren und bauen

Terminal window
aggrega validate --release release.yaml
aggrega build --release release.yaml

Das entworfene Release, nach der Validierung im Editor geöffnet, wobei die Aggrega-Ausgabe und eine Benachrichtigung beide melden, dass keine Probleme gefunden wurden.

Der Build des entworfenen Release: Ein dist-Ordner erscheint im Explorer, die Aggrega-Ausgabe listet die geschriebene Docker-Compose-Datei auf, und eine Benachrichtigung meldet, dass 1 Datei geschrieben wurde.

Die Validierung gibt aus:

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
release dependency validation passed: release.yaml (schema-pillar + dependency pillars)

und der Build, wobei <workspace> für den Ordner mit den Entwürfen steht:

warning: node "langflow" (provider "compose"): artifact "langflow-flow/langflow-flow.yaml": skipped provenance label injection — the fragment declares no compose service. Compose carries build provenance as service labels, so a fragment contributing only top-level networks, volumes or configs carries none; the services this component emits elsewhere carry the full set.
notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
[… omitted: a total build time, which differs per run]
Build completed: 1 file written to <workspace>/dist

Die Zeile warning betrifft den Teil der Compose-Datei, der den Flow trägt, einen Eintrag configs auf oberster Ebene, der keinen Dienst hat, an dem die Labels des Builds angebracht werden könnten. Die Zeile notice ist rein informativ: Das Secret-Feature akzeptiert sein origin aus den values des Aggregate oder der infra des Release, und der Hinweis meldet, dass ein Blatt in beiden deklariert ist. Keine der beiden ändert das Urteil.

dist/compose/docker-compose.yaml enthält Langflow und einen Dienst, der einmal vor ihm läuft:

services:
langflow:
image: langflowai/langflow:1.6.0
environment:
LANGFLOW_CONFIG_DIR: /app/langflow
LANGFLOW_SAVE_DB_IN_CONFIG_DIR: "true"
LANGFLOW_AUTO_LOGIN: "false"
LANGFLOW_SUPERUSER: admin
LANGFLOW_SUPERUSER_PASSWORD: ${LANGFLOW_ADMIN_PASSWORD}
OPENAI_BASE_URL: https://api.openai.com/v1
OPENAI_API_KEY: ${OPENAI_API_KEY}
LANGFLOW_LOAD_FLOWS_PATH: /app/flows
ports:
- 127.0.0.1:7860:7860
[… omitted: the labels the build writes on every service, naming the Aggregate, the component, the environment and the compiler's version]
volumes:
- type: volume
source: langflow--data
target: /app/langflow
networks:
- compose
depends_on:
langflow--data-owner:
condition: service_completed_successfully
[… omitted: the service's health check]
configs:
- source: langflow-flow
target: /app/flows/flow.json
langflow--data-owner:
image: langflowai/langflow:1.6.0
entrypoint:
- chown
- "1000:0"
- /app/langflow
[… omitted: the labels the build writes on every service]
volumes:
- type: volume
source: langflow--data
target: /app/langflow
networks:
- compose
restart: "no"
user: "0"

Der Flow erreicht Langflow als /app/flows/flow.json, aus einem Eintrag configs, der den Flow enthält, den das Aggregate trägt, und Langflow lädt ihn bei jedem Start aus LANGFLOW_LOAD_FLOWS_PATH. Der Schlüssel und das Passwort sind Variablenreferenzen, die beim Start des Stacks aus Ihrer Shell befüllt werden. Das Compose-Recipe von Langflow veröffentlicht nur dann einen Port auf Ihrem Rechner, wenn das Release published_port in der infra von Langflow setzt, und dann allein auf der Loopback-Adresse 127.0.0.1; ohne diese Einstellung ist der Dienst nur im Netzwerk des Stacks erreichbar.

langflow--data-owner führt das Image von Langflow als root aus, übergibt das Datenvolume an Benutzer 1000, Gruppe 0, die Identität, unter der das Image von Langflow läuft, und beendet sich. Langflow startet, sobald dieser Dienst abgeschlossen ist: Docker legt das Volume mit root als Eigentümer an, und Langflow könnte seine Daten sonst nicht dorthin schreiben.

Mit einem KI-Assistenten

Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie diesen Prompt dort ein.

Verwenden Sie nur die Aggrega-Tools und erstellen Sie selbst keinen Ordner. Wenn der Workspace-Ordner noch keinen Ordner `import-langflow` enthält, rufen Sie das Tool `scaffold` einmal auf, mit `example` auf `import-langflow` gesetzt und ohne `dir`: Es schreibt das Beispiel in einen neuen Ordner `import-langflow`, dessen Ordner `source` enthält, was diese Seite importiert. Rufen Sie dann das Tool `import` auf, mit `workspace_root` auf `import-langflow/source`, `source` auf `basic-prompting.json` und `target` auf `compose` gesetzt: Es liest die benötigten Antworten aus `import-answers.yaml` neben `basic-prompting.json`, schreibt seine Entwürfe in `import-langflow/source` und lädt per Pull, was sie benötigen. Rufen Sie dann das Tool `validate` auf, mit `workspace_root` auf `import-langflow/source` und `release` auf `release.yaml` gesetzt, und das Tool `build`, mit `workspace_root` auf `import-langflow/source`, `release` auf `release.yaml` und `write` auf true gesetzt. Sagen Sie mir, welche Dateien der Build geschrieben hat; sie liegen unter `import-langflow/source/dist/`.

In VS Code öffnen

Wenn die Aggrega-Erweiterung für Visual Studio Code installiert ist, öffnen Sie in VS Code den Ordner import-langflow/source, in den der Import seine Entwürfe geschrieben hat. Der Ordner enthält ein einziges Release, das entworfene release.yaml, daher wählt der Editor es für Sie aus und prüft die Entwürfe beim Bearbeiten gegen dieses Release, wobei er seine Befunde in der Datei und im Problembereich markiert. Aggrega: Show topology graph in der Befehlspalette zeichnet die Komponenten des Release und die Verbindungen zwischen ihnen. Aggrega: Build, Aggrega: Preview build und Aggrega: Pull wirken auf dasselbe Release, und jeder dieser Befehle ist auch eine Schaltfläche im Bereich Commands der Ansicht Aggrega in der Aktivitätsleiste; Build schreibt seine Dateien in das Verzeichnis dist/ des Ordners. Aggrega in Visual Studio Code verwenden behandelt den Rest.

Ausführen

Setzen Sie den Schlüssel und das Passwort des Administrators in Ihrer Shell und starten Sie dann den Stack:

Terminal window
export OPENAI_API_KEY='your OpenAI key'
export LANGFLOW_ADMIN_PASSWORD='a password of your own'
docker compose -p basic-prompting -f dist/compose/docker-compose.yaml up -d --wait

-p benennt das Projekt, wie es der Ausführungsschritt von Wie ein Import abläuft erklärt. --wait kehrt zurück, sobald langflow--data-owner abgeschlossen ist und Langflow sich als gesund meldet.

Testen

Öffnen Sie http://127.0.0.1:7860, die Adresse, die published_port veröffentlicht, und melden Sie sich als admin mit dem von Ihnen gesetzten Passwort an: Basic Prompting ist im Editor mit seinen drei Verbindungen.

Langflow führt einen Flow über seine API nur für einen API-Schlüssel aus, den ein Administrator nach der Anmeldung erstellt. Melden Sie sich an:

Terminal window
curl -sS -X POST http://127.0.0.1:7860/api/v1/login \
-d username=admin --data-urlencode "password=$LANGFLOW_ADMIN_PASSWORD"
{"access_token":"[… omitted: the access token]","refresh_token":"[… omitted: the refresh token]","token_type":"bearer"}

erstellen Sie mit dem Zugriffstoken einen Schlüssel:

Terminal window
curl -sS -X POST http://127.0.0.1:7860/api/v1/api_key/ \
-H 'Authorization: Bearer <access_token>' -H 'Content-Type: application/json' -d '{"name": "test-it"}'
{"name":"test-it","last_used_at":null,"total_uses":0,"is_active":true,"id":"[… omitted: the key's identifier]","api_key":"[… omitted: the key]","user_id":"[… omitted: the owner's identifier]"}

und führen Sie den Flow mit dem Schlüssel aus:

Terminal window
curl -sS -X POST 'http://127.0.0.1:7860/api/v1/run/0dbee653-41ae-4e51-af2e-55757fb24be3?stream=false' \
-H 'x-api-key: <api_key>' -H 'Content-Type: application/json' \
-d '{"input_value": "In one short sentence: what is Docker Compose?", "input_type": "chat", "output_type": "chat"}'

Der Lauf verwendete einen Platzhalter für den OpenAI-Schlüssel, daher ist die Antwort die Ablehnung des Schlüssels durch OpenAI, was zeigt, dass der Flow bis zu seinem Aufruf des Modells lief:

{"detail":"{\"message\":\"Error running graph: Error building Component Language Model: \\n\\nError code: 401 - {'error': {'message': 'Incorrect API key provided: sk-place*****************-key. You can find your API key at https://platform.openai.com/account/api-keys.', 'type': 'invalid_request_error', 'code': 'invalid_api_key', 'param': None}, 'status': 401}\",[… omitted: three empty fields, and a suggestion to update three of the flow's components]}"}

Mit Ihrem Schlüssel enthält die Antwort die Antwort des Modells unter outputs[0].outputs[0].results.message.text.

Auf Kubernetes, mit dem angewendeten Build, den Auf Kubernetes beschreibt, leiten Sie einen lokalen Port an den Service von Langflow, langflow-default, in dem Namespace weiter, auf den Sie angewendet haben, und lassen den Befehl laufen:

Terminal window
kubectl port-forward -n <namespace> svc/langflow-default 7860:7860

Von einem anderen Terminal aus erreichen die drei obigen Anfragen Langflow unter derselben Adresse, unverändert; der Lauf erhielt dieselbe Ablehnung des Platzhalterschlüssels.

Stoppen Sie den Stack mit dem folgenden Befehl. -v entfernt zusätzlich das Datenvolume von Langflow und damit das Konto des Administrators, den API-Schlüssel und den Ausführungsverlauf des Flows:

Terminal window
docker compose -p basic-prompting -f dist/compose/docker-compose.yaml down -v

Auf Kubernetes

Derselbe Flow wird für Kubernetes mit dem Ziel helm importiert. Die Entwürfe für Docker Compose liegen bereits in source, und der Import überschreibt dort nie ein Aggregate, entwerfen Sie diese also mit --output-dir in einen eigenen Ordner und validieren und bauen Sie dann von dort aus:

Terminal window
aggrega import basic-prompting.json --target helm --output-dir helm
cd helm
aggrega validate --release release.yaml
aggrega build --release release.yaml

Die Entwürfe unterscheiden sich dort, wo sich das Target unterscheidet. Das Manifest ordnet die Plattform helm/langflow zu, das Modell helm/openai und jedes Secret helm/k8s-existing-secret, das es aus einem bereits im Namespace vorhandenen Secret liest. Das Release hängt die beiden Secrets als core/referenced-secret an, jedes mit dem Namen dieses Secrets, und die Namen sind das, was die Antwortdatei enthält:

features:
admin_password:
type: core/referenced-secret
infra:
# Left for the Release, since the source cannot supply it: the name of a Kubernetes Secret already in the namespace holding, under the data key value, the administrator's password, read while values.require_authentication stays true.
origin: "langflow-admin"

Ohne die Antwortdatei fragt der Import beide Namen an einem Terminal ab und schreibt Ihre Antworten in eine neue Antwortdatei. Wo nichts abgefragt werden kann, schreibt er diese Datei mit beiden Schlüsseln und leeren Antworten und endet mit Status 1 und dieser Zeile, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:

2 values the drafts leave empty are still owed, listed in the answers file <workspace>/import-answers.yaml: write each beside its key there, then run the import again

Der Build schreibt einfache Kubernetes-Manifeste unter dist/helm/ im Stammverzeichnis des Workspace, source, das von helm aus ../dist/helm/ ist. Erstellen Sie die beiden Secrets in dem Namespace, auf den Sie anwenden, jedes mit seinem Wert unter dem Datenschlüssel value, und wenden Sie dann den Ordner an, wie es der Ausführungsschritt von Wie ein Import abläuft erklärt.