Importer un chatflow Flowise
Ce guide pas à pas importe un chatflow exporté depuis Flowise — une chaîne de conversation avec un modèle de chat et une mémoire — dans un Aggregate, une Release et un Manifest qui construisent Flowise portant le chatflow pour Docker Compose tels qu’ils sont écrits, puis les construit et exécute le résultat. Chaque fichier et chaque bloc de sortie ci-dessous proviennent d’une exécution réelle ; le chatflow et chaque étape du guide se trouvent dans l’exemple import-flowise, où un script de vérification relance l’import, compare ce qu’il écrit, ce qu’il affiche et les blocs que cite cette page avec les fichiers qui y sont conservés, puis valide et construit ce que l’import a écrit.
Générer l’exemple
Vous pouvez exécuter cette importation avec les commandes de cette page, ou la faire exécuter par votre assistant IA.
Écrivez l’exemple dans un nouveau dossier qui porte son nom :
aggrega scaffold --example import-flowiseElle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier ; la suivante, ci-dessous, vous place dans le dossier source du nouveau dossier, où s’exécute l’import. Ce dossier contient le fichier du chatflow, support-chat.json, que cette page décrit plutôt que de le citer :
cd import-flowise
Le chatflow
support-chat.json, écrit pour ce guide sous la forme dans laquelle l’éditeur de Flowise exporte un chatflow, contient trois nœuds et les deux arêtes qui les relient : un nœud ChatOpenAI qui sélectionne gpt-4o-mini, un nœud Buffer Memory et un nœud Conversation Chain qui reçoit les deux et répond avec un court message système. Le nœud ChatOpenAI ne sélectionne aucun identifiant enregistré et laisse son Base Path vide, de sorte que le client OpenAI sur lequel Flowise l’exécute lit son adresse et sa clé dans l’environnement de Flowise.
À côté du chatflow, un .aggrega-config.yaml fait du dossier un espace de travail :
# 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.aiet import-answers.yaml contient les réponses à ce qu’aucun chatflow ne peut contenir. Flowise ne charge aucun chatflow depuis un fichier au démarrage ; le build le charge donc via l’API propre de Flowise sous un compte propriétaire, et aucun export ne nomme ce compte : son adresse e-mail est la seule réponse dont un import pour Docker Compose a besoin. Un import pour Kubernetes a aussi besoin du nom du Secret Kubernetes qui contient chaque secret — le mot de passe du propriétaire et la clé OpenAI —, si bien que le fichier nomme aussi ces deux Secrets (voir Sur 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 représente une adresse e-mail à vous. Sans le fichier, un import lancé dans un terminal demande chaque valeur, une question à la fois, formulée d’après la description placée au-dessus de sa clé, et écrit vos réponses dans un nouveau fichier de réponses ; là où rien ne peut être demandé, il écrit ce fichier avec les clés et des réponses vides, les liste et se termine avec le statut 1. Le fichier de réponses de l’import décrit le fichier en entier.
L’import évalue chaque nœud par rapport aux Components du catalogue de l’espace de travail, et --target rédige un brouillon de Manifest à partir de ses Recipes. L’espace de travail n’indique aucun dossier de catalogue ; l’import lit donc le catalogue de la bibliothèque standard depuis le registre dont il récupère son importateur : un instantané signé du catalogue publié, que le premier import récupère, vérifie et conserve dans le cache de contenu de l’espace de travail, et que l’enregistrement écrit par l’import à côté de ses brouillons désigne par son condensé. Un espace de travail qui indique ses propres dossiers de catalogue — dans AGGREGA_CATALOG_DIRS, ou sous workspace.catalog_dirs — importe plutôt en s’appuyant sur ceux-ci. Placez-vous dans source :
cd sourceLancer l’importation
aggrega import support-chat.json --target composeSur la sortie standard, elle liste ce qu’elle a écrit :
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonSur la sortie d’erreur standard, où <workspace> désigne le dossier dans lequel vous l’avez lancée :
[… 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 ligne
mappedindique que le nœud ChatOpenAI est devenu le modèle OpenAI de la bibliothèque standard,core/ai-model/openai, référencé plutôt que rédigé, puisqu’il a correspondu dans le niveau haut, à 0.9 : un composant à part entière, relié au socketmodelde la plateforme. - La ligne
warnindique comment le chatflow atteint ce modèle : le nœud lit l’adresse et la clé que la plateforme fournit pour la connexion au modèle, de sorte que la clé que la Release attache à la connexion est celle qu’utilise le chatflow. - La ligne
infoconcerne le fichier de réponses. Il a fourni l’adresse e-mail du propriétaire, que les brouillons laissaient vide ; ses deux noms de Secret répondent à ce que seul un import pour Kubernetes laisse vide, ils restent donc dans le fichier, inutilisés ici. - Les lignes
made no choiceindiquent que la mémoire et la chaîne restent à l’intérieur du chatflow : aucun socket de la plateforme ne les accueille. - Les deux dernières lignes sont le pull. Toutes les valeurs ayant reçu une réponse, l’import a récupéré les dépendances de la Release rédigée, comme le fait
aggrega pull, et a écritrelease.lock; le build ci-dessous n’a besoin de rien de plus. La lignewarningest une ligne que le build affiche aussi, et Valider et construire l’explique.
Ce qu’elle écrit
L’Aggregate, la Release et le Manifest sont nommés imported/support-chat, d’après le fichier, support-chat.json, puisqu’un export Flowise ne porte pas de nom propre, sous le namespace que fixe le paramètre target_namespace de l’importeur, imported sauf si vous en fixez un autre (Paramètres).
aggregate.yaml — une instance de la plateforme Flowise de la bibliothèque standard, core/ai-agent/flowise, portant le chatflow tel qu’il a été exporté, en grande partie omis ici, et le modèle relié à son 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- Le modèle est
core/ai-model/openai, avec le modèle que sélectionne le nœud,gpt-4o-mini. Le commentaire au-dessus nomme un autre Component du catalogue auquel le nœud ressemble, avec son score. - Les deux secrets — le mot de passe du compte propriétaire sous lequel le chatflow est chargé, et la clé OpenAI que la plateforme présente au modèle — sont déclarés ici avec la variable sous laquelle chacun arrive dans l’environnement de Flowise,
OWNER_PASSWORDetOPENAI_API_KEY. Sur Docker Compose, un secret attaché par la seule Release arriverait sous la clévalue, et les deux entreraient en collision ; déclarés ici, chacun a sa propre clé. La Release indique d’où vient chacun. chatflow_idest dérivé du chatflow, puisqu’un export depuis l’éditeur de Flowise ne porte aucun identifiant propre ; ainsi, un même chatflow donne toujours le même identifiant. Un chatflow Flowise écrit{{<node id>.data.instance}}pour chaque connexion entre deux nœuds, et le texte d’un Aggregate est lu comme un template ; le brouillon écrit donc chaque{{sous la forme{{"{{"}}, que le build reconvertit en deux accolades.
release.yaml — la Release, qui déploie l’Aggregate avec le 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: {}environmentvautdevelopment, une valeur par défaut que le commentaire au-dessus demande de remplacer par l’environnement dans lequel la Release est déployée.- L’image est Flowise 3.1.3, la version qu’exécutent les Recipes du catalogue pour Flowise.
published_portvaut 3000, le port sur lequel Flowise sert, il répond donc àhttp://127.0.0.1:3000sur votre machine. Comme l’indique son commentaire, tout processus de cette machine peut l’y atteindre, et rien d’autre ; supprimez la ligne pour garder Flowise sur le seul réseau de la pile.owner_emailest la réponse issue du fichier de réponses. Le commentaire au-dessus explique pourquoi l’import n’a pas pu la rédiger.- Les deux secrets sont des références de variables,
${FLOWISE_OWNER_PASSWORD}et${OPENAI_API_KEY}, que Docker Compose remplit depuis votre shell au démarrage de la stack, de sorte qu’aucun fichier ne contient l’une ou l’autre valeur.
manifest.yaml — les Recipes Compose de la plateforme et du modèle, et la réalisation qui écrit telle quelle la référence de variable d’un secret dans le fichier Compose :
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 est l’enregistrement de ce que l’importation a écrit, que lit un aggrega import --sync ultérieur, et release.lock épingle chaque entité du catalogue vers laquelle la Release se résout, par version et digest.
Valider et compiler
aggrega validate --release release.yamlaggrega build --release release.yaml

La validation affiche :
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)et la compilation, où <workspace> désigne le dossier contenant les ébauches :
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 ligne warning concerne la partie du fichier Compose qui porte le chatflow, une entrée configs de premier niveau, qui n’a aucun service sur lequel apposer les étiquettes du build. La ligne notice est indicative : la Feature de secret accepte son origin depuis les values de l’Aggregate ou l’infra de la Release, et la notice signale qu’une feuille est déclarée dans les deux. Aucune des deux ne change le verdict.
dist/compose/docker-compose.yaml contient deux services. Flowise lui-même :
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]et le service qui charge le chatflow dès que Flowise se signale en bonne santé, puis se termine :
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.jsIl enregistre le compte propriétaire sur un Flowise neuf, ou s’y connecte avec ce compte, et écrit le chatflow à chatflow_id. La clé et le mot de passe sont des références de variables, remplies depuis votre shell au démarrage de la stack. La Recipe Compose de Flowise ne publie un port sur votre machine que là où la Release définit published_port dans l’infra de Flowise, et alors sur la seule adresse de bouclage, 127.0.0.1 ; sans cela, le service n’est joignable que sur le réseau de la stack.
Avec un assistant IA
Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-y ce prompt.
Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier Workspace ne contient pas encore de dossier `import-flowise`, appelez une fois l’outil `scaffold` avec `example` défini sur `import-flowise` et sans `dir` : il écrit l’exemple dans un nouveau dossier `import-flowise`, dont le dossier `source` contient ce que cette page importe. Appelez ensuite l’outil `import` avec `workspace_root` défini sur `import-flowise/source`, `source` défini sur `support-chat.json` et `target` défini sur `compose` : il lit les réponses dont il a besoin dans `import-answers.yaml` à côté de `support-chat.json`, écrit ses ébauches dans `import-flowise/source` et récupère ce dont elles ont besoin. Appelez ensuite l’outil `validate` avec `workspace_root` défini sur `import-flowise/source` et `release` défini sur `release.yaml`, puis l’outil `build` avec `workspace_root` défini sur `import-flowise/source`, `release` défini sur `release.yaml` et `write` défini sur true. Indiquez-moi quels fichiers le build a écrits ; ils se trouvent sous `import-flowise/source/dist/`.L’ouvrir dans VS Code
Avec l’extension Aggrega pour Visual Studio Code installée, ouvrez dans VS Code le dossier import-flowise/source, où l’import a écrit ses ébauches. Le dossier contient une seule Release, le release.yaml ébauché ; l’éditeur la sélectionne donc pour vous, et il vérifie les ébauches par rapport à cette Release pendant que vous les modifiez, en signalant ce qu’il trouve dans le fichier et dans le panneau Problèmes. Aggrega: Show topology graph, dans la palette de commandes, dessine les composants de la Release et les connexions entre eux. Aggrega: Build, Aggrega: Preview build et Aggrega: Pull agissent sur la même Release, et chacune est aussi un bouton du panneau Commands de la vue Aggrega dans la barre d’activité ; Build écrit ses fichiers dans le dist/ du dossier. Utiliser Aggrega dans Visual Studio Code couvre le reste.
Exécution
Définissez la clé et le mot de passe du propriétaire dans votre shell, démarrez Flowise, puis exécutez le service d’amorçage :
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 nomme le projet, comme l’explique l’étape d’exécution de Déroulement d’une importation. --wait rend la main dès que Flowise se déclare sain ; il ne nomme que flowise parce qu’il compte comme un échec tout conteneur qui s’est arrêté, et le service d’amorçage s’arrête par conception. La seconde commande exécute le service d’amorçage, affiche son journal et rend la main lorsqu’il s’arrête :
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 0Si un autre programme sur votre machine écoute déjà sur 127.0.0.1:3000, la première commande s’arrête avec failed to bind host port 127.0.0.1:3000/tcp: address already in use : définissez published_port sur un port libre et relancez le build. L’exécution ci-dessous l’a fait, avec 3002, et a utilisé ce port à la place de 3000.
Tester
Ouvrez http://127.0.0.1:3000, l’adresse que publie published_port, et connectez-vous avec l’e-mail et le mot de passe du propriétaire : le chatflow de l’amorçage se trouve dans Flowise.
Un chatflow qui ne définit pas de clé d’API propre répond sur son point de terminaison de prédiction sans en exiger. Posez-lui une question :
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’exécution a utilisé une valeur fictive pour la clé OpenAI ; la réponse est donc le refus de celle-ci par OpenAI, ce qui montre que le chatflow s’est exécuté jusqu’à son appel au modèle :
{"statusCode":500,"success":false,"message":"401 Unauthorized – check your API key and ensure it has access to the requested model.","stack":{}}Avec votre clé, la réponse contient le résultat dans text.
Sur Kubernetes, une fois le build décrit dans Sur Kubernetes appliqué et son Job d’amorçage terminé, redirigez un port local vers le Service de Flowise, flowise-default, dans le namespace sur lequel vous avez appliqué, et laissez la commande s’exécuter :
kubectl port-forward -n <namespace> svc/flowise-default 3000:3000Depuis un autre terminal, la question ci-dessus atteint le chatflow à la même adresse, sans modification ; l’exécution a obtenu le même refus de la clé fictive.
Arrêtez la pile avec la commande ci-dessous. -v supprime aussi le volume de données de Flowise, et avec lui le compte propriétaire et le chatflow écrits par l’amorçage :
docker compose -p support-chat -f dist/compose/docker-compose.yaml down -vSur Kubernetes
Le même chatflow s’importe pour Kubernetes avec la cible helm. Les ébauches pour Docker Compose se trouvent déjà dans source, et l’import n’écrase jamais un Aggregate qui s’y trouve ; ébauchez donc celles-ci dans un dossier à part avec --output-dir, puis validez et lancez le build depuis ce dossier :
aggrega import support-chat.json --target helm --output-dir helmcd helmaggrega validate --release release.yamlaggrega build --release release.yamlLes brouillons diffèrent là où la cible diffère. Le Manifest associe la plateforme à helm/flowise, le modèle à helm/openai et chaque secret à helm/k8s-existing-secret, qui le lit depuis un Secret déjà présent dans le namespace. La Release attache le mot de passe du propriétaire et la clé OpenAI en tant que core/referenced-secret, chacun nommant son Secret, et prend les trois réponses dans le fichier de réponses : l’e-mail du propriétaire, flowise-owner et openai-api-key.
Le build écrit de simples manifestes Kubernetes sous dist/helm/ à la racine du workspace, source, soit ../dist/helm/ depuis helm, dont le seed du chatflow sous forme de Job. Créez les deux Secrets dans le namespace auquel vous appliquez, chacun contenant sa valeur sous la clé de données value, puis appliquez le dossier comme l’explique l’étape d’exécution de Comment se déroule un import.