Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Server-side Verwendung von Werkzeugen

Wenn Sie die Responses API verwenden, um das Modell aufzurufen, kann es zusätzlich zu den zuvor erläuterten clientseitigen Toolaufrufen auch serverseitige Tool-Aufrufe verwenden. Server-side Der Werkzeugaufruf ist ein Mechanismus, bei dem Tools (APIs, Funktionen, Workflows) in einer vertrauenswürdigen Backend-Umgebung und nicht auf dem Client ausgeführt werden. Dies verbessert die Sicherheit, Zuverlässigkeit und Steuerung der Anwendung. Bevor Amazon Bedrock die Lambda-Funktion ausführt, die die Verwendung des Tools implementiert, wird sichergestellt, dass für die Lambda-Funktion dieselbe IAM-Richtlinie gilt wie für die Anwendung, die sie aufruft. Da Amazon Bedrock die Ausführung der Tools vorantreibt, können sich Kunden auf die Implementierung ihrer Geschäftslogik konzentrieren, anstatt Toolfunktionen hinzuzufügen. Amazon Bedrock unterstützt auch die höchsten Governance-Standards wie ISO, SOC und HIPAA-tauglich. Kunden können entweder ihre eigene benutzerdefinierte Lambda-Funktion einreichen, um das Tool auszuführen, oder vorhandene vordefinierte Tools wie Notizen und Aufgaben verwenden. Server-side Tools, die die Responses API verwenden, sind ab den 20B/120B GPT-OSS-Modellen von OpenAI verfügbar. Andere Modelle werden in Kürze unterstützt. Sie können die Models-API verwenden, um verfügbare Modelle zu finden, die Sie mit der Responses API verwenden können. Weitere Informationen zur Responses API finden Sie unter Generieren von Antworten mithilfe von OpenAI-APIs.

Es gibt zwei Arten von Tools, die Sie mit Amazon Bedrock verwenden können: Benutzerdefinierte Tools, die Lambda verwenden, oder vordefinierte Tools, die von Bedrock unterstützt werden. In diesem Abschnitt erfahren Sie, wie Sie mit der Responses API ein benutzerdefiniertes Lambda-Tool erstellen. Lassen Sie uns beide im Detail besprechen.

Benutzerdefinierte Tools, die Lambda in Responses API verwenden

Durch die Verwendung einer Lambda-Funktion als benutzerdefiniertes Tool in Bedrock können Sie die Funktionen des Agenten erweitern, indem Sie benutzerdefinierte AWS Lambda Lambda-Funktionen als Tools integrieren. Auf diese Weise können Sie serverlose, skalierbare Tools erstellen, die von KI-Assistenten und anderen Anwendungen über das Model Context Protocol (MCP) aufgerufen werden können. Hier sind die Vorteile dieser Funktion:

Damit ein Modell in Amazon Bedrock ein Tool verwenden kann, um eine Antwort auf eine Nachricht abzuschließen, senden Sie die Nachricht und die Definitionen für ein oder mehrere Tools an das Modell. Wenn das Modell auf der Grundlage der Aufforderung Ihrer Anwendung feststellt, dass eines der Tools bei der Generierung einer Antwort helfen kann, sendet es eine Anfrage an Bedrock zurück, das Tool zu verwenden und die Werkzeugergebnisse an das Modell zurückzusenden. Das Modell verwendet dann die Ergebnisse, um eine Antwort auf die ursprüngliche Nachricht zu generieren.

Die folgenden Schritte zeigen, wie Sie ein Tool mit der Responses API verwenden.

Funktionsweise

Schritt 1: Definieren Sie die Lambda-Funktion, um den beliebtesten Song zu erhalten

Erstellen Sie eine Lambda-Funktion, die das MCP-Protokoll implementiert. Hier ist ein einfaches Python-Beispiel:

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"
        }
    }

Schritt 2: Stellen Sie die Lambda-Funktion bereit

Verwenden Sie als Nächstes Ihre IAM-Rolle, um diese Lambda-Funktion bereitzustellen, um einen ARN zu erhalten. Weitere Informationen zur Bereitstellung einer Lambda-Funktion finden Sie hier.

# 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

Nehmen wir an, Ihr ARN lautet: arn:aws:lambda:us-west-2:123456789012:function:my-custom-tool

Schritt 3: Definieren Sie die Nachricht und die Tooldefinition in Ihrer Inferenzanfrage

Um die Nachricht und die Tooldefinition zu senden, verwenden Sie die Response-API-Operationen. Amazon Bedrock verwendet die Konnektoren und Remote-MCP-Serverfunktionen der Responses API, um Funktionen zur Verwendung von Tools bereitzustellen. Die Definition des Tools ist ein JSON-Schema, das Sie im mcp-Anforderungsparameter an den Create-Vorgang übergeben. In dem connector_id Feld in der Responses Connectors API können Sie den Lambda-ARN übergeben, den Sie im vorherigen Schritt erstellt haben. Sie müssen keine Autorisierungsdaten angeben, da Bedrock dieselben IAM-Rollen und Richtlinien verwendet wie Ihre Anwendung, die das Modell aufruft. Nachfolgend finden Sie ein Beispielschema für ein Tool, das den beliebtesten Song eines Radiosenders ermittelt.

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)

Schritt 4: Bedrock ruft das Tool auf und gibt die Antwort zurück an das Modell

Die Möglichkeit, das Connector-Tool zu verwenden, ist in den Modellen verfügbar, die die Responses API unterstützen. Prüfen Sie hier, welche Tools Ihr Modell unterstützen. Wenn Sie Tools verwenden, die die Responses API verwenden, zahlen Sie nur für Token, die beim Import von Tooldefinitionen oder bei Toolaufrufen verwendet werden. Pro Tool-Aufruf fallen keine zusätzlichen Gebühren an.

Wenn Sie im tools Parameter eine Lambda-Funktion angeben, versucht die API, eine Liste von Tools vom Server abzurufen. Wenn die Liste der Tools erfolgreich abgerufen werden kann, erscheint ein neues mcp_list_tools Ausgabeelement in der Ausgabe der Modellantwort. In der tools Eigenschaft dieses Objekts werden die Werkzeuge angezeigt, die erfolgreich importiert wurden. Sobald das Modell Zugriff auf diese Werkzeugdefinitionen hat, kann es sie je nach Kontext des Modells aufrufen. Wenn das Modell beschließt, ein Lambda-Tool aufzurufen, sendet die API eine Anfrage an die Lambda-Funktion, das Tool aufzurufen und seine Ausgabe in den Kontext des Modells zu stellen. Weitere Informationen zu den Listentools und Aufruf-Tools finden Sie in der OpenAI-Dokumentation. Beachten Sie, dass Ihrer Lambda-Funktion dieselben IAM-Rollen und Richtlinien zugewiesen sein müssen wie der Anwendung, die das Modell in Bedrock aufruft. Andernfalls schlägt die Lambda-Funktion fehl. Im Folgenden finden Sie die Fehlerdefinition.

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

Verwendung der von AWS bereitgestellten Tools in der Responses API

In die openai.gpt-oss-120b Modelle openai.gpt-oss-20b und sind zwei von AWS bereitgestellte Tools integriert: Note-taking Funktionalität (Notizen-Tool) und Aufgabenmanagement (Aufgabentool). Diese Tools sind automatisch verfügbar — Sie müssen sie nicht im tools Parameter definieren.

Überblick über das Notes-Tool

Das notes Tool ermöglicht es dem Modell, Notizen innerhalb derselben Konversationssitzung zu speichern. Dies bietet einen einfachen Speichermechanismus, um den Kontext über mehrere Interaktionen hinweg aufrechtzuerhalten. Der Speicher ist nur auf die aktuelle Konversation beschränkt.

Wenn das Modell das Notizwerkzeug verwendet, gibt es eine mcp_call Ausgabe mit name der Einstellung auf aus. "notes" Das Modell bestimmt die entsprechenden Argumente auf der Grundlage Ihrer Anfrage.

Sie können jede natürliche Sprache verwenden (z. B. „Denken Sie daran, dass meine Lieblingsfarbe Blau ist“, „Was habe ich Ihnen über meine Lieblingsfarbe erzählt?“ , „Speichern Sie die Tatsache, dass ich Besprechungen am Vormittag bevorzuge“, „Erinnern Sie sich daran, was ich zu den Besprechungspräferenzen gesagt habe“) oder Sie können in Ihrer Aufforderung direkte Tool-Aufrufe verwenden („Verwenden Sie das Notizen-Tool, um meine E-Mail als john@example.com zu speichern“, „Überprüfen Sie die Notizen auf meine E-Mail-Adresse“).

Überblick über das Aufgaben-Tool

Das tasks Tool bietet einen Stapel für die Verwaltung von Aufgaben innerhalb einer Konversationssitzung. Sie können Aufgaben auf den Stapel verschieben und wieder entfernen. Dies macht das Tool nützlich für die Verwaltung von Workflows, Erinnerungen oder die hierarchische Aufgabenverwaltung. Aufgaben bleiben während der gesamten Konversationssitzung bestehen. Der Arbeitsspeicher ist nur auf die aktuelle Konversation beschränkt.

Wenn das Modell das Tasks-Tool verwendet, gibt es eine mcp_call Ausgabe mit dem name Wert auf aus. "tasks" Das Modell bestimmt die entsprechenden Argumente (wie methodtask.title, undtask.description) auf der Grundlage Ihrer Anfrage.

Sie können das Aufgaben-Tool entweder in natürlicher Sprache aufrufen (z. B. „Fügen Sie eine Aufgabe hinzu, um das Budget zu überprüfen“, „Senden Sie eine Erinnerung, um den Kunden anzurufen“, „Was ist die nächste Aufgabe, die ich erledigen muss?“ , „Aktuellste Aufgabe einblenden“, „Aktuelle Aufgabe aus meinem Stapel abrufen“) oder Sie können das Tool direkt in Ihrer Aufforderung aufrufen („Verwenden Sie das Aufgabentool, um auf „Präsentation beenden“ zu klicken, „Eine Aufgabe aus dem Stapel herausnehmen“, „Meine Aufgabenliste für ein Meeting festlegen“).

Codebeispiel: Verwenden der Tools für Notizen und Aufgaben

Die Tools für Notizen und Aufgaben sind in die openai.gpt-oss-120b Modelle openai.gpt-oss-20b und integriert. Sie müssen sie nicht explizit im tools Parameter definieren — verweisen Sie einfach in Ihrer Eingabeaufforderung auf sie:

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 Integration zur Verwendung von Tools mit Gateway AgentCore

Amazon Bedrock unterstützt jetzt AgentCore Gateway als Integrationstyp für serverseitige Tools, die Tools aufrufen. Mit dieser Funktion können Sie Ihre Modelle direkt mit AgentCore Gateway-Endpunkten verbinden und so einen nahtlosen Zugriff auf Tools ermöglichen, die über die Gateway-Infrastruktur verwaltet werden.

Die AgentCore Gateway-Integration folgt dem gleichen Muster wie die Lambda-Funktionsintegration, mit einem wesentlichen Unterschied.

Lambda-Integration:

AgentCore Gateway-Integration:

Konfiguration

Struktur der Anfrage

Verwenden Sie bei der Konfiguration von AgentCore Gateway als Toolquelle die folgende Struktur in Ihrem tools Array in Ihrer Responses API-Anfrage.

{
  "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"
}

Parameter

Vollständiges Beispiel für eine Anfrage

{
  "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?"
        }
      ]
    }
  ]
}

Voraussetzungen

Bevor Sie die AgentCore Gateway-Integration verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen:

Vorteile der AgentCore Gateway-Integration

IAM-Berechtigungen

Ihre Bedrock-Ausführungsrolle benötigt die Erlaubnis, das Gateway aufzurufen: AgentCore

{
  "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"
    }
  ]
}

Nächste Schritte