Importateurs core
Le dépôt du compilateur compile dix plugins importateurs qui lui sont propres, un pour chaque format source, et les publie avec chaque version du compilateur :
| Plugin | Sert | Lit |
|---|---|---|
importer/langflow | import:langflow | un flux exporté depuis Langflow, en JSON |
importer/flowise | import:flowise | un chatflow ou un agentflow exporté depuis Flowise, en JSON |
importer/n8n | import:n8n | un workflow exporté depuis n8n, en JSON |
importer/mcp | import:mcp | la configuration d’un client MCP — .mcp.json, claude_desktop_config.json, .vscode/mcp.json ou .cursor/mcp.json — ou une description de serveur du registre MCP, server.json, en JSON |
importer/compose | import:compose | une application Compose — compose.yaml, docker-compose.yml et leurs fichiers de remplacement — en YAML |
importer/dify | import:dify | une application exportée depuis Dify dans son DSL, en YAML |
importer/crewai | import:crewai | les agents et les tâches que déclare un projet CrewAI — config/agents.yaml et config/tasks.yaml, en YAML, ou crew.jsonc et agents/<name>.jsonc, ou leurs variantes en JSON strict crew.json et agents/<name>.json, en JSON avec commentaires |
importer/langgraph | import:langgraph | la configuration d’une application LangGraph, langgraph.json, en JSON, et, d’un fichier d’environnement que nomme la configuration, les seuls noms des variables, lorsque ce fichier est transmis à l’importation sous with.sources |
importer/google-adk | import:google-adk | les agents déclarés dans les fichiers Agent Config d’une application construite sur Google ADK — root_agent.yaml et les configurations que nomment ses sous-agents — en YAML |
importer/agent-framework | import:agent-framework | un agent déclaratif de Microsoft Agent Framework, un document de type Prompt sous n’importe quel nom, en YAML |
Chacun est compilé à partir des sources du compilateur lui-même et marqué de la version du compilateur, de sorte que les importateurs publiés avec le compilateur en version X.Y.Z indiquent la version X.Y.Z, et que leurs entités Plugin l’enregistrent. Contrairement aux plugins listés dans Plugins embarqués, aucun n’est compilé dans le binaire. Le binaire embarque l’entité Plugin de chacun et le digest de l’unique module qu’il accepte pour lui, de sorte que chacun sert son format dans chaque espace de travail, sans aucune entrée dans son catalogue.
Les dix reposent sur le paquet importer du kit Go, github.com/aggrega-ai/aggrega-pdk/go/pkg/importer. Pour les importateurs Langflow, Flowise et n8n, tout ce que fait un importateur quel que soit son format — évaluer les Components du catalogue de l’espace de travail par rapport à chaque nœud, décider s’il faut référencer l’un d’eux ou en produire un nouveau en brouillon, disposer le brouillon, reporter les valeurs d’identifiants qu’il contient ou les écrire vides comme le demande un paramètre, écrire les brouillons et lire les paramètres décrits ci-dessous — relève de ce paquet, et seules la lecture du format et la connaissance de la plateforme sur laquelle ses flux s’exécutent sont propres à chaque importateur. L’importateur MCP produit en brouillon une instance d’un Component par serveur, il n’évalue donc rien ; il partage avec le paquet la lecture des paramètres qu’il lit, sa décision sur les valeurs d’identifiants et les conventions selon lesquelles ses brouillons sont nommés et décrits, comme le décrit L’importateur MCP. L’importateur Compose décide de chaque service qu’il fait correspondre comme les importateurs de flux décident d’un nœud, au moyen du même paquet, rend ses brouillons comme eux et partage le reste comme le fait l’importateur MCP, comme le décrit L’importateur Compose. L’importateur Dify produit en brouillon l’installation Dify qu’assemble la bibliothèque standard, qui porte l’application, au moyen du brouillon de plateforme du même paquet dans la forme qu’il prend pour une plateforme qui est une installation entière, comme le décrit L’importateur Dify. L’importateur CrewAI produit en brouillon une instance de l’agent CrewAI de la bibliothèque standard par agent que déclare un projet, reliée au modèle que nomme cet agent, et partage le reste comme le fait l’importateur MCP, comme le décrit L’importateur CrewAI. L’importateur LangGraph produit en brouillon une instance de l’agent LangGraph de la bibliothèque standard par graphe que déclare la configuration d’une application, reliée au magasin de données dans lequel son checkpointer conserve l’état, et partage le reste comme le fait l’importateur MCP, comme le décrit L’importateur LangGraph. L’importateur Google ADK produit en brouillon une instance de l’agent ADK de la bibliothèque standard par arbre d’agents que déclarent les configurations d’une application, reliée au modèle que nomme l’arbre lorsqu’ADK envoie ses requêtes à l’API Gemini, et partage le reste comme le fait l’importateur MCP, comme le décrit L’importateur Google ADK. L’importateur Agent Framework produit en brouillon une instance de l’agent Agent Framework de la bibliothèque standard par agent déclaratif, reliée au modèle OpenAI que nomme cet agent — chaque serveur MCP qu’il nomme étant écrit en commentaires, puisque le fournisseur du modèle l’atteint comme un outil hébergé — et partage le reste comme le fait l’importateur MCP, comme le décrit L’importateur Agent Framework. Le fonctionnement du socket importateur, et ce qui lui est transmis, est décrit sous Le socket importateur.
Cette page est la référence de ce que chaque importateur lit et produit comme brouillons. Pour importer votre propre projet et compiler le résultat, commencez par Importation, qui accompagne un projet de sa source jusqu’à une compilation, un format à la fois.
Comment une importation en obtient un
aggrega import, la méthode aggrega/import de la session de l’éditeur et l’outil import de l’assistant obtiennent un importateur core de la même manière. Lorsque la machine contient déjà son module — dans le cache de contenu de l’espace de travail — l’importation le lit depuis cet endroit, sans recourir au réseau pour cela. Lorsque ce n’est pas le cas, la première importation qui en a besoin le récupère depuis le registre par défaut de l’espace de travail, dans la version du compilateur, et :
- le confronte au digest que porte le binaire, de sorte que seul le module publié par la version du compilateur s’exécute ;
- le vérifie comme un pull vérifie un plugin qu’il récupère — sa signature selon la politique de confiance de ce registre, et les fonctions hôte qu’il utilise par rapport à celles qu’enregistre son entité Plugin ;
- le conserve dans le cache de contenu de l’espace de travail, qui est la seule chose écrite pour lui : aucun fichier de verrouillage, et aucun relevé des plugins de confiance, parce qu’une importation n’épingle aucun importateur.
Chaque importation ultérieure le lit depuis le cache de contenu. Un module dont la vérification échoue est refusé, et rien n’est conservé. Dans un dossier qu’aucun espace de travail ne marque, il n’existe aucun cache de contenu où le conserver, donc la récupération y est refusée, en nommant le dossier et la façon de nommer un espace de travail ou de faire du dossier un espace de travail. Le module n’est jamais lu à côté d’une entité Plugin du même nom dans une autre version dans un dossier de catalogue : ce module appartient à l’autre entité.
Lorsque le module ne peut pas être récupéré, l’importation s’arrête sous A plugin’s .wasm is not on this machine (Le fichier Wasm d’un plugin n’est pas sur cette machine), en nommant l’importateur et sa version, et indique ce qui place son module sur la machine :
- Exécutez l’importation une fois avec le réseau disponible, lorsque l’espace de travail est hors ligne ou que son registre n’a pas pu être joint. Cette exécution le récupère, et chaque exécution ultérieure est hors ligne.
- Placez son module à côté d’une entité Plugin de cet importateur dans cette version dans un dossier de catalogue, sous le nom que donne le message —
importer--langflow.wasmpour l’importateur Langflow. Une entité de catalogue de même nom et de même version qu’un importateur core s’exécute à sa place, son module étant lu à côté d’elle ; une entité qui s’y trouve sans module à côté d’elle ne s’exécute pas à sa place, et l’importateur core est obtenu comme indiqué ci-dessus. Lorsque le registre ne contient pas le module, ou que l’espace de travail ne nomme aucun registre par défaut, c’est l’unique remède que donne le message.
Lequel s’exécute à côté de vos propres importateurs
Les importateurs core sont candidats à côté des importateurs que contient le catalogue de votre espace de travail, selon les règles par lesquelles tout importateur est sélectionné, qu’expose Quel importateur transforme une source en brouillons :
- Au sein d’un même nom, c’est la version la plus élevée qui s’exécute, ou la version que nomme une entrée
plugins.importer. - Lorsque votre catalogue contient un importateur d’un autre nom pour
langflow,flowise,n8n,mcp,compose,dify,crewai,langgraph,google-adkouagent-framework, deux importateurs annoncent le format, et une importation qui ne rattache ni l’un ni l’autre est refusée en nommant les deux, sous A parse or import format is advertised by more than one plugin (Un format d’analyse ou d’importation est annoncé par plus d’un plugin). Une entréeplugins.importerqui nomme celui que vous voulez règle la question. - Un importateur que contient votre catalogue sous le même nom et dans la même version qu’un importateur core, avec son module à côté de son entité, est celui qui s’exécute, lu depuis cet emplacement.
- Une entité Plugin portant le nom d’un importateur core, sans module à côté d’elle dans son dossier de catalogue — un checkout d’un catalogue qui recense les importateurs qu’une version a publiés, par exemple — est une entité qu’aucune importation ne pourrait exécuter, puisque son module n’est lu nulle part ailleurs ; elle n’est donc pas candidate à l’exécution, bien que les signatures qu’elle recense participent toujours à la reconnaissance d’une source. À la version propre du compilateur, l’importateur core s’exécute à sa place. À toute autre version, plus ancienne ou plus récente, elle est écartée, et le choix se fait parmi les importateurs qui peuvent s’exécuter — à moins qu’une entrée
plugins.importerne nomme exactement cette version, ou qu’aucun importateur de ce nom pouvant s’exécuter n’annonce le format demandé, comme lorsque l’entité recense un format que l’importateur propre du compilateur ne recense pas. Elle reste alors candidate selon les règles ci-dessus, et une importation qui la choisit s’arrête en nommant le dossier où va son module.
Quel que soit l’importateur propre à votre catalogue qui est choisi, son module est lu à côté de sa propre entité, dans sa propre version : un module placé à côté d’une entité de même nom dans une autre version appartient à cette entité.
Comment une source est reconnue
Une importation qui ne nomme pas son format avec --format est reconnue par les signatures que déclare chaque importateur :
- Langflow — une source qui s’analyse comme du JSON et porte un tableau à
data.nodes. - Flowise — une source qui s’analyse comme du JSON, porte des tableaux à
nodesetedges, et ne porte rien àdata.nodes. - n8n — une source qui s’analyse comme du JSON, porte un tableau à
nodeset un objet àconnections, et ne porte rien àedgesni àdata.nodes. - MCP — une source qui s’analyse comme du JSON, est nommée
.mcp.json,claude_desktop_config.jsonou.cursor/mcp.jsonet porte un objet àmcpServers; une source qui s’analyse comme du JSON avec commentaires, tel que Visual Studio Code le lit, est nommée.vscode/mcp.jsonet porte un objet àservers; ou une source de n’importe quel nom qui s’analyse comme du JSON et dont le$schemaest un texte commençant parhttps://static.modelcontextprotocol.io/schemas/, une description de serveur de registre. Un nom est comparé à la fin du chemin transmis à l’importation, de sorte queproject/.vscode/mcp.jsonest reconnu, tandis quemcp.jsontransmis depuis l’intérieur de.vscode, ou le fichier d’un client sous tout autre nom, est importé en nommant--format mcp. - Compose — une source qui s’analyse comme du YAML, porte l’un des noms sous lesquels Compose lit par défaut un fichier Compose ou son fichier de remplacement —
compose.yaml,compose.yml,docker-compose.yml,docker-compose.yaml,compose.override.yml,compose.override.yaml,docker-compose.override.ymloudocker-compose.override.yaml— et porte un objet àservices. Un fichier Compose sous tout autre nom est importé en nommant--format compose. - Dify — une source de n’importe quel nom qui s’analyse comme du YAML, porte le texte
appàkind, et porte quelque chose àapp.modeet àversion, comme le fait toute application qu’exporte Dify. - CrewAI — une source nommée
config/agents.yamlouconfig/tasks.yamlqui s’analyse comme du YAML, une source nomméecrew.jsoncoucrew.jsonqui s’analyse comme du JSON avec commentaires et porte une liste àagents, ou une source nomméeagents/<name>.jsoncouagents/<name>.jsonqui s’analyse comme du JSON avec commentaires et porte quelque chose àrole. Un projet classique indexe ses agents et ses tâches par des noms au choix de son auteur, de sorte que ses deux fichiers ne se distinguent que par leur nom. - LangGraph — une source nommée
langgraph.jsonqui s’analyse comme du JSON et porte un objet àgraphs; ou une source de n’importe quel nom qui s’analyse comme du JSON, porte un objet àgraphset dont le$schemaest le textehttps://langgra.ph/schema.json, le schéma que LangGraph publie pour sa configuration. Une configuration sous un autre nom qui ne nomme aucun schéma est importée en nommant--format langgraph. Aucune signature d’importateur ne nomme de fichier d’environnement, donc la reconnaissance d’un répertoire n’en ouvre aucun. - Google ADK — une source nommée
root_agent.yamlqui s’analyse comme du YAML et porte quelque chose ànameet àinstruction, comme le fait la configuration d’un LlmAgent, ou un texte àagent_classet quelque chose àname, comme le fait celle de tout autre agent. Une configuration sous un autre nom est importée en nommant--format google-adk. Aucune signature ne nomme la configuration d’un sous-agent, qui peut s’appeler n’importe comment, donc la reconnaissance d’un répertoire n’ouvre aucun fichier YAML hormisroot_agent.yaml. - Agent Framework — une source de n’importe quel nom qui s’analyse comme du YAML, porte le texte
Promptàkindet un objet àmodel, comme le fait un agent déclaratif qui nomme son modèle ; Agent Framework charge un agent déclaratif depuis le fichier que nomme son application, quel qu’il soit, donc la signature ne nomme aucun fichier. Un agent déclaratif qui ne nomme aucun modèle, ou qui écrit son type dans une autre casse ou commeAgent, est importé en nommant--format agent-framework.
Une source qui correspond à deux d’entre elles est refusée en nommant les deux formats, et s’importe en nommant le bon avec --format. Les importateurs Langflow, Flowise, n8n et LangGraph lisent leur source au moyen du parseur qui sert parse:json, l’importateur MCP une configuration qui liste ses serveurs sous servers au moyen de celui qui sert parse:jsonc et toute autre source au moyen de celui qui sert parse:json, les importateurs Compose, Dify, Google ADK et Agent Framework au moyen de celui qui sert parse:yaml, et l’importateur CrewAI les fichiers d’un projet classique au moyen de celui qui sert parse:yaml et les autres au moyen de celui qui sert parse:jsonc : celui que sert le catalogue de votre espace de travail, lorsqu’il en sert un, et sinon le parseur que le compilateur embarque lui-même pour cette syntaxe (voir Plugins embarqués). Ainsi, une importation passant par l’un d’eux n’a besoin d’aucun parseur dans votre catalogue, et rien n’est récupéré pour un parseur. Un parseur que votre catalogue sert effectivement est celui qui est utilisé, et celui du compilateur ne joue aucun rôle. Les importateurs Langflow, Flowise, n8n, Dify et Agent Framework ne déclarent aucun motif de fichier, donc chacun lit un seul fichier et une importation d’un répertoire passant par l’un d’eux est refusée ; l’importateur MCP déclare les quatre noms de fichiers des clients, donc un répertoire est lu au travers des configurations de clients qu’il contient ; l’importateur Compose déclare les huit noms de fichiers Compose, donc un répertoire est lu au travers des fichiers Compose qu’il contient ; l’importateur CrewAI déclare les six noms des déclarations d’un projet, donc le répertoire d’un projet est lu au travers de ses déclarations et de rien d’autre ; l’importateur LangGraph déclare langgraph.json, donc le répertoire d’une application est lu au travers de sa seule configuration, et ni son code ni un fichier d’environnement ne sont jamais lus ; et l’importateur Google ADK déclare root_agent.yaml, donc le répertoire d’une application est lu au travers de sa seule configuration racine — les configurations que nomment ses sous-agents ne parvenant à l’importateur que sous le with.sources de son rattachement — et ni son code ni son fichier d’environnement ne sont jamais lus. Une signature qui ne nomme aucun fichier — celles des importateurs Langflow, Flowise et n8n, celle de l’importateur MCP pour une description de serveur de registre, celle de l’importateur LangGraph pour une configuration qui nomme son schéma, celle de l’importateur Dify et celle de l’importateur Agent Framework — s’applique à tout fichier importé seul : une importation qui ne nomme aucun format lit un tel fichier comme du JSON, et comme du YAML, pour essayer les deux, quel que soit l’importateur auquel il est destiné, au moyen de ces mêmes parseurs — le compilateur embarque les deux, donc rien n’est récupéré pour l’un ou l’autre. Un fichier contenant un commentaire ou une virgule finale ne s’analyse pas comme du JSON, donc aucune signature lisant du JSON ne le reconnaît ; les signatures de l’importateur CrewAI pour crew.jsonc, agents/<name>.jsonc et leurs variantes en .json, et celle de l’importateur MCP pour .vscode/mcp.json, lisent du JSON avec commentaires, au moyen du parseur que le compilateur embarque pour cette syntaxe lorsque votre catalogue n’en sert aucun.
Une source que son parseur refuse — pour les importateurs Langflow, Flowise, n8n et LangGraph une source qui n’est pas du JSON, pour l’importateur MCP une source qui n’est pas du JSON avec commentaires ou, à moins qu’elle ne liste ses serveurs sous servers, pas du JSON, pour les importateurs Compose, Dify et Agent Framework une source qui n’est pas du YAML, pour l’importateur CrewAI une déclaration qui n’est pas du YAML ou pas du JSON avec commentaires, et pour l’importateur Google ADK une configuration qui n’est pas du YAML — arrête l’importation sous parse-failed, dont le message porte la raison propre du parseur. Nommer le format n’y change rien : l’importateur demande l’arbre de la source, et le refus du parseur est la réponse qu’il obtient.
Comment un brouillon est nommé
Chaque importateur donne à l’Aggregate qu’il produit en brouillon, et à la Release à côté de lui lorsqu’il en produit une, le nom <target_namespace>/<name>. La première partie est le paramètre target_namespace, imported sauf si vous en définissez un autre. <name> est le premier des éléments suivants qui n’est pas vide :
-
le nom que la source se donne, dans le champ où son format le déclare :
Importateur Le nom qu’il lit importer/langflowle namedu fluximporter/flowiseaucun : un export ne porte pas de nom propre importer/n8nle namedu workflowimporter/mcple namede la description d’un serveur de registre ; la configuration d’un client n’en porte aucunimporter/composele namede premier niveau du projet, celui d’un fichier de surcharge à la place de celui du fichier qu’il surcharge, comme Compose les fusionneimporter/difyle namede l’application, sousappimporter/crewaile namede la crew danscrew.jsoncoucrew.json;config/agents.yamletconfig/tasks.yamln’en portent aucun, puisqu’un projet classique nomme sa crew dans son programmeimporter/langgraphl’identifiant du graphe que la configuration déclare, puisqu’une configuration ne porte pas de nom propre importer/google-adkle namede l’agent racineimporter/agent-frameworkle namede l’agent ; sondisplayNamen’est pas lu -
le nom du répertoire remis à l’import, en entier —
my.projectgarde son point, écritmy-project— comme Compose nomme un projet d’après le répertoire qui le contient ;aggrega import .nomme le répertoire dans lequel il s’exécute ; -
le nom du fichier remis seul à l’import, sans son extension ;
-
flow.
Un brouillon produit à partir de plusieurs sources — plusieurs projets Compose, configurations, arbres d’agents ou serveurs, ou une configuration déclarant plusieurs graphes — prend leur nom seulement si chacune d’elles se nomme elle-même et que tous s’écrivent de la même façon ; sinon, il prend le suivant. Un nom s’écrit en minuscules, chaque suite de caractères autres que les lettres et chiffres ASCII sous la forme d’un seul trait d’union, les traits d’union aux deux extrémités étant supprimés : Basic Prompting s’écrit basic-prompting, et SupportAgent supportagent. La même source est nommée de la même façon à chaque import. Un Manifest qu’un import produit en brouillon pour une cible prend le nom de la Release, ou celui de l’Aggregate lorsqu’aucune Release n’est produite, comme le décrit Ce qu’ajoute une cible.
Ce que lit l’importateur Langflow
- Les nœuds et les arêtes sous l’objet
datade premier niveau du flux,data.nodesetdata.edges. - Pour chaque nœud, son type, tiré du
data.typedu nœud, et ses champs, tirés des entrées dedata.node.templatedont la valeur est un objet portant untype. Les autres entrées du modèle ne sont pas des champs. - Un champ dont l’objet porte
password: trueest produit en brouillon comme emplacement d’identifiants, et tout autre champ comme champ de valeur. Le nom du champ ne joue aucun rôle, et produire un nœud en brouillon comme Component ne lit la valeur d’aucun champ. - Une note épinglée sur le canevas, un nœud de type
noteNode, n’est pas importée, et une arête vers un nœud qui n’est pas importé est abandonnée. - Produire en brouillon la plateforme qui porte le flux lit aussi, dans le flux : son
idde premier niveau ; la valeur de chaque champ marquépassword: true; le champmcp_serverd’un nœud MCP Tools — le serveur MCP qu’il nomme, et la configuration de ce serveur — ou, à la place, les champs dans lesquels il conserve son serveur ; chaque entrée que Langflow ne marque pas comme identifiants mais qui peut en porter, telles que les liste Valeurs d’identifiants que contient le flux ; le champ dans lequel un nœud nomme son modèle, et le fournisseur du modèle sur lequel il s’exécute ; et les champs par lesquels un nœud atteint l’adresse et la clé d’une partie, qu’il réécrit. Ce qu’ils produisent en brouillon indique ce que devient chacun.
Ce que lit l’importateur Flowise
- Les nœuds et les arêtes au premier niveau du flux,
nodesetedges. - Pour chaque nœud, son type, tiré du
data.namedu nœud ; ses emplacements d’identifiants, tirés des entrées dedata.inputParamsdont letypeestcredential, par leurname; et ses champs de valeur, tirés des clés dedata.inputs, moins celles que nommedata.inputAnchors— là où un autre nœud se connecte en entrée, ce qu’enregistre l’arête qui les relie — et moins les identifiants. - Produire un nœud en brouillon comme Component ne lit la valeur d’aucun champ, et le nom d’un identifiant ne joue aucun rôle dans le fait qu’il en soit un.
- Une note épinglée sur le canevas, un nœud de type
stickyNote, n’est pas importée, et une arête vers un nœud qui n’est pas importé est abandonnée. - Produire en brouillon la plateforme qui porte le chatflow lit aussi, dans celui-ci : son
idde premier niveau, lorsqu’il s’agit d’un UUID ; les identifiants qu’un nœud conserve àdata.credential; la valeur de chaque entrée que sesinputParamsdéclarent de typepassword;FLOWISE_CREDENTIAL_IDparmi les entrées d’un nœud, etcredentialouFLOWISE_CREDENTIAL_IDà l’intérieur d’un objet de configuration à n’importe quelle profondeur de celles-ci ; la configuration de serveur dans l’entréemcpServerConfigd’un nœud ; chaque entrée que Flowise ne marque pas comme identifiants mais qui peut en porter, telles que les liste Valeurs d’identifiants que contient le flux, et le membre dans lequel la configuration d’un agentflow nomme le modèle ou l’outil qu’elle sélectionne ; l’entréemodelNamed’un nœud ; et le Base Path d’un nœud OpenAI, son entréebasepath. Ce qu’ils produisent en brouillon indique ce que devient chacun.
Ce que lit l’importateur n8n
- Les
nodesdu workflow et sesconnections, au premier niveau de l’export. - Pour chaque nœud, son
name, qui l’identifie — les connexions de n8n nomment par leur nom les nœuds qu’elles relient, et les noms des nœuds d’un workflow sont uniques — et sontype, écrit en entier, avec son paquet :@n8n/n8n-nodes-langchain.lmChatOpenAi, par exemple, oun8n-nodes-base.httpRequest. Un nœud sans nom est identifié par sonid. - Chaque connexion que liste le workflow est une arête, du nœud qu’elle quitte au nœud dans lequel elle entre, quel que soit son type : une connexion
maintransporte des données d’un nœud au suivant, et une connexion d’IA —ai_languageModel,ai_tool,ai_vectorStore,ai_embedding,ai_memoryet les autres — remet au nœud dans lequel elle entre le modèle, l’outil, le magasin ou la mémoire que représente le nœud qu’elle quitte. Dans les deux cas, le nœud dans lequel entre une connexion consomme le nœud qu’elle quitte. - Chaque type d’identifiants que nomment les
credentialsd’un nœud, et chaque paramètre de premier niveau que n8n marque comme mot de passe, est produit en brouillon comme emplacement d’identifiants ; tout autre paramètre de premier niveau du nœud est un champ de valeur. Produire un nœud en brouillon comme Component ne lit la valeur d’aucun champ. - Une note épinglée sur le canevas, un nœud de type
n8n-nodes-base.stickyNote, n’est pas importée, et une connexion vers un nœud qui n’est pas importé est abandonnée. - Produire en brouillon la plateforme qui porte le workflow lit aussi, dans celui-ci : son
idde premier niveau ; chaque identifiant qu’un nœud sélectionne ; chaque paramètre que n8n marque comme mot de passe ; l’adresse qu’appelle un nœud client MCP ; les en-têtes et les paramètres de requête qu’un nœud envoie avec une requête que compose le workflow, tels que les liste Valeurs d’identifiants que contient le flux ; et le paramètre dans lequel un nœud de modèle nomme son modèle. Ce qu’ils produisent en brouillon indique ce que devient chacun.
Ce qu’ils produisent en brouillon
Chaque nœud est évalué par rapport aux Components du propre catalogue de l’espace de travail et à rien d’autre, comme le décrit le socket importateur, et chaque importateur embarque une courte table qui met en correspondance des types de nœuds courants de son format — modèles de chat et d’embedding, récupération, requêtes HTTP et, sur Langflow, le nœud MCP Tools MCPTools, qui correspond à core/ai-tool/mcp — avec des Components de la bibliothèque standard. La table de Langflow met aussi en correspondance son composant Language Model, LanguageModelComponent, le modèle de chat qu’appellent ses flux de démarrage, avec core/ai-model/openai, le modèle que sert la connexion de modèle de la plateforme Langflow : le nœud s’exécute sur le fournisseur de modèles que nomme son champ provider, OpenAI par défaut, et un nœud qui nomme un autre fournisseur n’est jamais raccordé à cette connexion, comme le décrit Quels nœuds deviennent des parties. La table de l’importateur n8n met en correspondance les modèles de chat et d’embedding de n8n, son outil client MCP avec core/ai-tool/mcp, ses outils de requête HTTP, son outil SerpApi, ses magasins vectoriels Qdrant, PGVector, Chroma, Milvus et Weaviate, et ses mémoires de chat Postgres et Redis. Un nœud que n8n exécute au sein du workflow lui-même — un agent, une chaîne, un déclencheur, une mémoire que le workflow conserve dans son propre processus, un outil de code — appartient au workflow, et aucune ligne ne le met en correspondance. Une ligne de cette table ne compte pour une correspondance que lorsque le catalogue de l’espace de travail contient le Component qu’elle nomme. La commande rapporte une ligne pour chaque nœud qu’elle a mis en correspondance, indiquant ce qu’elle a choisi, le niveau de correspondance et le score du meilleur candidat, et une ligne indiquant made no choice for <node id> (<node type>) pour un nœud auquel elle ne donne aucun Component propre. Un nœud qui référence un Component du catalogue, plutôt que d’être produit en brouillon, n’a pas de fichier propre : l’Aggregate en brouillon nomme le Component.
La disposition du brouillon relève du paramètre layout. platform, la valeur par défaut, produit en brouillon la plateforme qui exécute le flux, en portant le flux tel qu’il a été exporté, et ne donne un Component propre qu’à chaque partie du flux que prend un socket de la plateforme — sur les plateformes de la bibliothèque standard, un modèle, un serveur MCP ou un autre outil joint via HTTP, et un magasin vectoriel. nodes produit en brouillon chaque nœud comme un Component propre.
La plateforme qui porte le flux
Par défaut, une importation écrit :
aggregate.yaml— un Aggregate en brouillon nommé d’après le flux, comme le décrit Comment un brouillon est nommé. Il contient une instance de la plateforme qui exécute le flux —core/ai-agent/langflow, sous la clélangflow, pour un flux Langflow,core/ai-agent/flowise, sous la cléflowise, pour un flux Flowise, etcore/ai-agent/n8n, sous la clén8n, pour un workflow n8n — qui référence le Component du catalogue de ce nom. L’instance porte le flux dansvalues.flow_definitionet le nomme dans sa valeur d’identification,flow_idsur Langflow,chatflow_idsur Flowise etworkflow_idsur n8n. Chaque partie du flux est une entrée à part entière à côté d’elle, reliée à la plateforme sous lesusesde l’instance.release.yaml— une Release en brouillon du même nom, nommant cet Aggregate, avec une entrée pour la plateforme et une pour chaque partie, portant l’image de la plateforme et rattachant par référence chaque secret dont le brouillon a besoin, comme le décrit Ce que le brouillon laisse à la Release.- un fichier sous
components/pour chaque partie qu’elle produit en brouillon plutôt que de la référencer, écrit comme la disposition nœud par nœud écrit un nœud produit en brouillon.
Lorsqu’une cible est donnée, l’import produit manifest.yaml à côté d’eux, comme le décrit Ce qu’ajoute une cible.
Chaque nœud qui n’est pas une partie reste à l’intérieur du flux que porte la plateforme et ne devient aucun Component. Sa décision enregistre les candidats par rapport auxquels il a été évalué et ne choisit rien, et sa justification indique kept in the flow <platform> carries, with no Component of its own:, suivi de la raison — par exemple, qu’aucune ligne de mappage ne nomme son type et que son candidat le plus proche n’a obtenu qu’un score limité. Le flux conserve les arêtes entre les nœuds ; le brouillon n’en écrit aucune de son côté.
Le chatflow Multiple Documents QnA de Flowise, exporté sous le nom Multiple Documents QnA.json et importé sans paramètre ni cible sur un catalogue contenant la plateforme Flowise de la bibliothèque standard et ses Components de modèle et d’outil de récupération, est produit en brouillon sous la forme de cet Aggregate, la majeure partie du flux étant omise ici et marquée ... :
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/multiple-documents-qna version: 0.1.0 description: Draft Aggregate imported from a source in the flowise format.spec: components: flowise: type: core/ai-agent/flowise # For the compose target only, uncomment the lines below, which 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. # features: # 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: '96da3b80-86d0-5f23-b4e7-2573ea1f76ad' flow_definition: | { "description": "Tool agent that can retrieve answers from multiple sources using relevant Retriever Tools", ... "embeddings": "{{"{{"}}openAIEmbeddings_0.data.instance}}", ... } uses: model: chatopenai-0: target: chatopenai-0 # For the compose target only, uncomment the lines below, which 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-3.5-turboSon modèle de chat est la seule partie reliée ; ses deux modèles d’embedding restent dans le flux, puisque le socket de modèle accueille une seule connexion, et ses outils de récupération restent dans le flux, puisque aucun socket de la plateforme ne les prend. L’importation rapporte chacun.
L’identifiant du flux est celui que lui donne l’export — l’id de premier niveau d’un flux Langflow, l’id de premier niveau d’un chatflow Flowise lorsqu’il s’agit d’un UUID, et l’id de premier niveau d’un workflow n8n — lorsqu’il compte de une à 128 lettres, chiffres, ., -, _ ou :, et commence par une lettre ou un chiffre. Lorsque l’export n’en donne aucun, ou en donne un contenant tout autre caractère, le brouillon écrit un UUID fondé sur un nom, dérivé du nom du format et du flux tel qu’il est porté, de sorte qu’un flux produit toujours un même identifiant, et un commentaire au-dessus de la valeur indique qu’il a été dérivé. Un chatflow exporté depuis l’éditeur de Flowise ne porte aucun id, il reçoit donc un identifiant dérivé.
Lorsque le catalogue de l’espace de travail ne contient aucun Component portant le nom de la plateforme, le brouillon nomme tout de même la plateforme et n’y relie aucune partie : chaque nœud qui aurait été une partie reste dans le flux, rapporté, et l’importation avertit que le catalogue ne contient aucun Component de ce type.
Quels nœuds deviennent des parties, et où chacun est relié
Un nœud est une partie du flux lorsqu’une ligne de la table de mappage de l’importateur, ou une entrée mapping_overrides, met son type en correspondance, ou lorsque son meilleur candidat est au moins une correspondance de niveau moyen. Un nœud MCP Tools de Langflow est une partie quels que soient ses scores : il nomme le serveur MCP qu’il appelle, et ce serveur est la partie. Une partie devient un Component propre, référencé ou produit en brouillon exactement comme en décide reuse_mode, et est reliée au premier socket de la plateforme — dans l’ordre dans lequel l’entrée de catalogue de la plateforme déclare ses sockets — dont le sélecteur de labels est satisfait par le Component de la partie : les labels du Component qu’elle référence ou, pour une partie produite en brouillon, ceux de son meilleur candidat lorsque ce candidat est au moins une correspondance de niveau moyen. Une partie dont le Component ne satisfait le sélecteur d’aucun socket, ou qui n’a aucun Component sur lequel lire des labels, reste dans le flux, et l’importation la rapporte.
Ces règles restreignent cela :
- Un modèle Langflow qui nomme un autre fournisseur ne reçoit aucune connexion de modèle. Un nœud
LanguageModelComponentouEmbeddingModels’exécute sur le fournisseur de modèles que nomme son champproviderou, là où celui-ci est vide, sur le fournisseur du modèle que sélectionne son champmodel. La plateforme livre sa connexion de modèle pour un client compatible avec OpenAI, si bien qu’un nœud qui nomme un fournisseur autre queOpenAI— quel que soit ce vers quoi une ligne de correspondance ou une surcharge le fait correspondre — n’est jamais raccordé au socketmodel: il est raccordé au socket suivant que satisfait son Component, ou reste dans le flux, sa décision ne choisissant rien et aucun Component n’étant produit en brouillon pour lui, et l’import le signale en nommant le fournisseur sur lequel il s’exécute. Un nœud qui ne sélectionne aucun fournisseur, qui le nomme au moyen d’une variable globale ou qui prend son modèle d’un autre nœud est raccordé comme n’importe quelle autre partie. - Un socket qui accueille une seule connexion est occupé par une seule partie. Sur chaque plateforme, le socket
modelaccueille une connexion, que les Recipes de la plateforme fournissent sous la forme d’un seulOPENAI_BASE_URLet d’un seulOPENAI_API_KEY. Lorsque plusieurs parties y sont placées, la première dont le Component portemodel.aggrega.ai/capability: generativel’occupe — la première partie, lorsque aucune ne le porte — et chaque autre reste dans le flux, rapportée avec la partie qui occupe la connexion et avec la façon dont le flux l’atteint tel que son nœud est écrit. - Langflow n’atteint une connexion
toolsqu’au travers d’un nœud MCP Tools qui la nomme. La plateforme écrit l’adresse d’une connexion tools dans la configuration de serveur du nœud MCP Tools dont le champmcp_servernomme la connexion, de sorte qu’un nœud dont le modèle ne porte aucun champmcp_server— quel que soit son type, et quoi que lui fasse correspondre une ligne de mappage ou un remplacement — n’est jamais relié au sockettools: il est relié au socket suivant que satisfait son Component, ou reste dans le flux, rapporté. Un nœud MCP Tools qui ne nomme aucun serveur n’est relié à aucun socket et est rapporté. Il en va de même pour un nœud dont la configuration de serveur démarre un serveur qui lui est propre — il porte uncommand, ou définit le modeStdio— et son rapport indique ce qu’il faut retirer, puisque le build de la plateforme s’arrête sur un nœud nommant un serveur auquel ne répond aucune connexion tools. - Un serveur MCP est relié par le nom que lui donne le flux. Les nœuds d’un même flux qui nomment un même serveur atteignent une seule partie, produite en brouillon une seule fois, au travers d’une seule connexion. L’alias de la connexion est le nom du serveur lorsque l’alias d’une connexion peut le prendre — lettres, chiffres, traits d’union et traits de soulignement — et qu’aucune autre connexion de ce socket ne fournit sous le même nom de variable, son alias en majuscules avec chaque autre caractère écrit comme trait de soulignement. Sinon, la connexion prend un alias dérivé de la clé de la partie, le serveur du nœud est renommé avec cet alias dans le flux que porte le brouillon, et la décision de la partie l’indique.
La décision d’une partie reliée indique à quel socket de la plateforme elle est reliée et au travers de quelle connexion, et nomme chaque socket pour lequel elle a été écartée, et pourquoi.
Comment le flux porté atteint chaque partie
Là où le format le permet, le flux que porte la plateforme atteint chaque partie reliée au travers de sa connexion, et le brouillon écrit dans le flux ce qui l’y amène — le nom d’une variable, une adresse vidée, ou ce que le nœud enverrait à la place de ce que fournit la connexion, vidé, et jamais une valeur. Il s’agit de câblage, et non du retrait d’une valeur d’identifiants : le brouillon l’écrit quoi que dise le paramètre empty_credentials, puisqu’une valeur conservée à cet endroit remplacerait ce que livre la connexion.
-
Un nœud MCP Tools de Langflow. La plateforme écrit l’adresse que livre sa connexion dans la configuration de serveur du nœud et, là où la connexion porte des identifiants, le nom de la variable qui les contient sous l’en-tête que publie l’outil. Le brouillon écrit vide l’adresse que l’export contenait à cet endroit, de sorte que le flux n’en conserve aucune copie, et laisse l’adresse du serveur —
infra.endpointde la partie — à la Release. Langflow envoie le champheaderspropre au nœud par-dessus les en-têtes de sa configuration de serveur, si bien que le brouillon écrit vide la valeur entière de ce champ en conservant sa nature — un objet comme{}, une liste comme[], du texte comme une chaîne vide — puisqu’un en-tête conservé avec sa valeur vidée serait tout de même envoyé, alors qu’un objet ou une liste vide ne remplace rien. -
Un nœud de modèle ou de magasin vectoriel de Langflow. La plateforme livre une connexion de modèle sous la forme de
OPENAI_BASE_URLetOPENAI_API_KEY, et une connexion de magasin vectoriel sous la forme de variables nommées d’après son alias, que Langflow lit au moyen d’un champ nommant une variable globale : un champ dont l’objet porteload_from_db: truecontient le nom de la variable comme valeur, et Langflow lit la variable globale de ce nom, ou la variable d’environnement de ce nom là où aucune n’est stockée. Le brouillon écrit chacun de ces champs avec le nom de la variable etload_from_db: true:- le champ
openai_api_based’un nœudOpenAIModel, commeOPENAI_BASE_URL, et sonapi_key, commeOPENAI_API_KEY; - le champ
openai_api_based’un nœudOpenAIEmbeddings, commeOPENAI_BASE_URL, et sonopenai_api_key, commeOPENAI_API_KEY; - le champ
api_keyd’un nœudLanguageModelComponent, commeOPENAI_API_KEY; - le champ
api_based’un nœudEmbeddingModel, commeOPENAI_BASE_URL, et sonapi_key, commeOPENAI_API_KEY; - le champ
pg_server_urld’un nœudpgvector, commeAGGREGA_VECTOR_STORE_<ALIAS>_CONNECTION_STRING, où<ALIAS>est l’alias de la connexion mis en majuscules, chaque caractère autre qu’une lettre ou un chiffre étant écrit comme un trait de soulignement.
Un nœud
LanguageModelComponentouEmbeddingModels’exécute sur l’un de plusieurs fournisseurs de modèles — celui que nomme son champproviderou, là où celui-ci est vide, le fournisseur du modèle que sélectionne son champmodel— et remet sa clé à ce fournisseur. La plateforme livre la connexion de modèle pour un client compatible avec OpenAI, si bien qu’un tel nœud n’est écrit avec les variables que là où il s’exécute surOpenAI. Un nœud qui s’exécute sur un autre fournisseur n’est jamais raccordé, comme ci-dessus ; un nœud qui n’en sélectionne aucun, qui nomme son fournisseur au moyen d’une variable globale ou qui prend son modèle d’un autre nœud est écrit sans aucune d’elles, de sorte que le brouillon ne dirige jamais un autre fournisseur vers la clé de la connexion. Là où aucun champ d’un tel nœud ne donne l’adresse de son API — un nœudLanguageModelComponentn’en contient aucune pour OpenAI, et le champapi_based’un nœudEmbeddingModelpeut être absent, ou vide là où il ne peut pas nommer de variable — le client OpenAI sur lequel il s’exécute prendOPENAI_BASE_URLdans l’environnement, si bien que le nœud atteint tout de même l’adresse que livre la plateforme.Le client d’un nœud
OpenAIEmbeddingsenvoie sesdefault_headerspar-dessus ceux qu’il construit à partir de la clé, et fusionne sondefault_querypar-dessus la requête de l’adresse qu’il appelle, si bien que, sur un tel nœud que le brouillon relie, la valeur entière de chacun est écrite vide en conservant sa nature, comme le sont lesheadersd’un nœud MCP Tools.Un champ que l’export écrit sans ces deux membres n’est pas réécrit — un champ d’identifiants parmi eux est reporté tel qu’il est écrit, ou écrit vide là où le paramètre le demande, comme ci-dessous. Là où ce champ est celui qui porte l’adresse de la partie — et, pour un nœud
LanguageModelComponentouEmbeddingModel, en donne une —, là où un tel nœud ne s’exécute pas surOpenAI, ou là où le nœud est d’un autre type, l’importation rapporte la partie comme atteinte à l’adresse que donnent le flux ou les valeurs par défaut de son composant. - le champ
-
Un nœud OpenAI de Flowise. Le client OpenAI sur lequel Flowise exécute un nœud
chatOpenAIouopenAIEmbeddingslitOPENAI_BASE_URLetOPENAI_API_KEYdans l’environnement là où le Base Path du nœud est vide et où il ne sélectionne aucun identifiant, si bien que le brouillon écrit vide un Base Path que contient l’export, ainsi que les identifiants que sélectionne le nœud, àdata.credential. Ce client envoie les en-têtes par défaut du nœud, sesbaseOptions, par-dessus l’en-tête qu’il construit à partir de la clé, si bien que le brouillon écrit vide leur valeur entière en conservant sa nature. Un nœud de modèle de tout autre type est rapporté comme atteint à l’adresse que donnent le chatflow ou ses propres valeurs par défaut. -
Un outil ou un magasin vectoriel de Flowise. Un chatflow ne lit l’adresse que la plateforme livre pour l’un d’eux —
AGGREGA_TOOL_<ALIAS>_URLouAGGREGA_VECTOR_STORE_<ALIAS>_URL— qu’au moyen d’une variable Runtime de ce nom, que rien ne crée au démarrage. Le brouillon n’écrit rien pour cette adresse, et l’importation rapporte l’étape qui amène le chatflow à la lire : créer la variable Runtime dans la page Variables de Flowise, et la lire dans le nœud comme$vars.<name>. -
Tout nœud n8n. La plateforme livre une connexion de modèle sous la forme de
OPENAI_BASE_URLetOPENAI_API_KEY, et une connexion tools ou de magasin vectoriel sous la forme deAGGREGA_TOOL_<ALIAS>_URLouAGGREGA_VECTOR_STORE_<ALIAS>_URL, alors qu’un nœud n8n atteint un modèle, un magasin ou un service à l’adresse que donnent les identifiants stockés qu’il sélectionne, ou à l’adresse que contiennent ses propres paramètres, et qu’un workflow ne lit une variable d’environnement qu’au moyen d’une expression lisant$env, ce que la plateforme refuse à moins que l’Aggregate ne définissevalues.allow_env_access_in_nodesàtrue. Le brouillon laisse cette valeur à sa valeur par défaut,false, puisque la définir permet à chaque workflow, et à chaque utilisateur qui peut en modifier un, de lire chaque variable de l’environnement de la plateforme, identifiants livrés compris. Le brouillon n’écrit donc rien dans le workflow pour une connexion, et chaque partie reliée est rapportée comme atteinte autrement qu’au travers de celle-ci. Un nœud client MCP atteint son serveur à l’adresse que contient le workflow — telle que l’export l’a écrite, ou aucune là où le paramètreempty_credentialsl’écrit vide, comme ci-dessous — et l’adresse propre du serveur —infra.endpointde la partie — est laissée à la Release.
Là où le flux est porté, chaque partie reliée est rapportée avec celui de ces cas qui s’applique : part-reads-connection là où le flux atteint la partie au travers de sa connexion, et part-address-in-flow là où il l’atteint autrement qu’au travers de sa connexion — à une adresse que contient le flux, ou à une adresse que donnent les valeurs par défaut de son composant. La décision de la partie dit la même chose.
Un nœud que le brouillon ne relie à aucun socket peut tout de même être atteint par une connexion que le brouillon relie bel et bien, tel que le nœud est écrit : un client OpenAI sans adresse ni clé propres lit dans son environnement les OPENAI_BASE_URL et OPENAI_API_KEY que la plateforme livre pour la connexion de modèle. Là où c’est le cas, le brouillon écrit le nœud comme il écrirait un nœud relié, de sorte que rien de ce qu’il contient n’est envoyé à la place de ce que fournit la connexion, et le rapporte avec part-reads-connection :
- un nœud
OpenAIEmbeddingsde Langflow dont le champ d’adresse nomme la variableOPENAI_BASE_URLque livre la plateforme, lue comme une variable globale, pendant qu’une partie est reliée au socket de modèle : sesdefault_headersetdefault_query; - un nœud
chatOpenAIouopenAIEmbeddingsde Flowise dont le Base Path est vide et qui ne sélectionne aucun identifiant, ainsi que la configuration d’un tel modèle qu’un nœud d’agentflow conserve parmi ses entrées, pendant qu’une partie est reliée au socket de modèle : sesbaseOptions.
Sur tout autre nœud, ces valeurs ne relèvent pas du câblage : elles sont reportées telles qu’elles sont écrites, ou écrites vides là où le paramètre le demande, comme le dit la section suivante.
Valeurs d’identifiants que contient le flux
Avant que le flux soit porté, l’importation repère chaque valeur qu’il contient et qui peut porter des identifiants, aux endroits énumérés ci-dessous, chacune de l’une de trois sortes : ce qu’un format marque comme identifiants ; un membre de la configuration d’un serveur MCP, partout où un format en conserve une ; et une entrée qu’un format marque comme n’étant pas des identifiants mais qui peut tout de même en porter — en-têtes de requête, paramètres de requête, une requête entière écrite comme une ligne de commande, une entrée contenant des identifiants sous le nom d’identifiants.
Par défaut, l’importation n’en écrit aucune vide : le flux est porté tel qu’il a été exporté, et chaque valeur repérée qui contient quelque chose — ni une chaîne vide ni null — est nommée dans un avertissement credential-carried, par son nœud et son champ — un en-tête ou un paramètre de requête par son nom —, jamais par sa valeur ni par une partie de celle-ci, avec la valeur du paramètre empty_credentials qui l’écrit vide. Le paramètre active le retrait : marked écrit vide ce qu’un format marque comme identifiants et chaque membre de la configuration d’un serveur MCP ; all écrit vides en outre les entrées marquées comme n’en étant pas. Chaque valeur qu’il écrit vide est rapportée avec credential-emptied, par son nœud et son champ, jamais par sa valeur ; une valeur déjà vide, ou null, est laissée telle quelle et n’est pas rapportée. Une valeur que le paramètre n’accepte pas arrête l’importation, qui ne produit rien en brouillon, au lieu de valoir none.
Une valeur repérée qui est une référence de variable et rien d’autre ne contient aucune valeur propre : le nom nu d’une variable, ${NAME} — y compris une variable prédéfinie telle que ${workspaceFolder} ou ${userHome} — ou l’une des formes que définissent les clients MCP, ${env:NAME} et ${input:id}. Quoi que dise le paramètre, elle est reportée telle qu’elle est écrite et n’est nommée dans aucun avertissement, quel que soit le format du flux, comme l’importateur MCP en écrit une. Il en va de même d’un membre qui est une seule référence à l’intérieur d’une valeur qu’un format conserve sous forme de texte, comme un mcpServerConfig de Flowise écrit en texte JSON, ou des en-têtes et des paramètres de requête conservés comme un objet JSON dans du texte sur Flowise et n8n : écrit vide, le texte conserve ce membre tel qu’il est écrit.
Une référence portant du texte après un opérateur contient ce texte, qui peut être une clé, que des deux-points précèdent ou non l’opérateur : une valeur par défaut, ${NAME:-value} ou ${NAME-value} ; une alternative, ${NAME:+value} ou ${NAME+value} ; un message, ${NAME:?message} ou ${NAME?message} ; une affectation, ${NAME:=value} ou ${NAME=value}. Elle est repérée comme toute autre valeur — reportée et nommée dans un avertissement credential-carried par défaut, écrite vide là où le paramètre le demande pour sa sorte — et il en va de même de tout autre texte à l’intérieur de ${…}, comme ${config:name}, et du texte à côté d’une référence, comme --key=${NAME}.
Ce que le brouillon écrit pour qu’un nœud atteigne sa connexion — une adresse écrite vide, le nom d’une variable, des identifiants sélectionnés ou des en-têtes par défaut écrits vides, comme le décrit Comment le flux porté atteint chaque partie — relève du câblage : c’est écrit quoi que dise le paramètre, rapporté avec la manière dont le nœud atteint sa connexion, et jamais rapporté comme une valeur d’identifiants. Ce qui se trouve en dehors de tous les endroits ci-dessous revient à l’auteur à examiner, comme le dit la fin de cette section.
Ce qu’un format marque comme identifiants — écrit vide sous marked et all :
- Langflow — la valeur de chaque champ de modèle marqué
password: true, y compris un champ contenant le nom d’une variable globale, à moins que le brouillon n’écrive ce champ avec le nom de la variable que livre la plateforme, comme ci-dessus. - Flowise — les identifiants qu’un nœud conserve à
data.credential, que sélectionne son paramètre d’identifiants ; la valeur de chaque entrée que sesinputParamsdéclarent de typepassword; etFLOWISE_CREDENTIAL_IDparmi les entrées d’un nœud, ainsi quecredentialouFLOWISE_CREDENTIAL_IDà l’intérieur d’un objet de configuration à n’importe quelle profondeur de celles-ci, comme un agentflow conserve celle d’un modèle ou d’un outil. - n8n — l’
idde chaque identifiant stocké qu’un nœud sélectionne, àcredentials.<type>.id. Un export n8n conserve un identifiant sous forme de référence, jamais sa valeur, et lenamede la référence n’est pas repéré : n8n, en important le workflow sur une autre instance, résout un identifiant dont il ne détient pas l’idpar son type et son nom. Un identifiant qu’un export plus ancien sélectionne par son seul nom nomme un identifiant et n’en contient aucun, et n’est pas repéré. Et la valeur de chaque paramètre que n8n marque comme mot de passe dans les définitions de ses nœuds de base — lesecretdu nœud Crypto, par exemple, ou lepassworddes nœuds qui créent un utilisateur — où qu’il se trouve parmi les paramètres du nœud, un nœud utilisé comme outil d’un agent étant lu comme le nœud qu’il est.
La configuration d’un serveur MCP — écrite vide sous marked et all :
- La configuration
mcp_serverd’un nœud MCP Tools de Langflow, et lemcpServerConfigd’un nœud Flowise, écrits en texte JSON ou comme un objet : chaque valeur d’en-tête, que les en-têtes soient un objet, des lignes d’une clé et d’une valeur ou des objets fusionnés en entier, un élément de toute autre sorte étant repéré en entier ; chaque valeur d’environnement ; l’adresse du serveur ; la commande ; et chaque argument. Aucun des deux formats ne marque une adresse, une commande ou un argument comme identifiants, et chacun peut porter une clé — une adresse dans sa partie utilisateur, son chemin ou sa requête —, si bien que tous trois sont repérés aussi, sur les deux formats. Écrits vides, la commande et chaque argument conservent leurs membres, de sorte qu’une configuration qui démarre son propre serveur se lit toujours comme telle. Là où un nœud MCP Tools de Langflow est relié à une connexion tools, son adresse relève du câblage, comme ci-dessus, et n’est jamais rapportée comme une valeur d’identifiants. Une configuration Flowise écrite en texte qui ne se lit pas comme un objet JSON est repérée en entier, puisque rien à l’intérieur ne peut être repéré. - Un nœud MCP Tools de Langflow qui ne porte aucun champ
mcp_serverconserve à la place son serveur dans des champs qui lui sont propres — l’adresse danssse_url, les en-têtes dansheaders_input, l’environnement dansenv, et la ligne de commande entière, arguments compris, danscommand— et Langflow ne marque aucun d’eux non plus comme identifiants, si bien que chaque valeur d’en-tête, chaque entrée deenv, l’adresse et la ligne de commande sont repérées, leurs champs et entrées étant conservés lorsqu’ils sont écrits vides. Là oùenvest une liste, chaque entrée est rapportée par sa position, puisque le nom d’une variable et sa valeur partagent un même texte. Un tel nœud ne nomme aucun serveur MCP, si bien qu’il n’est jamais relié à une connexion tools. - Le champ
headerspropre à un nœud MCP Tools de Langflow, que Langflow envoie au serveur par-dessus les en-têtes de sa configuration, sur un nœud que le brouillon ne relie pas : sa valeur entière, écrite vide en conservant sa nature, comme sur un nœud relié, et rapportée une seule fois, commeheaders. - Les composants MCP Tools (SSE) et MCP Tools (stdio) de Langflow, que Langflow marque comme obsolètes, conservent leur serveur dans un seul champ chacun — un nœud
MCPSseson adresse dansurl, un nœudMCPStdiosa ligne de commande entière, arguments compris, danscommand— repéré en entier. Aucun des deux ne nomme de serveur MCP, si bien qu’aucun des deux n’est relié à une connexion tools. - Un nœud client MCP de n8n — le MCP Client Tool qu’appelle un agent, le nœud MCP Client, ou un client d’un serveur que liste le registre de n8n — conserve l’adresse du serveur dans son paramètre
endpointUrl, ousseEndpointdans sa première version, et ses en-têtes uniquement sous forme d’identifiants qu’il sélectionne ; l’adresse est repérée en entier, reliée ou non.
Une entrée qu’un format marque comme n’étant pas des identifiants — écrite vide sous all seul :
- En-têtes de requête — sur Langflow, les
headersd’un nœudAPIRequest,URLComponent,CloudflareWorkersAIEmbeddingsouConfluentKafkaProduceret lesapi_headersd’un nœudDoclingRemote; sur Flowise, lesheadersd’un nœudhttpAgentflow,getApiChain,postApiChain,openApiChain,apiLoader,openAPIToolkitousearXNG, lesrequestsGetHeaders,requestsPostHeaders,requestsPutHeadersetrequestsDeleteHeadersdes outils Requests, et lesbaseOptions— les en-têtes par défaut qu’envoie le client d’un modèle — d’un nœudazureChatOpenAI,azureOpenAIEmbeddings,chatCerebras,chatOpenAICustom,openAIEmbeddingsCustom,chatOpenRouter,chatSambanovaouopenAI; sur n8n, lesheaderParameters,jsonHeaders,headerParametersUietheaderParametersJsond’un nœudn8n-nodes-base.httpRequest— sa version actuelle conserve les deux premiers, ses versions antérieures les deux autres — et du même nœud utilisé comme outil d’un agent, lesparametersHeadersetjsonHeadersd’un nœud@n8n/n8n-nodes-langchain.toolHttpRequest, et lesheaderParametersUid’un nœudn8n-nodes-base.graphql. Le nom d’un en-tête ne porte aucun secret, si bien que la valeur de chaque en-tête est repérée et son nom conservé, quelle que soit la forme que prennent les en-têtes : un objet associant des noms à des valeurs, des lignes d’une clé et d’une valeur — sur n8n, des lignes d’unnameet d’unvalue— ou des objets que Langflow fusionne en entier dans les en-têtes. Chaque en-tête est rapporté par son nom. Un élément d’une liste qui n’est pas une ligne d’en-tête est repéré en entier et rapporté par sa position. Les en-têtes écrits en texte sont repérés en entier, sauf sur Flowise et n8n où le texte contient les en-têtes sous forme d’objet JSON : là, écrit vide, le texte est réécrit sur place, chaque valeur vide, et rapporté une seule fois avec les noms des en-têtes qu’il contient. Un texte n8n commençant par=est une expression que n8n évalue lorsque le workflow s’exécute, et il est repéré en entier. Écrites vides, toutes les valeurs le sont, y compris celles des en-têtes qui ne contiennent aucun secret tels queUser-Agent, si bien qu’une requête importée est envoyée avec ces valeurs vides jusqu’à ce que son auteur les rétablisse. - Paramètres de requête — sur Langflow, les
query_paramsd’un nœudAPIRequestouGoogleSerperAPIet lessearch_paramsd’un nœudSerpAPI,Serp,SearchAPIouSearchComponent; sur Flowise, lesqueryParamsd’un nœudhttpAgentflowet lescustomParametersd’un loadersearchApi; sur n8n, lesqueryParameters,jsonQuery,queryParametersUietqueryParametersJsond’un nœudn8n-nodes-base.httpRequest, utilisé comme outil ou non, lesparametersQueryetjsonQueryd’un nœud@n8n/n8n-nodes-langchain.toolHttpRequest, et lesqueryParametersetqueryParametersJsonqu’un nœudn8n-nodes-base.facebookGraphApiconserve parmi sesoptions. Chacun est envoyé comme la chaîne de requête d’une requête, et un paramètre de requête peut porter une clé — certaines API de recherche prennent la leur commeapi_keydans la requête — si bien que chacun est repéré comme le sont les en-têtes : chaque valeur, son nom conservé, quelle que soit la forme que prennent les paramètres, et chacun rapporté par son nom ; les paramètres écrits en texte sont repérés en entier, sauf sur Flowise et n8n où le texte les contient sous forme d’objet JSON, lequel, écrit vide, est réécrit sur place et rapporté une seule fois avec les noms qu’il contient. Écrites vides, toutes les valeurs le sont, y compris celles des paramètres qui ne contiennent aucun secret, si bien qu’une requête importée est envoyée avec ces valeurs vides — ou, depuis un nœud HTTP de Flowise, qui n’envoie aucun paramètre dont la valeur est vide, sans eux — jusqu’à ce que son auteur les rétablisse. - En-têtes par défaut et requête par défaut sur un nœud OpenAI qu’aucune connexion n’atteint — les
default_headersetdefault_queryd’un nœudOpenAIEmbeddingsde Langflow, et lesbaseOptionsd’un nœudchatOpenAIouopenAIEmbeddingsde Flowise, où que se trouve le nœud, y compris la configuration du modèle qu’un agentflow sélectionne, là où le brouillon ne relie pas le nœud et ne trouve aucune connexion l’atteignant tel qu’il est écrit ; là où c’est le cas, ils relèvent du câblage, comme ci-dessus. Chacun est repéré en entier et, écrit vide, conserve sa nature — un objet comme{}, une liste comme[], du texte comme une chaîne vide — et est rapporté une seule fois. - Une requête entière écrite comme une ligne de commande — le
curl_inputd’un nœudAPIRequestde Langflow et lecurld’un nœudWebhook, repérés en entier, y compris la valeur par défaut du Webhook. Aucun des deux n’est lu lorsque le flux s’exécute : le premier ne fait que remplir les champs du nœud dans l’éditeur, le second montre un exemple. - Une entrée contenant des identifiants sous le nom d’identifiants — l’
api_keyd’un nœudOlivyaComponentde Langflow, leverification_tokende chaque composant Composio, et lemem0_configd’un nœudmem0_chat_memory, dont la valeur entière conserve sa nature lorsqu’elle est écrite vide ; ainsi que lewebhookSecretet lecallbackSecretd’un nœudstartAgentflowde Flowise et lebearerTokend’un nœudteradataMCP. Chacun est repéré en entier. Une entrée dont le nom ne fait que ressembler à des identifiants — le nom d’une clé stockée ailleurs, un nom d’utilisateur, ou une option que le composant déclare comme non secrète — n’est pas repérée.
Hormis les valeurs que le paramètre écrit vides, ce que le brouillon écrit pour que le flux atteigne ses parties, les poignées d’une arête Langflow, écrites comme les écrit l’éditeur de Langflow, et les retours chariot écrits comme des sauts de ligne décrits ci-dessous, le flux est porté tel qu’il a été exporté : sans rien de tout cela, octet pour octet.
Une connexion dans le brouillon ne porte aucune valeur d’identifiant : la Release en brouillon rattache par référence celui que présente chaque connexion, comme le décrit Ce que le brouillon laisse à la Release.
Chaque valeur que le paramètre laisse telle qu’elle est écrite parvient au brouillon, et l’auteur l’examine, guidé par les avertissements credential-carried. Aucune règle portant sur un champ n’atteint non plus le reste d’un flux, si bien que l’auteur l’examine aussi avant de partager un brouillon : le code propre d’un composant, que porte le flux et dans lequel un composant personnalisé peut contenir une clé ; les entrées que l’éditeur ajoute à un nœud au-delà de celles que déclare son composant ; le corps avec lequel une requête est envoyée, comme celui d’un nœud APIRequest ou httpAgentflow, qui peut porter un jeton ; les arguments qu’un nœud transmet au client de son modèle ou à un loader sous la forme d’un objet qui lui est propre, comme les model_kwargs d’un nœud EmbeddingModel de Langflow ou les additionalInputs d’un nœud replicate de Flowise, qui peuvent porter une clé sous n’importe quel nom ; une adresse autre que celle d’un serveur MCP, qui peut porter une clé dans sa partie utilisateur ou sa requête ; le code d’un nœud Code de n8n, ainsi que les en-têtes ou la requête d’un nœud qui envoie une requête que l’importateur n’énumère pas ci-dessus ; et le texte libre tel qu’un prompt ou un message.
Ce que le brouillon laisse à la Release
La Release en brouillon porte, sur l’entrée de la plateforme et sur celle de chaque partie, ce que le flux ne peut pas fournir :
- L’image de la plateforme, en tant que
infra.image: le choix d’image propre à l’importeur, à la version que les Recipes du catalogue pour la plateforme sont connues pour exécuter —langflowai/langflow:1.6.0,flowiseai/flowise:3.1.3etn8nio/n8n:1.110.1—, sous un commentaire qui le dit. L’import ne la relève ni ne l’abaisse jamais pour suivre la source ; là où l’export indique une version différente de la plateforme, comme le fait lelast_tested_versiond’un flux Langflow, le commentaire la nomme. - Le port sur lequel la plateforme est publiée, en tant que
infra.published_port, avec--target composeuniquement : 7860 pour Langflow, 3000 pour Flowise et 5678 pour n8n, les ports sur lesquels chacune sert, que sa Recipe Compose publie sur l’adresse de bouclage de l’hôte, 127.0.0.1. Le commentaire au-dessus indique que le port n’est joignable que depuis cette machine, par tout processus qui s’y exécute, et que supprimer la ligne garde le service interne. Un deuxième flux d’un même import prend le port suivant qu’aucun précédent ne prend. Avec toute autre cible, ou sans cible, il n’est pas écrit. - Le secret propre à la plateforme et l’identifiant de chaque connexion à un modèle, rattachés par référence et jamais sous forme de valeur : sur Langflow, l’emplacement
admin_password, lu tant quevalues.require_authenticationreste àtrue; sur Flowise, l’emplacementowner_password, requis tant quevalues.flow_definitionest défini ; et, là où une partie est reliée au socketmodelde la plateforme, lecredentialde cette connexion. La plateforme n8n ne prend aucun secret propre. La manière dont chacun est rattaché dépend de la cible, comme le décrit Les secrets, pour chaque cible. - Chaque valeur qu’aucune source ne contient, écrite comme une chaîne vide sous un commentaire qui dit ce qu’elle est : sur Flowise,
infra.owner_email, l’adresse e-mail du compte propriétaire, requise tant quevalues.flow_definitionest défini ; et l’adresse de chaque serveur MCP relié à la plateforme,infra.endpointde sa partie. Chacune est une valeur que l’import doit, à laquelle on répond comme le décrit Le fichier de réponses de l’import.
L’identifiant que présente une connexion à un outil ou à un magasin vectoriel n’est pas produit en brouillon : l’identifiant d’une telle connexion arrête le build là où l’outil ne publie aucun en-tête dans lequel l’envoyer, si bien qu’un commentaire au-dessus de l’entrée de la plateforme le nomme, pour que vous le rattachiez là où l’outil en accepte un.
Les secrets, pour chaque cible
Sur --target helm, chaque secret est un core/referenced-secret dont l’origin est le nom d’un Secret Kubernetes déjà présent dans le namespace, qui contient la valeur sous la clé de données value. Ce nom n’est à fournir par aucune source, il est donc écrit vide sous un commentaire qui dit ce qu’il contient, et il fait partie des valeurs que l’importation doit encore fournir ; le Manifest produit en brouillon fait correspondre core/referenced-secret à helm/k8s-existing-secret.
Sur toute autre cible, et sans cible, chaque secret est un core/secret-value dont l’origin est une référence à une variable — ${LANGFLOW_ADMIN_PASSWORD}, ${FLOWISE_OWNER_PASSWORD} et ${OPENAI_API_KEY} pour les identifiants d’une connexion à un modèle — qu’une cible substituant les références de variables, comme le fait Docker Compose au démarrage de la pile, lit dans l’environnement, si bien qu’aucun fichier ne contient la valeur et que rien n’est dû pour elle. Le chatflow Flowise ci-dessus, importé sans cible, est produit en brouillon avec cette Release :
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: name: imported/multiple-documents-qna # 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/multiple-documents-qna # manifest: left empty, since the import was given no target; an import given a target drafts the Manifest and names it here. manifest: "" 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: "" 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: {}Sans cible, elle doit deux valeurs, spec.manifest et infra.owner_email ; avec --target compose, l’e-mail du propriétaire seul ; avec --target helm, l’e-mail du propriétaire et les noms des deux Secrets Kubernetes.
Sur la cible compose, un secret que la Release rattache seule arrive sous une même clé, value, si bien que le mot de passe du propriétaire ou de l’administrateur et les identifiants d’une connexion arriveraient tous deux sous celle-ci. L’Aggregate déclare donc chacun avec une clé qui lui est propre là où la plateforme accueille une connexion : owner_password avec la clé OWNER_PASSWORD sur Flowise, admin_password avec la clé LANGFLOW_SUPERUSER_PASSWORD sur Langflow, et la credential de la connexion au modèle avec la clé OPENAI_API_KEY sur les trois plateformes, chacune sous un commentaire qui en donne la raison. Avec --target compose, ces lignes sont écrites actives ; sans cible, elles sont écrites commentées, comme dans l’exemple ci-dessus, pour que vous les décommentiez si vous effectuez le build pour compose ; avec toute autre cible, elles ne sont pas écrites. La Release rattache l’origine de chaque emplacement, en nommant le même type ou aucun.
Avec le paramètre attach_egress_allowlist à true, l’instance de la plateforme déclare aussi la Feature core/egress-allowlist de la bibliothèque standard sous features, comme egress-allowlist, de sorte que la plateforme ne se connecte qu’aux composants qu’atteignent ses connexions, à ses propres pods et au DNS du cluster — la contrepartie sortante d’une arête uses comme appel déclaré. L’Aggregate déclare le type du rattachement et rien d’autre, puisque le rattachement d’un Aggregate ne porte aucun infra, et la Release produite en brouillon n’en écrit rien : le commentaire au-dessus de l’entrée de la plateforme nomme, sous features.egress-allowlist.infra, control_plane_present, que l’opérateur définit à true pour affirmer que le plugin réseau du cluster applique la politique réseau, sans quoi le build s’arrête ; admitted_destinations, une liste contenant, pour chaque connexion dont le cluster n’exécute pas la cible, comme un modèle hébergé, une entrée qui nomme la cible et une plage d’adresses, sans quoi le build s’arrête en nommant cette connexion ; et aggrega.ai/namespace pour la frontière qui contient la plateforme, puisque la politique est placée dans le namespace de ses charges de travail et que le build s’arrête là où elles ne sont émises dans aucun. Aucune de ces clés n’est écrite vide, si bien qu’aucune ne fait partie des valeurs que l’importation doit encore fournir. La décision de chaque partie reliée indique que le rattachement admet sa connexion, et l’importation rapporte le rattachement comme feature-attached. Compose n’a pas de politique réseau, si bien qu’un build compose d’un tel brouillon s’arrête en nommant le rattachement ; là où la plateforme accueille une connexion, les lignes compose ci-dessus sont écrites à l’intérieur du bloc features de l’instance, sans seconde clé features.
Le modèle que sert une partie
Une partie que le brouillon référence et dont le Component déclare une valeur nommée model — comme le fait, et l’exige, chaque Component de modèle de la bibliothèque standard — est écrite avec le nom du modèle que sélectionne son nœud, comme values.model :
- Langflow — le
model_named’un nœudOpenAIModelouAnthropicModel; lemodeld’un nœudOpenAIEmbeddings; et le remplacementmodel_named’un nœudLanguageModelComponentouEmbeddingModellà où il est défini, et sinon le modèle que sélectionne son champmodel. - Flowise — le
modelNamed’un nœudchatOpenAI,chatAnthropicouopenAIEmbeddings. - n8n — le paramètre
modeld’un nœud de chat, de complétion ou d’embeddings que met en correspondance la table de l’importateur, ou sonmodelNamesur les nœuds Google Gemini et Vertex, écrit comme un nom ou comme la valeur du sélecteur dans lequel les nœuds plus récents de n8n le conservent. n8n omet d’un export un paramètre défini à sa valeur par défaut, si bien qu’un nœud qui conserve le modèle par défaut n’en nomme aucun dans l’export.
Une Release ne peut pas écrire de valeur. Donc, là où le nœud ne nomme aucun modèle que le brouillon puisse écrire — il n’en sélectionne aucun, le nomme au moyen d’une variable globale ou d’une expression lue seulement lorsque le flux s’exécute, le prend d’un autre nœud qui lui est connecté, ou est d’un type dont l’importateur ne lit pas le champ de modèle — un commentaire à l’intérieur de la partie laisse values.model à l’auteur, et l’importation le rapporte avec model-not-named. Une partie que le brouillon produit en brouillon est écrite sans valeur.
Comment le flux est écrit dans le brouillon
Le flux est écrit comme un bloc littéral YAML dont le chomping conserve ses sauts de ligne finaux, de sorte que values.flow_definition se relit comme le texte propre du flux. Le texte d’un Aggregate est lu comme un template, si bien que chaque {{ que contient le flux — un chatflow Flowise écrit {{<node id>.data.instance}} pour chaque connexion entre deux nœuds — est écrit comme {{"{{"}}, que l’interpolation reconvertit en les deux accolades, comme le décrit Texte qui contient ses propres doubles accolades. Le nom d’un modèle est écrit de la même façon.
Un bloc littéral ne peut pas porter chaque caractère tel qu’il est écrit :
- Un retour chariot — d’une paire CR LF, ou isolé — est écrit comme un seul saut de ligne. Un document JSON n’en contient qu’entre ses jetons, où tout espace blanc se lit de la même façon, si bien que la plateforme lit le même flux. L’importation rapporte leur nombre avec
carriage-returns-rewritten. - Tout autre caractère qu’un bloc littéral ne peut pas porter empêche le flux d’être porté : un caractère de saut de ligne — U+0085, U+2028 ou U+2029 ; un caractère de contrôle autre que la tabulation et le saut de ligne — de U+0000 à U+001F, U+007F, et de U+0080 à U+009F ; les non-caractères U+FFFE et U+FFFF ; et un octet qui ne fait pas partie d’une séquence UTF-8.
values.flow_definitionest alors laissé non défini, avec un commentaire qui l’indique, le reste est produit en brouillon, et l’importation rapportedefinition-not-carriedpour chaque sorte de caractère, avec le nombre qu’en contient le flux et la ligne et la colonne du premier.
Le flux n’est pas porté non plus là où une valeur que le brouillon écrit vide ou à nouveau ne se trouve pas dans les octets de l’export à l’endroit où son arbre analysé la contient, et l’importation rapporte definition-not-carried en nommant l’emplacement de cette valeur. L’identifiant du flux est alors le sien là où le brouillon peut le porter, et sinon un identifiant dérivé des identifiants des nœuds du flux.
Nœud par nœud
Avec layout: nodes, une importation produit en brouillon chaque nœud du flux comme un Component propre, et écrit :
aggregate.yaml— un Aggregate en brouillon nommé d’après le flux, comme le décrit Comment un brouillon est nommé, composant les nœuds du flux : une entrée pour chacun, et chaque arête du flux comme une connexionusesdu nœud qu’elle alimente, son socket et son alias étant tous deux nommés d’après la clé du nœud qui l’alimente, si bien qu’un nœud alimenté par plusieurs nœuds donne à chaque connexion un alias propre.- un fichier sous
components/pour chaque nœud qu’elle produit en brouillon — un Component en brouillon nommé<target_namespace>/<category>/<name>, le nom étant tiré du type du nœud, à la version0.1.0, ses champs de valeur comme des champs de type chaîne d’un objetvaluesfermé et ses champs d’identifiants comme des emplacements d’identifiants requis dont une Recipe décide de la livraison. release.yaml— une Release en brouillon du même nom, qui nomme cet Aggregate, avec une entrée pour chaque nœud.
Le flux lui-même n’est pas porté, et la valeur d’aucun champ n’est lue.
Porter le flux exporté lui-même
Le brouillon par défaut porte le flux : l’instance de la plateforme prend l’export comme values.flow_definition, écrit comme le décrit Comment le flux est écrit dans le brouillon. Un auteur qui écrit un flux à la main dans un Aggregate — dans un brouillon disposé nœud par nœud, ou dans un Aggregate qui lui est propre — l’écrit de la même façon. Un Component qui exécute un flux tel qu’il a été rédigé prend l’export comme valeur — flow_definition sur core/ai-agent/langflow et core/ai-agent/flowise de la bibliothèque standard — et le texte d’un Aggregate est lu comme un template, si bien que les doubles accolades que contient l’export seraient lues comme des actions de template : un chatflow Flowise écrit {{<node id>.data.instance}} pour chaque connexion entre deux nœuds, un prompt Flowise nomme une variable {{question}}, et un export Langflow porte le code source de ses composants, où les accolades peuvent également apparaître. Écrivez chaque {{ de l’export comme {{"{{"}}, à l’intérieur d’un scalaire de bloc, et l’interpolation rétablit le texte de l’export avant que les Recipes du Component ne le lisent ; Texte qui contient ses propres doubles accolades explique pourquoi. Une valeur d’identifiants que contient l’export a sa place dans un secret que rattache la Release, et non dans l’Aggregate : écrivez-la vide, comme le fait le brouillon là où le paramètre empty_credentials le lui demande.
# Aggregate fragment — a Flowise chatflow carried as exportedspec: components: chat: type: core/ai-agent/flowise values: chatflow_id: 3f2b8c1e-7a4d-4e9b-8c2f-1a6d5e9b0c47 flow_definition: | { "nodes": [ { "id": "llmChain_0", "data": { "name": "llmChain", "inputs": { "model": "{{"{{"}}chatOpenAI_0.data.instance}}", "prompt": "{{"{{"}}promptTemplate_0.data.instance}}" } } } ], "edges": [] }L’importateur MCP
importer/mcp lit les serveurs MCP que liste la configuration d’un client MCP, ou l’unique serveur que décrit une description de serveur du registre MCP, et produit en brouillon chaque serveur comme une instance de l’outil MCP de la bibliothèque standard, core/ai-tool/mcp. Chaque serveur en est un, si bien que l’importateur n’évalue aucun candidat et ne rapporte aucune décision de mappage.
Ce qu’il lit
- La configuration d’un client. Le
.mcp.jsonde Claude Code, leclaude_desktop_config.jsonde Claude Desktop et le.cursor/mcp.jsonde Cursor listent leurs serveurs par nom sousmcpServers; le.vscode/mcp.jsonde Visual Studio Code les liste sousservers, et un fichier listant des serveurs sous les deux est lu d’abord sousmcpServers. Un serveur dont letypeeststdio, ou qui ne nomme aucuntypeet porte uncommand, est démarré à partir d’une ligne de commande — soncommandet sesargs— avec sonenvcomme environnement. Un serveur dont letypeesthttp,streamable-httpousse, ou qui ne nomme nitypenicommandet porte uneurl, est joint à sonurlet reçoit sesheaders. - Une description de serveur du registre. Le
server.jsonque publie le registre MCP : sonname, et son premier paquet ou, lorsqu’il n’en liste aucun, son premier point d’accès distant. Un paquet npm ou PyPI est démarré à partir de la ligne de commande que forment son lanceur — sonruntimeHint, ounpxpour npm etuvxpour PyPI —, sesruntimeArguments, le paquet avec sa version, écrit<identifier>@<version>pour npm et<identifier>==<version>pour PyPI, et sespackageArguments, avec sesenvironmentVariablescomme environnement. Un argument positionnel est sonvalue, ou sondefault; un argument nommé est écrit<name>=<value>lorsqu’il a l’un ou l’autre, et comme sonnamelorsqu’il n’a ni l’un ni l’autre. Un paquet OCI s’exécute à partir de l’image que nomme sonidentifier. Un point d’accès distant est joint à sonurlet reçoit sesheaders. Chaque autre paquet et point d’accès distant que liste la description est nommé dans un commentaire, puisqu’une instance n’en exécute qu’un.
Chaque autre membre d’un serveur — cwd, envFile, l’auth de Cursor, ou un membre que son type de serveur ne lit pas, comme l’url d’un serveur démarré à partir d’une ligne de commande — n’est écrit nulle part, et est nommé dans un commentaire au-dessus de l’entrée du serveur dans la Release, puisque aucune clé d’infrastructure de core/ai-tool/mcp ne le prend. Les inputs d’une configuration, qui décrivent ce que Visual Studio Code demande à l’utilisateur et ne contiennent aucune valeur, ne sont pas lus. Les serveurs, leur environnement et leurs en-têtes conservent l’ordre dans lequel la source les écrit, sauf dans une configuration lue comme du JSON avec commentaires, qui conserve l’ordre dans lequel les écrit son arbre analysé : l’ordre des noms (voir Une configuration contenant des commentaires).
Un répertoire est lu au travers des configurations client qu’il contient — chaque fichier nommé comme l’une des quatre, à n’importe quelle profondeur — dans l’ordre de leurs chemins, et chaque serveur de chaque fichier est produit en brouillon dans un seul Aggregate.
Ce que devient un serveur
aggregate.yaml est un Aggregate en brouillon nommé d’après la source, comme le décrit Comment un brouillon est nommé, contenant une instance de core/ai-tool/mcp par serveur. Une instance a pour clé le nom de son serveur, en minuscules, chaque suite de caractères autres que des lettres et des chiffres étant écrite comme un seul trait d’union, avec un suffixe numérique lorsqu’un serveur précédent a pris la clé. Lorsque la clé n’est pas le nom du serveur tel qu’il est écrit, ou que l’importation a lu plusieurs fichiers, un commentaire au-dessus de l’instance nomme le serveur et le fichier dont il provient. Aucun agent n’est produit en brouillon pour les utiliser.
À côté, release.yaml est une Release en brouillon du même nom, dont le spec.aggregate nomme l’Aggregate, portant pour chaque instance les entrées opérationnelles qu’indique la source :
- pour un serveur démarré à partir d’une ligne de commande,
infra.stdio_command, sa commande puis chaque argument, un élément chacun ; etinfra.stdio_runtime, l’écosystème du lanceur,npmlorsque la commande estnpx,npmounode,pypilorsqu’elle estuvx,uv,pythonoupython3et, pour un paquet du registre, son registre,npmoupypi; - pour un serveur joint à une adresse,
infra.endpoint: l’adresse sans sa partie utilisateur, sa requête et son fragment, puisque le Component prend l’adresse sans aucune partie portant une clé ; chaque partie qu’il omet est écrite dans le commentaire au-dessus de l’entrée, à côté de l’adresse, comme le décrit Valeurs d’identifiants que contient un serveur ; - pour un paquet OCI,
infra.image; - pour aucun serveur, sur aucune cible,
infra.published_port: le brouillon ne publie jamais un serveur sur l’hôte ; - pour l’environnement d’un serveur, l’emplacement
server_env, rattaché par référence selon la cible de l’importation. Sur--target helm, c’est uncore/referenced-secretqui nomme un Secret Kubernetes déjà présent dans le namespace et contenant une clé de données par variable, chacune nommée comme la variable qu’elle contient ; le nom du Secret est écrit vide, sous un commentaire qui nomme les clés de données, et il fait partie des valeurs que l’importation doit encore fournir. Sur toute autre cible, et sans cible, c’est uncore/referenced-secret-setavec une entrée sousinfra.entriespar variable, ayant pour clé le nom de la variable et pour valeur celle qu’écrit la source, si bien qu’une référence de variable telle que${GITHUB_TOKEN}reste une référence, qu’une cible substituant les références de variables lit dans l’environnement.
Ce que la source n’indique pas est écrit vide, sous un commentaire qui dit ce que c’est : une commande dont le lanceur ne figure dans aucune des deux images de pont laisse infra.stdio_runtime vide, et il fait partie des valeurs que l’importation doit encore fournir ; un argument qu’une description du registre laisse à son utilisateur est écrit comme un élément vide, et une variable dont la source n’écrit pas la valeur comme une entrée à valeur vide, chacun étant nommé dans le commentaire au-dessus de l’entrée.
Comme toute Release produite en brouillon, elle écrit metadata.environment comme development, sous un commentaire qui dit qu’il s’agit d’une valeur par défaut du brouillon à modifier, et, sans cible, spec.manifest comme une chaîne vide que l’importation doit encore fournir. Lorsqu’une cible est donnée, l’importateur produit lui-même le Manifest en brouillon, puisque le catalogue réalise core/ai-tool/mcp au moyen de plusieurs Recipes et que seul l’importateur sait comment s’exécute chaque serveur : il fait correspondre chaque serveur, par sa clé, sous mappings.components.name, à la réalisation de la cible pour la manière dont le serveur s’exécute — mcp-stdio-bridge pour une ligne de commande, mcp-remote pour une adresse, mcp pour une image, comme helm/mcp-stdio-bridge ou compose/mcp-remote — et le type de secret sous lequel l’environnement est rattaché à sa réalisation, helm/k8s-existing-secret sur helm et compose/dotenv-secret-set sur compose. L’importation complète ce Manifest et le nomme dans la Release, comme le décrit Ce qu’ajoute une cible.
Un .mcp.json de Claude Code listant un serveur joint via HTTP et un autre démarré avec npx :
{ "mcpServers": { "api-server": { "type": "http", "url": "https://api.example.com/mcp", "headers": { "Authorization": "Bearer ${API_KEY}" } }, "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}" } } }}est produit en brouillon ainsi :
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/mcp version: 0.1.0 description: Draft Aggregate imported from a source in the mcp format.spec: components: api-server: type: core/ai-tool/mcp github: type: core/ai-tool/mcpapiVersion: aggrega.ai/v1beta1kind: Releasemetadata: name: imported/mcp # 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 mcp format.spec: aggregate: imported/mcp # manifest: left empty, since the import was given no target; an import given a target drafts the Manifest and names it here. manifest: "" components: # The headers the source sends this server, which no infrastructure key of core/ai-tool/mcp takes, since a remote server's credential is held by each consumer, on its connection to the tool: # - Authorization: "Bearer ${API_KEY}" api-server: infra: endpoint: "https://api.example.com/mcp" github: infra: stdio_command: - "npx" - "-y" - "@modelcontextprotocol/server-github" stdio_runtime: npm features: server_env: type: core/referenced-secret-set infra: # Attached by reference wherever the source names a variable: the environment github is started with, one entry per variable, each written as the source writes it, so a variable reference stays one, which a target substituting variable references, as Docker Compose does when the stack starts, reads from the environment, and an empty value is one still owed. entries: - key: "GITHUB_PERSONAL_ACCESS_TOKEN" value: "${GITHUB_TOKEN}"Importée avec --target helm, la Release de la même configuration rattache l’environnement comme le Secret qu’elle nomme, et le Manifest que l’importateur produit en brouillon fait correspondre chaque serveur par sa clé :
# release.yaml, the github entry's environment features: server_env: 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 the environment github is started with, one data key per variable, each named as the variable it holds: GITHUB_PERSONAL_ACCESS_TOKEN. origin: ""apiVersion: aggrega.ai/v1beta1kind: Manifestmetadata: name: imported/mcp version: 0.1.0spec: mappings: components: type: {} name: api-server: helm/mcp-remote github: helm/mcp-stdio-bridge features: type: core/referenced-secret: helm/k8s-existing-secretValeurs d’identifiants que contient un serveur
Chaque valeur de la configuration d’un serveur qu’écrit la Release — la valeur de chaque en-tête, chaque élément de sa ligne de commande, son adresse, chaque partie de l’adresse qu’omet infra.endpoint et chaque valeur d’environnement — peut porter une clé, et aucun client n’en marque une comme identifiants, si bien que l’importation repère chacune comme un membre de la configuration d’un serveur MCP ; une entrée du registre marquée isSecret est repérée comme une valeur que son format marque comme identifiants. Une entrée du registre — une variable d’environnement ou l’en-tête d’un point d’accès distant — est lue comme son value, ou son default lorsqu’elle n’en écrit aucun. Par défaut, chacune est reportée telle qu’écrite dans la Release et nommée dans un avertissement credential-carried par son serveur et l’endroit où elle se trouve — headers.<header>, infra.stdio_command.<position>, infra.endpoint ou server_env.<variable>, et une partie de l’adresse par l’url dans laquelle elle est écrite et le nom de la partie, comme dans « url of node remote-search is carried with its query as written (l’url du nœud remote-search est reportée avec sa requête telle qu’écrite) » — jamais par sa valeur. Avec le paramètre empty_credentials à marked ou all, chacune est écrite vide et rapportée avec credential-emptied : un élément de la ligne de commande comme un élément vide et une valeur d’environnement comme une valeur vide, chacun étant nommé dans le commentaire au-dessus de l’entrée ; une adresse comme un infra.endpoint vide, que l’importation doit encore fournir ; et la valeur d’un en-tête ou une partie de l’adresse omise du commentaire, qui ne nomme alors que l’en-tête ou la partie. L’infra.stdio_runtime d’un client est lu sur la commande telle que l’écrit la Release, si bien qu’une commande écrite vide le laisse vide aussi, et l’importation doit encore le fournir. Sur --target helm, la Release n’écrit aucune valeur d’environnement : le Secret que nomme l’emplacement server_env les contient.
Une valeur qui est une référence de variable et rien d’autre — le nom nu ${NAME}, dont une variable prédéfinie telle que ${workspaceFolder}, ${env:NAME} ou ${input:id} — ne contient aucune valeur propre : elle est écrite comme le texte qu’elle est quoi que dise le paramètre, et n’est nommée dans aucun avertissement, comme une référence dans un flux. Une variable d’environnement dont la valeur est une telle référence est écrite comme valeur de l’entrée, la référence restant une référence, et un en-tête ou une partie de l’adresse dont la valeur est une telle référence est listé avec la référence dont il tire sa valeur. Une référence portant du texte après un opérateur — une valeur par défaut, une alternative, un message ou une affectation, comme ${NAME:-value} ou ${NAME-value}, avec ou sans deux-points — contient ce texte, et il en va de même du texte à côté d’une référence ; chacun est repéré comme toute autre valeur.
Aucune clé d’infrastructure de core/ai-tool/mcp ne prend la valeur d’un en-tête : les identifiants d’un serveur distant sont détenus par chaque consommateur, sur sa connexion à l’outil, et l’importation ne produit aucun consommateur en brouillon. Le commentaire au-dessus de l’entrée du serveur liste donc chaque en-tête que la source lui envoie, à côté de sa valeur telle qu’écrite — une chaîne entre guillemets doubles qui se relit exactement comme le texte de la source — pour que vous le déplaciez sur la connexion du consommateur qui le présente. Un en-tête dont la source n’écrit pas la valeur, comme une entrée d’en-tête du registre sans valeur ni valeur par défaut, est listé comme n’en ayant aucune. L’image que nomme un paquet OCI est écrite telle quelle, et n’est pas une valeur qu’atteint le paramètre.
infra.endpoint prend l’adresse sans aucune partie portant une clé, si bien que les parties de l’adresse qu’écrit la source et qu’il omet — la partie utilisateur avant le @, la requête après le ? et le fragment après le #, tout ce qui suit le premier # étant le fragment — sont listées dans le même commentaire, chacune à côté de son nom et telle qu’écrite, sans le @, le ? ou le # qui la sépare. Un consommateur lisant sa clé dans l’adresse fournit l’adresse entière sur sa propre connexion à l’outil. Un serveur joint à https://user:pw@api.example.com/mcp?key=k, sans aucun paramètre, est produit en brouillon ainsi :
# The address's user part and query are not written in infra.endpoint, which holds the address without any part that carries a key; a consumer reading its key from the address supplies the whole address on its own connection to the tool: # - user part: "user:pw" # - query: "key=k" api: infra: endpoint: "https://api.example.com/mcp"et avec empty_credentials à marked, infra.endpoint est laissé à la Release et le commentaire liste user part et query, chacune avec sa valeur omise.
Une configuration contenant des commentaires
Visual Studio Code lit .vscode/mcp.json comme du JSON avec commentaires, et l’importateur MCP aussi : sa signature pour ce fichier le lit au moyen du parseur qui sert parse:jsonc, si bien qu’une configuration contenant des commentaires // et /* */ et des virgules finales est reconnue sans qu’aucun format soit nommé, et l’importateur lit chaque source listant ses serveurs sous servers au moyen de ce parseur. Une telle configuration est produite en brouillon exactement comme la même configuration sans ses commentaires ni ses virgules finales. Le parseur écrit les membres d’un objet dans l’ordre des noms, si bien que les serveurs d’une telle configuration, leur environnement et leurs en-têtes sont produits en brouillon dans l’ordre des noms, qu’elle contienne ou non un commentaire ; une ligne de commande conserve son ordre. Les autres clients et le registre lisent leurs fichiers comme du JSON, et l’importateur aussi : un .mcp.json, claude_desktop_config.json, .cursor/mcp.json ou server.json contenant un commentaire n’est reconnu par aucune signature et, importé en nommant --format mcp, s’arrête sous parse-failed avec la raison du parseur. Un commentaire ouvert par /* et jamais fermé est laissé tel qu’écrit, et le parseur refuse le fichier.
Les paramètres qu’il lit
L’importateur MCP lit target_namespace et empty_credentials, tels que les décrit Paramètres, et aucun autre paramètre.
L’importateur Compose
importer/compose lit les services et les modèles que déclare un fichier Compose. Il produit en brouillon chaque service comme une instance du Component du catalogue auquel correspond son image, ou du serveur générique de la bibliothèque standard, core/compute/server, exécutant son image ; chaque modèle comme une instance de l’environnement d’exécution Docker Model Runner de la bibliothèque standard, core/ai-model/docker-model-runner, lorsque votre catalogue le contient, et comme un Component de modèle propre lorsqu’il ne le contient pas ; et, à côté d’eux, une Release portant ce que chaque service indique pour son fonctionnement.
Ce qu’il lit
- Les fichiers. Un fichier importé seul est lu seul. Un répertoire est lu comme Compose en lit un : dans chaque répertoire contenant des fichiers Compose, dans l’ordre des chemins des répertoires, le premier présent parmi
compose.yaml,compose.yml,docker-compose.ymletdocker-compose.yamlest le fichier Compose, et le premier présent parmicompose.override.yml,compose.override.yaml,docker-compose.override.ymletdocker-compose.override.yamlest fusionné par-dessus. Aucun autre de ces fichiers n’est lu. Dans un répertoire contenant des fichiers de remplacement et aucun fichier Compose, son premier fichier de remplacement est lu seul. Un commentaire en tête de l’Aggregate en brouillon nomme les fichiers lus, dans l’ordre dans lequel ils sont fusionnés, et les fichiers non lus. Chaque service et chaque modèle de chaque répertoire est produit en brouillon dans un seul Aggregate. - La fusion. Un fichier de remplacement est fusionné comme Compose en fusionne un :
imageest remplacé ; lesportssont fusionnés selon leur adresse, leur port publié, leur port de conteneur et leur protocole, lesvolumesselon leur chemin dans le conteneur, etenvironmentselon le nom de variable, une entrée ultérieure prenant la place d’une entrée antérieure et une nouvelle venant à la suite ;exposeest ajouté à la fin ;depends_onet lesmodelsd’un service sont réunis,endpoint_varetmodel_vard’une entrée prenant chacun la place de celui qu’indique un fichier antérieur. D’un modèle,modeletcontext_sizesont remplacés etruntime_flagsest ajouté à la fin. Les balises!resetet!overridede Compose ne sont pas prises en compte : une valeur qui en porte une est fusionnée telle que la lit le parseur YAML. - Un service. Son
image, et s’il en construit une sousbuild; sesports,expose,volumesetenvironment— un mapping, ou une liste d’élémentsNAME=value, un nom sans valeur prenant sa valeur dans l’environnement dans lequel s’exécute Compose ;depends_on, une liste ou un mapping ; et sesmodels, une liste de noms de modèles ou un mapping dont les entrées peuvent nommer, sousendpoint_varetmodel_var, les variables sous lesquelles l’adresse et l’identifiant du modèle parviennent au service. Tout autre membre —command,healthcheck,secrets,env_fileet le reste — n’est écrit nulle part, et est nommé dans un commentaire au-dessus de l’entrée du service dans la Release. - Un modèle. Chaque entrée des
modelsde premier niveau : sonmodel, l’identifiant OCI du modèle, soncontext_sizeet sesruntime_flags, reportés tels qu’écrits dans une instance decore/ai-model/docker-model-runnerlorsque votre catalogue le contient, et d’un Component de modèle produit en brouillon pour lui lorsqu’il ne le contient pas ; la décision du modèle indique lequel, et pourquoi. Tout autre membre est nommé dans un commentaire au-dessus de son instance. - Le reste. Les autres membres de premier niveau —
name,networks,volumes,secrets,configs— ne sont pas lus, et le commentaire en tête de l’Aggregate les nomme.
Les services, les modèles et l’environnement d’un service conservent l’ordre dans lequel le fichier les écrit. L’arbre du parseur écrit les membres d’un mapping dans un ordre trié, si bien que cet ordre est lu dans le texte du fichier, là où ils sont écrits sous forme de mapping en bloc ; un mapping écrit en style flow conserve l’ordre trié.
Quel Component est un service
L’importateur fait correspondre un service par le dépôt que nomme son image : la référence sans son tag ni son digest, une référence Docker Hub étant écrite sous sa forme courte — postgres pour docker.io/library/postgres:16. Il fait correspondre le dépôt au moyen de sa table d’images, une table allant du dépôt d’une image au Component du catalogue pour lequel une Recipe Compose du catalogue standard exécute une image de ce dépôt. La table est générée à partir des Recipes Compose et des Components du catalogue standard lorsque l’importateur est construit, et compilée dans celui-ci, si bien qu’aucune Recipe n’est lue lorsqu’une importation s’exécute et que la table contient les labels du catalogue standard, quoi que contienne votre catalogue ; l’entité Plugin de l’importateur nomme, dans sa description, la révision du hub à partir de laquelle la table a été générée. De chaque Recipe, la table lit le Component qu’implémente la Recipe et l’image de son conteneur nommé main, lorsque cette image écrit son dépôt dans son propre texte, ou est une entrée de locals qui le fait. Une Recipe exécutant l’image que la Release nomme en entier, ou une image que son template compose autrement, n’ajoute aucune ligne, et une image qu’une Recipe exécute à côté de son conteneur principal non plus. Deux Recipes nommant un même dépôt pour des Components différents empêchent la génération de la table, si bien qu’une ligne ne nomme jamais l’un de deux. Du Component que nomme une ligne, la table lit les labels tels qu’ils sont remis à une importation — à la version vers laquelle se résout une référence nommant le Component sans version, avec ceux qu’il hérite au moyen de extends — et écrit chaque label sauf component.aggrega.ai/category dans la ligne comme ses traits. Une Recipe implémentant un Component que le catalogue standard ne contient pas empêche aussi la génération de la table.
Une ligne est lue comme l’est une ligne de la table d’un importateur de flux : le Component, la catégorie dans laquelle le place son nom, ses traits, et le dernier segment de son nom comme son éditeur. Le paramètre mapping_overrides se superpose à la table sous le format compose, avec le dépôt pour clé, et une entrée pour un dépôt que la table met en correspondance prend la place de la ligne. Ainsi, une image que ne nomment pas les Recipes du catalogue standard — la vôtre, ou une image qu’un Component du catalogue exécute sous un autre dépôt — est mise en correspondance par une entrée :
with: settings: mapping_overrides: compose: bitnami/redis: component: core/datastore/redis category: datastore traits: datastore.aggrega.ai/engine: kv vendor: redisUn service dont une ligne met l’image en correspondance est décidé comme les importateurs de flux décident d’un nœud : évalué par rapport aux Components de votre catalogue, référencé lorsque reuse_mode vaut auto-apply-above-threshold, la valeur par défaut, et que son meilleur candidat est une correspondance de niveau élevé égale ou supérieure à reuse_threshold, et produit en brouillon comme un Component propre sinon, le fichier du Component produit en brouillon s’ouvrant sur un commentaire qui nomme le Component auquel il ressemble. Une ligne porte les labels du Component qu’elle nomme, si bien que, lorsque votre catalogue contient ce Component avec les labels que lui donne le catalogue standard, un service que la ligne met en correspondance est pour lui une correspondance de niveau élevé, avec un score de 0.90, et auto-apply-above-threshold le référence au reuse_threshold par défaut. Un Component dont votre catalogue a modifié les labels obtient un score inférieur, en proportion de la part des traits de la ligne qu’il ne porte plus, et n’est référencé que tant qu’il reste au niveau élevé ; la catégorie est évaluée une seule fois, dans son propre signal, et non de nouveau comme un trait. Les services produisant en brouillon un même Component en partagent l’unique fichier. Un service dont aucune ligne ne met l’image en correspondance, dont l’image ne nomme aucun dépôt que lit l’importateur, ou qui construit son image, est une instance de core/compute/server, quoi que contienne votre catalogue. La décision de chaque service est rapportée comme l’est celle de chaque nœud.
Ce que devient un service
aggregate.yaml est un Aggregate en brouillon nommé d’après le projet, comme le décrit Comment un brouillon est nommé, contenant une instance par service, du Component qu’a choisi sa décision, avec pour clé celle que l’importateur MCP donne à un serveur, et un commentaire au-dessus d’elle qui nomme le service et le fichier dont il provient lorsque la clé n’est pas le nom du service ou que l’importation a lu plusieurs répertoires. Chaque service que nomme le depends_on d’un service est une connexion, uses: <key>: <key>: {target: <key>}, écrite sous un socket et un alias tous deux nommés d’après la clé de la cible. Un composant lit chacune de ses connexions par son alias, quel que soit le socket auquel elle est reliée, si bien que chaque connexion d’un service a son propre alias. Une variable de l’environnement d’un service peut elle aussi donner lieu à une connexion, qui fournit la variable à partir de ce que publie le service qu’elle atteint, comme le décrit Ce que deviennent l’environnement et l’image d’un service. Chaque modèle est une instance de core/ai-model/docker-model-runner lorsque le catalogue de l’espace de travail le contient, quoi que dise reuse_mode, et aucun Component n’est produit en brouillon pour lui : l’instance écrit model et runtime_flags tels que la source les indique, et le context_size de la source comme context_window, la valeur que l’environnement d’exécution déclare pour la longueur de contexte d’un modèle, que sa Recipe Compose réécrit comme le context_size de Compose. Lorsque le catalogue ne contient aucun core/ai-model/docker-model-runner, le modèle est produit en brouillon comme <target_namespace>/ai-model/<key>, un Component de la catégorie ai-model dont les valeurs déclarent model, context_size et runtime_flags, et son instance écrit chacun de ceux qu’indique la source. Chaque modèle a une décision indiquant lequel — mapped llm (model) to core/ai-model/docker-model-runner as a reference, NONE, ou un brouillon dont la décision enregistre que le catalogue de l’espace de travail ne contient aucun core/ai-model/docker-model-runner — et chaque service nommant le modèle lui est relié dans les deux cas, comme à un service dont il dépend. Un service nommant le modèle sous la forme longue, avec endpoint_var ou model_var, nomme les variables sous lesquelles son adresse et son identifiant parviennent au service. Aucune clé du brouillon ne contient le nom d’une variable — la connexion est écrite sur un socket nommé d’après le modèle, qui ne déclare aucune valeur, et aucune clé d’infrastructure d’un Component n’est remise à un importateur — si bien qu’un commentaire au-dessus de la connexion nomme chacune, telle que l’écrit l’entrée, et que la décision du service enregistre la même phrase :
search: type: core/compute/server uses: # The service search reads the address of the model embedder as AI_MODEL_URL and its identifier as AI_MODEL_NAME, the names its models entry gives them; no key of the draft holds either name. embedder: embedder: target: embedderUn service nommant le modèle sous la forme courte, ou sans aucune des deux variables, lui est relié sans commentaire.
À côté, release.yaml est une Release en brouillon du même nom, dont le spec.aggregate nomme l’Aggregate. Pour une instance de core/compute/server, elle écrit infra.image, l’image telle qu’écrite, et infra.port, le port sur lequel le conteneur écoute dans la première entrée de ports, ou de expose lorsque ports n’en contient aucune. Avec --target compose, elle écrit aussi infra.published_port, le port hôte que publie cette même entrée de ports, tel que l’indique la source, sous le commentaire indiquant qu’il n’est joignable que depuis cette machine, par tout processus qui s’y exécute, et que supprimer la ligne garde le service interne ; un port hôte inférieur à 1024, que published_port ne prend pas, n’est pas écrit, et un commentaire au-dessus de l’entrée le nomme. Un commentaire au-dessus de l’entrée de chaque service écrit ce qu’indique la source et que ne porte aucune clé du brouillon — l’image d’un service mis en correspondance avec un autre Component dont le brouillon ne traduit pas le tag, ses ports, expose, volumes, et chaque variable de son environment que le brouillon ne traduit pas — pour que vous le reportiez là où le Component le prend. Ce que le brouillon laisse à la Release — l’image d’un service qui n’en nomme aucune, comme le fait un service qui construit la sienne, et un port qui n’est pas un nombre unique — est écrit vide sous un commentaire qui en indique la raison. Un build ne place que les instances que nomme une Release, si bien que l’instance de chaque modèle a une entrée vide, <key>: {}, après celles des services : aussi bien une instance de core/ai-model/docker-model-runner, qui ne prend sur Compose aucune entrée dépourvue de valeur par défaut, qu’un modèle produit en brouillon comme un Component propre ; le modèle produit en brouillon est donc déjà placé, et le build aboutit dès que vous écrivez la Recipe qui le réalise. Un port que le Component ne prend pas, comme un port inférieur au plancher de 1024 de core/compute/server, est écrit tel que l’indique la source, et le build s’arrête en le nommant. La Release écrit metadata.environment et, sans cible, un spec.manifest vide, comme celle de l’importateur MCP ; avec une cible, l’importation produit en brouillon le Manifest, comme le décrit Ce qu’ajoute une cible, en associant chaque Component à la Recipe qui le réalise sur cette cible — core/compute/server à compose/server ou helm/server, et core/ai-model/docker-model-runner à compose/docker-model-runner ou helm/docker-model-runner.
Un compose.yaml exécutant PostgreSQL et une API propre qui en dépend :
services: db: image: postgres:16 environment: POSTGRES_DB: shop api: image: ghcr.io/example/shop-api:1.4.2 depends_on: - db ports: - "8080:8080" environment: CACHE_URL: redis://cache:6379/0est produit en brouillon, sans aucun paramètre, sur un catalogue contenant le core/datastore/postgres de la bibliothèque standard, importé seul et nommé d’après le fichier puisque le projet ne porte aucun name, ainsi :
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/compose version: 0.1.0 description: Draft Aggregate imported from a source in the compose format.spec: components: db: type: core/datastore/postgres # The values of core/datastore/postgres the source sets as POSTGRES_DB, the variables its Compose Recipes set from them. values: database: "shop" api: type: core/compute/server uses: db: db: target: dbapiVersion: aggrega.ai/v1beta1kind: Releasemetadata: name: imported/compose # 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 compose format.spec: aggregate: imported/compose # manifest: left empty, since the import was given no target; an import given a target drafts the Manifest and names it here. manifest: "" components: db: infra: # The tag of the image the source runs, postgres:16, the engine_version of core/datastore/postgres its Compose Recipes run. engine_version: "16" # The source also states, for the Release to carry where core/compute/server takes it: # ports: # - "8080:8080" # environment: # CACHE_URL: "redis://cache:6379/0" api: infra: image: "ghcr.io/example/shop-api:1.4.2" port: 8080L’importation rapporte mapped db (postgres) to core/datastore/postgres as a reference, HIGH at 0.9. Le projet ne contient aucun service cache, si bien que CACHE_URL ne donne lieu à aucune connexion et reste dans le commentaire. Avec reuse_mode: hints-only, db est à la place type: imported/datastore/postgres, produit en brouillon dans components/imported-datastore-postgres.yaml, qui commence par # resembles core/datastore/postgres (score 0.9000); reference it by setting type: core/datastore/postgres ; son image et son environnement sont alors écrits dans le commentaire au-dessus de son entrée, puisqu’un Component produit en brouillon ne déclare aucune des valeurs que lisent les Recipes du catalogue. Avec --target compose, le Manifest associe core/datastore/postgres à compose/postgres et core/compute/server à compose/server ; avec --target helm, à helm/postgres et helm/server.
Ce que deviennent l’environnement et l’image d’un service
Lorsqu’un service est une instance du Component du catalogue que nomme la ligne de son image, et que le catalogue de l’espace de travail contient ce Component, l’importateur lit son image et son environnement comme les lisent les Recipes Compose du catalogue standard pour ce Component, à partir de ce que la table des images enregistre de chaque Recipe, et les traduit dans les brouillons :
- Le tag de l’image est la clé d’infrastructure à partir de laquelle la Recipe construit la référence de l’image, comme
engine_version—16pourpostgres:16— écrite dans la Release sous un commentaire qui nomme l’image de la source. - Une variable que la Recipe définit à partir de l’une des valeurs du Component —
POSTGRES_DB,POSTGRES_USER— et dont la valeur contient du texte est cette valeur de l’instance,databaseouuser, lorsque le Component du catalogue la déclare, écrite dans l’Aggregate sous un commentaire qui nomme les variables. - Une variable dans laquelle la Recipe lit un mot de passe, comme
POSTGRES_PASSWORD, et dont la valeur est une seule référence de variable, est un secret attaché sur cet emplacement, lu depuis la variable que nomme la référence et déclaré avec la clé sous laquelle la Recipe le lit.
Et, pour chaque service, chaque variable de son environnement qui n’est pas lue ainsi :
- Une valeur qui est le nom d’un autre service du projet, lorsque la ligne de ce service nomme la clé
providesqui publie son nom d’hôte, donne lieu à une connexion vers ce service, dont le blocinjectfournit la variable à partir de cette clé —CACHE_HOST: cacheestCACHE_HOSTà partir duhostdu cache. - Une valeur égale à une valeur qu’un autre service définit pour son Component et que le Component publie —
DATABASE_USER: notesà côté d’un service PostgreSQL qui définitPOSTGRES_USER: notes— donne lieu à une connexion qui fournit la variable à partir de cette cléprovides. Lorsque plusieurs services ou clés contiennent la valeur, celui ou celle dont la clé, ou dont la variable propre, se termine comme se termine le nom de la variable est lu, et, à défaut, celui à partir duquel les autres variables du service n’ont pas déjà été lues ; sinon, la variable n’est pas lue. - Une valeur qui est une seule référence de variable nommant une variable dans laquelle est lu le secret d’un autre service —
DATABASE_PASSWORD: ${POSTGRES_PASSWORD}— est, sur une instance decore/compute/server, un secret propre, attaché sous le nom de la variable en minuscules et lu depuis la même variable, lorsque la cible écrit le secret comme une valeur que le serveur prend.helm/serverrefuse uncore/referenced-secret, si bien qu’avec--target helmune telle variable reste dans le commentaire.
Toute autre variable est laissée dans le commentaire au-dessus de l’entrée du service, telle que l’écrit la source. Le guide pas à pas de l’importation Compose montre un projet dont l’API atteint sa base de données et son cache de cette manière, construit et exécuté tel que produit en brouillon.
Valeurs d’identifiants que contient un service
Compose ne marque aucune valeur d’environnement comme identifiants, et l’importateur ne lit le nom d’aucune variable pour ce qu’il signifie, si bien que chaque valeur d’environnement qui contient quelque chose est repérée comme une entrée que son format ne marque pas comme identifiants mais qui peut en porter. Par défaut, chacune est reportée telle qu’écrite dans les brouillons — dans la valeur en laquelle elle est traduite, ou dans le commentaire au-dessus de l’entrée de son service dans la Release — et nommée dans un avertissement credential-carried par son service et sa variable — environment.<variable> — jamais par sa valeur. Avec le paramètre empty_credentials à all, chacune est écrite vide et rapportée avec credential-emptied : le commentaire nomme sa variable sans valeur. À marked, aucune n’est écrite vide, puisque Compose n’en marque aucune. Une valeur qui est une référence de variable qu’interpole Compose et rien d’autre — ${NAME} ou $NAME — ne contient aucune valeur propre : elle est écrite comme le texte qu’elle est, et n’est nommée dans aucun avertissement. Une référence portant une valeur par défaut ou un message, comme ${NAME:-value}, contient ce texte, et est repérée comme toute autre valeur. Une valeur que Compose lit ailleurs — un env_file, le fichier d’un secret — n’est pas lue.
Les paramètres qu’il lit
L’importateur Compose lit target_namespace, reuse_mode, reuse_threshold, emit_hints, render_mode, mapping_overrides et empty_credentials, tels que les décrit Paramètres, et aucun autre paramètre. La suggestion que régit emit_hints est écrite dans le seul fichier du Component produit en brouillon ; l’Aggregate en brouillon n’en porte aucune.
L’importateur Dify
importer/dify lit une application exportée de Dify dans son DSL, le document YAML que Dify écrit pour une application, et produit en brouillon un Aggregate composant l’installation Dify de la bibliothèque standard, core/dify, l’application étant reportée dans le paramètre app_definition de l’installation. L’installation l’importe au déploiement, au moyen de l’étape que la Recipe de son serveur d’API rend pour elle.
Ce qu’il lit
- L’application.
kind, qui vautapp;version, la version du DSL dans laquelle l’application est écrite ; etapp, avec sonmode. - Un workflow ou un chatflow —
modeworkflowouadvanced-chat— garde son graphe sousworkflow: chaque nœud deworkflow.graph.nodesqui nomme son type sousdata.typeest un nœud de l’application, dans l’ordre où le graphe les liste, etworkflow.environment_variablescontient les variables qu’il lit. - Une application chat, agent chat ou completion garde sa configuration sous
model_config: sonmodel, chaque base de connaissances sousdataset_configs.datasets.datasetset chaque outil sousagent_mode.toolsest un nœud de l’application, nommé d’après sa place à cet endroit, commemodel_config.model. Une application du modeagentest un seul nœud,agent. - Les plugins dont elle a besoin. Chaque entrée de
dependenciesest aussi un nœud, nommédependencies.<n>, du type que nomme l’entrée, commemarketplace.
Rien d’autre ne décide de ce qui est produit en brouillon : l’application entière est reportée.
Ce que devient une application
aggregate.yaml est un Aggregate en brouillon nommé d’après l’application, comme le décrit Comment un brouillon est nommé, composant une entrée de core/dify, de clé dify, dont le paramètre app_definition porte l’application telle qu’écrite — comme le décrit Comment le flux est écrit dans le brouillon pour un flux, si bien que les références {{#…#}} propres à Dify atteignent l’installation telles qu’exportées. L’installation relie elle-même chaque connexion de son serveur d’API — sa base de données, son cache, son magasin vectoriel, sa sandbox, son environnement d’exécution des plugins et son proxy de sortie — si bien que le brouillon ne produit aucun Component en brouillon et ne relie rien : chaque nœud reste dans l’application, et sa décision le dit. À côté, release.yaml est une Release en brouillon du même nom, qui place l’installation dans une frontière, platform, et porte ce que l’application ne peut pas fournir.
Une importation voit les Components du catalogue du workspace et aucun de ses Aggregates, si bien qu’elle ne vérifie pas que le catalogue contient core/dify, et un commentaire au-dessus de l’entrée le dit. Lorsque le catalogue ne contient aucun core/ai-agent/dify, le serveur d’API qu’exécute core/dify, l’importation avertit avec platform-not-in-catalog et produit tout de même l’entrée en brouillon.
Le secret applicatif de l’installation, la clé avec laquelle Dify signe ses cookies de session et sous laquelle il chiffre les informations d’identification des fournisseurs de modèles qu’il stocke, est le paramètre secret_key de core/dify, qui n’a pas de valeur par défaut. Le brouillon déclare donc son propre paramètre secret_key — une chaîne, obligatoire, d’au moins un caractère et sans valeur par défaut — et le transmet à chaque entrée core/dify qu’il écrit, pour que la Release le renseigne sous ses parameters ; un build dont la Release le laisse non défini s’arrête en le nommant.
L’application est importée sous le compte propriétaire de l’installation, que la Release nomme dans son entrée de routage pour l’installation : infra.owner_email sur le composant api de l’installation, et l’emplacement owner_password sur ce composant, rattaché en tant que core/referenced-secret, sans lesquels le build s’arrête. L’adresse e-mail du propriétaire n’est à fournir par aucune source, elle est donc écrite vide sous un commentaire indiquant ce qu’elle est, et l’importation la signale comme due.
Sur chaque cible, la même entrée de routage définit infra.marketplace_enabled à true sur les composants api, worker et scheduler de l’installation, chacun sous un commentaire indiquant pourquoi : l’installation n’atteint rien de l’éditeur de Dify à moins que la Release ne l’autorise, chacun des trois lit son propre paramètre, et Dify installe le plugin servant le modèle d’une application, comme celui d’OpenAI, depuis sa place de marché de plugins.
Le secret applicatif et le mot de passe du propriétaire sont des secrets, produits en brouillon par référence pour la cible de l’importation :
- Avec
--target helm, chacun nomme un Secret Kubernetes déjà présent dans le namespace :secret_keyle nom du Secret, quecore/difylit sous la clé de donnéessecret-key, etowner_passwordun Secret contenant le mot de passe sous la clé de donnéesvalue. Aucun de ces noms n’est à fournir par une source, chacun est donc écrit vide sous un commentaire indiquant ce qu’il est, et l’importation les signale tous deux comme dus ; le Manifest produit en brouillon mappecore/referenced-secretsurhelm/k8s-existing-secret. - Sur toute autre cible, et sans cible, chacun est une référence à une variable —
secret_keysous la forme"${DIFY_SECRET_KEY}"et le mot de passe du propriétaire sous la forme"${DIFY_OWNER_PASSWORD}", les noms que lisent les Recipes Dify pour Compose du catalogue standard — que Docker Compose lit depuis l’environnement au démarrage de la stack, si bien que rien n’est dû pour l’un ni pour l’autre ; avec--target compose, le Manifest produit en brouillon mappecore/referenced-secretsurcompose/dotenv-referenced-secret.
Lorsqu’une cible est donnée, le Manifest mappe le type de chaque composant que compose l’installation ainsi que celui du brouillon lui-même, comme le décrit Ce qu’ajoute une cible.
L’application workflow rédigée à la main qu’importent les tests de cet importateur, nommée Support Answers, est produite en brouillon, sans aucun paramètre, ainsi :
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/support-answers version: 0.1.0 description: Draft Aggregate imported from a source in the dify format.spec: parameters: secret_key: type: string required: true minLength: 1 description: "Passed down to core/dify's secret_key parameter, which has no default; that parameter's description in core/dify says what the value is." aggregates: # An import sees the Components of the workspace's catalog and none of its Aggregates, so it does not check that the catalog holds core/dify. dify: type: core/dify parameters: secret_key: "{{ .parameters.secret_key }}" app_definition: | app: description: Answers a support question from a knowledge base and files it. ...Importée avec --target helm, sa Release produite en brouillon renseigne secret_key, et nomme le propriétaire et active la place de marché de plugins dans l’entrée de routage plaçant l’installation, chaque valeur due étant écrite vide :
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: name: imported/support-answers # 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 dify format.spec: aggregate: imported/support-answers manifest: imported/support-answers parameters: # Left for the Release, since the source cannot supply it: secret_key, which the drafted Aggregate declares and passes down to core/dify; that parameter's description there says what the value is secret_key: "" boundaries: platform: aggregates: dify: components: api: infra: # Lets the installation reach Dify's plugin marketplace, which the plugin serving the application's model, such as OpenAI's, is installed from. marketplace_enabled: true # Left for the Release, since the source cannot supply it: components.api.infra.owner_email, the email of the installation's owner account the application is imported under, on the api component of core/dify owner_email: "" features: owner_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 owner account's password. origin: "" worker: infra: # Lets the installation reach Dify's plugin marketplace, which the plugin serving the application's model, such as OpenAI's, is installed from. marketplace_enabled: true scheduler: infra: # Lets the installation reach Dify's plugin marketplace, which the plugin serving the application's model, such as OpenAI's, is installed from. marketplace_enabled: trueL’importation signale comme dues les trois valeurs vides. Importée avec --target compose, la même Release écrit secret_key: "${DIFY_SECRET_KEY}" et origin: "${DIFY_OWNER_PASSWORD}", et ne signale comme due que l’adresse e-mail du propriétaire ; elle écrit aussi infra.published_port sur le composant api, 5001, et sur le front-end, le composant console, 3001, chacun sous le commentaire indiquant qu’il n’est joignable que depuis cette machine, par tout processus qui s’y exécute, et que supprimer la ligne garde le service interne, et, sous le port du composant api, infra.console_url avec l’adresse à laquelle la console est publiée, "http://127.0.0.1:3001", que le serveur Dify prend comme adresse de la console. Le guide pas à pas de l’importation Dify construit une application pour les deux cibles et l’exécute sur Kubernetes.
Ce que Dify configure lui-même
Dify configure en son sein les fournisseurs des modèles et des outils qu’appelle une application, et core/ai-agent/dify ne déclare aucun socket pour un modèle, si bien que le brouillon n’en relie aucun. Chaque nœud qui en nomme un est rapporté avec part-configured-in-platform, et dans sa décision, d’après ce qu’il nomme :
- un nœud
llm,question-classifierouparameter-extractor, et lemodel_config.modeld’une application chat : le modèle, par son nom et son fournisseur ; - un nœud
tool, et l’outil d’une application chat : l’outil, par son nom et son fournisseur ; - un nœud
agent: la stratégie d’agent et le plugin qui la fournit ; - un nœud
knowledge-retrieval, et la base de connaissances d’une application chat : les bases de connaissances dans lesquelles il effectue la récupération, et le modèle avec lequel il route une requête ou effectue le reclassement, lorsqu’il en nomme un. Une application nomme une base de connaissances par un identifiant de l’installation dont elle a été exportée, et ne porte aucun de ses documents ni aucun magasin, si bien que chacune est créée dans Dify, dans le magasin vectoriel que l’installation relie à son serveur d’API ; - une dépendance : le plugin, par l’identifiant sous lequel Dify l’installe, et l’endroit d’où Dify l’installe.
Tout autre nœud est conservé dans l’application sans que rien ne soit rapporté.
Valeurs d’identifiants que contient une application
L’importateur repère, dans l’ordre où l’application les écrit :
- la valeur de chaque variable d’environnement dont le
value_typeestsecret, que Dify marque comme identifiants. L’export de Dify l’écrit vide sauf si l’export inclut les secrets ; - l’
authorization.config.api_keyd’un nœud de requête HTTP, que Dify marque comme identifiants et exporte tel qu’écrit ; - les identifiants stockés qu’un nœud
tool, ou un outil d’un nœudagent, sélectionne souscredential_id, que Dify marque comme identifiants et n’écrit que lorsque l’export inclut les secrets ; - les
headersetparamsd’un nœud de requête HTTP, que Dify ne marque pas comme identifiants et qui peuvent en porter, chacun en entier.
Par défaut, chacune contenant une valeur est reportée telle qu’écrite dans l’application et nommée dans un avertissement credential-carried par son nœud — workflow pour une variable d’environnement — et son champ, jamais par sa valeur. Avec le paramètre empty_credentials à marked, chaque valeur que Dify marque comme identifiants est écrite vide, et à all les en-têtes et les paramètres de requête aussi, chacune rapportée avec credential-emptied. Une valeur qui est une référence de variable et rien d’autre n’en contient aucune, et est reportée telle qu’écrite quoi que dise le paramètre, sans être nommée dans aucun avertissement, comme dans un flux. Une valeur est écrite vide dans le texte même de l’application : le scalaire qui suit sa clé est remplacé par '', et rien d’autre n’est modifié. L’application n’est reportée que lorsque le parseur qui sert parse:yaml relit le résultat comme l’application exportée avec exactement ces valeurs vidées ; sinon elle n’est pas reportée, app_definition est laissé non défini avec un commentaire, et definition-not-carried dit pourquoi — comme pour une application dans laquelle un alias YAML lit la valeur d’un secret, que l’écriture à vide de cette valeur modifierait aussi. Une valeur que le paramètre laisse telle qu’écrite n’est jamais réécrite, si bien qu’elle n’empêche jamais l’application d’être reportée.
La version du DSL
Lorsqu’une application est écrite dans une version du DSL plus récente que 0.7.0, la version qu’écrit Dify 1.17.0 — la version que core/ai-agent/dify exécute par défaut —, l’importation avertit avec dsl-version-newer. Dify retient l’importation d’une telle application en attente d’une confirmation, que donne l’étape qui l’importe au déploiement, alors vérifiez l’application par rapport à la version de Dify qu’exécute la Release.
Les paramètres qu’il lit
L’importateur Dify lit target_namespace, empty_credentials, layout, attach_egress_allowlist et render_mode, tels que les décrit Paramètres, ainsi que reuse_mode, reuse_threshold, emit_hints et mapping_overrides, qui ne changent rien à ce que produit en brouillon la disposition par défaut : chaque nœud reste dans l’application. attach_egress_allowlist ne rattache rien, puisqu’une entrée d’un Aggregate composé prend des paramètres et aucune Feature, et lorsqu’il vaut true l’importation avertit avec feature-not-attached. layout: nodes produit en brouillon chaque nœud comme un Component à part entière, comme le décrit Nœud par nœud, et ne reporte aucune application.
L’importateur CrewAI
importer/crewai lit les agents et les tâches qu’un projet CrewAI déclare dans ses fichiers de configuration, et produit en brouillon un Aggregate contenant une instance de l’agent CrewAI de la bibliothèque standard, core/ai-agent/crewai, par agent, chacune reliée au modèle que nomme sa configuration, ainsi qu’une Release à côté.
Ce qu’il lit
CrewAI garde le comportement d’une crew dans un programme et déclare ses agents et ses tâches dans des fichiers de configuration, selon l’une de deux organisations, et l’importateur lit l’une comme l’autre :
- Un projet classique —
config/agents.yaml, chaque agent ayant pour clé son nom, etconfig/tasks.yaml, chaque tâche ayant pour clé son nom, tous deux lus comme du YAML. Les agents sont lus dans l’ordre oùagents.yamlles écrit. - Un projet dans l’organisation JSON-first —
crew.jsonc, qui liste les agents de la crew par nom sousagentset ses tâches soustasks, etagents/<name>.jsonc, un fichier par agent, tous lus comme du JSON avec commentaires, si bien que leurs commentaires et leurs virgules finales sont lus comme CrewAI les lit. Les agents sont lus dans l’ordre oùcrew.jsoncles liste, suivis du fichier de tout autre agent dans l’ordre des noms ; un agent que liste la crew et dont le fichier n’a pas été remis à l’importation est nommé dans un commentaire, et rien n’est produit en brouillon pour lui. La même organisation écrite en JSON strict —crew.jsonetagents/<name>.json— est lue de la même manière. Lorsqu’une crew ou un agent est écrit dans les deux graphies, le fichier.jsoncest celui qui est lu, comme CrewAI le lit, et le fichier.jsonest nommé dans un commentaire comme non lu.
D’un agent, il lit son role, son goal et son backstory ; allow_delegation et verbose, au niveau supérieur de sa déclaration ou sous settings, settings l’emportant, comme CrewAI les lit ; son llm ; et les noms de ses tools. D’une tâche, il lit son nom et l’agent auquel elle est assignée. Tout autre membre est nommé dans un commentaire et n’est reporté nulle part.
Un répertoire est remis à l’importateur sous la forme des fichiers que nomment ses signatures et d’aucun autre, si bien que le programme de la crew — le crew.py d’un projet classique, le main.py d’un flux, un outil qu’un projet définit en Python — n’est jamais lu. Un fichier importé seul est lu comme la déclaration dont il a la forme. Le répertoire d’un projet peut contenir plusieurs crews, chacune lue depuis son propre répertoire.
Ce que devient un projet
aggregate.yaml est un Aggregate en brouillon nommé d’après la crew, comme le décrit Comment un brouillon est nommé, s’ouvrant sur des commentaires qui nomment les déclarations lues, le fait que le programme de la crew n’est pas lu, et les tâches de chaque crew avec l’agent auquel chacune est assignée. Il contient, par agent et ayant pour clé son nom, une instance de core/ai-agent/crewai avec :
role,goaletbackstorytels que déclarés ;allow_delegationtel que déclaré, etfalselorsque l’agent n’en déclare aucun ;log_levelDEBUGpour un agent déclaréverbose, qui raconte chaque étape de son raisonnement, etINFOpour un agent qui ne l’est pas, qui ne rapporte que la progression et les problèmes. Unverboseou unallow_delegationqui n’est nitruenifalseest laissé à la valeur par défaut du Component et nommé dans un commentaire ;- sa connexion
model, reliée à l’instance du modèle que nomme sonllm.
Un llm écrit <provider>/<model>, ou comme un objet nommant le modèle sous model, model_name ou deployment_name, nomme un fournisseur et un modèle. Le modèle est une instance du Component du catalogue pour ce fournisseur — core/ai-model/<provider>, un tiret bas dans le nom du fournisseur étant lu comme un trait d’union, et azure comme azure-openai — ayant pour clé le nom du modèle, avec le modèle comme son values.model ; les agents nommant un même fournisseur et un même modèle partagent une instance. Lorsque le catalogue du workspace ne contient aucun Component de ce nom, un Component est produit en brouillon, <target_namespace>/ai-model/<provider>, déclarant la valeur model, et sa décision le dit ; l’étiquette model.aggrega.ai/api par laquelle le socket model de l’agent sélectionne un Component, et une Recipe publiant son point de terminaison et son modèle, vous sont laissées, comme le dit un commentaire en tête de celui-ci. Un llm ne nommant aucun fournisseur — un nom de modèle nu, pour lequel CrewAI résout un fournisseur lorsque le programme s’exécute, ou le nom d’un llm que définit le programme — une référence dans le programme, et un agent ne déclarant aucun llm, que CrewAI lit alors dans l’environnement où s’exécute son programme, ne sont reliés à rien, et un commentaire au-dessus de l’agent dit pourquoi ; le build s’arrête en nommant le socket model tant qu’aucun n’est relié.
Une tâche est une logique qu’exécute le programme de la crew, et un outil est du code que le programme définit ou charge : aucun des deux ne devient un Component. Chacun est rapporté dans une décision qui ne choisit rien, et un outil dont le nom — sans Tool final, ni ses traits d’union et ses tirets bas — est le nom d’un Component d’outil que contient le catalogue porte ce Component comme suggestion : search_tool et SearchTool suggèrent tous deux core/ai-tool/search. core/ai-agent/crewai ne déclare aucun socket pour un outil, si bien que rien n’est relié pour un outil.
release.yaml, à côté, est une Release en brouillon du même nom nommant cet Aggregate. Elle écrit vide l’infra.image de chaque agent — l’image exécutant le programme de la crew, que ne nomme aucune déclaration — sous un commentaire indiquant ce qu’elle est, et l’importation la signale comme due. Avec --target compose, l’entrée de chaque agent écrit aussi infra.published_port, 8000, le port que l’infra.port du Component désigne par défaut pour le programme, que sa Recipe Compose publie sur l’adresse de bouclage de l’hôte, 127.0.0.1, sous le commentaire indiquant qu’il n’est joignable que depuis cette machine, par tout processus qui s’y exécute, et que supprimer la ligne garde le service interne ; un deuxième agent prend le port libre suivant, si bien que les deux agents du projet classique sont publiés sur 8000 et 8001. Elle rattache les identifiants que chaque agent présente à son modèle sous credential sur sa connexion model, par référence et jamais comme valeur : aucune déclaration ne nomme de variable pour eux, ils sont donc lus depuis la variable dans laquelle les bibliothèques clientes du fournisseur lisent leur clé d’API — OPENAI_API_KEY pour OpenAI — sous la forme d’une référence ${…} sur toute cible sauf helm, et sur helm comme le nom d’un Secret Kubernetes, écrit vide pour que l’importation le signale comme dû ; sur compose, la connexion model de l’agent les déclare avec cette clé. Chaque modèle a lui aussi une entrée, qui ne contient aucune infrastructure, si bien que la Release le place avec les agents. Pour un modèle déclaré comme un objet llm, chaque autre membre est écrit comme valeur de l’instance du modèle lorsque le Component du catalogue déclare une valeur de ce nom, et sinon dans un commentaire au-dessus de l’entrée du modèle dans la Release, pour que vous le reportiez là où le Component le prend. Comme toute Release produite en brouillon, elle écrit metadata.environment avec la valeur development et, sans cible, un spec.manifest vide que l’importation signale comme dû ; lorsqu’une cible est donnée, l’importation produit le Manifest en brouillon, comme le décrit Ce qu’ajoute une cible.
Le projet classique qu’importent les tests de cet importateur, dont les deux agents nomment tous deux openai/gpt-4o, est produit en brouillon, sans aucun paramètre, comme ci-dessous ; importé comme son répertoire de projet, market_brief — le répertoire dans lequel crewai create crew market_brief dispose un tel projet —, ses déclarations ne nommant aucune crew, il est nommé d’après ce répertoire :
# CrewAI declarations read:# - src/market_brief/config/agents.yaml# - src/market_brief/config/tasks.yaml# Not read: the crew's program, which runs its agents and its tasks and defines its tools; it runs in the image the Release names for each agent.# Tasks the crew's program runs, drafted as no Component:# - research_task, assigned to researcher# - brief_task, assigned to brief_writerapiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/market-brief version: 0.1.0 description: Draft Aggregate imported from a source in the crewai format.spec: components: # Tools the crew's program defines or loads for this agent, drafted as no Component: search_tool. researcher: type: core/ai-agent/crewai values: role: "{topic} Market Researcher\u000A" goal: "Gather the facts about {topic} a buyer needs before a first meeting\u000A" backstory: "You have briefed sales teams for years. ..." allow_delegation: false log_level: DEBUG uses: model: gpt-4o: target: gpt-4o # For the compose target only, uncomment the lines below, which declare credential on gpt-4o: 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 # The agent brief_writer. # Not carried, since core/ai-agent/crewai takes no value for it: max_iter. brief-writer: type: core/ai-agent/crewai ... # The model openai/gpt-4o. gpt-4o: type: core/ai-model/openai values: model: "gpt-4o"et sa Release, produite en brouillon sans cible, comme ci-dessous, l’entrée du second agent étant omise ici et marquée ... ; l’importation signale comme dus spec.manifest et l’image de chaque agent :
spec: aggregate: imported/market-brief # manifest: left empty, since the import was given no target; an import given a target drafts the Manifest and names it here. manifest: "" components: researcher: infra: # Left for the Release, since the source cannot supply it: infra.image, the container image running the crew's program image: "" uses: model: gpt-4o: features: credential: type: core/secret-value infra: # Attached by reference, never as a value: the credential researcher presents to gpt-4o on its model connection (the source names no variable for it, so it is read from the one OpenAI's client libraries read the API key from), 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}" brief-writer: ... gpt-4o: {}Chaque agent est ensuite rendu exécutant l’image que vous indiquez en réponse, recevant le point de terminaison du modèle et le nom du modèle comme OPENAI_BASE_URL et MODEL, les variables dans lesquelles CrewAI les lit.
Valeurs d’identifiants que contient une déclaration
Un llm écrit comme un objet peut porter une clé — sous api_key, dans une adresse, dans des en-têtes. Chacun de ses membres autres que celui qui nomme le modèle qui n’est ni un nombre ni un booléen est une valeur pouvant en porter une, que CrewAI ne marque pas comme identifiants. Par défaut, chacun contenant une valeur est reporté tel qu’écrit — comme valeur de l’instance du modèle lorsque son Component en déclare une, et sinon dans le commentaire au-dessus de l’entrée de son modèle dans la Release — et nommé dans un avertissement credential-carried par son agent et son membre, comme llm.api_key, jamais par sa valeur. Avec le paramètre empty_credentials à all, chacun est écrit sans valeur et rapporté avec credential-emptied ; à marked, chacun est reporté, puisque CrewAI n’en marque aucun. Le nom d’un membre n’est pas lu pour ce qu’il signifie. Tout autre membre que contient une déclaration et que le brouillon ne reporte pas — la configuration d’un outil, les inputs d’une crew — est nommé, jamais avec sa valeur.
Les paramètres qu’il lit
L’importateur CrewAI lit target_namespace, empty_credentials et render_mode, tels que les décrit Paramètres, et aucun autre paramètre.
L’importateur LangGraph
importer/langgraph lit les graphes que déclare la configuration d’une application LangGraph, langgraph.json, et produit en brouillon un Aggregate contenant une instance de l’agent LangGraph de la bibliothèque standard, core/ai-agent/langgraph, par graphe, chacune reliée au magasin de données dans lequel son checkpointer conserve l’état et à un modèle, ainsi qu’une Release à côté reportant l’environnement qu’indique la configuration. Il lit cette configuration, et jamais le code des graphes.
Ce qu’il lit
Une application LangGraph garde ses graphes dans du code et les déclare dans langgraph.json : sous graphs, l’id de chaque graphe correspond au chemin d’importation du graphe dans le code de l’application — ./src/agent/graph.py:graph, ou module:attr — ou à un objet nommant ce chemin sous path et décrivant le graphe sous description. L’importateur lit, dans l’ordre où la configuration les écrit :
graphs— l’id de chaque graphe, son chemin d’importation et sa description ;checkpointer— sonbackend:default, qui est PostgreSQL et ce que lit LangGraph lorsqu’aucun n’est nommé ;mongo, une base de données parlant le protocole de MongoDB ; oucustom, un checkpointer que le code de l’application définit àpath;store— le magasin de mémoire, qui ne nomme aucun backend : LangGraph le conserve dans la base de données PostgreSQL qu’utilise son serveur ;env— l’environnement avec lequel l’application s’exécute : un objet associant des noms de variables à des valeurs, ou le chemin d’un fichier d’environnement de lignesKEY=VALUE.
Les membres qui configurent l’image serveur que construit langgraph build — dependencies, source, python_version, node_version, base_image, image_distro, dockerfile_lines, pip_config_file, pip_installer, keep_pkg_tools, api_version — sont nommés dans un commentaire et ne sont reportés nulle part, puisque l’image que nomme la Release est celle de l’application elle-même ; il en va de même de tout autre membre, dont la configuration propre du serveur comme auth, http et webhooks, ainsi que de l’index et du ttl du magasin de mémoire et du ttl et du serde du checkpointer.
Un répertoire est remis à l’importateur sous la forme de langgraph.json et d’aucun autre fichier, si bien que ni le code de l’application ni un fichier d’environnement n’y sont jamais lus. Un fichier d’environnement n’atteint l’importateur que lorsque le with.sources de l’importateur le remet, et n’est jamais analysé : de celui que nomme l’env de la configuration — apparié par le dernier segment du chemin qu’il nomme — seuls les noms des variables sont lus, et un fichier d’environnement qu’aucune configuration ne nomme est nommé dans un commentaire comme non lu. Lorsque l’importation ne reçoit pas le fichier que nomme la configuration, l’Aggregate le nomme comme non remis et indique de le nommer sous le with.sources de l’importateur, et ses variables sont laissées à la Release :
plugins: importer: - uri: importer/langgraph:<version> with: sources: - ./local.envUne configuration importée seule est lue quel que soit son nom. Un répertoire peut contenir plusieurs applications, chacune lue depuis son propre répertoire.
Ce que devient une application
aggregate.yaml est un Aggregate en brouillon nommé d’après le graphe, comme le décrit Comment un brouillon est nommé, s’ouvrant sur des commentaires qui nomment les configurations lues, les fichiers d’environnement lus pour leurs seuls noms, le fait que le code de l’application n’est pas lu, et ce que le brouillon ne reporte pas. Il contient, par graphe et ayant pour clé son id, une instance de core/ai-agent/langgraph avec :
graph_entrypoint, le chemin d’importation du graphe, tel que l’écrit la configuration ;description, la description du graphe, lorsque la configuration en donne une ;- sa connexion
checkpointer_db, reliée au magasin de données de l’application ; - sa connexion
model, reliée au modèle de l’application.
recursion_limit n’est pas écrit, si bien que la valeur par défaut du Component, 25, s’applique. La configuration ne nomme aucun modèle, si bien que le brouillon contient une instance de core/ai-model/openai, de clé model, qu’appelle chaque graphe : le modèle transmis au client OpenAI de l’agent. Son values.model est écrit vide, sous un commentaire indiquant que la configuration n’en nomme aucun, et l’importation le signale comme dû.
Le backend du checkpointer est le magasin de données auquel chaque graphe de l’application est relié : default, ou un checkpointer ne nommant aucun backend, est une instance de core/datastore/postgres, de clé postgres. mongo est FerretDB, qui parle le protocole de MongoDB, au-dessus de PostgreSQL avec l’extension DocumentDB : une instance de core/datastore/ferretdb, de clé ferretdb, à laquelle chaque graphe est relié, et une de core/datastore/documentdb, de clé documentdb, qu’atteint la connexion backend de FerretDB, son bloc inject livrant ce que publie DocumentDB sous les noms que lit FerretDB ; un seul mot de passe, lu depuis la variable FERRETDB_PASSWORD, est rattaché à DocumentDB, à la connexion de FerretDB vers celui-ci et à la connexion de chaque graphe vers FerretDB. Lorsque le catalogue du workspace ne contient aucun Component portant le nom du magasin de données PostgreSQL, un Component est produit en brouillon, <target_namespace>/datastore/postgres, déclarant le host et le port que lit la connexion checkpointer_db de l’agent, et sa décision le dit ; une Recipe exécutant le magasin de données et les publiant vous est laissée, comme le dit un commentaire en tête de celui-ci. Lorsqu’il ne contient aucun Component FerretDB ou aucun Component DocumentDB, le checkpointer mongo n’est relié à aucun magasin de données. Un checkpointer custom, ou un backend que l’importateur n’associe à aucun magasin de données, ne relie rien, et un commentaire au-dessus de chaque graphe et la décision du checkpointer disent pourquoi ; le build s’arrête en nommant le socket checkpointer_db tant qu’aucun n’est relié. Le magasin de mémoire est rapporté dans une décision qui ne choisit rien.
Le mot de passe du magasin de données est un secret que le brouillon rattache par référence, sur l’emplacement password du magasin de données lui-même et sur la connexion checkpointer_db de chaque graphe, et il en va de même des identifiants que chaque graphe présente au modèle sur sa connexion model : lus depuis POSTGRES_PASSWORD (ou FERRETDB_PASSWORD) et OPENAI_API_KEY, puisque la configuration ne nomme de variable pour aucun des deux, sous la forme d’une référence ${…} sur toute cible sauf helm, et sur helm comme le nom d’un Secret Kubernetes, écrit vide pour que l’importation le signale comme dû. Sur compose, l’Aggregate déclare chacun avec la clé que lit sa Recipe, comme le décrit Les secrets, pour chaque cible pour une plateforme.
release.yaml, à côté, est une Release en brouillon du même nom nommant cet Aggregate. Des commentaires au-dessus de l’entrée du premier graphe indiquent quelle est l’image de chaque graphe — celle de l’application elle-même, son code avec LangGraph installé, et non l’image serveur que construit langgraph build —, les variables qui lui sont transmises et quel bloc inject: remplace lequel de leurs noms. L’entrée de chaque graphe écrit vide son infra.image, l’image exécutant l’application, sous un commentaire indiquant ce qu’elle est, et l’importation la signale comme due ; tant qu’elle n’est pas définie, la Recipe Docker Compose exécute l’agent quickstart du catalogue lui-même, qui lit les variables par défaut. Avec --target compose, l’entrée de chaque graphe écrit aussi infra.published_port, 8000, le port que l’infra.port du Component désigne par défaut pour l’application, que sa Recipe Compose publie sur l’adresse de bouclage de l’hôte, 127.0.0.1, sous le commentaire indiquant qu’il n’est joignable que depuis cette machine, par tout processus qui s’y exécute, et que supprimer la ligne garde le service interne ; un deuxième graphe prend le port libre suivant. Le magasin de données et le modèle ont eux aussi des entrées, si bien que la Release les place avec les graphes. Un commentaire au-dessus du premier graphe de l’application indique l’environnement que déclare sa configuration, comme le décrit L’environnement qu’indique une configuration. Comme toute Release produite en brouillon, elle écrit metadata.environment avec la valeur development et, sans cible, un spec.manifest vide que l’importation signale comme dû ; lorsqu’une cible est donnée, l’importation produit le Manifest en brouillon, comme le décrit Ce qu’ajoute une cible.
L’application Python qu’importent les tests de cet importateur, déclarant deux graphes, un checkpointer ne nommant aucun backend, un magasin de mémoire et un env écrit comme un objet, est produite en brouillon, sans aucun paramètre, comme ci-dessous ; importée comme son répertoire, support_desk — nommé, comme ici, d’après le paquet dans lequel ses graphes sont définis —, avec deux graphes dont les id diffèrent, elle est nommée d’après ce répertoire :
# LangGraph configurations read:# - langgraph.json# Not read: the application's code, which defines each graph; it runs in the image the Release names for each graph.# Not carried, since they configure the server image langgraph build builds, and the image the Release names is the application's own: dependencies, python_version.# Not carried, since core/ai-agent/langgraph takes no value for them: http.# The store configures the memory store, which LangGraph keeps in the PostgreSQL database its server uses; not carried, since core/ai-agent/langgraph takes no value for it: index, ttl.# Not carried, since core/ai-agent/langgraph takes no value for them: checkpointer.ttl.apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/support-desk version: 0.1.0 description: Draft Aggregate imported from a source in the langgraph format.spec: components: triage: type: core/ai-agent/langgraph values: graph_entrypoint: "./src/support_desk/triage.py:make_graph" description: "Routes an incoming ticket to the {team} that owns it." uses: checkpointer_db: postgres: target: postgres # For the compose target only, uncomment the lines below, which declare credential on postgres: 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: POSTGRES_PASSWORD model: model: target: model # For the compose target only, uncomment the lines below, ... support: type: core/ai-agent/langgraph ... # The database the configuration's checkpointer keeps each graph's state in, PostgreSQL. postgres: type: core/datastore/postgres # For the compose target only, uncomment the lines below, ... # The model every graph calls, which the configuration does not name. model: type: core/ai-model/openai values: # Left for the author, since the configuration names no model: values.model, the name of the model core/ai-model/openai serves. model: ""spec: aggregate: imported/support-desk # manifest: left empty, since the import was given no target; an import given a target drafts the Manifest and names it here. manifest: "" components: # Each graph's image is the application's own, not the server image langgraph build builds: its code, with LangGraph installed. # It is handed, for its code to read, the graph to run as LANGGRAPH_GRAPH_ENTRYPOINT, the model's name as OPENAI_MODEL, the checkpointer store's host and port as LANGGRAPH_CHECKPOINTER_HOST and LANGGRAPH_CHECKPOINTER_PORT, its user and database, where the store publishes them, as LANGGRAPH_CHECKPOINTER_USER and LANGGRAPH_CHECKPOINTER_DATABASE, and a password attached on the checkpointer_db connection as LANGGRAPH_CHECKPOINTER_PASSWORD. # It is also handed the model's address as OPENAI_BASE_URL and a key attached on the model connection as OPENAI_API_KEY, which the OpenAI client library reads, and recursion_limit as LANGGRAPH_DEFAULT_RECURSION_LIMIT, which LangGraph reads. # An inject: block on the graph's own instance, through an entry reading graph_entrypoint alone, replaces LANGGRAPH_GRAPH_ENTRYPOINT with the name it writes; one on the model connection replaces OPENAI_MODEL, and one on the checkpointer_db connection the store's host, port, user and database, with the names it writes. # The environment langgraph.json states for its application, for the Release to carry where core/ai-agent/langgraph takes it for each of its graphs: # SUPPORT_QUEUE: "..." # OPENAI_API_KEY: "..." # MAX_TICKETS: "25" triage: infra: # Left for the Release, since the source cannot supply it: infra.image, the container image running the application image: "" uses: checkpointer_db: postgres: features: credential: type: core/secret-value infra: # Attached by reference, never as a value: the credential triage presents to postgres on its checkpointer_db connection, the password of postgres (the configuration names no variable for it), read from the variable POSTGRES_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: "${POSTGRES_PASSWORD}" model: model: features: credential: type: core/secret-value infra: # Attached by reference, never as a value: the credential triage presents to model on its model connection (the source names no variable for it, so it is read from the one OpenAI's client libraries read the API key from), 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}" ... postgres: features: password: type: core/secret-value infra: # Attached by reference, never as a value: the password of postgres (the configuration names no variable for it), read from the variable POSTGRES_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: "${POSTGRES_PASSWORD}" model: {}L’importation signale quatre valeurs comme dues : spec.manifest, l’image de chaque graphe et le nom du modèle. Une fois qu’elles ont reçu une réponse, chaque graphe est rendu exécutant l’image que vous indiquez en réponse, recevant l’adresse de son magasin de données comme LANGGRAPH_CHECKPOINTER_HOST et LANGGRAPH_CHECKPOINTER_PORT, l’utilisateur et la base de données que publie le magasin de données comme LANGGRAPH_CHECKPOINTER_USER et LANGGRAPH_CHECKPOINTER_DATABASE — PostgreSQL publie les deux, et pour un magasin de données qui ne publie ni l’un ni l’autre, aucune des deux variables n’est rendue —, le point de terminaison et le nom du modèle comme OPENAI_BASE_URL et OPENAI_MODEL, la clé que livrent ses identifiants de modèle comme OPENAI_API_KEY, son chemin d’importation comme LANGGRAPH_GRAPH_ENTRYPOINT et sa limite d’étapes comme LANGGRAPH_DEFAULT_RECURSION_LIMIT. Les identifiants rattachés à sa connexion checkpointer_db lui donnent aussi le mot de passe du magasin de données comme LANGGRAPH_CHECKPOINTER_PASSWORD.
L’environnement qu’indique une configuration
Chaque variable que nomme l’env de la configuration est une entrée que la Release doit fournir, et aucune n’est produite en brouillon comme emplacement d’identifiants : LangGraph ne marque aucune variable comme secret, et le nom d’une variable n’est pas lu pour ce qu’il signifie. core/ai-agent/langgraph ne prend aucune valeur pour l’environnement, si bien que la Release l’indique dans un commentaire au-dessus du premier graphe de l’application.
- Un
envécrit comme un objet fait partie de la configuration, si bien que ses valeurs sont reportées telles qu’écrites dans ce commentaire, dans l’ordre où la configuration les écrit. Chaque valeur qui contient quelque chose peut porter des identifiants, que LangGraph ne marque pas comme identifiants : par défaut, chacune est reportée telle qu’écrite et nommée dans un avertissementcredential-carriedpar sa configuration et sa variable, commeenv.OPENAI_API_KEY, jamais par sa valeur. Avec le paramètreempty_credentialsàall, chacune est écrite sans valeur et rapportée aveccredential-emptied; àmarked, chacune est reportée, puisque LangGraph n’en marque aucune. - Un
envnommant un fichier nomme un fichier vers lequel la configuration ne fait que pointer, et qui contient couramment des secrets locaux. Il n’est lu que lorsque lewith.sourcesde l’importateur le remet. Le commentaire nomme chaque variable que nomme le fichier, laissée à la Release pour qu’elle la fournisse, et aucune valeur du fichier n’est lue : aucune n’atteint un brouillon, une décision ou un diagnostic, quoi que dise le paramètre. Une valeur entre guillemets sur plusieurs lignes est une seule valeur, si bien qu’une ligne à l’intérieur n’est jamais prise pour une variable, et une ligne ne nommant aucune variable est nommée par son numéro. Lorsque l’importation n’a pas reçu le fichier — toujours le cas pour un répertoire, qui n’en remet jamais — l’Aggregate le nomme comme non remis, avec la manière de le remettre, et ses variables sont laissées à la Release.
Les paramètres qu’il lit
L’importateur LangGraph lit target_namespace, empty_credentials et render_mode, tels que les décrit Paramètres, et aucun autre paramètre.
L’importateur Google ADK
importer/google-adk lit les agents qu’une application construite sur l’Agent Development Kit (ADK) de Google déclare dans ses fichiers Agent Config — root_agent.yaml et les configurations que nomment ses sous-agents — et produit en brouillon un Aggregate contenant une instance de l’agent ADK de la bibliothèque standard, core/ai-agent/google-adk, par arbre d’agents, reliée au modèle que nomme l’arbre lorsqu’ADK en envoie les requêtes à la Gemini API, ainsi qu’une Release à côté. Il lit ces configurations, et jamais le code de l’application.
ADK indique que sa fonctionnalité Agent Config est expérimentale. Le modèle d’un agent est par défaut un modèle Gemini ; ADK sert les modèles de certains autres fournisseurs par leur nom au moyen de classes qui lui sont propres, comme claude-sonnet-4-5 et gpt-4o, et d’autres au moyen d’une chaîne de modèle LiteLLM. Le socket model de l’agent n’admet que la Gemini API, de sorte que l’importateur relie un modèle qu’ADK envoie à la Gemini API et vous laisse tout autre, comme le décrit Ce que devient un arbre d’agents.
Ce qu’il lit
adk create --type=config d’ADK écrit root_agent.yaml, la configuration de l’agent racine d’une application, et un fichier d’environnement à côté. Une configuration déclare un agent :
name,descriptionetagent_class— la classe sous laquelle ADK construit l’agent,LlmAgentlorsqu’elle n’en nomme aucune ;model— le modèle que demande l’agent — oumodel_code, une référence à du code construisant son modèle ;tools— chaque outil parname, avec lesargsque lui remet sa configuration ;generate_content_config— les options des requêtes de modèle de l’agent, donthttp_options;sub_agents— chacun unconfig_path, le chemin d’une autre configuration depuis le répertoire de la configuration qui le nomme, oucode, un agent que construit le code de l’application.
Un répertoire est remis à l’importateur sous la forme de ses fichiers root_agent.yaml et d’aucun autre fichier, et une configuration importée seule est lue comme une racine, quel que soit son nom. L’arbre de chaque racine est lu en commençant par la racine, les sous-agents de chaque agent dans l’ordre où il les liste. La configuration qu’une entrée de sub_agents nomme par config_path n’est lue que lorsque le with.sources de l’importateur la remet, appariée par le dernier segment du chemin ; une configuration que l’importation n’a pas reçue est nommée dans l’Aggregate et dans sa décision comme non remise, avec la manière de la remettre, et son agent n’est pas lu :
plugins: importer: - uri: importer/google-adk:<version> with: sources: - ./my_agent/code_tutor_agent.yaml - ./my_agent/math_tutor_agent.yamlUn config_path absolu, ou qui sort du répertoire de la configuration qui le nomme, n’est pas lu, puisqu’ADK le refuse aussi. Un fichier que remet with.sources et qu’aucune configuration ne nomme est nommé dans un commentaire comme non lu, et rien de lui n’est lu ; un fichier qu’il remet n’est lu que comme une configuration que nomme l’arbre d’une racine, si bien qu’une importation ne contenant aucun root_agent.yaml ni aucun fichier importé seul ne lit aucun arbre et rapporte chaque fichier sous no-nodes. Le code de l’application — les outils, callbacks, schémas et agents qu’une configuration nomme par leur code — et le fichier d’environnement ne sont jamais remis, et l’importateur ne lit ni l’un ni l’autre : l’application charge elle-même ses configurations, depuis l’image que nomme la Release. Un répertoire peut contenir plusieurs applications, chacune lue depuis son propre root_agent.yaml.
Les autres membres d’une configuration — dont l’instruction d’un agent — sont lus par l’application depuis sa propre configuration, si bien que le brouillon n’en reporte aucun.
Ce que devient un arbre d’agents
ADK sert une application depuis son agent racine, chaque agent que nomment ses configurations étant construit à l’intérieur, et core/ai-agent/google-adk exécute une telle application. Ainsi aggregate.yaml, un Aggregate en brouillon nommé d’après l’agent racine, comme le décrit Comment un brouillon est nommé, contient, par arbre d’agents et ayant pour clé le nom de son agent racine, une instance de core/ai-agent/google-adk avec :
description, la description de l’agent racine, lorsque sa configuration en donne une ;- sa connexion
model, reliée au modèle que nomme l’arbre, lorsqu’ADK envoie ses requêtes à la Gemini API.
Des commentaires au-dessus d’elle nomment les autres agents de l’arbre, qui ne deviennent pas une instance à part entière ; chaque sous-agent qui n’est pas lu, et pourquoi — construit par le code de l’application, une configuration que l’importation n’a pas reçue, ou une configuration qu’ADK refuse ; les outils que nomment les agents de l’arbre, ceux que fournit ADK et ceux que définit le code de l’application ; les agents dont la classe — LoopAgent, ParallelAgent ou SequentialAgent — est dépréciée par ADK au profit de Workflow ; et, lorsque le modèle de l’arbre est relié, les modèles que demandent d’autres agents de l’arbre, chacun avec la famille par laquelle ADK le sert. Chacun est rapporté dans une décision qui ne choisit rien.
Le premier agent de l’arbre, en commençant par la racine, qui nomme un modèle ou le code qui en construit un décide du modèle de l’instance. Un modèle qu’il nomme et dont ADK envoie les requêtes à la Gemini API — un nom de modèle qu’ADK sert par sa classe Gemini, tel que gemini-2.5-flash, autre qu’un nom de ressource Vertex AI, ou un nom qu’il sert par sa classe Gemma — est une instance de core/ai-model/gemini, servant ce modèle et ayant celui-ci pour clé, et les arbres nommant un même modèle partagent une instance. Lorsque le catalogue du workspace ne contient aucun core/ai-model/gemini, un Component est produit en brouillon, <target_namespace>/ai-model/gemini, portant l’étiquette model.aggrega.ai/api: gemini que sélectionne le socket model de l’agent, et sa décision le dit ; une Recipe publiant son point de terminaison et son modèle vous est laissée, comme le dit un commentaire en tête de celui-ci. Un modèle qu’ADK sert de toute autre manière — une chaîne de modèle LiteLLM telle que openai/gpt-4o, un nom de ressource Vertex AI, ou un nom tel que claude-sonnet-4-5 ou gpt-4o, qu’ADK sert par Anthropic ou OpenAI — n’est relié à rien : le socket model de l’agent accepte un modèle Gemini, et l’agent ne lit aucun nom de modèle dans son environnement, si bien que c’est à vous d’y relier un modèle Gemini et de nommer ce modèle dans la configuration de l’agent. Le commentaire au-dessus de l’instance et la décision de l’agent racine nomment le modèle et la famille par laquelle ADK le sert. Un modèle que construit le code de l’application, ou un arbre n’en nommant aucun — ADK utilise alors son modèle par défaut — n’est relié à rien non plus, et un commentaire au-dessus de l’instance dit pourquoi. Partout où le modèle n’est relié à rien, le build s’arrête en nommant le socket model tant qu’aucun n’est relié. Parmi les modèles que demandent d’autres agents d’un arbre, celui dont ADK envoie les requêtes à la Gemini API n’a besoin d’aucune connexion propre : le client Gemini d’ADK envoie ses requêtes avec la clé que fournit la connexion de l’instance. Que l’application atteigne Gemini par la Gemini API ou par Vertex AI est choisi par son environnement, que l’importation ne lit pas ; le socket model de l’agent n’admet que la Gemini API.
Les tests de l’importateur importent aussi un agent racine isolé nommant openai/gpt-4o, dont l’instance est produite en brouillon ainsi :
spec: components: # The agent tree of root_agent.yaml, served from its root agent routed_agent. # The model connection is left for the author, since the model openai/gpt-4o, which routed_agent names, is one ADK serves through LiteLLM, not through the Gemini API, while core/ai-agent/google-adk takes a Gemini model on its model socket and reads no model name from its environment, so the author wires a Gemini model there and names that model in routed_agent's configuration; the build halts naming the socket until one is wired. routed-agent: type: core/ai-agent/google-adk values: description: "Answers questions with a model another provider serves."release.yaml, à côté, est une Release en brouillon du même nom nommant cet Aggregate. L’entrée de chaque instance écrit son infra.image — l’image exécutant l’application construite sur ADK, qui contient ses configurations — vide, sous un commentaire indiquant ce qu’elle est, et l’importation la signale comme due. Avec --target compose, l’entrée écrit aussi infra.published_port, 8000, le port sur lequel l’application écoute, que sa Recipe Compose publie sur l’adresse de bouclage de l’hôte, 127.0.0.1, sous le commentaire indiquant qu’il n’est joignable que depuis cette machine, par tout processus qui s’y exécute, et que supprimer la ligne garde le service interne ; un second arbre prend le port libre suivant. Lorsque son modèle est relié, l’entrée rattache les identifiants que l’instance présente à ce modèle sous credential sur sa connexion model, par référence et jamais comme valeur : aucune configuration ne nomme de variable pour eux, ils sont donc lus depuis GOOGLE_API_KEY, la variable dans laquelle les bibliothèques clientes de la Gemini API de Google lisent leur clé, comme référence ${…} sur toutes les cibles sauf helm, et sur helm comme nom d’un Kubernetes Secret, écrit vide et signalé comme dû par l’importation ; sur compose, la connexion model les déclare avec cette clé. Un modèle relié a lui aussi une entrée, qui ne contient aucune infrastructure, de sorte que la Release le place avec l’instance. Les valeurs que les configurations de l’arbre remettent à leurs outils et à leurs requêtes de modèle sont écrites dans un commentaire au-dessus de l’entrée, comme le décrit Valeurs d’identifiants que contient une configuration. Comme toute Release produite en brouillon, elle écrit metadata.environment comme development et, sans cible, un spec.manifest vide que l’importation signale comme dû ; avec une cible, l’importation produit le Manifest en brouillon, comme le décrit Ce qu’ajoute une cible.
L’application qu’importent les tests de cet importateur, un agent racine nommant les configurations de deux sous-agents et un sous-agent construit par du code, importée comme son répertoire avec les deux configurations nommées sous with.sources, est produite en brouillon, sans aucun paramètre, sous le nom de son agent racine, tutor_root, ainsi :
# Google ADK agent configurations read:# - root_agent.yaml# - code_tutor_agent.yaml# - math_tutor_agent.yaml# Not read: the application's code, which defines the tools, callbacks and agents a configuration names by their code, nor the environment file ADK's scaffold writes beside root_agent.yaml; the application runs in the image the Release names for each instance, and loads its configurations itself.# ADK states that its Agent Config is experimental. An agent's model is a Gemini model by default; ADK serves some other providers' models by name through classes of its own, such as claude-sonnet-4-5 and gpt-4o, and others through a LiteLLM model string.apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/tutor-root version: 0.1.0 description: Draft Aggregate imported from a source in the google-adk format.spec: components: # The agent tree of root_agent.yaml, served from its root agent tutor_root. # Sub-agents ADK builds inside this application, drafted as no instance of their own: code_tutor_agent, math_tutor_agent. # Not read: a sub-agent of tutor_root, which is built by the application's code at tutor_agents.review_agent, which the import does not read. # Tools ADK ships, which run inside the application, drafted as no Component: google_search. # Tools the application's code defines, drafted as no Component: tutor_tools.make_snippet_runner. # Models other agents of the tree ask for, ...: gemini-pro-latest (math_tutor_agent, served through Gemini). tutor-root: type: core/ai-agent/google-adk values: description: "Learning assistant that tutors {{`{{`}} students }} in code and math." uses: model: gemini-flash-latest: target: gemini-flash-latest # For the compose target only, uncomment the lines below, which declare credential on gemini-flash-latest: 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: GOOGLE_API_KEY # The model gemini-flash-latest. gemini-flash-latest: type: core/ai-model/gemini values: model: "gemini-flash-latest"Un texte que le brouillon copie d’une configuration dans l’Aggregate, dans une valeur ou dans un commentaire, écrit chaque {{ sous la forme {{`{{`}}, une action dont le résultat est les deux accolades, si bien que la description, et un nom contenant deux accolades dans un commentaire, se relisent tels qu’écrits une fois l’Aggregate évalué.
spec: aggregate: imported/tutor-root # manifest: left empty, since the import was given no target; an import given a target drafts the Manifest and names it here. manifest: "" components: # The configurations also hand these values to their tools and their model requests, which the application reads from its own configurations, written here for review: # code_tutor_agent tools.tutor_tools.make_snippet_runner.args.api_key: "..." # code_tutor_agent tools.tutor_tools.make_snippet_runner.args.sandbox: "python3.12" # code_tutor_agent tools.tutor_tools.make_snippet_runner.args.timeout_seconds: 20 # math_tutor_agent generate_content_config.http_options.headers: "..." # math_tutor_agent generate_content_config.http_options.timeout: 30000 tutor-root: infra: # Left for the Release, since the source cannot supply it: infra.image, the container image running the application built on ADK, holding its configurations image: "" uses: model: gemini-flash-latest: features: credential: type: core/secret-value infra: # Attached by reference, never as a value: the credential tutor-root presents to gemini-flash-latest on its model connection (the source names no variable for it, so it is read from the one Google's Gemini API's client libraries read the API key from), read from the variable GOOGLE_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: "${GOOGLE_API_KEY}" gemini-flash-latest: {}Une fois l’image renseignée, l’instance est rendue l’exécutant et reçoit les identifiants comme GOOGLE_API_KEY, que le client Gemini d’ADK envoie à la Gemini API, et le modèle comme un Service atteignant l’adresse de la Gemini API.
Valeurs d’identifiants que contient une configuration
Une configuration peut remettre une clé à un outil, dans ses args, ou à ses requêtes de modèle, dans les http_options de sa generate_content_config — leurs en-têtes, leur adresse, les arguments de leur client. Chaque membre des args d’un outil et de ces options HTTP est écrit dans le commentaire au-dessus de l’entrée de l’instance dans la Release, tel que sa configuration l’écrit, et chacun qui est un texte, un objet ou une liste peut porter des identifiants, qu’ADK ne marque pas comme identifiants : par défaut, chacun est reporté tel qu’écrit et nommé dans un avertissement credential-carried par son agent et son champ, comme tools.tutor_tools.make_snippet_runner.args.api_key, jamais par sa valeur. Avec le paramètre empty_credentials à all, chacun est écrit sans valeur et rapporté avec credential-emptied ; à marked, chacun est reporté, puisqu’ADK n’en marque aucun. Un nombre ou un booléen ne porte aucune clé, et est écrit tel que l’écrit la configuration. ADK ne développe aucune référence de variable dans une configuration, si bien que chaque valeur est lue telle qu’écrite ; le fichier d’environnement, qui contient couramment la clé que lit le client Gemini d’ADK, n’est jamais lu, quoi que dise le paramètre.
Les paramètres qu’il lit
L’importateur Google ADK lit target_namespace, empty_credentials et render_mode, tels que les décrit Paramètres, et aucun autre paramètre.
L’importateur Agent Framework
importer/agent-framework lit un agent déclaratif de Microsoft Agent Framework — le document YAML de type Prompt à partir duquel une application construite sur Agent Framework charge un agent — et produit en brouillon un Aggregate contenant une instance de l’agent Agent Framework de la bibliothèque standard, core/ai-agent/agent-framework, reliée au modèle OpenAI qu’il nomme, ainsi qu’une Release à côté. Il lit des agents déclaratifs, et jamais le code de l’application. Agent Framework publie ses paquets d’agents déclaratifs en préversion.
Ce qu’il lit
Un agent déclaratif déclare :
name,displayNameetdescription, sesinstructionset les schémas de son entrée et de sa sortie ;model— l’iddu modèle, leproviderqui le sert, l’API à laquelle son client envoie des requêtes (apiType), lesoptionsde ses requêtes, et saconnection: une connexionkeyprésentant une clé, écrite souskeyouapiKey, à unendpoint; une connexionremoteatteignant unendpoint; une connexionreferenceen nommant une que l’application résout ; ou une connexionanonymousne présentant rien ;tools— chacun d’unkind: unefunctiondont l’application lie le code, un outilweb_search,file_searchoucode_interpreterqu’exécute le fournisseur du modèle, ou un serveurmcpjoint à sonurl, avec l’approvalModeque suivent ses appels, lesallowedToolsdu serveur que l’agent peut appeler et uneconnectionqui lui est propre.
Un membre écrit =Env.NAME est lu par Agent Framework dans la variable d’environnement NAME uniquement lorsque l’application charge l’agent déclaratif avec AgentFactory(safe_mode=False), le propre paramètre de sécurité d’Agent Framework, et qu’un environnement d’exécution .NET est présent, et il est sinon pris comme le texte de l’expression tel qu’il est écrit ; tout autre membre commençant par = est une expression que calcule l’application. L’importateur ne lit ni l’un ni l’autre : il nomme une référence par sa variable, et une expression en tant que telle.
Un fichier importé seul est lu comme un agent déclaratif, quel que soit son nom, et chaque fichier que transmet le with.sources de l’importateur est lu comme un autre, si bien qu’une importation en produit plusieurs en brouillon :
plugins: importer: - uri: importer/agent-framework:<version> with: sources: - ./agents/triage.yaml - ./agents/writer.yamlUn répertoire n’est jamais transmis à l’importateur : sa signature ne nomme aucun fichier, si bien qu’une importation d’un répertoire ne nommant aucun format ne le reconnaît pas, et qu’une importation nommant --format agent-framework est refusée sous An importer that declares no file patterns is handed a directory (Un importer qui ne déclare aucun motif de fichier reçoit un répertoire) avant qu’aucun de ses fichiers ne soit ouvert. Importez plutôt chaque agent déclaratif comme un fichier à part. Une source à partir de laquelle Agent Framework ne construit aucun agent prompt — une source dont le kind n’est ni Prompt, quelle que soit la casse, ni Agent — est rapportée sous no-nodes. Le code de l’application — le programme chargeant chaque agent déclaratif et les fonctions qu’il lie à ses outils — ne fait jamais partie des sources : l’application charge elle-même ses agents déclaratifs, depuis l’image que nomme la Release.
Ce que devient un agent déclaratif
aggregate.yaml, un Aggregate en brouillon nommé d’après l’agent, comme le décrit Comment un brouillon est nommé, contient, par agent déclaratif et ayant pour clé son nom, une instance de core/ai-agent/agent-framework avec :
display_nameetdescription, ledisplayNameet ladescriptionde l’agent, lorsqu’il les indique ;- sa connexion
model, reliée au modèle qu’il nomme, lorsque ce modèle est relié.
Ses instructions, les schémas de son entrée et de sa sortie, son gabarit, ses métadonnées et les options de ses requêtes au modèle sont lus par l’application dans l’agent déclaratif, et sont nommés dans un commentaire au-dessus de l’instance. Un outil fonction, un outil qu’exécute le fournisseur du modèle et un outil de tout autre type sont eux aussi nommés dans un commentaire, et rapportés dans une décision qui ne choisit rien.
Un modèle dont le provider est OpenAI et qui nomme un id est une instance de core/ai-model/openai, servant cet id et l’ayant pour clé : le socket model de l’agent accueille un modèle servant l’API OpenAI, et l’environnement d’exécution fournit l’adresse, le nom et la clé de ce modèle dans les variables que lisent les clients OpenAI d’Agent Framework. Les agents nommant un même modèle à une même adresse partagent une instance. Lorsque le catalogue du workspace ne contient aucun core/ai-model/openai, un Component est produit en brouillon, <target_namespace>/ai-model/openai, portant l’étiquette model.aggrega.ai/api: openai que sélectionne le socket model de l’agent, et sa décision le dit ; une Recipe publiant son point de terminaison et son modèle vous est laissée, comme le dit un commentaire en tête de celui-ci. Un id écrit comme une référence vous laisse le values.model du modèle, un commentaire au-dessus du modèle nommant la variable ; le build s’arrête en le nommant tant qu’il n’est pas défini. Une connexion anonymous est écrite comme le unauthenticated: true de la connexion. Un modèle de tout autre fournisseur — AzureOpenAI, Anthropic —, un modèle nommant son fournisseur par une référence ou n’en nommant aucun, auquel cas Agent Framework utilise le fournisseur par défaut que définit l’application, et un modèle ne nommant aucun id ne sont reliés à rien, et un commentaire au-dessus de l’instance dit pourquoi ; le build s’arrête en nommant le socket model tant qu’aucun n’est relié.
Un outil de type mcp n’est produit en brouillon ni comme Component ni comme connexion : Agent Framework envoie le serveur au fournisseur du modèle comme outil hébergé, et c’est le fournisseur, et non l’application, qui l’atteint à son url, qui doit donc être joignable depuis le fournisseur, de sorte que rien de ce que déploie le brouillon ne l’atteint. Un commentaire au-dessus de l’instance de l’agent nomme le serveur, le signale, et nomme la description, l’approvalMode et les allowedTools que l’agent déclaratif indique pour lui ; son url est écrite, en entier, dans le commentaire au-dessus de l’entrée de l’agent dans la Release, et sa décision ne choisit rien.
release.yaml, à côté, est une Release en brouillon du même nom nommant cet Aggregate. L’entrée de l’agent écrit son infra.image — l’image exécutant l’application construite sur Agent Framework, qui contient son agent déclaratif — vide, sous un commentaire indiquant ce qu’elle est, et l’importation la signale comme due. Avec --target compose, l’entrée écrit aussi infra.published_port, 8000, le port que l’infra.port du Component désigne par défaut pour l’application, que sa Recipe Compose publie sur l’adresse de bouclage de l’hôte, 127.0.0.1, sous le commentaire indiquant qu’il n’est joignable que depuis cette machine, par tout processus qui s’y exécute, et que supprimer la ligne garde le service interne. Lorsque son modèle est relié, l’entrée rattache les identifiants que l’agent présente à ce modèle sous credential sur sa connexion model, par référence et jamais comme valeur : lus depuis la variable que l’agent déclaratif nomme pour sa clé, écrite =Env.NAME, et sinon depuis OPENAI_API_KEY, la variable dans laquelle les bibliothèques clientes d’OpenAI lisent leur clé ; comme référence ${…} sur toutes les cibles sauf helm, et sur helm comme nom d’un Kubernetes Secret, écrit vide et signalé comme dû par l’importation ; sur compose, la connexion model les déclare avec cette clé. Les valeurs qu’indique l’agent déclaratif pour son modèle et ses serveurs MCP — les clés, et l’url de chaque serveur — sont écrites dans un commentaire au-dessus de l’entrée de l’agent, comme le décrit Valeurs d’identifiants que contient un agent déclaratif. Chaque modèle relié a une entrée, de sorte que la Release le place avec l’agent. Le point de terminaison qu’indique sa connexion est écrit comme l’infra.endpoint du modèle, et un point de terminaison écrit comme une référence est nommé à côté de son entrée, l’adresse propre du Component étant utilisée tant qu’il n’est pas défini ; une connexion n’indiquant aucun point de terminaison laisse l’entrée sans aucune infrastructure, l’adresse propre du Component restant en vigueur. Comme toute Release produite en brouillon, elle écrit metadata.environment comme development et, sans cible, un spec.manifest vide que l’importation signale comme dû ; avec une cible, l’importation produit le Manifest en brouillon, comme le décrit Ce qu’ajoute une cible.
L’agent déclaratif qu’importent les tests de cet importateur, du fournisseur OpenAI avec une connexion par clé, un serveur MCP présentant sa propre clé, un outil fonction et une recherche web, importé comme un fichier à part, est produit en brouillon, sans aucun paramètre, sous son name, LearnAgent, ainsi :
# Not read: the application's code, which loads each declarative agent and binds the functions of its function tools; the application runs in the image the Release names for each instance, and loads its declarative agents itself.apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/learnagent version: 0.1.0 description: Draft Aggregate imported from a source in the agent-framework format.spec: components: # The declarative agent LearnAgent. # Read by the application from the declarative agent, and taken by no key of core/ai-agent/agent-framework: instructions, outputSchema, the options of its model requests (temperature, topP). # Function tools, whose code the application binds, drafted as no Component: GetRelease. # Tools the model's provider runs, drafted as no Component: search. # The MCP server microsoft_learn, drafted as no Component and no connection, since Agent Framework sends it to the model's provider as a hosted tool, and the provider, not the application, reaches it at its url, which must therefore be reachable from the provider; its url is written above learnagent's entry in the Release. # Stated by the declarative agent for microsoft_learn: its description, "Get information from Microsoft Learn."; its approval mode, never; the tools of the server it allows, microsoft_docs_search, microsoft_docs_fetch. learnagent: type: core/ai-agent/agent-framework values: display_name: "Learn Assistant" description: "Answers questions about {{`{{`}} product }} from the Microsoft Learn content." uses: model: gpt-4-1-mini: target: gpt-4-1-mini # For the compose target only, uncomment the lines below, which declare credential on gpt-4-1-mini: 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 # The model gpt-4.1-mini, which LearnAgent names with the OpenAI provider. gpt-4-1-mini: type: core/ai-model/openai values: model: "gpt-4.1-mini"Un texte que le brouillon copie d’un agent déclaratif dans l’Aggregate, dans une valeur ou dans un commentaire, écrit chaque {{ comme {{`{{`}}, si bien qu’il se relit tel qu’écrit une fois l’Aggregate évalué.
spec: aggregate: imported/learnagent # manifest: left empty, since the import was given no target; an import given a target drafts the Manifest and names it here. manifest: "" components: # The declarative agent also states these values for its model and its MCP servers, written here for review: # - model.connection.key: "..." # - tools.microsoft_learn.url: "https://learn.microsoft.com/api/mcp?session=..." # - tools.microsoft_learn.connection.key: "..." learnagent: infra: # Left for the Release, since the source cannot supply it: infra.image, the container image running the application built on Agent Framework, holding its declarative agent image: "" uses: model: gpt-4-1-mini: features: credential: type: core/secret-value infra: # Attached by reference, never as a value: the credential learnagent presents to gpt-4-1-mini on its model connection (the source names no variable for it, so it is read from the one OpenAI's client libraries read the API key from), 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}" gpt-4-1-mini: infra: endpoint: "https://llm-gateway.example.com/v1"Une fois l’image renseignée, l’agent est rendu l’exécutant, recevant le point de terminaison du modèle comme OPENAI_BASE_URL, son id comme OPENAI_MODEL et ses identifiants comme OPENAI_API_KEY, et le modèle est rendu comme un Service atteignant son hôte. Aucune variable ne porte l’adresse du serveur MCP : c’est le fournisseur du modèle, et non l’application, qui l’atteint.
Valeurs d’identifiants que contient un agent déclaratif
La clé que présente une connexion key — écrite sous key ou apiKey, sur le modèle ou sur un serveur MCP — est le seul membre qu’Agent Framework marque comme identifiants : c’est la seule valeur que son chargeur masque dans ce qu’il journalise. Chaque clé qu’un agent déclaratif écrit comme un littéral est écrite dans le commentaire au-dessus de l’entrée de l’agent dans la Release, telle que l’écrit l’agent déclaratif, et par défaut reportée telle qu’écrite et nommée dans un avertissement credential-carried par son agent et son champ, comme model.connection.key, jamais par sa valeur. L’url d’un serveur MCP, écrite en entier dans le même commentaire et nommée par son champ — tools.microsoft_learn.url of node LearnAgent is carried as written —, est un membre de la configuration d’un serveur MCP, et le point de terminaison d’un modèle relié est une entrée qu’Agent Framework marque comme n’étant pas des identifiants. Avec le paramètre empty_credentials à marked, les clés et les url des serveurs MCP sont écrites sans valeur — le commentaire ne nommant chacune que par son champ — et rapportées avec credential-emptied, et le point de terminaison du modèle est reporté ; à all, l’infra.endpoint du modèle est lui aussi omis, nommé dans le commentaire au-dessus de son entrée comme laissé à la Release, et l’adresse par défaut du Component est utilisée tant qu’il n’est pas défini. Une valeur écrite =Env.NAME n’en contient aucune, si bien qu’elle est nommée par sa variable, avec la condition dans laquelle Agent Framework la lit dans l’environnement — model.connection.key, written as =Env.OPENAI_API_KEY, which Agent Framework reads … — quoi que dise le paramètre, et rapportée sous aucun des deux codes ; une valeur écrite comme toute autre expression est nommée en tant que telle et jamais écrite.
Les paramètres qu’il lit
L’importateur Agent Framework lit target_namespace, empty_credentials et render_mode, tels que les décrit Paramètres, et aucun autre paramètre.
Ce qu’ajoute une cible
Une importation qui reçoit une cible — --target sur aggrega import, ou target sur l’outil d’importation de l’assistant et la méthode aggrega/import de la session, nommant une capacité de fournisseur telle que compose ou helm — transmet cette cible à l’importateur, qui produit donc ses brouillons pour elle : chaque secret sous la forme que cette cible lit, et les lignes dont seule cette cible a besoin, écrites actives, tandis que les lignes dont seule une autre cible a besoin sont omises. Sur compose, ces lignes comprennent infra.published_port partout où l’importateur publie un service sur l’adresse de bouclage de l’hôte, comme l’indique la section de chaque importateur ; un port que choisit l’importateur ne prend jamais un numéro que prend un autre port de la Release. L’importation produit ensuite le Manifest en brouillon à côté de ce qu’a produit l’importateur, quel que soit l’importateur exécuté : manifest.yaml, à côté de la Release en brouillon et nommé et versionné comme elle — ou, lorsque l’importateur n’a produit aucune Release en brouillon, à côté de l’Aggregate en brouillon et nommé et versionné comme lui.
Pour chaque type de composant et chaque type de feature dont les brouillons ont besoin — sur les composants de l’Aggregate en brouillon, leurs connexions et ses sous-systèmes, sur les Aggregates du catalogue qu’il compose, comme core/dify, et sur les rattachements de la Release en brouillon —, le Manifest fait correspondre le type à la Recipe, ou pour un type de feature à la feature recipe, de cette capacité que le catalogue du workspace offre pour lui : celle qui existe, plusieurs versions d’une même comptant pour une ; ou, lorsqu’il y en a plusieurs de noms différents, celle qui porte le nom du type lui-même, comme helm/postgres pour core/datastore/postgres. Un type qui n’en a aucune, ou en a plusieurs dont aucune ne porte ce nom, reste sans correspondance, un avertissement le nomme en indiquant pourquoi, et un build des brouillons s’arrête en nommant chacune de ses instances ou chacun de ses rattachements tant que vous ne l’avez pas mis en correspondance.
Lorsque seul l’importateur sait laquelle de plusieurs Recipes s’applique, il produit lui-même le Manifest en brouillon — l’importateur MCP fait correspondre chaque serveur, par sa clé, à la réalisation de la manière dont le serveur s’exécute, et un importateur rattachant un secret par son nom fait correspondre core/referenced-secret à helm/k8s-existing-secret — et l’importation le complète : chaque correspondance écrite par l’importateur que le catalogue offre pour ce type et cette capacité est conservée, toute autre est écartée avec un avertissement, et les types qu’il laisse sont mis en correspondance comme ci-dessus.
Le spec.manifest de la Release en brouillon, écrit vide sans cible, est défini sur le nom du Manifest, le commentaire au-dessus est supprimé, et rien d’autre ne change dans la Release. aggrega import le décrit en détail.
Paramètres
Un importateur reçoit les paramètres de l’entrée plugins.importer qui le rattache, sous with.settings, comme le décrit Quel importeur transforme une source en brouillons. Sans entrée, ou sans paramètres, chaque paramètre prend sa valeur par défaut.
plugins: importer: - uri: importer/langflow:<version> with: settings: target_namespace: payments reuse_mode: hints-only| Paramètre | Par défaut | Fonctionnement |
|---|---|---|
target_namespace | imported | L’espace de noms sous lequel les entités produites en brouillon sont nommées : <target_namespace>/<category>/<name> pour un Component, et <target_namespace>/<name> pour l’Aggregate et la Release, <name> étant le nom propre de la source, sinon le nom de son répertoire ou le nom de son fichier sans l’extension, sinon flow, écrit en minuscules, chaque suite de caractères autres que des lettres et des chiffres ASCII devenant un seul trait d’union, comme le décrit Comment un brouillon est nommé. |
reuse_mode | auto-apply-above-threshold | auto-apply-above-threshold référence le Component du catalogue qui correspond le mieux pour un nœud auquel le brouillon donne un Component propre, dont la correspondance est au niveau élevé et obtient un score égal ou supérieur à reuse_threshold, et produit en brouillon tous les autres. hints-only produit en brouillon chacun de ces nœuds et ne référence aucun Component du catalogue, en enregistrant une correspondance forte comme suggestion. Toute autre valeur est lue comme hints-only. |
reuse_threshold | 0.85 | Le score à partir duquel auto-apply-above-threshold référence un Component. Lu dans ce mode uniquement ; 0 est lu comme la valeur par défaut. |
emit_hints | true | Si le fichier d’un Component produit en brouillon s’ouvre sur un commentaire nommant le Component du catalogue auquel il ressemble, pour une correspondance de niveau élevé ou moyen. L’Aggregate en brouillon porte le même commentaire au-dessus de l’entrée de ce nœud, et au-dessus d’une entrée référencée un commentaire nommant le candidat suivant le mieux classé contre lequel elle pourrait être échangée, ou disant qu’aucun n’a obtenu un score supérieur à zéro. false omet les commentaires. |
render_mode | human | human écrit les brouillons décrits ci-dessus. llm n’écrit aucun brouillon, et écrit à la place l’ensemble du registre des décisions — chaque nœud, les candidats évalués et le choix fait — sous la forme d’un document unique, import-decisions.json, destiné à être lu par un autre outil. Toute autre valeur est lue comme human. |
mapping_overrides | aucune | Des correspondances superposées à la table propre de l’importateur, ayant pour clé le format puis le type de nœud — pour l’importateur Compose, le dépôt de l’image. Chaque entrée nomme le component auquel correspond un nœud de ce type et, facultativement, sa category, les traits — des étiquettes et leurs valeurs — que porte un Component correspondant, et un mot vendor que porte son nom. Une entrée pour un type de nœud que la table fait déjà correspondre prend la place de la ligne de la table. Seules les entrées sous le format en cours d’importation sont lues. |
layout | platform | platform produit en brouillon la plateforme qui exécute le flux, portant le flux, chacune de ses parties étant un Component propre relié à la plateforme, comme le décrit La plateforme qui porte le flux. nodes produit en brouillon chaque nœud comme un Component propre, comme le décrit Nœud par nœud. Pour l’importateur Dify, platform produit en brouillon l’installation Dify portant l’application, comme le décrit Ce que devient une application. Toute autre valeur produit le brouillon comme platform, et l’importation avertit avec unknown-layout. |
empty_credentials | none | Quelles valeurs d’identifiants sont écrites vides dans le flux que porte la plateforme, comme les liste Valeurs d’identifiants que contient le flux, dans la Release que produit en brouillon l’importateur MCP, comme les liste Valeurs d’identifiants que contient un serveur, dans la Release que produit en brouillon l’importateur Compose, comme les liste Valeurs d’identifiants que contient un service, dans l’application que porte l’importateur Dify, comme les liste Valeurs d’identifiants que contient une application, dans la Release que produit en brouillon l’importateur CrewAI, comme les liste Valeurs d’identifiants que contient une déclaration, dans la Release que produit en brouillon l’importateur LangGraph, comme les liste L’environnement qu’indique une configuration, dans la Release que produit en brouillon l’importateur Google ADK, comme les liste Valeurs d’identifiants que contient une configuration, et dans la Release que produit en brouillon l’importateur Agent Framework, comme les liste Valeurs d’identifiants que contient un agent déclaratif. none n’en écrit aucune vide : chacune est reportée telle qu’écrite et nommée dans un avertissement credential-carried. marked écrit vide ce qu’un format marque comme identifiants et chaque membre de la configuration d’un serveur MCP. all écrit vides également les entrées qu’un format marque comme n’étant pas des identifiants mais qui peuvent en porter — en-têtes de requête, paramètres de requête, une requête écrite comme une ligne de commande, une entrée nommée d’après une clé. Ce que le brouillon écrit pour qu’un nœud atteigne sa connexion est écrit quoi que dise ce paramètre. Toute autre valeur arrête l’importation, qui ne produit rien en brouillon, avec unknown-empty-credentials. Un brouillon fait nœud par nœud ne lit aucune valeur, et ne lit donc pas ce paramètre. |
attach_egress_allowlist | false | true rattache la Feature core/egress-allowlist de la bibliothèque standard à chaque instance de plateforme qu’écrit le brouillon, sous le nom egress-allowlist, sans définir aucun élément de son infra, comme le décrit Ce que le brouillon laisse à la Release. false ne rattache rien. Un brouillon qui n’écrit aucune plateforme, sous layout: nodes, et le brouillon de l’importateur Dify, dont l’entrée pour l’installation Dify ne prend aucune Feature, ne rattachent rien quoi que dise ce paramètre, et, avec celui-ci à true, l’importation avertit avec feature-not-attached. Toute valeur qui n’est pas un booléen est lue comme false. |
Un paramètre qu’un importateur ne connaît pas est ignoré.
with: settings: mapping_overrides: langflow: AzureOpenAIModel: component: acme/ai-model/azure-openai category: ai-model vendor: azureCe que rapporte une importation
Chaque importateur core rapporte sous forme de diagnostics ce qu’il n’a pas pu faire, et ce qu’il a fait pour le compte de l’auteur. La commande affiche chacun sur la sortie d’erreur standard sous la forme <severity>: <message>, avant la ligne de chaque nœud ; la méthode aggrega/import de la session de l’éditeur et l’outil import de l’assistant renvoient aussi chacun avec son code.
| Code | Niveau de gravité | Rapporté lorsque |
|---|---|---|
parse-failed | halt | La source ne s’analyse pas : son parseur la refuse, et le message porte la raison donnée par le parseur. |
no-nodes | warn | La source ne contient aucun nœud que l’importateur reconnaît — pour l’importateur MCP, aucun serveur, pour l’importateur Compose, aucun service et aucun modèle, pour l’importateur CrewAI, une crew ne déclarant aucun agent, pour l’importateur LangGraph, une configuration ne déclarant aucun graphe, pour l’importateur Google ADK, une configuration racine ne déclarant aucun agent, ou aucun des fichiers que with.sources remet à une importation ne contenant de configuration racine, et pour l’importateur Agent Framework, une source ne déclarant aucun agent prompt. |
unknown-layout | warn | layout n’est ni platform ni nodes ; le flux est produit en brouillon comme platform. |
unknown-empty-credentials | halt | empty_credentials contient une valeur autre que none, marked ou all, nommée avec le paramètre ; l’importation ne produit rien en brouillon. |
platform-not-in-catalog | warn | Le catalogue du workspace ne contient aucun Component portant le nom de la plateforme, donc aucune partie n’y est reliée ; pour l’importateur Dify, aucun core/ai-agent/dify, et core/dify est assemblé malgré tout. |
part-not-placed | warn | Une partie du flux n’est reliée à aucun socket de la plateforme, avec la raison ; elle reste dans le flux. |
socket-selector-unreadable | warn | Le sélecteur que déclare un socket de la plateforme ne se lit pas, donc aucune partie n’y est reliée ; une fois pour chaque socket. |
credential-carried | warn | Une valeur d’identifiants est reportée telle qu’écrite dans le flux que porte le brouillon, ou dans la Release que produit en brouillon l’importateur MCP, Compose, CrewAI, LangGraph, Google ADK ou Agent Framework, nommée par son nœud — ou son serveur, son service, son agent ou sa configuration — et son champ, jamais par sa valeur, avec la valeur de empty_credentials qui l’écrit vide. |
credential-emptied | warn | Une valeur d’identifiants est écrite vide dans le flux que porte le brouillon, ou dans la Release que produit en brouillon l’importateur MCP, Compose, CrewAI, LangGraph, Google ADK ou Agent Framework, là où empty_credentials le demande, nommée par son nœud — ou son serveur, son service, son agent ou sa configuration — et son champ. |
carriage-returns-rewritten | warn | Les retours chariot du flux sont écrits comme des sauts de ligne, avec leur nombre. |
definition-respelled | warn | Les valeurs du flux sont écrites dans la graphie dans laquelle les outils propres de la plateforme les lisent, avec les mêmes valeurs, en indiquant lesquelles et pourquoi : les poignées d’arêtes d’un flux Langflow, écrites comme l’éditeur de Langflow les écrit. Une valeur que le brouillon écrit pour que le flux atteigne une partie, ou une valeur pouvant porter des identifiants, n’est jamais réécrite dans une autre graphie — elle reste celle du câblage, ou celle d’empty_credentials — et l’avertissement compte chaque valeur non réécrite. |
definition-not-carried | warn | Le flux n’est pas porté dans values.flow_definition, ou l’application de l’importateur Dify dans parameters.app_definition, avec la raison. |
part-reads-connection | warn | Comment le flux atteint une partie reliée par sa connexion, ou comment une connexion atteint, telle qu’elle est écrite, un nœud que le brouillon ne relie à aucun socket. |
part-address-in-flow | warn | Le flux atteint une partie reliée autrement que par sa connexion, avec la manière. |
model-not-named | warn | values.model d’une partie référencée est laissé à l’auteur, avec la raison. |
feature-attached | info | attach_egress_allowlist a rattaché core/egress-allowlist à une plateforme produite en brouillon, avec ce que la Release en définit ; une fois pour chaque instance de plateforme. |
feature-not-attached | warn | attach_egress_allowlist vaut true et le brouillon n’écrit aucune plateforme, ou assemble l’installation Dify, dont l’entrée ne prend aucune Feature, donc rien n’est rattaché. |
part-configured-in-platform | warn | Un nœud d’une application Dify nomme ce que Dify configure pour lui-même — un modèle et son fournisseur, un outil, une base de connaissances, une stratégie d’agent, un plugin — donc le brouillon ne relie aucune partie pour lui. |
dsl-version-newer | warn | Une application Dify est écrite dans une version du DSL plus récente que celle qu’écrit la version de Dify que core/ai-agent/dify exécute par défaut. |
Une importation qui reçoit une cible rapporte, après les diagnostics de l’importateur, ce qu’a trouvé la production en brouillon du Manifest : un warn nommant chaque type de composant ou de feature que le Manifest laisse sans correspondance et pourquoi, et un info lorsque la Release produite en brouillon nomme déjà un Manifest ou qu’aucune Release produite en brouillon ne le référence. Ceux-ci appartiennent à l’importation elle-même plutôt qu’à un importateur, et ne portent aucun code ; Ce qu’ajoute une cible les décrit. Chaque importation rapporte ensuite, également comme les siens, un warn pour chaque valeur que les brouillons doivent encore, nommant le fichier produit en brouillon, le chemin de la clé et sa description, et, sous --offline, lorsqu’elle a produit une Release en brouillon et ne doit rien, un info nommant l’aggrega pull à exécuter ensuite, comme le décrit Le fichier de réponses de l’importation.
Publiés avec chaque release du compilateur
Chaque release du compilateur construit les dix importateurs à partir des sources taguées et génère leurs entités Plugin à partir des importateurs eux-mêmes, de sorte que la capacité, les signatures de reconnaissance, les fonctions hôtes et la description d’une entité sont ce que rapporte son importateur. La release signe et publie les dix, importer/langflow, importer/flowise, importer/n8n, importer/mcp, importer/compose, importer/dify, importer/crewai, importer/langgraph, importer/google-adk et importer/agent-framework, à la version de la release, à côté des autres plugins core, et enregistre leurs entités avec les entités des autres plugins core pour le catalogue standard.