Listar plantillas de recursos en una AgentCore puerta de enlace
Para enumerar todas las plantillas de recursos disponibles que proporciona una AgentCore puerta de enlace, realice una solicitud POST al punto final MCP de la puerta de enlace y especifique resources/templates/list el método en el cuerpo de la solicitud:
POST /mcp HTTP/1.1
Host: ${GatewayEndpoint}
Content-Type: application/json
Authorization: ${Authorization header}
${RequestBody}
Reemplace los siguientes valores:
-
${GatewayEndpoint}— La URL de la puerta de enlace, tal como se proporciona en la respuesta de la CreateGatewayAPI.
-
${Authorization header}— Las credenciales de autorización del proveedor de identidad al configurar la autorización entrante.
-
${RequestBody}— La carga útil JSON del cuerpo de la solicitud, tal como se especifica en las plantillas de recursos del Model Context Protocol (MCP). Incluir resources/templates/list como. method
La respuesta devuelve una lista de las plantillas de recursos disponibles con sus plantillas de URI, nombres, descripciones y tipos de MIME.
Las plantillas de recursos utilizan plantillas URI del RFC 6570 para describir los recursos parametrizados. Los clientes pueden rellenar los parámetros de la plantilla para crear URIs de recursos concretos para utilizarlos con ellos. resources/read Por ejemplo, una plantilla se users://{user_id}/profile puede ampliar ausers://123/profile.
Ejemplos de código para enumerar plantillas de recursos
Para ver ejemplos de cómo enumerar las plantillas de recursos disponibles en la puerta de enlace, seleccione uno de los siguientes métodos:
ejemplo
- Python requests package
-
-
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
-
-
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
-
-
# 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
-
-
# 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}"))
