Importar um fluxo do Langflow
Este passo a passo importa um fluxo exportado do Langflow — Basic Prompting, o projeto inicial que acompanha o Langflow 1.6.0 — para um Aggregate, uma Release e um Manifest que, tal como estão escritos, fazem o build do Langflow com o fluxo para Docker Compose; em seguida, faz o build deles e executa o resultado. Cada arquivo e cada bloco de saída abaixo vêm de uma execução real; o fluxo e cada etapa do passo a passo estão no exemplo import-langflow, onde um script de verificação executa a importação novamente, compara o que ela escreve, o que ela imprime e os blocos que esta página cita com os arquivos mantidos lá, e valida e faz o build do que a importação escreveu.
Gerar o exemplo
Você pode executar esta importação com os comandos desta página ou pedir ao seu assistente de IA que a execute para você.
Escreva o exemplo em uma nova pasta com o nome dele:
aggrega scaffold --example import-langflowEm seguida ele imprime os próximos comandos a executar. O primeiro entra na pasta nova; o seguinte, abaixo, entra na pasta source da pasta nova, onde a importação é executada. Essa pasta contém o arquivo do fluxo, basic-prompting.json, que esta página descreve em vez de citar:
cd import-langflow
O fluxo
O Basic Prompting encadeia quatro nós: um Chat Input, um Prompt, um Language Model que chama o gpt-4.1 da OpenAI e um Chat Output. Tal como o Langflow o distribui, ele é um único arquivo JSON, basic-prompting.json, de cerca de 54 KB, que traz o código-fonte de cada componente além do fluxo. Seu nó Language Model lê a chave da variável global OPENAI_API_KEY, que o Langflow lê do seu ambiente quando nenhuma variável com esse nome está armazenada.
Ao lado do fluxo, um .aggrega-config.yaml torna a pasta um espaço de trabalho:
# The workspace key marks this directory as the workspace root, so an import run# here writes its drafts beside basic-prompting.json.workspace: {}# The registry the importer is fetched from the first time an import needs it.default_registry: hub.aggrega.aie import-answers.yaml contém as respostas para o que nenhum fluxo pode conter. Uma importação para Docker Compose não precisa de nenhuma delas: ela anexa cada segredo por uma referência de variável que o Docker Compose preenche a partir do seu shell. Uma importação para Kubernetes anexa cada segredo pelo nome de um Secret do Kubernetes, que só você pode nomear, então o arquivo nomeia os dois Secrets que essa importação pede (veja No Kubernetes):
# Values the import could not draft from the source, keyed by the drafted file and the key path inside# it. Write each one beside its key; an import of the same source, and a sync, read them from here and# ask nothing. A secret is never written here: its key asks where the secret comes from — a variable# name, ${NAME}, or the name of a Kubernetes Secret.release.yaml: # The origin of the secret value, written by the operator in the Release. Read exactly as # values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes # from, never the value. spec.components.langflow.features.admin_password.infra.origin: "langflow-admin" # The origin of the secret value, written by the operator in the Release. Read exactly as # values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes # from, never the value. spec.components.langflow.uses.model.languagemodelcomponent-kboja.features.credential.infra.origin: "openai-api-key"Cada resposta é o nome de um Secret, nunca o segredo em si, então o arquivo pode ser mantido junto com o fluxo. O arquivo de respostas da importação descreve o arquivo por completo.
A importação compara cada nó com os Components do catálogo do espaço de trabalho, e --target rascunha um Manifest a partir das Recipes desse catálogo. O espaço de trabalho não indica nenhuma pasta de catálogo, então a importação lê o catálogo da biblioteca padrão a partir do registro do qual obtém o seu importador: um snapshot assinado do catálogo publicado, que a primeira importação busca, verifica e guarda no cache de conteúdo do espaço de trabalho, e que o histórico que a importação escreve ao lado dos seus rascunhos indica pelo seu digest. Um espaço de trabalho que indica suas próprias pastas de catálogo — em AGGREGA_CATALOG_DIRS, ou em workspace.catalog_dirs — importa a partir delas em vez disso. Entre em source:
cd sourceExecutar a importação
aggrega import basic-prompting.json --target composeNa saída padrão, ela lista o que gravou:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonNa saída de erro padrão, com <workspace> representando a pasta em que você a executou:
[… omitted: a warning that the importer runs unverified, printed where its module is read from beside its Plugin entity in a catalog folder rather than fetched]read as the langflow format, with drafted paths relative to <workspace>warn: the flow is carried in values.flow_definition with the handles of all 3 of its edges written as Langflow's editor writes them — the same handles, their keys in order with no space between them — since the editor compares an edge's handles with the ones it writes for the nodes the edge joins, character for character, when it opens the flow, and drops every edge whose handles differwarn: node LanguageModelComponent-kBOja reaches languagemodelcomponent-kboja through the model connection languagemodelcomponent-kboja of core/ai-agent/langflow: its field api_key names the variable OPENAI_API_KEY, which the platform delivers for this connection and Langflow reads as a global variable; no field of it gives its API's address, so the OpenAI client it runs takes OPENAI_BASE_URL, the address the platform delivers for this connection, from the environmentmade no choice for ChatInput-SzjnT (ChatInput)made no choice for Prompt-tOH5D (Prompt)made no choice for ChatOutput-8ZWWB (ChatOutput)mapped LanguageModelComponent-kBOja (LanguageModelComponent) to core/ai-model/openai as a reference, HIGH at 0.9 warning: node "langflow" (provider "compose"): artifact "langflow-flow/langflow-flow.yaml": skipped provenance label injection — the fragment declares no compose service. Compose carries build provenance as service labels, so a fragment contributing only top-level networks, volumes or configs carries none; the services this component emits elsewhere carry the full set.Pull complete: <workspace>/release.lock (entities=8, source_artifacts=0, external_inputs=0)
- A linha
mappeddiz em que o nó Language Model se tornou: o modelo OpenAI da biblioteca padrão,core/ai-model/openai, referenciado em vez de rascunhado, já que correspondeu no nível alto, com pontuação 0.9. É um componente próprio, ligado ao socketmodelda plataforma. Por padrão, o rascunho executa o fluxo inteiro na plataforma que executa o Langflow, e dá um componente próprio apenas a um nó que um socket dessa plataforma recebe — um modelo, uma ferramenta, um armazenamento vetorial — quando o nó é reconhecido como tal. - A primeira linha
warndiz que o fluxo é levado com os handles de cada aresta escritos como o editor do Langflow os escreve. O Langflow mantém seus projetos iniciais com um espaço após cada dois-pontos e cada vírgula dos handles de uma aresta; seu editor, ao abrir um fluxo, descarta toda aresta cujos handles não estejam escritos exatamente como ele os escreve e depois salva o fluxo sem ela. Escrito assim, o fluxo abre com suas três conexões e é executado com elas. - A linha
warnque nomeia o nó diz como o fluxo chega a esse modelo. O nó lê sua chave da variávelOPENAI_API_KEY, e seu endereço deOPENAI_BASE_URL, e a plataforma entrega ambos para a conexão do modelo, então o fluxo não precisa de nenhuma edição. - As linhas
made no choicenomeiam os nós que nenhum socket da plataforma recebe: eles permanecem dentro do fluxo, que o Langflow executa tal como foi exportado. - As duas últimas linhas são o pull. Não restava nada a responder, então a importação baixou as dependências da Release rascunhada, como faz
aggrega pull, e escreveurelease.lock; o build abaixo não precisa de mais nada. A linhawarningé uma que o build também imprime, e Validar e compilar a explica.
O arquivo de respostas nomeia dois Secrets que esta importação não pede: ela não deixa nada vazio para eles, então não aplica nenhum e deixa o arquivo como está.
O que a importação grava
O Aggregate, a Release e o Manifest se chamam imported/basic-prompting, a partir do nome próprio do fluxo, Basic Prompting, reduzido a basic-prompting — um fluxo sem nome recebe o nome do seu arquivo — sob o namespace definido pela configuração target_namespace do importador, imported, a menos que você defina outro (Configurações).
aggregate.yaml — uma instância da plataforma Langflow da biblioteca padrão, core/ai-agent/langflow, com o fluxo tal como foi exportado, exceto pelos handles de suas arestas, escritos como o editor do Langflow os escreve, do qual mais de mil linhas foram omitidas aqui, e o modelo que ele alcança:
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/basic-prompting version: 0.1.0 description: Draft Aggregate imported from a source in the langflow format.spec: components: langflow: type: core/ai-agent/langflow features: # For the compose target, the lines below declare admin_password on langflow: 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. admin_password: type: core/secret-value values: key: LANGFLOW_SUPERUSER_PASSWORD values: flow_id: '0dbee653-41ae-4e51-af2e-55757fb24be3' flow_definition: |- { "data": { "edges": [ [… omitted: the rest of the flow] } uses: model: languagemodelcomponent-kboja: target: languagemodelcomponent-kboja # For the compose target, the lines below declare credential on languagemodelcomponent-kboja: 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 languagemodelcomponent-kboja: type: core/ai-model/openai values: model: |- gpt-4.1- O modelo é
core/ai-model/openai, com o modelo que o nó do fluxo seleciona,gpt-4.1. O comentário acima dele nomeia outro Component do catálogo com o qual o nó se parece, com sua pontuação, para quem preferir esse. - Os dois segredos — a senha do administrador que o editor do Langflow pede e a chave da OpenAI que a plataforma apresenta ao modelo — são declarados aqui com a variável sob a qual cada um chega ao ambiente do Langflow,
LANGFLOW_SUPERUSER_PASSWORDeOPENAI_API_KEY. No Docker Compose, um segredo anexado apenas pela Release chegaria sob a chavevalue, e os dois colidiriam; declarados aqui, cada um tem uma chave própria. A Release diz de onde vem cada um. flow_idé o identificador que a exportação dá ao fluxo.
release.yaml — a Release, que implanta o Aggregate com o Manifest:
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: name: imported/basic-prompting # 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 langflow format.spec: aggregate: imported/basic-prompting manifest: imported/basic-prompting components: langflow: infra: # The image running core/ai-agent/langflow, 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. The source states version "1.5.0" of the platform. image: "langflowai/langflow:1.6.0" # Published on this machine's loopback address, 127.0.0.1: reachable from this machine only, by any process running on it. Delete this line to keep the service internal. published_port: 7860 features: admin_password: type: core/secret-value infra: # Attached by reference, never as a value: the administrator's password, read while values.require_authentication stays true, read from the variable LANGFLOW_ADMIN_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: "${LANGFLOW_ADMIN_PASSWORD}" uses: model: languagemodelcomponent-kboja: features: credential: type: core/secret-value infra: # Attached by reference, never as a value: the credential langflow presents to languagemodelcomponent-kboja 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}" languagemodelcomponent-kboja: {}environmentédevelopment, um padrão que o comentário acima dele diz para trocar pelo ambiente em que a Release é implantada.- A imagem é Langflow 1.6.0, a versão que as Recipes do catálogo para Langflow executam. O fluxo foi testado pela última vez no Langflow 1.5.0, como diz o comentário; a importação mantém a versão que as Recipes executam em vez de seguir a do fluxo.
published_porté 7860, a porta em que o Langflow atende, então o editor responde emhttp://127.0.0.1:7860na sua máquina. Como diz o comentário, qualquer processo nesta máquina pode alcançá-lo ali e nada mais pode; apague a linha para manter o Langflow apenas na rede da stack.- Os dois segredos são referências de variáveis,
${LANGFLOW_ADMIN_PASSWORD}e${OPENAI_API_KEY}, que o Docker Compose preenche a partir do seu shell quando a stack é iniciada, então nenhum arquivo contém nenhum dos dois valores.
manifest.yaml — as Recipes de Compose da plataforma e do modelo, e a realização que escreve a referência de variável de um segredo no arquivo Compose tal como foi escrita:
apiVersion: aggrega.ai/v1beta1kind: Manifestmetadata: name: imported/basic-prompting version: 0.1.0spec: mappings: components: type: core/ai-agent/langflow: compose/langflow core/ai-model/openai: compose/openai features: type: core/secret-value: compose/dotenv-secret.aggrega-import.json é o registro do que a importação escreveu, que um aggrega import --sync posterior lê, e release.lock fixa cada entidade do catálogo para a qual a Release se resolve, por versão e digest.
Validar e compilar
aggrega validate --release release.yamlaggrega build --release release.yaml

A validação imprime:
notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)release dependency validation passed: release.yaml (schema-pillar + dependency pillars)e o build, com <workspace> representando a pasta que contém os rascunhos:
warning: node "langflow" (provider "compose"): artifact "langflow-flow/langflow-flow.yaml": skipped provenance label injection — the fragment declares no compose service. Compose carries build provenance as service labels, so a fragment contributing only top-level networks, volumes or configs carries none; the services this component emits elsewhere carry the full set. notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)[… omitted: a total build time, which differs per run]Build completed: 1 file written to <workspace>/distA linha warning trata da parte do arquivo Compose que carrega o fluxo, uma entrada configs de nível superior, que não tem nenhum serviço onde colocar os rótulos do build. A linha notice é informativa: a Feature de segredo aceita seu origin dos values do Aggregate ou do infra da Release, e o aviso informa que uma folha está declarada em ambos. Nenhuma das duas altera o veredito.
dist/compose/docker-compose.yaml contém o Langflow e um serviço que é executado uma vez antes dele:
services: langflow: image: langflowai/langflow:1.6.0 environment: LANGFLOW_CONFIG_DIR: /app/langflow LANGFLOW_SAVE_DB_IN_CONFIG_DIR: "true" LANGFLOW_AUTO_LOGIN: "false" LANGFLOW_SUPERUSER: admin LANGFLOW_SUPERUSER_PASSWORD: ${LANGFLOW_ADMIN_PASSWORD} OPENAI_BASE_URL: https://api.openai.com/v1 OPENAI_API_KEY: ${OPENAI_API_KEY} LANGFLOW_LOAD_FLOWS_PATH: /app/flows ports: - 127.0.0.1:7860:7860 [… omitted: the labels the build writes on every service, naming the Aggregate, the component, the environment and the compiler's version] volumes: - type: volume source: langflow--data target: /app/langflow networks: - compose depends_on: langflow--data-owner: condition: service_completed_successfully [… omitted: the service's health check] configs: - source: langflow-flow target: /app/flows/flow.json langflow--data-owner: image: langflowai/langflow:1.6.0 entrypoint: - chown - "1000:0" - /app/langflow [… omitted: the labels the build writes on every service] volumes: - type: volume source: langflow--data target: /app/langflow networks: - compose restart: "no" user: "0"O fluxo chega ao Langflow como /app/flows/flow.json, a partir de uma entrada configs que contém o fluxo que o Aggregate carrega, e o Langflow o carrega de LANGFLOW_LOAD_FLOWS_PATH a cada inicialização. A chave e a senha são referências de variável, preenchidas a partir do seu shell quando a stack é iniciada. A Recipe do Compose do Langflow publica uma porta na sua máquina somente onde a Release define published_port no infra do Langflow, e então apenas no endereço de loopback, 127.0.0.1; sem isso, o serviço só é alcançado na rede da stack.
langflow--data-owner executa a imagem do Langflow como root, entrega o volume de dados ao usuário 1000, grupo 0, a identidade com que a imagem do Langflow é executada, e encerra. O Langflow inicia assim que esse serviço termina: o Docker cria o volume pertencente ao root, e de outra forma o Langflow não conseguiria gravar seus dados nele.
Com um assistente de IA
Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole este prompt nele.
Use apenas as ferramentas do Aggrega e não crie nenhuma pasta por conta própria. Se a pasta do Workspace ainda não contiver uma pasta `import-langflow`, chame a ferramenta `scaffold` uma vez com `example` definido como `import-langflow` e sem `dir`: ela grava o exemplo em uma nova pasta `import-langflow`, cuja pasta `source` contém o que esta página importa. Em seguida, chame a ferramenta `import` com `workspace_root` definido como `import-langflow/source`, `source` definido como `basic-prompting.json` e `target` definido como `compose`: ela lê as respostas de que precisa em `import-answers.yaml` ao lado de `basic-prompting.json`, grava seus rascunhos em `import-langflow/source` e baixa o que eles precisam. Em seguida, chame a ferramenta `validate` com `workspace_root` definido como `import-langflow/source` e `release` definido como `release.yaml`, e a ferramenta `build` com `workspace_root` definido como `import-langflow/source`, `release` definido como `release.yaml` e `write` definido como true. Diga-me quais arquivos a compilação gravou; eles ficam em `import-langflow/source/dist/`.Abra no VS Code
Com a extensão do Aggrega para Visual Studio Code instalada, abra no VS Code a pasta import-langflow/source, onde a importação gravou seus rascunhos. A pasta contém uma única Release, o release.yaml gerado, então o editor a seleciona para você e verifica os rascunhos em relação a essa Release enquanto você os edita, marcando o que encontra no arquivo e no painel Problemas. Aggrega: Show topology graph, na Paleta de Comandos, desenha os componentes da Release e as conexões entre eles. Aggrega: Build, Aggrega: Preview build e Aggrega: Pull atuam sobre a mesma Release, e cada um também é um botão no painel Commands da visualização Aggrega na barra de atividades; Build grava seus arquivos no dist/ da pasta. Usar o Aggrega no Visual Studio Code cobre o restante.
Execução
Defina a chave e a senha do administrador no seu shell e, em seguida, inicie a stack:
export OPENAI_API_KEY='your OpenAI key'export LANGFLOW_ADMIN_PASSWORD='a password of your own'docker compose -p basic-prompting -f dist/compose/docker-compose.yaml up -d --wait-p nomeia o projeto, como explica a etapa de execução de Como uma importação é executada. --wait retorna assim que langflow--data-owner termina e o Langflow informa que está íntegro.
Teste
Abra http://127.0.0.1:7860, o endereço que published_port publica, e entre como admin com a senha que você definiu: o Basic Prompting está no editor com suas três conexões.
O Langflow executa um fluxo pela sua API somente para uma chave de API, que um administrador cria depois de entrar. Entre:
curl -sS -X POST http://127.0.0.1:7860/api/v1/login \ -d username=admin --data-urlencode "password=$LANGFLOW_ADMIN_PASSWORD"{"access_token":"[… omitted: the access token]","refresh_token":"[… omitted: the refresh token]","token_type":"bearer"}crie uma chave com o token de acesso:
curl -sS -X POST http://127.0.0.1:7860/api/v1/api_key/ \ -H 'Authorization: Bearer <access_token>' -H 'Content-Type: application/json' -d '{"name": "test-it"}'{"name":"test-it","last_used_at":null,"total_uses":0,"is_active":true,"id":"[… omitted: the key's identifier]","api_key":"[… omitted: the key]","user_id":"[… omitted: the owner's identifier]"}e execute o fluxo com a chave:
curl -sS -X POST 'http://127.0.0.1:7860/api/v1/run/0dbee653-41ae-4e51-af2e-55757fb24be3?stream=false' \ -H 'x-api-key: <api_key>' -H 'Content-Type: application/json' \ -d '{"input_value": "In one short sentence: what is Docker Compose?", "input_type": "chat", "output_type": "chat"}'A execução usou um placeholder para a chave da OpenAI, então a resposta é a recusa da chave pela OpenAI, o que mostra que o fluxo foi executado até a sua chamada ao modelo:
{"detail":"{\"message\":\"Error running graph: Error building Component Language Model: \\n\\nError code: 401 - {'error': {'message': 'Incorrect API key provided: sk-place*****************-key. You can find your API key at https://platform.openai.com/account/api-keys.', 'type': 'invalid_request_error', 'code': 'invalid_api_key', 'param': None}, 'status': 401}\",[… omitted: three empty fields, and a suggestion to update three of the flow's components]}"}Com a sua chave, a resposta traz a resposta do modelo em outputs[0].outputs[0].results.message.text.
No Kubernetes, com a compilação descrita em No Kubernetes aplicada, encaminhe uma porta local para o Service do Langflow, langflow-default, no namespace ao qual você aplicou, e deixe o comando em execução:
kubectl port-forward -n <namespace> svc/langflow-default 7860:7860De outro terminal, as três requisições acima chegam ao Langflow no mesmo endereço, sem alterações; a execução obteve a mesma recusa da chave placeholder.
Pare a stack com o comando abaixo. -v também remove o volume de dados do Langflow e, com ele, a conta do administrador, a chave de API e o histórico de execuções do fluxo:
docker compose -p basic-prompting -f dist/compose/docker-compose.yaml down -vNo Kubernetes
O mesmo fluxo é importado para Kubernetes com o target helm. Os rascunhos para Docker Compose já estão em source, e a importação nunca sobrescreve um Aggregate que esteja ali, então gere estes em uma pasta própria com --output-dir e depois valide e compile a partir dela:
aggrega import basic-prompting.json --target helm --output-dir helmcd helmaggrega validate --release release.yamlaggrega build --release release.yamlOs rascunhos diferem onde o destino difere. O Manifest mapeia a plataforma para helm/langflow, o modelo para helm/openai e cada segredo para helm/k8s-existing-secret, que o lê de um Secret já existente no namespace. A Release anexa os dois segredos como core/referenced-secret, cada um nomeando esse Secret, e os nomes são o que o arquivo de respostas contém:
features: admin_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 administrator's password, read while values.require_authentication stays true. origin: "langflow-admin"Sem o arquivo de respostas, a importação pede os dois nomes em um terminal e grava suas respostas em um novo arquivo de respostas. Onde nada pode ser perguntado, ela grava esse arquivo com as duas chaves e respostas vazias, e termina com status 1 e esta linha, em que <workspace> representa a pasta em que você a executou:
2 values the drafts leave empty are still owed, listed in the answers file <workspace>/import-answers.yaml: write each beside its key there, then run the import againA compilação grava manifestos simples do Kubernetes em dist/helm/ na raiz do workspace, source, que a partir de helm é ../dist/helm/. Crie os dois Secrets no namespace ao qual você aplica, cada um contendo seu valor sob a chave de dados value, e então aplique a pasta como explica a etapa de execução de Como uma importação é executada.