Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Importer une application LangGraph

Ce tutoriel pas à pas importe la configuration d’une application LangGraph — un graphe qui répond aux questions des clients sur leurs commandes — et construit l’application pour Docker Compose. L’import rédige en brouillon chaque fichier que lit le build : le graphe, la base de données PostgreSQL dans laquelle son checkpointer conserve l’état, le modèle qu’il appelle, les mots de passe et la clé sous forme de références à des variables, et les réalisations de chacun. Il demande une seule fois les deux valeurs qu’aucune configuration ne contient : le modèle qu’appelle le code du graphe et l’image dans laquelle l’application s’exécute. Chaque fichier et chaque bloc de sortie ci-dessous proviennent d’une exécution réelle ; la configuration et chaque étape du tutoriel se trouvent dans l’exemple import-langgraph, où un script de vérification relance l’import, compare ce qu’il écrit, ce qu’il affiche et les blocs que cite cette page avec les fichiers qui y sont conservés, puis valide et construit ce que l’import a écrit.

Générer l’exemple

Vous pouvez exécuter cette importation avec les commandes de cette page, ou la faire exécuter par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example import-langgraph

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier ; la suivante, ci-dessous, vous place dans le dossier source du nouveau dossier, qui contient ce que cette page importe et où s’exécute l’import :

Terminal window
cd import-langgraph

Le dossier source de l’exemple généré, ouvert dans Visual Studio Code, montrant sa configuration LangGraph, qui nomme un graphe, support.

Le projet

Une application LangGraph conserve ses graphes dans le code et les déclare dans langgraph.json, le fichier de configuration de l’outil en ligne de commande de LangGraph. Celle-ci, écrite pour ce tutoriel, déclare un graphe, support, par le chemin d’import du graphe dans le code de l’application et une description :

{
"$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."
}
}
}

L’import lit langgraph.json et jamais le code de l’application, de sorte que l’exemple ne contient que la configuration. À côté, un .aggrega-config.yaml fait du dossier un espace de travail :

# 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

L’import référence les Components du catalogue pour l’agent LangGraph, pour PostgreSQL et pour le modèle OpenAI, et --target rédige un Manifest en brouillon à partir de ses Recipes. L’espace de travail n’indique aucun dossier de catalogue ; l’import lit donc le catalogue de la bibliothèque standard depuis le registre dont il récupère son importateur : un instantané signé du catalogue publié, que le premier import récupère, vérifie et conserve dans le cache de contenu de l’espace de travail, et que l’enregistrement écrit par l’import à côté de ses brouillons désigne par son condensé. Un espace de travail qui indique ses propres dossiers de catalogue — dans AGGREGA_CATALOG_DIRS, ou sous workspace.catalog_dirs — importe plutôt en s’appuyant sur ceux-ci.

Ce que demande l’importation

Une configuration LangGraph ne nomme aucun modèle, puisque le code du graphe le choisit, ni aucune image, puisque vous construisez cette image à partir de votre projet. L’import demande donc les deux : le nom du modèle qu’appelle le graphe, pour le modèle OpenAI qu’il rédige, et l’image dans laquelle s’exécute l’application. Dans un terminal, il pose la question et écrit les réponses dans les brouillons et dans le fichier de réponses, import-answers.yaml, à l’intérieur du répertoire qu’il importe — ici la racine du projet, . — afin que l’import suivant les y lise et ne demande rien. Sans terminal — en intégration continue, ou à travers un pipe — il ne demande rien : il écrit le fichier avec les clés vides, et s’arrête :

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

L’exemple contient déjà le fichier, avec ses réponses : le graphe appelle gpt-4o-mini d’OpenAI, et ghcr.io/example/support-agent:1.0.0 représente l’image que vous construisez :

# 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"

Les trois réponses origin concernent un build pour Kubernetes, avec --target helm : là, le mot de passe de la base de données et la clé OpenAI sont lus depuis des Secrets Kubernetes, et chaque réponse est le nom d’un Secret — le mot de passe de la base de données depuis support-db-password, aux deux extrémités, et la clé depuis openai-api-key — jamais le mot de passe ni la clé. Un build pour Docker Compose les lit plutôt depuis votre shell, si bien que cet import n’utilise pas ces réponses. Le fichier de réponses de l’import décrit le fichier, les questions et les règles applicables à la réponse pour un secret.

aggrega import liste toutes les options que prend la commande, dont --answers, qui nomme un fichier de réponses conservé ailleurs.

Placez-vous dans source :

Terminal window
cd source

Lancer l’importation

Indiquez le répertoire de l’application. L’import en lit le langgraph.json et aucun autre fichier :

Terminal window
aggrega import . --target compose

Sur la sortie standard, elle liste ce qu’elle a écrit :

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

Sur la sortie d’erreur standard, où <workspace> désigne le dossier dans lequel vous l’avez lancée :

[… 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)

L’import exécuté depuis l’éditeur : l’Aggregate, la Release et le Manifest rédigés apparaissent à côté de la configuration LangGraph, la sortie Aggrega indique comment le graphe, son checkpointer et son modèle ont été associés et liste les fichiers écrits, et une notification indique que l’import a rédigé 3 fichiers, reconnus comme langgraph.

  • La ligne info nomme les réponses que les brouillons Docker Compose n’utilisent pas, conservées dans le fichier de réponses pour une construction pour Kubernetes.
  • Les lignes mapped indiquent que le graphe est une instance de l’agent LangGraph de la bibliothèque standard, core/ai-agent/langgraph ; que son checkpointer, où LangGraph conserve l’état de chaque graphe, est une instance de core/datastore/postgres, puisque la configuration ne nomme aucun checkpointer et que LangGraph conserve alors l’état dans PostgreSQL ; et que le modèle qu’appelle chaque graphe est une instance de core/ai-model/openai. Leur niveau indique NONE : l’import LangGraph référence ces Components d’après ce que déclare la configuration plutôt qu’en évaluant chacun par rapport au catalogue. Une configuration dont le checkpointer.backend est mongo est rédigée avec core/datastore/ferretdb, qui parle le protocole de MongoDB, au-dessus de core/datastore/documentdb, les deux étant reliés comme les relie l’Aggregate FerretDB du catalogue, avec un seul mot de passe pour les deux.
  • La ligne Pull complete correspond à l’import qui récupère ce dont dépend la Release rédigée, comme le fait aggrega pull, dans release.lock, de sorte que les brouillons se valident et se construisent immédiatement. Avec --offline, l’import ne récupère rien et indique la commande aggrega pull à exécuter.

Ce qu’elle écrit

L’Aggregate, la Release et le Manifest sont nommés imported/support, d’après l’unique graphe que sert langgraph.json, support, puisqu’une configuration ne porte pas de nom propre — une configuration servant plusieurs graphes est nommée d’après son fichier, ou d’après son répertoire lorsque, comme ici, l’import reçoit son répertoire —, sous le namespace que fixe le paramètre target_namespace de l’importeur, imported sauf si vous en fixez un autre (Paramètres).

aggregate.yaml — le graphe, la base de données dans laquelle il conserve son état et le modèle qu’il appelle, chaque connexion déclarant l’identifiant qu’elle présente, avec en ouverture des commentaires qui indiquent ce qui a été lu et ce qui ne l’a pas été :

# 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 est le chemin d’import du graphe tel que la configuration l’écrit. Sa connexion checkpointer_db est reliée à la base de données et sa connexion model au modèle, dont le nom est la réponse que l’import a lue dans import-answers.yaml. recursion_limit n’est pas écrit, donc la valeur par défaut du Component, 25, s’applique. La base de données reçoit un mot de passe, de sorte que la Recipe PostgreSQL n’en écrit aucun qui lui soit propre, et le graphe présente le même mot de passe sur sa connexion à la base de données.

release.yaml — l’environnement, l’image, le port publié et la provenance de la clé et des mots de passe, avec au-dessus du graphe des commentaires indiquant quelle est son image et ce qui lui est transmis :

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: {}

L’environnement, development, est une valeur par défaut que l’import écrit parce qu’aucune configuration n’en nomme ; modifiez-le là où la Release est déployée ailleurs. L’image est la réponse que l’import a lue dans import-answers.yaml. Le graphe est publié sur l’adresse de bouclage de votre machine, sur 8000, avec redirection vers le port sur lequel son programme écoute, infra.port, 8000 sauf si vous le définissez. La clé et le mot de passe sont des références de variables, ${OPENAI_API_KEY} et ${POSTGRES_PASSWORD}, jamais des valeurs.

manifest.yaml — la Recipe Compose de chaque type, et la réalisation qui écrit chaque référence de variable dans le fichier Compose telle qu’elle est écrite :

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 enregistre, par digest, les entités du catalogue vers lesquelles la Release a été résolue, et .aggrega-import.json est l’enregistrement de ce que l’importation a écrit, que lit un aggrega import --sync ultérieur.

Valider et compiler

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

La Release rédigée, ouverte dans l’éditeur après sa validation, la sortie Aggrega et une notification signalant toutes deux qu’aucun problème n’a été trouvé.

Le build de la Release rédigée : un dossier dist apparaît dans l’Explorateur, la sortie Aggrega liste le fichier Docker Compose écrit, et une notification indique qu’1 fichier a été écrit.

La validation affiche :

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)

et le build, où <workspace> désigne le dossier dans lequel vous l’avez exécuté :

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

La ligne notice est indicative : la Feature de secret accepte son origin depuis les values de l’Aggregate ou l’infra de la Release, et la notice signale qu’une feuille est déclarée dans les deux. Elle ne change aucun verdict.

Le build écrit dist/compose/docker-compose.yaml, avec un service pour le graphe, un pour la base de données et un qui attend la base de données. Le service du graphe :

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

Le graphe reçoit l’adresse du modèle, son nom et sa clé, l’hôte, le port, l’utilisateur, le nom et le mot de passe de la base de données, ainsi que son propre point d’entrée de graphe. L’utilisateur et le nom de la base de données sont les valeurs par défaut du Component PostgreSQL, appuser et appdb, avec lesquelles le service de la base de données ci-dessous est créé ; le graphe les reçoit parce que la Recipe PostgreSQL publie les deux, et avec un stockage qui ne publie ni l’un ni l’autre, comme Valkey, il ne reçoit ni l’un ni l’autre. Le nom du modèle, l’hôte, le port, l’utilisateur et le nom de la base de données et le point d’entrée du graphe arrivent sous les noms que le Component LangGraph fournit par défaut, qu’un bloc inject: sur la connexion, ou sur le composant lui-même pour ses propres valeurs, remplace par les noms que lit votre code. L’adresse du modèle, sa clé et le mot de passe de la base de données restent tels que les blocs les nomment, de même que LANGGRAPH_DEFAULT_RECURSION_LIMIT, que LangGraph lit de lui-même comme limite d’étapes d’une exécution dont la configuration n’en fixe aucune. Le service propre à la base de données reçoit le même mot de passe :

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]

Le service du graphe ne démarre qu’une fois le troisième service terminé. Celui-ci s’exécute une seule fois, dans l’image de l’agent quickstart du catalogue plutôt que dans celle du graphe, et attend que l’adresse de la base de données accepte une connexion TCP, en réessayant toutes les 2 s pendant 300 s au plus ; faute de connexion d’ici là, il se termine en nommant l’adresse, et le graphe n’est pas démarré. Il reçoit l’hôte et le port de la base de données, et rien d’autre :

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"

La clé et le mot de passe sont des références de variables, renseignées depuis votre shell au démarrage de la stack. Le modèle n’obtient aucun service propre : le graphe atteint l’API OpenAI à sa propre adresse. Le service du graphe publie son port sur 127.0.0.1 seulement, et le port propre à la base de données est atteint sur le réseau de la stack, sans rien de publié.

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-y ce prompt.

Utilise uniquement les outils Aggrega, et ne crée aucun dossier toi-même. Si le dossier du Workspace ne contient pas encore de dossier `import-langgraph`, appelle une fois l’outil `scaffold` avec `example` défini sur `import-langgraph` et sans `dir` : il écrit l’exemple dans un nouveau dossier `import-langgraph`, dont le dossier `source` contient ce que cette page importe. Appelle ensuite l’outil `import` avec `workspace_root` défini sur `import-langgraph/source`, `source` défini sur `.` et `target` défini sur `compose` : il lit les réponses dont il a besoin dans `import-answers.yaml` à côté de `langgraph.json`, écrit ses brouillons dans `import-langgraph/source` et récupère ce dont ils ont besoin. Appelle ensuite l’outil `validate` avec `workspace_root` défini sur `import-langgraph/source` et `release` défini sur `release.yaml`, et l’outil `build` avec `workspace_root` défini sur `import-langgraph/source`, `release` défini sur `release.yaml` et `write` défini sur true. Dis-moi quels fichiers le build a écrits ; ils se trouvent sous `import-langgraph/source/dist/`.

L’ouvrir dans VS Code

Avec l’extension Aggrega pour Visual Studio Code installée, ouvrez dans VS Code le dossier import-langgraph/source, où l’import a écrit ses brouillons. Le dossier contient une seule Release, le release.yaml rédigé : l’éditeur la sélectionne donc pour vous, et vérifie les brouillons par rapport à cette Release pendant que vous les modifiez, en signalant ce qu’il trouve dans le fichier et dans le panneau Problèmes. Aggrega: Show topology graph, dans la palette de commandes, dessine les composants de la Release et les connexions entre eux. Aggrega: Build, Aggrega: Preview build et Aggrega: Pull agissent sur la même Release, et chacune est aussi un bouton du panneau Commands de la vue Aggrega dans la barre d’activité ; Build écrit ses fichiers dans le dist/ du dossier. Utiliser Aggrega dans Visual Studio Code couvre le reste.

Exécution

Vous construisez l’image à partir du projet, avec votre propre Dockerfile : le code du graphe, avec LangGraph installé. Docker Compose exécute la commande propre à l’image comme service du graphe, puisque la Recipe n’en définit aucune ; cette commande doit donc continuer à s’exécuter, et doit servir des requêtes si vous voulez atteindre le graphe. Elle trouve le graphe, le modèle et la base de données grâce aux variables ci-dessus. C’est votre programme qui décide de l’adresse, de la route et de la réponse.

L’exécution ci-dessous a utilisé une telle image : le graphe au chemin que nomme langgraph.json, src/support_agent/graph.py, un nœud qui répond par l’intermédiaire du modèle que nomme OPENAI_MODEL, et, comme commande de l’image, un petit serveur HTTP propre au programme sur le port 8000. L’image conserve l’arborescence du projet dans son répertoire de travail, de sorte que le chemin que nomme LANGGRAPH_GRAPH_ENTRYPOINT, relatif à celui-ci, trouve le graphe. Le serveur charge ce graphe, conserve l’état de chaque conversation dans la base de données grâce au checkpointer PostgreSQL de LangGraph, ouvert avec l’hôte, le port, l’utilisateur, le nom et le mot de passe de la base de données, chacun lu dans la variable LANGGRAPH_CHECKPOINTER_ sous laquelle il arrive, de sorte que le programme n’en écrit lui-même aucun, et exécute le graphe une fois pour chaque POST /threads/<thread>/runs. Le service du graphe démarre dès que la base de données accepte les connexions ; un serveur qui ouvre le checkpointer à son démarrage trouve donc la base de données prête à accepter des connexions. Construisez votre image à la racine du projet, écrivez son nom à la place de ghcr.io/example/support-agent:1.0.0 dans import-answers.yaml, et relancez l’import avec --sync, qui écrit la nouvelle réponse dans les brouillons et refait le pull ; puis lancez le build :

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

Définissez ensuite la clé et le mot de passe de la base de données dans votre shell et démarrez la stack :

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 nomme le projet, comme l’explique l’étape d’exécution de Déroulement d’une importation. --wait rend la main dès que la base de données se signale en bonne santé, que l’attente de celle-ci est terminée et que le service du graphe s’exécute.

Tester

La requête ci-dessous atteint le programme que l’image de ce guide exécute : le graphe derrière un petit serveur HTTP sur le port 8000, qui répond à POST /threads/<thread>/runs. Votre propre programme décide de sa propre route et de sa réponse. Envoyez-la à http://127.0.0.1:8000, l’adresse que publie 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]"
}

L’exécution a défini OPENAI_API_KEY sur une valeur fictive ; la réponse est donc le refus d’OpenAI, transmis par le programme. La requête du graphe a atteint l’API OpenAI avec la clé que le build a fournie, depuis un programme qui avait ouvert son checkpointer dans la base de données avec les informations d’identification que le build a fournies.

Arrêtez la pile avec :

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

-v supprime le volume dans lequel la base de données conserve ses données, et les conversations avec lui.

Sur Kubernetes, importez avec --target helm et poussez l’image vers un registre depuis lequel votre cluster tire les images, en la nommant dans import-answers.yaml. Créez ensuite les Secrets openai-api-key et support-db-password et appliquez le build, comme le décrit l’étape d’exécution de Déroulement d’une importation. Le Deployment du graphe n’a pas de Service. Son pod redémarre jusqu’à ce que la base de données accepte les connexions, car le programme ouvre son checkpointer au démarrage. Redirigez un port local vers celui-ci ; la commande s’exécute jusqu’à ce que vous l’arrêtiez :

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

Depuis un autre terminal, envoyez la même requête au port redirigé :

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