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

Core-Importer

Das Repository des Compilers baut zehn eigene Importer-Plugins, eines für jedes Quellformat, und veröffentlicht sie mit jedem Compiler-Release:

PluginBedientLiest
importer/langflowimport:langflowein aus Langflow exportierter Flow, als JSON
importer/flowiseimport:flowiseein aus Flowise exportierter Chatflow oder Agentflow, als JSON
importer/n8nimport:n8nein aus n8n exportierter Workflow, als JSON
importer/mcpimport:mcpdie Konfiguration eines MCP-Clients — .mcp.json, claude_desktop_config.json, .vscode/mcp.json oder .cursor/mcp.json — oder eine Serverbeschreibung der MCP-Registry, server.json, als JSON
importer/composeimport:composeeine Compose-Anwendung — compose.yaml, docker-compose.yml und ihre Überschreibungsdateien — als YAML
importer/difyimport:difyeine aus Dify in dessen DSL exportierte Anwendung, als YAML
importer/crewaiimport:crewaidie Agenten und Tasks, die ein CrewAI-Projekt deklariert — config/agents.yaml und config/tasks.yaml, als YAML, oder crew.jsonc und agents/<name>.jsonc oder ihre Schreibweisen in striktem JSON, crew.json und agents/<name>.json, als JSON mit Kommentaren
importer/langgraphimport:langgraphdie Konfiguration einer LangGraph-Anwendung, langgraph.json, als JSON, und aus einer Umgebungsdatei, die die Konfiguration nennt, allein die Namen der Variablen, wo dem Import diese Datei unter with.sources übergeben wird
importer/google-adkimport:google-adkdie Agenten, die in den Agent-Config-Dateien einer auf Google ADK gebauten Anwendung deklariert sind — root_agent.yaml und die Konfigurationen, die seine Sub-Agenten nennen — als YAML
importer/agent-frameworkimport:agent-frameworkein deklarativer Agent von Microsoft Agent Framework, ein Dokument vom Typ Prompt unter beliebigem Namen, als YAML

Jeder wird aus den eigenen Quellen des Compilers gebaut und mit der Version des Compilers versehen, sodass die mit dem Compiler in X.Y.Z veröffentlichten Importer die Version X.Y.Z melden und ihre Plugin-Entitäten sie erfassen. Anders als die unter Eingebettete Plugins aufgeführten Plugins ist keiner in das Binary kompiliert. Das Binary trägt die Plugin-Entität jedes einzelnen und den Digest des einen Moduls, das es dafür akzeptiert, sodass jeder sein Format in jedem Workspace bedient, ohne Eintrag in dessen Katalog.

Alle zehn bauen auf dem Importer-Paket des Go-Kits auf, github.com/aggrega-ai/aggrega-pdk/go/pkg/importer. Für die Importer für Langflow, Flowise und n8n gehört alles, was ein Importer unabhängig von seinem Format tut — die Components des Workspace-Katalogs gegen jeden Knoten bewerten, entscheiden, ob auf eine davon verwiesen oder eine neue entworfen wird, den Entwurf anordnen, die enthaltenen Werte der Zugangsdaten übernehmen oder sie leer schreiben, wie es eine Einstellung verlangt, die Entwürfe schreiben und die unten beschriebenen Einstellungen lesen —, zu diesem Paket, und nur das Lesen des Formats und das Wissen um die Plattform, auf der seine Flows laufen, ist jedem Importer eigen. Der MCP-Importer entwirft eine Instanz einer Component pro Server und bewertet daher nichts; er teilt mit dem Paket das Lesen der Einstellungen, die er liest, die Entscheidung über Werte der Zugangsdaten und die Konventionen, nach denen seine Entwürfe benannt und beschrieben werden, wie Der MCP-Importer beschreibt. Der Compose-Importer entscheidet über jeden Service, den er zuordnet, so wie die Flow-Importer über einen Knoten entscheiden, über dasselbe Paket, rendert seine Entwürfe wie sie und teilt den Rest wie der MCP-Importer, wie Der Compose-Importer beschreibt. Der Dify-Importer entwirft die Dify-Installation, die die Standardbibliothek zusammenstellt und die die Anwendung trägt, über den Plattform-Entwurf desselben Pakets in der Form, die er für eine Plattform annimmt, die eine ganze Installation ist, wie Der Dify-Importer beschreibt. Der CrewAI-Importer entwirft eine Instanz des CrewAI-Agenten der Standardbibliothek pro Agent, den ein Projekt deklariert, verbunden mit dem Modell, das dieser Agent nennt, und teilt den Rest wie der MCP-Importer, wie Der CrewAI-Importer beschreibt. Der LangGraph-Importer entwirft eine Instanz des LangGraph-Agenten der Standardbibliothek pro Graph, den die Konfiguration einer Anwendung deklariert, verbunden mit dem Datenspeicher, in dem sein Checkpointer den Zustand hält, und teilt den Rest wie der MCP-Importer, wie Der LangGraph-Importer beschreibt. Der Google-ADK-Importer entwirft eine Instanz des ADK-Agenten der Standardbibliothek pro Agentenbaum, den die Konfigurationen einer Anwendung deklarieren, verbunden mit dem Modell, das der Baum nennt, wenn ADK seine Anfragen an die Gemini-API sendet, und teilt den Rest wie der MCP-Importer, wie Der Google-ADK-Importer beschreibt. Der Agent-Framework-Importer entwirft eine Instanz des Agent-Framework-Agenten der Standardbibliothek pro deklarativem Agenten, verbunden mit dem OpenAI-Modell, das dieser Agent nennt — wobei jeder MCP-Server, den er nennt, in Kommentaren geschrieben wird, da der Anbieter des Modells ihn als gehostetes Tool erreicht —, und teilt den Rest wie der MCP-Importer, wie Der Agent-Framework-Importer beschreibt. Wie der Importer-Socket funktioniert und was ihm übergeben wird, ist unter Der Importer-Socket beschrieben.

Diese Seite ist die Referenz dafür, was jeder Importer liest und als Entwurf erstellt. Um ein eigenes Projekt zu importieren und das Ergebnis zu bauen, beginnen Sie bei Import, das ein Projekt von seiner Quelle bis zu einem Build führt, ein Format nach dem anderen.

Wie ein Import einen erhält

aggrega import, die Methode aggrega/import der Editor-Sitzung und das Werkzeug import des Assistenten beziehen einen Core-Importer auf dieselbe Weise. Wo der Rechner sein Modul bereits enthält — im Content-Cache des Workspace —, liest der Import es von dort, ohne dafür ein Netzwerk zu benötigen. Wo nicht, ruft der erste Import, der es benötigt, es von der Standard-Registry des Workspace ab, in der Version des Compilers, und:

  • prüft es gegen den Digest, den das Binary trägt, sodass nur das Modul läuft, das das Compiler-Release veröffentlicht hat;
  • verifiziert es, wie ein Pull ein Plugin verifiziert, das er abruft — seine Signatur gemäß der Vertrauensrichtlinie dieser Registry und die Host-Funktionen, die es verwendet, gegen die, die seine Plugin-Entität erfasst;
  • behält es im Content-Cache des Workspace, der das Einzige ist, was dafür geschrieben wird: kein Lockfile und keine Aufzeichnung vertrauenswürdiger Plugins, denn ein Import pinnt keinen Importer.

Jeder spätere Import liest es aus dem Content-Cache. Ein Modul, das die Verifizierung nicht besteht, wird zurückgewiesen, und nichts wird behalten. In einem Ordner, den kein Workspace markiert, gibt es keinen Content-Cache, in dem es behalten werden könnte, daher wird der Abruf dort zurückgewiesen, mit dem Ordner und dem Hinweis, wie ein Workspace benannt oder der Ordner zu einem gemacht wird. Das Modul wird nie von neben einer gleichnamigen Plugin-Entität in einer anderen Version in einem Katalogordner gelesen: Dieses Modul gehört zu der anderen Entität.

Wo das Modul nicht abgerufen werden kann, bricht der Import unter A plugin’s .wasm is not on this machine (Die Wasm-Datei zu einem Plugin ist nicht auf diesem Rechner) ab, nennt den Importer und seine Version und sagt, was sein Modul auf den Rechner bringt:

  • Führen Sie den Import einmal mit verfügbarem Netzwerk aus, wo der Workspace offline ist oder seine Registry nicht erreichbar war. Dieser Lauf ruft es ab, und jeder spätere Lauf ist offline.
  • Legen Sie sein Modul neben eine Plugin-Entität dieses Importers in dieser Version in einem Katalogordner, unter dem Namen, den die Meldung nennt — importer--langflow.wasm für den Langflow-Importer. Eine Katalogentität mit demselben Namen und derselben Version wie ein Core-Importer läuft an dessen Stelle, wobei ihr Modul von neben ihr gelesen wird; eine dortige Entität ohne Modul daneben läuft nicht an seiner Stelle, und der Core-Importer wird wie oben beschrieben bezogen. Wo die Registry das Modul nicht enthält oder der Workspace keine Standard-Registry nennt, ist dies die einzige Abhilfe, die die Meldung nennt.

Welcher neben Ihren eigenen Importern läuft

Die Core-Importer sind Kandidaten neben den Importern, die der Katalog Ihres Workspace enthält, nach den Regeln, nach denen jeder Importer ausgewählt wird und die Welcher Importer eine Quelle in Entwürfe umwandelt darlegt:

  • Innerhalb eines Namens läuft die höchste Version oder die Version, die ein Eintrag plugins.importer nennt.
  • Wo Ihr Katalog einen Importer anderen Namens für langflow, flowise, n8n, mcp, compose, dify, crewai, langgraph, google-adk oder agent-framework enthält, weisen zwei Importer das Format aus, und ein Import, der keinen von beiden anbindet, wird unter Nennung beider zurückgewiesen, unter A parse or import format is advertised by more than one plugin (Ein Parse- oder Importformat wird von mehr als einem Plugin ausgewiesen). Ein Eintrag plugins.importer, der den gewünschten nennt, entscheidet es.
  • Ein Importer, den Ihr Katalog mit demselben Namen und derselben Version wie ein Core-Importer enthält, mit seinem Modul neben seiner Entität, ist derjenige, der läuft, von dort gelesen.
  • Eine Plugin-Entität mit dem Namen eines Core-Importers ohne Modul daneben in ihrem Katalogordner — etwa in einem Checkout eines Katalogs, der die von einer Veröffentlichung publizierten Importer verzeichnet — ist eine, die kein Import ausführen könnte, da ihr Modul von nirgendwo sonst gelesen wird; daher ist sie kein Kandidat für die Ausführung, obwohl die Signaturen, die sie verzeichnet, weiterhin an der Erkennung einer Quelle mitwirken. In der eigenen Version des Compilers läuft an ihrer Stelle der Core-Importer. In jeder anderen Version, älter oder neuer, wird sie übergangen, und die Wahl fällt unter den Importern, die laufen können — es sei denn, ein plugins.importer-Eintrag nennt genau diese Version, oder kein lauffähiger Importer dieses Namens bietet das angefragte Format an, etwa wenn die Entität ein Format verzeichnet, das der eigene Importer des Compilers nicht verzeichnet. Dann bleibt sie ein Kandidat nach den obigen Regeln, und ein Import, der sie wählt, bricht ab und nennt den Ordner, in den ihr Modul gehört.

Welcher der eigenen Importer Ihres Katalogs auch gewählt wird, sein Modul wird von neben seiner eigenen Entität gelesen, in seiner eigenen Version: Ein Modul, das neben eine Entität desselben Namens in einer anderen Version gelegt wird, gehört zu dieser Entität.

Wie eine Quelle erkannt wird

Ein Import, der sein Format nicht mit --format nennt, wird anhand der Signaturen erkannt, die jeder Importer deklariert:

  • Langflow — eine Quelle, die sich als JSON parsen lässt und unter data.nodes ein Array trägt.
  • Flowise — eine Quelle, die sich als JSON parsen lässt, unter nodes und edges Arrays trägt und unter data.nodes nichts trägt.
  • n8n — eine Quelle, die sich als JSON parsen lässt, unter nodes ein Array und unter connections ein Objekt trägt und weder unter edges noch unter data.nodes etwas trägt.
  • MCP — eine Quelle, die sich als JSON parsen lässt, .mcp.json, claude_desktop_config.json oder .cursor/mcp.json heißt und unter mcpServers ein Objekt trägt; eine Quelle, die sich als JSON mit Kommentaren parsen lässt, wie Visual Studio Code es liest, .vscode/mcp.json heißt und unter servers ein Objekt trägt; oder eine Quelle beliebigen Namens, die sich als JSON parsen lässt und deren $schema ein Text ist, der mit https://static.modelcontextprotocol.io/schemas/ beginnt, eine Serverbeschreibung der Registry. Ein Name wird mit dem Ende des Pfads verglichen, der dem Import übergeben wird, sodass project/.vscode/mcp.json erkannt wird, während mcp.json, von innerhalb von .vscode übergeben, oder die Datei eines Clients unter einem anderen Namen durch Nennung von --format mcp importiert wird.
  • Compose — eine Quelle, die sich als YAML parsen lässt, so heißt, wie Compose standardmäßig eine Compose-Datei oder ihre Überschreibungsdatei liest — compose.yaml, compose.yml, docker-compose.yml, docker-compose.yaml, compose.override.yml, compose.override.yaml, docker-compose.override.yml oder docker-compose.override.yaml — und unter services ein Objekt trägt. Eine Compose-Datei unter einem anderen Namen wird durch Nennung von --format compose importiert.
  • Dify — eine Quelle beliebigen Namens, die sich als YAML parsen lässt, den Text app unter kind trägt und unter app.mode und unter version etwas trägt, wie es jede Anwendung tut, die Dify exportiert.
  • CrewAI — eine Quelle namens config/agents.yaml oder config/tasks.yaml, die sich als YAML parsen lässt, eine Quelle namens crew.jsonc oder crew.json, die sich als JSON mit Kommentaren parsen lässt und unter agents eine Liste trägt, oder eine Quelle namens agents/<name>.jsonc oder agents/<name>.json, die sich als JSON mit Kommentaren parsen lässt und unter role etwas trägt. Ein klassisches Projekt schlüsselt seine Agenten und seine Tasks nach Namen auf, die sein Autor wählt, daher werden seine zwei Dateien allein an ihren Namen erkannt.
  • LangGraph — eine Quelle namens langgraph.json, die sich als JSON parsen lässt und unter graphs ein Objekt trägt; oder eine Quelle beliebigen Namens, die sich als JSON parsen lässt, unter graphs ein Objekt trägt und deren $schema der Text https://langgra.ph/schema.json ist, das Schema, das LangGraph für seine Konfiguration veröffentlicht. Eine Konfiguration unter einem anderen Namen, die kein Schema nennt, wird durch Nennung von --format langgraph importiert. Keine Signatur eines Importers nennt eine Umgebungsdatei, daher öffnet das Erkennen eines Verzeichnisses keine.
  • Google ADK — eine Quelle namens root_agent.yaml, die sich als YAML parsen lässt und unter name und unter instruction etwas trägt, wie es die Konfiguration eines LlmAgent tut, oder unter agent_class einen Text und unter name etwas, wie es die jedes anderen Agenten tut. Eine Konfiguration unter einem anderen Namen wird durch Nennung von --format google-adk importiert. Keine Signatur nennt die Konfiguration eines Sub-Agenten, die beliebig heißen kann, daher öffnet das Erkennen eines Verzeichnisses keine YAML-Datei außer root_agent.yaml.
  • Agent Framework — eine Quelle beliebigen Namens, die sich als YAML parsen lässt, den Text Prompt unter kind und ein Objekt unter model trägt, wie es ein deklarativer Agent tut, der sein Modell nennt; Agent Framework lädt einen deklarativen Agenten aus der Datei, die seine Anwendung nennt, welche es auch sei, daher nennt die Signatur keine Datei. Ein deklarativer Agent, der kein Modell nennt oder seinen Typ in anderer Groß- und Kleinschreibung oder als Agent schreibt, wird durch Nennung von --format agent-framework importiert.

Eine Quelle, auf die zwei davon zutreffen, wird unter Nennung beider Formate zurückgewiesen und wird importiert, indem das richtige mit --format genannt wird. Die Importer für Langflow, Flowise, n8n und LangGraph lesen ihre Quelle über den Parser, der parse:json bedient, der MCP-Importer eine Konfiguration, die ihre Server unter servers aufführt, über den, der parse:jsonc bedient, und jede andere Quelle über den, der parse:json bedient, die Importer für Compose, Dify, Google ADK und Agent Framework über den, der parse:yaml bedient, und der CrewAI-Importer die Dateien eines klassischen Projekts über den, der parse:yaml bedient, und die anderen über den, der parse:jsonc bedient: den, den der Katalog Ihres Workspace bereitstellt, wo er einen bereitstellt, und andernfalls den Parser, den der Compiler selbst für diese Syntax mitbringt (siehe Eingebettete Plugins). Ein Import über einen von ihnen benötigt daher keinen Parser in Ihrem Katalog, und für einen solchen wird nichts abgerufen. Ein Parser, den Ihr Katalog sehr wohl bereitstellt, ist der verwendete, und der des Compilers spielt keine Rolle. Die Importer für Langflow, Flowise, n8n, Dify und Agent Framework deklarieren kein Dateimuster, daher liest jeder eine Datei, und ein Import eines Verzeichnisses über einen von ihnen wird zurückgewiesen; der MCP-Importer deklariert die vier Dateinamen der Clients, daher wird ein Verzeichnis über die Client-Konfigurationen gelesen, die es enthält; der Compose-Importer deklariert die acht Compose-Dateinamen, daher wird ein Verzeichnis über die Compose-Dateien gelesen, die es enthält; der CrewAI-Importer deklariert die sechs Namen der Deklarationen eines Projekts, daher wird das Verzeichnis eines Projekts über seine Deklarationen und nichts anderes gelesen; der LangGraph-Importer deklariert langgraph.json, daher wird das Verzeichnis einer Anwendung allein über ihre Konfiguration gelesen, und weder ihr Code noch eine Umgebungsdatei wird je gelesen; und der Google-ADK-Importer deklariert root_agent.yaml, daher wird das Verzeichnis einer Anwendung allein über ihre Wurzelkonfiguration gelesen — die Konfigurationen, die ihre Sub-Agenten nennen, erreichen den Importer nur unter dem with.sources seiner Anbindung —, und weder ihr Code noch ihre Umgebungsdatei wird je gelesen. Eine Signatur, die keine Datei nennt — die der Importer für Langflow, Flowise und n8n, die des MCP-Importers für eine Serverbeschreibung der Registry, die des LangGraph-Importers für eine Konfiguration, die ihr Schema nennt, die des Dify-Importers und die des Agent-Framework-Importers —, gilt für jede einzeln importierte Datei: Ein Import, der kein Format nennt, liest eine solche Datei als JSON und als YAML, um beide zu versuchen, gleich für welchen Importer sie bestimmt ist, über dieselben Parser — der Compiler bringt beide mit, daher wird für keinen von beiden etwas abgerufen. Eine Datei mit einem Kommentar oder einem nachgestellten Komma lässt sich nicht als JSON parsen, daher erkennt keine Signatur, die JSON liest, sie; die Signaturen des CrewAI-Importers für crew.jsonc, agents/<name>.jsonc und ihre Schreibweisen mit .json sowie die des MCP-Importers für .vscode/mcp.json lesen JSON mit Kommentaren, über den Parser, den der Compiler für diese Syntax mitbringt, wo Ihr Katalog keinen bereitstellt.

Eine Quelle, die ihr Parser zurückweist — für die Importer für Langflow, Flowise, n8n und LangGraph eine, die kein JSON ist, für den MCP-Importer eine, die kein JSON mit Kommentaren ist oder, sofern sie ihre Server nicht unter servers aufführt, kein JSON, für die Importer für Compose, Dify und Agent Framework eine, die kein YAML ist, für den CrewAI-Importer eine Deklaration, die kein YAML oder kein JSON mit Kommentaren ist, und für den Google-ADK-Importer eine Konfiguration, die kein YAML ist —, bricht den Import unter parse-failed ab, dessen Meldung den eigenen Grund des Parsers enthält. Das Format zu nennen ändert daran nichts: Der Importer fragt nach dem Baum der Quelle, und die Zurückweisung des Parsers ist die Antwort, die er erhält.

Wie ein Entwurf benannt wird

Jeder Importer gibt dem Aggregate, das er entwirft, und dem Release daneben, wo er eines entwirft, den Namen <target_namespace>/<name>. Der erste Teil ist die Einstellung target_namespace, imported, sofern Sie keine andere festlegen. <name> ist der erste der folgenden Werte, der nicht leer ist:

  • der Name, den sich die Quelle selbst gibt, in dem Feld, in dem ihr Format ihn deklariert:

    ImporterDer gelesene Name
    importer/langflowder name des Flows
    importer/flowisekeiner: Ein Export trägt keinen eigenen Namen
    importer/n8nder name des Workflows
    importer/mcpder name der Serverbeschreibung einer Registry; die Konfiguration eines Clients trägt keinen
    importer/composeder name auf oberster Ebene des Projekts, der einer Override-Datei anstelle desjenigen der Datei, die sie überschreibt, so wie Compose sie zusammenführt
    importer/difyder name der Anwendung, unter app
    importer/crewaider name der Crew in crew.jsonc oder crew.json; config/agents.yaml und config/tasks.yaml tragen keinen, da ein klassisches Projekt seine Crew in seinem Programm benennt
    importer/langgraphdie ID des Graphen, den die Konfiguration deklariert, da eine Konfiguration keinen eigenen Namen trägt
    importer/google-adkder name des Root-Agenten
    importer/agent-frameworkder name des Agenten; sein displayName wird nicht gelesen
  • der Name des Verzeichnisses, das dem Import übergeben wurde, vollständig — my.project behält seinen Punkt, geschrieben my-project —, so wie Compose ein Projekt nach dem Verzeichnis benennt, das es enthält; aggrega import . benennt das Verzeichnis, in dem es ausgeführt wird;

  • der Name der Datei, die dem Import allein übergeben wurde, ohne ihre Erweiterung;

  • flow.

Ein aus mehreren Quellen erstellter Entwurf — mehreren Compose-Projekten, Konfigurationen, Agentenbäumen oder Servern oder einer Konfiguration, die mehrere Graphen deklariert — übernimmt deren Namen nur, wenn jede von ihnen sich selbst benennt und alle gleich geschrieben sind; andernfalls übernimmt er den nächsten. Ein Name wird kleingeschrieben, jede Folge von Zeichen außer den ASCII-Buchstaben und -Ziffern als ein Bindestrich, wobei die Bindestriche an beiden Enden entfallen: Basic Prompting wird basic-prompting geschrieben und SupportAgent supportagent. Dieselbe Quelle wird bei jedem Import gleich benannt. Ein Manifest, das ein Import für ein Ziel entwirft, übernimmt den Namen des Release oder den des Aggregate, wo kein Release entworfen wird, wie Was ein Ziel hinzufügt beschreibt.

Was der Langflow-Importer liest

  • Die Knoten und Kanten unter dem Objekt data auf oberster Ebene des Flows, data.nodes und data.edges.
  • Für jeden Knoten sein Typ aus data.type des Knotens und seine Felder aus den Einträgen von data.node.template, deren Wert ein Objekt ist, das ein type trägt. Die anderen Einträge des Templates sind keine Felder.
  • Ein Feld, dessen Objekt password: true trägt, wird als Slot für Zugangsdaten entworfen und jedes andere Feld als Wertfeld. Der Name des Feldes spielt keine Rolle, und das Entwerfen eines Knotens als Component liest keinen Feldwert.
  • Eine auf der Arbeitsfläche angeheftete Notiz, ein Knoten vom Typ noteNode, wird nicht importiert, und eine Kante zu einem Knoten, der nicht importiert wird, wird verworfen.
  • Das Entwerfen der Plattform, die den Flow trägt, liest aus dem Flow außerdem: seine id auf oberster Ebene; den Wert jedes mit password: true markierten Feldes; das Feld mcp_server eines MCP-Tools-Knotens — den MCP-Server, den es nennt, und dessen Konfiguration — oder stattdessen die Felder, in denen der Knoten seinen Server hält; jede Eingabe, die Langflow nicht als Zugangsdaten markiert, die aber welche tragen kann, wie Werte von Zugangsdaten, die der Flow enthält sie aufführt; das Feld, in dem ein Knoten sein Modell nennt, und den Modellanbieter, auf dem er läuft; und die Felder, über die ein Knoten Adresse und Schlüssel eines Bestandteils erreicht, die er umschreibt. Was sie entwerfen sagt, was aus jedem wird.

Was der Flowise-Importer liest

  • Die Knoten und Kanten auf oberster Ebene des Flows, nodes und edges.
  • Für jeden Knoten sein Typ aus data.name des Knotens; seine Slots für Zugangsdaten aus den Einträgen von data.inputParams, deren type den Wert credential hat, nach ihrem name; und seine Wertfelder aus den Schlüsseln von data.inputs, ohne die, die data.inputAnchors nennt — wo ein anderer Knoten eingehend verbunden ist, was die Kante zwischen ihnen erfasst —, und ohne die Zugangsdaten.
  • Das Entwerfen eines Knotens als Component liest keinen Feldwert, und der Name von Zugangsdaten spielt keine Rolle dafür, dass es sich um Zugangsdaten handelt.
  • Eine auf der Arbeitsfläche angeheftete Notiz, ein Knoten vom Typ stickyNote, wird nicht importiert, und eine Kante zu einem Knoten, der nicht importiert wird, wird verworfen.
  • Das Entwerfen der Plattform, die den Chatflow trägt, liest aus ihm außerdem: seine id auf oberster Ebene, sofern sie eine UUID ist; die Zugangsdaten, die ein Knoten unter data.credential hält; den Wert jeder Eingabe, die die inputParams eines Knotens als vom Typ password deklarieren; FLOWISE_CREDENTIAL_ID unter den Eingaben eines Knotens sowie credential oder FLOWISE_CREDENTIAL_ID innerhalb eines Konfigurationsobjekts in beliebiger Tiefe darin; die Serverkonfiguration in der Eingabe mcpServerConfig eines Knotens; jede Eingabe, die Flowise nicht als Zugangsdaten markiert, die aber welche tragen kann, wie Werte von Zugangsdaten, die der Flow enthält sie aufführt, und das Element, in dem die Konfiguration eines Agentflows das Modell oder das Werkzeug nennt, das sie auswählt; die Eingabe modelName eines Knotens; und den Base Path eines OpenAI-Knotens, seine Eingabe basepath. Was sie entwerfen sagt, was aus jedem wird.

Was der n8n-Importer liest

  • Die nodes und die connections des Workflows, auf oberster Ebene des Exports.
  • Für jeden Knoten sein name, der ihn identifiziert — die Verbindungen von n8n benennen die Knoten, die sie verbinden, nach Namen, und die Knotennamen eines Workflows sind eindeutig —, und sein type, vollständig geschrieben, mit seinem Paket: zum Beispiel @n8n/n8n-nodes-langchain.lmChatOpenAi oder n8n-nodes-base.httpRequest. Ein Knoten ohne Namen wird durch seine id identifiziert.
  • Jede Verbindung, die der Workflow aufführt, ist eine Kante, von dem Knoten, den sie verlässt, zu dem Knoten, in den sie eintritt, gleich welchen Typs: Eine Verbindung vom Typ main trägt Daten von einem Knoten zum nächsten, und eine KI-Verbindung — ai_languageModel, ai_tool, ai_vectorStore, ai_embedding, ai_memory und die anderen — übergibt dem Knoten, in den sie eintritt, das Modell, das Werkzeug, den Store oder den Speicher, für den der Knoten steht, den sie verlässt. So oder so konsumiert der Knoten, in den eine Verbindung eintritt, den Knoten, den sie verlässt.
  • Jeder Typ von Zugangsdaten, den die credentials eines Knotens nennen, und jeder Parameter auf oberster Ebene, den n8n als Passwort markiert, wird als Slot für Zugangsdaten entworfen; jeder andere Parameter des Knotens auf oberster Ebene ist ein Wertfeld. Das Entwerfen eines Knotens als Component liest keinen Feldwert.
  • Eine auf der Arbeitsfläche angeheftete Notiz, ein Knoten vom Typ n8n-nodes-base.stickyNote, wird nicht importiert, und eine Verbindung zu einem Knoten, der nicht importiert wird, wird verworfen.
  • Das Entwerfen der Plattform, die den Workflow trägt, liest aus ihm außerdem: seine id auf oberster Ebene; alle Zugangsdaten, die ein Knoten auswählt; jeden Parameter, den n8n als Passwort markiert; die Adresse, die ein MCP-Client-Knoten aufruft; die Header und Query-Parameter, die ein Knoten mit einer Anfrage sendet, die der Workflow zusammenstellt, wie Werte von Zugangsdaten, die der Flow enthält sie aufführt; und den Parameter, in dem ein Modellknoten sein Modell nennt. Was sie entwerfen sagt, was aus jedem wird.

Was sie entwerfen

Jeder Knoten wird gegen die Components des eigenen Katalogs des Workspace bewertet und gegen nichts anderes, wie der Importer-Socket beschreibt, und jeder Importer bringt eine kurze Tabelle mit, die gängige Knotentypen seines Formats — Chat- und Embedding-Modelle, Retrieval, HTTP-Anfragen und, bei Langflow, den MCP-Tools-Knoten MCPTools, der auf core/ai-tool/mcp abgebildet wird — auf Components der Standardbibliothek abbildet. Die Tabelle von Langflow bildet außerdem dessen Language-Model-Komponente, LanguageModelComponent, das Chat-Modell, das die Starter-Flows von Langflow aufrufen, auf core/ai-model/openai ab, das Modell, das die Modellverbindung der Langflow-Plattform bedient: Der Knoten läuft auf dem Modellanbieter, den sein Feld provider nennt, standardmäßig OpenAI, und ein Knoten, der einen anderen Anbieter nennt, wird nie an diese Verbindung angebunden, wie Welche Knoten zu Teilen werden beschreibt. Die Tabelle des n8n-Importers bildet die Chat- und Embedding-Modelle von n8n ab, sein MCP-Client-Werkzeug auf core/ai-tool/mcp, seine HTTP-Anfrage-Werkzeuge, sein SerpApi-Werkzeug, seine Vektorspeicher Qdrant, PGVector, Chroma, Milvus und Weaviate sowie seine Chat-Speicher Postgres und Redis. Ein Knoten, den n8n innerhalb des Workflows selbst ausführt — ein Agent, eine Chain, ein Trigger, ein Speicher, den der Workflow in seinem eigenen Prozess hält, ein Code-Werkzeug —, gehört dem Workflow, und keine Zeile bildet ihn ab. Eine Zeile dieser Tabelle zählt nur dann für eine Übereinstimmung, wenn der Katalog des Workspace die Component enthält, die sie nennt. Der Befehl meldet eine Zeile für jeden Knoten, den er abgebildet hat, mit dem, was er gewählt hat, der Trefferebene und der Punktzahl des besten Kandidaten, und eine Zeile mit dem Wortlaut made no choice for <node id> (<node type>) für einen Knoten, dem er keine eigene Component gibt. Ein Knoten, der auf eine Component des Katalogs verweist, statt entworfen zu werden, hat keine eigene Datei: Das entworfene Aggregate nennt die Component.

Wie der Entwurf angeordnet wird, bestimmt die Einstellung layout. platform, der Standard, entwirft die Plattform, die den Flow ausführt, trägt den Flow so, wie er exportiert wurde, und gibt nur jedem Bestandteil des Flows, den ein Socket der Plattform aufnimmt, eine eigene Component — auf den Plattformen der Standardbibliothek ein Modell, einen MCP-Server oder ein anderes über HTTP erreichtes Werkzeug und einen Vektorspeicher. nodes entwirft jeden Knoten als eigene Component.

Die Plattform, die den Flow trägt

Standardmäßig schreibt ein Import:

  • aggregate.yaml — ein entworfenes Aggregate, benannt nach dem Flow, wie Wie ein Entwurf benannt wird beschreibt. Es enthält eine Instanz der Plattform, die den Flow ausführt — core/ai-agent/langflow unter dem Schlüssel langflow für einen Langflow-Flow, core/ai-agent/flowise unter dem Schlüssel flowise für einen Flowise-Flow und core/ai-agent/n8n unter dem Schlüssel n8n für einen n8n-Workflow —, die auf die Katalog-Component dieses Namens verweist. Die Instanz trägt den Flow in values.flow_definition und nennt ihn in ihrem Bezeichnerwert, flow_id bei Langflow, chatflow_id bei Flowise und workflow_id bei n8n. Jeder Bestandteil des Flows ist ein eigener Eintrag daneben, mit der Plattform unter den uses der Instanz verbunden.
  • release.yaml — ein Release-Entwurf mit demselben Namen, der dieses Aggregate nennt, mit einem Eintrag für die Plattform und einem für jeden Teil, der das Image der Plattform trägt und jedes Secret, das der Entwurf benötigt, per Referenz anbindet, wie Was der Entwurf dem Release überlässt beschreibt.
  • eine Datei unter components/ für jeden Bestandteil, den der Import entwirft, statt auf ihn zu verweisen, so geschrieben, wie das Layout Knoten für Knoten einen entworfenen Knoten schreibt.

Ist ein Ziel angegeben, entwirft der Import daneben manifest.yaml, wie Was ein Ziel hinzufügt beschreibt.

Jeder Knoten, der kein Bestandteil ist, bleibt innerhalb des Flows, den die Plattform trägt, und wird zu keiner Component. Seine Entscheidung erfasst die Kandidaten, gegen die er bewertet wurde, und wählt nichts, und seine Begründung lautet kept in the flow <platform> carries, with no Component of its own:, gefolgt vom Grund — etwa, dass keine Mapping-Zeile seinen Typ nennt und sein nächster Kandidat nur eine bestimmte Punktzahl erreichte. Der Flow behält die Kanten zwischen den Knoten; der Entwurf schreibt keine eigenen.

Der Chatflow Multiple Documents QnA von Flowise, exportiert als Multiple Documents QnA.json und ohne Einstellung und ohne Ziel importiert über einen Katalog, der die Flowise-Plattform der Standardbibliothek und ihre Components für Modell und Retrieval-Werkzeug enthält, wird als dieses Aggregate entworfen, wobei der Großteil des Flows hier ausgelassen und mit ... markiert ist:

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
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-turbo

Sein Chat-Modell ist der einzige verbundene Bestandteil; seine beiden Embedding-Modelle bleiben im Flow, da der Modell-Socket eine einzige Verbindung aufnimmt, und seine Retriever-Werkzeuge bleiben im Flow, da kein Socket der Plattform sie aufnimmt. Der Import meldet jeden davon.

Der Bezeichner des Flows ist derjenige, den der Export ihm gibt — die id auf oberster Ebene eines Langflow-Flows, die id auf oberster Ebene eines Flowise-Chatflows, sofern sie eine UUID ist, und die id auf oberster Ebene eines n8n-Workflows —, sofern dieser aus einem bis 128 Buchstaben, Ziffern, ., -, _ oder : besteht und mit einem Buchstaben oder einer Ziffer beginnt. Wo der Export keinen gibt oder einen mit einem anderen Zeichen, schreibt der Entwurf eine namensbasierte UUID, abgeleitet aus dem Namen des Formats und dem Flow, wie er getragen wird, sodass ein Flow stets einen Bezeichner ergibt, und ein Kommentar über dem Wert sagt, dass er abgeleitet wurde. Ein aus dem Editor von Flowise exportierter Chatflow trägt keine id, daher erhält er einen abgeleiteten Bezeichner.

Wo der Katalog des Workspace keine Component mit dem Namen der Plattform enthält, nennt der Entwurf die Plattform trotzdem und verbindet keinen Bestandteil mit ihr: Jeder Knoten, der ein Bestandteil gewesen wäre, bleibt im Flow und wird gemeldet, und der Import warnt, dass der Katalog keine solche Component enthält.

Welche Knoten zu Bestandteilen werden und wo jeder verbunden wird

Ein Knoten ist ein Bestandteil des Flows, wo eine Zeile der Mapping-Tabelle des Importers oder ein Eintrag mapping_overrides seinen Typ abbildet oder wo sein bester Kandidat mindestens ein Treffer der mittleren Ebene ist. Ein MCP-Tools-Knoten von Langflow ist unabhängig von seinen Punktzahlen ein Bestandteil: Er nennt den MCP-Server, den er aufruft, und dieser Server ist der Bestandteil. Ein Bestandteil wird zu einer eigenen Component, auf die verwiesen oder die entworfen wird, genau wie reuse_mode entscheidet, und wird mit dem ersten Socket der Plattform verbunden — in der Reihenfolge, in der der Katalogeintrag der Plattform ihre Sockets deklariert —, dessen Label-Selektor die Component des Bestandteils erfüllt: die Labels der Component, auf die er verweist, oder, für einen Bestandteil, den der Import entwirft, die seines besten Kandidaten, sofern dieser Kandidat mindestens ein Treffer der mittleren Ebene ist. Ein Bestandteil, dessen Component den Selektor keines Sockets erfüllt oder der keine Component hat, von der Labels gelesen werden können, bleibt im Flow, und der Import meldet ihn.

Diese Regeln schränken das ein:

  • Ein Langflow-Modell, das einen anderen Anbieter nennt, erhält keine Modellverbindung. Ein Knoten vom Typ LanguageModelComponent oder EmbeddingModel läuft auf dem Modellanbieter, den sein Feld provider nennt, oder, wo dieses leer ist, auf dem Anbieter des Modells, das sein Feld model auswählt. Die Plattform liefert ihre Modellverbindung für einen OpenAI-kompatiblen Client, daher wird ein Knoten, der einen anderen Anbieter als OpenAI nennt — worauf auch immer eine Zuordnungszeile oder ein Override ihn abbildet —, nie an den Socket model angebunden: Er wird an den nächsten Socket angebunden, den seine Component erfüllt, oder bleibt im Flow, wobei seine Entscheidung nichts wählt und keine Component für ihn entworfen wird, und der Import meldet ihn unter Nennung des Anbieters, auf dem er läuft. Ein Knoten, der keinen Anbieter auswählt, ihn über eine globale Variable nennt oder sein Modell von einem anderen Knoten übernimmt, wird wie jeder andere Teil angebunden.
  • Ein Socket, der eine einzige Verbindung aufnimmt, wird von einem Bestandteil belegt. Auf jeder Plattform nimmt der Socket model eine Verbindung auf, die die Recipes der Plattform als ein OPENAI_BASE_URL und ein OPENAI_API_KEY liefern. Wo mehrere Bestandteile darin platziert werden, belegt ihn der erste, dessen Component model.aggrega.ai/capability: generative trägt — der erste Bestandteil, wo keiner das tut —, und jeder andere bleibt im Flow, gemeldet zusammen mit dem Bestandteil, der die Verbindung belegt, und damit, wie der Flow ihn erreicht, so wie sein Knoten geschrieben ist.
  • Langflow erreicht eine Verbindung tools nur über einen MCP-Tools-Knoten, der sie nennt. Die Plattform schreibt die Adresse einer Tools-Verbindung in die Serverkonfiguration des MCP-Tools-Knotens, dessen Feld mcp_server die Verbindung nennt, sodass ein Knoten, dessen Template kein Feld mcp_server trägt — gleich welchen Typs und gleich, worauf eine Mapping-Zeile oder eine Überschreibung ihn abbildet —, nie mit dem Socket tools verbunden wird: Er wird mit dem nächsten Socket verbunden, den seine Component erfüllt, oder bleibt im Flow und wird gemeldet. Ein MCP-Tools-Knoten, der keinen Server nennt, wird mit keinem Socket verbunden und gemeldet. Ebenso einer, dessen Serverkonfiguration einen eigenen Server startet — er trägt ein command oder setzt den Modus Stdio —, und seine Meldung sagt, was zu entfernen ist, da der Build der Plattform bei einem Knoten abbricht, der einen Server nennt, auf den keine Tools-Verbindung antwortet.
  • Ein MCP-Server wird unter dem Namen verbunden, den der Flow ihm gibt. Die Knoten eines Flows, die einen Server nennen, erreichen einen Bestandteil, einmal entworfen, über eine Verbindung. Der Alias der Verbindung ist der Name des Servers, wo der Alias einer Verbindung ihn annehmen kann — Buchstaben, Ziffern, Bindestriche und Unterstriche — und keine andere Verbindung dieses Sockets unter demselben Variablennamen liefert, ihrem Alias in Großbuchstaben, wobei jedes andere Zeichen als Unterstrich geschrieben wird. Andernfalls erhält die Verbindung einen aus dem Schlüssel des Bestandteils abgeleiteten Alias, der Server des Knotens wird in dem Flow, den der Entwurf trägt, in diesen Alias umbenannt, und die Entscheidung des Bestandteils sagt dies.

Die Entscheidung eines verbundenen Bestandteils sagt, mit welchem Socket der Plattform er verbunden ist und über welche Verbindung, und nennt jeden Socket, für den er übergangen wurde, und warum.

Wie der getragene Flow jeden Bestandteil erreicht

Wo das Format es zulässt, erreicht der Flow, den die Plattform trägt, jeden verbundenen Bestandteil über dessen Verbindung, und der Entwurf schreibt in den Flow, was ihn dazu bringt — den Namen einer Variablen, eine geleerte Adresse oder das, was der Knoten anstelle dessen senden würde, was die Verbindung liefert, geleert, und niemals einen Wert. Das ist Verdrahtung, nicht das Entfernen eines Werts von Zugangsdaten: Der Entwurf schreibt es unabhängig davon, was die Einstellung empty_credentials sagt, da ein dort belassener Wert überschreiben würde, was die Verbindung liefert.

  • Ein MCP-Tools-Knoten von Langflow. Die Plattform schreibt die Adresse, die ihre Verbindung liefert, in die Serverkonfiguration des Knotens und, wo die Verbindung Zugangsdaten trägt, den Namen der Variablen, die sie enthält, unter den Header, den das Werkzeug veröffentlicht. Der Entwurf schreibt die Adresse, die der Export dort enthielt, leer, sodass der Flow keine Kopie davon enthält, und überlässt die Adresse des Servers — infra.endpoint des Bestandteils — dem Release. Langflow sendet das eigene Feld headers des Knotens mit Vorrang vor den Headern seiner Serverkonfiguration, daher schreibt der Entwurf den gesamten Wert dieses Feldes leer und behält dabei seine Art bei — ein Objekt als {}, eine Liste als [], Text als leere Zeichenkette —, da ein Header, der mit geleertem Wert beibehalten wird, trotzdem gesendet würde, während ein leeres Objekt oder eine leere Liste nichts überschreibt.

  • Ein Modell- oder Vektorspeicher-Knoten von Langflow. Die Plattform liefert eine Modellverbindung als OPENAI_BASE_URL und OPENAI_API_KEY und eine Vektorspeicher-Verbindung als Variablen, die nach ihrem Alias benannt sind und die Langflow über ein Feld liest, das eine globale Variable nennt: Ein Feld, dessen Objekt load_from_db: true trägt, enthält den Namen der Variablen als seinen Wert, und Langflow liest die globale Variable dieses Namens oder, wo keine gespeichert ist, die Umgebungsvariable dieses Namens. Der Entwurf schreibt jedes dieser Felder mit dem Namen der Variablen und load_from_db: true:

    • das Feld openai_api_base eines Knotens vom Typ OpenAIModel als OPENAI_BASE_URL und sein api_key als OPENAI_API_KEY;
    • das Feld openai_api_base eines Knotens vom Typ OpenAIEmbeddings als OPENAI_BASE_URL und sein openai_api_key als OPENAI_API_KEY;
    • das Feld api_key eines Knotens vom Typ LanguageModelComponent als OPENAI_API_KEY;
    • das Feld api_base eines Knotens vom Typ EmbeddingModel als OPENAI_BASE_URL und sein api_key als OPENAI_API_KEY;
    • das Feld pg_server_url eines Knotens vom Typ pgvector als AGGREGA_VECTOR_STORE_<ALIAS>_CONNECTION_STRING, wobei <ALIAS> der Alias der Verbindung in Großbuchstaben ist, mit jedem Zeichen außer einem Buchstaben oder einer Ziffer als Unterstrich geschrieben.

    Ein Knoten vom Typ LanguageModelComponent oder EmbeddingModel läuft auf einem von mehreren Modellanbietern — dem, den sein Feld provider nennt, oder, wo dieses leer ist, dem Anbieter des Modells, das sein Feld model auswählt — und übergibt seinen Schlüssel diesem Anbieter. Die Plattform liefert die Modellverbindung für einen OpenAI-kompatiblen Client, daher wird ein solcher Knoten nur dort mit den Variablen geschrieben, wo er auf OpenAI läuft. Einer, der auf einem anderen Anbieter läuft, wird nie angebunden, wie oben beschrieben; einer, der keinen auswählt, seinen Anbieter über eine globale Variable nennt oder sein Modell von einem anderen Knoten übernimmt, wird mit keiner von ihnen geschrieben, sodass der Entwurf niemals einen anderen Anbieter auf den Schlüssel der Verbindung verweist. Wo kein Feld eines solchen Knotens die Adresse seiner API angibt — ein Knoten vom Typ LanguageModelComponent enthält für OpenAI keine, und das Feld api_base eines Knotens vom Typ EmbeddingModel kann fehlen oder leer sein, wo es keine Variable nennen kann —, übernimmt der OpenAI-Client, auf dem er läuft, OPENAI_BASE_URL aus der Umgebung, sodass der Knoten die Adresse, die die Plattform liefert, trotzdem erreicht.

    Der Client eines Knotens vom Typ OpenAIEmbeddings sendet seine default_headers mit Vorrang vor denen, die er aus dem Schlüssel bildet, und führt seine default_query mit Vorrang in die Query der Adresse zusammen, die er aufruft, daher wird auf einem solchen Knoten, den der Entwurf verbindet, der gesamte Wert von beiden leer geschrieben und seine Art beibehalten, wie es die headers eines MCP-Tools-Knotens werden.

    Ein Feld, das der Export ohne diese beiden Elemente schreibt, wird nicht neu geschrieben — ein Feld für Zugangsdaten darunter wird wie geschrieben übernommen oder leer geschrieben, wo die Einstellung es verlangt, wie unten beschrieben. Wo dieses Feld dasjenige ist, das die Adresse des Bestandteils trägt — und, bei einem Knoten vom Typ LanguageModelComponent oder EmbeddingModel, eine angibt —, wo ein solcher Knoten nicht auf OpenAI läuft oder wo der Knoten von einem anderen Typ ist, meldet der Import den Bestandteil als unter der Adresse erreicht, die der Flow oder die Standardwerte seiner Komponente angeben.

  • Ein OpenAI-Knoten von Flowise. Der OpenAI-Client, auf dem Flowise einen Knoten vom Typ chatOpenAI oder openAIEmbeddings ausführt, liest OPENAI_BASE_URL und OPENAI_API_KEY aus der Umgebung, wo der Base Path des Knotens leer ist und er keine Zugangsdaten auswählt, daher schreibt der Entwurf einen Base Path, den der Export enthält, leer und ebenso die Zugangsdaten, die der Knoten auswählt, unter data.credential. Dieser Client sendet die Standard-Header des Knotens, seine baseOptions, mit Vorrang vor dem Header, den er aus dem Schlüssel bildet, daher schreibt der Entwurf ihren gesamten Wert leer und behält seine Art bei. Ein Modellknoten eines anderen Typs wird als unter der Adresse erreicht gemeldet, die der Chatflow oder seine eigenen Standardwerte angeben.

  • Ein Werkzeug oder Vektorspeicher von Flowise. Ein Chatflow liest die Adresse, die die Plattform für eines davon liefert — AGGREGA_TOOL_<ALIAS>_URL oder AGGREGA_VECTOR_STORE_<ALIAS>_URL —, nur über eine Runtime-Variable dieses Namens, die beim Start nichts anlegt. Der Entwurf schreibt nichts dafür, und der Import meldet den Schritt, der den Chatflow sie lesen lässt: die Runtime-Variable auf der Seite Variables von Flowise anlegen und sie im Knoten als $vars.<name> lesen.

  • Jeder n8n-Knoten. Die Plattform liefert eine Modellverbindung als OPENAI_BASE_URL und OPENAI_API_KEY und eine Tools- oder Vektorspeicher-Verbindung als AGGREGA_TOOL_<ALIAS>_URL oder AGGREGA_VECTOR_STORE_<ALIAS>_URL, während ein n8n-Knoten ein Modell, einen Speicher oder einen Dienst unter der Adresse erreicht, die die gespeicherten Zugangsdaten angeben, die er auswählt, oder unter der Adresse, die seine eigenen Parameter enthalten, und ein Workflow eine Umgebungsvariable nur über einen Ausdruck liest, der $env liest, was die Plattform ablehnt, es sei denn, das Aggregate setzt values.allow_env_access_in_nodes auf true. Der Entwurf belässt diesen Wert auf seinem Standardwert false, da sein Setzen jedem Workflow und jedem Benutzer, der einen bearbeiten kann, erlaubt, jede Variable der Umgebung der Plattform zu lesen, die gelieferten Zugangsdaten eingeschlossen. Daher schreibt der Entwurf für eine Verbindung nichts in den Workflow, und jeder verbundene Bestandteil wird als anders als über sie erreicht gemeldet. Ein MCP-Client-Knoten erreicht seinen Server unter der Adresse, die der Workflow enthält — so, wie der Export sie geschrieben hat, oder keiner, wo die Einstellung empty_credentials sie leer schreibt, wie unten beschrieben —, und die eigene Adresse des Servers — infra.endpoint des Bestandteils — wird dem Release überlassen.

Wo der Flow getragen wird, wird jeder verbundene Bestandteil damit gemeldet, welcher dieser Fälle zutrifft: part-reads-connection, wo der Flow den Bestandteil über dessen Verbindung erreicht, und part-address-in-flow, wo er den Bestandteil anders als über dessen Verbindung erreicht — unter einer Adresse, die der Flow enthält, oder einer, die die Standardwerte seiner Komponente angeben. Die Entscheidung des Bestandteils sagt dasselbe.

Ein Knoten, den der Entwurf mit keinem Socket verbindet, kann so, wie der Knoten geschrieben ist, dennoch von einer Verbindung erreicht werden, die der Entwurf sehr wohl verbindet: Ein OpenAI-Client ohne eigene Adresse und ohne eigenen Schlüssel liest die OPENAI_BASE_URL und den OPENAI_API_KEY, die die Plattform für die Modellverbindung liefert, aus seiner Umgebung. Wo das der Fall ist, schreibt der Entwurf den Knoten wie einen verbundenen, sodass nichts, was er enthält, anstelle dessen gesendet wird, was die Verbindung liefert, und meldet ihn mit part-reads-connection:

  • ein Knoten vom Typ OpenAIEmbeddings von Langflow, dessen Adressfeld die Variable OPENAI_BASE_URL nennt, die die Plattform liefert, gelesen als globale Variable, während ein Bestandteil mit dem Modell-Socket verbunden ist: seine default_headers und default_query;
  • ein Knoten vom Typ chatOpenAI oder openAIEmbeddings von Flowise, dessen Base Path leer ist und der keine Zugangsdaten auswählt, sowie die Konfiguration eines solchen Modells, die ein Agentflow-Knoten unter seinen Eingaben hält, während ein Bestandteil mit dem Modell-Socket verbunden ist: seine baseOptions.

Auf jedem anderen Knoten sind diese Werte keine Verdrahtung: Sie werden wie geschrieben übernommen oder leer geschrieben, wo die Einstellung es verlangt, wie der nächste Abschnitt sagt.

Werte von Zugangsdaten, die der Flow enthält

Bevor der Flow getragen wird, ermittelt der Import jeden Wert darin, der Zugangsdaten tragen kann, an den unten aufgeführten Stellen, jeden von einer von drei Arten: was ein Format als Zugangsdaten markiert; ein Element der Konfiguration eines MCP-Servers, wo immer ein Format eine hält; und eine Eingabe, die ein Format nicht als Zugangsdaten markiert, die aber dennoch welche tragen kann — Anfrage-Header, Query-Parameter, eine ganze Anfrage, als Befehlszeile geschrieben, eine Eingabe, die Zugangsdaten unter dem Namen von Zugangsdaten enthält.

Standardmäßig schreibt der Import keinen davon leer: Der Flow wird so getragen, wie er exportiert wurde, und jeder ermittelte Wert, der etwas enthält — keine leere Zeichenkette und nicht null —, wird in einer Warnung credential-carried genannt, über seinen Knoten und sein Feld — ein Header oder ein Query-Parameter über seinen Namen —, niemals über seinen Wert oder einen Teil davon, zusammen mit dem Wert der Einstellung empty_credentials, der ihn leer schreibt. Die Einstellung schaltet das Entfernen ein: marked schreibt leer, was ein Format als Zugangsdaten markiert, sowie jedes Element der Konfiguration eines MCP-Servers; all schreibt zusätzlich die Eingaben leer, die als keine markiert sind. Jeder Wert, den sie leer schreibt, wird mit credential-emptied gemeldet, über seinen Knoten und sein Feld, niemals über seinen Wert; ein bereits leerer Wert oder null bleibt, wie er ist, und wird nicht gemeldet. Ein Wert, den die Einstellung nicht annimmt, bricht den Import ab, der nichts entwirft, statt als none zu gelten.

Ein ermittelter Wert, der eine Variablenreferenz und nichts anderes ist, enthält keinen eigenen Wert: der bloße Name einer Variablen, ${NAME} — eine vordefinierte Variable wie ${workspaceFolder} oder ${userHome} eingeschlossen — oder eine der Formen, die die MCP-Clients definieren, ${env:NAME} und ${input:id}. Was auch immer die Einstellung sagt, er wird wie geschrieben übernommen und in keiner Warnung genannt, gleich in welchem Format der Flow vorliegt, so wie der MCP-Importer einen schreibt. Ebenso ein Element, das eine einzelne Referenz innerhalb eines Werts ist, den ein Format als Text hält, etwa ein mcpServerConfig von Flowise, als JSON-Text geschrieben, oder Header und Query-Parameter, die auf Flowise und n8n als JSON-Objekt in Text gehalten werden: Leer geschrieben, behält der Text dieses Element wie geschrieben bei.

Eine Referenz, die nach einem Operator Text trägt, enthält diesen Text, der ein Schlüssel sein kann, ob vor dem Operator ein Doppelpunkt steht oder nicht: ein Standardwert, ${NAME:-value} oder ${NAME-value}; eine Alternative, ${NAME:+value} oder ${NAME+value}; eine Meldung, ${NAME:?message} oder ${NAME?message}; eine Zuweisung, ${NAME:=value} oder ${NAME=value}. Sie wird wie jeder andere Wert ermittelt — standardmäßig übernommen und in einer Warnung credential-carried genannt, leer geschrieben, wo die Einstellung es für ihre Art verlangt —, und ebenso jeder andere Text innerhalb von ${…}, etwa ${config:name}, und Text neben einer Referenz, etwa --key=${NAME}.

Was der Entwurf schreibt, damit ein Knoten seine Verbindung erreicht — eine leer geschriebene Adresse, der Name einer Variablen, ausgewählte Zugangsdaten oder leer geschriebene Standard-Header, wie Wie der getragene Flow jeden Bestandteil erreicht beschreibt —, ist Verdrahtung: Es wird unabhängig davon geschrieben, was die Einstellung sagt, damit gemeldet, wie der Knoten seine Verbindung erreicht, und niemals als Wert von Zugangsdaten gemeldet. Was außerhalb aller unten aufgeführten Stellen liegt, hat der Autor zu prüfen, wie das Ende dieses Abschnitts sagt.

Was ein Format als Zugangsdaten markiert — leer geschrieben unter marked und all:

  • Langflow — der Wert jedes mit password: true markierten Template-Feldes, ein Feld, das den Namen einer globalen Variablen enthält, eingeschlossen, es sei denn, der Entwurf schreibt dieses Feld mit dem Namen der Variablen, die die Plattform liefert, wie oben beschrieben.
  • Flowise — die Zugangsdaten, die ein Knoten unter data.credential hält und die sein Parameter für Zugangsdaten auswählt; der Wert jeder Eingabe, die seine inputParams vom Typ password deklarieren; und FLOWISE_CREDENTIAL_ID unter den Eingaben eines Knotens sowie credential oder FLOWISE_CREDENTIAL_ID innerhalb eines Konfigurationsobjekts in beliebiger Tiefe darin, so wie ein Agentflow die eines Modells oder eines Werkzeugs hält.
  • n8n — die id jeder gespeicherten Zugangsdaten, die ein Knoten auswählt, unter credentials.<type>.id. Ein n8n-Export hält Zugangsdaten als Referenz, niemals ihren Wert, und der name der Referenz wird nicht ermittelt: n8n löst beim Importieren des Workflows auf einer anderen Instanz Zugangsdaten, deren id es nicht hat, über ihren Typ und ihren Namen auf. Zugangsdaten, die ein älterer Export allein über ihren Namen auswählt, nennen Zugangsdaten und enthalten keine, und werden nicht ermittelt. Und der Wert jedes Parameters, den n8n in den Definitionen seiner Basisknoten als Passwort markiert — etwa das secret des Crypto-Knotens oder das password der Knoten, die einen Benutzer anlegen —, wo auch immer er unter den Parametern des Knotens steht, wobei ein als Werkzeug eines Agenten verwendeter Knoten als der Knoten gelesen wird, der er ist.

Die Konfiguration eines MCP-Servers — leer geschrieben unter marked und all:

  • Die Konfiguration mcp_server eines MCP-Tools-Knotens von Langflow und die mcpServerConfig eines Flowise-Knotens, als JSON-Text oder als Objekt geschrieben: jeder Header-Wert, ob die Header ein Objekt, Zeilen aus einem Schlüssel und einem Wert oder ganz zusammengeführte Objekte sind, wobei ein Element anderer Art als Ganzes ermittelt wird; jeder Umgebungswert; die Adresse des Servers; der Befehl; und jedes Argument. Keines der beiden Formate markiert eine Adresse, einen Befehl oder ein Argument als Zugangsdaten, und jedes kann einen Schlüssel tragen — eine Adresse in ihrem Benutzerteil, ihrem Pfad oder ihrer Query —, daher werden auch alle drei ermittelt, auf beiden Formaten. Leer geschrieben, behalten der Befehl und jedes Argument ihre Elemente, sodass eine Konfiguration, die einen eigenen Server startet, weiterhin als eine solche gelesen wird. Wo ein MCP-Tools-Knoten von Langflow mit einer Tools-Verbindung verbunden ist, ist seine Adresse Verdrahtung, wie oben beschrieben, und wird niemals als Wert von Zugangsdaten gemeldet. Eine als Text geschriebene Flowise-Konfiguration, die sich nicht als JSON-Objekt lesen lässt, wird als Ganzes ermittelt, da sich darin nichts ermitteln lässt.
  • Ein MCP-Tools-Knoten von Langflow, der kein Feld mcp_server trägt, hält seinen Server stattdessen in eigenen Feldern — die Adresse in sse_url, die Header in headers_input, die Umgebung in env und die ganze Befehlszeile samt ihren Argumenten in command —, und Langflow markiert auch keines davon als Zugangsdaten, daher werden jeder Header-Wert, jeder Eintrag von env, die Adresse und die Befehlszeile ermittelt, wobei ihre Felder und Einträge beim Leerschreiben erhalten bleiben. Wo env eine Liste ist, wird jeder Eintrag über seine Position gemeldet, da sich der Name einer Variablen und ihr Wert einen Text teilen. Ein solcher Knoten nennt keinen MCP-Server, daher wird er niemals mit einer Tools-Verbindung verbunden.
  • Das eigene Feld headers eines MCP-Tools-Knotens von Langflow, das Langflow mit Vorrang vor den Headern seiner Konfiguration an den Server sendet, auf einem Knoten, den der Entwurf nicht verbindet: sein gesamter Wert, leer geschrieben unter Beibehaltung seiner Art, wie auf einem verbundenen Knoten, und einmal gemeldet, als headers.
  • Die Komponenten MCP Tools (SSE) und MCP Tools (stdio) von Langflow, die Langflow als veraltet markiert, halten ihren Server in jeweils einem Feld — ein Knoten vom Typ MCPSse seine Adresse in url, ein Knoten vom Typ MCPStdio seine ganze Befehlszeile samt ihren Argumenten in command —, als Ganzes ermittelt. Keine von beiden nennt einen MCP-Server, daher wird keine von beiden mit einer Tools-Verbindung verbunden.
  • Ein MCP-Client-Knoten von n8n — das MCP Client Tool, das ein Agent aufruft, der Knoten MCP Client oder ein Client eines Servers, den die Registry von n8n aufführt — hält die Adresse des Servers in seinem Parameter endpointUrl, in seiner ersten Version sseEndpoint, und seine Header nur als Zugangsdaten, die er auswählt; die Adresse wird als Ganzes ermittelt, ob verbunden oder nicht.

Eine Eingabe, die ein Format nicht als Zugangsdaten markiert — leer geschrieben allein unter all:

  • Anfrage-Header — bei Langflow die headers eines Knotens vom Typ APIRequest, URLComponent, CloudflareWorkersAIEmbeddings oder ConfluentKafkaProducer und die api_headers eines Knotens vom Typ DoclingRemote; bei Flowise die headers eines Knotens vom Typ httpAgentflow, getApiChain, postApiChain, openApiChain, apiLoader, openAPIToolkit oder searXNG, die requestsGetHeaders, requestsPostHeaders, requestsPutHeaders und requestsDeleteHeaders der Requests-Werkzeuge sowie die baseOptions — die Standard-Header, die der Client eines Modells sendet — eines Knotens vom Typ azureChatOpenAI, azureOpenAIEmbeddings, chatCerebras, chatOpenAICustom, openAIEmbeddingsCustom, chatOpenRouter, chatSambanova oder openAI; bei n8n die headerParameters, jsonHeaders, headerParametersUi und headerParametersJson eines Knotens vom Typ n8n-nodes-base.httpRequest — seine aktuelle Version hält die ersten beiden, seine früheren Versionen die anderen beiden — und desselben Knotens, wenn er als Werkzeug eines Agenten verwendet wird, die parametersHeaders und jsonHeaders eines Knotens vom Typ @n8n/n8n-nodes-langchain.toolHttpRequest und die headerParametersUi eines Knotens vom Typ n8n-nodes-base.graphql. Der Name eines Headers trägt kein Geheimnis, daher wird der Wert jedes Headers ermittelt und sein Name beibehalten, welche Form die Header auch haben: ein Objekt aus Namen und Werten, Zeilen aus einem Schlüssel und einem Wert — bei n8n Zeilen aus einem name und einem value — oder Objekte, die Langflow als Ganzes in die Header zusammenführt. Jeder Header wird über seinen Namen gemeldet. Ein Element einer Liste, das keine Header-Zeile ist, wird als Ganzes ermittelt und über seine Position gemeldet. Als Text geschriebene Header werden als Ganzes ermittelt, außer bei Flowise und n8n, wo der Text Header als JSON-Objekt enthält: Dort wird der Text beim Leerschreiben an Ort und Stelle neu geschrieben, jeder Wert leer, und einmal mit den Namen der Header gemeldet, die er enthält. n8n-Text, der mit = beginnt, ist ein Ausdruck, den n8n auswertet, wenn der Workflow läuft, und wird als Ganzes ermittelt. Beim Leerschreiben wird jeder Wert geleert, auch die von Headern, die kein Geheimnis enthalten, etwa User-Agent, sodass eine importierte Anfrage mit ihnen leer gesendet wird, bis ihr Autor sie wiederherstellt.
  • Query-Parameter — bei Langflow die query_params eines Knotens vom Typ APIRequest oder GoogleSerperAPI und die search_params eines Knotens vom Typ SerpAPI, Serp, SearchAPI oder SearchComponent; bei Flowise die queryParams eines Knotens vom Typ httpAgentflow und die customParameters eines Loaders vom Typ searchApi; bei n8n die queryParameters, jsonQuery, queryParametersUi und queryParametersJson eines Knotens vom Typ n8n-nodes-base.httpRequest, ob als Werkzeug verwendet oder nicht, die parametersQuery und jsonQuery eines Knotens vom Typ @n8n/n8n-nodes-langchain.toolHttpRequest sowie die queryParameters und queryParametersJson, die ein Knoten vom Typ n8n-nodes-base.facebookGraphApi unter seinen options hält. Jeder davon wird als Query einer Anfrage gesendet, und ein Query-Parameter kann einen Schlüssel tragen — manche Such-APIs nehmen ihren als api_key in der Query entgegen —, daher wird jeder wie Header ermittelt: jeder Wert, sein Name beibehalten, welche Form die Parameter auch haben, und jeder über seinen Namen gemeldet; als Text geschriebene Parameter werden als Ganzes ermittelt, außer bei Flowise und n8n, wo der Text sie als JSON-Objekt enthält, das beim Leerschreiben an Ort und Stelle neu geschrieben und einmal mit den Namen gemeldet wird, die es enthält. Beim Leerschreiben wird jeder Wert geleert, auch die von Parametern, die kein Geheimnis enthalten, sodass eine importierte Anfrage mit ihnen leer gesendet wird — oder, von einem HTTP-Knoten von Flowise, der keinen Parameter mit leerem Wert sendet, ohne sie —, bis ihr Autor sie wiederherstellt.
  • Standard-Header und eine Standard-Query auf einem OpenAI-Knoten, den keine Verbindung erreicht — die default_headers und default_query eines Knotens vom Typ OpenAIEmbeddings von Langflow sowie die baseOptions eines Knotens vom Typ chatOpenAI oder openAIEmbeddings von Flowise, wo auch immer der Knoten steht, die Konfiguration des Modells, das ein Agentflow auswählt, eingeschlossen, wo der Entwurf den Knoten weder verbindet noch eine Verbindung findet, die ihn so, wie er geschrieben ist, erreicht; wo er das doch tut, sind sie Verdrahtung, wie oben beschrieben. Jeder wird als Ganzes ermittelt, behält leer geschrieben seine Art — ein Objekt als {}, eine Liste als [], Text als leere Zeichenkette — und wird einmal gemeldet.
  • Eine ganze Anfrage, als Befehlszeile geschrieben — das curl_input eines Knotens vom Typ APIRequest von Langflow und das curl eines Knotens vom Typ Webhook, als Ganzes ermittelt, der Standardwert des Webhooks eingeschlossen. Keines von beiden wird gelesen, wenn der Flow läuft: Das erste füllt nur die Felder des Knotens im Editor aus, das zweite zeigt ein Beispiel.
  • Eine Eingabe, die Zugangsdaten unter dem Namen von Zugangsdaten enthält — der api_key eines Knotens vom Typ OlivyaComponent von Langflow, das verification_token jeder Composio-Komponente und die mem0_config eines Knotens vom Typ mem0_chat_memory, deren gesamter Wert beim Leerschreiben seine Art behält; sowie das webhookSecret und das callbackSecret eines Knotens vom Typ startAgentflow von Flowise und das bearerToken eines Knotens vom Typ teradataMCP. Jede wird als Ganzes ermittelt. Eine Eingabe, deren Name Zugangsdaten nur ähnelt — der Name eines anderswo gespeicherten Schlüssels, ein Benutzername oder eine Option, die die Komponente als kein Geheimnis deklariert —, wird nicht ermittelt.

Abgesehen von den Werten, die die Einstellung leer schreibt, dem, was der Entwurf schreibt, damit der Flow seine Bestandteile erreicht, den Handles einer Langflow-Kante, so geschrieben, wie der Langflow-Editor sie schreibt, und den unten beschriebenen Wagenrückläufen, die als Zeilenvorschübe geschrieben werden, wird der Flow so getragen, wie er exportiert wurde: ohne all dies Byte für Byte.

Eine Verbindung im Entwurf trägt keinen Wert von Zugangsdaten: Der Release-Entwurf bindet die Zugangsdaten, die jede Verbindung vorweist, per Referenz an, wie Was der Entwurf dem Release überlässt beschreibt.

Jeder Wert, den die Einstellung wie geschrieben belässt, gelangt in den Entwurf, und der Autor prüft ihn, geleitet von den Warnungen credential-carried. Auch den Rest eines Flows erreicht keine Regel über ein Feld, daher prüft der Autor auch ihn, bevor er einen Entwurf weitergibt: den eigenen Code einer Komponente, den der Flow trägt und in dem eine benutzerdefinierte Komponente einen Schlüssel enthalten kann; Eingaben, die der Editor einem Knoten über die von seiner Komponente deklarierten hinaus hinzufügt; den Body, mit dem eine Anfrage gesendet wird, etwa den eines Knotens vom Typ APIRequest oder httpAgentflow, der ein Token tragen kann; die Argumente, die ein Knoten dem Client seines Modells oder einem Loader als ein eigenes Objekt übergibt, etwa die model_kwargs eines Knotens vom Typ EmbeddingModel von Langflow oder die additionalInputs eines Knotens vom Typ replicate von Flowise, die unter beliebigem Namen einen Schlüssel tragen können; eine Adresse außer der eines MCP-Servers, die in ihrem Benutzerteil oder ihrer Query einen Schlüssel tragen kann; den Code eines Code-Knotens von n8n sowie die Header oder die Query eines Knotens, der eine Anfrage sendet, die der Importer oben nicht aufführt; und freien Text wie einen Prompt oder eine Nachricht.

Was der Entwurf dem Release überlässt

Der Release-Entwurf trägt im Eintrag der Plattform und im Eintrag jedes Teils, was der Flow nicht liefern kann:

  • Das Image der Plattform, als infra.image: die eigene Wahl des Importers, in der Version, mit der die Recipes des Katalogs für die Plattform bekanntermaßen laufen — langflowai/langflow:1.6.0, flowiseai/flowise:3.1.3 und n8nio/n8n:1.110.1 —, unter einem Kommentar, der dies sagt. Der Import hebt oder senkt sie nie, um der Quelle zu folgen; wo der Export eine abweichende Version der Plattform angibt, wie es last_tested_version eines Langflow-Flows tut, nennt der Kommentar sie.
  • Der Port, auf dem die Plattform veröffentlicht wird, als infra.published_port, nur mit --target compose: 7860 für Langflow, 3000 für Flowise und 5678 für n8n, die Ports, auf denen jede bedient, die ihr Compose-Recipe auf der Loopback-Adresse des Hosts, 127.0.0.1, veröffentlicht. Der Kommentar darüber sagt, dass der Port nur von diesem Rechner aus erreichbar ist, für jeden Prozess, der darauf läuft, und dass das Löschen der Zeile den Dienst intern hält. Ein zweiter Flow desselben Imports erhält den nächsten Port, den kein früherer belegt. Mit jedem anderen Ziel oder ohne Ziel wird er nicht geschrieben.
  • Das eigene Secret der Plattform und die Zugangsdaten jeder Modellverbindung, per Referenz angebunden und nie als Wert: bei Langflow der Slot admin_password, gelesen, solange values.require_authentication auf true bleibt; bei Flowise der Slot owner_password, erforderlich, solange values.flow_definition gesetzt ist; und, wo ein Teil mit dem Socket model der Plattform verbunden ist, credential auf dieser Verbindung. Die n8n-Plattform nimmt kein eigenes Secret. Wie jedes angebunden wird, hängt vom Ziel ab, wie Secrets, je Ziel beschreibt.
  • Jeder Wert, den keine Quelle enthält, als leere Zeichenkette unter einem Kommentar geschrieben, der sagt, was er ist: bei Flowise infra.owner_email, die E-Mail-Adresse des Eigentümerkontos, erforderlich, solange values.flow_definition gesetzt ist; und die Adresse jedes mit der Plattform verbundenen MCP-Servers, infra.endpoint seines Teils. Jeder ist ein Wert, den der Import schuldet, beantwortet wie in Die Antwortdatei des Imports beschrieben.

Die Zugangsdaten, die eine Verbindung zu einem Werkzeug oder einem Vektorspeicher vorweist, werden nicht entworfen: Die Zugangsdaten einer solchen Verbindung halten den Build an, wo das Werkzeug keinen Header veröffentlicht, in dem sie gesendet werden können, daher nennt ein Kommentar über dem Eintrag der Plattform sie, damit Sie sie anbinden, wo das Werkzeug welche annimmt.

Geheimnisse, je nach Target

Bei --target helm ist jedes Geheimnis ein core/referenced-secret, dessen origin der Name eines Kubernetes-Secrets ist, das bereits im Namespace liegt und den Wert unter dem Datenschlüssel value enthält. Diesen Namen kann keine Quelle liefern, daher wird er leer unter einem Kommentar geschrieben, der sagt, was er enthält, und er zählt zu den Werten, die der Import schuldet; das entworfene Manifest bildet core/referenced-secret auf helm/k8s-existing-secret ab.

Bei jedem anderen Target und ohne Target ist jedes Geheimnis ein core/secret-value, dessen origin eine Referenz auf eine Variable ist — ${LANGFLOW_ADMIN_PASSWORD}, ${FLOWISE_OWNER_PASSWORD} und ${OPENAI_API_KEY} für die Zugangsdaten einer Modellverbindung —, die ein Target, das Variablenreferenzen ersetzt, wie Docker Compose beim Start des Stacks, aus der Umgebung liest, sodass keine Datei den Wert enthält und dafür nichts geschuldet wird. Der Flowise-Chatflow von oben, ohne Target importiert, wird mit diesem Release entworfen:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
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: {}

Ohne Target schuldet er zwei Werte, spec.manifest und infra.owner_email; mit --target compose nur die E-Mail-Adresse des Eigentümers; mit --target helm die E-Mail-Adresse des Eigentümers und die Namen der beiden Kubernetes-Secrets.

Beim Target compose kommt ein Geheimnis, das allein das Release anbindet, unter einem einzigen Schlüssel an, value, sodass das Passwort des Eigentümers oder des Administrators und die Zugangsdaten einer Verbindung beide darunter ankämen. Das Aggregate deklariert daher jedes mit einem eigenen Schlüssel, wo die Plattform eine Verbindung aufnimmt: owner_password mit dem Schlüssel OWNER_PASSWORD bei Flowise, admin_password mit dem Schlüssel LANGFLOW_SUPERUSER_PASSWORD bei Langflow und die credential der Modellverbindung mit dem Schlüssel OPENAI_API_KEY auf allen drei Plattformen, jeweils unter einem Kommentar, der den Grund nennt. Mit --target compose werden diese Zeilen aktiv geschrieben; ohne Target werden sie auskommentiert geschrieben, wie im Beispiel oben, damit Sie sie einkommentieren, wenn Sie für compose bauen; mit jedem anderen Target werden sie nicht geschrieben. Das Release bindet den Ursprung jedes Slots an und nennt denselben Typ oder keinen.

Mit der Einstellung attach_egress_allowlist auf true deklariert die Instanz der Plattform außerdem das Feature core/egress-allowlist der Standardbibliothek unter features, als egress-allowlist, sodass sich die Plattform nur mit den Komponenten verbindet, die ihre Verbindungen erreichen, mit ihren eigenen Pods und mit dem DNS des Clusters — das ausgehende Gegenstück zu einer Kante uses als deklarierter Aufruf. Das Aggregate deklariert den Typ der Anbindung und sonst nichts, da die Anbindung eines Aggregate kein infra trägt, und das entworfene Release schreibt nichts davon: Der Kommentar über dem Eintrag der Plattform nennt unter features.egress-allowlist.infra den Schlüssel control_plane_present, den der Betreiber auf true setzt, um zu bestätigen, dass das Netzwerk-Plugin des Clusters Netzwerk-Policies durchsetzt, ohne welche Bestätigung der Build abbricht; admitted_destinations, eine Liste mit einem Eintrag, der das Ziel und einen Adressbereich nennt, für jede Verbindung, deren Ziel der Cluster nicht ausführt, etwa ein gehostetes Modell, ohne den der Build abbricht und diese Verbindung nennt; und aggrega.ai/namespace für die Boundary, die die Plattform enthält, da die Policy im Namespace ihrer Arbeitslasten platziert wird und der Build abbricht, wo diese in keinen ausgegeben werden. Keiner dieser Schlüssel wird leer geschrieben, daher gehört keiner zu den Werten, die der Import schuldet. Die Entscheidung jedes verbundenen Bestandteils sagt, dass die Anbindung seine Verbindung zulässt, und der Import meldet die Anbindung als feature-attached. Compose hat keine Netzwerk-Policy, daher bricht ein Compose-Build eines solchen Entwurfs ab und nennt die Anbindung; wo die Plattform eine Verbindung aufnimmt, werden die oben beschriebenen Compose-Zeilen innerhalb des Blocks features der Instanz geschrieben, ohne einen zweiten Schlüssel features.

Das Modell, das ein Bestandteil bereitstellt

Ein Bestandteil, auf den der Entwurf verweist und dessen Component einen Wert namens model deklariert — wie es jede Modell-Component der Standardbibliothek tut und verlangt —, wird mit dem Namen des Modells geschrieben, das sein Knoten auswählt, als values.model:

  • Langflow — der model_name eines Knotens vom Typ OpenAIModel oder AnthropicModel; das model eines Knotens vom Typ OpenAIEmbeddings; und die Überschreibung model_name eines Knotens vom Typ LanguageModelComponent oder EmbeddingModel, wo sie gesetzt ist, und andernfalls das Modell, das sein Feld model auswählt.
  • Flowise — der modelName eines Knotens vom Typ chatOpenAI, chatAnthropic oder openAIEmbeddings.
  • n8n — der Parameter model eines Chat-, Completion- oder Embedding-Knotens, den die Tabelle des Importers abbildet, oder sein modelName bei den Knoten Google Gemini und Vertex, als Name geschrieben oder als Wert des Selektors, in dem die neueren Knoten von n8n ihn halten. n8n lässt einen auf seinen Standardwert gesetzten Parameter aus einem Export weg, daher nennt ein Knoten, der das Standardmodell beibehält, im Export keines.

Ein Release kann keinen Wert schreiben. Wo der Knoten also kein Modell nennt, das der Entwurf schreiben kann — er wählt keines aus, nennt es über eine globale Variable oder einen Ausdruck, der erst gelesen wird, wenn der Flow läuft, übernimmt es von einem anderen mit ihm verbundenen Knoten oder ist von einem Typ, dessen Modellfeld der Importer nicht liest —, überlässt ein Kommentar innerhalb des Bestandteils values.model dem Autor, und der Import meldet es mit model-not-named. Ein Bestandteil, den der Entwurf entwirft, wird ohne Wert geschrieben.

Wie der Flow in den Entwurf geschrieben wird

Der Flow wird als YAML-Literalblock geschrieben, dessen Chomping seine abschließenden Zeilenumbrüche beibehält, sodass sich values.flow_definition wieder als der eigene Text des Flows liest. Der Text eines Aggregate wird als Template gelesen, daher wird jedes {{, das der Flow enthält — ein Flowise-Chatflow schreibt {{<node id>.data.instance}} für jede Verbindung zwischen zwei Knoten —, als {{"{{"}} geschrieben, das die Interpolation wieder in die zwei geschweiften Klammern umwandelt, wie Text mit eigenen doppelten geschweiften Klammern beschreibt. Der Name eines Modells wird auf dieselbe Weise geschrieben.

Ein Literalblock kann nicht jedes Zeichen so tragen, wie es geschrieben ist:

  • Ein Wagenrücklauf — eines CR-LF-Paares oder allein stehend — wird als ein Zeilenvorschub geschrieben. Ein JSON-Dokument enthält einen nur zwischen seinen Tokens, wo jeder Leerraum gleich gelesen wird, sodass die Plattform denselben Flow liest. Der Import meldet mit carriage-returns-rewritten, wie viele es sind.
  • Jedes andere Zeichen, das ein Literalblock nicht tragen kann, verhindert, dass der Flow getragen wird: ein Zeilenumbruchzeichen — U+0085, U+2028 oder U+2029; ein Steuerzeichen außer dem Tabulator und dem Zeilenvorschub — U+0000 bis U+001F, U+007F und U+0080 bis U+009F; die Nichtzeichen U+FFFE und U+FFFF; und ein Byte, das nicht Teil einer UTF-8-Sequenz ist. values.flow_definition bleibt dann ungesetzt, mit einem Kommentar, der das sagt, der Rest wird entworfen, und der Import meldet definition-not-carried für jede Art von Zeichen, mit ihrer Anzahl im Flow sowie Zeile und Spalte des ersten.

Der Flow wird auch dort nicht getragen, wo ein Wert, den der Entwurf leer oder neu schreibt, in den Bytes des Exports nicht dort steht, wo sein geparster Baum ihn hält, und der Import meldet definition-not-carried und nennt die Stelle dieses Werts. Der Bezeichner des Flows ist dann sein eigener, wo der Entwurf ihn tragen kann, und andernfalls einer, der aus den Bezeichnern der Knoten des Flows abgeleitet ist.

Knoten für Knoten

Mit layout: nodes entwirft ein Import jeden Knoten des Flows als eigene Component und schreibt:

  • aggregate.yaml — ein entworfenes Aggregate, benannt nach dem Flow, wie Wie ein Entwurf benannt wird beschreibt, das die Knoten des Flows zusammensetzt: ein Eintrag für jeden, und jede Kante des Flows als Verbindung uses des Knotens, den sie speist, wobei ihr Socket und ihr Alias beide nach dem Schlüssel des Knotens benannt sind, der sie speist, sodass ein Knoten, der von mehreren gespeist wird, jeder Verbindung einen eigenen Alias gibt.
  • eine Datei unter components/ für jeden Knoten, den der Import entwirft — eine entworfene Component namens <target_namespace>/<category>/<name>, der Name aus dem Typ des Knotens übernommen, in Version 0.1.0, ihre Wertfelder als String-Felder eines geschlossenen Objekts values und ihre Felder für Zugangsdaten als erforderliche Slots für Zugangsdaten, deren Bereitstellung ein Recipe bestimmt.
  • release.yaml — ein Release-Entwurf gleichen Namens, der dieses Aggregate nennt, mit einem Eintrag für jeden Knoten.

Der Flow selbst wird nicht getragen, und kein Feldwert wird gelesen.

Den exportierten Flow selbst tragen

Der Standardentwurf trägt den Flow: Die Instanz der Plattform übernimmt den Export als values.flow_definition, so geschrieben, wie Wie der Flow in den Entwurf geschrieben wird beschreibt. Ein Autor, der einen Flow von Hand in ein Aggregate schreibt — in einen Knoten für Knoten angeordneten Entwurf oder in ein eigenes Aggregate —, schreibt ihn auf dieselbe Weise. Eine Component, die einen Flow so ausführt, wie er verfasst wurde, nimmt den Export als Wert entgegen — flow_definition bei core/ai-agent/langflow und core/ai-agent/flowise der Standardbibliothek —, und der Text eines Aggregate wird als Template gelesen, daher würden die doppelten geschweiften Klammern, die der Export enthält, als Template-Aktionen gelesen: Ein Flowise-Chatflow schreibt {{<node id>.data.instance}} für jede Verbindung zwischen zwei Knoten, ein Flowise-Prompt nennt eine Variable als {{question}}, und ein Langflow-Export trägt den Quellcode seiner Komponenten, in dem die geschweiften Klammern ebenfalls vorkommen können. Schreiben Sie jedes {{ im Export als {{"{{"}}, innerhalb eines Block-Skalars, und die Interpolation stellt den Text des Exports wieder her, bevor die Recipes der Component ihn lesen; Text mit eigenen doppelten geschweiften Klammern beschreibt, warum. Ein Wert von Zugangsdaten, den der Export enthält, gehört in ein Geheimnis, das das Release anbindet, nicht in das Aggregate: Schreiben Sie ihn leer, wie es der Entwurf tut, wo die Einstellung empty_credentials es von ihm verlangt.

# Aggregate fragment — a Flowise chatflow carried as exported
spec:
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": []
}

Der MCP-Importer

importer/mcp liest die MCP-Server, die die Konfiguration eines MCP-Clients aufführt, oder den einen Server, den eine Serverbeschreibung der MCP-Registry beschreibt, und entwirft jeden Server als Instanz des MCP-Werkzeugs der Standardbibliothek, core/ai-tool/mcp. Jeder Server ist ein solches Werkzeug, daher bewertet der Importer keinen Kandidaten und meldet keine Mapping-Entscheidung.

Was er liest

  • Die Konfiguration eines Clients. Die .mcp.json von Claude Code, die claude_desktop_config.json von Claude Desktop und die .cursor/mcp.json von Cursor führen ihre Server nach Namen unter mcpServers auf; die .vscode/mcp.json von Visual Studio Code führt sie unter servers auf, und eine Datei, die Server unter beiden aufführt, wird zuerst unter mcpServers gelesen. Ein Server, dessen type stdio ist oder der keinen type nennt und ein command trägt, wird über eine Befehlszeile gestartet — sein command und seine args — mit seinem env als Umgebung. Ein Server, dessen type http, streamable-http oder sse ist oder der weder einen type noch ein command nennt und eine url trägt, wird unter seiner url erreicht und erhält seine headers.
  • Eine Serverbeschreibung der Registry. Die server.json, die die MCP-Registry veröffentlicht: ihr name und ihr erstes Paket oder, wo sie keines aufführt, ihr erstes Remote. Ein npm- oder PyPI-Paket wird über die Befehlszeile gestartet, die sein Launcher — sein runtimeHint oder npx für npm und uvx für PyPI —, seine runtimeArguments, das Paket mit seiner Version, geschrieben <identifier>@<version> für npm und <identifier>==<version> für PyPI, und seine packageArguments bilden, mit seinen environmentVariables als Umgebung. Ein Positionsargument ist sein value oder sein default; ein benanntes Argument wird als <name>=<value> geschrieben, wo es eines von beiden hat, und als sein name, wo es keines von beiden hat. Ein OCI-Paket läuft aus dem Image, das sein identifier nennt. Ein Remote wird unter seiner url erreicht und erhält seine headers. Jedes andere Paket und jedes andere Remote, das die Beschreibung aufführt, wird in einem Kommentar genannt, da eine Instanz nur eines davon ausführt.

Jedes andere Element eines Servers — cwd, envFile, auth von Cursor oder ein Element, das seine Serverart nicht liest, etwa die url eines über eine Befehlszeile gestarteten Servers — wird nirgends geschrieben und in einem Kommentar über dem Eintrag des Servers im Release genannt, da kein Infrastrukturschlüssel von core/ai-tool/mcp es aufnimmt. Die inputs einer Konfiguration, die beschreiben, wonach Visual Studio Code fragt, und keinen Wert enthalten, werden nicht gelesen. Die Server, ihre Umgebung und ihre Header behalten die Reihenfolge, in der die Quelle sie schreibt, außer in einer als JSON mit Kommentaren gelesenen Konfiguration, die die Reihenfolge behält, in der ihr geparster Baum sie schreibt: die Namensreihenfolge (siehe Eine Konfiguration mit Kommentaren).

Ein Verzeichnis wird über die Client-Konfigurationen gelesen, die es enthält — jede Datei, die wie eine der vier benannt ist, in beliebiger Tiefe — in der Reihenfolge ihrer Pfade, und jeder Server jeder Datei wird in ein einziges Aggregate entworfen.

Was aus einem Server wird

aggregate.yaml ist ein entworfenes Aggregate, das nach der Quelle benannt ist, wie Wie ein Entwurf benannt wird beschreibt, und eine Instanz von core/ai-tool/mcp pro Server enthält. Eine Instanz ist nach dem Namen ihres Servers geschlüsselt, in Kleinbuchstaben, wobei jede Folge von Zeichen außer Buchstaben und Ziffern als ein einzelner Bindestrich geschrieben wird, und mit einem numerischen Suffix, wo ein früherer Server den Schlüssel belegt hat. Wo der Schlüssel nicht der Name des Servers wie geschrieben ist oder der Import mehrere Dateien gelesen hat, nennt ein Kommentar über der Instanz den Server und die Datei, aus der er stammt. Es wird kein Agent entworfen, der sie verwendet.

Daneben ist release.yaml ein entworfenes Release desselben Namens, dessen spec.aggregate das Aggregate nennt und das für jede Instanz die betrieblichen Eingaben trägt, die die Quelle angibt:

  • für einen über eine Befehlszeile gestarteten Server infra.stdio_command, sein Befehl und dann jedes Argument, je ein Element; und infra.stdio_runtime, das Ökosystem des Launchers, npm, wo der Befehl npx, npm oder node ist, pypi, wo er uvx, uv, python oder python3 ist, und für ein Registry-Paket dessen Registry, npm oder pypi;
  • für einen unter einer Adresse erreichten Server infra.endpoint: die Adresse ohne ihren Benutzerteil, ihre Query und ihr Fragment, da die Component die Adresse ohne jeden Teil aufnimmt, der einen Schlüssel trägt; jeder Teil, den sie auslässt, wird in den Kommentar über dem Eintrag geschrieben, neben die Adresse, wie Werte von Zugangsdaten, die ein Server enthält beschreibt;
  • für ein OCI-Paket infra.image;
  • für keinen Server, bei keinem Target, infra.published_port: Der Entwurf veröffentlicht nie einen Server auf dem Host;
  • für die Umgebung eines Servers den Slot server_env, per Referenz passend zum Target des Imports angebunden. Bei --target helm ist er ein core/referenced-secret, das ein bereits im Namespace vorhandenes Kubernetes-Secret nennt, das einen Datenschlüssel pro Variable enthält, jeweils benannt wie die Variable, die er enthält; der Name des Secrets wird leer geschrieben, unter einem Kommentar, der die Datenschlüssel nennt, und er zählt zu den Werten, die der Import schuldet. Bei jedem anderen Target und ohne Target ist er ein core/referenced-secret-set mit einem Eintrag unter infra.entries pro Variable, mit dem Namen der Variable als Schlüssel und ihrem Wert so, wie die Quelle ihn schreibt, sodass eine Variablenreferenz wie ${GITHUB_TOKEN} eine Referenz bleibt, die ein Target, das Variablenreferenzen ersetzt, aus der Umgebung liest.

Was die Quelle nicht angibt, wird leer geschrieben, unter einem Kommentar, der sagt, was es ist: Ein Befehl, dessen Launcher in keinem der beiden Bridge-Images enthalten ist, lässt infra.stdio_runtime leer, und es zählt zu den Werten, die der Import schuldet; ein Argument, das eine Registry-Beschreibung ihrem Benutzer überlässt, wird als leeres Element geschrieben, und eine Variable, deren Wert die Quelle nicht schreibt, als Eintrag mit leerem Wert, jeweils im Kommentar über dem Eintrag genannt.

Wie jedes entworfene Release schreibt es metadata.environment als development, unter einem Kommentar, der sagt, dass dies ein zu ändernder Standardwert des Entwurfs ist, und ohne Target spec.manifest als leere Zeichenkette, die der Import schuldet. Ist ein Target gegeben, entwirft der Importer das Manifest selbst, da der Katalog core/ai-tool/mcp über mehrere Recipes realisiert und nur der Importer weiß, wie jeder Server läuft: Er bildet jeden Server über seinen Schlüssel, unter mappings.components.name, auf die Realisierung des Targets für die Art ab, wie der Server läuft — mcp-stdio-bridge für eine Befehlszeile, mcp-remote für eine Adresse, mcp für ein Image, etwa helm/mcp-stdio-bridge oder compose/mcp-remote — und den Geheimnistyp, als der die Umgebung angebunden ist, auf seine Realisierung, helm/k8s-existing-secret bei helm und compose/dotenv-secret-set bei compose. Der Import vervollständigt dieses Manifest und nennt es im Release, wie Was ein Target hinzufügt beschreibt.

Eine .mcp.json von Claude Code, die einen über HTTP erreichten Server und einen mit npx gestarteten aufführt:

{
"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}" }
}
}
}

wird entworfen als:

aggregate.yaml
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
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/mcp
release.yaml
apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
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}"

Mit --target helm importiert, bindet das Release derselben Konfiguration die Umgebung als das Secret an, das es nennt, und das Manifest, das der Importer entwirft, bildet jeden Server über seinen Schlüssel ab:

# 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: ""
manifest.yaml
apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/mcp
version: 0.1.0
spec:
mappings:
components:
type: {}
name:
api-server: helm/mcp-remote
github: helm/mcp-stdio-bridge
features:
type:
core/referenced-secret: helm/k8s-existing-secret

Werte von Zugangsdaten, die ein Server enthält

Jeder Wert der Konfiguration eines Servers, den das Release schreibt — der Wert jedes Headers, jedes Element seiner Befehlszeile, seine Adresse, jeder Teil der Adresse, den infra.endpoint auslässt, und jeder Umgebungswert —, kann einen Schlüssel tragen, und kein Client markiert einen davon als Zugangsdaten, daher ermittelt der Import jeden als Element der Konfiguration eines MCP-Servers; eine mit isSecret markierte Registry-Eingabe wird als Wert ermittelt, den sein Format als Zugangsdaten markiert. Eine Registry-Eingabe — eine Umgebungsvariable oder der Header eines Remote — wird als ihr value gelesen oder als ihr default, wo sie keinen Wert schreibt. Standardmäßig wird jeder wie geschrieben in das Release übernommen und in einer Warnung credential-carried über seinen Server und seine Stelle genannt — headers.<header>, infra.stdio_command.<position>, infra.endpoint oder server_env.<variable>, und ein Teil der Adresse über die url, in der er geschrieben ist, und den Namen des Teils, wie in „url of node remote-search is carried with its query as written (die url des Knotens remote-search wird mit ihrer Query wie geschrieben übernommen)“ — niemals über seinen Wert. Mit der Einstellung empty_credentials auf marked oder all wird jeder leer geschrieben und mit credential-emptied gemeldet: ein Element der Befehlszeile als leeres Element und ein Umgebungswert als leerer Wert, jeweils im Kommentar über dem Eintrag genannt; eine Adresse als leeres infra.endpoint, das der Import schuldet; und der Wert eines Headers oder ein Teil der Adresse aus dem Kommentar ausgelassen, der dann nur den Header oder den Teil nennt. Das infra.stdio_runtime eines Clients wird vom Befehl abgelesen, wie das Release ihn schreibt, daher lässt ein leer geschriebener Befehl es ebenfalls leer, und der Import schuldet es. Bei --target helm schreibt das Release überhaupt keinen Umgebungswert: Das Secret, das der Slot server_env nennt, enthält sie.

Ein Wert, der eine Variablenreferenz und nichts anderes ist — der bloße Name ${NAME}, darunter eine vordefinierte Variable wie ${workspaceFolder}, ${env:NAME} oder ${input:id} —, enthält keinen eigenen Wert: Er wird als der Text geschrieben, der er ist, was auch immer die Einstellung sagt, und er wird in keiner Warnung genannt, so wie eine Referenz in einem Flow. Eine Umgebungsvariable, deren Wert eine solche Referenz ist, wird als Wert des Eintrags geschrieben, wobei die Referenz eine Referenz bleibt, und ein Header oder ein Teil der Adresse, dessen Wert eine solche Referenz ist, wird mit der Referenz aufgeführt, aus der er liest. Eine Referenz, die nach einem Operator Text trägt — einen Standardwert, eine Alternative, eine Meldung oder eine Zuweisung, etwa ${NAME:-value} oder ${NAME-value}, mit oder ohne Doppelpunkt —, enthält diesen Text, und ebenso Text neben einer Referenz; jeder davon wird wie jeder andere Wert ermittelt.

Kein Infrastrukturschlüssel von core/ai-tool/mcp nimmt den Wert eines Headers auf: Die Zugangsdaten eines entfernten Servers hält jeder Konsument, auf seiner Verbindung zum Werkzeug, und der Import entwirft keinen Konsumenten. Daher führt der Kommentar über dem Eintrag des Servers jeden Header auf, den die Quelle ihm sendet, neben seinem Wert wie geschrieben — eine Zeichenkette in doppelten Anführungszeichen, die sich exakt als der Text der Quelle zurücklesen lässt —, damit Sie ihn auf die Verbindung des Konsumenten verschieben, der ihn vorlegt. Ein Header, dessen Wert die Quelle nicht schreibt, etwa eine Header-Eingabe der Registry ohne Wert und ohne Standardwert, wird als ohne Wert aufgeführt. Das Image, das ein OCI-Paket nennt, wird so geschrieben, wie es ist, und ist kein Wert, den die Einstellung erreicht.

infra.endpoint nimmt die Adresse ohne jeden Teil auf, der einen Schlüssel trägt, daher werden die Teile der Adresse, die die Quelle schreibt und die es auslässt — der Benutzerteil vor dem @, die Query nach dem ? und das Fragment nach dem #, wobei alles nach dem ersten # das Fragment ist —, im selben Kommentar aufgeführt, jeder neben seinem Namen und wie geschrieben, ohne das @, ? oder #, das ihn abtrennt. Ein Konsument, der seinen Schlüssel aus der Adresse liest, liefert die ganze Adresse auf seiner eigenen Verbindung zum Werkzeug. Ein Server, der unter https://user:pw@api.example.com/mcp?key=k erreicht wird, wird ohne Einstellung entworfen als:

# 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"

und mit empty_credentials auf marked bleibt infra.endpoint dem Release überlassen, und der Kommentar führt user part und query jeweils mit ausgelassenem Wert auf.

Eine Konfiguration mit Kommentaren

Visual Studio Code liest .vscode/mcp.json als JSON mit Kommentaren, und ebenso der MCP-Importer: Seine Signatur für diese Datei liest sie über den Parser, der parse:jsonc bedient, sodass eine Konfiguration mit Kommentaren // und /* */ und nachgestellten Kommas ohne Angabe eines Formats erkannt wird, und der Importer liest jede Quelle, die ihre Server unter servers aufführt, über diesen Parser. Eine solche Konfiguration wird genau so entworfen wie dieselbe Konfiguration ohne ihre Kommentare und nachgestellten Kommas. Der Parser schreibt die Elemente eines Objekts in Namensreihenfolge, daher werden die Server einer solchen Konfiguration, ihre Umgebung und ihre Header in Namensreihenfolge entworfen, ob sie einen Kommentar enthält oder nicht; eine Befehlszeile behält ihre Reihenfolge. Die anderen Clients und die Registry lesen ihre Dateien als JSON, und ebenso der Importer: Eine .mcp.json, claude_desktop_config.json, .cursor/mcp.json oder server.json, die einen Kommentar enthält, wird von keiner Signatur erkannt und bricht, unter Nennung von --format mcp importiert, mit parse-failed und dem Grund des Parsers ab. Ein mit /* geöffneter und nie geschlossener Kommentar bleibt wie geschrieben, und der Parser weist die Datei zurück.

Die Einstellungen, die er liest

Der MCP-Importer liest target_namespace und empty_credentials, wie Einstellungen sie beschreibt, und keine andere Einstellung.

Der Compose-Importer

importer/compose liest die Services und die Modelle, die eine Compose-Datei deklariert. Er entwirft jeden Service als Instanz der Katalog-Component, der sein Image entspricht, oder des generischen Servers der Standardbibliothek, core/compute/server, der sein Image ausführt; jedes Modell als Instanz der Docker-Model-Runner-Laufzeit der Standardbibliothek, core/ai-model/docker-model-runner, wo Ihr Katalog sie enthält, und als eigene Modell-Component, wo er sie nicht enthält; und daneben ein Release, das trägt, was jeder Service für seinen Betrieb angibt.

Was er liest

  • Die Dateien. Eine allein importierte Datei wird allein gelesen. Ein Verzeichnis wird gelesen, wie Compose eines liest: In jedem Verzeichnis, das Compose-Dateien enthält, in der Reihenfolge der Pfade der Verzeichnisse, ist die erste vorhandene von compose.yaml, compose.yml, docker-compose.yml und docker-compose.yaml die Compose-Datei, und die erste vorhandene von compose.override.yml, compose.override.yaml, docker-compose.override.yml und docker-compose.override.yaml wird über sie zusammengeführt. Jede andere dieser Dateien wird nicht gelesen. Bei einem Verzeichnis, das Überschreibungsdateien und keine Compose-Datei enthält, wird seine erste Überschreibungsdatei allein gelesen. Ein Kommentar am Anfang des entworfenen Aggregate nennt die gelesenen Dateien, in der Reihenfolge, in der sie zusammengeführt werden, und die nicht gelesenen Dateien. Jeder Service und jedes Modell jedes Verzeichnisses wird in ein einziges Aggregate entworfen.
  • Die Zusammenführung. Eine Überschreibungsdatei wird zusammengeführt, wie Compose eine zusammenführt: image wird ersetzt; ports werden nach ihrer Adresse, ihrem veröffentlichten Port, ihrem Container-Port und ihrem Protokoll zusammengeführt, volumes nach ihrem Pfad im Container und environment nach dem Variablennamen, wobei ein späterer Eintrag den Platz eines früheren einnimmt und ein neuer nachfolgt; expose wird angehängt; depends_on und die models eines Service werden vereinigt, wobei endpoint_var und model_var eines Eintrags jeweils den Platz dessen einnehmen, was eine frühere Datei angibt. Bei einem Modell werden model und context_size ersetzt und runtime_flags angehängt. Die Tags !reset und !override von Compose werden nicht berücksichtigt: Ein Wert, der eines davon trägt, wird so zusammengeführt, wie der YAML-Parser ihn liest.
  • Ein Service. Sein image und ob er unter build eines baut; seine ports, expose, volumes und environment — ein Mapping oder eine Liste von Elementen NAME=value, wobei ein Name ohne Wert seinen Wert aus der Umgebung erhält, in der Compose läuft; depends_on, eine Liste oder ein Mapping; und seine models, eine Liste von Modellnamen oder ein Mapping, dessen Einträge unter endpoint_var und model_var die Variablen nennen können, unter denen die Adresse und der Bezeichner des Modells den Service erreichen. Jedes andere Element — command, healthcheck, secrets, env_file und der Rest — wird nirgends geschrieben und in einem Kommentar über dem Eintrag des Service im Release genannt.
  • Ein Modell. Jeder Eintrag der models auf oberster Ebene: sein model, der OCI-Bezeichner des Modells, seine context_size und seine runtime_flags, wie geschrieben in eine Instanz von core/ai-model/docker-model-runner übernommen, wo Ihr Katalog sie enthält, und in eine Instanz einer für es entworfenen Modell-Component, wo er sie nicht enthält; die Entscheidung des Modells sagt, welche davon, und warum. Jedes andere Element wird in einem Kommentar über seiner Instanz genannt.
  • Der Rest. Die anderen Elemente auf oberster Ebene — name, networks, volumes, secrets, configs — werden nicht gelesen, und der Kommentar am Anfang des Aggregate nennt sie.

Services, Modelle und die Umgebung eines Service behalten die Reihenfolge, in der die Datei sie schreibt. Der Baum des Parsers schreibt die Elemente eines Mappings in sortierter Reihenfolge, daher wird jene Reihenfolge aus dem Text der Datei gelesen, wo sie als Block-Mapping geschrieben sind; ein im Flow-Stil geschriebenes Mapping behält die sortierte Reihenfolge.

Welche Component ein Service ist

Der Importer ordnet einen Service über das Repository zu, das sein Image nennt: die Referenz ohne ihren Tag und ihren Digest, wobei eine Docker-Hub-Referenz in ihrer Kurzform geschrieben wird — postgres für docker.io/library/postgres:16. Er ordnet das Repository über seine Image-Tabelle zu, eine Tabelle vom Image-Repository zur Katalog-Component, für die ein Compose-Recipe des Standardkatalogs ein Image dieses Repositorys ausführt. Die Tabelle wird beim Bauen des Importers aus den Compose-Recipes und Components des Standardkatalogs erzeugt und in ihn kompiliert, daher wird bei der Ausführung eines Imports kein Recipe gelesen, und die Tabelle enthält die Labels des Standardkatalogs, was auch immer Ihr Katalog enthält; die Plugin-Entität des Importers nennt in ihrer Beschreibung die Hub-Revision, aus der die Tabelle erzeugt wurde. Von jedem Recipe liest die Tabelle die Component, die das Recipe implementiert, und das Image seines Containers namens main, wo dieses Image sein Repository in seinem eigenen Text schreibt oder ein locals-Eintrag ist, der dies tut. Ein Recipe, das das Image ausführt, das das Release vollständig nennt, oder eines, das sein Template anderweitig zusammensetzt, fügt keine Zeile hinzu, und ebenso wenig ein Image, das ein Recipe neben seinem Hauptcontainer ausführt. Zwei Recipes, die ein Repository für verschiedene Components nennen, verhindern die Erzeugung der Tabelle, sodass eine Zeile nie eine von zweien nennt. Von der Component, die eine Zeile nennt, liest die Tabelle ihre Labels so, wie sie einem Import übergeben werden — in der Version, zu der eine Referenz aufgelöst wird, die die Component ohne Version nennt, mit denen, die sie über extends erbt — und schreibt jedes Label außer component.aggrega.ai/category als ihre Merkmale in die Zeile. Ein Recipe, das eine Component implementiert, die der Standardkatalog nicht enthält, verhindert die Erzeugung der Tabelle ebenfalls.

Eine Zeile wird gelesen, wie die Tabellenzeile eines Flow-Importers gelesen wird: die Component, die Kategorie, in die ihr Name sie einordnet, ihre Merkmale und das letzte Segment ihres Namens als ihr Anbieter. Die Einstellung mapping_overrides legt sich unter dem Format compose über die Tabelle, nach Repository geschlüsselt, und ein Eintrag für ein Repository, das die Tabelle abbildet, nimmt den Platz der Zeile ein. So wird ein Image, das die Recipes des Standardkatalogs nicht nennen — Ihr eigenes oder eines, das eine Component des Katalogs unter einem anderen Repository ausführt —, durch einen Eintrag abgebildet:

with:
settings:
mapping_overrides:
compose:
bitnami/redis:
component: core/datastore/redis
category: datastore
traits:
datastore.aggrega.ai/engine: kv
vendor: redis

Ein Service, dessen Image eine Zeile abbildet, wird so entschieden, wie die Flow-Importer einen Knoten entscheiden: gegen die Components Ihres Katalogs bewertet, referenziert, wo reuse_mode auto-apply-above-threshold ist, der Standardwert, und sein bester Kandidat ein Treffer der hohen Ebene bei oder über reuse_threshold ist, und andernfalls als eigene Component entworfen, wobei die Datei der entworfenen Component mit einem Kommentar beginnt, der die Component nennt, der sie ähnelt. Eine Zeile trägt die Labels der Component, die sie nennt, daher ist dort, wo Ihr Katalog diese Component mit den Labels enthält, die der Standardkatalog ihr gibt, ein Service, den die Zeile abbildet, ein Treffer der hohen Ebene für sie, mit der Punktzahl 0.90, und auto-apply-above-threshold verweist beim standardmäßigen reuse_threshold auf sie. Eine Component, deren Labels Ihr Katalog geändert hat, erzielt eine niedrigere Punktzahl, im Verhältnis zum Anteil der Merkmale der Zeile, die sie nicht mehr trägt, und wird nur referenziert, solange sie in der hohen Ebene bleibt; die Kategorie wird einmal bewertet, in ihrem eigenen Signal, nicht noch einmal als Merkmal. Services, die eine Component entwerfen, teilen sich deren eine Datei. Ein Service, dessen Image keine Zeile abbildet, dessen Image kein Repository nennt, das der Importer liest, oder der sein Image baut, ist eine Instanz von core/compute/server, was auch immer Ihr Katalog enthält. Die Entscheidung jedes Service wird gemeldet, wie die jedes Knotens gemeldet wird.

Was aus einem Service wird

aggregate.yaml ist ein entworfenes Aggregate, das nach dem Projekt benannt ist, wie Wie ein Entwurf benannt wird beschreibt, und eine Instanz pro Service enthält, der Component, die seine Entscheidung gewählt hat, geschlüsselt, wie der MCP-Importer einen Server schlüsselt, mit einem Kommentar darüber, der den Service und die Datei nennt, aus der er stammt, wo der Schlüssel nicht der Name des Service ist oder der Import mehrere Verzeichnisse gelesen hat. Jeder Service, den das depends_on eines Service nennt, ist eine Verbindung, uses: <key>: <key>: {target: <key>}, geschrieben unter einem Socket und einem Alias, die beide nach dem Schlüssel des Ziels benannt sind. Eine Komponente liest jede ihrer Verbindungen über deren Alias, gleich an welchen Socket sie angeschlossen ist, daher hat jede Verbindung eines Service einen eigenen Alias. Auch eine Variable der Umgebung eines Service kann eine Verbindung ergeben, die die Variable aus dem liefert, was der erreichte Service veröffentlicht, wie Was aus der Umgebung und dem Image eines Service wird beschreibt. Jedes Modell ist eine Instanz von core/ai-model/docker-model-runner, wo der Katalog des Workspace sie enthält, was auch immer reuse_mode sagt, und für es wird keine Component entworfen: Die Instanz schreibt model und runtime_flags, wie die Quelle sie angibt, und die context_size der Quelle als context_window, den Wert, den die Laufzeit für die Kontextlänge eines Modells deklariert und den ihr Compose-Recipe als context_size von Compose zurückschreibt. Wo der Katalog keine core/ai-model/docker-model-runner enthält, wird das Modell als <target_namespace>/ai-model/<key> entworfen, eine Component der Kategorie ai-model, deren Werte model, context_size und runtime_flags deklarieren, und seine Instanz schreibt jeden davon, den die Quelle angibt. Jedes Modell hat eine Entscheidung, die sagt, welches von beiden — mapped llm (model) to core/ai-model/docker-model-runner as a reference, NONE oder ein Entwurf, dessen Entscheidung erfasst, dass der Katalog des Workspace keine core/ai-model/docker-model-runner enthält —, und jeder Service, der das Modell nennt, wird in beiden Fällen mit ihm verbunden, wie mit einem Service, von dem er abhängt. Ein Service, der das Modell in der Langform nennt, mit endpoint_var oder model_var, nennt die Variablen, unter denen seine Adresse und sein Bezeichner den Service erreichen. Kein Schlüssel des Entwurfs enthält den Namen einer Variablen — die Verbindung wird auf einen nach dem Modell benannten Socket geschrieben, der keinen Wert deklariert, und einem Importer werden keine Infrastrukturschlüssel einer Component übergeben —, daher nennt ein Kommentar über der Verbindung jede davon, wie der Eintrag sie schreibt, und die Entscheidung des Service erfasst denselben Satz:

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: embedder

Ein Service, der das Modell in der Kurzform oder mit keiner der beiden Variablen nennt, wird ohne Kommentar mit ihm verbunden.

Daneben ist release.yaml ein entworfenes Release desselben Namens, dessen spec.aggregate das Aggregate nennt. Für eine Instanz von core/compute/server schreibt es infra.image, das Image wie geschrieben, und infra.port, den Port, auf dem der Container lauscht, im ersten Eintrag von ports oder von expose, wo ports keinen enthält. Mit --target compose schreibt es außerdem infra.published_port, den Host-Port, den derselbe Eintrag von ports veröffentlicht, wie die Quelle ihn angibt, unter dem Kommentar, dass er nur von dieser Maschine aus erreichbar ist, von jedem darauf laufenden Prozess, und dass das Löschen der Zeile den Service intern hält; ein Host-Port unter 1024, den published_port nicht aufnimmt, wird nicht geschrieben, und ein Kommentar über dem Eintrag nennt ihn. Ein Kommentar über dem Eintrag jedes Service schreibt, was die Quelle angibt und kein Schlüssel des Entwurfs trägt — das Image eines Service, der einer anderen Component zugeordnet ist, deren Tag der Entwurf nicht übersetzt, seine ports, expose, volumes und jede Variable seiner environment, die der Entwurf nicht übersetzt —, damit Sie es dorthin übernehmen, wo die Component es aufnimmt. Was der Entwurf dem Release überlässt — das Image eines Service, der keines nennt, wie es einer tut, der sein eigenes baut, und einen Port, der keine einzelne Zahl ist —, wird leer unter einem Kommentar geschrieben, der sagt, warum. Ein Build platziert nur die Instanzen, die ein Release nennt, daher hat die Instanz jedes Modells einen leeren Eintrag, <key>: {}, nach denen der Services: eine Instanz von core/ai-model/docker-model-runner, die auf Compose keine Eingabe ohne Standardwert aufnimmt, ebenso wie ein als eigene Component entworfenes Modell, sodass das entworfene Modell bereits platziert ist und sich bauen lässt, sobald Sie das Recipe schreiben, das es realisiert. Ein Port, den die Component nicht aufnimmt, etwa einer unter der Untergrenze von 1024 von core/compute/server, wird so geschrieben, wie die Quelle ihn angibt, und der Build bricht ab und nennt ihn. Das Release schreibt metadata.environment und, ohne Target, ein leeres spec.manifest, wie es das des MCP-Importers tut; mit einem Target entwirft der Import das Manifest, wie Was ein Target hinzufügt beschreibt, und ordnet jede Component dem Recipe zu, das sie auf diesem Target realisiert — core/compute/server compose/server oder helm/server und core/ai-model/docker-model-runner compose/docker-model-runner oder helm/docker-model-runner.

Eine compose.yaml, die PostgreSQL und eine eigene API ausführt, die davon abhängt:

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/0

wird, für sich allein importiert und nach der Datei benannt, da das Projekt kein name trägt, ohne Einstellung über einem Katalog, der core/datastore/postgres der Standardbibliothek enthält, entworfen als:

aggregate.yaml
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
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: db
release.yaml
apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
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: 8080

Der Import meldet mapped db (postgres) to core/datastore/postgres as a reference, HIGH at 0.9. Das Projekt enthält keinen Service cache, daher ergibt CACHE_URL keine Verbindung und bleibt im Kommentar. Mit reuse_mode: hints-only ist db stattdessen type: imported/datastore/postgres, entworfen in components/imported-datastore-postgres.yaml, das mit # resembles core/datastore/postgres (score 0.9000); reference it by setting type: core/datastore/postgres beginnt; sein Image und seine Umgebung werden dann in den Kommentar über seinem Eintrag geschrieben, da eine entworfene Component keinen der Werte deklariert, die die Recipes des Katalogs lesen. Mit --target compose ordnet das Manifest core/datastore/postgres compose/postgres und core/compute/server compose/server zu; mit --target helm helm/postgres und helm/server.

Was aus der Umgebung und dem Image eines Service wird

Wo ein Service eine Instanz der Katalog-Component ist, die die Zeile seines Images nennt, und der Katalog des Workspace diese Component enthält, liest der Importer sein Image und seine Umgebung so, wie die Compose-Recipes des Standardkatalogs für diese Component sie lesen, anhand dessen, was die Image-Tabelle zu jedem Recipe festhält, und übersetzt sie in die Entwürfe:

  • Das Tag des Images ist der Infrastrukturschlüssel, aus dem das Recipe die Image-Referenz bildet, etwa engine_version — 16 für postgres:16 —, geschrieben im Release unter einem Kommentar, der das Image der Quelle nennt.
  • Eine Variable, die das Recipe aus einem der Werte der Component setzt — POSTGRES_DB, POSTGRES_USER — und deren Wert Text enthält, ist dieser Wert der Instanz, database oder user, wo die Component des Katalogs ihn deklariert, geschrieben im Aggregate unter einem Kommentar, der die Variablen nennt.
  • Eine Variable, aus der das Recipe ein Passwort liest, etwa POSTGRES_PASSWORD, deren Wert eine einzelne Variablenreferenz ist, ist ein an diesem Slot angehängtes Geheimnis, gelesen aus der Variablen, die die Referenz nennt, und deklariert mit dem Schlüssel, unter dem das Recipe es liest.

Und für jeden Service jede Variable seiner Umgebung, die nicht so gelesen wird:

  • Ein Wert, der der Name eines anderen Service des Projekts ist, wo die Zeile dieses Service den provides-Schlüssel nennt, der seinen Hostnamen veröffentlicht, ergibt eine Verbindung zu diesem Service, deren inject-Block die Variable aus diesem Schlüssel liefert — CACHE_HOST: cache ist CACHE_HOST aus dem host des Cache.
  • Ein Wert, der einem Wert gleicht, den ein anderer Service für seine Component setzt und den die Component veröffentlicht — DATABASE_USER: notes neben einem PostgreSQL-Service, der POSTGRES_USER: notes setzt —, ergibt eine Verbindung, die die Variable aus diesem provides-Schlüssel liefert. Wo mehrere Services oder Schlüssel den Wert enthalten, wird derjenige gelesen, dessen Schlüssel oder dessen eigene Variable so endet, wie der Name der Variablen endet, und andernfalls derjenige, aus dem die anderen Variablen des Service noch nicht gelesen wurden; sonst wird die Variable nicht gelesen.
  • Ein Wert, der eine einzelne Variablenreferenz ist, die eine Variable nennt, aus der das Geheimnis eines anderen Service gelesen wird — DATABASE_PASSWORD: ${POSTGRES_PASSWORD} —, ist auf einer Instanz von core/compute/server ein eigenes Geheimnis, angehängt unter dem Namen der Variablen in Kleinbuchstaben und aus derselben Variablen gelesen, wo das Target das Geheimnis als einen Wert schreibt, den der Server aufnimmt. helm/server lehnt ein core/referenced-secret ab, daher bleibt eine solche Variable bei --target helm im Kommentar.

Jede andere Variable bleibt im Kommentar über dem Eintrag des Service, wie die Quelle sie schreibt. Die Schritt-für-Schritt-Anleitung zum Compose-Import zeigt ein Projekt, dessen API ihre Datenbank und ihren Cache auf diese Weise erreicht, gebaut und ausgeführt wie entworfen.

Werte von Zugangsdaten, die ein Service enthält

Compose markiert keinen Umgebungswert als Zugangsdaten, und der Importer liest den Namen keiner Variablen auf seine Bedeutung hin, daher wird jeder Umgebungswert, der etwas enthält, als Eingabe ermittelt, die ihr Format nicht als Zugangsdaten markiert, die aber welche tragen kann. Standardmäßig wird jeder wie geschrieben in die Entwürfe übernommen — in den Wert, in den er übersetzt wird, oder in den Kommentar über dem Eintrag seines Service im Release — und in einer Warnung credential-carried über seinen Service und seine Variable genannt — environment.<variable> — niemals über seinen Wert. Mit der Einstellung empty_credentials auf all wird jeder leer geschrieben und mit credential-emptied gemeldet: Der Kommentar nennt seine Variable ohne Wert. Bei marked wird keiner leer geschrieben, da Compose keinen markiert. Ein Wert, der eine Variablenreferenz, die Compose interpoliert, und nichts anderes ist — ${NAME} oder $NAME —, enthält keinen eigenen Wert: Er wird als der Text geschrieben, der er ist, und in keiner Warnung genannt. Eine Referenz, die einen Standardwert oder eine Meldung trägt, etwa ${NAME:-value}, enthält diesen Text und wird wie jeder andere Wert ermittelt. Ein Wert, den Compose von anderswo liest — eine env_file, die Datei eines Geheimnisses —, wird nicht gelesen.

Die Einstellungen, die er liest

Der Compose-Importer liest target_namespace, reuse_mode, reuse_threshold, emit_hints, render_mode, mapping_overrides und empty_credentials, wie Einstellungen sie beschreibt, und keine andere Einstellung. Der Hinweis, den emit_hints steuert, wird nur in die Datei der entworfenen Component geschrieben; das entworfene Aggregate trägt keinen.

Der Dify-Importer

importer/dify liest eine aus Dify exportierte Anwendung in ihrer DSL, dem YAML-Dokument, das Dify für eine Anwendung schreibt, und entwirft ein Aggregate, das die Dify-Installation der Standardbibliothek, core/dify, zusammensetzt, wobei die Anwendung im Parameter app_definition der Installation übernommen wird. Die Installation importiert sie bei der Bereitstellung, über den Schritt, den die Recipe ihres API-Servers dafür rendert.

Was er liest

  • Die Anwendung. kind, das app ist; version, die Version der DSL, in der die Anwendung geschrieben ist; und app mit seinem mode.
  • Ein Workflow oder ein Chatflow — mode workflow oder advanced-chat — hält seinen Graphen unter workflow: Jeder Knoten von workflow.graph.nodes, der seinen Typ unter data.type nennt, ist ein Knoten der Anwendung, in der Reihenfolge, in der der Graph sie aufführt, und workflow.environment_variables enthält die Variablen, die er liest.
  • Eine Chat-, Agent-Chat- oder Completion-Anwendung hält ihre Konfiguration unter model_config: Ihr model, jede Wissensdatenbank unter dataset_configs.datasets.datasets und jedes Werkzeug unter agent_mode.tools ist ein Knoten der Anwendung, benannt nach seiner Stelle dort, etwa model_config.model. Eine Anwendung im Modus agent ist ein einziger Knoten, agent.
  • Die Plugins, die sie benötigt. Auch jeder Eintrag von dependencies ist ein Knoten, benannt dependencies.<n>, vom Typ, den der Eintrag nennt, etwa marketplace.

Nichts anderes entscheidet, was entworfen wird: Die gesamte Anwendung wird übernommen.

Was aus einer Anwendung wird

aggregate.yaml ist ein entworfenes Aggregate, das nach der Anwendung benannt ist, wie Wie ein Entwurf benannt wird beschreibt, und einen Eintrag von core/dify zusammensetzt, geschlüsselt als dify, dessen Parameter app_definition die Anwendung wie geschrieben übernimmt — wie Wie der Flow in den Entwurf geschrieben wird es für einen Flow beschreibt, sodass Difys eigene Referenzen {{#…#}} die Installation so erreichen, wie sie exportiert wurden. Die Installation stellt jede Verbindung ihres API-Servers selbst her — ihre Datenbank, ihren Cache, ihren Vektorspeicher, ihre Sandbox, ihre Plugin-Laufzeit und ihren Egress-Proxy —, daher entwirft der Entwurf keine Component und verbindet nichts: Jeder Knoten bleibt in der Anwendung, und seine Entscheidung sagt das. Daneben ist release.yaml ein entworfenes Release desselben Namens, das die Installation in eine Grenze, platform, platziert und übernimmt, was die Anwendung nicht liefern kann.

Ein Import sieht die Components des Workspace-Katalogs und keines seiner Aggregates, daher prüft er nicht, ob der Katalog core/dify enthält, und ein Kommentar über dem Eintrag sagt das. Wo der Katalog kein core/ai-agent/dify enthält, den API-Server, den core/dify ausführt, warnt der Import mit platform-not-in-catalog und entwirft den Eintrag trotzdem.

Das Anwendungsgeheimnis der Installation, der Schlüssel, mit dem Dify seine Sitzungscookies signiert und unter dem es die gespeicherten Zugangsdaten der Modellanbieter verschlüsselt, ist der Parameter secret_key von core/dify, der keinen Standardwert hat. Daher deklariert der Entwurf einen eigenen Parameter secret_key — eine Zeichenkette, erforderlich, mindestens ein Zeichen lang und ohne Standardwert — und reicht ihn an jeden Eintrag von core/dify weiter, den er schreibt, damit das Release ihn unter seinen parameters erfüllt; ein Build, dessen Release ihn nicht setzt, bricht ab und nennt ihn.

Die Anwendung wird unter dem Eigentümerkonto der Installation importiert, das das Release in seinem Routing-Eintrag für die Installation nennt: infra.owner_email auf der Komponente api der Installation und den Slot owner_password auf dieser Komponente, angehängt als core/referenced-secret, ohne die der Build abbricht. Die E-Mail-Adresse des Eigentümers kann keine Quelle liefern, daher wird sie leer unter einem Kommentar geschrieben, der sagt, was sie ist, und der Import weist sie als ausstehend aus.

Auf jedem Target setzt derselbe Routing-Eintrag infra.marketplace_enabled auf den Komponenten api, worker und scheduler der Installation auf true, jeweils unter einem Kommentar, der den Grund nennt: Die Installation erreicht nichts vom Anbieter von Dify, sofern das Release es nicht erlaubt, jede der drei liest ihre eigene Einstellung, und Dify installiert das Plugin, das das Modell einer Anwendung bereitstellt, etwa das von OpenAI, aus seinem Plugin-Marketplace.

Das Anwendungsgeheimnis und das Passwort des Eigentümers sind Secrets, die per Referenz für das Target des Imports entworfen werden:

  • Bei --target helm nennt jedes ein Kubernetes-Secret, das bereits im Namespace liegt: secret_key den Namen des Secrets, das core/dify unter dem Datenschlüssel secret-key liest, und owner_password ein Secret, das das Passwort unter dem Datenschlüssel value enthält. Keinen der beiden Namen kann eine Quelle liefern, daher wird jeder leer unter einem Kommentar geschrieben, der sagt, was er ist, und der Import weist beide als ausstehend aus; das entworfene Manifest bildet core/referenced-secret auf helm/k8s-existing-secret ab.
  • Bei jedem anderen Target, und ohne Target, ist jedes eine Referenz auf eine Variable — secret_key als "${DIFY_SECRET_KEY}" und das Passwort des Eigentümers als "${DIFY_OWNER_PASSWORD}", die Namen, die die Dify-Recipes für Compose des Standardkatalogs lesen —, die Docker Compose beim Start des Stacks aus der Umgebung liest, sodass für keines von beiden etwas aussteht; bei --target compose bildet das entworfene Manifest core/referenced-secret auf compose/dotenv-referenced-secret ab.

Ist ein Target gegeben, bildet das Manifest den Typ jeder Komponente ab, die die Installation zusammensetzt, ebenso wie den des Entwurfs selbst, wie Was ein Target hinzufügt beschreibt.

Die eigens verfasste Workflow-Anwendung namens Support Answers, die die Tests dieses Importers importieren, wird ohne Einstellung entworfen als:

aggregate.yaml
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
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.
...

Mit --target helm importiert, erfüllt ihr entworfenes Release secret_key, nennt im Routing-Eintrag, der die Installation platziert, den Eigentümer und schaltet dort den Plugin-Marketplace ein, wobei jeder ausstehende Wert leer geschrieben wird:

release.yaml
apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
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: true

Der Import weist die drei leeren Werte als ausstehend aus. Mit --target compose importiert, schreibt dasselbe Release secret_key: "${DIFY_SECRET_KEY}" und origin: "${DIFY_OWNER_PASSWORD}" und weist allein die E-Mail-Adresse des Eigentümers als ausstehend aus; es schreibt außerdem infra.published_port auf der Komponente api, 5001, und auf dem Frontend, der Komponente console, 3001, jeweils unter dem Kommentar, der sagt, dass der Dienst nur von diesem Rechner aus erreichbar ist, für jeden darauf laufenden Prozess, und dass das Löschen der Zeile den Dienst intern hält, und unter dem Port der Komponente api infra.console_url mit der Adresse, unter der die Konsole veröffentlicht wird, "http://127.0.0.1:3001", die der Dify-Server als Adresse der Konsole übernimmt. Die Schritt-für-Schritt-Anleitung zum Dify-Import baut eine Anwendung für beide Targets und führt sie auf Kubernetes aus.

Was Dify selbst konfiguriert

Dify konfiguriert die Anbieter der Modelle und der Werkzeuge, die eine Anwendung aufruft, in sich selbst, und core/ai-agent/dify deklariert keinen Socket für ein Modell, daher verbindet der Entwurf keinen. Jeder Knoten, der einen davon nennt, wird mit part-configured-in-platform gemeldet, und in seiner Entscheidung, nach dem, was er nennt:

  • ein Knoten vom Typ llm, question-classifier oder parameter-extractor und das model_config.model einer Chat-Anwendung: das Modell, nach seinem Namen und seinem Anbieter;
  • ein Knoten vom Typ tool und das Werkzeug einer Chat-Anwendung: das Werkzeug, nach seinem Namen und seinem Anbieter;
  • ein Knoten vom Typ agent: die Agentenstrategie und das Plugin, das sie bereitstellt;
  • ein Knoten vom Typ knowledge-retrieval und die Wissensdatenbank einer Chat-Anwendung: die Wissensdatenbanken, aus denen er abruft, und das Modell, mit dem er eine Query weiterleitet oder ein Reranking durchführt, wo er eines nennt. Eine Anwendung nennt eine Wissensdatenbank über eine Kennung der Installation, aus der sie exportiert wurde, und trägt keines ihrer Dokumente und keinen Speicher, daher wird jede innerhalb von Dify angelegt, im Vektorspeicher, den die Installation mit ihrem API-Server verbindet;
  • eine Abhängigkeit: das Plugin, nach der Kennung, unter der Dify es installiert, und woher Dify es installiert.

Jeder andere Knoten bleibt in der Anwendung, ohne dass etwas gemeldet wird.

Werte von Zugangsdaten, die eine Anwendung enthält

Der Importer ermittelt, in der Reihenfolge, in der die Anwendung sie schreibt:

  • den Wert jeder Umgebungsvariablen, deren value_type secret ist, die Dify als Zugangsdaten markiert. Difys Export schreibt ihn leer, es sei denn, der Export schließt Geheimnisse ein;
  • den authorization.config.api_key eines HTTP-Anfrageknotens, den Dify als Zugangsdaten markiert und wie geschrieben exportiert;
  • die gespeicherten Zugangsdaten, die ein Knoten vom Typ tool oder ein Werkzeug eines Knotens vom Typ agent unter credential_id auswählt, die Dify als Zugangsdaten markiert und nur schreibt, wo der Export Geheimnisse einschließt;
  • die headers und params eines HTTP-Anfrageknotens, die Dify nicht als Zugangsdaten markiert und die welche tragen können, jeweils als Ganzes.

Standardmäßig wird jeder, der einen Wert enthält, wie geschrieben in der Anwendung übernommen und in einer Warnung credential-carried über seinen Knoten — workflow für eine Umgebungsvariable — und sein Feld genannt, niemals über seinen Wert. Mit der Einstellung empty_credentials auf marked wird jeder Wert, den Dify als Zugangsdaten markiert, leer geschrieben, und auf all auch die Header und die Query-Parameter, jeweils mit credential-emptied gemeldet. Ein Wert, der eine Variablenreferenz und nichts anderes ist, enthält keinen, wird wie geschrieben übernommen, was auch immer die Einstellung sagt, und in keiner Warnung genannt, wie in einem Flow. Ein Wert wird im eigenen Text der Anwendung leer geschrieben: Der Skalar nach seinem Schlüssel wird durch '' ersetzt, und nichts anderes wird geändert. Die Anwendung wird nur übernommen, wo der Parser, der parse:yaml bedient, das Ergebnis als die exportierte Anwendung mit genau diesen geleerten Werten zurückliest; andernfalls wird sie nicht übernommen, app_definition bleibt mit einem Kommentar ungesetzt, und definition-not-carried sagt, warum — etwa bei einer Anwendung, in der ein YAML-Alias den Wert eines Geheimnisses liest, den das Leerschreiben dieses Werts ebenfalls ändern würde. Ein Wert, den die Einstellung wie geschrieben lässt, wird nie umgeschrieben, daher verhindert er nie, dass die Anwendung übernommen wird.

Die DSL-Version

Wo eine Anwendung in einer Version der DSL geschrieben ist, die neuer ist als 0.7.0, die Version, die Dify 1.17.0 — die Version, die core/ai-agent/dify standardmäßig ausführt — schreibt, warnt der Import mit dsl-version-newer. Dify hält den Import einer solchen Anwendung zur Bestätigung zurück, die der Schritt gibt, der sie bei der Bereitstellung importiert, daher prüfen Sie die Anwendung gegen die Dify-Version, die das Release ausführt.

Die Einstellungen, die er liest

Der Dify-Importer liest target_namespace, empty_credentials, layout, attach_egress_allowlist und render_mode, wie Einstellungen sie beschreibt, sowie reuse_mode, reuse_threshold, emit_hints und mapping_overrides, die nichts an dem ändern, was das Standardlayout entwirft: Jeder Knoten bleibt in der Anwendung. attach_egress_allowlist bindet nichts an, da ein Eintrag eines zusammengesetzten Aggregate Parameter und kein Feature aufnimmt, und mit dem Wert true warnt der Import mit feature-not-attached. layout: nodes entwirft jeden Knoten als eigene Component, wie Knoten für Knoten beschreibt, und übernimmt keine Anwendung.

Der CrewAI-Importer

importer/crewai liest die Agenten und die Aufgaben, die ein CrewAI-Projekt in seinen Konfigurationsdateien deklariert, und entwirft ein Aggregate, das eine Instanz des CrewAI-Agenten der Standardbibliothek, core/ai-agent/crewai, pro Agent enthält, jede mit dem Modell verbunden, das ihre Konfiguration nennt, und daneben ein Release.

Was er liest

CrewAI hält das Verhalten einer Crew in einem Programm und deklariert ihre Agenten und ihre Aufgaben in Konfigurationsdateien, in einem von zwei Layouts, und der Importer liest beide:

  • Ein klassisches Projekt — config/agents.yaml, jeder Agent nach seinem Namen geschlüsselt, und config/tasks.yaml, jede Aufgabe nach ihrem Namen geschlüsselt, beide als YAML gelesen. Die Agenten werden in der Reihenfolge gelesen, in der agents.yaml sie schreibt.
  • Ein Projekt im JSON-first-Layout — crew.jsonc, das die Agenten der Crew nach Namen unter agents und ihre Aufgaben unter tasks aufführt, und agents/<name>.jsonc, eine Datei pro Agent, alle als JSON mit Kommentaren gelesen, sodass ihre Kommentare und nachgestellten Kommas so gelesen werden, wie CrewAI sie liest. Die Agenten werden in der Reihenfolge gelesen, in der crew.jsonc sie aufführt, gefolgt von der Datei jedes anderen Agenten in Namensreihenfolge; für einen Agenten, den die Crew aufführt und dessen Datei dem Import nicht übergeben wurde, wird ein Kommentar geschrieben, der ihn nennt, und nichts entworfen. Dasselbe Layout in striktem JSON geschrieben — crew.json und agents/<name>.json — wird auf dieselbe Weise gelesen. Wo eine Crew oder ein Agent in beiden Schreibweisen vorliegt, ist die Datei .jsonc diejenige, die gelesen wird, wie CrewAI sie liest, und die Datei .json wird in einem Kommentar als nicht gelesen genannt.

Von einem Agenten liest er seine role, goal und backstory; allow_delegation und verbose, auf der obersten Ebene seiner Deklaration oder unter settings, wobei settings Vorrang hat, wie CrewAI sie liest; sein llm; und die Namen seiner tools. Von einer Aufgabe liest er ihren Namen und den Agenten, dem sie zugewiesen ist. Jedes andere Element wird in einem Kommentar genannt und nirgends übernommen.

Ein Verzeichnis wird dem Importer als die Dateien übergeben, die seine Signaturen nennen, und keine anderen, daher wird das Programm der Crew — die crew.py eines klassischen Projekts, die main.py eines Flows, ein Werkzeug, das ein Projekt in Python definiert — nie gelesen. Eine für sich allein importierte Datei wird als die Deklaration gelesen, deren Form sie hat. Das Verzeichnis eines Projekts kann mehrere Crews enthalten, jede aus ihrem eigenen Verzeichnis gelesen.

Was aus einem Projekt wird

aggregate.yaml ist ein entworfenes Aggregate, das nach der Crew benannt ist, wie Wie ein Entwurf benannt wird beschreibt, und mit Kommentaren beginnt, die die gelesenen Deklarationen nennen, dass das Programm der Crew nicht gelesen wird, und die Aufgaben jeder Crew mit dem Agenten, dem jede zugewiesen ist. Es enthält pro Agent, nach seinem Namen geschlüsselt, eine Instanz von core/ai-agent/crewai mit:

  • role, goal und backstory wie deklariert;
  • allow_delegation wie deklariert und false, wo der Agent keines deklariert;
  • log_level DEBUG für einen als verbose deklarierten Agenten, der jeden Schritt seines Denkens schildert, und INFO für einen, der es nicht ist, der nur Fortschritt und Probleme meldet. Ein verbose oder ein allow_delegation, das weder true noch false ist, wird dem Standardwert der Component überlassen und in einem Kommentar genannt;
  • seine Verbindung model, verbunden mit der Instanz des Modells, das sein llm nennt.

Ein llm, geschrieben als <provider>/<model> oder als Objekt, das das Modell unter model, model_name oder deployment_name nennt, nennt einen Anbieter und ein Modell. Das Modell ist eine Instanz der Component des Katalogs für diesen Anbieter — core/ai-model/<provider>, wobei ein Unterstrich im Namen des Anbieters als Bindestrich gelesen wird und azure als azure-openai —, nach dem Namen des Modells geschlüsselt, mit dem Modell als ihrem values.model; Agenten, die denselben Anbieter und dasselbe Modell nennen, teilen sich eine Instanz. Wo der Workspace-Katalog keine Component dieses Namens enthält, wird eine entworfen, <target_namespace>/ai-model/<provider>, die den Wert model deklariert, und ihre Entscheidung sagt das; das Label model.aggrega.ai/api, nach dem der Socket model des Agenten eine Component auswählt, und eine Recipe, die ihren Endpunkt und ihr Modell veröffentlicht, bleiben Ihnen überlassen, wie ein Kommentar zu ihrem Beginn sagt. Ein llm, das keinen Anbieter nennt — ein bloßer Modellname, für den CrewAI einen Anbieter auflöst, wenn das Programm läuft, oder der Name eines llm, das das Programm definiert — eine Referenz in das Programm hinein, und ein Agent, der kein llm deklariert, das CrewAI dann aus der Umgebung liest, in der sein Programm läuft, werden mit nichts verbunden, und ein Kommentar über dem Agenten sagt, warum; der Build bricht ab und nennt den Socket model, bis einer verbunden ist.

Eine Aufgabe ist Logik, die das Programm der Crew ausführt, und ein Werkzeug ist Code, den das Programm definiert oder lädt: Keines von beiden wird eine Component. Jedes wird in einer Entscheidung gemeldet, die nichts wählt, und ein Werkzeug, dessen Name — ohne ein abschließendes Tool, seine Bindestriche und Unterstriche — der Name einer Werkzeug-Component ist, die der Katalog enthält, trägt diese Component als Hinweis: search_tool und SearchTool weisen beide auf core/ai-tool/search hin. core/ai-agent/crewai deklariert keinen Socket für ein Werkzeug, daher wird für eines nichts verbunden.

release.yaml daneben ist ein entworfenes Release desselben Namens, das dieses Aggregate nennt. Es schreibt das infra.image jedes Agenten — das Image, das das Programm der Crew ausführt und das keine Deklaration nennt — leer unter einem Kommentar, der sagt, was es ist, und der Import weist es als ausstehend aus. Mit --target compose schreibt der Eintrag jedes Agenten außerdem infra.published_port, 8000, den Port, den infra.port der Component standardmäßig für das Programm nennt und den ihre Compose-Recipe auf der Loopback-Adresse des Hosts, 127.0.0.1, veröffentlicht, unter dem Kommentar, der sagt, dass der Dienst nur von diesem Rechner aus erreichbar ist, für jeden darauf laufenden Prozess, und dass das Löschen der Zeile den Dienst intern hält; ein zweiter Agent erhält den nächsten freien Port, sodass die beiden Agenten des klassischen Projekts auf 8000 und 8001 veröffentlicht werden. Es hängt die Zugangsdaten, die jeder Agent seinem Modell vorlegt, unter credential an seine Verbindung model an, per Referenz und nie als Wert: Keine Deklaration nennt eine Variable dafür, daher werden sie aus der Variablen gelesen, aus der die Client-Bibliotheken des Anbieters ihren API-Schlüssel lesen — OPENAI_API_KEY für OpenAI —, als Referenz ${…} bei jedem Target außer helm und bei helm als Name eines Kubernetes-Secrets, leer geschrieben, damit der Import ihn als ausstehend ausweist; bei compose deklariert die Verbindung model des Agenten sie mit diesem Schlüssel. Jedes Modell hat ebenfalls einen Eintrag, der keine Infrastruktur enthält, sodass das Release es zusammen mit den Agenten platziert. Bei einem als Objekt llm deklarierten Modell wird jedes andere Element als Wert der Instanz des Modells geschrieben, wo die Component des Katalogs einen Wert dieses Namens deklariert, und andernfalls in einen Kommentar über dem Eintrag des Modells im Release, damit Sie es dorthin übernehmen, wo die Component es aufnimmt. Wie jedes entworfene Release schreibt es metadata.environment als development und, ohne Target, ein leeres spec.manifest, das der Import als ausstehend ausweist; ist ein Target gegeben, entwirft der Import das Manifest, wie Was ein Target hinzufügt beschreibt.

Das klassische Projekt, das die Tests dieses Importers importieren und dessen zwei Agenten beide openai/gpt-4o nennen, wird ohne Einstellung wie unten gezeigt entworfen; als sein Projektverzeichnis importiert, market_brief — das Verzeichnis, in dem crewai create crew market_brief ein solches Projekt anlegt —, wird es, da seine Deklarationen keine Crew nennen, nach diesem Verzeichnis benannt:

aggregate.yaml
# 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_writer
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
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"

und sein Release, ohne Target entworfen, wie unten, wobei der Eintrag des zweiten Agenten hier weggelassen und mit ... markiert ist; der Import weist spec.manifest und das Image jedes Agenten als ausstehend aus:

release.yaml
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: {}

Jeder Agent wird dann so gerendert, dass er das Image ausführt, das Sie angeben, und erhält den Endpunkt und den Namen des Modells als OPENAI_BASE_URL und MODEL, die Variablen, aus denen CrewAI sie liest.

Werte von Zugangsdaten, die eine Deklaration enthält

Ein als Objekt geschriebenes llm kann einen Schlüssel tragen — unter api_key, in einer Adresse, in Headern. Jedes seiner Elemente außer dem, das das Modell nennt, das keine Zahl und kein boolescher Wert ist, ist ein Wert, der einen tragen kann, den CrewAI nicht als Zugangsdaten markiert. Standardmäßig wird jeder, der einen Wert enthält, wie geschrieben übernommen — als Wert der Instanz des Modells, wo seine Component einen deklariert, und andernfalls in den Kommentar über dem Eintrag seines Modells im Release — und in einer Warnung credential-carried über seinen Agenten und sein Element genannt, etwa llm.api_key, niemals über seinen Wert. Mit der Einstellung empty_credentials auf all wird jeder ohne Wert geschrieben und mit credential-emptied gemeldet; auf marked wird jeder übernommen, da CrewAI keinen markiert. Der Name eines Elements wird nicht auf seine Bedeutung hin gelesen. Jedes andere Element, das eine Deklaration enthält und das der Entwurf nicht übernimmt — die Konfiguration eines Werkzeugs, die inputs einer Crew —, wird genannt, niemals mit seinem Wert.

Die Einstellungen, die er liest

Der CrewAI-Importer liest target_namespace, empty_credentials und render_mode, wie Einstellungen sie beschreibt, und keine andere Einstellung.

Der LangGraph-Importer

importer/langgraph liest die Graphen, die die Konfiguration einer LangGraph-Anwendung, langgraph.json, deklariert, und entwirft ein Aggregate, das eine Instanz des LangGraph-Agenten der Standardbibliothek, core/ai-agent/langgraph, pro Graph enthält, jede mit dem Datenspeicher verbunden, in dem ihr Checkpointer den Zustand hält, und mit einem Modell, und daneben ein Release, das die Umgebung übernimmt, die die Konfiguration angibt. Er liest diese Konfiguration und nie den Code der Graphen.

Was er liest

Eine LangGraph-Anwendung hält ihre Graphen im Code und deklariert sie in langgraph.json: Unter graphs wird die ID jedes Graphen dem Importpfad des Graphen im Code der Anwendung zugeordnet — ./src/agent/graph.py:graph oder module:attr — oder einem Objekt, das diesen Pfad unter path nennt und den Graphen unter description beschreibt. Der Importer liest, in der Reihenfolge, in der die Konfiguration sie schreibt:

  • graphs — die ID jedes Graphen, seinen Importpfad und seine Beschreibung;
  • checkpointer — dessen backend: default, das PostgreSQL ist und das, was LangGraph liest, wo keines genannt ist; mongo, eine Datenbank, die das Protokoll von MongoDB spricht; oder custom, einen Checkpointer, den der Code der Anwendung unter path definiert;
  • store — den Gedächtnisspeicher, der kein Backend nennt: LangGraph hält ihn in der PostgreSQL-Datenbank, die sein Server verwendet;
  • env — die Umgebung, mit der die Anwendung läuft: ein Objekt aus Variablennamen und Werten oder den Pfad einer Umgebungsdatei mit Zeilen KEY=VALUE.

Die Elemente, die das Server-Image konfigurieren, das langgraph build baut — dependencies, source, python_version, node_version, base_image, image_distro, dockerfile_lines, pip_config_file, pip_installer, keep_pkg_tools, api_version —, werden in einem Kommentar genannt und nirgends übernommen, da das Image, das das Release nennt, das eigene Image der Anwendung ist; dasselbe gilt für jedes andere Element, darunter die eigene Konfiguration des Servers wie auth, http und webhooks, sowie für index und ttl des Gedächtnisspeichers und ttl und serde des Checkpointers.

Ein Verzeichnis wird dem Importer als langgraph.json und keine andere Datei übergeben, daher wird weder der Code der Anwendung noch eine Umgebungsdatei je daraus gelesen. Eine Umgebungsdatei erreicht den Importer nur, wo with.sources des Importers sie übergibt, und wird nie geparst: Von derjenigen, die env der Konfiguration nennt — zugeordnet über das letzte Segment des Pfads, den es nennt —, werden nur die Namen der Variablen gelesen, und eine Umgebungsdatei, die keine Konfiguration nennt, wird in einem Kommentar als nicht gelesen genannt. Wo dem Import die Datei, die die Konfiguration nennt, nicht übergeben wird, nennt das Aggregate sie als nicht übergeben und sagt, sie unter with.sources des Importers zu nennen, und ihre Variablen bleiben dem Release überlassen:

plugins:
importer:
- uri: importer/langgraph:<version>
with:
sources:
- ./local.env

Eine für sich allein importierte Konfiguration wird gelesen, wie auch immer sie heißt. Ein Verzeichnis kann mehrere Anwendungen enthalten, jede aus ihrem eigenen Verzeichnis gelesen.

Was aus einer Anwendung wird

aggregate.yaml ist ein entworfenes Aggregate, das nach dem Graphen benannt ist, wie Wie ein Entwurf benannt wird beschreibt, und mit Kommentaren beginnt, die die gelesenen Konfigurationen nennen, die allein wegen ihrer Namen gelesenen Umgebungsdateien, dass der Code der Anwendung nicht gelesen wird, und was der Entwurf nicht übernimmt. Es enthält pro Graph, nach seiner ID geschlüsselt, eine Instanz von core/ai-agent/langgraph mit:

  • graph_entrypoint, der Importpfad des Graphen, wie die Konfiguration ihn schreibt;
  • description, die Beschreibung des Graphen, wo die Konfiguration eine angibt;
  • seine Verbindung checkpointer_db, verbunden mit dem Datenspeicher der Anwendung;
  • seine Verbindung model, verbunden mit dem Modell der Anwendung.

recursion_limit wird nicht geschrieben, daher gilt der Standardwert der Component, 25. Die Konfiguration nennt kein Modell, daher enthält der Entwurf eine Instanz von core/ai-model/openai, geschlüsselt als model, die jeder Graph aufruft: das Modell, das dem OpenAI-Client des Agenten übergeben wird. Sein values.model wird leer geschrieben, unter einem Kommentar, der sagt, dass die Konfiguration keines nennt, und der Import weist es als ausstehend aus.

Das Backend des Checkpointers ist der Datenspeicher, mit dem jeder Graph der Anwendung verbunden ist: default oder ein Checkpointer, der kein Backend nennt, ist eine Instanz von core/datastore/postgres, geschlüsselt als postgres. mongo ist FerretDB, das das Protokoll von MongoDB spricht, über PostgreSQL mit der Erweiterung DocumentDB: eine Instanz von core/datastore/ferretdb, geschlüsselt als ferretdb, mit der jeder Graph verbunden ist, und eine von core/datastore/documentdb, geschlüsselt als documentdb, die die Verbindung backend von FerretDB erreicht, wobei ihr inject-Block das, was DocumentDB veröffentlicht, unter den Namen liefert, die FerretDB liest; ein Passwort, gelesen aus der Variablen FERRETDB_PASSWORD, wird an DocumentDB, an die Verbindung von FerretDB dorthin und an die Verbindung jedes Graphen zu FerretDB angehängt. Wo der Workspace-Katalog keine Component mit dem Namen des PostgreSQL-Datenspeichers enthält, wird eine entworfen, <target_namespace>/datastore/postgres, die host und port deklariert, die die Verbindung checkpointer_db des Agenten liest, und ihre Entscheidung sagt das; eine Recipe, die den Datenspeicher ausführt und sie veröffentlicht, bleibt Ihnen überlassen, wie ein Kommentar zu ihrem Beginn sagt. Wo er keine FerretDB- oder keine DocumentDB-Component enthält, wird der Checkpointer mongo mit keinem Datenspeicher verbunden. Ein Checkpointer custom oder ein Backend, das der Importer keinem Datenspeicher zuordnet, verbindet nichts, und ein Kommentar über jedem Graphen und die Entscheidung des Checkpointers sagen, warum; der Build bricht ab und nennt den Socket checkpointer_db, bis einer verbunden ist. Der Gedächtnisspeicher wird in einer Entscheidung gemeldet, die nichts wählt.

Das Passwort des Datenspeichers ist ein Secret, das der Entwurf per Referenz anhängt, an den eigenen Slot password des Datenspeichers und an die Verbindung checkpointer_db jedes Graphen, und ebenso die Zugangsdaten, die jeder Graph dem Modell auf seiner Verbindung model vorlegt: gelesen aus POSTGRES_PASSWORD (oder FERRETDB_PASSWORD) und OPENAI_API_KEY, da die Konfiguration für keines von beiden eine Variable nennt, als Referenz ${…} bei jedem Target außer helm und bei helm als Name eines Kubernetes-Secrets, leer geschrieben, damit der Import ihn als ausstehend ausweist. Bei compose deklariert das Aggregate jedes mit dem Schlüssel, den seine Recipe liest, wie Secrets für jedes Target es für eine Plattform beschreibt.

release.yaml daneben ist ein entworfenes Release desselben Namens, das dieses Aggregate nennt. Kommentare über dem Eintrag des ersten Graphen geben an, was das Image jedes Graphen ist — das eigene Image der Anwendung, ihr Code mit installiertem LangGraph, nicht das Server-Image, das langgraph build baut —, welche Variablen ihm übergeben werden und welcher inject:-Block welchen ihrer Namen ersetzt. Der Eintrag jedes Graphen schreibt dessen infra.image, das Image, das die Anwendung ausführt, leer unter einem Kommentar, der sagt, was es ist, und der Import weist es als ausstehend aus; solange es nicht gesetzt ist, führt die Docker-Compose-Recipe den katalogeigenen Quickstart-Agenten aus, der die Standardvariablen liest. Mit --target compose schreibt der Eintrag jedes Graphen außerdem infra.published_port, 8000, den Port, den infra.port der Component standardmäßig für die Anwendung nennt und den ihre Compose-Recipe auf der Loopback-Adresse des Hosts, 127.0.0.1, veröffentlicht, unter dem Kommentar, der sagt, dass der Dienst nur von diesem Rechner aus erreichbar ist, für jeden darauf laufenden Prozess, und dass das Löschen der Zeile den Dienst intern hält; ein zweiter Graph erhält den nächsten freien Port. Auch der Datenspeicher und das Modell haben Einträge, sodass das Release sie zusammen mit den Graphen platziert. Ein Kommentar über dem ersten Graphen der Anwendung gibt die Umgebung an, die ihre Konfiguration deklariert, wie Die Umgebung, die eine Konfiguration angibt beschreibt. Wie jedes entworfene Release schreibt es metadata.environment als development und, ohne Target, ein leeres spec.manifest, das der Import als ausstehend ausweist; ist ein Target gegeben, entwirft der Import das Manifest, wie Was ein Target hinzufügt beschreibt.

Die Python-Anwendung, die die Tests dieses Importers importieren und die zwei Graphen, einen Checkpointer, der kein Backend nennt, einen Gedächtnisspeicher und ein als Objekt geschriebenes env deklariert, wird ohne Einstellung wie unten gezeigt entworfen; als ihr Verzeichnis importiert, support_desk — wie hier nach dem Paket benannt, in dem ihre Graphen definiert sind —, wird sie bei zwei Graphen mit unterschiedlichen IDs nach diesem Verzeichnis benannt:

aggregate.yaml
# 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/v1beta1
kind: Aggregate
metadata:
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: ""
release.yaml
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: {}

Der Import weist vier Werte als ausstehend aus: spec.manifest, das Image jedes Graphen und den Namen des Modells. Sobald sie beantwortet sind, wird jeder Graph so gerendert, dass er das Image ausführt, das Sie angeben, und erhält die Adresse seines Datenspeichers als LANGGRAPH_CHECKPOINTER_HOST und LANGGRAPH_CHECKPOINTER_PORT, den Benutzer und die Datenbank, die der Datenspeicher veröffentlicht, als LANGGRAPH_CHECKPOINTER_USER und LANGGRAPH_CHECKPOINTER_DATABASE — PostgreSQL veröffentlicht beide, und bei einem Datenspeicher, der keines von beiden veröffentlicht, wird keine der beiden Variablen gerendert —, den Endpunkt und den Namen des Modells als OPENAI_BASE_URL und OPENAI_MODEL, den Schlüssel, den seine Modell-Zugangsdaten liefern, als OPENAI_API_KEY, seinen Importpfad als LANGGRAPH_GRAPH_ENTRYPOINT und sein Schrittlimit als LANGGRAPH_DEFAULT_RECURSION_LIMIT. Die Zugangsdaten, die an seiner Verbindung checkpointer_db angehängt sind, übergeben ihm zudem das Passwort des Datenspeichers als LANGGRAPH_CHECKPOINTER_PASSWORD.

Die Umgebung, die eine Konfiguration angibt

Jede Variable, die env der Konfiguration nennt, ist eine Eingabe, die das Release liefern muss, und keine wird als Slot für Zugangsdaten entworfen: LangGraph markiert keine Variable als Geheimnis, und der Name einer Variablen wird nicht auf seine Bedeutung hin gelesen. core/ai-agent/langgraph nimmt keinen Wert für die Umgebung auf, daher gibt das Release sie in einem Kommentar über dem ersten Graphen der Anwendung an.

  • Ein als Objekt geschriebenes env ist Teil der Konfiguration, daher werden seine Werte wie geschrieben in diesen Kommentar übernommen, in der Reihenfolge, in der die Konfiguration sie schreibt. Jeder Wert, der etwas enthält, kann Zugangsdaten tragen, die LangGraph nicht als Zugangsdaten markiert: Standardmäßig wird jeder wie geschrieben übernommen und in einer Warnung credential-carried über seine Konfiguration und seine Variable genannt, etwa env.OPENAI_API_KEY, niemals über seinen Wert. Mit der Einstellung empty_credentials auf all wird jeder ohne Wert geschrieben und mit credential-emptied gemeldet; auf marked wird jeder übernommen, da LangGraph keinen markiert.
  • Ein env, das eine Datei nennt, nennt eine Datei, auf die die Konfiguration nur verweist und die üblicherweise lokale Geheimnisse enthält. Sie wird nur gelesen, wo with.sources des Importers sie übergibt. Der Kommentar nennt jede Variable, die die Datei nennt, als vom Release zu liefern, und kein Wert der Datei wird gelesen: Keiner erreicht einen Entwurf, eine Entscheidung oder eine Diagnose, was auch immer die Einstellung sagt. Ein über mehrere Zeilen in Anführungszeichen gesetzter Wert ist ein einziger Wert, daher wird eine Zeile darin nie für eine Variable gehalten, und eine Zeile, die keine Variable nennt, wird über ihre Nummer genannt. Wo dem Import die Datei nicht übergeben wurde — bei einem Verzeichnis immer, da es nie eine übergibt —, nennt das Aggregate sie als nicht übergeben, mit dem Hinweis, wie sie zu übergeben ist, und ihre Variablen bleiben dem Release überlassen.

Die Einstellungen, die er liest

Der LangGraph-Importer liest target_namespace, empty_credentials und render_mode, wie Einstellungen sie beschreibt, und keine andere Einstellung.

Der Google-ADK-Importer

importer/google-adk liest die Agenten, die eine auf Googles Agent Development Kit (ADK) aufgebaute Anwendung in ihren Agent-Config-Dateien deklariert — root_agent.yaml und die Konfigurationen, die dessen Sub-Agenten nennen —, und entwirft ein Aggregate, das eine Instanz des ADK-Agenten der Standardbibliothek, core/ai-agent/google-adk, pro Agentenbaum enthält, verbunden mit dem Modell, das der Baum nennt, sofern ADK dessen Anfragen an die Gemini API sendet, und daneben ein Release. Er liest diese Konfigurationen und nie den Code der Anwendung.

ADK gibt an, dass seine Agent-Config-Funktion experimentell ist. Das Modell eines Agenten ist standardmäßig ein Gemini-Modell; die Modelle einiger anderer Anbieter bedient ADK per Name über eigene Klassen, etwa claude-sonnet-4-5 und gpt-4o, und andere über einen LiteLLM-Modellstring. Der model-Socket des Agenten lässt allein die Gemini API zu, daher verbindet der Importer ein Modell, das ADK an die Gemini API sendet, und überlässt jedes andere Ihnen, wie Was aus einem Agentenbaum wird beschreibt.

Was er liest

adk create --type=config von ADK schreibt root_agent.yaml, die Konfiguration des Wurzelagenten einer Anwendung, und daneben eine Umgebungsdatei. Eine Konfiguration deklariert einen Agenten:

  • name, description und agent_class — die Klasse, als die ADK den Agenten baut, LlmAgent, wo sie keine nennt;
  • model — das Modell, das der Agent anfordert — oder model_code, eine Referenz auf Code, der sein Modell baut;
  • tools — jedes Werkzeug über name, mit den args, die seine Konfiguration ihm übergibt;
  • generate_content_config — die Optionen der Modellanfragen des Agenten, darunter http_options;
  • sub_agents — jeweils ein config_path, der Pfad einer anderen Konfiguration ausgehend vom Verzeichnis der Konfiguration, die ihn nennt, oder code, ein Agent, den der Code der Anwendung baut.

Ein Verzeichnis wird dem Importer als seine Dateien root_agent.yaml und keine andere Datei übergeben, und eine für sich allein importierte Konfiguration wird als Wurzel gelesen, wie auch immer sie heißt. Der Baum jeder Wurzel wird gelesen, zuerst die Wurzel, die Sub-Agenten jedes Agenten in der Reihenfolge, in der er sie aufführt. Die Konfiguration, die ein Eintrag von sub_agents über config_path nennt, wird nur gelesen, wo with.sources des Importers sie übergibt, zugeordnet über das letzte Segment des Pfads; eine, die dem Import nicht übergeben wurde, wird im Aggregate und in seiner Entscheidung als nicht übergeben genannt, mit dem Hinweis, wie sie zu übergeben ist, und ihr Agent wird nicht gelesen:

plugins:
importer:
- uri: importer/google-adk:<version>
with:
sources:
- ./my_agent/code_tutor_agent.yaml
- ./my_agent/math_tutor_agent.yaml

Ein config_path, der absolut ist oder aus dem Verzeichnis der Konfiguration, die ihn nennt, herausführt, wird nicht gelesen, da auch ADK ihn ablehnt. Eine Datei, die with.sources übergibt und die keine Konfiguration nennt, wird in einem Kommentar als nicht gelesen genannt, und nichts von ihr wird gelesen; eine Datei, die es übergibt, wird nur als Konfiguration gelesen, die der Baum einer Wurzel nennt, daher liest ein Import, der keine root_agent.yaml und keine für sich allein importierte Datei enthält, keinen Baum und meldet jede Datei unter no-nodes. Der Code der Anwendung — die Werkzeuge, Callbacks, Schemas und Agenten, die eine Konfiguration über ihren Code nennt — und die Umgebungsdatei werden nie übergeben, und der Importer liest keines von beiden: Die Anwendung lädt ihre Konfigurationen selbst, aus dem Image, das das Release nennt. Ein Verzeichnis kann mehrere Anwendungen enthalten, jede aus ihrer eigenen root_agent.yaml gelesen.

Die anderen Elemente einer Konfiguration — darunter die instruction eines Agenten — liest die Anwendung aus ihrer eigenen Konfiguration, daher übernimmt der Entwurf keines davon.

Was aus einem Agentenbaum wird

ADK stellt eine Anwendung von ihrem Wurzelagenten aus bereit, wobei jeder Agent, den ihre Konfigurationen nennen, darin gebaut wird, und core/ai-agent/google-adk führt eine solche Anwendung aus. Daher enthält aggregate.yaml, ein entworfenes Aggregate, das nach dem Wurzelagenten benannt ist, wie Wie ein Entwurf benannt wird beschreibt, pro Agentenbaum, nach dem Namen seines Wurzelagenten geschlüsselt, eine Instanz von core/ai-agent/google-adk mit:

  • description, die Beschreibung des Wurzelagenten, wo seine Konfiguration eine angibt;
  • ihre Verbindung model, verbunden mit dem Modell, das der Baum nennt, sofern ADK die Anfragen dieses Modells an die Gemini API sendet.

Kommentare darüber nennen die anderen Agenten des Baums, die zu keiner eigenen Instanz werden; jeden Sub-Agenten, der nicht gelesen wird, und warum — vom Code der Anwendung gebaut, eine Konfiguration, die dem Import nicht übergeben wurde, oder eine, die ADK ablehnt; die Werkzeuge, die die Agenten des Baums nennen, diejenigen, die ADK mitliefert, und diejenigen, die der Code der Anwendung definiert; die Agenten, deren Klasse — LoopAgent, ParallelAgent oder SequentialAgent — ADK zugunsten von Workflow als veraltet markiert; und, wo das Modell des Baums verbunden ist, die Modelle, die andere Agenten des Baums anfordern, jeweils mit der Familie, über die ADK es bereitstellt. Jedes wird in einer Entscheidung gemeldet, die nichts wählt.

Der erste Agent des Baums, beginnend mit der Wurzel, der ein Modell oder den Code nennt, der eines baut, entscheidet über das Modell der Instanz. Ein Modell, das er nennt und dessen Anfragen ADK an die Gemini API sendet — ein Modellname, den ADK über seine Gemini-Klasse bereitstellt, etwa gemini-2.5-flash, mit Ausnahme eines Vertex-AI-Ressourcennamens, oder einer, den es über seine Gemma-Klasse bereitstellt —, ist eine Instanz von core/ai-model/gemini, die dieses Modell bereitstellt und nach ihm geschlüsselt ist, und Bäume, die dasselbe Modell nennen, teilen sich eine Instanz. Wo der Workspace-Katalog keine core/ai-model/gemini enthält, wird eine entworfen, <target_namespace>/ai-model/gemini, die das Label model.aggrega.ai/api: gemini trägt, das der Socket model des Agenten auswählt, und ihre Entscheidung sagt das; eine Recipe, die ihren Endpunkt und ihr Modell veröffentlicht, bleibt Ihnen überlassen, wie ein Kommentar zu ihrem Beginn sagt. Ein Modell, das ADK auf andere Weise bereitstellt — ein LiteLLM-Modellstring wie openai/gpt-4o, ein Vertex-AI-Ressourcenname oder ein Name wie claude-sonnet-4-5 oder gpt-4o, den ADK über Anthropic oder OpenAI bereitstellt —, wird mit nichts verbunden: Der Socket model des Agenten nimmt ein Gemini-Modell auf, und der Agent liest keinen Modellnamen aus seiner Umgebung, daher verbinden Sie dort ein Gemini-Modell und nennen dieses Modell in der Konfiguration des Agenten. Der Kommentar über der Instanz und die Entscheidung des Wurzel-Agenten nennen das Modell und die Familie, über die ADK es bereitstellt. Ein Modell, das der Code der Anwendung baut, oder ein Baum, der keines nennt — ADK verwendet dann sein Standardmodell —, wird ebenfalls mit nichts verbunden, und ein Kommentar über der Instanz sagt, warum. Wo immer das Modell mit nichts verbunden ist, bricht der Build ab und nennt den Socket model, bis einer verbunden ist. Von den Modellen, die andere Agenten eines Baums anfordern, braucht eines, dessen Anfragen ADK an die Gemini API sendet, keine eigene Verbindung: Der Gemini-Client von ADK sendet dessen Anfragen mit dem Schlüssel, den die Verbindung der Instanz liefert. Ob die Anwendung Gemini über die Gemini API oder über Vertex AI erreicht, wählt ihre Umgebung, die der Import nicht liest; der Socket model des Agenten nimmt allein die Gemini API auf.

Die Tests des Importers importieren außerdem einen einzelnen Wurzel-Agenten, der openai/gpt-4o nennt und dessen Instanz so entworfen wird:

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 daneben ist ein entworfenes Release desselben Namens, das dieses Aggregate nennt. Der Eintrag jeder Instanz schreibt deren infra.image — das Image, das die auf ADK aufgebaute Anwendung ausführt und ihre Konfigurationen enthält — leer, unter einem Kommentar, der sagt, was es ist, und der Import meldet es als ausstehend. Mit --target compose schreibt der Eintrag außerdem infra.published_port, 8000, den Port, auf dem die Anwendung lauscht und den ihr Compose-Recipe auf der Loopback-Adresse des Hosts, 127.0.0.1, veröffentlicht, unter dem Kommentar, der sagt, dass er nur von diesem Rechner aus erreichbar ist, von jedem darauf laufenden Prozess, und dass das Löschen der Zeile den Dienst intern hält; ein zweiter Baum erhält den nächsten freien Port. Wo ihr Modell verbunden ist, bindet der Eintrag die Zugangsdaten, die die Instanz diesem Modell vorlegt, unter credential an ihre Verbindung model an, per Referenz und nie als Wert: Keine Konfiguration nennt eine Variable dafür, daher werden sie aus GOOGLE_API_KEY gelesen, der Variable, aus der die Client-Bibliotheken der Gemini API von Google ihren Schlüssel lesen, als ${…}-Referenz auf jedem Target außer helm, und auf helm als Name eines Kubernetes Secret, leer geschrieben und vom Import als ausstehend gemeldet; auf compose deklariert die Verbindung model sie mit diesem Schlüssel. Auch ein verbundenes Modell hat einen Eintrag, der keine Infrastruktur enthält, sodass das Release es zusammen mit der Instanz platziert. Die Werte, die die Konfigurationen des Baums ihren Werkzeugen und ihren Modellanfragen übergeben, werden in einen Kommentar über dem Eintrag geschrieben, wie Werte von Zugangsdaten, die eine Konfiguration enthält beschreibt. Wie jedes entworfene Release schreibt es metadata.environment als development und, ohne Target, ein leeres spec.manifest, das der Import als ausstehend meldet; mit einem Target entwirft der Import das Manifest, wie Was ein Target hinzufügt beschreibt.

Die Anwendung, die die Tests dieses Importers importieren, ein Wurzelagent, der die Konfigurationen zweier Sub-Agenten und einen durch Code gebauten nennt, als ihr Verzeichnis importiert, mit den beiden Konfigurationen unter with.sources genannt, wird ohne Einstellung unter dem Namen ihres Wurzelagenten, tutor_root, entworfen als:

aggregate.yaml
# 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/v1beta1
kind: Aggregate
metadata:
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"

Ein Text, den der Entwurf aus einer Konfiguration in das Aggregate kopiert, in einem Wert oder in einem Kommentar, schreibt jedes {{ als {{`{{`}}, eine Aktion, deren Ergebnis die beiden geschweiften Klammern sind, sodass die Beschreibung und ein Name, der in einem Kommentar zwei geschweifte Klammern enthält, nach der Auswertung des Aggregate wie geschrieben zurückgelesen werden.

release.yaml
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: {}

Sobald das Image beantwortet ist, wird die Instanz so gerendert, dass sie es ausführt, und erhält die Zugangsdaten als GOOGLE_API_KEY, die der Gemini-Client von ADK an die Gemini API sendet, und das Modell als Service, der die Adresse der Gemini API erreicht.

Werte von Zugangsdaten, die eine Konfiguration enthält

Eine Konfiguration kann einem Werkzeug einen Schlüssel übergeben, in seinen args, oder ihren Modellanfragen, in den http_options ihrer generate_content_config — deren Header, deren Adresse, die Argumente ihres Clients. Jedes Element der args eines Werkzeugs und dieser HTTP-Optionen wird in den Kommentar über dem Eintrag der Instanz im Release geschrieben, wie seine Konfiguration es schreibt, und jedes, das ein Text, ein Objekt oder eine Liste ist, kann Zugangsdaten tragen, die ADK nicht als Zugangsdaten markiert: Standardmäßig wird jedes wie geschrieben übernommen und in einer Warnung credential-carried über seinen Agenten und sein Feld genannt, etwa tools.tutor_tools.make_snippet_runner.args.api_key, niemals über seinen Wert. Mit der Einstellung empty_credentials auf all wird jedes ohne Wert geschrieben und mit credential-emptied gemeldet; auf marked wird jedes übernommen, da ADK keines markiert. Eine Zahl oder ein boolescher Wert trägt keinen Schlüssel und wird so geschrieben, wie die Konfiguration ihn schreibt. ADK expandiert keine Variablenreferenz in einer Konfiguration, daher wird jeder Wert wie geschrieben gelesen; die Umgebungsdatei, die üblicherweise den Schlüssel enthält, den der Gemini-Client von ADK liest, wird nie gelesen, was auch immer die Einstellung sagt.

Die Einstellungen, die er liest

Der Google-ADK-Importer liest target_namespace, empty_credentials und render_mode, wie Einstellungen sie beschreibt, und keine andere Einstellung.

Der Agent-Framework-Importer

importer/agent-framework liest einen deklarativen Agenten von Microsoft Agent Framework — das YAML-Dokument vom Typ Prompt, aus dem eine auf Agent Framework gebaute Anwendung einen Agenten lädt — und entwirft ein Aggregate, das eine Instanz des Agent-Framework-Agenten der Standardbibliothek, core/ai-agent/agent-framework, enthält, verbunden mit dem OpenAI-Modell, das der Agent nennt, sowie ein Release daneben. Er liest deklarative Agenten und niemals den Code der Anwendung. Agent Framework veröffentlicht seine Pakete für deklarative Agenten als Vorabversionen.

Was er liest

Ein deklarativer Agent deklariert:

  • name, displayName und description, seine instructions und die Schemas seiner Eingabe und seiner Ausgabe;
  • model — die id des Modells, den provider, der es bereitstellt, die API, an die sein Client Anfragen sendet (apiType), die options seiner Anfragen und seine connection: eine Verbindung key, die einen Schlüssel, geschrieben unter key oder apiKey, einem endpoint vorlegt; eine Verbindung remote, die einen endpoint erreicht; eine Verbindung reference, die eine nennt, die die Anwendung auflöst; oder eine Verbindung anonymous, die nichts vorlegt;
  • tools — jedes mit einer kind: eine function, deren Code die Anwendung bindet, ein Werkzeug web_search, file_search oder code_interpreter, das der Anbieter des Modells ausführt, oder ein Server mcp, erreicht unter seiner url, mit dem approvalMode, dem seine Aufrufe folgen, den allowedTools des Servers, die der Agent aufrufen darf, und einer eigenen connection.

Ein als =Env.NAME geschriebenes Element wird von Agent Framework nur dann aus der Umgebungsvariablen NAME gelesen, wenn die Anwendung den deklarativen Agenten mit AgentFactory(safe_mode=False) lädt, der eigenen Sicherheitseinstellung von Agent Framework, und eine .NET-Laufzeitumgebung vorhanden ist, und wird andernfalls als der Text des Ausdrucks genommen, wie er geschrieben ist; jedes andere Element, das mit = beginnt, ist ein Ausdruck, den die Anwendung berechnet. Der Importer liest keines von beiden: Er nennt eine Referenz über ihre Variable und einen Ausdruck als solchen.

Eine allein importierte Datei wird als ein deklarativer Agent gelesen, wie auch immer sie heißt, und jede Datei, die with.sources des Importers übergibt, wird als ein weiterer gelesen, sodass ein Import mehrere entwirft:

plugins:
importer:
- uri: importer/agent-framework:<version>
with:
sources:
- ./agents/triage.yaml
- ./agents/writer.yaml

Ein Verzeichnis wird dem Importer nie übergeben: Seine Signatur nennt keine Datei, daher erkennt ein Import eines Verzeichnisses, der kein Format nennt, es nicht, und einer, der --format agent-framework nennt, wird unter An importer that declares no file patterns is handed a directory (Einem Importer, der keine Dateimuster deklariert, wird ein Verzeichnis übergeben) abgelehnt, bevor eine seiner Dateien geöffnet wird. Importieren Sie stattdessen jeden deklarativen Agenten als eigene Datei. Eine Quelle, aus der Agent Framework keinen Prompt-Agenten baut — eine, deren kind weder Prompt, in beliebiger Groß- und Kleinschreibung, noch Agent ist —, wird unter no-nodes gemeldet. Der Code der Anwendung — das Programm, das jeden deklarativen Agenten lädt, und die Funktionen, die es an seine Werkzeuge bindet — gehört nie zu den Quellen: Die Anwendung lädt ihre deklarativen Agenten selbst, aus dem Image, das das Release nennt.

Was aus einem deklarativen Agenten wird

aggregate.yaml, ein entworfenes Aggregate, das nach dem Agenten benannt ist, wie Wie ein Entwurf benannt wird beschreibt, enthält pro deklarativem Agenten, nach seinem Namen geschlüsselt, eine Instanz von core/ai-agent/agent-framework mit:

  • display_name und description, dem displayName und der description des Agenten, wo er sie angibt;
  • seiner Verbindung model, verbunden mit dem Modell, das er nennt, wo dieses Modell verbunden ist.

Seine Anweisungen, die Schemas seiner Eingabe und seiner Ausgabe, sein Template, seine Metadaten und die Optionen seiner Modellanfragen liest die Anwendung aus dem deklarativen Agenten, und sie werden in einem Kommentar über der Instanz genannt. Ein Funktionswerkzeug, ein Werkzeug, das der Anbieter des Modells ausführt, und ein Werkzeug jeder anderen Art werden ebenfalls in einem Kommentar genannt und in einer Entscheidung gemeldet, die nichts wählt.

Ein Modell, dessen provider OpenAI ist und das eine id nennt, ist eine Instanz von core/ai-model/openai, die diese ID bereitstellt und nach ihr geschlüsselt ist: Der Socket model des Agenten nimmt ein Modell auf, das die OpenAI-API bereitstellt, und die Laufzeit liefert Adresse, Namen und Schlüssel dieses Modells in den Variablen, die die OpenAI-Clients von Agent Framework lesen. Agenten, die dasselbe Modell unter derselben Adresse nennen, teilen sich eine Instanz. Wo der Workspace-Katalog kein core/ai-model/openai enthält, wird eines entworfen, <target_namespace>/ai-model/openai, das das Label model.aggrega.ai/api: openai trägt, das der Socket model des Agenten auswählt, und seine Entscheidung sagt das; eine Recipe, die seinen Endpunkt und sein Modell veröffentlicht, bleibt Ihnen überlassen, wie ein Kommentar zu seinem Beginn sagt. Eine als Referenz geschriebene id überlässt Ihnen das values.model des Modells, wobei ein Kommentar über dem Modell die Variable nennt; der Build bricht ab und nennt es, bis es gesetzt ist. Eine Verbindung anonymous wird als unauthenticated: true der Verbindung geschrieben. Ein Modell jedes anderen Anbieters — AzureOpenAI, Anthropic —, eines, das seinen Anbieter als Referenz oder gar nicht nennt, in welchem Fall Agent Framework den Standardanbieter verwendet, den die Anwendung setzt, und eines, das keine id nennt, werden mit nichts verbunden, und ein Kommentar über der Instanz sagt, warum; der Build bricht ab und nennt den Socket model, bis einer verbunden ist.

Ein Werkzeug vom Typ mcp wird weder als Component noch als Verbindung entworfen: Agent Framework sendet den Server als gehostetes Werkzeug an den Anbieter des Modells, und der Anbieter, nicht die Anwendung, erreicht ihn unter seiner url, die daher vom Anbieter aus erreichbar sein muss, sodass nichts, was der Entwurf bereitstellt, ihn erreicht. Ein Kommentar über der Instanz des Agenten nennt den Server, sagt dies und nennt die Beschreibung, den approvalMode und die allowedTools, die der deklarative Agent für ihn angibt; seine url wird vollständig in den Kommentar über dem Eintrag des Agenten im Release geschrieben, und seine Entscheidung wählt nichts.

release.yaml daneben ist ein entworfenes Release desselben Namens, das dieses Aggregate nennt. Der Eintrag des Agenten schreibt dessen infra.image — das Image, das die auf Agent Framework gebaute Anwendung ausführt und seinen deklarativen Agenten enthält — leer, unter einem Kommentar, der sagt, was es ist, und der Import meldet es als ausstehend. Mit --target compose schreibt der Eintrag außerdem infra.published_port, 8000, den Port, den infra.port der Component standardmäßig für die Anwendung nennt und den ihre Compose-Recipe auf der Loopback-Adresse des Hosts, 127.0.0.1, veröffentlicht, unter dem Kommentar, der sagt, dass der Dienst nur von diesem Rechner aus erreichbar ist, für jeden darauf laufenden Prozess, und dass das Löschen der Zeile den Dienst intern hält. Wo sein Modell verbunden ist, bindet der Eintrag die Zugangsdaten, die der Agent diesem Modell vorlegt, unter credential an seine Verbindung model an, per Referenz und nie als Wert: gelesen aus der Variable, die der deklarative Agent für seinen Schlüssel nennt, geschrieben als =Env.NAME, und andernfalls aus OPENAI_API_KEY, der Variable, aus der die Client-Bibliotheken von OpenAI ihren Schlüssel lesen; als ${…}-Referenz auf jedem Target außer helm, und auf helm als Name eines Kubernetes Secret, leer geschrieben und vom Import als ausstehend gemeldet; auf compose deklariert die Verbindung model sie mit diesem Schlüssel. Die Werte, die der deklarative Agent für sein Modell und seine MCP-Server angibt — die Schlüssel und die url jedes Servers —, werden in einen Kommentar über dem Eintrag des Agenten geschrieben, wie Werte von Zugangsdaten, die ein deklarativer Agent enthält beschreibt. Jedes verbundene Modell hat einen Eintrag, sodass das Release es zusammen mit dem Agenten platziert. Der Endpunkt, den seine Verbindung angibt, wird als infra.endpoint des Modells geschrieben, und einer, der als Referenz geschrieben ist, wird neben seinem Eintrag genannt, wobei die eigene Adresse der Component verwendet wird, bis er gesetzt ist; eine Verbindung, die keinen Endpunkt angibt, lässt den Eintrag ohne Infrastruktur, und die eigene Adresse der Component bleibt bestehen. Wie jedes entworfene Release schreibt es metadata.environment als development und, ohne Target, ein leeres spec.manifest, das der Import als ausstehend meldet; mit einem Target entwirft der Import das Manifest, wie Was ein Target hinzufügt beschreibt.

Der deklarative Agent, den die Tests dieses Importers importieren, des Anbieters OpenAI mit einer Schlüsselverbindung, einem MCP-Server, der einen eigenen Schlüssel vorlegt, einem Funktionswerkzeug und einer Websuche, als eigene Datei importiert, wird ohne Einstellung unter seinem name, LearnAgent, entworfen als:

aggregate.yaml
# 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/v1beta1
kind: Aggregate
metadata:
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"

Ein Text, den der Entwurf aus einem deklarativen Agenten in das Aggregate kopiert, in einem Wert oder in einem Kommentar, schreibt jedes {{ als {{`{{`}}, sodass er wie geschrieben zurückgelesen wird, sobald das Aggregate ausgewertet ist.

release.yaml
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"

Sobald das Image beantwortet ist, wird der Agent so gerendert, dass er es ausführt, und erhält den Endpunkt des Modells als OPENAI_BASE_URL, seine ID als OPENAI_MODEL und seine Zugangsdaten als OPENAI_API_KEY, und das Modell wird als Service gerendert, der seinen Host erreicht. Keine Variable trägt die Adresse des MCP-Servers: Der Anbieter des Modells, nicht die Anwendung, erreicht ihn.

Werte von Zugangsdaten, die ein deklarativer Agent enthält

Der Schlüssel, den eine Verbindung key vorlegt — geschrieben unter key oder apiKey, am Modell oder an einem MCP-Server —, ist das eine Element, das Agent Framework als Zugangsdaten markiert: Es ist der eine Wert, den sein Loader in dem schwärzt, was er protokolliert. Jeder Schlüssel, den ein deklarativer Agent als Literal schreibt, wird in den Kommentar über dem Eintrag des Agenten im Release geschrieben, wie der deklarative Agent ihn schreibt, und standardmäßig wie geschrieben übernommen und in einer Warnung credential-carried über seinen Agenten und sein Feld genannt, etwa model.connection.key, niemals über seinen Wert. Die url eines MCP-Servers, vollständig in denselben Kommentar geschrieben und über ihr Feld genannt — tools.microsoft_learn.url of node LearnAgent is carried as written —, ist ein Element der Konfiguration eines MCP-Servers, und der Endpunkt eines verbundenen Modells ist eine Eingabe, die Agent Framework als keine Zugangsdaten markiert. Mit der Einstellung empty_credentials auf marked werden die Schlüssel und die url-Werte der MCP-Server ohne Wert geschrieben — der Kommentar nennt jedes Element nur über sein Feld — und mit credential-emptied gemeldet, und der Endpunkt des Modells wird übernommen; auf all wird auch der infra.endpoint des Modells ausgelassen, im Kommentar über seinem Eintrag als dem Release überlassen genannt, und die Standardadresse der Component wird verwendet, bis er gesetzt ist. Ein als =Env.NAME geschriebener Wert enthält keinen, daher wird er über seine Variable genannt, zusammen mit der Bedingung, unter der Agent Framework ihn aus der Umgebung liest — model.connection.key, written as =Env.OPENAI_API_KEY, which Agent Framework reads … —, was auch immer die Einstellung sagt, und unter keinem der beiden Codes gemeldet; ein Wert, der als irgendein anderer Ausdruck geschrieben ist, wird als solcher genannt und nie geschrieben.

Die Einstellungen, die er liest

Der Agent-Framework-Importer liest target_namespace, empty_credentials und render_mode, wie Einstellungen sie beschreibt, und keine andere Einstellung.

Was ein Target hinzufügt

Ein Import, dem ein Target gegeben wird — --target bei aggrega import oder target beim Import-Werkzeug des Assistenten und bei der Methode aggrega/import der Sitzung, das eine Provider-Fähigkeit wie compose oder helm nennt —, übergibt dieses Target dem Importer, sodass der Importer dafür entwirft: jedes Secret in der Form, die dieses Target liest, und die Zeilen, die nur dieses Target braucht, aktiv geschrieben, während Zeilen, die nur ein anderes Target braucht, weggelassen werden. Auf compose umfassen diese Zeilen infra.published_port überall dort, wo der Importer einen Dienst auf der Loopback-Adresse des Hosts veröffentlicht, wie der Abschnitt jedes Importers sagt; ein Port, den der Importer wählt, erhält nie eine Nummer, die ein anderer Port des Release belegt. Anschließend entwirft der Import das Manifest neben dem, was der Importer entworfen hat, unabhängig davon, welcher Importer lief: manifest.yaml, neben dem entworfenen Release und wie dieses benannt und versioniert — oder, wo der Importer kein Release entworfen hat, neben dem entworfenen Aggregate und wie dieses benannt und versioniert.

Für jeden Komponententyp und jeden Feature-Typ, den die Entwürfe benötigen — bei den Komponenten des entworfenen Aggregate, ihren Verbindungen und seinen Subsystemen, bei den Katalog-Aggregates, die es zusammensetzt, wie core/dify, und bei den Anbindungen des entworfenen Release —, bildet das Manifest den Typ auf das Recipe oder, bei einem Feature-Typ, auf das Feature-Recipe dieser Fähigkeit ab, das der Workspace-Katalog dafür anbietet: das eine, das es gibt, wobei mehrere Versionen eines einzigen als eines zählen; oder, wo es mehrere mit unterschiedlichen Namen gibt, dasjenige, das nach dem Typ selbst benannt ist, wie helm/postgres für core/datastore/postgres. Ein Typ ohne eines oder mit mehreren, von denen keines so benannt ist, bleibt unabgebildet, eine Warnung nennt ihn und den Grund, und ein Build der Entwürfe bricht ab und nennt jede seiner Instanzen oder Anbindungen, bis Sie ihn abbilden.

Wo nur der Importer weiß, welches von mehreren Recipes zutrifft, entwirft er das Manifest selbst — der MCP-Importer bildet jeden Server anhand seines Schlüssels auf die Realisierung der Art ab, wie der Server läuft, und ein Importer, der ein Secret per Namen anbindet, bildet core/referenced-secret auf helm/k8s-existing-secret ab —, und der Import vervollständigt es: Jede Abbildung, die der Importer geschrieben hat und die der Katalog für diesen Typ und diese Fähigkeit anbietet, wird beibehalten, jede andere wird mit einer Warnung verworfen, und die Typen, die er offen lässt, werden wie oben abgebildet.

Das spec.manifest des entworfenen Release, das ohne Target leer geschrieben wird, wird auf den Namen des Manifest gesetzt, der Kommentar darüber entfällt, und sonst ändert sich nichts am Release. aggrega import beschreibt es vollständig.

Einstellungen

Einem Importer werden die Einstellungen des Eintrags plugins.importer, der ihn anbindet, unter with.settings übergeben, wie Welcher Importer eine Quelle in Entwürfe umwandelt beschreibt. Ohne Eintrag oder ohne Einstellungen nimmt jede Einstellung ihren Standardwert an.

plugins:
importer:
- uri: importer/langflow:<version>
with:
settings:
target_namespace: payments
reuse_mode: hints-only
EinstellungStandardFunktionsweise
target_namespaceimportedDer Namespace, unter dem entworfene Entitäten benannt werden: <target_namespace>/<category>/<name> für eine Component und <target_namespace>/<name> für das Aggregate und das Release, wobei <name> der eigene Name der Quelle ist, andernfalls der Name ihres Verzeichnisses oder der Name ihrer Datei ohne die Erweiterung, andernfalls flow, in Kleinbuchstaben geschrieben, wobei jede Folge anderer Zeichen als ASCII-Buchstaben und -Ziffern zu einem einzigen Bindestrich wird, wie Wie ein Entwurf benannt wird beschreibt.
reuse_modeauto-apply-above-thresholdauto-apply-above-threshold referenziert für einen Knoten, dem der Entwurf eine eigene Component gibt und dessen Treffer in der hohen Ebene liegt und eine Punktzahl bei oder über reuse_threshold erzielt, die am besten passende Katalog-Component und entwirft jeden anderen. hints-only entwirft jeden solchen Knoten und referenziert keine Katalog-Component, wobei ein starker Treffer als Hinweis festgehalten wird. Jeder andere Wert wird als hints-only gelesen.
reuse_threshold0.85Die Punktzahl, bei oder über der auto-apply-above-threshold eine Component referenziert. Nur in diesem Modus gelesen; 0 wird als Standardwert gelesen.
emit_hintstrueOb die Datei einer entworfenen Component mit einem Kommentar beginnt, der die Katalog-Component nennt, der sie ähnelt, bei einem Treffer der hohen oder mittleren Ebene. Das entworfene Aggregate trägt denselben Kommentar über dem Eintrag dieses Knotens und über einem referenzierten Eintrag einen, der den nächstbesten Kandidaten nennt, gegen den er ausgetauscht werden könnte, oder sagt, dass keiner über null punktete. false lässt die Kommentare weg.
render_modehumanhuman schreibt die oben beschriebenen Entwürfe. llm schreibt keine Entwürfe und schreibt stattdessen das gesamte Entscheidungsprotokoll — jeden Knoten, die bewerteten Kandidaten und die getroffene Wahl — als ein Dokument, import-decisions.json, das ein anderes Werkzeug lesen kann. Jeder andere Wert wird als human gelesen.
mapping_overrideskeineAbbildungen, die über die eigene Tabelle des Importers gelegt werden, nach Format und dann nach Knotentyp geschlüsselt — beim Compose-Importer nach Image-Repository. Jeder Eintrag nennt die component, auf die ein Knoten dieses Typs abgebildet wird, und optional ihre category, die traits — Labels und ihre Werte —, die eine passende Component trägt, und ein Wort vendor, das ihr Name trägt. Ein Eintrag für einen Knotentyp, den die Tabelle bereits abbildet, nimmt den Platz der Tabellenzeile ein. Nur die Einträge unter dem importierten Format werden gelesen.
layoutplatformplatform entwirft die Plattform, die den Flow ausführt und den Flow trägt, wobei jeder seiner Bestandteile eine eigene Component ist, die mit der Plattform verbunden ist, wie Die Plattform, die den Flow trägt beschreibt. nodes entwirft jeden Knoten als eigene Component, wie Knoten für Knoten beschreibt. Beim Dify-Importer entwirft platform die Dify-Installation, die die Anwendung trägt, wie Was aus einer Anwendung wird beschreibt. Jeder andere Wert entwirft wie platform, und der Import warnt mit unknown-layout.
empty_credentialsnoneWelche Werte von Zugangsdaten leer geschrieben werden: im Flow, den die Plattform trägt, wie Werte von Zugangsdaten, die der Flow enthält sie aufführt, im Release, das der MCP-Importer entwirft, wie Werte von Zugangsdaten, die ein Server enthält sie aufführt, im Release, das der Compose-Importer entwirft, wie Werte von Zugangsdaten, die ein Service enthält sie aufführt, in der Anwendung, die der Dify-Importer trägt, wie Werte von Zugangsdaten, die eine Anwendung enthält sie aufführt, im Release, das der CrewAI-Importer entwirft, wie Werte von Zugangsdaten, die eine Deklaration enthält sie aufführt, im Release, das der LangGraph-Importer entwirft, wie Die Umgebung, die eine Konfiguration angibt sie aufführt, im Release, das der Google-ADK-Importer entwirft, wie Werte von Zugangsdaten, die eine Konfiguration enthält sie aufführt, und im Release, das der Agent-Framework-Importer entwirft, wie Werte von Zugangsdaten, die ein deklarativer Agent enthält sie aufführt. none schreibt keinen leer: Jeder wird wie geschrieben übernommen und in einer Warnung credential-carried genannt. marked schreibt leer, was ein Format als Zugangsdaten markiert, und jedes Element der Konfiguration eines MCP-Servers. all schreibt zusätzlich die Eingaben leer, die ein Format als keine Zugangsdaten markiert, die aber welche tragen können — Anfrage-Header, Query-Parameter, eine als Befehlszeile geschriebene Anfrage, eine nach einem Schlüssel benannte Eingabe. Was der Entwurf schreibt, damit ein Knoten seine Verbindung erreicht, wird geschrieben, was auch immer diese Einstellung sagt. Jeder andere Wert bricht den Import ab, der nichts entwirft, mit unknown-empty-credentials. Ein Knoten für Knoten erstellter Entwurf liest keinen Wert und liest daher diese Einstellung nicht.
attach_egress_allowlistfalsetrue bindet das Feature core/egress-allowlist der Standardbibliothek an jede Plattforminstanz an, die der Entwurf schreibt, als egress-allowlist, ohne etwas von seinem infra zu setzen, wie Was der Entwurf dem Release überlässt beschreibt. false bindet nichts an. Ein Entwurf, der keine Plattform schreibt, unter layout: nodes, und der Entwurf des Dify-Importers, dessen Eintrag für die Dify-Installation kein Feature aufnimmt, binden nichts an, was auch immer diese Einstellung sagt, und steht sie auf true, warnt der Import mit feature-not-attached. Jeder Wert, der kein boolescher Wert ist, wird als false gelesen.

Eine Einstellung, die ein Importer nicht kennt, wird ignoriert.

with:
settings:
mapping_overrides:
langflow:
AzureOpenAIModel:
component: acme/ai-model/azure-openai
category: ai-model
vendor: azure

Was ein Import meldet

Jeder Core-Importer meldet als Diagnosen, was er nicht tun konnte und was er im Namen des Autors getan hat. Der Befehl gibt jede auf der Standardfehlerausgabe als <severity>: <message> aus, vor der Zeile für jeden Knoten; die Methode aggrega/import der Editor-Sitzung und das Werkzeug import des Assistenten geben jede zusätzlich mit ihrem code zurück.

CodeSchweregradGemeldet, wenn
parse-failedhaltDie Quelle lässt sich nicht parsen: Ihr Parser weist sie zurück, und die Meldung enthält die Begründung des Parsers.
no-nodeswarnDie Quelle enthält keinen Knoten, den der Importer erkennt — beim MCP-Importer keinen Server, beim Compose-Importer keinen Service und kein Modell, beim CrewAI-Importer eine Crew, die keinen Agenten deklariert, beim LangGraph-Importer eine Konfiguration, die keinen Graphen deklariert, beim Google-ADK-Importer eine Wurzelkonfiguration, die keinen Agenten deklariert, oder keine der Dateien, die with.sources einem Import übergibt, enthält eine Wurzelkonfiguration, und beim Agent-Framework-Importer eine Quelle, die keinen Prompt-Agenten deklariert.
unknown-layoutwarnlayout ist weder platform noch nodes; der Flow wird als platform entworfen.
unknown-empty-credentialshaltempty_credentials enthält einen anderen Wert als none, marked oder all, zusammen mit der Einstellung genannt; der Import entwirft nichts.
platform-not-in-catalogwarnDer Workspace-Katalog enthält keine Component mit dem Namen der Plattform, daher wird kein Bestandteil mit ihr verbunden; beim Dify-Importer kein core/ai-agent/dify, und core/dify wird trotzdem zusammengesetzt.
part-not-placedwarnEin Bestandteil des Flows ist mit keinem Socket der Plattform verbunden, mit Begründung; er bleibt im Flow.
socket-selector-unreadablewarnDer Selektor, den ein Socket der Plattform deklariert, ist nicht lesbar, daher wird kein Bestandteil mit ihm verbunden; einmal für jeden Socket.
credential-carriedwarnEin Wert von Zugangsdaten wird im Flow, den der Entwurf trägt, oder im Release, das der MCP-, Compose-, CrewAI-, LangGraph-, Google-ADK- oder Agent-Framework-Importer entwirft, wie geschrieben übernommen, genannt über seinen Knoten — oder seinen Server, Service, Agenten oder seine Konfiguration — und sein Feld, niemals über seinen Wert, zusammen mit dem Wert von empty_credentials, der ihn leer schreibt.
credential-emptiedwarnEin Wert von Zugangsdaten wird im Flow, den der Entwurf trägt, oder im Release, das der MCP-, Compose-, CrewAI-, LangGraph-, Google-ADK- oder Agent-Framework-Importer entwirft, leer geschrieben, wo empty_credentials es verlangt, genannt über seinen Knoten — oder seinen Server, Service, Agenten oder seine Konfiguration — und sein Feld.
carriage-returns-rewrittenwarnDie Wagenrückläufe des Flows werden als Zeilenvorschübe geschrieben, mit ihrer Anzahl.
definition-respelledwarnWerte des Flows werden in der Schreibweise geschrieben, in der die eigenen Werkzeuge der Plattform sie lesen, mit denselben Werten, unter Angabe welcher und warum: die Kanten-Handles eines Langflow-Flows, so geschrieben, wie der Editor von Langflow sie schreibt. Ein Wert, den der Entwurf schreibt, damit der Flow einen Teil erreicht, oder einer, der Zugangsdaten tragen kann, wird nie umgeschrieben — er bleibt der der Verdrahtung oder der von empty_credentials —, und die Warnung zählt jeden nicht umgeschriebenen Wert.
definition-not-carriedwarnDer Flow wird nicht in values.flow_definition getragen, oder die Anwendung des Dify-Importers nicht in parameters.app_definition, mit Begründung.
part-reads-connectionwarnWie der Flow einen verbundenen Bestandteil über dessen Verbindung erreicht, oder wie eine Verbindung, so wie sie geschrieben ist, einen Knoten erreicht, den der Entwurf mit keinem Socket verbindet.
part-address-in-flowwarnDer Flow erreicht einen verbundenen Bestandteil auf anderem Weg als über dessen Verbindung, mit Angabe, wie.
model-not-namedwarnvalues.model eines referenzierten Bestandteils bleibt dem Autor überlassen, mit Begründung.
feature-attachedinfoattach_egress_allowlist hat core/egress-allowlist an eine entworfene Plattform angebunden, mit dem, was das Release davon setzt; einmal für jede Plattforminstanz.
feature-not-attachedwarnattach_egress_allowlist ist true, und der Entwurf schreibt keine Plattform oder setzt die Dify-Installation zusammen, deren Eintrag kein Feature aufnimmt, daher wird nichts angebunden.
part-configured-in-platformwarnEin Knoten einer Dify-Anwendung nennt etwas, das Dify für sich selbst konfiguriert — ein Modell und seinen Anbieter, ein Werkzeug, eine Wissensdatenbank, eine Agentenstrategie, ein Plugin —, daher verbindet der Entwurf keinen Bestandteil dafür.
dsl-version-newerwarnEine Dify-Anwendung ist in einer Version der DSL geschrieben, die neuer ist als die, die die Dify-Version schreibt, die core/ai-agent/dify standardmäßig ausführt.

Ein Import, dem ein Target gegeben wird, meldet nach den Diagnosen des Importers, was der Entwurf für das Manifest ergeben hat: ein warn, das jeden Komponenten- oder Feature-Typ nennt, den das Manifest unabgebildet lässt, und den Grund dafür, und ein info, wo das entworfene Release bereits ein Manifest nennt oder kein entworfenes Release darauf verweist. Diese gehören dem Import selbst statt einem Importer und tragen keinen Code; Was ein Target hinzufügt beschreibt sie. Jeder Import meldet anschließend, ebenfalls als seine eigenen, ein warn für jeden Wert, den die Entwürfe noch schulden, das die entworfene Datei, den Schlüsselpfad und seine Beschreibung nennt, und, unter --offline, wo er ein Release entworfen hat und nichts schuldet, ein info, das das als Nächstes auszuführende aggrega pull nennt, wie Die Antwortdatei des Imports beschreibt.

Mit jedem Compiler-Release veröffentlicht

Jedes Compiler-Release baut die zehn Importer aus den getaggten Quellen und erzeugt ihre Plugin-Entitäten aus den Importern selbst, sodass Fähigkeit, Erkennungssignaturen, Host-Funktionen und Beschreibung einer Entität das sind, was ihr Importer meldet. Das Release signiert und veröffentlicht alle zehn, importer/langflow, importer/flowise, importer/n8n, importer/mcp, importer/compose, importer/dify, importer/crewai, importer/langgraph, importer/google-adk und importer/agent-framework, in der Version des Release, neben den anderen Core-Plugins, und erfasst ihre Entitäten zusammen mit den Entitäten der anderen Core-Plugins für den Standardkatalog.