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 CreateGatewayAPI.
-
${Authorization header}— As credenciais de autorização do provedor de identidade quando você configura a autorização de entrada.
-
${RequestBody}— A carga JSON do corpo da solicitação, conforme especificado nos modelos de recursos no Model Context Protocol (MCP). Incluir resources/templates/list como method o.
A resposta retorna uma lista de modelos de recursos disponíveis com seus modelos de URI, nomes, descrições e tipos de MIME.
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 comresources/read. Por exemplo, um modelo users://{user_id}/profile pode ser expandido parausers://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:
exemplo
- 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}"))
