# Listar modelos de recursos em um AgentCore gateway
Para listar todos os modelos de recursos disponíveis fornecidos por um AgentCore gateway, faça uma solicitação POST ao endpoint MCP do gateway e especifique `resources/templates/list` como método no corpo da solicitação:
```
POST /mcp HTTP/1.1
Host: ${GatewayEndpoint}
Content-Type: application/json
Authorization: ${Authorization header}
${RequestBody}
```
Substitua os valores a seguir:
+ `${GatewayEndpoint}`— O URL do gateway, conforme fornecido na resposta da [CreateGateway](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreateGateway.html)API.
+ `${Authorization header}`— As credenciais de autorização do provedor de identidade quando você configura a autorização de [entrada](gateway-inbound-auth.md).
+ `${RequestBody}`— A carga JSON do corpo da solicitação, conforme especificado nos [modelos de recursos](https://modelcontextprotocol.io/specification/2025-06-18/server/resources#resource-templates) no [Model Context Protocol (MCP](https://modelcontextprotocol.io/docs/getting-started/intro)). Incluir `resources/templates/list` como `method` o.
**nota**
Para obter uma lista de parâmetros com suporte opcional para`resources/templates/list`, consulte o `params` objeto no corpo da solicitação em [Recursos](https://modelcontextprotocol.io/specification/2025-06-18/server/resources) na [documentação do Model Context Protocol](https://modelcontextprotocol.io/specification/2025-06-18). Na parte superior da página ao lado da barra de pesquisa, você pode selecionar a versão do MCP cuja documentação você deseja visualizar. Certifique-se de que a versão seja [compatível com o Amazon Bedrock AgentCore](gateway-using.md).
A resposta retorna uma lista de modelos de recursos disponíveis com seus modelos de URI, nomes, descrições e tipos de MIME.
**nota**
Os modelos de recursos usam modelos de URI do RFC 6570 para descrever recursos parametrizados. Os clientes podem preencher os parâmetros do modelo para criar URIs de recursos concretos para uso com`resources/read`. Por exemplo, um modelo `users://{user_id}/profile` pode ser expandido para`users://123/profile`.
## Exemplos de código para listar modelos de recursos
Para ver exemplos de listagem de modelos de recursos disponíveis no gateway, selecione um dos seguintes 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(, )
```
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}"))
```