Importar uma aplicação LangGraph
Este guia prático importa a configuração de uma aplicação LangGraph — um grafo que responde às perguntas dos clientes sobre as suas encomendas — e compila a aplicação para Docker Compose. A importação gera como rascunho cada ficheiro que a compilação lê: o grafo, a base de dados PostgreSQL onde o seu checkpointer guarda o estado, o modelo que chama, as palavras-passe e a chave como referências a variáveis, e as realizações de cada um. 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 ficheiro e cada bloco de saída abaixo provém de uma execução real; a configuração e cada etapa do guia estão no exemplo import-langgraph, onde um script de verificação executa novamente a importação, compara o que ela escreve, o que imprime e os blocos que esta página cita com os ficheiros aí guardados, e valida e compila o que a importação escreveu.
Gerar o exemplo
É possível executar esta importação com os comandos desta página ou pedir ao seu assistente de IA que a execute.
Escreva o exemplo numa nova pasta com o nome dele:
aggrega scaffold --example import-langgraphDepois, imprime os próximos comandos a executar. O primeiro entra na nova pasta; o seguinte, abaixo, entra na pasta source da nova pasta, 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 os seus grafos no código e declara-os em langgraph.json, o ficheiro de configuração da ferramenta de linha de comandos do LangGraph. Esta, escrita para este guia prático, 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, pelo que o exemplo contém apenas a configuração. Ao lado dela, um .aggrega-config.yaml faz da pasta uma área de trabalho:
# 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 deste. O espaço de trabalho não indica nenhuma pasta de catálogo, pelo que a importação lê o catálogo da biblioteca padrão a partir do registry de onde obtém o seu importador: um snapshot assinado do catálogo publicado, que a primeira importação obtém, verifica e guarda na cache de conteúdo do espaço de trabalho, e que o registo que a importação escreve junto aos seus rascunhos indica pelo seu digest. Um espaço de trabalho que indique as suas próprias pastas de catálogo — em AGGREGA_CATALOG_DIRS, ou em workspace.catalog_dirs — importa antes com base nessas pastas.
O que a importação pergunta
Uma configuração LangGraph não indica nenhum modelo, uma vez que é o código do grafo que o escolhe, nem nenhuma imagem, uma vez que essa imagem é construída a partir do projeto. Por isso, a importação pede ambos: o nome do modelo que o grafo chama, para o modelo OpenAI que rascunha, e a imagem em que a aplicação é executada. Num terminal, pergunta-os e escreve as respostas nos rascunhos e no ficheiro de respostas, import-answers.yaml, dentro do diretório que importa — aqui a raiz do projeto, . — para que a importação seguinte as leia daí e não pergunte nada. Sem terminal — em integração contínua, ou através de um pipe — não pergunta nada: escreve o ficheiro 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 ficheiro, com as respostas: o grafo chama o gpt-4o-mini da OpenAI, e ghcr.io/example/support-agent:1.0.0 representa a imagem que se 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 destinam-se a um build para Kubernetes, com --target helm: aí, a palavra-passe da base de dados e a chave da OpenAI são lidas de Secrets do Kubernetes, e cada resposta é o nome de um Secret — a palavra-passe da base de dados de support-db-password, em ambas as extremidades, e a chave de openai-api-key — nunca a palavra-passe ou a chave. Um build para Docker Compose lê-as antes da shell, pelo que esta importação não usa essas respostas. O ficheiro de respostas da importação descreve o ficheiro, 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 indica um ficheiro de respostas guardado noutro local.
Entre em source:
cd sourceExecutar a importação
Indique o diretório da aplicação. A importação lê o respetivo langgraph.json e nenhum outro ficheiro dele:
aggrega import . --target composeNa saída padrão, lista o que escreveu:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonNa saída de erro padrão, com <workspace> a representar a pasta em que 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 para Docker Compose não usam, guardadas no ficheiro de respostas para uma compilação para Kubernetes. - As linhas
mappedindicam que o grafo é uma instância do agente LangGraph da biblioteca padrão,core/ai-agent/langgraph; que o seu checkpointer, onde o LangGraph guarda o estado de cada grafo, é uma instância decore/datastore/postgres, uma vez que a configuração não indica nenhum checkpointer e o LangGraph guarda então o estado em 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 estes Components pelo que a configuração declara, em vez de comparar cada um com o catálogo. Uma configuração cujocheckpointer.backendsejamongoé rascunhada comcore/datastore/ferretdb, que fala o protocolo do MongoDB, sobrecore/datastore/documentdb, os dois ligados tal como o Aggregate de FerretDB do catálogo os liga, com uma única palavra-passe para ambos. - A linha
Pull completeé a importação a obter aquilo de que a Release rascunhada depende, como fazaggrega pull, pararelease.lock, para que os rascunhos sejam validados e compilados de imediato. Com--offline, a importação não obtém nada e indica o comandoaggrega pulla executar.
O que a importação escreve
O Aggregate, a Release e o Manifest chamam-se imported/support, a partir do único grafo que langgraph.json serve, support, uma vez que uma configuração não tem nome próprio — uma que sirva vários grafos recebe o nome do seu ficheiro, ou do seu diretório quando, como aqui, a importação recebe o diretório — no namespace que a definição target_namespace do importador estabelece, imported, salvo se definir outro (Definições).
aggregate.yaml — o grafo, a base de dados em que guarda o estado e o modelo que chama, com cada ligação a declarar a credencial que apresenta, começando com comentários que indicam 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. A sua ligação checkpointer_db aponta para a base de dados e a sua ligação model para o modelo, cujo nome é a resposta que a importação leu de import-answers.yaml. recursion_limit não é escrito, pelo que se mantém o valor predefinido do Component, 25. A base de dados recebe uma palavra-passe, pelo que a Recipe PostgreSQL não escreve nenhuma própria, e o grafo apresenta a mesma palavra-passe na sua ligação à base de dados.
release.yaml — o ambiente, a imagem, a porta publicada e a proveniência da chave e das palavras-passe, com comentários acima do grafo que dizem qual é a sua imagem e o que lhe é entregue:
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 valor predefinido que a importação escreve porque nenhuma configuração indica um; altere-o onde a Release for implementada noutro local. 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, com reencaminhamento para a porta em que o seu programa está à escuta, infra.port, 8000 se não a definir. A chave e a palavra-passe 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 ficheiro 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 regista, por digest, as entidades do catálogo para as quais a Release foi resolvida, e .aggrega-import.json é o registo do que a importação escreveu, 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> a representar a pasta onde 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 o seu origin dos values do Aggregate ou da infra da Release, e a notificação informa que uma folha está declarada em ambos. Não altera nenhum veredicto.
O build escreve dist/compose/docker-compose.yaml, com um serviço para o grafo, outro para a base de dados e outro que aguarda pela base 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, o seu nome e a sua chave, o host, a porta, o utilizador, o nome e a palavra-passe da base de dados, e o seu próprio ponto de entrada de grafo. O utilizador e o nome da base de dados são os valores predefinidos do Component PostgreSQL, appuser e appdb, com os quais é criado o serviço da base de dados mostrado abaixo; o grafo recebe-os 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 utilizador e o nome da base de dados e o ponto de entrada do grafo chegam sob os nomes que o Component LangGraph entrega por predefinição, que um bloco inject: na ligaçã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, a sua chave e a palavra-passe da base de dados mantêm os nomes que os blocos indicam, tal como LANGGRAPH_DEFAULT_RECURSION_LIMIT, que o LangGraph lê por si próprio como limite de passos de uma execução cuja configuração não define nenhum. O próprio serviço da base de dados recebe a mesma palavra-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]O serviço do grafo só arranca depois de o terceiro serviço ter sido 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 da base de dados aceite uma ligação TCP, tentando a cada 2 s durante até 300 s; sem ligação até lá, termina indicando o endereço, e o grafo não é iniciado. Recebe o host e a porta da base de dados e mais nada:
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 palavra-passe são referências de variáveis, preenchidas a partir da sua shell quando a stack arranca. O modelo não recebe um serviço próprio: o grafo chega à API da OpenAI no endereço desta. O serviço do grafo publica a sua porta apenas em 127.0.0.1, e a porta própria da base 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 nele este prompt.
Usa apenas as ferramentas do Aggrega e não cries nenhuma pasta por tua conta. Se a pasta do Workspace ainda não contiver uma pasta `import-langgraph`, chama uma vez a ferramenta `scaffold` com `example` definido como `import-langgraph` e sem `dir`: ela escreve o exemplo numa nova pasta `import-langgraph`, cuja pasta `source` contém o que esta página importa. Em seguida, chama 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`, escreve os seus rascunhos em `import-langgraph/source` e obtém aquilo de que precisam. Em seguida, chama 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. Diz-me que ficheiros a compilação escreveu; estão em `import-langgraph/source/dist/`.Abrir 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 escreveu os seus rascunhos. A pasta contém uma única Release, o release.yaml gerado, pelo que o editor a seleciona automaticamente e verifica os rascunhos em relação a essa Release à medida que são editados, assinalando o que encontra no ficheiro e no painel Problemas. Aggrega: Show topology graph, na Paleta de Comandos, desenha os componentes da Release e as ligaçõ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 vista Aggrega na barra de atividades; Build escreve os seus ficheiros no dist/ da pasta. Utilizar o Aggrega no Visual Studio Code cobre o resto.
Execução
A imagem é construída 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 serviço do grafo, uma vez que a Recipe não define nenhum, pelo que esse comando tem de continuar em execução, e tem de servir pedidos se se pretender chegar ao grafo. Encontra o grafo, o modelo e a base de dados através das variáveis acima. É o seu programa que decide o endereço, a rota e a resposta.
A execução abaixo usou uma imagem deste tipo: o grafo no caminho que langgraph.json indica, src/support_agent/graph.py, um nó que responde através 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 no seu diretório de trabalho, pelo que o caminho que LANGGRAPH_GRAPH_ENTRYPOINT indica, relativo a ele, encontra o grafo. O servidor carrega esse grafo, guarda o estado de cada conversa na base de dados através do checkpointer PostgreSQL do LangGraph, aberto com o host, a porta, o utilizador, o nome e a palavra-passe da base de dados, cada um lido da variável LANGGRAPH_CHECKPOINTER_ sob a qual chega, pelo que o próprio programa não escreve nenhum deles, e executa o grafo uma vez por cada POST /threads/<thread>/runs. O serviço do grafo arranca assim que a base de dados aceita ligações, pelo que um servidor que abre o checkpointer ao arrancar encontra a base de dados a aceitar ligações. Construa a 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 volte a importar com --sync, que escreve a nova resposta nos rascunhos e volta a fazer o pull; depois faça o build:
docker build -t order-support:local .aggrega import . --syncaggrega build --release release.yamlEm seguida, defina a chave e a palavra-passe da base de dados na 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 dá nome ao projeto, como explica o passo de execução de Como decorre uma importação. --wait retorna assim que a base de dados reporta estar saudável, a espera por ela terminou e o serviço do grafo está em execução.
Testar
O pedido abaixo chega ao programa que a imagem deste guia executa: o grafo por detrás de um pequeno servidor HTTP na porta 8000, que responde a POST /threads/<thread>/runs. O seu próprio programa decide a sua própria rota e resposta. Envie-o 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 com um valor provisório, pelo que a resposta é a recusa da OpenAI, transmitida pelo programa. O pedido do grafo chegou à API da OpenAI com a chave que o build entregou, a partir de um programa que tinha aberto o seu checkpointer na base 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 a base de dados guarda os seus dados, e com ele as conversas.
No Kubernetes, importe com --target helm e envie a imagem para um registo a partir do qual o cluster obtém imagens, indicando-a em import-answers.yaml. Em seguida, crie os Secrets openai-api-key e support-db-password e aplique o build, como descreve o passo de execução de Como decorre uma importação. O Deployment do grafo não tem Service. O seu pod reinicia até a base de dados aceitar ligações, porque o programa abre o seu checkpointer ao arrancar. Reencaminhe uma porta local para ele; o comando fica em execução até ser interrompido:
kubectl port-forward deploy/support 8000:8000Forwarding from 127.0.0.1:8000 -> 8000Forwarding from [::1]:8000 -> 8000Noutro terminal, envie o mesmo pedido para a porta reencaminhada:
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]"}