Przejdź do głównej zawartości
AggregaAggrega
Wybierz język: Polski
Ta strona została przetłumaczona maszynowo. Przeczytaj oryginał w języku angielskim.

Importowanie przepływu z Langflow

Ten przewodnik krok po kroku importuje przepływ wyeksportowany z Langflow — Basic Prompting, projekt startowy dostarczany z Langflow 1.6.0 — do encji Aggregate, Release i Manifest, które w postaci, w jakiej zostały zapisane, budują Langflow z tym przepływem dla Docker Compose, a następnie je buduje i uruchamia wynik. Każdy plik i każdy blok wyjścia poniżej pochodzi z rzeczywistego uruchomienia; przepływ i każdy etap przewodnika znajdują się w przykładzie import-langflow, w którym skrypt sprawdzający ponownie uruchamia import, porównuje to, co zapisuje, to, co wypisuje, oraz bloki cytowane na tej stronie z przechowywanymi tam plikami, a także waliduje i buduje to, co zapisał import.

Generowanie przykładu

Ten import można uruchomić poleceniami z tej strony albo zlecić to asystentowi AI.

Należy zapisać przykład w nowym folderze nazwanym tak jak on:

Terminal window
aggrega scaffold --example import-langflow

Następnie wypisuje polecenia do uruchomienia w dalszej kolejności. Pierwsze przechodzi do nowego folderu; kolejne, poniżej, przechodzi do folderu source w nowym folderze, w którym uruchamia się import. Ten folder zawiera plik przepływu, basic-prompting.json, który ta strona opisuje, zamiast go cytować:

Terminal window
cd import-langflow

Folder source wygenerowanego przykładu otwarty w Visual Studio Code, pokazujący eksport Langflow podstawowego przepływu promptowania.

Przepływ

Basic Prompting łączy w łańcuch cztery węzły: Chat Input, Prompt, Language Model wywołujący gpt-4.1 od OpenAI oraz Chat Output. W postaci, w jakiej dostarcza go Langflow, jest jednym plikiem JSON, basic-prompting.json, o rozmiarze około 54 KB, który oprócz przepływu zawiera kod źródłowy każdego komponentu. Jego węzeł Language Model odczytuje klucz ze zmiennej globalnej OPENAI_API_KEY, którą Langflow odczytuje ze swojego środowiska, gdy nie jest zapisana żadna zmienna o tej nazwie.

Obok przepływu plik .aggrega-config.yaml czyni folder przestrzenią roboczą:

# 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.ai

a import-answers.yaml zawiera odpowiedzi na to, czego żaden przepływ nie może zawierać. Import dla Docker Compose nie potrzebuje żadnej z nich: dołącza każdy sekret przez odwołanie do zmiennej, które Docker Compose wypełnia z powłoki użytkownika. Import dla Kubernetes dołącza każdy sekret przez nazwę obiektu Secret Kubernetes, którą może wskazać tylko użytkownik, dlatego plik wskazuje dwa obiekty Secret, o które prosi ten import (zob. W 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"

Każda odpowiedź to nazwa obiektu Secret, nigdy sam sekret, dlatego plik można przechowywać razem z przepływem. Plik odpowiedzi importu opisuje ten plik w całości.

Import porównuje każdy węzeł z encjami Components z katalogu przestrzeni roboczej, a --target tworzy szkic encji Manifest na podstawie jego encji Recipes. Przestrzeń robocza nie wskazuje żadnego folderu katalogu, więc import odczytuje katalog biblioteki standardowej z rejestru, z którego pobiera swój importer: podpisaną migawkę opublikowanego katalogu, którą pierwszy import pobiera, weryfikuje i przechowuje w pamięci podręcznej treści przestrzeni roboczej i którą rekord zapisywany przez import obok jego szkiców wskazuje za pomocą jej skrótu. Przestrzeń robocza, która wskazuje własne foldery katalogu — w AGGREGA_CATALOG_DIRS lub pod workspace.catalog_dirs — importuje zamiast tego względem nich. Należy przejść do source:

Terminal window
cd source

Uruchomienie importu

Terminal window
aggrega import basic-prompting.json --target compose

Na standardowym wyjściu wymienia to, co zapisał:

wrote aggregate.yaml
wrote release.yaml
wrote manifest.yaml
wrote .aggrega-import.json

Na standardowym wyjściu błędów, gdzie <workspace> oznacza folder, w którym go uruchomiono:

[… 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 differ
warn: 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 environment
made 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)

Import uruchomiony z edytora: wygenerowane encje Aggregate, Release i Manifest pojawiają się obok eksportu przepływu, wyjście Aggrega pokazuje, jak zmapowano każdy komponent przepływu, oraz zapisane pliki, a powiadomienie informuje, że import wygenerował 3 pliki, rozpoznane jako langflow.

  • Wiersz mapped mówi, czym stał się węzeł Language Model: modelem OpenAI z biblioteki standardowej, core/ai-model/openai, do którego się odwołano zamiast go szkicować, ponieważ dopasował się na wysokim poziomie, z wynikiem 0.9. Jest to osobny komponent, podłączony do gniazda model platformy. Domyślnie szkic uruchamia cały przepływ na platformie, która uruchamia Langflow, i daje osobny komponent tylko węzłowi przyjmowanemu przez gniazdo tej platformy — modelowi, narzędziu, magazynowi wektorów — o ile węzeł zostanie jako taki rozpoznany.
  • Pierwszy wiersz warn mówi, że przepływ jest przenoszony z uchwytami każdej krawędzi zapisanymi tak, jak zapisuje je edytor Langflow. Langflow przechowuje swoje projekty startowe ze spacją po każdym dwukropku i każdym przecinku w uchwytach krawędzi; jego edytor przy otwieraniu przepływu usuwa każdą krawędź, której uchwyty nie są zapisane dokładnie tak, jak on je zapisuje, a następnie zapisuje przepływ bez niej. Zapisany w ten sposób przepływ otwiera się ze swoimi trzema połączeniami i z nimi działa.
  • Wiersz warn wskazujący węzeł mówi, jak przepływ dociera do tego modelu. Węzeł odczytuje swój klucz ze zmiennej OPENAI_API_KEY, a swój adres z OPENAI_BASE_URL, a platforma dostarcza oba dla połączenia z modelem, więc przepływ nie wymaga edycji.
  • Wiersze made no choice wymieniają węzły, których nie przyjmuje żadne gniazdo platformy: pozostają one wewnątrz przepływu, który Langflow uruchamia w postaci, w jakiej został wyeksportowany.
  • Ostatnie dwa wiersze to pobranie. Nie zostało nic do odpowiedzi, więc import pobrał zależności naszkicowanej encji Release, tak jak robi to aggrega pull, i zapisał release.lock; poniższa kompilacja nie potrzebuje niczego więcej. Wiersz warning wypisuje także kompilacja, a Walidacja i kompilacja go wyjaśnia.

Plik odpowiedzi wskazuje dwa obiekty Secret, o które ten import nie pyta: nie pozostawia dla nich niczego pustego, więc nie stosuje żadnego z nich i pozostawia plik bez zmian.

Co zapisuje import

Encje Aggregate, Release i Manifest otrzymują nazwę imported/basic-prompting od własnej nazwy przepływu, Basic Prompting, sprowadzonej do basic-prompting — przepływ bez nazwy otrzymuje nazwę od swojego pliku — w przestrzeni nazw określonej przez ustawienie target_namespace importera, imported, o ile nie ustawi się innej (Ustawienia).

aggregate.yaml — jedna instancja platformy Langflow z biblioteki standardowej, core/ai-agent/langflow, niosąca przepływ w takiej postaci, w jakiej został wyeksportowany, z wyjątkiem uchwytów jego krawędzi, zapisanych tak, jak zapisuje je edytor Langflow, z ponad tysiącem jego wierszy pominiętych tutaj, oraz model, do którego przepływ dociera:

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
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
  • Model to core/ai-model/openai, z modelem wybranym przez węzeł przepływu, gpt-4.1. Komentarz nad nim wskazuje inną encję Component z katalogu, do której węzeł jest podobny, wraz z jej wynikiem, dla czytelnika, który woli właśnie ją.
  • Dwa sekrety — hasło administratora, o które pyta edytor Langflow, i klucz OpenAI, który platforma przedstawia modelowi — są zadeklarowane tutaj wraz ze zmienną, pod którą każdy z nich trafia do środowiska Langflow, LANGFLOW_SUPERUSER_PASSWORD i OPENAI_API_KEY. W Docker Compose sekret dołączony wyłącznie przez encję Release trafiłby pod klucz value, a oba by ze sobą kolidowały; zadeklarowany tutaj każdy ma własny klucz. Encja Release określa, skąd pochodzi każdy z nich.
  • flow_id to identyfikator, który eksport nadaje przepływowi.

release.yaml — encja Release, która wdraża encję Aggregate z encją Manifest:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
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 ma wartość development, domyślną, którą według komentarza nad nią należy zmienić na środowisko, w którym wdrażana jest encja Release.
  • Obraz to Langflow 1.6.0, wersja uruchamiana przez encje Recipes z katalogu dla Langflow. Przepływ był ostatnio testowany na Langflow 1.5.0, jak mówi komentarz; import zachowuje wersję uruchamianą przez encje Recipes, zamiast podążać za wersją przepływu.
  • published_port to 7860, port, na którym działa Langflow, więc edytor odpowiada pod adresem http://127.0.0.1:7860 na maszynie lokalnej. Jak mówi jego komentarz, każdy proces na tej maszynie może tam do niego dotrzeć, a nic innego nie może; aby pozostawić Langflow wyłącznie w sieci stosu, należy usunąć ten wiersz.
  • Dwa sekrety to odwołania do zmiennych, ${LANGFLOW_ADMIN_PASSWORD} i ${OPENAI_API_KEY}, które Docker Compose wypełnia z powłoki przy uruchamianiu stosu, więc żaden plik nie zawiera żadnej z tych wartości.

manifest.yaml — encje Recipes dla Compose dla platformy i modelu oraz realizacja, która zapisuje odwołanie do zmiennej sekretu w pliku Compose dosłownie:

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/basic-prompting
version: 0.1.0
spec:
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 to zapis tego, co zapisał import, odczytywany przez późniejsze aggrega import --sync, a release.lock przypina każdą encję katalogu, na którą rozwiązuje się encja Release, według wersji i skrótu (digest).

Walidacja i kompilacja

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

Wygenerowana encja Release otwarta w edytorze po walidacji; wyjście Aggrega i powiadomienie zgłaszają, że nie znaleziono problemów.

Build wygenerowanej encji Release: w Eksploratorze pojawia się folder dist, wyjście Aggrega pokazuje zapisany plik Docker Compose, a powiadomienie informuje, że zapisano 1 plik.

Walidacja wypisuje:

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)

a kompilacja, gdzie <workspace> oznacza folder zawierający szkice:

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

Wiersz warning dotyczy części pliku Compose, która niesie przepływ, wpisu configs najwyższego poziomu, który nie ma żadnej usługi, na której można by umieścić etykiety kompilacji. Wiersz notice ma charakter informacyjny: encja Feature sekretu przyjmuje swój origin z values encji Aggregate lub z infra encji Release, a komunikat zgłasza, że jeden liść jest zadeklarowany w obu miejscach. Żaden z nich nie zmienia werdyktu.

dist/compose/docker-compose.yaml zawiera Langflow oraz usługę, która uruchamia się jednorazowo przed nim:

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"

Przepływ dociera do Langflow jako /app/flows/flow.json, z wpisu configs zawierającego przepływ niesiony przez encję Aggregate, a Langflow ładuje go z LANGFLOW_LOAD_FLOWS_PATH przy każdym starcie. Klucz i hasło są odwołaniami do zmiennych, wypełnianymi z powłoki przy uruchamianiu stosu. Encja Recipe dla Compose platformy Langflow publikuje port na maszynie lokalnej tylko tam, gdzie encja Release ustawia published_port w infra platformy Langflow, i wtedy wyłącznie na adresie pętli zwrotnej, 127.0.0.1; bez tego usługa jest osiągalna tylko w sieci stosu.

langflow--data-owner uruchamia obraz Langflow jako root, przekazuje wolumen danych użytkownikowi 1000, grupie 0, czyli tożsamości, z którą działa obraz Langflow, i kończy działanie. Langflow uruchamia się dopiero po zakończeniu tej usługi: Docker tworzy wolumen należący do roota, a w przeciwnym razie Langflow nie mógłby zapisywać tam swoich danych.

Z asystentem AI

Asystent AI skonfigurowany z narzędziami Aggrega może zrobić to samo: wystarczy wkleić do niego ten prompt.

Używaj wyłącznie narzędzi Aggrega i nie twórz samodzielnie żadnego folderu. Jeśli folder Workspace nie zawiera jeszcze folderu `import-langflow`, wywołaj raz narzędzie `scaffold` z `example` ustawionym na `import-langflow` i bez `dir`: zapisuje ono przykład w nowym folderze `import-langflow`, którego folder `source` zawiera to, co importuje ta strona. Następnie wywołaj narzędzie `import` z `workspace_root` ustawionym na `import-langflow/source`, `source` ustawionym na `basic-prompting.json` i `target` ustawionym na `compose`: odczytuje ono potrzebne odpowiedzi z `import-answers.yaml` obok `basic-prompting.json`, zapisuje swoje wersje robocze w `import-langflow/source` i pobiera to, czego potrzebują. Następnie wywołaj narzędzie `validate` z `workspace_root` ustawionym na `import-langflow/source` i `release` ustawionym na `release.yaml` oraz narzędzie `build` z `workspace_root` ustawionym na `import-langflow/source`, `release` ustawionym na `release.yaml` i `write` ustawionym na true. Powiedz mi, które pliki zapisał build; znajdują się w `import-langflow/source/dist/`.

Otwieranie w VS Code

Po zainstalowaniu rozszerzenia Aggrega dla Visual Studio Code należy otworzyć w VS Code folder import-langflow/source, w którym import zapisał swoje wersje robocze. Folder zawiera jedną encję Release, wygenerowany release.yaml, więc edytor wybiera ją automatycznie i podczas edycji sprawdza wersje robocze względem tej encji Release, oznaczając znalezione problemy w pliku i w panelu Problemy. Aggrega: Show topology graph w palecie poleceń rysuje komponenty encji Release i połączenia między nimi. Aggrega: Build, Aggrega: Preview build i Aggrega: Pull działają na tej samej encji Release, a każde z nich jest też przyciskiem w panelu Commands widoku Aggrega na pasku aktywności; Build zapisuje swoje pliki w dist/ folderu. Resztę omawia Używanie Aggrega w Visual Studio Code.

Uruchomienie

Należy ustawić klucz i hasło administratora w powłoce, a następnie uruchomić stos:

Terminal window
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 nadaje nazwę projektowi, jak wyjaśnia krok uruchamiania w Jak przebiega import. --wait zwraca sterowanie, gdy langflow--data-owner zakończy działanie, a Langflow zgłosi poprawny stan.

Testowanie

Należy otworzyć http://127.0.0.1:7860, adres, który publikuje published_port, i zalogować się jako admin z ustawionym hasłem: Basic Prompting jest w edytorze ze swoimi trzema połączeniami.

Langflow uruchamia przepływ przez swoje API tylko dla klucza API, który administrator tworzy po zalogowaniu. Należy się zalogować:

Terminal window
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"}

utworzyć klucz za pomocą tokenu dostępu:

Terminal window
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]"}

i uruchomić przepływ z tym kluczem:

Terminal window
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"}'

Przebieg użył symbolu zastępczego jako klucza OpenAI, więc odpowiedzią jest odrzucenie klucza przez OpenAI, co pokazuje, że przepływ wykonał się aż do wywołania modelu:

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

Z własnym kluczem odpowiedź zawiera odpowiedź modelu w outputs[0].outputs[0].results.message.text.

Na Kubernetes, po zastosowaniu buildu opisanego w Na Kubernetes, należy przekierować lokalny port do obiektu Service platformy Langflow, langflow-default, w przestrzeni nazw, do której zastosowano build, i pozostawić polecenie uruchomione:

Terminal window
kubectl port-forward -n <namespace> svc/langflow-default 7860:7860

Z innego terminala trzy powyższe żądania docierają do Langflow pod tym samym adresem, bez zmian; przebieg otrzymał to samo odrzucenie klucza zastępczego.

Stos należy zatrzymać poleceniem poniżej. -v usuwa także wolumen danych Langflow, a wraz z nim konto administratora, klucz API i historię uruchomień przepływu:

Terminal window
docker compose -p basic-prompting -f dist/compose/docker-compose.yaml down -v

Na Kubernetes

Ten sam przepływ importuje się dla Kubernetes z celem helm. Wersje robocze dla Docker Compose znajdują się już w source, a import nigdy nie nadpisuje znajdującej się tam encji Aggregate, więc te należy utworzyć w osobnym folderze za pomocą --output-dir, a następnie z niego zwalidować i zbudować:

Terminal window
aggrega import basic-prompting.json --target helm --output-dir helm
cd helm
aggrega validate --release release.yaml
aggrega build --release release.yaml

Szkice różnią się tam, gdzie różni się cel. Encja Manifest mapuje platformę na helm/langflow, model na helm/openai, a każdy sekret na helm/k8s-existing-secret, który odczytuje go z obiektu Secret istniejącego już w przestrzeni nazw. Encja Release dołącza oba sekrety jako core/referenced-secret, każdy wskazujący nazwę tego obiektu Secret, a te nazwy są tym, co przechowuje plik odpowiedzi:

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"

Bez pliku odpowiedzi import pyta o obie nazwy w terminalu i zapisuje odpowiedzi w nowym pliku odpowiedzi. Tam, gdzie nie można o nic zapytać, zapisuje ten plik z oboma kluczami i pustymi odpowiedziami, po czym kończy się statusem 1 i tym wierszem, w którym <workspace> oznacza folder, w którym go uruchomiono:

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 again

Build zapisuje zwykłe manifesty Kubernetes w dist/helm/ w katalogu głównym obszaru roboczego, source, który z perspektywy helm to ../dist/helm/. Należy utworzyć oba obiekty Secrets w przestrzeni nazw, do której się je stosuje, każdy przechowujący swoją wartość pod kluczem danych value, a następnie zastosować folder, jak wyjaśnia krok uruchamiania w Jak przebiega import.