Agent de Strands Python

Générer un agent Strands Agent en Python pour créer des agents IA avec des outils, et optionnellement le déployer sur Amazon Bedrock AgentCore Runtime. Par défaut, le générateur utilise FastAPI pour exposer un serveur HTTP. Alternativement, vous pouvez choisir le protocole Agent-to-Agent (A2A) pour l’interopérabilité avec d’autres agents compatibles A2A, ou le protocole AG-UI pour une intégration frontend directe via CopilotKit.

Qu’est-ce que Strands ?

Strands est un framework Python léger et prêt pour la production permettant de créer des agents IA. Principales fonctionnalités :

• Léger et personnalisable : Boucle d’agent simple qui reste discrète
• Prêt pour la production : Observabilité complète, traçage et options de déploiement évolutives
• Agnostique aux modèles et fournisseurs : Supporte de nombreux modèles de différents fournisseurs
• Outils communautaires : Ensemble puissant d’outils contribués par la communauté
• Support multi-agents : Techniques avancées comme les équipes d’agents et agents autonomes
• Modes d’interaction flexibles : Support conversationnel, streaming et non-streaming

Utilisation

Générer un agent Strands

Vous pouvez générer un agent Strands en Python de deux manières :

VSCode

1. Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
2. Ouvrez la console Nx dans VSCode
3. Cliquez sur Generate (UI) dans la section "Common Nx Commands"
4. Recherchez @aws/nx-plugin - py#strands-agent
5. Remplissez les paramètres requis
6. Cliquez sur Generate

CLI

pnpm

pnpm nx g @aws/nx-plugin:py#strands-agent

yarn

yarn nx g @aws/nx-plugin:py#strands-agent

npm

npx nx g @aws/nx-plugin:py#strands-agent

bun

bunx nx g @aws/nx-plugin:py#strands-agent

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm

pnpm nx g @aws/nx-plugin:py#strands-agent --dry-run

yarn

yarn nx g @aws/nx-plugin:py#strands-agent --dry-run

npm

npx nx g @aws/nx-plugin:py#strands-agent --dry-run

bun

bunx nx g @aws/nx-plugin:py#strands-agent --dry-run

Prérequis du projet

Utilisez d’abord le générateur py#project pour créer un projet auquel ajouter votre agent Strands.

Options

Paramètre	Type	Par défaut	Description
project Requis	string	-	Le projet auquel ajouter l'Agent Strands
computeType	string	BedrockAgentCoreRuntime	Le type de calcul pour héberger votre Agent Strands.
name	string	-	Le nom de votre Agent Strands (par défaut : agent)
auth	string	IAM	La méthode utilisée pour s'authentifier auprès de votre Strands Agent. Choisissez entre IAM (par défaut) ou Cognito.
protocol	string	HTTP	Le protocole serveur pour votre Strands Agent. HTTP expose un serveur HTTP FastAPI. A2A expose un serveur de protocole Agent-to-Agent. AG-UI expose un serveur de protocole Agent-User Interaction pour l'intégration directe avec le frontend.
iacProvider	string	Inherit	Le fournisseur IaC préféré. Par défaut, celui-ci est hérité de votre sélection initiale.

Résultat du générateur

Le générateur ajoutera les fichiers suivants à votre projet Python existant. Les fichiers générés dépendent du protocol choisi :

Protocole HTTP (par défaut)

• Répertoireyour-project/

  • Répertoireyour_module/

    • Répertoireagent/ (ou nom personnalisé si spécifié)

      • __init__.py Initialisation du package Python
      • init.py Configuration de l’application FastAPI avec middleware CORS et gestion des erreurs
      • agent.py Définition principale de l’agent avec des outils exemples
      • main.py Point d’entrée FastAPI pour Bedrock AgentCore Runtime
      • Dockerfile Point d’entrée pour héberger votre agent (exclu si computeType est None)
  • pyproject.toml Mis à jour avec les dépendances Strands
  • project.json Mis à jour avec les cibles de service de l’agent

Protocole A2A

Lorsque protocol est défini sur A2A, le point d’entrée utilise le Strands A2A Server au lieu de FastAPI :

• Répertoireyour-project/

  • Répertoireyour_module/

    • Répertoireagent/ (ou nom personnalisé si spécifié)

      • __init__.py Initialisation du package Python
      • agent.py Définition principale de l’agent avec des outils exemples
      • main.py Point d’entrée du serveur A2A
      • Dockerfile Point d’entrée pour héberger votre agent (exclu si computeType est None)
  • pyproject.toml Mis à jour avec les dépendances Strands
  • project.json Mis à jour avec les cibles de service de l’agent

Protocole AG-UI

Lorsque protocol est défini sur AG-UI, le point d’entrée utilise l’intégration ag-ui-strands, qui expose votre agent via le protocole AG-UI pour une intégration frontend directe avec CopilotKit :

• Répertoireyour-project/

  • Répertoireyour_module/

    • Répertoireagent/ (ou nom personnalisé si spécifié)

      • __init__.py Initialisation du package Python
      • agent.py Définition principale de l’agent avec des outils exemples
      • main.py Point d’entrée du serveur AG-UI utilisant ag-ui-strands
      • Dockerfile Point d’entrée pour héberger votre agent (exclu si computeType est None)
  • pyproject.toml Mis à jour avec les dépendances Strands et AG-UI
  • project.json Mis à jour avec les cibles de service de l’agent

Connexion à un site web React

Les agents AG-UI peuvent être connectés à un frontend React en utilisant le générateur connection, qui configurera les composants CopilotKit pour une expérience de chat enrichie.

Infrastructure

Déploiement serverless

Si vous avez sélectionné None pour computeType, le générateur ne générera pas d’infrastructure as code.

Ce générateur fournit de l’infrastructure as code basée sur votre iacProvider choisi. Il créera un projet dans packages/common qui inclut les constructions CDK ou modules Terraform pertinents.

Le projet commun d’infrastructure as code est structuré comme suit :

CDK

• Répertoirepackages/common/constructs

  • Répertoiresrc

    • Répertoireapp/ Constructions pour l’infrastructure spécifique à un projet/générateur

      • …
    • Répertoirecore/ Constructions génériques réutilisées par celles dans app

      • …
    • index.ts Point d’entrée exportant les constructions depuis app
  • project.json Cibles de build et configuration du projet

Projet généré

Ce projet est généré avec le générateur ts#project et configure donc les mêmes cibles de build.

Terraform

• Répertoirepackages/common/terraform

  • Répertoiresrc

    • Répertoireapp/ Modules Terraform pour l’infrastructure spécifique à un projet/générateur

      • …
    • Répertoirecore/ Modules génériques réutilisés par ceux dans app

      • …
  • project.json Cibles de build et configuration du projet

Projet généré

Ce projet est généré avec le générateur terraform#project et configure donc les mêmes cibles de build.

Pour le déploiement de votre agent Strands, les fichiers suivants sont générés :

CDK

• Répertoirepackages/common/constructs/src

  • Répertoireapp

    • Répertoireagents

      • Répertoire<project-name>

        • <project-name>.ts Construct CDK pour déployer votre agent

Terraform

• Répertoirepackages/common/terraform/src

  • Répertoireapp

    • Répertoireagents

      • Répertoire<project-name>

        • <project-name>.tf Module pour déployer votre agent
  • Répertoirecore

    • Répertoireagent-core

      • runtime.tf Module générique pour le déploiement sur Bedrock AgentCore Runtime

Utilisation de votre agent Strands

Ajout d’outils

Les outils sont des fonctions que l’agent IA peut appeler pour effectuer des actions. Le framework Strands utilise une approche basée sur des décorateurs pour définir les outils.

Vous pouvez ajouter de nouveaux outils dans le fichier agent.py :

from strands import Agent, tool

@tool
def calculate_sum(numbers: list[int]) -> int:
    """Calcule la somme d'une liste de nombres"""
    return sum(numbers)

@tool
def get_weather(city: str) -> str:
    """Obtient les informations météo d'une ville"""
    # Votre intégration d'API météo ici
    return f"Weather in {city}: Sunny, 25°C"

# Ajoutez les outils à votre agent
agent = Agent(
    system_prompt="You are a helpful assistant with access to various tools.",
    tools=[calculate_sum, get_weather],
)

Le framework Strands gère automatiquement :

• La validation des types via les annotations de type
• La génération de schémas JSON pour l’appel d’outils
• La gestion des erreurs et le formatage des réponses

Utilisation d’outils pré-définis

Strands fournit une collection d’outils prêts à l’emploi via le package strands-tools :

from strands_tools import current_time, http_request, file_read

agent = Agent(
    system_prompt="You are a helpful assistant.",
    tools=[current_time, http_request, file_read],
)

Configuration du modèle

Par défaut, les agents Strands utilisent Claude 4 Sonnet, mais vous pouvez personnaliser le fournisseur de modèle. Consultez la documentation Strands sur les fournisseurs de modèles pour les options de configuration :

from strands import Agent
from strands.models import BedrockModel

# Créez un BedrockModel
bedrock_model = BedrockModel(
    model_id="anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-west-2",
    temperature=0.3,
)

agent = Agent(model=bedrock_model)

Utilisation des serveurs MCP

Vous pouvez ajouter des outils depuis des serveurs MCP à votre agent Strands.

Pour utiliser des serveurs MCP créés avec les générateurs py#mcp-server ou ts#mcp-server, vous pouvez utiliser le générateur connection.

VSCode

1. Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
2. Ouvrez la console Nx dans VSCode
3. Cliquez sur Generate (UI) dans la section "Common Nx Commands"
4. Recherchez @aws/nx-plugin - connection
5. Remplissez les paramètres requis
6. Cliquez sur Generate

CLI

pnpm

pnpm nx g @aws/nx-plugin:connection

yarn

yarn nx g @aws/nx-plugin:connection

npm

npx nx g @aws/nx-plugin:connection

bun

bunx nx g @aws/nx-plugin:connection

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm

pnpm nx g @aws/nx-plugin:connection --dry-run

yarn

yarn nx g @aws/nx-plugin:connection --dry-run

npm

npx nx g @aws/nx-plugin:connection --dry-run

bun

bunx nx g @aws/nx-plugin:connection --dry-run

Consultez le guide du générateur connection pour plus de détails sur la configuration de la connexion.

Pour d’autres serveurs MCP, veuillez consulter la documentation Strands.

Pour aller plus loin

Pour un guide plus détaillé sur l’écriture d’agents Strands, consultez la documentation Strands.

Protocole

Le protocole serveur de votre agent détermine comment il communique. Toutes les options sont servies par FastAPI — le point d’entrée diffère :

• HTTP (par défaut) : Un serveur FastAPI standard avec un point de terminaison /invocations personnalisé, CORS et streaming. Idéal pour les intégrations client personnalisées.
• A2A : Le Strands A2A Server monté sur une application FastAPI. Idéal lorsque votre agent doit être découvrable et invocable par d’autres agents compatibles A2A.
• AG-UI : L’intégration ag-ui-strands, qui expose le protocole AG-UI via SSE. Idéal pour une intégration frontend directe avec CopilotKit dans un site web React.

Tous les protocoles exposent /ping pour le contrat de vérification de santé du runtime AgentCore. Les agents A2A écoutent sur le port 9000 ; les agents HTTP et AG-UI écoutent sur le port 8080. Le Dockerfile et l’infrastructure générés sont configurés pour vous.

Serveur FastAPI (protocole HTTP)

Le serveur HTTP généré inclut :

• Configuration de l’application FastAPI avec middleware CORS
• Middleware de gestion des erreurs
• Génération du schéma OpenAPI
• Point de terminaison de vérification de santé (/ping)
• Point de terminaison d’invocation de l’agent (/invocations)

Personnalisation des entrées et sorties d’invocation avec Pydantic

Le point de terminaison d’invocation de l’agent utilise des modèles Pydantic pour définir et valider les schémas de requête et de réponse. Vous pouvez personnaliser ces modèles dans main.py pour correspondre aux besoins de votre agent.

Définition des modèles d’entrée

Le modèle InvokeInput par défaut accepte un message.

from pydantic import BaseModel

class InvokeInput(BaseModel):
    message: str

Vous pouvez étendre ce modèle pour inclure tous les champs supplémentaires dont votre agent a besoin.

L’ID de session est extrait de l’en-tête HTTP x-amzn-bedrock-agentcore-runtime-session-id, conformément au contrat de session Bedrock AgentCore Runtime. Si l’en-tête n’est pas fourni, un UUID aléatoire est généré par défaut.

Organisation du code

Vous voudrez probablement abstraire tout ou partie de l’ID de session de l’appelant si les utilisateurs doivent invoquer votre agent directement. Par exemple, vous pouvez utiliser l’ID utilisateur authentifié comme partie de l’ID de session.

Il est également à noter que selon votre cas d’usage, vous devrez peut-être implémenter une autorisation pour les sessions, par exemple en vous assurant que les utilisateurs ne peuvent accéder qu’à leurs propres sessions et non à celles d’autres utilisateurs.

Définition des modèles de sortie

Pour les réponses en streaming, le générateur fournit JsonStreamingResponse qui sérialise automatiquement les modèles Pydantic au format JSON Lines (application/jsonl). Ce format est compatible avec la spécification de streaming d’OpenAPI 3.2 et fonctionne parfaitement avec le client TypeScript généré.

Par défaut, l’agent génère des objets StreamChunk contenant le texte de réponse de l’agent :

class StreamChunk(BaseModel):
    content: str

Vous pouvez personnaliser le modèle StreamChunk selon vos besoins :

from pydantic import BaseModel

class StreamChunk(BaseModel):
    content: str
    timestamp: str
    token_count: int

Limitation de streaming FastAPI

Notez que puisque FastAPI ne supporte pas actuellement la génération d’une spécification OpenAPI pour les réponses en streaming, nous devons explicitement définir le modèle de réponse pour chaque opération de streaming, c’est-à-dire :

@app.post(
    "/invocations",
    response_class=JsonStreamingResponse,
    responses={200: JsonStreamingResponse.openapi_response(StreamChunk)},
)
async def invoke(input: InvokeInput) -> JsonStreamingResponse:
    return JsonStreamingResponse(handle_invoke(input))

Il existe une demande de fonctionnalité ouverte pour un support natif dans FastAPI.

SDK Python Bedrock AgentCore

Le générateur inclut une dépendance au SDK Python Bedrock AgentCore pour les constantes PingStatus. Si vous le souhaitez, il est simple d’utiliser BedrockAgentCoreApp au lieu de FastAPI, mais notez que la sécurité des types est perdue.

Vous trouverez plus de détails sur les capacités du SDK dans la documentation ici.

Infrastructure as Code

Le générateur fournissant une infrastructure CDK ou Terraform pour déployer votre agent, vous n’avez pas besoin d’utiliser le bedrock-agentcore-starter-toolkit mentionné dans la documentation.

Serveur A2A (protocole A2A)

Lorsque protocol=A2A, le fichier main.py généré monte A2AServer.to_fastapi_app() sur une application FastAPI parente qui expose également /ping. Lorsqu’il est déployé sur AgentCore, le point d’entrée résout l’ARN public du runtime depuis AppConfig et l’annonce dans la carte d’agent.

La plupart des utilisateurs n’auront pas besoin de modifier ce fichier — éditez agent.py pour changer les outils ou le prompt système. Le serveur A2A remplit la carte d’agent (/.well-known/agent-card.json) à partir du name et de la description du constructeur Agent.

Serveur AG-UI (protocole AG-UI)

Lorsque protocol=AG-UI, le fichier main.py généré enveloppe votre Agent Strands dans un ag_ui_strands.StrandsAgent et crée une application FastAPI via create_strands_app(). L’application résultante expose un seul point de terminaison POST qui diffuse des événements AG-UI via Server-Sent Events (SSE), ainsi que /ping pour la vérification de santé du runtime AgentCore.

La plupart des utilisateurs n’auront pas besoin de modifier ce fichier — éditez agent.py pour changer les outils ou le prompt système.

Connexion à un site web React

Les agents AG-UI sont conçus pour être consommés directement par un frontend. Utilisez le générateur connection pour connecter votre site web React à l’agent avec un fournisseur CopilotKit et un client AG-UI HttpAgent.

Exécution de votre agent Strands

Développement local

Le générateur configure une cible nommée <your-agent-name>-serve qui démarre votre agent Strands localement pour le développement et les tests.

pnpm

pnpm nx agent-serve your-project

yarn

yarn nx agent-serve your-project

npm

npx nx agent-serve your-project

bun

bunx nx agent-serve your-project

Cette commande utilise uv run pour exécuter votre agent Strands via le SDK Python Bedrock AgentCore.

Déploiement de votre agent Strands sur Bedrock AgentCore Runtime

Infrastructure as Code

Si vous avez sélectionné BedrockAgentCoreRuntime pour computeType, l’infrastructure CDK ou Terraform correspondante est générée, que vous pouvez utiliser pour déployer votre Strands Agent sur Amazon Bedrock AgentCore Runtime.

CDK

Un construct CDK est généré pour votre agent, nommé en fonction du name que vous avez choisi lors de l’exécution du générateur, ou <ProjectName>Agent par défaut.

Vous pouvez utiliser ce construct CDK dans une application CDK :

import { MyProjectAgent } from ':my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    new MyProjectAgent(this, 'MyProjectAgent');
  }
}

Construct CDK Alpha

Ce construct utilise le module @aws-cdk/aws-bedrock-agentcore-alpha.

Terraform

Un module Terraform est généré pour vous, nommé en fonction du name que vous avez choisi lors de l’exécution du générateur, ou <ProjectName>-agent par défaut.

Vous pouvez utiliser ce module terraform dans un projet Terraform :

# Agent
module "my_project_agent" {
  # Relative path to the generated module in the common/terraform project
  source = "../../common/terraform/src/app/agents/my-project-agent"
}

Permissions des modèles Bedrock

Le construct d’agent généré accorde par défaut la permission d’invoquer tous les modèles de fondation et profils d’inférence Bedrock (bedrock:InvokeModel et bedrock:InvokeModelWithResponseStream sur arn:aws:bedrock:*:*:foundation-model/* et arn:aws:bedrock:*:*:inference-profile/*).

Vous pouvez souhaiter restreindre cela aux modèle(s) spécifiques utilisés par votre agent. Vous pouvez trouver le modèle par défaut utilisé par les agents Strands dans la documentation Strands ; consultez le guide des fournisseurs de modèles Strands pour configurer un modèle différent.

Docker requis

Docker est requis pour construire et déployer votre Strands Agent. Assurez-vous d’avoir installé et lancé Docker pour éviter des erreurs telles que :

ERROR: Cannot connect to the Docker daemon at unix://path/to/docker.sock.

Authentification

Le générateur fournit une option auth pour configurer l’authentification de votre Strands Agent. Vous pouvez choisir entre l’authentification IAM (par défaut) ou Cognito lors de la génération de votre agent.

IAM

Par défaut, votre Strands Agent sera sécurisé à l’aide de l’authentification IAM, déployez-le simplement sans aucun argument :

CDK

import { MyProjectAgent } from ':my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    new MyProjectAgent(this, 'MyProjectAgent');
  }
}

Vous pouvez accorder l’accès pour invoquer votre agent sur Bedrock AgentCore Runtime en utilisant la méthode grantInvokeAccess, par exemple :

import { MyProjectAgent } from ':my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    const agent = new MyProjectAgent(this, 'MyProjectAgent');
    const lambdaFunction = new Function(this, ...);

    agent.grantInvokeAccess(lambdaFunction);
  }
}

Terraform

# Agent
module "my_project_agent" {
  # Relative path to the generated module in the common/terraform project
  source = "../../common/terraform/src/app/agents/my-project-agent"
}

Pour accorder l’accès pour invoquer votre agent, vous devrez ajouter une politique telle que la suivante, en référençant la sortie module.my_project_agent.agent_core_runtime_arn :

{
  Effect = "Allow"
  Action = [
    "bedrock-agentcore:InvokeAgentRuntime"
  ]
  Resource = [
    module.my_project_agent.agent_core_runtime_arn,
    "${module.my_project_agent.agent_core_runtime_arn}/*"
  ]
}

Authentification Cognito

Lorsque vous sélectionnez l’authentification Cognito, le générateur configure l’agent pour utiliser Cognito pour l’authentification.

CDK

Le construct généré accepte une prop identity qui configure l’authentification Cognito :

import { MyProjectAgent, UserIdentity } from ':my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    const identity = new UserIdentity(this, 'Identity');

    new MyProjectAgent(this, 'MyProjectAgent', {
      identity,
    });
  }
}

Le construct UserIdentity peut être généré en utilisant le générateur ts#react-website#auth, ou vous pouvez créer votre propre UserPool et UserPoolClient CDK.

Terraform

Le module généré accepte les variables user_pool_id et user_pool_client_ids pour l’authentification Cognito :

module "user_identity" {
  source = "../../common/terraform/src/core/user-identity"
}

module "my_project_agent" {
  source = "../../common/terraform/src/app/agents/my-project-agent"

  user_pool_id         = module.user_identity.user_pool_id
  user_pool_client_ids = [module.user_identity.user_pool_client_id]
}

Fournisseurs OIDC personnalisés

Si vous avez besoin d’une authentification JWT personnalisée avec un fournisseur OIDC non-Cognito, vous pouvez modifier directement le construct CDK ou le module Terraform généré pour votre agent. Notez que le générateur de connexion ne prendra en charge que l’authentification IAM ou Cognito.

Cibles Bundle et Docker

Pour construire votre agent Strands pour Bedrock AgentCore Runtime, une cible bundle est ajoutée à votre projet, qui :

• Exporte vos dépendances Python dans un fichier requirements.txt via uv export
• Installe les dépendances pour la plateforme cible (aarch64-manylinux_2_28) via uv pip install

Une cible docker spécifique à votre agent Strands est également ajoutée, qui copie le Dockerfile et les artefacts bundlés dans un répertoire de contexte Docker. Cela co-localise le Dockerfile avec la sortie construite, permettant à CDK de construire l’image Docker directement en utilisant AgentRuntimeArtifact.fromAsset.

Observabilité

Votre agent est automatiquement configuré avec l’observabilité via AWS Distro for Open Telemetry (ADOT), via l’auto-instrumentation dans votre Dockerfile.

Vous pouvez trouver les traces dans la console CloudWatch en sélectionnant “GenAI Observability” dans le menu. Notez que pour voir les traces, vous devez activer Transaction Search.

Pour plus de détails, consultez la documentation AgentCore sur l’observabilité.

Invocation de votre agent Strands

Invoquer le serveur local

Pour invoquer un agent exécuté localement via la cible <your-agent-name>-serve, vous pouvez envoyer une simple requête POST à /invocations sur le port où votre agent local s’exécute. Par exemple, avec curl :

curl -N -X POST http://localhost:8081/invocations \
  -d '{"message": "what is 3 + 5?"}' \
  -H "Content-Type: application/json"

Flag de streaming Curl

L’argument -N donné à curl désactive la mise en mémoire tampon du flux de sortie, vous permettant de voir la réponse en streaming en temps réel.

Invoquer l’agent déployé

Pour invoquer votre Agent déployé sur Bedrock AgentCore Runtime, vous pouvez envoyer une requête POST au point de terminaison du plan de données Bedrock AgentCore Runtime avec votre ARN d’exécution encodé en URL.

Vous pouvez obtenir l’ARN d’exécution depuis votre infrastructure comme suit :

CDK

import { CfnOutput } from 'aws-cdk-lib';
import { MyProjectAgent } from ':my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    const agent = new MyProjectAgent(this, 'MyProjectAgent');

    new CfnOutput(this, 'AgentArn', {
      value: agent.agentCoreRuntime.agentRuntimeArn,
    });
  }
}

Terraform

# Agent
module "my_project_agent" {
  # Relative path to the generated module in the common/terraform project
  source = "../../common/terraform/src/app/agents/my-project-agent"
}

output "agent_arn" {
  value = module.my_project_agent.agent_core_runtime_arn
}

L’ARN aura le format suivant : arn:aws:bedrock-agentcore:<region>:<account>:runtime/<agent-runtime-id>.

Vous pouvez ensuite encoder l’ARN en URL en remplaçant : par %3A et / par %2F.

Console du navigateur

Ceci est simple dans une console de navigateur ou un REPL Node en utilisant la méthode intégrée encodeURIComponent :

encodeURIComponent('arn:aws:bedrock-agentcore:<region>:<account>:runtime/<agent-runtime-id>')

L’URL du plan de données Bedrock AgentCore Runtime pour invoquer l’agent est la suivante :

https://bedrock-agentcore.<region>.amazonaws.com/runtimes/<url-encoded-arn>/invocations

La manière exacte d’invoquer cette URL dépend de la méthode d’authentification utilisée.

Authentification IAM

Pour l’authentification IAM, la requête doit être signée avec AWS Signature Version 4 (SigV4).

acurl <region> bedrock-agentcore -N -X POST \
'https://bedrock-agentcore.<region>.amazonaws.com/runtimes/<url-encoded-arn>/invocations' \
-d '{"message": "what is 3 + 5?"}' \
-H 'Content-Type: application/json'

Cliquez ici pour plus de détails sur la configuration de la commande acurl ci-dessus

Authentification JWT / Cognito

Pour l’authentification Cognito, passez le jeton d’accès Cognito dans l’en-tête Authorization :

curl -N -X POST 'https://bedrock-agentcore.<region>.amazonaws.com/runtimes/<url-encoded-arn>/invocations' \
  -d '{"message": "what is 3 + 5?"}' \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access-token>"

Vous pouvez obtenir le jeton d’accès en utilisant la commande cognito-idp admin-initiate-auth de l’AWS CLI, par exemple :

aws cognito-idp admin-initiate-auth \
  --user-pool-id <user-pool-id> \
  --client-id <user-pool-client-id> \
  --auth-flow ADMIN_NO_SRP_AUTH \
  --auth-parameters USERNAME=<username>,PASSWORD=<password> \
  --region <region> \
  --query 'AuthenticationResult.AccessToken' \
  --output text

Navigateur / Site web React

Pour invoquer votre agent Strands depuis un site web React, vous pouvez utiliser le générateur connection, qui configure automatiquement un client avec l’authentification appropriée (IAM ou Cognito).

VSCode

1. Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
2. Ouvrez la console Nx dans VSCode
3. Cliquez sur Generate (UI) dans la section "Common Nx Commands"
4. Recherchez @aws/nx-plugin - connection
5. Remplissez les paramètres requis
6. Cliquez sur Generate

CLI

pnpm

pnpm nx g @aws/nx-plugin:connection

yarn

yarn nx g @aws/nx-plugin:connection

npm

npx nx g @aws/nx-plugin:connection

bun

bunx nx g @aws/nx-plugin:connection

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm

pnpm nx g @aws/nx-plugin:connection --dry-run

yarn

yarn nx g @aws/nx-plugin:connection --dry-run

npm

npx nx g @aws/nx-plugin:connection --dry-run

bun

bunx nx g @aws/nx-plugin:connection --dry-run

Consultez le guide du générateur connection pour plus de détails sur la configuration de la connexion.

Invocation d’un agent A2A en tant qu’outil

Pour déléguer du travail de cet agent vers un agent A2A distant (soit TypeScript soit Python), utilisez le générateur connection. Il fournit un client authentifié SigV4 pour l’agent cible et transforme le agent.py de cet agent par AST pour enregistrer l’agent A2A distant en tant que délégué décoré avec @tool.

VSCode

1. Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
2. Ouvrez la console Nx dans VSCode
3. Cliquez sur Generate (UI) dans la section "Common Nx Commands"
4. Recherchez @aws/nx-plugin - connection
5. Remplissez les paramètres requis
6. Cliquez sur Generate

CLI

pnpm

pnpm nx g @aws/nx-plugin:connection

yarn

yarn nx g @aws/nx-plugin:connection

npm

npx nx g @aws/nx-plugin:connection

bun

bunx nx g @aws/nx-plugin:connection

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm

pnpm nx g @aws/nx-plugin:connection --dry-run

yarn

yarn nx g @aws/nx-plugin:connection --dry-run

npm

npx nx g @aws/nx-plugin:connection --dry-run

bun

bunx nx g @aws/nx-plugin:connection --dry-run

Consultez le guide du générateur connection pour plus de détails sur la configuration de la connexion.