Importar una aplicación LangGraph
Este recorrido guiado importa la configuración de una aplicación LangGraph — un grafo que responde a las preguntas de los clientes sobre sus pedidos — y compila la aplicación para Docker Compose. La importación genera como borrador cada archivo que lee la compilación: el grafo, la base de datos PostgreSQL en la que su checkpointer guarda el estado, el modelo al que llama, las contraseñas y la clave como referencias a variables, y las realizaciones de cada uno. Pide una sola vez los dos valores que ninguna configuración contiene: el modelo al que llama el código del grafo y la imagen en la que se ejecuta la aplicación. Cada archivo y cada bloque de salida que aparecen a continuación provienen de una ejecución real; la configuración y cada etapa del recorrido están en el ejemplo import-langgraph, donde un script de comprobación vuelve a ejecutar la importación, compara lo que escribe, lo que imprime y los bloques que cita esta página con los archivos que se conservan allí, y valida y compila lo que escribió la importación.
Generar el ejemplo
Puedes ejecutar esta importación con los comandos de esta página o pedir a tu asistente de IA que la ejecute por ti.
Escribe el ejemplo en una carpeta nueva con su nombre:
aggrega scaffold --example import-langgraphDespués imprime los comandos que hay que ejecutar a continuación. El primero entra en la carpeta nueva; el siguiente, más abajo, entra en la carpeta source de la carpeta nueva, que contiene lo que esta página importa y es donde se ejecuta la importación:
cd import-langgraph
El proyecto
Una aplicación LangGraph mantiene sus grafos en el código y los declara en langgraph.json, el archivo de configuración de la herramienta de línea de comandos de LangGraph. Esta, escrita para este recorrido, declara un grafo, support, mediante la ruta de importación del grafo en el código de la aplicación y una descripción:
{ "$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." } }}La importación lee langgraph.json y nunca el código de la aplicación, por lo que el ejemplo contiene solo la configuración. Junto a ella, un .aggrega-config.yaml convierte la carpeta en un espacio de trabajo:
# 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.aiLa importación hace referencia a los Components del catálogo para el agente LangGraph, para PostgreSQL y para el modelo de OpenAI, y --target genera como borrador un Manifest a partir de sus Recipes. El espacio de trabajo no indica ninguna carpeta de catálogo, así que la importación lee el catálogo de la biblioteca estándar desde el registro del que obtiene su importador: una instantánea firmada del catálogo publicado, que la primera importación obtiene, verifica y guarda en la caché de contenido del espacio de trabajo, y que el historial que la importación escribe junto a sus borradores nombra por su resumen criptográfico. Un espacio de trabajo que indica sus propias carpetas de catálogo — en AGGREGA_CATALOG_DIRS, o bajo workspace.catalog_dirs — importa en cambio a partir de ellas.
Qué pide la importación
Una configuración de LangGraph no nombra ningún modelo, ya que lo elige el código del grafo, ni ninguna imagen, ya que esa imagen la construyes tú a partir de tu proyecto. Por eso la importación pregunta por ambos: el nombre del modelo al que llama el grafo, para el modelo de OpenAI que redacta como borrador, y la imagen en la que se ejecuta la aplicación. En un terminal pregunta, y escribe las respuestas en los borradores y en el archivo de respuestas, import-answers.yaml, dentro del directorio que importa — aquí la raíz del proyecto, . — para que la siguiente importación las lea desde ahí y no pregunte nada. Sin terminal — en integración continua, o a través de una tubería — no pregunta nada: escribe el archivo con las claves vacías y se detiene:
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 againEl ejemplo ya contiene el archivo, con las respuestas: el grafo llama a gpt-4o-mini de OpenAI, y ghcr.io/example/support-agent:1.0.0 representa la imagen que construyes:
# 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"Las tres respuestas origin son para una compilación para Kubernetes, con --target helm: allí la contraseña de la base de datos y la clave de OpenAI se leen de Secrets de Kubernetes, y cada respuesta es el nombre de un Secret — la contraseña de la base de datos desde support-db-password, en ambos extremos, y la clave desde openai-api-key — nunca la contraseña ni la clave. Una compilación para Docker Compose las lee en cambio de tu shell, así que esta importación no usa esas respuestas. El archivo de respuestas de la importación describe el archivo, las preguntas y las reglas para la respuesta de un secreto.
aggrega import enumera cada opción que admite el comando, entre ellas --answers, que nombra un archivo de respuestas guardado en otro lugar.
Entra en source:
cd sourceEjecutar la importación
Indica el directorio de la aplicación. La importación lee su langgraph.json y ningún otro archivo de él:
aggrega import . --target composeEn la salida estándar enumera lo que escribió:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonEn la salida de error estándar, donde <workspace> representa la carpeta en la que la ejecutaste:
[… 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)
- La línea
infonombra las respuestas que los borradores de Docker Compose no usan, guardadas en el archivo de respuestas para una compilación para Kubernetes. - Las líneas
mappedindican que el grafo es una instancia del agente LangGraph de la biblioteca estándar,core/ai-agent/langgraph; que su checkpointer, donde LangGraph guarda el estado de cada grafo, es una instancia decore/datastore/postgres, ya que la configuración no nombra ningún checkpointer y entonces LangGraph guarda el estado en PostgreSQL; y que el modelo al que llama cada grafo es una instancia decore/ai-model/openai. Su nivel indicaNONE: la importación de LangGraph hace referencia a estos Components según lo que declara la configuración en lugar de sopesar cada uno frente al catálogo. Una configuración cuyocheckpointer.backendesmongose genera como borrador concore/datastore/ferretdb, que habla el protocolo de MongoDB, sobrecore/datastore/documentdb, ambos conectados como los conecta el Aggregate de FerretDB del catálogo, con una sola contraseña para los dos. - La línea
Pull completees la importación obteniendo aquello de lo que depende la Release redactada, como haceaggrega pull, enrelease.lock, para que los borradores se validen y se compilen de inmediato. Con--offline, la importación no obtiene nada e indica el comandoaggrega pullque hay que ejecutar.
Lo que escribe
El Aggregate, la Release y el Manifest se llaman imported/support, por el único grafo que sirve langgraph.json, support, ya que una configuración no lleva nombre propio — una que sirve varios grafos recibe el nombre de su archivo, o el de su directorio cuando, como aquí, a la importación se le da su directorio — bajo el namespace que fija el ajuste target_namespace del importador, imported salvo que fijes otro (Ajustes).
aggregate.yaml — el grafo, la base de datos en la que guarda su estado y el modelo al que llama, cada conexión declarando la credencial que presenta, con comentarios al principio que dicen qué se leyó y qué no:
# 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 es la ruta de importación del grafo tal como la escribe la configuración. Su conexión checkpointer_db está enlazada a la base de datos y su conexión model al modelo, cuyo nombre es la respuesta que la importación leyó de import-answers.yaml. recursion_limit no está escrito, así que se mantiene el valor predeterminado del Component, 25. La base de datos recibe una contraseña, de modo que la Recipe de PostgreSQL no escribe ninguna propia, y el grafo presenta la misma contraseña en su conexión a la base de datos.
release.yaml — el entorno, la imagen, el puerto publicado y de dónde vienen la clave y las contraseñas, con comentarios sobre el grafo que dicen cuál es su imagen y qué se le entrega:
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: {}El entorno, development, es un valor predeterminado que la importación escribe porque ninguna configuración nombra uno; cámbialo donde la Release se despliegue en otro lugar. La imagen es la respuesta que la importación leyó de import-answers.yaml. El grafo se publica en la dirección de loopback de tu máquina, en el 8000, reenviando al puerto en el que escucha su programa, infra.port, 8000 salvo que lo definas. La clave y la contraseña son referencias a variables, ${OPENAI_API_KEY} y ${POSTGRES_PASSWORD}, nunca valores.
manifest.yaml — la Recipe de Compose de cada tipo y la realización que escribe cada referencia a variable en el archivo de Compose tal como está escrita:
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 registra, por digest, las entidades del catálogo a las que se resolvió la Release, y .aggrega-import.json es el registro de lo que escribió la importación, que lee un aggrega import --sync posterior.
Validar y compilar
aggrega validate --release release.yamlaggrega build --release release.yaml

La validación imprime:
notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)release dependency validation passed: release.yaml (schema-pillar + dependency pillars)y la compilación, donde <workspace> representa la carpeta en la que la ejecutaste:
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>/distLa línea notice es informativa: la Feature de secreto acepta su origin desde los values del Aggregate o desde la infra de la Release, y el aviso informa de que una hoja está declarada en ambos. No cambia ningún veredicto.
La compilación escribe dist/compose/docker-compose.yaml, con un servicio para el grafo, otro para la base de datos y otro que espera a la base de datos. El servicio del grafo:
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_startedEl grafo recibe la dirección del modelo, su nombre y su clave, el host, el puerto, el usuario, el nombre y la contraseña de la base de datos, y su propio punto de entrada del grafo. El usuario y el nombre de la base de datos son los valores predeterminados del Component PostgreSQL, appuser y appdb, con los que se crea el servicio de la base de datos que aparece más abajo; el grafo los recibe porque la Recipe de PostgreSQL publica ambos, y con un almacén que no publica ninguno de los dos, como ocurre con Valkey, no recibe ninguno. El nombre del modelo, el host, el puerto, el usuario y el nombre de la base de datos y el punto de entrada del grafo llegan con los nombres que el Component de LangGraph entrega de forma predeterminada, que un bloque inject: en la conexión, o en el propio componente para sus propios valores, sustituye por los nombres que lee tu código. La dirección del modelo, su clave y la contraseña de la base de datos se quedan con los nombres que indican los bloques, y lo mismo ocurre con LANGGRAPH_DEFAULT_RECURSION_LIMIT, que LangGraph lee por sí mismo como límite de pasos de una ejecución cuya configuración no fija ninguno. El propio servicio de la base de datos recibe la misma contraseña:
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]El servicio del grafo solo se inicia cuando el tercer servicio ha terminado. Este se ejecuta una sola vez, en la imagen del agente quickstart del catálogo en lugar de en la del propio grafo, y espera hasta que la dirección de la base de datos acepta una conexión TCP, reintentando cada 2 s durante un máximo de 300 s; si para entonces no logra ninguna conexión, termina indicando la dirección, y el grafo no se inicia. Recibe el host y el puerto de la base de datos y nada más:
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 clave y la contraseña son referencias a variables, que se completan desde tu shell cuando se inicia el stack. El modelo no obtiene un servicio propio: el grafo llega a la API de OpenAI en la propia dirección de esta. El servicio del grafo publica su puerto solo en 127.0.0.1, y al propio puerto de la base de datos se llega en la red del stack, sin nada publicado.
Con un asistente de IA
Un asistente de IA configurado con las herramientas de Aggrega puede hacer lo mismo: pega en él este prompt.
Usa solo las herramientas de Aggrega y no crees ninguna carpeta por tu cuenta. Si la carpeta del Workspace todavía no contiene una carpeta `import-langgraph`, llama una vez a la herramienta `scaffold` con `example` establecido en `import-langgraph` y sin `dir`: escribe el ejemplo en una nueva carpeta `import-langgraph`, cuya carpeta `source` contiene lo que importa esta página. Después llama a la herramienta `import` con `workspace_root` establecido en `import-langgraph/source`, `source` establecido en `.` y `target` establecido en `compose`: lee las respuestas que necesita de `import-answers.yaml` junto a `langgraph.json`, escribe sus borradores en `import-langgraph/source` y descarga lo que necesitan. Después llama a la herramienta `validate` con `workspace_root` establecido en `import-langgraph/source` y `release` establecido en `release.yaml`, y a la herramienta `build` con `workspace_root` establecido en `import-langgraph/source`, `release` establecido en `release.yaml` y `write` establecido en true. Dime qué archivos escribió la compilación; están en `import-langgraph/source/dist/`.Ábrelo en VS Code
Con la extensión de Aggrega para Visual Studio Code instalada, abre en VS Code la carpeta import-langgraph/source, donde la importación escribió sus borradores. La carpeta contiene una sola Release, el release.yaml generado, así que el editor la selecciona por ti y comprueba los borradores con esa Release mientras los editas, marcando lo que encuentra en el archivo y en el panel Problemas. Aggrega: Show topology graph, en la paleta de comandos, dibuja los componentes de la Release y las conexiones entre ellos. Aggrega: Build, Aggrega: Preview build y Aggrega: Pull actúan sobre la misma Release, y cada uno es también un botón del panel Commands de la vista Aggrega en la barra de actividades; Build escribe sus archivos en el dist/ de la carpeta. Usar Aggrega en Visual Studio Code cubre el resto.
Ejecución
Construyes la imagen a partir del proyecto, con un Dockerfile propio: el código del grafo, con LangGraph instalado. Docker Compose ejecuta el comando propio de la imagen como servicio del grafo, ya que la Recipe no establece ninguno, así que ese comando debe seguir en ejecución, y debe atender solicitudes si quieres llegar al grafo. Encuentra el grafo, el modelo y la base de datos a través de las variables anteriores. Tu programa decide la dirección, la ruta y la respuesta.
La ejecución siguiente usó una imagen así: el grafo en la ruta que indica langgraph.json, src/support_agent/graph.py, un nodo que responde a través del modelo que indica OPENAI_MODEL y, como comando de la imagen, un pequeño servidor HTTP propio del programa en el puerto 8000. La imagen conserva la estructura del proyecto en su directorio de trabajo, de modo que la ruta que indica LANGGRAPH_GRAPH_ENTRYPOINT, relativa a él, encuentra el grafo. El servidor carga ese grafo, guarda el estado de cada conversación en la base de datos mediante el checkpointer de PostgreSQL de LangGraph, abierto con el host, el puerto, el usuario, el nombre y la contraseña de la base de datos, cada uno leído de la variable LANGGRAPH_CHECKPOINTER_ con la que llega, de modo que el programa no escribe ninguno por sí mismo, y ejecuta el grafo una vez por cada POST /threads/<thread>/runs. El servicio del grafo se inicia en cuanto la base de datos acepta conexiones, así que un servidor que abre el checkpointer al iniciarse encuentra la base de datos aceptando conexiones. Construye tu imagen en la raíz del proyecto, escribe su nombre en lugar de ghcr.io/example/support-agent:1.0.0 en import-answers.yaml y vuelve a importar con --sync, que escribe la nueva respuesta en los borradores y vuelve a hacer el pull; luego compila:
docker build -t order-support:local .aggrega import . --syncaggrega build --release release.yamlDespués, establece la clave y la contraseña de la base de datos en tu shell e inicia el 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 nombra el proyecto, como explica el paso de ejecución de Cómo se ejecuta una importación. --wait regresa en cuanto la base de datos informa de que está en buen estado, la espera por ella ha terminado y el servicio del grafo está en ejecución.
Probarlo
La solicitud siguiente llega al programa que ejecuta la imagen de este recorrido: el grafo detrás de un pequeño servidor HTTP en el puerto 8000, que responde a POST /threads/<thread>/runs. Tu propio programa decide su propia ruta y respuesta. Envíala a http://127.0.0.1:8000, la dirección que publica published_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]"}La ejecución estableció OPENAI_API_KEY en un valor de marcador, así que la respuesta es el rechazo de OpenAI, transmitido por el programa. La solicitud del grafo llegó a la API de OpenAI con la clave que entregó el build, desde un programa que había abierto su checkpointer en la base de datos con las credenciales que entregó el build.
Detén el stack con:
docker compose -p order-support -f dist/compose/docker-compose.yaml down -v-v elimina el volumen en el que la base de datos guarda sus datos, y con él las conversaciones.
En Kubernetes, importa con --target helm y sube la imagen a un registro del que tu clúster extraiga imágenes, nombrándola en import-answers.yaml. Después crea los Secrets openai-api-key y support-db-password y aplica el build, como describe el paso de ejecución de Cómo se ejecuta una importación. El Deployment del grafo no tiene Service. Su pod se reinicia hasta que la base de datos acepta conexiones, porque el programa abre su checkpointer al iniciarse. Reenvía un puerto local hacia él; el comando se ejecuta hasta que lo detengas:
kubectl port-forward deploy/support 8000:8000Forwarding from 127.0.0.1:8000 -> 8000Forwarding from [::1]:8000 -> 8000Desde otra terminal, envía la misma solicitud al puerto reenviado:
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]"}