View a markdown version of this page

Répertorier les modèles de ressources dans une AgentCore passerelle - Amazon Bedrock AgentCore
Exemples de code pour répertorier les modèles de ressources

Répertorier les modèles de ressources dans une AgentCore passerelle

Pour répertorier tous les modèles de ressources disponibles fournis par une AgentCore passerelle, envoyez une requête POST au point de terminaison MCP de la passerelle et spécifiez resources/templates/list comme méthode dans le corps de la demande :

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

${RequestBody}

Remplacez les valeurs suivantes :

  • ${GatewayEndpoint}— L'URL de la passerelle, telle que fournie dans la réponse de l'CreateGatewayAPI.

  • ${Authorization header}— Les informations d'autorisation fournies par le fournisseur d'identité lorsque vous configurez l'autorisation entrante.

  • ${RequestBody}— La charge utile JSON du corps de la requête, telle que spécifiée dans les modèles de ressources du Model Context Protocol (MCP). Inclure resources/templates/list en tant quemethod.

Note

Pour obtenir la liste des paramètres éventuellement pris en charge pourresources/templates/list, consultez l'paramsobjet dans le corps de la demande dans la section Ressources de la documentation du protocole Model Context. En haut de la page, à côté de la barre de recherche, vous pouvez sélectionner la version de MCP dont vous souhaitez consulter la documentation. Assurez-vous que la version est prise en charge par Amazon Bedrock AgentCore.

La réponse renvoie une liste des modèles de ressources disponibles avec leurs modèles d'URI, leurs noms, leurs descriptions et leurs types MIME.

Note

Les modèles de ressources utilisent les modèles d'URI RFC 6570 pour décrire les ressources paramétrées. Les clients peuvent renseigner les paramètres du modèle pour créer des URI de ressources concrètes à utiliser avecresources/read. Par exemple, un modèle users://{user_id}/profile peut être étendu àusers://123/profile.

Exemples de code pour répertorier les modèles de ressources

Pour voir des exemples de liste des modèles de ressources disponibles dans la passerelle, sélectionnez l'une des méthodes suivantes :

Exemple
Python requests package

  1. import requests
import json

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

    payload = {
        "jsonrpc": "2.0",
        "id": "list-resource-templates-request",
        "method": "resources/templates/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
templates = list_resource_templates(gateway_url, access_token)
print(json.dumps(templates, 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 resource templates
            print("Listing resource templates...")
            cursor = True
            templates = []
            while cursor:
                next_cursor = cursor
                if isinstance(cursor, bool):
                    next_cursor = None
                list_templates_response = await session.list_resource_templates(next_cursor)
                templates.extend(list_templates_response.resourceTemplates)
                cursor = list_templates_response.nextCursor

            if templates:
                for template in templates:
                    print(f"{template.uriTemplate} - {template.name}")
            print(f"Total resource templates: {len(templates)}")

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 template support may vary. Use the MCP Client
# approach above for the most reliable resources/templates/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_resource_templates_sync()
        print(f"Found the following templates: {[t.uriTemplate for t in result.resourceTemplates]}")

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

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

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

async def list_resource_templates(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_resource_templates()
            for template in response.resourceTemplates:
                print(f"{template.uriTemplate} - {template.name}")

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