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

Einen Flowise-Chatflow importieren

Diese Schritt-für-Schritt-Anleitung importiert einen aus Flowise exportierten Chatflow — eine Konversationskette mit einem Chat-Modell und einem Speicher — in ein Aggregate, ein Release und ein Manifest, die Flowise samt Chatflow 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 Chatflow und jede Stufe der Anleitung liegen im Beispiel import-flowise, 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-flowise

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 Chatflow-Datei, support-chat.json, die diese Seite beschreibt, statt sie zu zitieren:

Terminal window
cd import-flowise

Der source-Ordner des erzeugten Beispiels, geöffnet in Visual Studio Code, mit dem Flowise-Chatflow-Export eines Support-Chats, geöffnet auf seinem ChatOpenAI-Knoten.

Der Chatflow

support-chat.json, für diese Anleitung in der Form geschrieben, in der der Editor von Flowise einen Chatflow exportiert, enthält drei Knoten und die beiden Kanten zwischen ihnen: einen ChatOpenAI-Knoten, der gpt-4o-mini auswählt, einen Buffer-Memory-Knoten und einen Conversation-Chain-Knoten, der beide aufnimmt und mit einer kurzen Systemnachricht antwortet. Der ChatOpenAI-Knoten wählt keine gespeicherten Anmeldedaten aus und lässt seinen Base Path leer, sodass der OpenAI-Client, auf dem Flowise ihn ausführt, seine Adresse und seinen Schlüssel aus der Umgebung von Flowise liest.

Neben dem Chatflow 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 support-chat.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 Chatflow enthalten kann. Flowise lädt beim Start keinen Chatflow aus einer Datei, daher spielt der Build ihn über die eigene API von Flowise unter einem Eigentümerkonto ein, und kein Export nennt dieses Konto: Seine E-Mail-Adresse ist die einzige Antwort, die ein Import für Docker Compose benötigt. Ein Import für Kubernetes benötigt zusätzlich den Namen des Kubernetes-Secrets, das jedes Geheimnis enthält — das Passwort des Eigentümers und den OpenAI-Schlüssel —, daher nennt die Datei auch diese beiden Secrets (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:
# Email address of the platform's owner account, read only when values.flow_definition is set. The
# step that seeds the chatflow registers this account when the instance has no owner yet, which makes
# it the owner, and signs in as it; on an instance that already has one, it names an account allowed
# to import chatflows, and the password attached to the owner_password slot is that account's.
# Required when values.flow_definition is set: the build halts when it is empty. It has no default.
spec.components.flowise.infra.owner_email: "owner@example.com"
# 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.flowise.features.owner_password.infra.origin: "flowise-owner"
# 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.flowise.uses.model.chatopenai-0.features.credential.infra.origin: "openai-api-key"

owner@example.com steht für eine eigene E-Mail-Adresse. Ohne die Datei fragt ein Import an einem Terminal jeden Wert ab, eine Frage nach der anderen, formuliert nach der Beschreibung über ihrem Schlüssel, und schreibt Ihre Antworten in eine neue Antwortdatei; wo nichts gefragt werden kann, schreibt er diese Datei mit den Schlüsseln und leeren Antworten, listet sie auf und beendet sich mit Status 1. Die Import-Antwortdatei 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 support-chat.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 flowise format, with drafted paths relative to <workspace>
warn: node chatOpenAI_0 reaches chatopenai-0 through the model connection chatopenai-0 of core/ai-agent/flowise: its Base Path is empty, so the OpenAI client Flowise runs it on reads the address the platform delivers for this connection, OPENAI_BASE_URL, and, since it selects no credential, the key delivered as OPENAI_API_KEY
info: the answers file <workspace>/import-answers.yaml also answers spec.components.flowise.features.owner_password.infra.origin in release.yaml, spec.components.flowise.uses.model.chatopenai-0.features.credential.infra.origin in release.yaml, which these drafts do not leave empty; those answers are kept there and not applied
mapped chatOpenAI_0 (chatOpenAI) to core/ai-model/openai as a reference, HIGH at 0.9
made no choice for bufferMemory_0 (bufferMemory)
made no choice for conversationChain_0 (conversationChain)
warning: node "flowise" (provider "compose"): artifact "flowise-flow/flowise-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, ausgeführt aus dem Editor: Das entworfene Aggregate, Release und Manifest erscheinen neben dem Chatflow-Export, die Aggrega-Ausgabe listet, wie jeder Knoten zugeordnet wurde, und die geschriebenen Dateien, und eine Benachrichtigung meldet, dass der Import 3 Dateien entworfen hat, erkannt als flowise.

  • Die Zeile mapped besagt, dass der ChatOpenAI-Knoten zum OpenAI-Modell der Standardbibliothek wurde, core/ai-model/openai, referenziert statt entworfen, da er in der hohen Stufe übereinstimmte, mit 0.9: eine eigene Komponente, verbunden mit dem Socket model der Plattform.
  • Die Zeile warn besagt, wie der Chatflow dieses Modell erreicht: Der Knoten liest die Adresse und den Schlüssel, die die Plattform für die Modellverbindung liefert, sodass der Schlüssel, den das Release an die Verbindung anhängt, derjenige ist, den der Chatflow verwendet.
  • Die Zeile info betrifft die Antwortdatei. Sie lieferte die E-Mail-Adresse des Eigentümers, die die Entwürfe leer ließen; ihre beiden Secret-Namen beantworten, was nur ein Import für Kubernetes leer lässt, daher bleiben sie in der Datei und werden hier nicht verwendet.
  • Die Zeilen made no choice besagen, dass der Speicher und die Kette innerhalb des Chatflows bleiben: Kein Socket der Plattform nimmt sie auf.
  • Die letzten beiden Zeilen sind der Pull. Da jeder Wert beantwortet war, hat der Import die Abhängigkeiten des entworfenen Release abgerufen, wie es aggrega pull tut, und release.lock geschrieben; der Build unten benötigt nichts weiter. Die Zeile warning gibt auch der Build aus, und Validieren und bauen erklärt sie.

Was er schreibt

Das Aggregate, das Release und das Manifest heißen imported/support-chat, nach der Datei, support-chat.json, da ein Flowise-Export keinen eigenen Namen trägt, unter dem Namespace, den die Einstellung target_namespace des Importers festlegt, imported, sofern Sie keinen anderen festlegen (Einstellungen).

aggregate.yaml — eine Instanz der Flowise-Plattform der Standardbibliothek, core/ai-agent/flowise, die den Chatflow so trägt, wie er exportiert wurde, hier größtenteils ausgelassen, und das Modell, verbunden mit ihrem Socket model:

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/support-chat
version: 0.1.0
description: Draft Aggregate imported from a source in the flowise format.
spec:
components:
flowise:
type: core/ai-agent/flowise
features:
# For the compose target, the lines below declare owner_password on flowise: 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.
owner_password:
type: core/secret-value
values:
key: OWNER_PASSWORD
values:
# chatflow_id is derived from the exported flow, which gives no identifier of its own.
chatflow_id: '40d9f5c5-5187-54c1-a9f5-a8dac92f88bb'
flow_definition: |
{
"nodes": [
[… omitted: the chatflow's nodes, as exported, up to the Conversation Chain's inputs]
"inputs": {
"model": "{{"{{"}}chatOpenAI_0.data.instance}}",
"memory": "{{"{{"}}bufferMemory_0.data.instance}}",
[… omitted: the rest of the chatflow, as exported]
}
uses:
model:
chatopenai-0:
target: chatopenai-0
# For the compose target, the lines below declare credential on chatopenai-0: 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
chatopenai-0:
type: core/ai-model/openai
values:
model: |-
gpt-4o-mini
  • Das Modell ist core/ai-model/openai, mit dem Modell, das der Knoten auswählt, gpt-4o-mini. Der Kommentar darüber nennt eine weitere Component des Katalogs, der der Knoten ähnelt, mit ihrer Bewertung.
  • Die beiden Geheimnisse — das Passwort des Eigentümerkontos, unter dem der Chatflow eingespielt wird, und der OpenAI-Schlüssel, den die Plattform dem Modell übergibt — werden hier mit der Variablen deklariert, unter der jedes in der Umgebung von Flowise ankommt, OWNER_PASSWORD und OPENAI_API_KEY. Unter Docker Compose käme ein Geheimnis, 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 gibt an, woher jedes stammt.
  • chatflow_id wird aus dem Chatflow abgeleitet, da ein Export aus dem Editor von Flowise keinen eigenen Bezeichner enthält; so ergibt ein Chatflow stets denselben Bezeichner. Ein Flowise-Chatflow schreibt {{<node id>.data.instance}} für jede Verbindung zwischen zwei Knoten, und der Text eines Aggregate wird als Template gelesen; daher schreibt der Entwurf jedes {{ als {{"{{"}}, was der Build wieder in die zwei geschweiften Klammern zurückverwandelt.

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

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/support-chat
# 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 flowise format.
spec:
aggregate: imported/support-chat
manifest: imported/support-chat
components:
flowise:
infra:
# The image running core/ai-agent/flowise, 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.
image: "flowiseai/flowise:3.1.3"
# Left for the Release, since the source cannot supply it: infra.owner_email, the email address of the platform's owner account, required while values.flow_definition is set
owner_email: "owner@example.com"
# 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: 3000
features:
owner_password:
type: core/secret-value
infra:
# Attached by reference, never as a value: the owner account's password, required while values.flow_definition is set, read from the variable FLOWISE_OWNER_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: "${FLOWISE_OWNER_PASSWORD}"
uses:
model:
chatopenai-0:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential flowise presents to chatopenai-0 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}"
chatopenai-0: {}
  • 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 Flowise 3.1.3, die Version, die die Recipes des Katalogs für Flowise ausführen.
  • published_port ist 3000, der Port, auf dem Flowise bereitstellt, daher antwortet es auf Ihrem Rechner unter http://127.0.0.1:3000. Wie sein Kommentar sagt, kann jeder Prozess auf diesem Rechner es dort erreichen und nichts anderes; löschen Sie die Zeile, um Flowise allein im Netzwerk des Stacks zu halten.
  • owner_email ist die Antwort aus der Antwortdatei. Der Kommentar darüber erklärt, warum der Import sie nicht entwerfen konnte.
  • Die beiden Geheimnisse sind Variablenreferenzen, ${FLOWISE_OWNER_PASSWORD} und ${OPENAI_API_KEY}, die Docker Compose beim Start des Stacks aus Ihrer Shell befü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/support-chat
version: 0.1.0
spec:
mappings:
components:
type:
core/ai-agent/flowise: compose/flowise
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; die Aggrega-Ausgabe und eine Benachrichtigung melden beide, dass keine Probleme gefunden wurden.

Der Build des entworfenen Release: Im Explorer erscheint ein dist-Ordner, 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 "flowise" (provider "compose"): artifact "flowise-flow/flowise-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 Chatflow 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 zwei Dienste. Flowise selbst:

flowise:
image: flowiseai/flowise:3.1.3
environment:
DATABASE_PATH: /home/node/.flowise
SECRETKEY_PATH: /home/node/.flowise
OPENAI_BASE_URL: https://api.openai.com/v1
OPENAI_API_KEY: ${OPENAI_API_KEY}
ports:
- 127.0.0.1:3000:3000
[… 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: flowise--data
target: /home/node
networks:
- compose
[… omitted: the service's health check]

und den Dienst, der den Chatflow einspielt, sobald Flowise als gesund gemeldet wird, und sich dann beendet:

flowise-flow-seed:
image: flowiseai/flowise:3.1.3
entrypoint:
- node
- /seed/seed.js
environment:
FLOWISE_URL: http://127.0.0.1:3000
OWNER_EMAIL: owner@example.com
OWNER_PASSWORD: ${FLOWISE_OWNER_PASSWORD}
CHATFLOW_ID: 40d9f5c5-5187-54c1-a9f5-a8dac92f88bb
CHATFLOW_NAME: 40d9f5c5-5187-54c1-a9f5-a8dac92f88bb
[… omitted: the labels the build writes on every service]
network_mode: service:flowise
depends_on:
flowise:
condition: service_healthy
restart: "no"
configs:
- source: flowise-flow
target: /seed/flow.json
- source: flowise-flow-seed
target: /seed/seed.js

Er registriert das Eigentümerkonto auf einem frischen Flowise oder meldet sich damit an und schreibt den Chatflow unter chatflow_id. Der Schlüssel und das Passwort sind Variablenreferenzen, die beim Start des Stacks aus Ihrer Shell befüllt werden. Das Compose-Recipe von Flowise veröffentlicht nur dann einen Port auf Ihrem Rechner, wenn das Release published_port in der infra von Flowise setzt, und dann ausschließlich auf der Loopback-Adresse 127.0.0.1; ohne diese Einstellung ist der Dienst nur im Netzwerk des Stacks erreichbar.

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 ausschließlich die Aggrega-Tools und legen Sie selbst keinen Ordner an. Wenn der Workspace-Ordner noch keinen Ordner `import-flowise` enthält, rufen Sie das Tool `scaffold` einmal mit `example` auf `import-flowise` gesetzt und ohne `dir` auf: Es schreibt das Beispiel in einen neuen Ordner `import-flowise`, dessen Ordner `source` enthält, was diese Seite importiert. Rufen Sie dann das Tool `import` mit `workspace_root` auf `import-flowise/source`, `source` auf `support-chat.json` und `target` auf `compose` gesetzt auf: Es liest die benötigten Antworten aus `import-answers.yaml` neben `support-chat.json`, schreibt seine Entwürfe nach `import-flowise/source` und pullt, was sie benötigen. Rufen Sie dann das Tool `validate` mit `workspace_root` auf `import-flowise/source` und `release` auf `release.yaml` gesetzt auf, sowie das Tool `build` mit `workspace_root` auf `import-flowise/source`, `release` auf `release.yaml` und `write` auf true gesetzt. Nennen Sie mir die Dateien, die der Build geschrieben hat; sie liegen unter `import-flowise/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-flowise/source, in den der Import seine Entwürfe geschrieben hat. Der Ordner enthält ein einziges Release, die entworfene release.yaml, daher wählt der Editor es für Sie aus und prüft die Entwürfe während der Bearbeitung gegen dieses Release; was er findet, markiert er in der Datei und im Bereich Probleme. 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 davon ist auch eine Schaltfläche im Bereich Commands der Ansicht Aggrega in der Aktivitätsleiste; Build schreibt seine Dateien in dist/ innerhalb des Ordners. Aggrega in Visual Studio Code verwenden behandelt den Rest.

Ausführen

Setzen Sie den Schlüssel und das Passwort des Eigentümers in Ihrer Shell, starten Sie Flowise und führen Sie dann den Seed-Dienst aus:

Terminal window
export OPENAI_API_KEY='your OpenAI key'
export FLOWISE_OWNER_PASSWORD='a password of your own'
docker compose -p support-chat -f dist/compose/docker-compose.yaml up -d --wait flowise
docker compose -p support-chat -f dist/compose/docker-compose.yaml up flowise-flow-seed

-p benennt das Projekt, wie der Ausführungsschritt von Wie ein Import abläuft erklärt. --wait kehrt zurück, sobald Flowise sich als gesund meldet; es nennt nur flowise, weil es jeden beendeten Container als Fehlschlag wertet und der Seed-Dienst sich planmäßig beendet. Der zweite Befehl führt den Seed-Dienst aus, gibt sein Log aus und kehrt zurück, wenn er sich beendet:

flowise-flow-seed-1 | registered the owner account owner@example.com
flowise-flow-seed-1 | imported chatflow 40d9f5c5-5187-54c1-a9f5-a8dac92f88bb as "40d9f5c5-5187-54c1-a9f5-a8dac92f88bb"
flowise-flow-seed-1 exited with code 0

Wenn ein anderes Programm auf Ihrem Rechner bereits auf 127.0.0.1:3000 lauscht, bricht der erste Befehl mit failed to bind host port 127.0.0.1:3000/tcp: address already in use ab: Setzen Sie published_port auf einen freien Port und führen Sie den Build erneut aus. Der Lauf unten hat das mit 3002 getan und diesen Port anstelle von 3000 verwendet.

Testen

Öffnen Sie http://127.0.0.1:3000, die Adresse, die published_port veröffentlicht, und melden Sie sich mit der E-Mail-Adresse und dem Passwort des Eigentümers an: Der Chatflow des Seed-Dienstes ist in Flowise vorhanden.

Ein Chatflow, der keinen eigenen API-Schlüssel festlegt, beantwortet Anfragen an seinen Prediction-Endpunkt ohne einen. Stellen Sie ihm eine Frage:

Terminal window
curl -sS -X POST http://127.0.0.1:3000/api/v1/prediction/40d9f5c5-5187-54c1-a9f5-a8dac92f88bb \
-H 'Content-Type: application/json' -d '{"question": "In one short sentence: what is Docker Compose?"}'

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

{"statusCode":500,"success":false,"message":"401 Unauthorized – check your API key and ensure it has access to the requested model.","stack":{}}

Mit Ihrem Schlüssel enthält die Antwort das Ergebnis unter text.

Leiten Sie auf Kubernetes, nachdem der unter Auf Kubernetes beschriebene Build angewendet und sein Seed-Job abgeschlossen ist, einen lokalen Port an den Service von Flowise, flowise-default, in dem Namespace weiter, auf den Sie angewendet haben, und lassen Sie den Befehl laufen:

Terminal window
kubectl port-forward -n <namespace> svc/flowise-default 3000:3000

Von einem anderen Terminal aus erreicht die obige Frage den Chatflow unverändert unter derselben Adresse; der Lauf erhielt dieselbe Ablehnung des Platzhalterschlüssels.

Beenden Sie den Stack mit dem folgenden Befehl. -v entfernt außerdem das Datenvolume von Flowise und mit ihm das Eigentümerkonto und den Chatflow, den der Seed-Dienst geschrieben hat:

Terminal window
docker compose -p support-chat -f dist/compose/docker-compose.yaml down -v

Auf Kubernetes

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

Terminal window
aggrega import support-chat.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 Ziel unterscheidet. Das Manifest bildet die Plattform auf helm/flowise ab, das Modell auf helm/openai und jedes Secret auf helm/k8s-existing-secret, das es aus einem bereits im Namespace vorhandenen Secret liest. Das Release hängt das Passwort des Eigentümers und den OpenAI-Schlüssel als core/referenced-secret an, die jeweils ihr Secret benennen, und übernimmt alle drei Antworten aus der Antwortdatei: die E-Mail-Adresse des Eigentümers, flowise-owner und openai-api-key.

Der Build schreibt einfache Kubernetes-Manifeste unter dist/helm/ im Stammverzeichnis des Workspace, source, was von helm aus ../dist/helm/ ist, darunter den Seed des Chatflows als Job. 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.