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 Werkzeuggebrauch

Wenn Sie die Responses API verwenden, um das Modell aufzurufen, kann es zusätzlich zu dem zuvor besprochenen clientseitigen Toolaufruf serverseitige Tool-Aufrufe verwenden. Server-side Der Werkzeugaufruf ist ein Mechanismus, bei dem Tools (APIs, Funktionen, Workflows) in einer vertrauenswürdigen Backend-Umgebung ausgeführt werden, nicht auf dem Client. Dies verbessert die Sicherheit, Zuverlässigkeit und Governance der Anwendung. Bevor Amazon Bedrock die Lambda-Funktion ausführt, die die Verwendung des Tools implementiert, stellt es sicher, 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 übernimmt, können sich Kunden auf die Implementierung ihrer Geschäftslogik konzentrieren, anstatt Toolfunktionen hinzuzufügen. Amazon Bedrock unterstützt auch die höchsten Verwaltungsstandards wie ISO-, SOC- und HIPAA-konform. Sie 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 verfügbar. Unterstützung für andere Modelle wird in Kürze verfügbar sein. Sie können die Models-API verwenden, um verfügbare Modelle zu ermitteln, 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 Amazon Bedrock unterstützt werden. In diesem Abschnitt wird beschrieben, wie Sie ein benutzerdefiniertes Lambda-Tool mit der Responses API erstellen. In den folgenden Abschnitten werden die einzelnen Typen detailliert beschrieben.

Benutzerdefinierte Tools, die Lambda in der Responses API verwenden

Durch die Verwendung einer Lambda-Funktion als benutzerdefiniertes Tool in Amazon Bedrock können Sie die Funktionen des Agenten erweitern, indem Sie benutzerdefinierte 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 zu vervollständigen, senden Sie die Nachricht und die Definitionen für ein oder mehrere Tools an das Modell. Wenn das Modell anhand der Aufforderung Ihrer Anwendung feststellt, dass eines der Tools beim Generieren einer Antwort helfen kann, gibt es eine Aufforderung an Amazon 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 abzurufen

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 und einen ARN zu erhalten. Weitere Informationen finden Sie unter Erste Schritte mit Lambda im Lambda Developer Guide.

# 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 Responses API-Operationen. Amazon Bedrock verwendet die Connectors- und Remote-MCP-Server-Funktionen 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 Vorgang Create ü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 Amazon Bedrock dieselben IAM-Rollen und -Richtlinien verwendet, die für Ihre Anwendung verwendet werden, 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 leitet 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 unter Antworten mithilfe von OpenAI-APIs bedrock/latest/userguide/bedrock-mantle.html generieren, welche Tools Ihr Modell unterstützen. Wenn Sie Tools verwenden, die die Responses API verwenden, zahlen Sie nur für Token, die beim Importieren von Werkzeugdefinitionen oder beim Ausführen von Toolaufrufen verwendet werden. Pro Toolaufruf 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 wird, erscheint ein neues mcp_list_tools Ausgabeelement in der Ausgabe der Modellantwort. Die tools Eigenschaft dieses Objekts zeigt die Werkzeuge an, die erfolgreich importiert wurden. Nachdem das Modell Zugriff auf diese Werkzeugdefinitionen hat, kann es sich entscheiden, sie aufzurufen, je nachdem, was sich im Kontext des Modells befindet. Wenn das Modell beschließt, ein Lambda-Tool aufzurufen, fordert die API die Lambda-Funktion auf, das Tool aufzurufen und seine Ausgabe in den Kontext des Modells zu stellen. Weitere Informationen zu den Listentools und den Aufruftools finden Sie in der OpenAI-Dokumentation. Beachten Sie, dass Ihrer Lambda-Funktion dieselben IAM-Rollen und Richtlinien zugeordnet sein müssen wie die der Anwendung, die das Modell in Amazon Bedrock aufruft, da sonst die Lambda-Funktion fehlschlägt. Im Folgenden finden Sie die Fehlerdefinition.

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

Verwenden Sie AWS die bereitgestellten Tools in der Responses API

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

Überblick über das Tool „Notizen“

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

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

Sie können eine 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 Morgen bevorzuge“, „Denken Sie daran, was ich zu den Besprechungspräferenzen gesagt habe“) oder Sie können direkte Tool-Aufrufe in Ihrer Aufforderung verwenden („Verwende das Notiz-Tool, um meine E-Mail unter john@example.com zu speichern“, „Prüfe die Notizen für meine E-Mail-Adresse“).

Überblick über das Tool „Aufgaben“

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

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

Sie können das Aufgabentool entweder in natürlicher Sprache aufrufen (z. B. „Eine Aufgabe hinzufügen, um das Budget zu überprüfen“, „Eine Erinnerung senden, um den Kunden anzurufen“, „Was ist die nächste Aufgabe, die ich erledigen muss?“ , „Aktuelle Aufgabe anzeigen“, „Aktuelle Aufgabe aus meinem Stapel abrufen“) oder Sie können das Tool direkt in Ihrer Eingabeaufforderung aufrufen („Verwenden Sie das Aufgabentool, um die Präsentation fertigzustellen“, „Eine Aufgabe aus dem Stapel entfernen“, „Einen Termin zu meiner Aufgabenliste hinzufügen“).

Codebeispiel: Verwenden der Notizen- und Aufgabentools

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 darauf:

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

Amazon Bedrock unterstützt jetzt AgentCore Gateway als serverseitigen Tool-Integrationstyp. Mit dieser Funktion können Sie Ihre Modelle direkt mit AgentCore Gateway-Endpunkten verbinden, um nahtlosen Zugriff auf Tools zu erhalten, die über die Gateway-Infrastruktur verwaltet werden.

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

Lambda-Integration:

AgentCore Gateway-Integration:

Konfiguration

Struktur der Anfrage

Wenn Sie AgentCore Gateway als Toolquelle konfigurieren, verwenden Sie 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

Beispiel für eine vollständige 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