Importar uma aplicação LangGraph
Este passo a passo importa a configuração de uma aplicação LangGraph — um grafo que responde às perguntas dos clientes sobre seus pedidos — e compila a aplicação para Docker Compose. A importação gera como rascunho cada arquivo que a compilação lê: o grafo, o banco de dados PostgreSQL em que seu checkpointer mantém o estado, o modelo que ele chama, as senhas e a chave como referências a variáveis, e as realizações de cada um. Ela pede uma única vez os dois valores que nenhuma configuração contém: o modelo que o código do grafo chama e a imagem em que a aplicação é executada. Cada arquivo e cada bloco de saída abaixo vem de uma execução real; a configuração e cada etapa do passo a passo estão no exemplo import-langgraph, onde um script de verificação executa a importação novamente, compara o que ela escreve, o que ela imprime e os blocos que esta página cita com os arquivos mantidos ali, e valida e compila o que a importação escreveu.
Gerar o exemplo
Você pode executar esta importação com os comandos desta página ou pedir ao seu assistente de IA que a execute para você.
Escreva o exemplo em uma nova pasta com o nome dele:
aggrega scaffold --example import-langgraphEm seguida ele imprime os próximos comandos a executar. O primeiro entra na pasta nova; o seguinte, abaixo, entra na pasta source da pasta nova, que contém o que esta página importa e é onde a importação é executada:
cd import-langgraph
O projeto
Uma aplicação LangGraph mantém seus grafos no código e os declara em langgraph.json, o arquivo de configuração da ferramenta de linha de comando do LangGraph. Esta, escrita para este passo a passo, declara um grafo, support, pelo caminho de importação do grafo no código da aplicação e por uma descrição:
{ "$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." } }}A importação lê langgraph.json e nunca o código da aplicação, então o exemplo contém apenas a configuração. Ao lado dela, um .aggrega-config.yaml torna a pasta um 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.aiA importação referencia os Components de agente LangGraph, de PostgreSQL e de modelo OpenAI do catálogo, e --target gera o rascunho de um Manifest a partir das Recipes dele. O espaço de trabalho não indica nenhuma pasta de catálogo, então a importação lê o catálogo da biblioteca padrão a partir do registro do qual obtém o seu importador: um snapshot assinado do catálogo publicado, que a primeira importação busca, verifica e guarda no cache de conteúdo do espaço de trabalho, e que o histórico que a importação escreve ao lado dos seus rascunhos indica pelo seu digest. Um espaço de trabalho que indica suas próprias pastas de catálogo — em AGGREGA_CATALOG_DIRS, ou em workspace.catalog_dirs — importa a partir delas em vez disso.
O que a importação pergunta
Uma configuração LangGraph não nomeia nenhum modelo, já que o código do grafo o escolhe, nem nenhuma imagem, já que você constrói essa imagem a partir do seu projeto. Por isso a importação pergunta por ambos: o nome do modelo que o grafo chama, para o modelo OpenAI que ela rascunha, e a imagem em que a aplicação é executada. Em um terminal, ela pergunta e escreve as respostas nos rascunhos e no arquivo de respostas, import-answers.yaml, dentro do diretório que importa — aqui a raiz do projeto, . — para que a próxima importação as leia de lá e não pergunte nada. Sem terminal — em integração contínua, ou por meio de um pipe — ela não pergunta nada: escreve o arquivo com as chaves vazias e para:
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 againO exemplo já contém o arquivo, respondido: o grafo chama o gpt-4o-mini da OpenAI, e ghcr.io/example/support-agent:1.0.0 representa a imagem que você constrói:
# 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"As três respostas origin são para um build para Kubernetes, com --target helm: ali a senha do banco de dados e a chave da OpenAI são lidas de Secrets do Kubernetes, e cada resposta é o nome de um Secret — a senha do banco de dados de support-db-password, nas duas pontas, e a chave de openai-api-key — nunca a senha ou a chave. Um build para Docker Compose as lê do seu shell em vez disso, então esta importação não usa essas respostas. O arquivo de respostas da importação descreve o arquivo, as perguntas e as regras para a resposta de um segredo.
aggrega import lista todas as flags que o comando aceita, entre elas --answers, que nomeia um arquivo de respostas mantido em outro lugar.
Entre em source:
cd sourceExecutar a importação
Indique o diretório da aplicação. A importação lê o langgraph.json dele e nenhum outro arquivo:
aggrega import . --target composeNa saída padrão, ela lista o que gravou:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonNa saída de erro padrão, com <workspace> representando a pasta em que você a executou:
[… 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)
- A linha
infoindica as respostas que os rascunhos do Docker Compose não usam, mantidas no arquivo de respostas para um build para Kubernetes. - As linhas
mappeddizem que o grafo é uma instância do agente LangGraph da biblioteca padrão,core/ai-agent/langgraph; que seu checkpointer, onde o LangGraph mantém o estado de cada grafo, é uma instância decore/datastore/postgres, já que a configuração não nomeia nenhum checkpointer e o LangGraph então mantém o estado no PostgreSQL; e que o modelo que cada grafo chama é uma instância decore/ai-model/openai. O nível delas éNONE: a importação de LangGraph referencia esses Components pelo que a configuração declara, em vez de comparar cada um com o catálogo. Uma configuração cujocheckpointer.backendémongoé rascunhada comcore/datastore/ferretdb, que fala o protocolo do MongoDB, sobrecore/datastore/documentdb, os dois conectados como o Aggregate de FerretDB do catálogo os conecta, com uma única senha para ambos. - A linha
Pull completeé a importação buscando aquilo de que a Release rascunhada depende, como fazaggrega pull, emrelease.lock, para que os rascunhos sejam validados e compilados imediatamente. Com--offline, a importação não busca nada e indica o comandoaggrega pulla executar.
O que a importação grava
O Aggregate, a Release e o Manifest se chamam imported/support, a partir do único grafo que langgraph.json serve, support, já que uma configuração não carrega nome próprio — uma que serve vários grafos recebe o nome do seu arquivo, ou do seu diretório quando, como aqui, a importação recebe o diretório — sob o namespace definido pela configuração target_namespace do importador, imported, a menos que você defina outro (Configurações).
aggregate.yaml — o grafo, o banco de dados em que ele mantém o estado e o modelo que ele chama, com cada conexão declarando a credencial que apresenta, abrindo com comentários que dizem o que foi lido e o que não foi:
# 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 é o caminho de importação do grafo tal como a configuração o escreve. Sua conexão checkpointer_db está ligada ao banco de dados e sua conexão model ao modelo, cujo nome é a resposta que a importação leu de import-answers.yaml. recursion_limit não é escrito, então vale o padrão do Component, 25. O banco de dados recebe uma senha, de modo que a Recipe PostgreSQL não escreve nenhuma própria, e o grafo apresenta a mesma senha em sua conexão com o banco de dados.
release.yaml — o ambiente, a imagem, a porta publicada e de onde vêm a chave e as senhas, com comentários acima do grafo dizendo qual é a sua imagem e o que é entregue a ele:
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: {}O ambiente, development, é um padrão que a importação escreve porque nenhuma configuração nomeia um; altere-o onde a Release for implantada em outro lugar. A imagem é a resposta que a importação leu de import-answers.yaml. O grafo é publicado no endereço de loopback da sua máquina, na 8000, encaminhando para a porta em que o programa dele escuta, infra.port, 8000, a menos que você a defina. A chave e a senha são referências a variáveis, ${OPENAI_API_KEY} e ${POSTGRES_PASSWORD}, nunca valores.
manifest.yaml — a Recipe Compose de cada tipo e a realização que escreve cada referência a variável no arquivo 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, as entidades do catálogo para as quais a Release foi resolvida, e .aggrega-import.json é o registro do que a importação gravou, que um aggrega import --sync posterior lê.
Validar e compilar
aggrega validate --release release.yamlaggrega build --release release.yaml

A validação 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)e o build, com <workspace> representando a pasta em que você o executou:
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>/distA linha notice é apenas informativa: a Feature de segredo aceita seu origin dos values do Aggregate ou da infra da Release, e a notificação informa que uma folha está declarada em ambos. Ela não altera nenhum veredito.
O build escreve dist/compose/docker-compose.yaml, com um serviço para o grafo, outro para o banco de dados e outro que aguarda o banco de dados. O serviço do 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_startedO grafo recebe o endereço do modelo, seu nome e sua chave, o host, a porta, o usuário, o nome e a senha do banco de dados, e seu próprio ponto de entrada de grafo. O usuário e o nome do banco de dados são os padrões do Component PostgreSQL, appuser e appdb, com os quais o serviço do banco de dados mostrado abaixo é criado; o grafo os recebe porque a Recipe PostgreSQL publica ambos, e, com um armazenamento que não publica nenhum dos dois, como o Valkey, não recebe nenhum. O nome do modelo, o host, a porta, o usuário e o nome do banco de dados e o ponto de entrada do grafo chegam sob os nomes que o Component LangGraph entrega por padrão, que um bloco inject: na conexão, ou no próprio componente para os seus próprios valores, substitui pelos nomes que o seu código lê. O endereço do modelo, sua chave e a senha do banco de dados permanecem com os nomes que os blocos indicam, assim como LANGGRAPH_DEFAULT_RECURSION_LIMIT, que o LangGraph lê por conta própria como limite de passos de uma execução cuja configuração não define nenhum. O próprio serviço do banco de dados recebe a mesma senha:
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]O serviço do grafo só inicia depois que o terceiro serviço é concluído. Este é executado uma única vez, na imagem do agente quickstart do catálogo, e não na do próprio grafo, e aguarda até que o endereço do banco de dados aceite uma conexão TCP, tentando a cada 2 s por até 300 s; sem conexão até lá, ele encerra indicando o endereço, e o grafo não é iniciado. Ele recebe o host e a porta do banco de dados e nada mais:
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"A chave e a senha são referências de variáveis, preenchidas a partir do seu shell quando a stack é iniciada. O modelo não recebe um serviço próprio: o grafo alcança a API da OpenAI no próprio endereço dela. O serviço do grafo publica sua porta apenas em 127.0.0.1, e a porta do próprio banco de dados é alcançada na rede da stack, sem nada publicado.
Com um assistente de IA
Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole este prompt nele.
Use apenas as ferramentas do Aggrega e não crie nenhuma pasta por conta própria. Se a pasta do Workspace ainda não contiver uma pasta `import-langgraph`, chame a ferramenta `scaffold` uma vez com `example` definido como `import-langgraph` e sem `dir`: ela grava o exemplo em uma nova pasta `import-langgraph`, cuja pasta `source` contém o que esta página importa. Em seguida, chame a ferramenta `import` com `workspace_root` definido como `import-langgraph/source`, `source` definido como `.` e `target` definido como `compose`: ela lê as respostas de que precisa em `import-answers.yaml` ao lado de `langgraph.json`, grava seus rascunhos em `import-langgraph/source` e baixa o que eles precisam. Em seguida, chame a ferramenta `validate` com `workspace_root` definido como `import-langgraph/source` e `release` definido como `release.yaml`, e a ferramenta `build` com `workspace_root` definido como `import-langgraph/source`, `release` definido como `release.yaml` e `write` definido como true. Diga-me quais arquivos a compilação gravou; eles ficam em `import-langgraph/source/dist/`.Abra no VS Code
Com a extensão do Aggrega para Visual Studio Code instalada, abra no VS Code a pasta import-langgraph/source, onde a importação gravou seus rascunhos. A pasta contém uma única Release, o release.yaml gerado, então o editor a seleciona para você e verifica os rascunhos em relação a essa Release enquanto você os edita, marcando o que encontra no arquivo e no painel Problemas. Aggrega: Show topology graph, na Paleta de Comandos, desenha os componentes da Release e as conexões entre eles. Aggrega: Build, Aggrega: Preview build e Aggrega: Pull atuam sobre a mesma Release, e cada um também é um botão no painel Commands da visualização Aggrega na barra de atividades; Build grava seus arquivos no dist/ da pasta. Usar o Aggrega no Visual Studio Code cobre o restante.
Execução
Você constrói a imagem a partir do projeto, com um Dockerfile próprio: o código do grafo, com o LangGraph instalado. O Docker Compose executa o comando próprio da imagem como o serviço do grafo, já que a Recipe não define nenhum, então esse comando precisa continuar em execução, e precisa atender requisições se você quiser alcançar o grafo. Ele encontra o grafo, o modelo e o banco de dados por meio das variáveis acima. O seu programa decide o endereço, a rota e a resposta.
A execução abaixo usou uma imagem assim: o grafo no caminho que langgraph.json indica, src/support_agent/graph.py, um nó que responde por meio do modelo que OPENAI_MODEL indica e, como comando da imagem, um pequeno servidor HTTP do próprio programa na porta 8000. A imagem mantém a estrutura do projeto em seu diretório de trabalho, de modo que o caminho que LANGGRAPH_GRAPH_ENTRYPOINT indica, relativo a ele, encontra o grafo. O servidor carrega esse grafo, mantém o estado de cada conversa no banco de dados por meio do checkpointer PostgreSQL do LangGraph, aberto com o host, a porta, o usuário, o nome e a senha do banco de dados, cada um lido da variável LANGGRAPH_CHECKPOINTER_ sob a qual chega, de modo que o programa não escreve nenhum deles por conta própria, e executa o grafo uma vez para cada POST /threads/<thread>/runs. O serviço do grafo inicia assim que o banco de dados aceita conexões, então um servidor que abre o checkpointer ao iniciar encontra o banco de dados aceitando conexões. Construa sua imagem na raiz do projeto, escreva o nome dela no lugar de ghcr.io/example/support-agent:1.0.0 em import-answers.yaml e importe novamente com --sync, que escreve a nova resposta nos rascunhos e faz o pull de novo; depois faça o build:
docker build -t order-support:local .aggrega import . --syncaggrega build --release release.yamlEm seguida, defina a chave e a senha do banco de dados no seu shell e inicie a 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 nomeia o projeto, como explica a etapa de execução de Como uma importação é executada. --wait retorna assim que o banco de dados informa que está íntegro, a espera por ele termina e o serviço do grafo está em execução.
Teste
A requisição abaixo chega ao programa que a imagem deste passo a passo executa: o grafo por trás de um pequeno servidor HTTP na porta 8000, que responde a POST /threads/<thread>/runs. Seu próprio programa decide sua própria rota e resposta. Envie-a para http://127.0.0.1:8000, o endereço que published_port publica:
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]"}A execução definiu OPENAI_API_KEY como um valor provisório, então a resposta é a recusa da OpenAI, repassada pelo programa. A requisição do grafo chegou à API da OpenAI com a chave que o build entregou, a partir de um programa que havia aberto seu checkpointer no banco de dados com as credenciais que o build entregou.
Pare a stack com:
docker compose -p order-support -f dist/compose/docker-compose.yaml down -v-v remove o volume em que o banco de dados mantém seus dados, e as conversas junto com ele.
No Kubernetes, importe com --target helm e envie a imagem para um registro do qual seu cluster faz pull, informando-a em import-answers.yaml. Em seguida, crie os Secrets openai-api-key e support-db-password e aplique o build, como descreve a etapa de execução de Como uma importação é executada. O Deployment do grafo não tem Service. Seu pod reinicia até que o banco de dados aceite conexões, porque o programa abre seu checkpointer ao iniciar. Encaminhe uma porta local para ele; o comando fica em execução até que você o interrompa:
kubectl port-forward deploy/support 8000:8000Forwarding from 127.0.0.1:8000 -> 8000Forwarding from [::1]:8000 -> 8000Em outro terminal, envie a mesma requisição para a porta encaminhada:
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]"}