# Receive progress notifications from your AgentCore gateway
<a name="gateway-mcp-progress"></a>

Progress notifications allow MCP server targets to report incremental progress on long-running tool calls. When a tool call takes time to complete, the server can send `notifications/progress` events to keep the client informed about the operation’s status. AgentCore Gateway forwards these notifications from MCP server targets to your client as Server-Sent Events (SSE) chunks.

## Prerequisites
<a name="gateway-mcp-progress-prereqs"></a>

To receive progress notifications from your gateway:
+  **Response streaming enabled** — Progress notifications are delivered as SSE chunks during an open connection. Set `streamingConfiguration.enableResponseStreaming` to `true` in your gateway’s `protocolConfiguration.mcp`.
+  **MCP server target type** — Progress notifications originate from MCP server targets.
+  **Client sends `Accept: text/event-stream` header** — The client must request an SSE response to receive streaming events.

## How progress notifications work
<a name="gateway-mcp-progress-how"></a>

When a client makes a `tools/call` request with a `progressToken` in the request parameters, the MCP server target can send `notifications/progress` events during execution. The gateway forwards these events to the client as SSE chunks before the final tool result.

Each progress notification includes:
+  `progressToken` — Matches the token provided in the original request.
+  `progress` — The current progress value (numeric).
+  `total` — Optional total value indicating completion target.
+  `message` — Optional human-readable description of current status.

## Code samples
<a name="gateway-mcp-progress-examples"></a>

**Example**  

1. Call a tool with a progress token:

   ```
   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": "analyzeDataset",
         "arguments": {
           "datasetId": "ds-12345"
         },
         "_meta": {
           "progressToken": "progress-1"
         }
       }
   }'
   ```

   The gateway returns an SSE stream with progress notifications followed by the final result:

   ```
   event: message
   data: {"jsonrpc":"2.0","method":"notifications/progress","params":{"progressToken":"progress-1","progress":1,"total":4,"message":"Loading dataset..."}}
   
   event: message
   data: {"jsonrpc":"2.0","method":"notifications/progress","params":{"progressToken":"progress-1","progress":2,"total":4,"message":"Running analysis..."}}
   
   event: message
   data: {"jsonrpc":"2.0","method":"notifications/progress","params":{"progressToken":"progress-1","progress":3,"total":4,"message":"Generating report..."}}
   
   event: message
   data: {"jsonrpc":"2.0","method":"notifications/progress","params":{"progressToken":"progress-1","progress":4,"total":4,"message":"Complete"}}
   
   event: message
   data: {"jsonrpc":"2.0","id":"tool-call-1","result":{"content":[{"type":"text","text":"Analysis complete. Found 3 anomalies in dataset ds-12345."}]}}
   ```

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 with progress token (streaming response)
   response = requests.post(gateway_url, headers=headers, json={
       "jsonrpc": "2.0",
       "id": "tool-call-1",
       "method": "tools/call",
       "params": {
           "name": "analyzeDataset",
           "arguments": {"datasetId": "ds-12345"},
           "_meta": {"progressToken": "progress-1"}
       }
   }, stream=True)
   
   # Process SSE events
   client = sseclient.SSEClient(response)
   for event in client.events():
       data = json.loads(event.data)
       if data.get("method") == "notifications/progress":
           params = data["params"]
           print(f"Progress: {params['progress']}/{params.get('total', '?')} - {params.get('message', '')}")
       elif "result" in data:
           print(f"Tool result: {data['result']}")
           break
   ```

1. 

   ```
   from mcp import ClientSession
   from mcp.client.streamable_http import streamablehttp_client
   import asyncio
   
   async def progress_handler(progress_token, progress, total, message=None):
       """Handle progress notifications."""
       print(f"[{progress}/{total}] {message or ''}")
   
   async def use_progress(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,
               progress_handler=progress_handler
           ) as session:
               await session.initialize()
   
               # Call tool with progress token - notifications handled by callback
               result = await session.call_tool(
                   name="analyzeDataset",
                   arguments={"datasetId": "ds-12345"}
               )
               print(f"Tool result: {result}")
               return result
   
   asyncio.run(use_progress(
       url="https://mygateway-abcdefghij.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp",
       token="YOUR_ACCESS_TOKEN"
   ))
   ```

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 progress notifications automatically
   with mcp_client:
       agent = Agent(tools=mcp_client.list_tools_sync())
       response = agent("Analyze dataset ds-12345")
       print(response)
   ```