# Répertorier les ressources disponibles dans une AgentCore passerelle
<a name="gateway-using-mcp-resources-list"></a>

Pour répertorier toutes les ressources disponibles fournies par une AgentCore passerelle, envoyez une requête POST au point de terminaison MCP de la passerelle et spécifiez `resources/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'[CreateGateway](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreateGateway.html)API.
+  `${Authorization header}`— Les informations d'autorisation fournies par le fournisseur d'identité lorsque vous configurez l'[autorisation entrante](gateway-inbound-auth.md).
+  `${RequestBody}`— La charge utile JSON du corps de la requête, telle que spécifiée dans la section [Liste des ressources](https://modelcontextprotocol.io/specification/2025-06-18/server/resources#listing-resources) dans le [Model Context Protocol (MCP](https://modelcontextprotocol.io/docs/getting-started/intro)). Inclure `resources/list` en tant que`method`.

**Note**  
Pour obtenir la liste des paramètres éventuellement pris en charge pour`resources/list`, consultez l'`params`objet dans le corps de la demande dans la section [Ressources](https://modelcontextprotocol.io/specification/2025-06-18/server/resources) de la [documentation du protocole Model Context](https://modelcontextprotocol.io/specification/2025-06-18). 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](gateway-using.md).

La réponse renvoie une liste des ressources disponibles avec leurs URI, leurs noms, leurs descriptions et leurs types MIME.

**Note**  
Contrairement aux outils et aux invites, les URI des ressources sont renvoyées sans préfixe de nom de cible. L'URI d'origine du serveur MCP est renvoyé tel quel.

**Note**  
Lorsque plusieurs cibles exposent le même URI de ressource, la passerelle renvoie la ressource de la cible avec la `resourcePriority` valeur la plus faible.

**Important**  
Les URI des ressources sont fournis par le serveur MCP cible en aval et ne sont ni validés ni nettoyés par la passerelle. Un serveur MCP malveillant ou compromis peut renvoyer des URI pointant vers des points de terminaison internes (SSRF) ou des chemins de systèmes de fichiers locaux (par exemple,). `file:///etc/passwd` Validez et nettoyez les URI des ressources avant de les suivre, et ne récupérez ni ne restituez automatiquement les URI provenant de cibles de serveurs MCP non fiables.

## Exemples de code pour répertorier les ressources
<a name="gateway-using-mcp-resources-list-examples"></a>

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

**Example**  

1. 

   ```
   import requests
   import json
   
   def list_resources(gateway_url, access_token):
       headers = {
           "Content-Type": "application/json",
           "Authorization": f"Bearer {access_token}"
       }
   
       payload = {
           "jsonrpc": "2.0",
           "id": "list-resources-request",
           "method": "resources/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
   resources = list_resources(gateway_url, access_token)
   print(json.dumps(resources, 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 resources
               print("Listing resources...")
               cursor = True
               resources = []
               while cursor:
                   next_cursor = cursor
                   if isinstance(cursor, bool):
                       next_cursor = None
                   list_resources_response = await session.list_resources(next_cursor)
                   resources.extend(list_resources_response.resources)
                   cursor = list_resources_response.nextCursor
   
               if resources:
                   for resource in resources:
                       print(f"{resource.uri} - {resource.name} ({resource.mimeType})")
               print(f"Total resources: {len(resources)}")
   
   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 support may vary. Use the MCP Client approach
   # above for the most reliable resources/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_resources_sync()
           print(f"Found the following resources: {[r.uri for r in result.resources]}")
   
   run_agent(<MCP URL>, <Access token>)
   ```

1. 

   ```
   # NOTE: LangGraph MCP adapter resource support may vary. Use the MCP Client
   # approach above for the most reliable resources/list implementation.
   
   import asyncio
   from mcp import ClientSession
   from mcp.client.streamable_http import streamablehttp_client
   
   async def list_resources(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_resources()
               for resource in response.resources:
                   print(f"{resource.uri} - {resource.name}")
   
   asyncio.run(list_resources("https://${GatewayEndpoint}/mcp", "${AccessToken}"))
   ```