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

Import

aggrega import liest ein in einem anderen Format geschriebenes Projekt — einen aus Langflow exportierten Flow, die Konfiguration eines MCP-Clients, eine Compose-Datei und die weiteren unten aufgeführten Formate — und schreibt daraus Aggrega-Dateien: ein Aggregate, ein Release und, für das Ziel, das --target nennt, ein Manifest. Zusammen bilden sie einen Workspace, der sich so, wie er geschrieben ist, validieren und bauen lässt, sobald die wenigen Werte beantwortet sind, die keine Quelle enthalten kann: Der Import fragt jeden davon einmal ab und bewahrt die Antworten in einer Antwortdatei auf. Der Befehl stellt nichts bereit und greift auf keinen Cluster und kein Cloud-Konto zu. Die Entwürfe sind einfache Dateien in Ihrem Workspace, und was danach mit ihnen geschieht, entscheiden Sie.

  • LangGraph
  • CrewAI
  • n8n
  • Dify
  • Langflow
  • Flowise
  • Google ADK
  • Microsoft Agent Framework
  • MCP client configurations
  • Compose
aggrega import

Aggrega-Entwurfsdateien

zum Prüfen und Bearbeiten durch Sie

Ihr bestehendes Projekt hinein, Aggrega-Entwurfsdateien heraus. Nichts wird bereitgestellt; Sie prüfen die Entwürfe zuerst.

Was der Import Ihnen bietet

  • Ihr Projekt gelangt zu Aggrega, ohne von Hand neu geschrieben zu werden. Das entworfene Aggregate, Release und Manifest sind dieselbe Art von Dateien, die Sie selbst schreiben würden. Sie lassen sich so, wie sie geschrieben sind, für das Ziel bauen, das der Import nennt, und jede Governance-Policy, die Ihr Workspace anhängt, beurteilt diesen Build wie jeden anderen.
  • Was die Quelle angibt, wird übernommen. Ein Knoten oder Dienst, für den der Katalog eine starke Übereinstimmung enthält, referenziert diese Katalog-Component mit den Werten, die die Quelle ihm gibt, etwa dem Modell, das ein Flow nennt. Eine Plattform, auf der die Quelle läuft, wird mit dem Image entworfen, das die Recipes des Katalogs für sie ausführen. Ein Geheimnis wird als Verweis darauf entworfen, woher es stammt, nie als sein Wert.
  • Sie werden nur nach dem gefragt, was keine Quelle enthalten kann, und das nur einmal. Die Antworten werden in einer Antwortdatei neben der Quelle aufbewahrt, sodass der nächste Import derselben Quelle nichts fragt.
  • Die Entwürfe gehören Ihnen. Sie sind einfaches YAML in Ihrem Workspace, und nichts bleibt zurück, wovon der Build abhängt. Bearbeiten Sie sie, benennen Sie sie um, committen Sie sie.
  • Der Entwurf kann seiner Quelle folgen. aggrega import --sync bringt die Entwürfe eines früheren Imports auf den Stand einer geänderten Quelle und ändert dabei nur, was der Import geschrieben hat. Wo die Quelle einen Teil geändert hat, den Sie bearbeitet haben, hält der Befehl an und benennt den Teil, statt Ihre Bearbeitung zu überschreiben.

Was es nicht tut

Ein Import entwirft, was die Quelle angibt und was Ihr Katalog bestimmt, und fragt nach dem Rest. Jeder Entwurf nennt in einem Kommentar neben dem Wert, woher ein von ihm entworfener Wert stammt.

  • Er errät nicht, was Ihre Quelle nicht angeben kann. Keine Quelle nennt die Umgebung, in der ein Release bereitgestellt wird, daher nennt das entworfene Release development, mit einem Kommentar, dass dies ein zu ändernder Standardwert ist. Ein Wert, den der Katalog verlangt und den keine Quelle enthält — die E-Mail-Adresse eines Eigentümerkontos, das Image einer aus Ihrem eigenen Code gebauten Anwendung, der Name eines Kubernetes-Secrets — wird leer entworfen und abgefragt, wie Wie ein Import abläuft weiter unten beschreibt.
  • Er liest keinen Code. Das eigene Programm eines Flows oder eines Projekts wird nicht gelesen: das Programm einer CrewAI-Crew, der Graph-Code einer LangGraph-Anwendung, der Quelltext einer Langflow-Komponente, abgesehen davon, dass er innerhalb des Flows mitgeführt wird.
  • Er beurteilt nicht, was ein Wert bedeutet. Jeder Knoten oder Dienst wird gegen die Components des Katalogs Ihres Workspace abgewogen — ihre Namen, ihre Kategorien, ihre Labels und die Namen der Werte, die sie deklarieren. Eine Übereinstimmung in der oberen Stufe wird im Entwurf referenziert; eine schwächere wird als Kommentar geschrieben, der die Component und ihre Bewertung nennt, damit Sie entscheiden.
  • Er ändert nicht die Version, die eine Plattform ausführt, um der Quelle zu folgen. Das Image einer Plattform wird in der Version entworfen, von der bekannt ist, dass die Recipes des Katalogs für sie sie ausführen, und wo die Quelle eine andere Version nennt, nennt ein Kommentar neben dem Image diese.
  • Er entfernt keine Anmeldedaten für Sie aus Ihrer Quelle. Ein Wert, der einen Schlüssel enthalten kann — ein Umgebungswert, ein Header, die Befehlszeile eines MCP-Servers —, wird standardmäßig so in den Entwurf übernommen, wie er geschrieben ist, und der Import benennt jeden davon in einer Warnung credential-carried, nie über seinen Wert. Die Einstellung empty_credentials des Importers schreibt sie stattdessen leer (Einstellungen). Lesen Sie die Warnungen, bevor Sie einen Entwurf weitergeben.
  • Er stellt nichts bereit und führt nichts aus. Er liest die Quelle und Ihren Katalog und schreibt Dateien. Die Entwürfe zu bauen und auszuführen, was der Build schreibt, sind getrennte Schritte, die Sie selbst unternehmen.

Wie ein Import abläuft

Sie können einen Import mit den folgenden Befehlen ausführen oder ihn von Ihrem KI-Assistenten ausführen lassen.

  1. Beginnen Sie in einem Workspace. Ein Import schreibt seine Entwürfe unterhalb des Wurzelverzeichnisses des Workspace, in dem er läuft — des Ordners mit einer .aggrega-config.yaml, die einen Schlüssel workspace enthält —, oder unterhalb des Verzeichnisses, das --output-dir angibt. Er überschreibt nie ein bereits vorhandenes Aggregate.

  2. Der Katalog, gegen den er abwägt. Der Import bewertet Ihre Quelle gegen die Components des Katalogs des Workspace und gegen nichts anderes. Wo der Workspace keinen eigenen Katalogordner nennt, ist das der Standardbibliothek-Katalog, gelesen aus der Standard-Registry des Workspace: Jede Veröffentlichung des Katalogs veröffentlicht einen signierten Snapshot des gesamten Katalogs, und der erste Import holt diesen Snapshot, verifiziert seine Signatur, legt ihn im Content-Cache des Workspace ab und benennt ihn über seinen Digest in der Aufzeichnung, die er neben die Entwürfe schreibt, sodass ein späterer Import derselben Entwürfe denselben Katalog liest, ohne die Registry erneut zu fragen. Gegen ihn wird ein PostgreSQL-Dienst core/datastore/postgres zugeordnet, und --target entwirft aus den Recipes des Katalogs ein Manifest. Ohne Katalog hat der Import nichts zuzuordnen, und --target wird abgelehnt, da kein Recipe an das Ziel gebunden ist.

    Ein Workspace, der eigene Katalogordner nennt, importiert stattdessen gegen diese und holt keinen Snapshot: die Verzeichnisse, die workspace.catalog_dirs auflistet, ein Ordner catalog im Wurzelverzeichnis des Workspace oder die Verzeichnisse, die AGGREGA_CATALOG_DIRS angibt. Die eigenen Dateien des Standardbibliothek-Katalogs sind der Ordner aggrega-catalog des Repositorys aggrega-hub, https://github.com/aggrega-ai/aggrega-hub, für einen Workspace, der sie als Ordner haben möchte. --upgrade holt den neuesten Snapshot, den die Registry veröffentlicht, und importiert von da an gegen ihn; unter --offline hält ein Import, der einen Snapshot holen müsste, an und nennt, was auszuführen ist.

  3. Führen Sie den Import aus. Geben Sie die Datei oder das Verzeichnis an:

    Terminal window
    aggrega import compose.yaml --target compose

    Das Format wird anhand des Dateinamens und des Inhalts erkannt; --format gibt es an, wo das nicht gelingt. --target gibt eine Provider-Fähigkeit an, etwa compose oder helm, und entwirft ein Manifest, das jeden Komponententyp und jeden Funktionstyp, den die Entwürfe benötigen, dem Recipe dieser Fähigkeit zuordnet, das Ihr Katalog dafür anbietet: dem einzigen vorhandenen oder, unter mehreren, dem nach dem Typ benannten. Das entworfene Release nennt dieses Manifest, und was die Entwürfe enthalten, richtet sich nach dem Ziel: Bei compose ist ein Geheimnis ein Variablenverweis, den Docker Compose aus Ihrer Shell füllt, bei helm der Name eines Kubernetes Secret. Auf der Standardfehlerausgabe nennt der Import das gelesene Format, jede Warnung und eine Zeile für jeden zugeordneten Knoten; auf der Standardausgabe listet er die geschriebenen Dateien auf.

  4. Beantworten Sie, was keine Quelle enthält. Ein Wert, den der Katalog verlangt und den keine Quelle enthalten kann — die E-Mail-Adresse des Kontos eines Eigentümers, das Image einer aus Ihrem eigenen Code gebauten Anwendung, der Name eines Kubernetes Secret —, wird einmal beantwortet. Der Import liest die Antworten aus import-answers.yaml neben der Quelle oder aus der Datei, die --answers nennt; an einem Terminal fragt er jeden noch fehlenden Wert ab, eine Frage nach der anderen, und schreibt Ihre Antworten in diese Datei. Ein Geheimnis wird mit seiner Herkunft beantwortet — einer Variablen oder dem Namen eines Secret —, nie mit seinem Wert. Wo nichts abgefragt werden kann — in der Continuous Integration, über eine Pipe, aus dem Assistenten oder dem Editor —, schreibt der Import die Antwortdatei mit dem Schlüssel jedes fehlenden Werts und einer leeren Antwort, listet sie auf und beendet sich mit Status 1; füllen Sie sie aus und führen Sie den Import erneut aus. Eine Antwortdatei dient jedem Ziel: Eine Antwort, die die Entwürfe für ein Ziel nicht benötigen, bleibt in der Datei erhalten und ungenutzt. Die Antwortdatei des Imports beschreibt die Datei vollständig.

  5. Der Import holt, was der Build benötigt. Sobald nichts mehr fehlt, holt der Import die Abhängigkeiten des entworfenen Release, wie es aggrega pull tut, und schreibt release.lock daneben. Unter --offline holt er nichts und nennt den auszuführenden Befehl aggrega pull.

  6. Validieren und bauen Sie. Im Ordner mit den Entwürfen:

    Terminal window
    aggrega validate --release release.yaml
    aggrega build --release release.yaml

    Wenn beide erfolgreich sind, hat der Build die Dateien des Ziels unter dist/ geschrieben. Eine Ablehnung nennt, was wo zu ändern ist, in dem Dokument, das Sie ändern.

  7. Führen Sie aus, was der Build geschrieben hat. Ein Build für Docker Compose schreibt dist/compose/docker-compose.yaml, und die Datei nennt kein Compose-Projekt; geben Sie daher mit -p eines an:

    Terminal window
    docker compose -p <name> -f dist/compose/docker-compose.yaml up -d

    Ohne -p benennt Docker Compose das Projekt nach dem Ordner, der die Datei enthält, compose, sodass sich zwei auf diese Weise gestartete Arbeitsbereiche ein Projekt teilen. Die Services liegen in einem Netzwerk, das Docker Compose nach dem Projekt benennt, <name>_compose. Ein Service, für den der Build keinen Port veröffentlicht, wird aus diesem Netzwerk heraus erreicht, mit docker compose -p <name> -f dist/compose/docker-compose.yaml exec <service> …, oder aus einem Container, den Sie in diesem Netzwerk starten, mit docker run --network <name>_compose …. Die Abschnitte „Ausführen“ und „Testen“ einer Schritt-für-Schritt-Anleitung zeigen die Befehle für ihren eigenen Build.

    Ein Lauf antwortet ohne OpenAI-Schlüssel, sobald sein core/ai-model/openai-Modell auf ein kleines Modell zeigt, das Ollama im selben Projekt bereitstellt, mit drei Änderungen an den entworfenen Dateien, einem Build mit --auto-pull, der holt, was die hinzugefügte Komponente benötigt, und einem Befehl, sobald der Stack läuft:

    • im Aggregate eine weitere Komponente, mit nichts verbunden: local-model, vom Typ core/ai-model/ollama, mit model: qwen2.5:0.5b in ihren values;
    • im Manifest das zugehörige Compose-Recipe: core/ai-model/ollama: compose/ollama;
    • im Release local-model: {} sowie der endpoint des OpenAI-Modells unter dessen infra, gesetzt auf die OpenAI-kompatible Adresse dieses Servers, http://local-model:11434/v1;
    • sobald der Stack läuft, das heruntergeladene Modell unter den Modellnamen kopiert, den das OpenAI-Modell des Builds nennt, <model>, etwa gpt-4o-mini oder gpt-4.1: docker compose -p <name> -f dist/compose/docker-compose.yaml exec local-model ollama cp qwen2.5:0.5b <model>.

    OPENAI_API_KEY kann dann einen beliebigen nicht leeren Wert Ihrer Wahl enthalten: Der lokale Server prüft keinen. Ein n8n-Workflow liest Adresse und Schlüssel des Modells aus den Zugangsdaten, die sein Modellknoten auswählt, nicht aus der Adresse, die endpoint liefert; geben Sie daher auch diesen Zugangsdaten die Adresse des Servers, als url neben apiKey in deren data. Der Ollama-Server, den core/ai-model/ollama standardmäßig ausführt, stellt neben Chat Completions auch die Responses API von OpenAI bereit; daher erreicht ein deklarativer Agent-Framework-Agent, der apiType: Responses nennt, ihn so, wie er geschrieben ist.

    Ein Build für Kubernetes, das Ziel helm, schreibt einfache Manifeste statt eines Charts, wie es der helm-Provider beschreibt: unter dist/helm/ oder, für die Komponenten, die ein Release in einer Boundary platziert, unter dist/boundaries/<boundary>/helm/, einige davon in einem eigenen Ordner darunter. Dateien, die keinen Namespace nennen, wie die der MCP- und Dify-Builds, landen in dem Namespace, den Ihr kubectl-Kontext nennt, oder in default, wo er keinen nennt; legen Sie dort zuerst die Secrets an, die sie lesen, und wenden Sie dann den Ordner an:

    Terminal window
    kubectl apply -R -f dist/helm/

    -R erreicht die Dateien in diesen Ordnern. Ein ClusterIP-Service, die Art, die die MCP- und Dify-Builds den von ihnen ausgeführten Servern geben, ist nur innerhalb des Clusters erreichbar: Erreichen Sie einen von Ihrem Rechner aus, indem Sie einen lokalen Port an ihn weiterleiten, mit kubectl port-forward svc/<service> <local port>:<port>, das läuft, bis Sie es beenden.

Neben seinen Entwürfen schreibt der Import .aggrega-import.json, die Aufzeichnung dessen, was er geschrieben hat. Bewahren Sie sie auf, solange Sie aggrega import --sync ausführen wollen, das sie liest, um Ihre Bearbeitungen von seinen eigenen zu unterscheiden. Bewahren Sie auch die Antwortdatei auf: Sie enthält kein Geheimnis, kann also neben der Quelle in der Versionsverwaltung liegen, und jeder spätere Import dieser Quelle liest sie.

Mit einem KI-Assistenten

Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie diesen Prompt dort ein.

Verwende nur die Aggrega-Tools und lege selbst keinen Ordner an. Rufe das Tool `import` mit `source` auf `compose.yaml` und `target` auf `compose` gesetzt auf: Es schreibt seine Entwürfe in den Workspace-Ordner. Wenn es meldet, dass noch Werte fehlen, nenne mir jeden davon und was er ist, und warte, während ich meine Antworten neben ihre Schlüssel in die Antwortdatei schreibe, die es nennt; rufe dann das Tool `import` erneut auf dieselbe Weise auf. Rufe anschließend das Tool `validate` mit `release` auf `release.yaml` gesetzt auf, und das Tool `build` mit `release` auf `release.yaml` und `write` auf true gesetzt. Sag mir, welche Dateien der Build geschrieben hat; sie liegen unter `dist/` im Workspace-Ordner.

In VS Code öffnen

Wenn die Aggrega-Erweiterung für Visual Studio Code installiert ist, öffnen Sie den Workspace, in dem der Import lief – den Ordner mit seiner .aggrega-config.yaml –, in VS Code: Die Entwürfe liegen darin, an seiner Wurzel oder in dem Ordner, den --output-dir genannt hat. Enthält der Workspace ein Release, wählt der Editor es für Sie aus; enthält er mehrere, wählt Aggrega: Select Release… dasjenige, mit dem der Editor arbeitet. Der Editor prüft die Entwürfe beim Bearbeiten gegen das ausgewählte Release und markiert, was er findet, in der Datei und im Panel „Probleme“. Aggrega: Show topology graph in der Befehlspalette zeichnet die Komponenten des ausgewählten Release und die Verbindungen zwischen ihnen. Aggrega: Build, Aggrega: Preview build und Aggrega: Pull wirken auf dasselbe Release, und jeder ist auch eine Schaltfläche im Panel Commands der Ansicht Aggrega in der Aktivitätsleiste; Build schreibt seine Dateien in das dist/ des Workspace. Aggrega in Visual Studio Code verwenden behandelt den Rest.

Woher die Importer kommen

Jedes Format wird von einem Importer-Plugin gelesen. Die Kern-Importer des Compilers, einer für jedes Format der folgenden Tabelle, werden mit jeder Version des Compilers veröffentlicht und bedienen ihre Formate in jedem Workspace, ohne Eintrag in Ihrem Katalog. Der erste Import, der einen davon benötigt, holt ihn aus der Standard-Registry des Workspace in der eigenen Version des Compilers, verifiziert ihn und legt ihn im Content-Cache des Workspace ab, sodass jeder spätere Import ihn von dort liest, ohne dafür ein Netzwerk zu brauchen. Wo das Modul überhaupt nicht geholt werden kann — etwa weil der Workspace offline ist —, hält der Import an und nennt die zwei Wege, es auf den Rechner zu bringen. Kern-Importer beschreibt jeden Importer vollständig sowie die Einstellungen, die ein Importer über einen Eintrag plugins.importer erhält.

Die Formate

FormatWas er liestSchritt-für-Schritt-Anleitung
Composeeine Compose-Datei und ihre Override-Datei oder ein Verzeichnis, das sie enthältEin Compose-Projekt importieren
MCP-Client-Konfigurationen.mcp.json, claude_desktop_config.json, .vscode/mcp.json, .cursor/mcp.json oder eine server.json einer MCP-RegistryEine MCP-Client-Konfiguration importieren
Langflowein aus Langflow exportierter Flow, als JSONEinen Langflow-Flow importieren
Flowiseein aus Flowise exportierter Chatflow oder Agentflow, als JSONEinen Flowise-Chatflow importieren
n8nein aus n8n exportierter Workflow, als JSONEinen n8n-Workflow importieren
Difyeine aus Dify in dessen DSL exportierte Anwendung, als YAMLEine Dify-Anwendung importieren
CrewAIdie Agenten- und Task-Deklarationen eines CrewAI-ProjektsEin CrewAI-Projekt importieren
LangGraphdie langgraph.json einer LangGraph-AnwendungEine LangGraph-Anwendung importieren
Google ADKdie Agent-Config-Dateien einer auf Google ADK aufgebauten Anwendung, ausgehend von root_agent.yamlEinen Google-ADK-Agenten importieren
Microsoft Agent Frameworkein deklarativer Agent, ein YAML-Dokument der Art PromptEinen deklarativen Agenten von Microsoft Agent Framework importieren

aggrega import ist die vollständige Referenz des Befehls: jedes Flag, wie eine Quelle erkannt wird, was --sync ändert und was es ablehnt. Die Antwortdatei des Imports beschreibt die Antwortdatei: wo sie liegt, was sie enthält und wie ein Geheimnis beantwortet wird.