Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Server-side utilisation de l'outil

Si vous utilisez l'API Responses pour invoquer le modèle, celui-ci peut utiliser un appel d'outil côté serveur, en plus de l'appel d'outil côté client dont nous avons parlé précédemment. Server-side l'appel d'outils est un mécanisme par lequel les outils (API, fonctions, flux de travail) sont exécutés dans un environnement backend fiable, et non sur le client. Cela améliore la sécurité, la fiabilité et la posture de gouvernance de l'application. Avant qu'Amazon Bedrock n'exécute la fonction Lambda qui implémente l'utilisation de l'outil, il s'assure que la fonction Lambda applique la même politique IAM que celle de l'application qui l'appelle. Comme Amazon Bedrock gère l'exécution des outils, les clients peuvent se concentrer sur la mise en œuvre de leur logique métier, plutôt que sur l'ajout de fonctionnalités d'outils. Amazon Bedrock prend également en charge les normes de gouvernance les plus strictes, telles que les normes ISO, SOC et HIPAA. Vous pouvez soit soumettre votre propre fonction Lambda personnalisée pour exécuter l'outil, soit utiliser des outils prédéfinis existants, tels que des notes et des tâches. Server-side les outils utilisant l'API Responses sont disponibles, en commençant par les 20B/120B modèles GPT OSS, et la prise en charge d'autres modèles sera bientôt disponible. Vous pouvez utiliser l'API Models pour découvrir les modèles disponibles que vous pouvez utiliser avec l'API Responses. Pour plus de détails sur l'API Responses, voir Générer des réponses à l'aide des API OpenAI.

Il existe deux types d'outils que vous pouvez utiliser avec Amazon Bedrock : des outils personnalisés utilisant Lambda ou des outils prédéfinis pris en charge par Amazon Bedrock. Cette section explique comment créer un outil Lambda personnalisé à l'aide de l'API Responses. Les sections suivantes décrivent chaque type en détail.

Outils personnalisés utilisant Lambda dans l'API Responses

En utilisant une fonction Lambda comme outil personnalisé dans Amazon Bedrock, vous pouvez étendre les fonctionnalités de l'agent en intégrant des fonctions Lambda personnalisées en tant qu'outils. Vous pouvez ainsi créer des outils évolutifs et sans serveur qui peuvent être appelés par des assistants IA et d'autres applications via le protocole MCP (Model Context Protocol). Voici les avantages de cette fonctionnalité :

Pour permettre à un modèle dans Amazon Bedrock d'utiliser un outil pour répondre à un message, vous devez envoyer le message et les définitions d'un ou de plusieurs outils au modèle. Sur la base de l'invite de votre application, si le modèle détermine que l'un des outils peut aider à générer une réponse, il renvoie une demande pour qu'Amazon Bedrock utilise l'outil et renvoie les résultats de l'outil au modèle. Le modèle utilise ensuite le résultat de l’outil pour générer une réponse pour le message d’origine.

Les étapes suivantes montrent comment utiliser un outil avec l'API Responses.

Fonctionnement

Étape 1 : Définissez la fonction Lambda pour obtenir la chanson la plus populaire

Créez une fonction Lambda qui implémente le protocole MCP. Voici un exemple Python simple :

import json

def lambda_handler(event, context):
    # Parse JSON-RPC request
    method = event.get('method')
    params = event.get('params', {})
    request_id = event.get('id')
    
    if method == 'tools/list':
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "tools": [
                    {
                        "name": "my_custom_tool",
                        "description": "My custom business logic tool",
                        "inputSchema": {
                            "type": "object",
                            "properties": {
                                "input": {
                                    "type": "string",
                                    "description": "Input text to process"
                                }
                            },
                            "required": ["input"]
                        }
                    }
                ]
            }
        }
    elif method == 'tools/call':
        tool_name = params.get('name')
        arguments = params.get('arguments', {})
        
        if tool_name == 'my_custom_tool':
            # Your custom logic here
            result = f"Processed: {arguments.get('input', '')}"
            return {
                "jsonrpc": "2.0",
                "id": request_id,
                "result": {
                    "content": [
                        {
                            "type": "text",
                            "text": result
                        }
                    ]
                }
            }
    
    # Error response for unsupported methods
    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "error": {
            "code": -32601,
            "message": "Method not found"
        }
    }

Étape 2 : Déploiement de la fonction Lambda

Ensuite, utilisez votre rôle IAM pour déployer cette fonction Lambda afin d'obtenir un ARN. Pour en savoir plus, consultez la section Premiers pas avec Lambda dans le Guide du développeur Lambda.

# Example using AWS CLI
aws lambda create-function \
  --function-name my-custom-tool \
  --runtime python3.14 \
  --role arn:aws:iam::YOUR-ACCOUNT:role/lambda-execution-role \
  --handler lambda_function.lambda_handler \
  --zip-file fileb://function.zip

Supposons que votre ARN soit : arn:aws:lambda:us-west-2:123456789012:function:my-custom-tool

Étape 3 : Définissez le message et la définition de l'outil dans votre demande d'inférence

Pour envoyer le message et la définition de l'outil, vous utilisez les opérations de l'API Responses. Amazon Bedrock utilise les connecteurs et les fonctionnalités de serveurs MCP distants de l'API Responses pour fournir des fonctionnalités d'utilisation d'outils. La définition de l'outil est un schéma JSON que vous transmettez dans le paramètre de requête mcp à l'opération Create. Dans le connector_id champ de l'API Responses Connectors, vous pouvez transmettre l'ARN Lambda que vous avez créé à l'étape précédente. Vous n'avez pas besoin de fournir des informations d'autorisation car Amazon Bedrock utilise les mêmes rôles et politiques IAM que ceux utilisés pour votre application qui invoque le modèle. L’exemple de schéma suivant concerne un outil qui permet d’obtenir les chansons les plus populaires d’une station de radio.

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="oss-gpt-120b",
    tools=[
        {
            "type": "mcp",
            "server_label": "xamzn_arn",
            "connector_id": "arn:aws:lambda:us-west-2:123456789012:function:my-custom-tool",
            "require_approval": "never",
        },
    ],
    input="My custom prompt.",
)

print(resp.output_text)

Étape 4 : Bedrock appelle l'outil et renvoie la réponse au modèle

La possibilité d'utiliser l'outil de connexion est disponible dans les modèles qui prennent en charge l'API Responses. Vérifiez quels outils prennent en charge votre modèle dans Générer des réponses à l'aide des API OpenAI. Lorsque vous utilisez des outils à l'aide de l'API Responses, vous ne payez que pour les jetons utilisés lors de l'importation de définitions d'outils ou des appels d'outils. Il n'y a pas de frais supplémentaires par appel d'outil.

Lorsque vous spécifiez une fonction Lambda dans le tools paramètre, l'API tente d'obtenir une liste d'outils à partir du serveur. Si vous parvenez à récupérer la liste des outils, un nouvel élément mcp_list_tools de sortie apparaîtra dans la sortie de réponse du modèle. La tools propriété de cet objet affiche les outils qui ont été importés avec succès. Une fois que le modèle a accès à ces définitions d'outils, il peut choisir de les appeler en fonction du contexte du modèle. Lorsque le modèle décide d'appeler un outil Lambda, l'API demande à la fonction Lambda d'appeler l'outil et de placer sa sortie dans le contexte du modèle. Vous pouvez en savoir plus sur les outils de liste et les outils d'appel dans la documentation https://platform.openai.com/docs/guides/tools-connectors-mcp?quickstart-panels=connector OpenAI. Notez que votre fonction Lambda doit être associée aux mêmes rôles IAM et à la même politique que ceux de l'application qui appelle le modèle dans Amazon Bedrock, sinon la fonction Lambda échouera. Voici la définition de l'erreur.

{
    "jsonrpc": "2.0",
    "id": 1,
    "error": {
        "code": -32000,
        "message": "Tool execution failed",
        "data": "Additional error details"
    }
}

Utilisation des outils AWS fournis dans l'API Responses

Deux outils sont intégrés AWS aux openai.gpt-oss-120b modèles openai.gpt-oss-20b et : la Note-taking fonctionnalité (outil de notes) et la gestion des tâches (outil de tâches). Ces outils sont automatiquement disponibles, il n'est pas nécessaire de les définir dans le tools paramètre.

Présentation de l'outil Notes

L'notesoutil permet au modèle de stocker des notes au cours d'une même session de conversation. Cela fournit un mécanisme de mémoire simple pour maintenir le contexte lors de multiples interactions. La mémoire est limitée à la conversation en cours uniquement.

Lorsque le modèle utilise l'outil de notes, il émet une mcp_call sortie avec name défini sur. "notes" Le modèle détermine les arguments appropriés en fonction de votre demande.

Vous pouvez utiliser l'un ou l'autre langage naturel (par exemple, « N'oubliez pas que ma couleur préférée est le bleu », « Qu'est-ce que je vous ai dit à propos de ma couleur préférée ? » , « Mémorisez le fait que je préfère les réunions du matin », « Souvenez-vous de ce que j'ai dit à propos des préférences relatives aux réunions ») ou vous pouvez utiliser les appels directs à l'outil dans votre invite (« Utiliser l'outil de notes pour enregistrer mon adresse e-mail sous le nom john@example.com », « Vérifiez les notes pour mon adresse e-mail »).

Présentation de l'outil Tâches

L'tasksoutil fournit une pile permettant de gérer les tâches au cours d'une session de conversation. Vous pouvez placer des tâches dans la pile et les faire apparaître, ce qui est utile pour gérer les flux de travail, les rappels ou la gestion hiérarchique des tâches. Les tâches persistent tout au long de la session de conversation. La mémoire est limitée à la conversation en cours uniquement.

Lorsque le modèle utilise l'outil Tâches, il émet une mcp_call sortie avec name défini sur. "tasks" Le modèle détermine les arguments appropriés (tels que methodtask.title, ettask.description) en fonction de votre demande.

Vous pouvez appeler l'outil Tâches en utilisant le langage naturel (par exemple, « Ajouter une tâche pour revoir le budget », « Envoyer un rappel pour appeler le client », « Quelle est la prochaine tâche que je dois effectuer ? » , « Afficher la tâche la plus récente », « Obtenir la dernière tâche de ma pile ») ou vous pouvez appeler l'outil directement depuis votre invite (« Utilisez l'outil des tâches pour appuyer sur « Terminer la présentation » », « Afficher une tâche de la pile », « Ajouter « Planifier une réunion » à ma liste de tâches »).

Exemple de code : utilisation des outils de notes et de tâches

Les outils de notes et de tâches sont intégrés aux openai.gpt-oss-120b modèles openai.gpt-oss-20b et. Vous n'avez pas besoin de les définir explicitement dans le tools paramètre, il vous suffit de les référencer dans votre invite :

from openai import OpenAI

client = OpenAI(
    base_url="https://bedrock-mantle.us-east-1.api.aws/v1"
)

# The notes tool is built-in — just ask the model to use it
resp = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Use the notes tool to store that my preferred language is Python.",
)

print(resp.output)
# The model automatically calls the notes tool via mcp_call

# Use the tasks tool to push a task
resp = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Use the tasks tool to push a task: review the API documentation",
)

print(resp.output)

Server-side intégration de l'utilisation des outils avec Gateway AgentCore

Amazon Bedrock prend désormais en charge AgentCore Gateway en tant qu'outil côté serveur appelant le type d'intégration. Grâce à cette fonctionnalité, vous pouvez connecter vos modèles directement aux points de terminaison de AgentCore Gateway pour un accès transparent aux outils gérés via l'infrastructure de passerelle.

L'intégration de AgentCore Gateway suit le même schéma que l'intégration de la fonction Lambda, à une différence près.

Intégration Lambda :

AgentCore Intégration de la passerelle :

Configuration

Structure de la demande

Lorsque vous configurez AgentCore Gateway en tant que source d'outils, utilisez la structure suivante dans votre tools tableau dans votre demande d'API Responses.

{
  "type":"mcp",
  "server_label":"agentcore_tools",
  "connector_id":"arn:aws:bedrock-agentcore:us-west-2:342789630635:gateway/agentcore-intro-gateway-v2-swvq44sovp",
  "server_description":"AgentCore Gateway providing custom tools",
  "require_approval":"never"
}

Paramètres

Exemple de demande complète

{
  "model":"openai.gpt-oss-120b",
  "stream":true,
  "background":false,
  "store":false,
  "tools": [
    {
      "type":"mcp",
      "server_label":"agentcore_tools",
      "connector_id":"arn:aws:bedrock-agentcore:us-west-2:342789630635:gateway/agentcore-intro-gateway-v2-swvq44sovp",
      "server_description":"AgentCore Gateway providing custom tools",
      "require_approval":"never"
    }
  ],
  "input": [
    {
      "type":"message",
      "role":"user",
      "content": [
        {
          "type":"input_text",
          "text":"What is the weather in Seattle?"
        }
      ]
    }
  ]
}

Conditions préalables

Avant d'utiliser l'intégration de AgentCore Gateway, assurez-vous que vous disposez des éléments suivants :

Avantages de l'intégration de AgentCore Gateway

Autorisations IAM

Votre rôle d'exécution Bedrock a besoin d'une autorisation pour invoquer la AgentCore passerelle :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock-agentcore:InvokeGateway"
      ],
      "Resource": "arn:aws:bedrock-agentcore:us-west-2:342789630635:gateway/agentcore-intro-gateway-v2-swvq44sovp"
    }
  ]
}

Étapes suivantes