View a markdown version of this page

Recevez des messages de journalisation depuis votre AgentCore passerelle - Amazon Bedrock AgentCore
Conditions préalablesNiveaux de journalisation.Comment fonctionne la journalisation des messagesExemples de code

Recevez des messages de journalisation depuis votre AgentCore passerelle

Les cibles du serveur MCP peuvent envoyer des messages de journal aux clients lors de l'exécution de l'outil à l'aide de notifications/message cette méthode. Ces messages fournissent une visibilité en temps réel de ce que fait le serveur, ce qui est utile pour le débogage, l'audit et le suivi du comportement des outils. AgentCore Gateway transmet ces notifications de journal des cibles du serveur MCP à votre client sous forme de fragments d' Server-Sent événements (SSE).

Conditions préalables

Pour recevoir des messages de journalisation depuis votre passerelle :

  • Streaming de réponses activé — Les messages du journal sont envoyés sous forme de fragments SSE lors d'une connexion ouverte. streamingConfiguration.enableResponseStreamingRéglez sur true celui de votre passerelleprotocolConfiguration.mcp.

  • Type de cible du serveur MCP — Les messages du journal proviennent des cibles du serveur MCP.

  • Le client envoie un Accept: text/event-stream en-tête : le client doit demander une réponse SSE pour recevoir des événements en streaming.

Niveaux de journalisation.

MCP définit les niveaux de log suivants, par ordre croissant de gravité :

Niveau Description

debug

Informations de diagnostic détaillées pour le dépannage.

info

Messages d'information généraux sur le fonctionnement normal.

notice

Des événements normaux mais significatifs.

warning

Situations potentiellement dangereuses qui n'empêchent pas le fonctionnement.

error

Conditions d'erreur qui ont empêché une opération spécifique.

critical

Conditions critiques nécessitant une attention immédiate.

alert

Des mesures doivent être prises immédiatement.

emergency

Le système est inutilisable.

Comment fonctionne la journalisation des messages

Lorsqu'une cible de serveur MCP émet un message notifications/message pendant l'exécution de l'outil, la passerelle le transmet au client sous la forme d'un événement SSE. Chaque message de journal inclut :

  • level— Le niveau de gravité du message.

  • logger— Nom facultatif identifiant le composant source.

  • data— Le contenu du journal (chaîne ou objet structuré).

Les messages du journal sont informatifs et ne nécessitent aucune réponse de la part du client. Ils sont fournis parallèlement à d'autres événements SSE tels que les notifications de progression et le résultat final de l'outil.

Exemples de code

Exemple
curl

  1. Appelez un outil et recevez des messages de journal dans le flux SSE :

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

    La passerelle renvoie un flux SSE avec des messages de journal suivis du résultat final :

    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)