View a markdown version of this page

Empfangen Sie Logging-Nachrichten von Ihrem AgentCore Gateway - Amazon Grundgestein AgentCore
VoraussetzungenProtokollstufenWie funktioniert das Protokollieren von NachrichtenCodebeispiele

Empfangen Sie Logging-Nachrichten von Ihrem AgentCore Gateway

Mit dieser notifications/message Methode können MCP-Serverziele während der Ausführung des Tools Protokollnachrichten an Clients senden. Diese Meldungen bieten in Echtzeit Einblick in die Aktivitäten des Servers und sind nützlich für das Debuggen, Prüfen und Überwachen des Toolverhaltens. AgentCore Gateway leitet diese Protokollbenachrichtigungen von MCP-Serverzielen als Server-Sent Event-Chunks (SSE) an Ihren Client weiter.

Voraussetzungen

Gehen Sie wie folgt vor, um Protokollnachrichten von Ihrem Gateway zu empfangen:

  • Antwort-Streaming aktiviert — Protokollnachrichten werden während einer offenen Verbindung als SSE-Chunks zugestellt. trueIn streamingConfiguration.enableResponseStreaming Ihren Gateways auf eingestellt. protocolConfiguration.mcp

  • MCP-Serverzieltyp — Protokollnachrichten stammen von MCP-Serverzielen.

  • Client sendet Accept: text/event-stream Header — Der Client muss eine SSE-Antwort anfordern, um Streaming-Ereignisse zu empfangen.

Protokollstufen

MCP definiert die folgenden Protokollebenen in der Reihenfolge ihres zunehmenden Schweregrads:

Level Description

debug

Detaillierte Diagnoseinformationen zur Fehlerbehebung.

info

Allgemeine Informationsmeldungen zum normalen Betrieb.

notice

Normale, aber wichtige Ereignisse.

warning

Potenziell schädliche Situationen, die den Betrieb nicht verhindern.

error

Fehlerbedingungen, die einen bestimmten Vorgang verhindert haben.

critical

Kritische Bedingungen, die sofortige Aufmerksamkeit erfordern.

alert

Es müssen sofort Maßnahmen ergriffen werden.

emergency

Das System ist unbrauchbar.

Wie funktioniert das Protokollieren von Nachrichten

Wenn ein MCP-Serverziel notifications/message während der Ausführung des Tools ein ausgibt, leitet das Gateway es als SSE-Ereignis an den Client weiter. Jede Protokollnachricht enthält:

  • level— Der Schweregrad der Nachricht.

  • logger— Optionaler Name, der die Quellkomponente identifiziert.

  • data— Der Inhalt des Protokolls (Zeichenfolge oder strukturiertes Objekt).

Protokollnachrichten sind informativ und erfordern keine Antwort vom Client. Sie werden zusammen mit anderen SSE-Ereignissen wie Fortschrittsmeldungen und dem Endergebnis des Tools übermittelt.

Codebeispiele

Beispiel
curl

  1. Rufen Sie ein Tool auf und erhalten Sie Protokollmeldungen im SSE-Stream:

    curl -N -X POST \
  https://mygateway-abcdefghij.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -d '{
    "jsonrpc": "2.0",
    "id": "tool-call-1",
    "method": "tools/call",
    "params": {
      "name": "deployService",
      "arguments": {
        "serviceName": "my-api",
        "environment": "staging"
      }
    }
}'

    Das Gateway gibt einen SSE-Stream mit Protokollnachrichten zurück, gefolgt vom Endergebnis:

    event: message
data: {"jsonrpc":"2.0","method":"notifications/message","params":{"level":"info","logger":"deploy-service","data":"Starting deployment of my-api to staging"}}

event: message
data: {"jsonrpc":"2.0","method":"notifications/message","params":{"level":"info","logger":"deploy-service","data":"Building container image..."}}

event: message
data: {"jsonrpc":"2.0","method":"notifications/message","params":{"level":"warning","logger":"deploy-service","data":"Deprecated configuration detected in service manifest"}}

event: message
data: {"jsonrpc":"2.0","method":"notifications/message","params":{"level":"info","logger":"deploy-service","data":"Deployment complete"}}

event: message
data: {"jsonrpc":"2.0","id":"tool-call-1","result":{"content":[{"type":"text","text":"Successfully deployed my-api to staging environment."}]}}
Python requests package

  1. import requests
import json
import sseclient

gateway_url = "https://mygateway-abcdefghij.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp"
headers = {
    "Content-Type": "application/json",
    "Accept": "text/event-stream",
    "Authorization": "Bearer YOUR_ACCESS_TOKEN"
}

# Call tool (streaming response)
response = requests.post(gateway_url, headers=headers, json={
    "jsonrpc": "2.0",
    "id": "tool-call-1",
    "method": "tools/call",
    "params": {
        "name": "deployService",
        "arguments": {"serviceName": "my-api", "environment": "staging"}
    }
}, stream=True)

# Process SSE events
client = sseclient.SSEClient(response)
for event in client.events():
    data = json.loads(event.data)
    if data.get("method") == "notifications/message":
        params = data["params"]
        print(f"[{params['level'].upper()}] {params.get('logger', '')}: {params['data']}")
    elif "result" in data:
        print(f"Tool result: {data['result']}")
        break
MCP Client

  1. from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
import asyncio

async def log_handler(level, logger, data):
    """Handle log messages from the server."""
    print(f"[{level.upper()}] {logger or 'server'}: {data}")

async def use_logging(url, token):
    headers = {"Authorization": f"Bearer {token}"}

    async with streamablehttp_client(url=url, headers=headers) as (
        read_stream, write_stream, _
    ):
        async with ClientSession(
            read_stream, write_stream,
            logging_handler=log_handler
        ) as session:
            await session.initialize()

            # Call tool - log messages handled by callback
            result = await session.call_tool(
                name="deployService",
                arguments={"serviceName": "my-api", "environment": "staging"}
            )
            print(f"Tool result: {result}")
            return result

asyncio.run(use_logging(
    url="https://mygateway-abcdefghij.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp",
    token="YOUR_ACCESS_TOKEN"
))
Strands MCP Client

  1. from mcp.client.streamable_http import streamablehttp_client
from strands import Agent
from strands.tools.mcp import MCPClient

mcp_url = "https://mygateway-abcdefghij.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp"
access_token = "YOUR_ACCESS_TOKEN"

mcp_client = MCPClient(
    lambda: streamablehttp_client(
        mcp_url, headers={"Authorization": f"Bearer {access_token}"}
    )
)

# Strands handles streaming and log messages automatically
with mcp_client:
    agent = Agent(tools=mcp_client.list_tools_sync())
    response = agent("Deploy my-api to staging")
    print(response)