

# Daftar sumber daya yang tersedia di AgentCore gateway
<a name="gateway-using-mcp-resources-list"></a>

Untuk mencantumkan semua sumber daya yang tersedia yang disediakan AgentCore gateway, buat permintaan POST ke titik akhir MCP gateway dan tentukan `resources/list` sebagai metode di badan permintaan:

```
POST /mcp HTTP/1.1
Host: ${GatewayEndpoint}
Content-Type: application/json
Authorization: ${Authorization header}

${RequestBody}
```

Ganti nilai-nilai berikut:
+  `${GatewayEndpoint}`— URL gateway, seperti yang disediakan dalam respons [CreateGateway](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreateGateway.html)API.
+  `${Authorization header}`[- Kredensi otorisasi dari penyedia identitas saat Anda mengatur otorisasi masuk.](gateway-inbound-auth.md)
+  `${RequestBody}`— Payload JSON dari badan permintaan, sebagaimana ditentukan dalam [Listing resource](https://modelcontextprotocol.io/specification/2025-06-18/server/resources#listing-resources) dalam [Model Context Protocol (MCP](https://modelcontextprotocol.io/docs/getting-started/intro)). Sertakan `resources/list` sebagai`method`.

**catatan**  
Untuk daftar parameter yang didukung secara opsional`resources/list`, lihat `params` objek di badan permintaan di [Resources](https://modelcontextprotocol.io/specification/2025-06-18/server/resources) dalam [dokumentasi Protokol Konteks Model](https://modelcontextprotocol.io/specification/2025-06-18). Di bagian atas halaman di sebelah bilah pencarian, Anda dapat memilih versi MCP yang dokumentasinya ingin Anda lihat. Pastikan versi tersebut [didukung oleh Amazon Bedrock AgentCore](gateway-using.md).

Respons menampilkan daftar sumber daya yang tersedia dengan URI, nama, deskripsi, dan tipe MIME mereka.

**catatan**  
Tidak seperti alat dan prompt, URI sumber daya dikembalikan tanpa awalan nama target. URI asli dari server MCP dikembalikan apa adanya.

**catatan**  
Ketika beberapa target mengekspos URI sumber daya yang sama, gateway mengembalikan sumber daya dari target dengan `resourcePriority` nilai terendah.

**penting**  
URI sumber daya disediakan oleh target server MCP hilir dan tidak divalidasi atau disanitasi oleh gateway. Server MCP yang berbahaya atau dikompromikan dapat mengembalikan URI yang menunjuk ke titik akhir internal (SSRF) atau jalur sistem file lokal (misalnya,). `file:///etc/passwd` Validasi dan sanitasi URI sumber daya sebelum mengikutinya, dan jangan secara otomatis mengambil atau merender URI dari target server MCP yang tidak tepercaya.

## Contoh kode untuk sumber daya daftar
<a name="gateway-using-mcp-resources-list-examples"></a>

Untuk melihat contoh daftar sumber daya yang tersedia di gateway, pilih salah satu metode berikut:

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