Eine LangGraph-Anwendung importieren
Diese Schritt-für-Schritt-Anleitung importiert die Konfiguration einer LangGraph-Anwendung — ein Graph, der Fragen von Kunden zu ihren Bestellungen beantwortet — und baut die Anwendung für Docker Compose. Der Import entwirft jede Datei, die der Build liest: den Graphen, die PostgreSQL-Datenbank, in der sein Checkpointer den Zustand hält, das Modell, das er aufruft, die Passwörter und den Schlüssel als Variablenreferenzen sowie die Realisierungen von allen. Er fragt einmalig nach den beiden Werten, die keine Konfiguration enthält: dem Modell, das der Code des Graphen aufruft, und dem Image, in dem die Anwendung läuft. Jede Datei und jeder Ausgabeblock unten stammt aus einem echten Lauf; die Konfiguration und jede Phase der Anleitung befinden sich im Beispiel import-langgraph, in dem ein Prüfskript den Import erneut ausführt, das, was er schreibt, was er ausgibt, und die Blöcke, die diese Seite zitiert, mit den dort abgelegten Dateien vergleicht und das, was der Import geschrieben hat, validiert und baut.
Das Beispiel generieren
Sie können diesen Import mit den Befehlen auf dieser Seite ausführen oder ihn von Ihrem KI-Assistenten ausführen lassen.
Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:
aggrega scaffold --example import-langgraphDanach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner; der folgende, unten, wechselt in den Ordner source des neuen Ordners, der enthält, was diese Seite importiert, und in dem der Import läuft:
cd import-langgraph
Das Projekt
Eine LangGraph-Anwendung hält ihre Graphen im Code und deklariert sie in langgraph.json, der Konfigurationsdatei des Kommandozeilenwerkzeugs von LangGraph. Diese hier, für diese Anleitung geschrieben, deklariert einen Graphen, support, über den Importpfad des Graphen im Code der Anwendung und eine Beschreibung:
{ "$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." } }}Der Import liest langgraph.json und niemals den Code der Anwendung, daher enthält das Beispiel nur die Konfiguration. Daneben macht eine .aggrega-config.yaml den Ordner zu einem Workspace:
# 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.aiDer Import referenziert die Components des Katalogs für den LangGraph-Agenten, für PostgreSQL und für das OpenAI-Modell, und --target entwirft ein Manifest aus dessen Recipes. Der Arbeitsbereich nennt keinen Katalogordner, daher liest der Import den Katalog der Standardbibliothek aus der Registry, aus der er seinen Importer holt: einen signierten Snapshot des veröffentlichten Katalogs, den der erste Import holt, verifiziert und im Inhalts-Cache des Arbeitsbereichs ablegt und den die Aufzeichnung, die der Import neben seine Entwürfe schreibt, über seinen Digest benennt. Ein Arbeitsbereich, der eigene Katalogordner nennt — in AGGREGA_CATALOG_DIRS oder unter workspace.catalog_dirs —, importiert stattdessen gegen diese.
Wonach der Import fragt
Eine LangGraph-Konfiguration nennt kein Modell, da der Code des Graphen es wählt, und kein Image, da Sie dieses Image aus Ihrem Projekt bauen. Daher fragt der Import nach beidem: nach dem Namen des Modells, das der Graph aufruft, für das OpenAI-Modell, das er entwirft, und nach dem Image, in dem die Anwendung läuft. An einem Terminal fragt er und schreibt die Antworten in die Entwürfe und in die Antwortdatei, import-answers.yaml, innerhalb des Verzeichnisses, das er importiert — hier das Stammverzeichnis des Projekts, . —, sodass der nächste Import sie von dort liest und nichts fragt. Ohne Terminal — in der Continuous Integration oder über eine Pipe — fragt er nichts: Er schreibt die Datei mit leeren Schlüsseln und hält an:
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 againDas Beispiel enthält die Datei bereits, beantwortet: Der Graph ruft gpt-4o-mini von OpenAI auf, und ghcr.io/example/support-agent:1.0.0 steht für das Image, das Sie bauen:
# 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"Die drei origin-Antworten sind für einen Build für Kubernetes mit --target helm bestimmt: Dort werden das Passwort der Datenbank und der OpenAI-Schlüssel aus Kubernetes-Secrets gelesen, und jede Antwort ist der Name eines Secrets — das Passwort der Datenbank aus support-db-password, auf beiden Seiten, und der Schlüssel aus openai-api-key —, niemals das Passwort oder der Schlüssel. Ein Build für Docker Compose liest sie stattdessen aus Ihrer Shell, daher verwendet dieser Import diese Antworten nicht. Die Antwortdatei des Imports beschreibt die Datei, die Fragen und die Regeln für die Antwort zu einem Secret.
aggrega import listet jedes Flag auf, das der Befehl annimmt, darunter --answers, das eine anderswo abgelegte Antwortdatei nennt.
Wechseln Sie in source:
cd sourceDen Import ausführen
Geben Sie das Verzeichnis der Anwendung an. Der Import liest dessen langgraph.json und keine andere Datei daraus:
aggrega import . --target composeAuf der Standardausgabe listet er auf, was er geschrieben hat:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonAuf der Standardfehlerausgabe, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:
[… 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 appliedmapped support (graph) to core/ai-agent/langgraph as a reference, NONEmapped checkpointer (checkpointer) to core/datastore/postgres as a reference, NONEmapped model (model) to core/ai-model/openai as a reference, NONEPull complete: <workspace>/release.lock (entities=10, source_artifacts=0, external_inputs=0)
- Die
info-Zeile nennt die Antworten, die die Docker-Compose-Entwürfe nicht verwenden und die für einen Build für Kubernetes in der Antwortdatei aufbewahrt werden. - Die Zeilen
mappedbesagen, dass der Graph eine Instanz des LangGraph-Agenten der Standardbibliothek,core/ai-agent/langgraph, ist; dass sein Checkpointer, in dem LangGraph den Zustand jedes Graphen speichert, eine Instanz voncore/datastore/postgresist, da die Konfiguration keinen Checkpointer nennt und LangGraph den Zustand dann in PostgreSQL speichert; und dass das Modell, das jeder Graph aufruft, eine Instanz voncore/ai-model/openaiist. Ihre Stufe lautetNONE: Der LangGraph-Import referenziert diese Components anhand dessen, was die Konfiguration deklariert, statt jede gegen den Katalog abzuwägen. Eine Konfiguration, derencheckpointer.backendmongoist, wird mitcore/datastore/ferretdb, das das Protokoll von MongoDB spricht, übercore/datastore/documentdbentworfen, beide so verbunden, wie das FerretDB-Aggregate des Katalogs sie verbindet, mit einem Passwort für beide. - Die Zeile
Pull completezeigt, dass der Import das, wovon das entworfene Release abhängt, wieaggrega pullinrelease.lockabruft, sodass die Entwürfe sofort validiert und gebaut werden können. Mit--offlineruft der Import nichts ab und nennt den auszuführenden Befehlaggrega pull.
Was er schreibt
Das Aggregate, das Release und das Manifest heißen imported/support, nach dem einen Graphen, den langgraph.json bereitstellt, support, da eine Konfiguration keinen eigenen Namen trägt — eine, die mehrere Graphen bereitstellt, wird nach ihrer Datei benannt oder nach ihrem Verzeichnis, wenn dem Import wie hier ihr Verzeichnis übergeben wird —, unter dem Namespace, den die Einstellung target_namespace des Importers festlegt, imported, sofern Sie keinen anderen festlegen (Einstellungen).
aggregate.yaml — der Graph, die Datenbank, in der er seinen Zustand speichert, und das Modell, das er aufruft, wobei jede Verbindung die Anmeldeinformation deklariert, die sie vorlegt, eingeleitet von Kommentaren, die sagen, was gelesen wurde und was nicht:
# 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/v1beta1kind: Aggregatemetadata: 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 ist der Importpfad des Graphen, wie die Konfiguration ihn schreibt. Seine Verbindung checkpointer_db ist mit der Datenbank verdrahtet und seine Verbindung model mit dem Modell, dessen Name die Antwort ist, die der Import aus import-answers.yaml gelesen hat. recursion_limit ist nicht geschrieben, daher gilt der Standardwert der Component, 25. Die Datenbank erhält ein Passwort, sodass das PostgreSQL-Recipe kein eigenes schreibt, und der Graph legt auf seiner Verbindung zur Datenbank dasselbe Passwort vor.
release.yaml — die Umgebung, das Image, der veröffentlichte Port und woher der Schlüssel und die Passwörter kommen, mit Kommentaren über dem Graphen, die sagen, was sein Image ist und was ihm übergeben wird:
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: 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: {}Die Umgebung, development, ist ein Standardwert, den der Import schreibt, weil keine Konfiguration eine nennt; ändern Sie sie, wo das Release anderswohin deployt. Das Image ist die Antwort, die der Import aus import-answers.yaml gelesen hat. Der Graph wird auf der Loopback-Adresse Ihres Rechners auf 8000 veröffentlicht und an den Port weitergeleitet, auf dem sein Programm lauscht, infra.port, 8000, sofern Sie ihn nicht setzen. Der Schlüssel und das Passwort sind Variablenreferenzen, ${OPENAI_API_KEY} und ${POSTGRES_PASSWORD}, niemals Werte.
manifest.yaml — das Compose-Recipe jedes Typs und die Realisierung, die jede Variablenreferenz so, wie sie geschrieben ist, in die Compose-Datei schreibt:
apiVersion: aggrega.ai/v1beta1kind: Manifestmetadata: name: imported/support version: 0.1.0spec: 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-secretrelease.lock hält per Digest die Katalog-Entitäten fest, zu denen das Release aufgelöst wurde, und .aggrega-import.json ist die Aufzeichnung dessen, was der Import geschrieben hat, und wird von einem späteren aggrega import --sync gelesen.
Validieren und bauen
aggrega validate --release release.yamlaggrega build --release release.yaml

Die Validierung gibt aus:
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)und der Build, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:
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>/distDie notice-Zeile ist ein Hinweis: Das Secret-Feature akzeptiert sein origin aus den values des Aggregate oder aus der infra des Release, und der Hinweis meldet, dass ein Blatt in beiden deklariert ist. Er ändert kein Urteil.
Der Build schreibt dist/compose/docker-compose.yaml mit einem Service für den Graphen, einem für die Datenbank und einem, der auf die Datenbank wartet. Der Service des Graphen:
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_startedDer Graph erhält die Adresse des Modells, seinen Namen und seinen Schlüssel, Host, Port, Benutzer, Namen und Passwort der Datenbank sowie seinen eigenen Graph-Einstiegspunkt. Benutzer und Datenbankname sind die Standardwerte der PostgreSQL-Component, appuser und appdb, mit denen der unten gezeigte Service der Datenbank erstellt wird; der Graph erhält sie, weil das PostgreSQL-Recipe beide veröffentlicht, und bei einem Speicher, der keinen von beiden veröffentlicht, wie Valkey, erhält er keinen von beiden. Der Name des Modells, Host, Port, Benutzer und Name der Datenbank und der Graph-Einstiegspunkt kommen unter den Namen an, die die LangGraph-Component standardmäßig liefert und die ein Block inject: auf der Verbindung, oder auf der Komponente selbst für ihre eigenen Werte, durch die Namen ersetzt, die Ihr Code liest. Die Adresse des Modells, sein Schlüssel und das Passwort der Datenbank bleiben so, wie die Blöcke sie nennen, ebenso LANGGRAPH_DEFAULT_RECURSION_LIMIT, das LangGraph von sich aus als Schrittlimit eines Laufs liest, dessen Konfiguration keines festlegt. Der eigene Service der Datenbank erhält dasselbe Passwort:
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]Der Service des Graphen startet erst, wenn der dritte Service abgeschlossen ist. Dieser läuft einmal, im Quickstart-Agent-Image des Katalogs statt im eigenen Image des Graphen, und wartet, bis die Adresse der Datenbank eine TCP-Verbindung annimmt, wobei er es alle 2 s bis zu 300 s lang versucht; kommt bis dahin keine Verbindung zustande, beendet er sich unter Nennung der Adresse, und der Graph wird nicht gestartet. Er erhält Host und Port der Datenbank und sonst nichts:
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"Der Schlüssel und das Passwort sind Variablenreferenzen, die beim Start des Stacks aus Ihrer Shell gefüllt werden. Das Modell erhält keinen eigenen Service: Der Graph erreicht die OpenAI-API unter deren eigener Adresse. Der Service des Graphen veröffentlicht seinen Port nur auf 127.0.0.1, und der eigene Port der Datenbank wird im Netzwerk des Stacks erreicht, ohne dass etwas veröffentlicht wird.
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.
Verwenden Sie nur die Aggrega-Tools und erstellen Sie selbst keinen Ordner. Wenn der Workspace-Ordner noch keinen Ordner `import-langgraph` enthält, rufen Sie das Tool `scaffold` einmal auf, mit `example` auf `import-langgraph` gesetzt und ohne `dir`: Es schreibt das Beispiel in einen neuen Ordner `import-langgraph`, dessen Ordner `source` enthält, was diese Seite importiert. Rufen Sie dann das Tool `import` auf, mit `workspace_root` auf `import-langgraph/source`, `source` auf `.` und `target` auf `compose` gesetzt: Es liest die benötigten Antworten aus `import-answers.yaml` neben `langgraph.json`, schreibt seine Entwürfe in `import-langgraph/source` und lädt per Pull, was sie benötigen. Rufen Sie dann das Tool `validate` auf, mit `workspace_root` auf `import-langgraph/source` und `release` auf `release.yaml` gesetzt, und das Tool `build`, mit `workspace_root` auf `import-langgraph/source`, `release` auf `release.yaml` und `write` auf true gesetzt. Sagen Sie mir, welche Dateien der Build geschrieben hat; sie liegen unter `import-langgraph/source/dist/`.In VS Code öffnen
Wenn die Aggrega-Erweiterung für Visual Studio Code installiert ist, öffnen Sie in VS Code den Ordner import-langgraph/source, in den der Import seine Entwürfe geschrieben hat. Der Ordner enthält ein einziges Release, das entworfene release.yaml, daher wählt der Editor es für Sie aus und prüft die Entwürfe beim Bearbeiten gegen dieses Release, wobei er seine Befunde in der Datei und im Problembereich markiert. Aggrega: Show topology graph in der Befehlspalette zeichnet die Komponenten des Release und die Verbindungen zwischen ihnen. Aggrega: Build, Aggrega: Preview build und Aggrega: Pull wirken auf dasselbe Release, und jeder dieser Befehle ist auch eine Schaltfläche im Bereich Commands der Ansicht Aggrega in der Aktivitätsleiste; Build schreibt seine Dateien in das Verzeichnis dist/ des Ordners. Aggrega in Visual Studio Code verwenden behandelt den Rest.
Ausführen
Sie bauen das Image aus dem Projekt, mit einem eigenen Dockerfile: dem Code des Graphen, mit installiertem LangGraph. Docker Compose führt den eigenen Befehl des Images als Service des Graphen aus, da das Recipe keinen festlegt; dieser Befehl muss daher weiterlaufen und muss Anfragen bedienen, wenn Sie den Graphen erreichen wollen. Er findet den Graphen, das Modell und die Datenbank über die oben genannten Variablen. Ihr Programm bestimmt die Adresse, die Route und die Antwort.
Der unten gezeigte Lauf verwendete ein solches Image: den Graphen unter dem Pfad, den langgraph.json nennt, src/support_agent/graph.py, einen Knoten, der über das Modell antwortet, das OPENAI_MODEL nennt, und als Befehl des Images einen kleinen, programmeigenen HTTP-Server auf Port 8000. Das Image behält die Struktur des Projekts in seinem Arbeitsverzeichnis bei, sodass der Pfad, den LANGGRAPH_GRAPH_ENTRYPOINT relativ dazu nennt, den Graphen findet. Der Server lädt diesen Graphen, hält den Zustand jeder Unterhaltung über den PostgreSQL-Checkpointer von LangGraph in der Datenbank, geöffnet mit Host, Port, Benutzer, Name und Passwort der Datenbank, die jeweils aus der Variable LANGGRAPH_CHECKPOINTER_ gelesen werden, unter der sie ankommen, sodass das Programm keinen davon selbst festschreibt, und führt den Graphen einmal für jedes POST /threads/<thread>/runs aus. Der Service des Graphen startet, sobald die Datenbank Verbindungen annimmt, sodass ein Server, der den Checkpointer beim Start öffnet, eine Datenbank vorfindet, die Verbindungen annimmt. Bauen Sie Ihr Image im Stammverzeichnis des Projekts, schreiben Sie seinen Namen anstelle von ghcr.io/example/support-agent:1.0.0 in import-answers.yaml und importieren Sie erneut mit --sync, das die neue Antwort in die Entwürfe schreibt und erneut pullt; bauen Sie dann:
docker build -t order-support:local .aggrega import . --syncaggrega build --release release.yamlSetzen Sie dann den Schlüssel und das Passwort der Datenbank in Ihrer Shell und starten Sie den Stack:
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 benennt das Projekt, wie der Ausführungsschritt von Wie ein Import abläuft erklärt. --wait kehrt zurück, sobald die Datenbank einen fehlerfreien Zustand meldet, das Warten auf sie abgeschlossen ist und der Dienst des Graphen läuft.
Testen
Die folgende Anfrage erreicht das Programm, das das Image dieser Anleitung ausführt: den Graphen hinter einem kleinen HTTP-Server auf Port 8000, der POST /threads/<thread>/runs beantwortet. Ihr eigenes Programm bestimmt seine eigene Route und Antwort. Senden Sie sie an http://127.0.0.1:8000, die Adresse, die published_port veröffentlicht:
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]"}Der Lauf setzte OPENAI_API_KEY auf einen Platzhalter, daher ist die Antwort die Ablehnung durch OpenAI, die das Programm weitergibt. Die Anfrage des Graphen erreichte die OpenAI-API mit dem Schlüssel, den der Build lieferte, aus einem Programm, das seinen Checkpointer in der Datenbank mit den Anmeldeinformationen geöffnet hatte, die der Build lieferte.
Beenden Sie den Stack mit:
docker compose -p order-support -f dist/compose/docker-compose.yaml down -v-v entfernt das Volume, in dem die Datenbank ihre Daten hält, und damit die Unterhaltungen.
Importieren Sie auf Kubernetes mit --target helm, pushen Sie das Image in eine Registry, aus der Ihr Cluster zieht, und nennen Sie es in import-answers.yaml. Erstellen Sie dann die Secrets openai-api-key und support-db-password und wenden Sie den Build an, wie der Ausführungsschritt von Wie ein Import abläuft beschreibt. Das Deployment des Graphen hat keinen Service. Sein Pod startet neu, bis die Datenbank Verbindungen annimmt, weil das Programm seinen Checkpointer beim Start öffnet. Leiten Sie einen lokalen Port dorthin weiter; der Befehl läuft, bis Sie ihn beenden:
kubectl port-forward deploy/support 8000:8000Forwarding from 127.0.0.1:8000 -> 8000Forwarding from [::1]:8000 -> 8000Senden Sie von einem anderen Terminal aus dieselbe Anfrage an den weitergeleiteten Port:
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]"}