> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Bedrock Agents

> Tracez les invocations d’Amazon Bedrock Agents avec Weave en capturant les entrées de l’agent, l’utilisation du modèle de fondation et la sortie générée.

[Amazon Bedrock Agents](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) vous permet de créer sur AWS des agents d’IA managés qui orchestrent des modèles de fondation, des bases de connaissances et des groupes d’actions. Weave trace les appels au client `bedrock-agent-runtime`, ce qui vous permet d’inspecter chaque invocation de `invoke_agent`, notamment le modèle de fondation, l’utilisation des jetons, l’ID de session et la réponse de l’agent.

<Note>
  Le SDK TypeScript de Weave ne prend pas encore en charge l’intégration Bedrock Agents.
</Note>

<h2 id="prerequisites">
  Prérequis
</h2>

* Une clé API W\&B. Pour plus d'informations, voir [Clés API](/fr/products/wandb/platform/app/settings-page/user-settings#api-keys).
* Des identifiants d’authentification AWS configurés pour un compte ayant accès à Bedrock Agents (voir [Identity and access management for Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)).
* Un agent Bedrock existant et son alias. Notez les valeurs `agentId` et `agentAliasId`. Pour obtenir la liste des agents associés à votre ID, exécutez la commande AWS CLI suivante en remplaçant `<your-region>` par l’identifiant de la région où se trouve votre agent :

  ```bash theme={"system"}
  aws bedrock-agent list-agents --region us-east-1
  ```

<h2 id="installation">
  Installation
</h2>

Installez Weave et le SDK AWS pour Python :

```bash theme={"system"}
pip install weave boto3
```

<h2 id="trace-invoke_agent-calls">
  Tracer les appels `invoke_agent`
</h2>

Créez un client `bedrock-agent-runtime` et transmettez-le à `patch_client`. Weave détecte le type de client et encapsule la méthode `invoke_agent`. Une fois le patching appliqué, utilisez le client comme d’habitude.

```python lines highlight="15-17" theme={"system"}
import boto3

import weave
from weave.integrations.bedrock import patch_client

weave.init("your-team-name/bedrock-agents-demo")

# Créer le client runtime Bedrock Agents et lui appliquer le patch.
bedrock_agent_client = boto3.client("bedrock-agent-runtime", region_name="us-east-1")
patch_client(bedrock_agent_client)

# Invoquer l’agent. Définir `enableTrace=True` pour que Weave puisse capturer le modèle
# de fondation sous-jacent et l’utilisation des jetons à partir des événements de trace d’orchestration.
response = bedrock_agent_client.invoke_agent(
    agentId="[YOUR-AGENT-ID]",
    agentAliasId="[YOUR-AGENT-ALIAS-ID]",
    sessionId="[YOUR-SESSION-ID]",
    inputText="What is the capital of France?",
    enableTrace=True,
)

# Consommer la complétion diffusée en streaming pour reconstituer le texte final de la réponse.
final_text = ""
for event in response["completion"]:
    chunk = event.get("chunk")
    if chunk and "bytes" in chunk:
        final_text += chunk["bytes"].decode("utf-8")

print(final_text)
```

Chaque appel `invoke_agent` apparaît dans l’interface Weights & Biases sous la forme d’une trace `BedrockAgentRuntime.invoke_agent`. La trace enregistre :

* Les entrées de l’agent (`agentId`, `agentAliasId`, `sessionId`, `inputText`).
* Le texte de l’assistant extrait du flux d’événements de complétion.
* Le modèle de fondation sous-jacent utilisé par l’agent (extrait de la trace d’orchestration).
* L’utilisation des jetons (`prompt_tokens`, `completion_tokens`, `total_tokens`), lorsque l’agent la fournit.

Le modèle de fondation et l’utilisation des jetons sont extraits des événements `orchestrationTrace`, que Bedrock n’émet que si `invoke_agent` est appelé avec `enableTrace=True`. Sans cet indicateur, les traces capturent tout de même les entrées et le texte de la réponse générée, mais le modèle de fondation prend par défaut la valeur `bedrock-agent:<agentId>` et le nombre de jetons n’est pas disponible.

<h2 id="nest-related-agent-calls-together">
  Imbriquer les appels d’agent associés
</h2>

Pour regrouper un appel `invoke_agent` avec la logique qui s’y rattache, comme un prétraitement, un post-traitement ou des appels d’API chaînés, encapsulez votre fonction avec `@weave.op`. Weave imbrique alors la trace `invoke_agent` patchée dans l’op parent.

```python lines theme={"system"}
@weave.op
def ask_agent(question: str, session_id: str) -> str:
    response = bedrock_agent_client.invoke_agent(
        agentId="[YOUR-AGENT-ID]",
        agentAliasId="[YOUR-AGENT-ALIAS-ID]",
        sessionId=session_id,
        inputText=question,
        enableTrace=True,
    )
    text = ""
    for event in response["completion"]:
        chunk = event.get("chunk")
        if chunk and "bytes" in chunk:
            text += chunk["bytes"].decode("utf-8")
    return text


answer = ask_agent("Summarize today's open support tickets.", session_id="session-1")
```

<h2 id="multi-turn-conversations">
  Conversations sur plusieurs tours de conversation
</h2>

Bedrock Agents conserve l’état de la conversation côté service lorsque vous réutilisez un `sessionId`. Pour regrouper plusieurs tours de conversation dans une seule trace de l’interface Weights & Biases, encapsulez ces tours dans `weave.thread` :

```python lines theme={"system"}
with weave.thread("support-conversation") as t:
    for prompt in [
        "I can't log in to my account.",
        "I already tried resetting my password.",
    ]:
        ask_agent(prompt, session_id=t.thread_id)
```

Weave affiche chaque tour de conversation dans l’interface utilisateur sous forme de ligne distincte dans la vue Threads.

<h2 id="view-traces">
  Afficher les traces
</h2>

Lorsque vous exécutez l’exemple, Weave affiche un lien vers le tableau de bord du projet. Ouvrez ce lien pour examiner, pour chaque appel `invoke_agent`, les entrées de l’agent, le modèle de fondation utilisé, l’utilisation des jetons et la réponse générée.