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 aplikacji LangGraph

Ten przewodnik krok po kroku importuje konfigurację aplikacji LangGraph — jednego grafu odpowiadającego na pytania klientów o ich zamówienia — i buduje aplikację dla Docker Compose. Import tworzy szkic każdego pliku, który odczytuje build: grafu, bazy danych PostgreSQL, w której jego checkpointer przechowuje stan, modelu, który wywołuje, haseł i klucza jako odwołań do zmiennych oraz realizacji każdego z nich. Jednorazowo pyta o dwie wartości, których nie zawiera żadna konfiguracja: model wywoływany przez kod grafu i obraz, w którym działa aplikacja. Każdy plik i każdy blok wyjścia poniżej pochodzi z rzeczywistego uruchomienia; konfiguracja i każdy etap przewodnika znajdują się w przykładzie import-langgraph, gdzie 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-langgraph

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, który zawiera to, co importuje ta strona, i w którym uruchamia się import:

Terminal window
cd import-langgraph

Folder source wygenerowanego przykładu otwarty w Visual Studio Code, pokazujący jego konfigurację LangGraph, która wskazuje jeden graf, support.

Projekt

Aplikacja LangGraph przechowuje swoje grafy w kodzie i deklaruje je w langgraph.json, pliku konfiguracyjnym narzędzia wiersza poleceń LangGraph. Ta konfiguracja, napisana na potrzeby tego przewodnika, deklaruje jeden graf, support, za pomocą ścieżki importu grafu w kodzie aplikacji oraz opisu:

{
"$schema": "https://langgra.ph/schema.json",
"dependencies": ["."],
"python_version": "3.12",
"graphs": {
"support": {
"path": "./src/support_agent/graph.py:graph",
"description": "Answers a question from a customer about their order, and hands it to a person when it cannot."
}
}
}

Import odczytuje langgraph.json i nigdy kod aplikacji, więc przykład zawiera tylko konfigurację. Obok niej plik .aggrega-config.yaml czyni z folderu obszar roboczy:

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside langgraph.json.
workspace: {}
# The registry the importer is fetched from the first time an import needs it.
default_registry: hub.aggrega.ai

Import odwołuje się do encji Components z katalogu dla agenta LangGraph, dla PostgreSQL i dla modelu OpenAI, a --target tworzy szkic encji Manifest na podstawie encji Recipes z katalogu. Obszar roboczy 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 obszaru roboczego i którą rekord zapisywany przez import obok jego szkiców wskazuje za pomocą jej skrótu. Obszar roboczy, który wskazuje własne foldery katalogu — w AGGREGA_CATALOG_DIRS lub pod workspace.catalog_dirs — importuje zamiast tego względem nich.

O co pyta import

Konfiguracja LangGraph nie wskazuje żadnego modelu, ponieważ wybiera go kod grafu, ani żadnego obrazu, ponieważ ten obraz buduje się z własnego projektu. Dlatego import pyta o oba: o nazwę modelu, który wywołuje graf, na potrzeby szkicowanego modelu OpenAI, oraz o obraz, w którym działa aplikacja. W terminalu zadaje pytania i zapisuje odpowiedzi w szkicach oraz w pliku odpowiedzi, import-answers.yaml, wewnątrz importowanego katalogu — tutaj w katalogu głównym projektu, . — dzięki czemu kolejny import odczytuje je stamtąd i o nic nie pyta. Bez terminala — w ciągłej integracji lub przez potok — o nic nie pyta: zapisuje plik z pustymi kluczami i się zatrzymuje:

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

Przykład zawiera już ten plik, z odpowiedziami: graf wywołuje gpt-4o-mini od OpenAI, a ghcr.io/example/support-agent:1.0.0 oznacza budowany obraz:

# 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.
aggregate.yaml:
# Left for the author, since the configuration names no model: values.model, the name of the model
# core/ai-model/openai serves.
spec.components.model.values.model: "gpt-4o-mini"
release.yaml:
# Container image running the LangGraph application code. The Docker Compose Recipe runs the catalog's
# quickstart agent when it is unset.
spec.components.support.infra.image: "ghcr.io/example/support-agent:1.0.0"
# 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.support.uses.checkpointer_db.postgres.features.credential.infra.origin: "support-db-password"
# 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.support.uses.model.model.features.credential.infra.origin: "openai-api-key"
# 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.postgres.features.password.infra.origin: "support-db-password"

Trzy odpowiedzi origin są przeznaczone dla kompilacji dla Kubernetes, z --target helm: tam hasło bazy danych i klucz OpenAI są odczytywane z obiektów Secret Kubernetes, a każda odpowiedź jest nazwą obiektu Secret — hasło bazy danych z support-db-password, po obu stronach, a klucz z openai-api-key — nigdy samym hasłem ani kluczem. Kompilacja dla Docker Compose odczytuje je zamiast tego z powłoki, więc ten import nie używa tych odpowiedzi. Plik odpowiedzi importu opisuje plik, pytania i zasady dotyczące odpowiedzi dla sekretu.

aggrega import wymienia każdą flagę przyjmowaną przez polecenie, w tym --answers, która wskazuje plik odpowiedzi przechowywany gdzie indziej.

Należy przejść do source:

Terminal window
cd source

Uruchomienie importu

Należy wskazać folder aplikacji. Import odczytuje jego langgraph.json i żaden inny plik z niego:

Terminal window
aggrega import . --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 langgraph format, with drafted paths relative to <workspace>
info: the answers file <workspace>/import-answers.yaml also answers spec.components.postgres.features.password.infra.origin in release.yaml, spec.components.support.uses.checkpointer_db.postgres.features.credential.infra.origin in release.yaml, spec.components.support.uses.model.model.features.credential.infra.origin in release.yaml, which these drafts do not leave empty; those answers are kept there and not applied
mapped support (graph) to core/ai-agent/langgraph as a reference, NONE
mapped checkpointer (checkpointer) to core/datastore/postgres as a reference, NONE
mapped model (model) to core/ai-model/openai as a reference, NONE
Pull complete: <workspace>/release.lock (entities=10, source_artifacts=0, external_inputs=0)

Import uruchomiony z edytora: wygenerowane encje Aggregate, Release i Manifest pojawiają się obok konfiguracji LangGraph, wyjście Aggrega pokazuje, jak zmapowano graf, jego checkpointer i jego model, oraz zapisane pliki, a powiadomienie informuje, że import wygenerował 3 pliki, rozpoznane jako langgraph.

  • Wiersz info wskazuje odpowiedzi, których szkice dla Docker Compose nie używają, zachowane w pliku odpowiedzi na potrzeby kompilacji dla Kubernetes.
  • Wiersze mapped mówią, że graf jest instancją agenta LangGraph z biblioteki standardowej, core/ai-agent/langgraph; że jego checkpointer, w którym LangGraph przechowuje stan każdego grafu, jest instancją core/datastore/postgres, ponieważ konfiguracja nie wskazuje żadnego checkpointera, a wtedy LangGraph przechowuje stan w PostgreSQL; oraz że model, który wywołuje każdy graf, jest instancją core/ai-model/openai. Ich poziom to NONE: import LangGraph odwołuje się do tych encji Components na podstawie tego, co deklaruje konfiguracja, zamiast porównywać każdą z nich z katalogiem. Konfiguracja, której checkpointer.backend ma wartość mongo, jest szkicowana z core/datastore/ferretdb, który obsługuje protokół MongoDB, nad core/datastore/documentdb, przy czym oba są połączone tak, jak łączy je encja Aggregate FerretDB z katalogu, z jednym hasłem dla obu.
  • Wiersz Pull complete oznacza, że import pobiera to, od czego zależy szkic encji Release, tak jak robi to aggrega pull, do release.lock, dzięki czemu szkice od razu przechodzą walidację i budowanie. Z --offline import niczego nie pobiera i podaje polecenie aggrega pull, które należy uruchomić.

Co zapisuje import

Encje Aggregate, Release i Manifest otrzymują nazwę imported/support od jedynego grafu, który udostępnia langgraph.json, czyli support, ponieważ konfiguracja nie ma własnej nazwy — taka, która udostępnia kilka grafów, otrzymuje nazwę od swojego pliku albo od swojego katalogu, gdy, jak tutaj, import otrzymuje jej katalog — w przestrzeni nazw określonej przez ustawienie target_namespace importera, imported, o ile nie ustawi się innej (Ustawienia).

aggregate.yaml — graf, baza danych, w której przechowuje on swój stan, i model, który wywołuje, przy czym każde połączenie deklaruje poświadczenie, które przedstawia, poprzedzone komentarzami, które mówią, co zostało odczytane, a co nie:

# 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.
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/support
version: 0.1.0
description: Draft Aggregate imported from a source in the langgraph format.
spec:
components:
support:
type: core/ai-agent/langgraph
values:
graph_entrypoint: "./src/support_agent/graph.py:graph"
description: "Answers a question from a customer about their order, and hands it to a person when it cannot."
uses:
checkpointer_db:
postgres:
target: postgres
# For the compose target, the lines below 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, the lines below declare credential on model: 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 database the configuration's checkpointer keeps each graph's state in, PostgreSQL.
postgres:
type: core/datastore/postgres
features:
# For the compose target, the lines below declare password 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.
password:
type: core/secret-value
values:
key: POSTGRES_PASSWORD
# 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: "gpt-4o-mini"

graph_entrypoint to ścieżka importu grafu w takiej postaci, w jakiej zapisuje ją konfiguracja. Jego połączenie checkpointer_db jest podłączone do bazy danych, a połączenie model do modelu, którego nazwa jest odpowiedzią odczytaną przez import z import-answers.yaml. recursion_limit nie jest zapisane, więc obowiązuje wartość domyślna encji Component, 25. Baza danych otrzymuje hasło, więc encja Recipe dla PostgreSQL nie zapisuje własnego, a graf przedstawia to samo hasło w swoim połączeniu z bazą danych.

release.yaml — środowisko, obraz, opublikowany port oraz to, skąd pochodzą klucz i hasła, z komentarzami nad grafem, które mówią, jaki jest jego obraz i co jest mu przekazywane:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/support
# 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 langgraph format.
spec:
aggregate: imported/support
manifest: imported/support
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.
support:
infra:
# Left for the Release, since the source cannot supply it: infra.image, the container image running the application
image: "ghcr.io/example/support-agent:1.0.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: 8000
uses:
checkpointer_db:
postgres:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential support 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 support 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: {}

Środowisko, development, to wartość domyślna, którą import zapisuje, ponieważ żadna konfiguracja go nie wskazuje; należy ją zmienić tam, gdzie encja Release jest wdrażana gdzie indziej. Obraz jest odpowiedzią odczytaną przez import z import-answers.yaml. Graf jest publikowany na adresie pętli zwrotnej komputera, na porcie 8000, z przekierowaniem na port, na którym nasłuchuje jego program, infra.port, domyślnie 8000, o ile go nie ustawiono. Klucz i hasło są odwołaniami do zmiennych, ${OPENAI_API_KEY} i ${POSTGRES_PASSWORD}, nigdy wartościami.

manifest.yaml — encja Recipe dla Compose każdego typu oraz realizacja, która zapisuje każde odwołanie do zmiennej w pliku Compose dokładnie tak, jak zostało napisane:

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/support
version: 0.1.0
spec:
mappings:
components:
type:
core/ai-agent/langgraph: compose/langgraph
core/datastore/postgres: compose/postgres
core/ai-model/openai: compose/openai
features:
type:
core/secret-value: compose/dotenv-secret

release.lock rejestruje, według digestu, encje katalogu, na które została rozwiązana encja Release, a .aggrega-import.json to zapis tego, co utworzył import, odczytywany przez późniejsze aggrega import --sync.

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)

oraz build, gdzie <workspace> oznacza folder, w którym go uruchomiono:

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 notice ma charakter informacyjny: encja Feature sekretu przyjmuje swoje origin z values encji Aggregate lub z infra encji Release, a komunikat informuje, że jeden liść jest zadeklarowany w obu miejscach. Nie zmienia żadnego werdyktu.

Kompilacja zapisuje dist/compose/docker-compose.yaml z usługą dla grafu, drugą dla bazy danych i trzecią, która czeka na bazę danych. Usługa grafu:

support:
image: ghcr.io/example/support-agent:1.0.0
environment:
LANGGRAPH_DEFAULT_RECURSION_LIMIT: "25"
OPENAI_BASE_URL: https://api.openai.com/v1
OPENAI_MODEL: gpt-4o-mini
LANGGRAPH_CHECKPOINTER_HOST: postgres
LANGGRAPH_CHECKPOINTER_PORT: "5432"
LANGGRAPH_CHECKPOINTER_USER: appuser
LANGGRAPH_CHECKPOINTER_DATABASE: appdb
LANGGRAPH_GRAPH_ENTRYPOINT: ./src/support_agent/graph.py:graph
OPENAI_API_KEY: ${OPENAI_API_KEY}
LANGGRAPH_CHECKPOINTER_PASSWORD: ${POSTGRES_PASSWORD}
ports:
- 127.0.0.1:8000:8000
[… omitted: the labels the build writes on every service, naming the Aggregate, the component, the environment and the compiler's version]
networks:
- compose
depends_on:
support--wait-for-store:
condition: service_completed_successfully
postgres:
condition: service_started

Graf otrzymuje adres modelu, jego nazwę i klucz, host, port, użytkownika, nazwę i hasło bazy danych oraz własny punkt wejścia grafu. Użytkownik i nazwa bazy danych to wartości domyślne encji Component PostgreSQL, appuser i appdb, z którymi tworzona jest poniższa usługa bazy danych; graf je otrzymuje, ponieważ encja Recipe PostgreSQL publikuje obie, a przy magazynie, który nie publikuje żadnej z nich, jak Valkey, nie otrzymuje żadnej. Nazwa modelu, host, port, użytkownik i nazwa bazy danych oraz punkt wejścia grafu docierają pod nazwami, które encja Component LangGraph dostarcza domyślnie, a które blok inject: na połączeniu, lub na samym komponencie dla jego własnych wartości, zastępuje nazwami odczytywanymi przez kod aplikacji. Adres modelu, jego klucz i hasło bazy danych pozostają pod nazwami, które podają bloki, podobnie jak LANGGRAPH_DEFAULT_RECURSION_LIMIT, który LangGraph odczytuje samodzielnie jako limit kroków uruchomienia, którego konfiguracja nie ustawia żadnego. Własna usługa bazy danych otrzymuje to samo hasło:

postgres:
image: postgres:16
environment:
POSTGRES_USER: appuser
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: appdb
[… omitted: the labels the build writes on every service, the network, and a health check running PostgreSQL's pg_isready]

Usługa grafu uruchamia się dopiero wtedy, gdy trzecia usługa zakończy działanie. Trzecia usługa uruchamia się jeden raz, w obrazie agenta quickstart z katalogu zamiast we własnym obrazie grafu, i czeka, aż adres bazy danych przyjmie połączenie TCP, ponawiając próbę co 2 s przez maksymalnie 300 s; jeśli do tego czasu nie uzyska połączenia, kończy działanie, podając adres, a graf nie zostaje uruchomiony. Otrzymuje host i port bazy danych i nic więcej:

support--wait-for-store:
image: hub.aggrega.ai/tools/quickstart-agent:1.0.1@sha256:a5f8dcfbb670d86a0cae0aadd2844bec93221a651238f8be3863873e261ee168
[… omitted: the command and the entrypoint, a bash loop that opens a connection to the address]
environment:
STORE_HOST: postgres
STORE_PORT: "5432"
[… omitted: the labels the build writes on every service, and the network]
restart: "no"

Klucz i hasło są odwołaniami do zmiennych, wypełnianymi z powłoki przy uruchamianiu stosu. Model nie otrzymuje własnej usługi: graf łączy się z API OpenAI pod własnym adresem tego API. Usługa grafu publikuje swój port wyłącznie na 127.0.0.1, a do własnego portu bazy danych dociera się w sieci stosu, bez publikowania czegokolwiek.

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-langgraph`, wywołaj raz narzędzie `scaffold` z `example` ustawionym na `import-langgraph` i bez `dir`: zapisuje ono przykład w nowym folderze `import-langgraph`, którego folder `source` zawiera to, co importuje ta strona. Następnie wywołaj narzędzie `import` z `workspace_root` ustawionym na `import-langgraph/source`, `source` ustawionym na `.` i `target` ustawionym na `compose`: odczytuje ono potrzebne odpowiedzi z `import-answers.yaml` obok `langgraph.json`, zapisuje swoje wersje robocze w `import-langgraph/source` i pobiera to, czego potrzebują. Następnie wywołaj narzędzie `validate` z `workspace_root` ustawionym na `import-langgraph/source` i `release` ustawionym na `release.yaml` oraz narzędzie `build` z `workspace_root` ustawionym na `import-langgraph/source`, `release` ustawionym na `release.yaml` i `write` ustawionym na true. Powiedz mi, które pliki zapisał build; znajdują się w `import-langgraph/source/dist/`.

Otwieranie w VS Code

Po zainstalowaniu rozszerzenia Aggrega dla Visual Studio Code należy otworzyć w VS Code folder import-langgraph/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

Obraz buduje się z projektu, przy użyciu własnego pliku Dockerfile: kod grafu z zainstalowanym LangGraph. Docker Compose uruchamia własne polecenie obrazu jako usługę grafu, ponieważ encja Recipe nie ustawia żadnego, więc to polecenie musi działać nieprzerwanie i musi obsługiwać żądania, jeśli graf ma być osiągalny. Znajduje ono graf, model i bazę danych za pomocą powyższych zmiennych. O adresie, trasie i odpowiedzi decyduje sam program.

Poniższe uruchomienie korzystało z takiego obrazu: graf w ścieżce wskazanej przez langgraph.json, src/support_agent/graph.py, jeden węzeł odpowiadający za pośrednictwem modelu wskazanego przez OPENAI_MODEL oraz, jako polecenie obrazu, mały własny serwer HTTP programu na porcie 8000. Obraz zachowuje układ projektu w swoim katalogu roboczym, więc ścieżka wskazana przez LANGGRAPH_GRAPH_ENTRYPOINT, względna wobec niego, odnajduje graf. Serwer ładuje ten graf, przechowuje stan każdej rozmowy w bazie danych za pomocą checkpointera PostgreSQL z LangGraph, otwieranego z hostem, portem, użytkownikiem, nazwą i hasłem bazy danych, z których każde jest odczytywane ze zmiennej LANGGRAPH_CHECKPOINTER_, pod którą dociera, więc program sam nie zapisuje żadnego z nich, i uruchamia graf raz dla każdego POST /threads/<thread>/runs. Usługa grafu uruchamia się, gdy tylko baza danych przyjmuje połączenia, więc serwer, który otwiera checkpointer przy uruchomieniu, zastaje bazę danych przyjmującą połączenia. Należy zbudować obraz w katalogu głównym projektu, wpisać jego nazwę w miejsce ghcr.io/example/support-agent:1.0.0 w import-answers.yaml i zaimportować ponownie z --sync, co zapisuje nową odpowiedź w szkicach i ponownie wykonuje pull; następnie zbudować:

Terminal window
docker build -t order-support:local .
aggrega import . --sync
aggrega build --release release.yaml

Następnie należy ustawić klucz i hasło bazy danych w powłoce i uruchomić stos:

Terminal window
export OPENAI_API_KEY='your OpenAI key'
export POSTGRES_PASSWORD='a password of your own'
docker compose -p order-support -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 baza danych zgłosi poprawny stan, oczekiwanie na nią się zakończy, a usługa grafu będzie działać.

Testowanie

Poniższe żądanie trafia do programu, który uruchamia obraz z tego przewodnika: grafu za małym serwerem HTTP na porcie 8000, odpowiadającym na POST /threads/<thread>/runs. Własny program sam decyduje o swojej trasie i odpowiedzi. Żądanie należy wysłać na http://127.0.0.1:8000, adres, który publikuje published_port:

Terminal window
curl -sS -X POST http://127.0.0.1:8000/threads/order-1234/runs -H 'Content-Type: application/json' \
-d '{"message": "Where is my order 1234? It has not arrived yet."}'
{
"thread": "order-1234",
"error": "the run failed: OpenAIAuthenticationError: Error code: 401 - Incorrect API key provided: sk-place************-key. [… omitted: where to find an API key]"
}

Uruchomienie ustawiło OPENAI_API_KEY na wartość zastępczą, więc odpowiedź to odmowa OpenAI, przekazana dalej przez program. Żądanie grafu dotarło do API OpenAI z kluczem dostarczonym przez build, z programu, który otworzył swój checkpointer w bazie danych przy użyciu poświadczeń dostarczonych przez build.

Stack zatrzymuje się poleceniem:

Terminal window
docker compose -p order-support -f dist/compose/docker-compose.yaml down -v

-v usuwa wolumen, w którym baza danych przechowuje swoje dane, a wraz z nim rozmowy.

W Kubernetes należy zaimportować z --target helm i wypchnąć obraz do rejestru, z którego klaster pobiera obrazy, podając jego nazwę w import-answers.yaml. Następnie należy utworzyć obiekty Secret openai-api-key i support-db-password oraz zastosować build, jak opisuje krok uruchamiania w Jak przebiega import. Obiekt Deployment grafu nie ma obiektu Service. Jego pod jest restartowany, dopóki baza danych nie zacznie przyjmować połączeń, ponieważ program otwiera swój checkpointer przy starcie. Należy przekierować do niego port lokalny; polecenie działa, dopóki się go nie zatrzyma:

Terminal window
kubectl port-forward deploy/support 8000:8000
Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000

Z innego terminala należy wysłać to samo żądanie na przekierowany port:

Terminal window
curl -sS -X POST http://127.0.0.1:8000/threads/order-1234/runs -H 'Content-Type: application/json' \
-d '{"message": "Where is my order 1234? It has not arrived yet."}'
{
"thread": "order-1234",
"error": "the run failed: OpenAIAuthenticationError: Error code: 401 - Incorrect API key provided: sk-place************-key. [… omitted: where to find an API key]"
}