Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Brasil)
Esta página foi traduzida automaticamente. Leia o original em inglês.

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:

Terminal window
aggrega scaffold --example import-langgraph

Em 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:

Terminal window
cd import-langgraph

A pasta source do exemplo gerado aberta no Visual Studio Code, mostrando sua configuração do LangGraph, que nomeia um grafo, support.

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.ai

A 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 again

O 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:

Terminal window
cd source

Executar a importação

Indique o diretório da aplicação. A importação lê o langgraph.json dele e nenhum outro arquivo:

Terminal window
aggrega import . --target compose

Na saída padrão, ela lista o que gravou:

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

Na 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 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)

A importação executada a partir do editor: o Aggregate, a Release e o Manifest gerados aparecem ao lado da configuração do LangGraph, a saída do Aggrega lista como o grafo, seu checkpointer e seu modelo foram mapeados e os arquivos gravados, e uma notificação diz que a importação gerou 3 arquivos, reconhecidos como langgraph.

  • A linha info indica as respostas que os rascunhos do Docker Compose não usam, mantidas no arquivo de respostas para um build para Kubernetes.
  • As linhas mapped dizem 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 de core/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 de core/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 cujo checkpointer.backend é mongo é rascunhada com core/datastore/ferretdb, que fala o protocolo do MongoDB, sobre core/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 faz aggrega pull, em release.lock, para que os rascunhos sejam validados e compilados imediatamente. Com --offline, a importação não busca nada e indica o comando aggrega pull a 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/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 é 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/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: {}

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/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 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

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

A Release gerada aberta no editor após a validação, com a saída do Aggrega e uma notificação informando que nenhum problema foi encontrado.

A compilação da Release gerada: uma pasta dist aparece no Explorer, a saída do Aggrega lista o arquivo do Docker Compose gravado, e uma notificação diz que 1 arquivo foi gravado.

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>/dist

A 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_started

O 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:

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

Em seguida, defina a chave e a senha do banco de dados no seu shell e inicie a 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 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:

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

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:

Terminal window
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:

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

Em outro terminal, envie a mesma requisição para a porta encaminhada:

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