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

Importer un projet CrewAI

Ce guide pas à pas importe les déclarations d’agents et de tâches d’un projet CrewAI — une crew de deux agents qui répond à la question d’un client sur les offres de support — et construit la crew pour Docker Compose. L’importation ébauche chaque fichier que lit le build : les deux agents et leur modèle, la clé que chacun présente au modèle sous forme de référence de variable, et les réalisations de chacun. Elle demande une seule fois l’unique valeur qu’aucune déclaration ne contient, l’image dans laquelle s’exécute le programme de la crew. Chaque fichier et chaque bloc de sortie ci-dessous proviennent d’une exécution réelle ; les déclarations et chaque étape du guide se trouvent dans l’exemple import-crewai, où un script de vérification relance l’importation, compare ce qu’elle écrit, ce qu’elle affiche et les blocs que cite cette page avec les fichiers qui y sont conservés, puis valide et construit ce que l’importation a écrit.

Générer l’exemple

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

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

Terminal window
aggrega scaffold --example import-crewai

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

Terminal window
cd import-crewai

Le dossier source de l’exemple généré, ouvert dans Visual Studio Code, montrant la configuration des agents de la crew, avec un chercheur et un rédacteur.

Le projet

Un projet CrewAI conserve le comportement de sa crew dans un programme et déclare ses agents et ses tâches dans des fichiers de configuration. Celui-ci, écrit pour ce guide, suit la structure classique de CrewAI, et l’importation lit ses deux fichiers de déclaration, sous src/support_brief/config/. Le programme — le crew.py d’un projet classique, les outils qu’il définit — n’est jamais lu ; l’exemple ne contient donc que les déclarations.

agents.yaml déclare les deux agents, tous deux sur gpt-4o-mini d’OpenAI :

researcher:
role: >
Support plan researcher
goal: >
Find what each support plan of the company covers, and what it costs
backstory: >
You keep the company's support plans at your fingertips and answer from
them alone.
llm: openai/gpt-4o-mini
verbose: true
writer:
role: >
Support reply writer
goal: >
Turn the researcher's findings into a short, friendly reply to the customer
backstory: >
You write replies customers can act on, in plain words.
llm: openai/gpt-4o-mini

tasks.yaml attribue une tâche à chacun :

research_task:
description: >
Find the support plans that answer the customer's question: {question}
expected_output: >
The plans that apply, each with what it covers and what it costs
agent: researcher
reply_task:
description: >
Write a reply to the customer's question from the researcher's findings
expected_output: >
A reply of at most five sentences
agent: writer

À la racine du projet, un fichier .aggrega-config.yaml fait du dossier un espace de travail :

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside src/.
workspace: {}
# The registry the importer is fetched from the first time an import needs it.
default_registry: hub.aggrega.ai

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

Ce que demande l’importation

Les déclarations nomment le modèle de chaque agent, jamais l’image dans laquelle s’exécute le programme de la crew : cette image, vous la construisez à partir de votre projet. L’importation la demande donc, une fois pour chaque agent. Dans un terminal, elle pose une question pour chacun et écrit les réponses dans les brouillons et dans le fichier de réponses, import-answers.yaml, à l’intérieur du répertoire qu’elle importe, src/support_brief/, de sorte que l’importation suivante les lit à cet endroit et ne demande rien. Sans terminal — en intégration continue, ou à travers un pipe — elle ne demande rien : elle écrit le fichier avec les clés vides et s’arrête, en nommant le fichier. L’exemple contient déjà le fichier, avec les deux agents sur la même image, ghcr.io/example/support-brief:1.0.0, qui tient lieu de l’image que vous construisez :

# Values the import could not draft from the source, keyed by the drafted file and the key path inside
# it. Write each one beside its key; an import of the same source, and a sync, read them from here and
# ask nothing. A secret is never written here: its key asks where the secret comes from — a variable
# name, ${NAME}, or the name of a Kubernetes Secret.
release.yaml:
# Container image running the CrewAI application code.
spec.components.researcher.infra.image: "ghcr.io/example/support-brief: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.researcher.uses.model.gpt-4o-mini.features.credential.infra.origin: "openai-api-key"
# Container image running the CrewAI application code.
spec.components.writer.infra.image: "ghcr.io/example/support-brief: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.writer.uses.model.gpt-4o-mini.features.credential.infra.origin: "openai-api-key"

Les deux réponses origin servent à une construction pour Kubernetes, avec --target helm : chaque agent y lit la clé OpenAI depuis un Secret Kubernetes, et la réponse est le nom du Secret, openai-api-key, jamais la clé. Une construction pour Docker Compose lit plutôt la clé depuis votre shell, si bien que cette importation n’utilise pas ces réponses. Le fichier de réponses d’importation décrit le fichier, les questions et les règles applicables à la réponse pour un secret.

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

Placez-vous dans source :

Terminal window
cd source

Lancer l’importation

Indiquez le répertoire de la crew. L’importation lit les déclarations qu’il contient et rien d’autre :

Terminal window
aggrega import src/support_brief --target compose

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

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

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

[… omitted: a warning that the importer runs unverified, printed where its module is read from beside its Plugin entity in a catalog folder rather than fetched]
read as the crewai format, with drafted paths relative to <workspace>
info: the answers file <workspace>/src/support_brief/import-answers.yaml also answers spec.components.researcher.uses.model.gpt-4o-mini.features.credential.infra.origin in release.yaml, spec.components.writer.uses.model.gpt-4o-mini.features.credential.infra.origin in release.yaml, which these drafts do not leave empty; those answers are kept there and not applied
mapped researcher (agent) to core/ai-agent/crewai as a reference, NONE
mapped openai/gpt-4o-mini (llm) to core/ai-model/openai as a reference, NONE
mapped writer (agent) to core/ai-agent/crewai as a reference, NONE
made no choice for research_task (task)
made no choice for reply_task (task)
Pull complete: <workspace>/release.lock (entities=8, source_artifacts=0, external_inputs=0)

L’importation lancée depuis l’éditeur : l’Aggregate, la Release et le Manifest rédigés apparaissent à côté du projet de la crew, la sortie d’Aggrega liste la correspondance établie pour chaque agent, modèle et tâche ainsi que les fichiers écrits, et une notification indique que l’importation a rédigé 3 fichiers, reconnus comme crewai.

  • La ligne info nomme les réponses que les brouillons Docker Compose n’utilisent pas, conservées dans le fichier de réponses pour une construction pour Kubernetes.
  • Les lignes mapped indiquent que chaque agent est une instance de l’agent CrewAI de la bibliothèque standard, core/ai-agent/crewai, et que le modèle que les deux nomment, openai/gpt-4o-mini, est une instance de core/ai-model/openai. Leur niveau est NONE : l’importation CrewAI référence ces Components d’après ce que nomment les déclarations, un agent et un fournisseur de modèles, plutôt qu’en comparant chacun au catalogue.
  • Les lignes made no choice indiquent que rien n’est ébauché pour les tâches : une tâche est une logique qu’exécute le programme de la crew.
  • La ligne Pull complete correspond à l’import qui récupère ce dont dépend la Release rédigée, comme le fait aggrega pull, dans release.lock, de sorte que les brouillons se valident et se construisent immédiatement. Avec --offline, l’import ne récupère rien et indique la commande aggrega pull à exécuter.

Ce qu’elle écrit

L’Aggregate, la Release et le Manifest sont nommés imported/support-brief : les fichiers config/agents.yaml et config/tasks.yaml d’un projet ne nomment aucun crew — son nom se trouve dans le programme, que l’import ne lit pas —, si bien qu’un import de leur répertoire est nommé d’après ce répertoire, support_brief, écrit comme un segment de nom, sous le namespace que fixe le paramètre target_namespace de l’importeur, imported sauf si vous en fixez un autre (Paramètres).

aggregate.yaml — une instance par agent, chacune reliée au modèle qu’elle nomme, la clé qu’elle présente étant déclarée sur la connexion, et le modèle, avec en tête des commentaires qui indiquent ce qui a été lu et ce qui ne l’a pas été :

# CrewAI declarations read:
# - config/agents.yaml
# - config/tasks.yaml
# Not read: the crew's program, which runs its agents and its tasks and defines its tools; it runs in the image the Release names for each agent.
# Tasks the crew's program runs, drafted as no Component:
# - research_task, assigned to researcher
# - reply_task, assigned to writer
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/support-brief
version: 0.1.0
description: Draft Aggregate imported from a source in the crewai format.
spec:
components:
researcher:
type: core/ai-agent/crewai
values:
role: "Support plan researcher\u000A"
goal: "Find what each support plan of the company covers, and what it costs\u000A"
backstory: "You keep the company's support plans at your fingertips and answer from them alone.\u000A"
allow_delegation: false
log_level: DEBUG
uses:
model:
gpt-4o-mini:
target: gpt-4o-mini
# For the compose target, the lines below declare credential on gpt-4o-mini: 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
writer:
type: core/ai-agent/crewai
values:
role: "Support reply writer\u000A"
goal: "Turn the researcher's findings into a short, friendly reply to the customer\u000A"
backstory: "You write replies customers can act on, in plain words.\u000A"
allow_delegation: false
log_level: INFO
uses:
model:
gpt-4o-mini:
target: gpt-4o-mini
# For the compose target, the lines below declare credential on gpt-4o-mini: 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 model openai/gpt-4o-mini.
gpt-4o-mini:
type: core/ai-model/openai
values:
model: "gpt-4o-mini"

role, goal et backstory sont repris tels que déclarés, y compris le saut de ligne qui termine chaque bloc replié. log_level vaut DEBUG pour l’agent researcher, déclaré verbose, et INFO pour l’agent writer, qui ne l’est pas. Un agent qui ne déclare pas allow_delegation est ébauché avec false. Le modèle étant un service hébergé, le Component de l’agent refuse une connexion vers lui qui ne porte aucun identifiant ; chaque connexion en déclare un, sous la clé OPENAI_API_KEY.

release.yaml — l’environnement, l’image et le port publié de chaque agent, et la provenance de chaque clé :

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/support-brief
# 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 crewai format.
spec:
aggregate: imported/support-brief
manifest: imported/support-brief
components:
researcher:
infra:
# Left for the Release, since the source cannot supply it: infra.image, the container image running the crew's program
image: "ghcr.io/example/support-brief: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:
model:
gpt-4o-mini:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential researcher presents to gpt-4o-mini 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}"
writer:
infra:
# Left for the Release, since the source cannot supply it: infra.image, the container image running the crew's program
image: "ghcr.io/example/support-brief: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: 8001
uses:
model:
gpt-4o-mini:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential writer presents to gpt-4o-mini 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}"
gpt-4o-mini: {}

L’environnement, development, est une valeur par défaut que l’importation écrit parce qu’aucune déclaration n’en nomme un ; modifiez-le là où la Release est déployée ailleurs. Chaque image est la réponse que l’importation a lue dans import-answers.yaml. Chaque agent est publié sur l’adresse de bouclage de votre machine, avec renvoi vers le port sur lequel écoute son programme, infra.port, 8000 sauf si vous le définissez : le chercheur sur 8000 et le rédacteur sur 8001, car deux services d’une même Release ne peuvent pas publier le même port. Les déclarations ne nomment aucune variable pour la clé ; chaque connexion la lit donc depuis ${OPENAI_API_KEY}, la variable que lisent les bibliothèques clientes d’OpenAI, sous forme de référence de variable et jamais de valeur.

manifest.yaml — la Recipe Compose de chaque type, et la réalisation qui écrit telle quelle la référence de variable d’une clé dans le fichier Compose :

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/support-brief
version: 0.1.0
spec:
mappings:
components:
type:
core/ai-agent/crewai: compose/crewai
core/ai-model/openai: compose/openai
features:
type:
core/secret-value: compose/dotenv-secret

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

Valider et compiler

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

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

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

La validation affiche :

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
release dependency validation passed: release.yaml (schema-pillar + dependency pillars)

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

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
[… omitted: a total build time, which differs per run]
Build completed: 1 file written to <workspace>/dist

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

Le service du chercheur dans dist/compose/docker-compose.yaml ; celui du rédacteur ne diffère que par son nom, par les valeurs que portent ses propres variables et par le port qu’il publie :

services:
researcher:
image: ghcr.io/example/support-brief:1.0.0
environment:
OPENAI_BASE_URL: https://api.openai.com/v1
MODEL: gpt-4o-mini
CREWAI_ALLOW_DELEGATION: "false"
CREWAI_BACKSTORY: |
You keep the company's support plans at your fingertips and answer from them alone.
CREWAI_GOAL: |
Find what each support plan of the company covers, and what it costs
CREWAI_LOG_LEVEL: DEBUG
CREWAI_ROLE: |
Support plan researcher
OPENAI_API_KEY: ${OPENAI_API_KEY}
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

L’agent reçoit l’adresse du modèle et son nom sous la forme de OPENAI_BASE_URL et MODEL, les variables dans lesquelles CrewAI les lit, et la clé sous la forme de OPENAI_API_KEY. Son rôle, son objectif, son histoire, son interrupteur de délégation et son niveau de journalisation arrivent sous les noms que le Component CrewAI leur donne par défaut, pour que le programme de l’équipe les lise ; un bloc inject: sur le composant lui-même livre plutôt n’importe lequel d’entre eux sous le nom que lit le programme. Chaque valeur rédigée par l’import conserve le saut de ligne par lequel se terminait sa déclaration, si bien que le fichier l’écrit sous forme de bloc. Le modèle n’obtient aucun service propre : les agents atteignent l’API OpenAI à sa propre adresse. La clé est une référence de variable, renseignée depuis votre shell au démarrage de la stack. Chaque service ne publie son port que sur 127.0.0.1 : le 8000 du chercheur et le 8001 du rédacteur, chacun renvoyant vers le port 8000 du programme dans son conteneur.

Avec un assistant IA

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

Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier du Workspace ne contient pas encore de dossier `import-crewai`, appelez une fois l’outil `scaffold` avec `example` défini sur `import-crewai` et sans `dir` : il écrit l’exemple dans un nouveau dossier `import-crewai`, dont le dossier `source` contient ce que cette page importe. Appelez ensuite l’outil `import` avec `workspace_root` défini sur `import-crewai/source`, `source` défini sur `src/support_brief` et `target` défini sur `compose` : il lit les réponses dont il a besoin dans `import-answers.yaml`, à l’intérieur du dossier `src/support_brief`, écrit ses brouillons dans `import-crewai/source` et récupère ce dont ils ont besoin. Appelez ensuite l’outil `validate` avec `workspace_root` défini sur `import-crewai/source` et `release` défini sur `release.yaml`, puis l’outil `build` avec `workspace_root` défini sur `import-crewai/source`, `release` défini sur `release.yaml` et `write` défini sur true. Indiquez-moi quels fichiers le build a écrits ; ils se trouvent sous `import-crewai/source/dist/`.

L’ouvrir dans VS Code

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

Exécution

Vous construisez l’image à partir du projet, avec votre propre Dockerfile. Docker Compose exécute la commande propre à l’image comme service de chaque agent, puisque la Recipe n’en définit aucune ; cette commande doit donc continuer à tourner, et doit servir des requêtes si vous voulez atteindre la crew. Votre programme décide de l’adresse, de la route et de la réponse.

L’exécution ci-dessous a utilisé une telle image : le programme de la crew dans la disposition classique de CrewAI — un crew.py qui construit la crew à partir des deux fichiers de déclaration, tels que l’importation les a lus — et, comme commande de l’image, un petit serveur HTTP propre au programme sur le port 8000, qui exécute la crew une fois pour chaque POST /kickoff. Construisez votre image à la racine du projet, écrivez son nom à la place de ghcr.io/example/support-brief:1.0.0 pour les deux agents dans src/support_brief/import-answers.yaml, et importez de nouveau avec --sync, qui écrit les nouvelles réponses dans les ébauches et refait le pull ; puis lancez le build :

Terminal window
docker build -t support-brief:local .
aggrega import src/support_brief --sync
aggrega build --release release.yaml

Avec support-brief:local comme réponse aux deux, la synchronisation nomme, parmi les lignes qu’elle affiche, les deux valeurs qu’elle a modifiées :

changed spec.components.researcher.infra.image in release.yaml
changed spec.components.writer.infra.image in release.yaml

Définissez ensuite la clé dans votre shell et démarrez la pile :

Terminal window
export OPENAI_API_KEY='your OpenAI key'
docker compose -p support-brief -f dist/compose/docker-compose.yaml up -d --wait

-p nomme le projet, comme l’explique l’étape d’exécution de Déroulement d’une importation.

Tester

La requête ci-dessous atteint le programme qu’exécute l’image de ce guide : la crew derrière un petit serveur HTTP sur le port 8000, qui répond à POST /kickoff. Votre propre programme décide de sa propre route et de sa réponse. Envoyez-la au chercheur à http://127.0.0.1:8000, l’adresse que publie published_port, une fois que le programme écoute, quelques secondes après le démarrage de la pile :

Terminal window
curl -sS -X POST http://127.0.0.1:8000/kickoff -H 'Content-Type: application/json' \
-d '{"question": "Which support plan covers a weekend outage, and what does it cost?"}'
{
"error": "the crew failed: AuthenticationError: Error code: 401 - {'error': {'message': 'Incorrect API key provided: sk-place************-key. [… omitted: where to find an API key, and the error's type and code]"
}

L’exécution a défini OPENAI_API_KEY sur une valeur fictive, la réponse est donc le refus d’OpenAI, transmis par le programme. La requête de la crew a atteint l’API d’OpenAI avec la clé que la construction a fournie. Les deux agents exécutent la même image, la requête pouvait donc aller à l’un ou à l’autre : le rédacteur répond de la même façon à http://127.0.0.1:8001.

Arrêtez la pile avec :

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

Sur Kubernetes, importez avec --target helm et poussez l’image vers un registre depuis lequel votre cluster tire les images, en l’indiquant dans src/support_brief/import-answers.yaml. Créez ensuite le Secret openai-api-key et appliquez la construction, comme le décrit l’étape d’exécution de Déroulement d’une importation. Le Deployment de chaque agent n’a pas de Service, redirigez donc un port local vers celui du researcher. La commande s’exécute jusqu’à ce que vous l’arrêtiez :

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

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

Terminal window
curl -sS -X POST http://127.0.0.1:8000/kickoff -H 'Content-Type: application/json' \
-d '{"question": "Which support plan covers a weekend outage, and what does it cost?"}'
{
"error": "the crew failed: AuthenticationError: Error code: 401 - {'error': {'message': 'Incorrect API key provided: sk-place************-key. [… omitted: where to find an API key, and the error's type and code]"
}