# Listar plantillas de recursos en una AgentCore puerta de enlace
<a name="gateway-using-mcp-resources-templates-list"></a>

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 [CreateGateway](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreateGateway.html)API.
+  `${Authorization header}`— Las credenciales de autorización del proveedor de identidad al configurar la [autorización entrante](gateway-inbound-auth.md).
+  `${RequestBody}`— La carga útil JSON del cuerpo de la solicitud, tal como se especifica en las [plantillas de recursos](https://modelcontextprotocol.io/specification/2025-06-18/server/resources#resource-templates) del [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro). Incluir `resources/templates/list` como. `method`

**nota**  
Para obtener una lista de los parámetros compatibles opcionalmente`resources/templates/list`, consulte el `params` objeto en el cuerpo de la solicitud en [Recursos](https://modelcontextprotocol.io/specification/2025-06-18/server/resources), en la [documentación del Protocolo de contexto modelo](https://modelcontextprotocol.io/specification/2025-06-18). En la parte superior de la página, junto a la barra de búsqueda, puede seleccionar la versión del MCP cuya documentación desea ver. Asegúrese de que la versión sea [compatible con Amazon Bedrock AgentCore](gateway-using.md).

La respuesta devuelve una lista de las plantillas de recursos disponibles con sus plantillas de URI, nombres, descripciones y tipos de MIME.

**nota**  
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 a`users://123/profile`.

## Ejemplos de código para enumerar plantillas de recursos
<a name="gateway-using-mcp-resources-templates-list-examples"></a>

Para ver ejemplos de cómo enumerar las plantillas de recursos disponibles en la puerta de enlace, seleccione uno de los siguientes métodos:

**Example**  

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))
   ```

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())
   ```

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>)
   ```

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}"))
   ```