Importare un chatflow di Flowise
Questa guida passo passo importa un chatflow esportato da Flowise — una catena di conversazione con un modello di chat e una memoria — in un Aggregate, una Release e un Manifest che compilano Flowise con il chatflow per Docker Compose così come sono scritti, poi li compila ed esegue il risultato. Ogni file e ogni blocco di output riportati di seguito provengono da un’esecuzione reale; il chatflow e ogni fase della guida si trovano nell’esempio import-flowise, dove uno script di verifica esegue di nuovo l’importazione, confronta ciò che scrive, ciò che stampa e i blocchi citati in questa pagina con i file conservati lì, e valida e compila ciò che l’importazione ha scritto.
Generare l’esempio
Puoi eseguire questa importazione con i comandi di questa pagina, oppure farla eseguire al tuo assistente AI.
Scrivi l’esempio in una nuova cartella che porta il suo nome:
aggrega scaffold --example import-flowisePoi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella; quello successivo, qui sotto, ti porta nella cartella source della nuova cartella, dove viene eseguita l’importazione. Quella cartella contiene il file del chatflow, support-chat.json, che questa pagina descrive anziché citare:
cd import-flowise
Il chatflow
support-chat.json, scritto per questa guida nella forma in cui l’editor di Flowise esporta un chatflow, contiene tre nodi e i due archi tra di essi: un nodo ChatOpenAI che seleziona gpt-4o-mini, un nodo Buffer Memory e un nodo Conversation Chain che li riceve entrambi e risponde con un breve messaggio di sistema. Il nodo ChatOpenAI non seleziona alcuna credenziale memorizzata e lascia vuoto il suo Base Path, quindi il client OpenAI su cui Flowise lo esegue legge il proprio indirizzo e la propria chiave dall’ambiente di Flowise.
Accanto al chatflow, un .aggrega-config.yaml rende la cartella uno spazio di lavoro:
# 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.aie import-answers.yaml contiene le risposte a ciò che nessun chatflow può contenere. Flowise non carica alcun chatflow da un file all’avvio, quindi la build lo precarica tramite l’API di Flowise stessa con un account proprietario, e nessuna esportazione indica quell’account: la sua email è l’unica risposta di cui ha bisogno un’importazione per Docker Compose. Un’importazione per Kubernetes richiede anche il nome del Secret Kubernetes che contiene ciascun segreto — la password del proprietario e la chiave OpenAI — quindi il file indica anche quei due Secret (vedi Su 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 sta per un tuo indirizzo email. Senza il file, un’importazione da terminale chiede ciascun valore, una domanda alla volta, formulata a partire dalla descrizione sopra la sua chiave, e scrive le tue risposte in un nuovo file di risposte; dove non è possibile chiedere nulla, scrive quel file con le chiavi e risposte vuote, le elenca ed esce con stato 1. Il file di risposte dell’importazione descrive il file per intero.
L’importazione valuta ogni nodo rispetto ai Components del catalogo dello spazio di lavoro, e --target abbozza un Manifest a partire dalle sue Recipes. Lo spazio di lavoro non indica alcuna cartella di catalogo, quindi l’importazione legge il catalogo della libreria standard dal registry da cui recupera il proprio importer: uno snapshot firmato del catalogo pubblicato, che la prima importazione recupera, verifica e conserva nella cache dei contenuti dello spazio di lavoro, e che il record scritto dall’importazione accanto alle sue bozze indica tramite il suo digest. Uno spazio di lavoro che indica le proprie cartelle di catalogo — in AGGREGA_CATALOG_DIRS, oppure sotto workspace.catalog_dirs — importa invece rispetto a quelle. Entra in source:
cd sourceEseguire l’importazione
aggrega import support-chat.json --target composeSullo standard output elenca ciò che ha scritto:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonSullo standard error, dove <workspace> sta per la cartella in cui l’hai eseguita:
[… 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_KEYinfo: 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 appliedmapped chatOpenAI_0 (chatOpenAI) to core/ai-model/openai as a reference, HIGH at 0.9made 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)
- La riga
mappeddice che il nodo ChatOpenAI è diventato il modello OpenAI della libreria standard,core/ai-model/openai, referenziato anziché abbozzato, poiché ha trovato corrispondenza nella fascia alta, a 0.9: un componente a sé, collegato al socketmodeldella piattaforma. - La riga
warndice come il chatflow raggiunge quel modello: il nodo legge l’indirizzo e la chiave che la piattaforma fornisce per la connessione al modello, quindi la chiave che la Release associa alla connessione è quella che il chatflow usa. - La riga
inforiguarda il file di risposte. Ha fornito l’email del proprietario, che le bozze lasciavano vuota; i suoi due nomi di Secret rispondono a ciò che solo un’importazione per Kubernetes lascia vuoto, quindi restano nel file, qui inutilizzati. - Le righe
made no choicedicono che la memoria e la catena restano all’interno del chatflow: nessun socket della piattaforma le accoglie. - Le ultime due righe sono il pull. Con ogni valore fornito, l’importazione ha scaricato le dipendenze della Release abbozzata, come fa
aggrega pull, e ha scrittorelease.lock; la build qui sotto non richiede altro. La rigawarningè una che stampa anche la build, e Validare e compilare la spiega.
Cosa scrive
L’Aggregate, la Release e il Manifest si chiamano imported/support-chat, dal file, support-chat.json, poiché un’esportazione di Flowise non porta un nome proprio, nel namespace definito dall’impostazione target_namespace dell’importatore, imported a meno che tu non ne imposti un altro (Impostazioni).
aggregate.yaml — un’istanza della piattaforma Flowise della libreria standard, core/ai-agent/flowise, che porta il chatflow così come è stato esportato, qui in gran parte omesso, e il modello collegato al suo socket model:
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: 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- Il modello è
core/ai-model/openai, con il modello selezionato dal nodo,gpt-4o-mini. Il commento sopra di esso indica un altro Component del catalogo a cui il nodo somiglia, con il suo punteggio. - I due segreti — la password dell’account proprietario con cui il chatflow viene precaricato e la chiave OpenAI che la piattaforma presenta al modello — sono dichiarati qui con la variabile con cui ciascuno arriva nell’ambiente di Flowise,
OWNER_PASSWORDeOPENAI_API_KEY. Su Docker Compose un segreto associato dalla sola Release arriverebbe con la chiavevalue, e i due entrerebbero in conflitto; dichiarati qui, ciascuno ha una chiave propria. La Release indica da dove proviene ciascuno. chatflow_idè derivato dal chatflow, poiché un’esportazione dall’editor di Flowise non porta alcun identificatore proprio, quindi un chatflow produce sempre lo stesso identificatore. Un chatflow di Flowise scrive{{<node id>.data.instance}}per ogni connessione tra due nodi, e il testo di un Aggregate viene letto come template, quindi la bozza scrive ogni{{come{{"{{"}}, che la build riconverte nelle due parentesi graffe.
release.yaml — la Release, che distribuisce l’Aggregate con il Manifest:
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: 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èdevelopment, un valore predefinito che il commento sopra di esso indica di cambiare con l’ambiente in cui la Release viene distribuita.- L’immagine è Flowise 3.1.3, la versione che eseguono le Recipes del catalogo per Flowise.
published_portè 3000, la porta su cui Flowise serve, quindi risponde suhttp://127.0.0.1:3000sulla tua macchina. Come dice il suo commento, qualsiasi processo su questa macchina può raggiungerlo lì e nient’altro può farlo; elimina la riga per mantenere Flowise soltanto sulla rete dello stack.owner_emailè la risposta tratta dal file di risposte. Il commento sopra di essa spiega perché l’importazione non ha potuto abbozzarla.- I due segreti sono riferimenti a variabili,
${FLOWISE_OWNER_PASSWORD}e${OPENAI_API_KEY}, che Docker Compose valorizza dalla tua shell all’avvio dello stack, così nessun file contiene alcuno dei due valori.
manifest.yaml — le Recipes Compose della piattaforma e del modello, e la realizzazione che scrive il riferimento a variabile di un segreto nel file Compose tale e quale:
apiVersion: aggrega.ai/v1beta1kind: Manifestmetadata: name: imported/support-chat version: 0.1.0spec: 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 è il registro di ciò che l’importazione ha scritto, che un successivo aggrega import --sync legge, e release.lock fissa ogni entità del catalogo a cui la Release si risolve, per versione e digest.
Convalidare e compilare
aggrega validate --release release.yamlaggrega build --release release.yaml

La convalida stampa:
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)e la build, dove <workspace> sta per la cartella che contiene le bozze:
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>/distLa riga warning riguarda la parte del file Compose che porta il chatflow, una voce configs di primo livello, che non ha alcun servizio su cui apporre le etichette della build. La riga notice è informativa: la Feature del segreto accetta il proprio origin dai values dell’Aggregate o dall’infra della Release, e la notifica segnala che una foglia è dichiarata in entrambi. Nessuna delle due cambia il verdetto.
dist/compose/docker-compose.yaml contiene due servizi. Flowise stesso:
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]e il servizio che precarica il chatflow non appena Flowise risulta integro, per poi terminare:
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.jsRegistra l’account proprietario su un’istanza nuova di Flowise, oppure accede con esso, e scrive il chatflow in chatflow_id. La chiave e la password sono riferimenti a variabili, valorizzati dalla tua shell all’avvio dello stack. La Recipe Compose di Flowise pubblica una porta sulla tua macchina solo dove la Release imposta published_port nell’infra di Flowise, e in tal caso solo sull’indirizzo di loopback, 127.0.0.1; senza di essa, il servizio è raggiungibile solo sulla rete dello stack.
Con un assistente AI
Un assistente AI configurato con gli strumenti di Aggrega può fare lo stesso: incollaci questo prompt.
Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella Workspace non contiene ancora una cartella `import-flowise`, chiama una volta lo strumento `scaffold` con `example` impostato su `import-flowise` e senza `dir`: scrive l’esempio in una nuova cartella `import-flowise`, la cui cartella `source` contiene ciò che questa pagina importa. Poi chiama lo strumento `import` con `workspace_root` impostato su `import-flowise/source`, `source` impostato su `support-chat.json` e `target` impostato su `compose`: legge le risposte di cui ha bisogno da `import-answers.yaml` accanto a `support-chat.json`, scrive le sue bozze in `import-flowise/source` ed esegue il pull di ciò di cui hanno bisogno. Poi chiama lo strumento `validate` con `workspace_root` impostato su `import-flowise/source` e `release` impostato su `release.yaml`, e lo strumento `build` con `workspace_root` impostato su `import-flowise/source`, `release` impostato su `release.yaml` e `write` impostato su true. Dimmi quali file ha scritto la build; si trovano in `import-flowise/source/dist/`.Aprilo in VS Code
Con l’estensione Aggrega per Visual Studio Code installata, apri in VS Code la cartella import-flowise/source, dove l’importazione ha scritto le sue bozze. La cartella contiene una sola Release, il release.yaml in bozza, quindi l’editor la seleziona per te e, mentre modifichi le bozze, le verifica rispetto a quella Release, segnalando ciò che trova nel file e nel pannello Problemi. Aggrega: Show topology graph, nel riquadro comandi, disegna i componenti della Release e le connessioni tra di essi. Aggrega: Build, Aggrega: Preview build e Aggrega: Pull agiscono sulla stessa Release, e ciascuno è anche un pulsante nel pannello Commands della vista Aggrega nella barra delle attività; Build scrive i suoi file nella dist/ della cartella. Usare Aggrega in Visual Studio Code descrive il resto.
Esecuzione
Imposta nella tua shell la chiave e la password del proprietario, avvia Flowise, quindi esegui il seed:
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 flowisedocker compose -p support-chat -f dist/compose/docker-compose.yaml up flowise-flow-seed-p dà il nome al progetto, come spiega il passo di esecuzione di Come si svolge un’importazione. --wait ritorna non appena Flowise risulta in salute; indica solo flowise perché considera un errore qualsiasi container che sia terminato, e il seed termina per progettazione. Il secondo comando esegue il seed, ne stampa il log e ritorna quando termina:
flowise-flow-seed-1 | registered the owner account owner@example.comflowise-flow-seed-1 | imported chatflow 40d9f5c5-5187-54c1-a9f5-a8dac92f88bb as "40d9f5c5-5187-54c1-a9f5-a8dac92f88bb"flowise-flow-seed-1 exited with code 0Se un altro programma sulla tua macchina è già in ascolto su 127.0.0.1:3000, il primo comando si interrompe con failed to bind host port 127.0.0.1:3000/tcp: address already in use: imposta published_port su una porta libera ed esegui di nuovo la build. L’esecuzione qui sotto lo ha fatto, con 3002, e ha usato quella porta al posto di 3000.
Eseguire il test
Apri http://127.0.0.1:3000, l’indirizzo che published_port pubblica, e accedi con l’email e la password del proprietario: il chatflow del seed è in Flowise.
Un chatflow che non imposta una propria chiave API risponde al suo endpoint di previsione senza richiederne una. Fagli una domanda:
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?"}'L’esecuzione ha usato un segnaposto per la chiave OpenAI, quindi la risposta è il rifiuto di OpenAI, che mostra che il chatflow è arrivato fino alla chiamata al modello:
{"statusCode":500,"success":false,"message":"401 Unauthorized – check your API key and ensure it has access to the requested model.","stack":{}}Con la tua chiave, la replica riporta la risposta in text.
Su Kubernetes, con la build descritta in Su Kubernetes applicata e il suo Job di seed completato, inoltra una porta locale al Service di Flowise, flowise-default, nel namespace a cui hai applicato, e lascia il comando in esecuzione:
kubectl port-forward -n <namespace> svc/flowise-default 3000:3000Da un altro terminale, la domanda qui sopra raggiunge il chatflow allo stesso indirizzo, invariata; l’esecuzione ha ricevuto lo stesso rifiuto della chiave segnaposto.
Arresta lo stack con il comando seguente. -v rimuove anche il volume dei dati di Flowise, e con esso l’account del proprietario e il chatflow scritto dal seed:
docker compose -p support-chat -f dist/compose/docker-compose.yaml down -vSu Kubernetes
Lo stesso chatflow si importa per Kubernetes con il target helm. Le bozze per Docker Compose si trovano già in source, e l’importazione non sovrascrive mai un Aggregate lì presente, quindi scrivi queste bozze in una cartella a parte con --output-dir, poi valida ed esegui la build da lì:
aggrega import support-chat.json --target helm --output-dir helmcd helmaggrega validate --release release.yamlaggrega build --release release.yamlLe bozze differiscono dove differisce il target. Il Manifest mappa la piattaforma su helm/flowise, il modello su helm/openai e ciascun secret su helm/k8s-existing-secret, che lo legge da un Secret già presente nel namespace. La Release associa la password del proprietario e la chiave OpenAI come core/referenced-secret, ciascuna con il nome del proprio Secret, e prende tutte e tre le risposte dal file delle risposte: l’email del proprietario, flowise-owner e openai-api-key.
La build scrive semplici manifest Kubernetes in dist/helm/ alla radice del workspace, source, che da helm è ../dist/helm/, tra cui il seed del chatflow come Job. Crea i due Secret nel namespace a cui applichi, ciascuno con il proprio valore sotto la chiave dati value, quindi applica la cartella come spiega la fase di esecuzione di Come si esegue un’importazione.