View a markdown version of this page

List available resources in an AgentCore gateway - Amazon Bedrock AgentCore
Code samples for listing resources

List available resources in an AgentCore gateway

To list all available resources that an AgentCore gateway provides, make a POST request to the gateway’s MCP endpoint and specify resources/list as the method in the request body:

POST /mcp HTTP/1.1
Host: ${GatewayEndpoint}
Content-Type: application/json
Authorization: ${Authorization header}

${RequestBody}

Replace the following values:

Note

For a list of optionally supported parameters for resources/list , see the params object in the request body at Resources in the Model Context Protocol documentation . At the top of the page next to the search bar, you can select the MCP version whose documentation you want to view. Make sure that the version is one supported by Amazon Bedrock AgentCore.

The response returns a list of available resources with their URIs, names, descriptions, and MIME types.

Note

Unlike tools and prompts, resource URIs are returned without a target name prefix. The original URI from the MCP server is returned as-is.

Note

When multiple targets expose the same resource URI, the gateway returns the resource from the target with the lowest resourcePriority value.

Important

Resource URIs are provided by the downstream MCP server target and are not validated or sanitized by the gateway. A malicious or compromised MCP server could return URIs pointing to internal endpoints (SSRF) or local filesystem paths (for example, file:///etc/passwd). Validate and sanitize resource URIs before following them, and do not automatically fetch or render URIs from untrusted MCP server targets.

Code samples for listing resources

To see examples of listing available resources in the gateway, select one of the following methods:

Example
Python requests package

  1. import requests
import json

def list_resources(gateway_url, access_token):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}"
    }

    payload = {
        "jsonrpc": "2.0",
        "id": "list-resources-request",
        "method": "resources/list"
    }

    response = requests.post(gateway_url, headers=headers, json=payload)
    return response.json()

# Example usage
gateway_url = "https://${GatewayEndpoint}/mcp" # Replace with your actual gateway endpoint
access_token = "${AccessToken}" # Replace with your actual access token
resources = list_resources(gateway_url, access_token)
print(json.dumps(resources, indent=2))
MCP Client

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

async def execute_mcp(
    url,
    token,
    headers=None
):
    default_headers = {
        "Authorization": f"Bearer {token}"
    }
    headers = {**default_headers, **(headers or {})}

    async with streamablehttp_client(
       url=url,
       headers=headers,
    ) as (
        read_stream,
        write_stream,
        callA,
    ):
        async with ClientSession(read_stream, write_stream) as session:
            # 1. Perform initialization handshake
            print("Initializing MCP...")
            _init_response = await session.initialize()
            print(f"MCP Server Initialize successful! - {_init_response}")

            # 2. List available resources
            print("Listing resources...")
            cursor = True
            resources = []
            while cursor:
                next_cursor = cursor
                if isinstance(cursor, bool):
                    next_cursor = None
                list_resources_response = await session.list_resources(next_cursor)
                resources.extend(list_resources_response.resources)
                cursor = list_resources_response.nextCursor

            if resources:
                for resource in resources:
                    print(f"{resource.uri} - {resource.name} ({resource.mimeType})")
            print(f"Total resources: {len(resources)}")

async def main():
    url = "https://${GatewayEndpoint}/mcp"
    token = "your_bearer_token_here"

    # Optional additional headers
    additional_headers = {
        "Content-Type": "application/json",
    }

    await execute_mcp(
        url=url,
        token=token,
        headers=additional_headers
    )

# Run the async function
if __name__ == "__main__":
    asyncio.run(main())
Strands MCP Client

  1. # NOTE: Strands SDK resource support may vary. Use the MCP Client approach
# above for the most reliable resources/list implementation.
from strands.tools.mcp.mcp_client import MCPClient
from mcp.client.streamable_http import streamablehttp_client

def create_streamable_http_transport(mcp_url: str, access_token: str):
       return streamablehttp_client(mcp_url, headers={"Authorization": f"Bearer {access_token}"})

def run_agent(mcp_url: str, access_token: str):
    mcp_client = MCPClient(lambda: create_streamable_http_transport(mcp_url, access_token))

    with mcp_client:
        result = mcp_client.list_resources_sync()
        print(f"Found the following resources: {[r.uri for r in result.resources]}")

run_agent(<MCP URL>, <Access token>)
LangGraph MCP Client

  1. # NOTE: LangGraph MCP adapter resource support may vary. Use the MCP Client
# approach above for the most reliable resources/list implementation.

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

async def list_resources(url, token):
    headers = {"Authorization": f"Bearer {token}"}
    async with streamablehttp_client(url=url, headers=headers) as (
        read_stream, write_stream, callA
    ):
        async with ClientSession(read_stream, write_stream) as session:
            await session.initialize()
            response = await session.list_resources()
            for resource in response.resources:
                print(f"{resource.uri} - {resource.name}")

asyncio.run(list_resources("https://${GatewayEndpoint}/mcp", "${AccessToken}"))