Exemples de code pour lire une ressource Erreurs

Lire une ressource depuis une AgentCore passerelle

Pour lire une ressource spécifique, envoyez une requête POST au point de terminaison MCP de la passerelle et spécifiez resources/read comme méthode dans le corps de la requête et l'URI de la ressource :

Exemple

Note

La passerelle accepte uniquement les versions du protocole MCP répertoriées dans le supportedVersions champ de sa protocolConfiguration.mcp configuration. Pour utiliser la version2026-07-28, assurez-vous que votre passerelle l'supportedVersionsinclut. Vous pouvez modifier les versions prises en charge à l'aide de l'UpdateGatewayAPI.

Remplacez les valeurs suivantes :

${GatewayEndpoint}— L'URL de la passerelle, telle que fournie dans la réponse de l'CreateGatewayAPI.
${Authorization header}— Les informations d'autorisation fournies par le fournisseur d'identité lorsque vous configurez l'autorisation Configurez l'autorisation entrante pour votre passerelle entrante.
${McpProtocolVersion}— La version du protocole MCP pour la demande, telle que2025-11-25. La version doit être prise en charge par votre passerelle.
${ResourceUri}— L'URI de la ressource, correspondant uri à celui du corps de la requête.
${RequestBody}— La charge utile JSON du corps de la requête, telle que spécifiée dans Reading resources in the Model Context Protocol (MCP). Incluez resources/read en tant que ressource method et incluez le. uri Sur la version2026-07-28, incluez également les champs de _meta version dansparams.

La réponse renvoie un contents tableau dans lequel chaque entrée inclut le urimimeType, et soit text (pour le contenu textuel) soit blob (contenu binaire codé en base64).

Note

L'resources/readopération transmet la demande en direct au serveur MCP en aval. L'URI de la ressource est l'URI brut tel que renvoyé par resources/list (pas de préfixe cible).

Note

Lorsque plusieurs cibles exposent le même URI de ressource, la passerelle achemine la demande vers la cible dont la resourcePriority valeur est la plus faible.

Important

Le uri paramètre est transmis à la cible du serveur MCP en aval sans nettoyage. Un URI de ressource fourni par l'utilisateur peut contenir un point de terminaison d'URL malveillant destiné aux attaques SSRF ou tenter de lire les chemins du système de fichiers local (par exemple,). file:///etc/passwd Validez les URI des ressources par rapport à une liste autorisée de schémas et de modèles d'URI attendus avant d'appeler. resources/read Utilisez uniquement les URI renvoyés par resources/list des cibles de serveur MCP fiables.

Exemples de code pour lire une ressource

Pour voir des exemples de lecture d'une ressource depuis la passerelle, sélectionnez l'une des méthodes suivantes :

Exemple

curl (2025-11-25 and earlier)

La requête curl suivante montre un exemple de demande pour lire une ressource avec un URI config://app-settings via une passerelle avec l'IDmygateway-abcdefghij. Définissez l'MCP-Protocol-Versionen-tête sur une version prise en charge par votre passerelle.


curl -X POST \
  https://mygateway-abcdefghij.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp \
  -H "Accept: application/json, text/event-stream" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "MCP-Protocol-Version: 2025-11-25" \
  -d '{
    "jsonrpc": "2.0",
    "id": "read-resource-request",
    "method": "resources/read",
    "params": {
      "uri": "config://app-settings"
    }
}'

curl (2026-07-28)

Dans la version2026-07-28, incluez les en-têtes Mcp-Method Mcp-Name et les métadonnées de demande et les champs de _meta version dans le corps. Pourresources/read, Mcp-Name est la ressourceuri, et l'MCP-Protocol-Versionen-tête doit correspondre_meta.io.modelcontextprotocol/protocolVersion. Votre passerelle supportedVersions doit inclure2026-07-28.


curl -X POST \
  https://mygateway-abcdefghij.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp \
  -H "Accept: application/json, text/event-stream" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "MCP-Protocol-Version: 2026-07-28" \
  -H "Mcp-Method: resources/read" \
  -H "Mcp-Name: config://app-settings" \
  -d '{
    "jsonrpc": "2.0",
    "id": "read-resource-request",
    "method": "resources/read",
    "params": {
      "uri": "config://app-settings",
      "_meta": {
        "io.modelcontextprotocol/protocolVersion": "2026-07-28",
        "io.modelcontextprotocol/clientInfo": {
          "name": "my-agent",
          "version": "1.0.0"
        },
        "io.modelcontextprotocol/clientCapabilities": {}
      }
    }
}'

Python requests package (2025-11-25 and earlier)

Définissez l'MCP-Protocol-Versionen-tête sur une version prise en charge par votre passerelle.


import requests
import json

def read_resource(gateway_url, access_token, resource_uri):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}",
        "MCP-Protocol-Version": "2025-11-25"
    }

    payload = {
        "jsonrpc": "2.0",
        "id": "read-resource-request",
        "method": "resources/read",
        "params": {
            "uri": resource_uri
        }
    }

    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
result = read_resource(
    gateway_url,
    access_token,
    "config://app-settings"  # Replace with the resource URI from resources/list
)
print(json.dumps(result, indent=2))

Python requests package (2026-07-28)


import requests
import json

def read_resource(gateway_url, access_token, resource_uri):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}",
        "MCP-Protocol-Version": "2026-07-28",
        "Mcp-Method": "resources/read",
        "Mcp-Name": resource_uri
    }

    payload = {
        "jsonrpc": "2.0",
        "id": "read-resource-request",
        "method": "resources/read",
        "params": {
            "uri": resource_uri,
            "_meta": {
                "io.modelcontextprotocol/protocolVersion": "2026-07-28",
                "io.modelcontextprotocol/clientInfo": {"name": "my-agent", "version": "1.0.0"},
                "io.modelcontextprotocol/clientCapabilities": {}
            }
        }
    }

    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
result = read_resource(
    gateway_url,
    access_token,
    "config://app-settings"  # Replace with the resource URI from resources/list
)
print(json.dumps(result, indent=2))

MCP Client


from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
from pydantic import AnyUrl
import asyncio

async def execute_mcp(
    url,
    token,
    resource_uri,
    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. Read specific resource
            print(f"Reading resource: {resource_uri}")
            resource_response = await session.read_resource(uri=AnyUrl(resource_uri))
            for content in resource_response.contents:
                print(f"URI: {content.uri}, MIME: {content.mimeType}")
                if hasattr(content, 'text') and content.text:
                    print(f"Text: {content.text}")
                elif hasattr(content, 'blob') and content.blob:
                    print(f"Blob (base64): {content.blob[:100]}...")
            return resource_response

async def main():
    url = "https://${GatewayEndpoint}/mcp"
    token = "your_bearer_token_here"
    resource_uri = "config://app-settings"
    await execute_mcp(
        url=url,
        token=token,
        resource_uri=resource_uri
    )


if __name__ == "__main__":
    asyncio.run(main())

Strands MCP Client

REMARQUE : La prise en charge des ressources du SDK Strands peut varier. Utilisez l'approche MCP Client présentée précédemment pour une resources/read mise en œuvre la plus fiable possible.


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.read_resource_sync(uri="config://app-settings")
        print(result)

run_agent(<MCP URL>, <Access token>)

LangGraph MCP Client

REMARQUE : la prise en charge des ressources de l'adaptateur LangGraph MCP peut varier. Utilisez l'approche MCP Client présentée précédemment pour une resources/read mise en œuvre la plus fiable possible.


import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
from pydantic import AnyUrl

async def read_resource(url, token, resource_uri):
    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.read_resource(uri=AnyUrl(resource_uri))
            for content in response.contents:
                if hasattr(content, 'text') and content.text:
                    print(f"{content.uri}: {content.text}")
                elif hasattr(content, 'blob') and content.blob:
                    print(f"{content.uri}: <blob, {len(content.blob)} chars base64>")

asyncio.run(read_resource(
    "https://${GatewayEndpoint}/mcp",
    "${AccessToken}",
    "config://app-settings"
))

Erreurs

L'resources/readopération peut renvoyer les types d'erreurs suivants :

Erreurs renvoyées dans le cadre du code d'état HTTP :

AuthenticationError

La demande a échoué en raison d'informations d'authentification non valides.

Code d'état HTTP : 401

AuthorizationError

L'appelant n'est pas autorisé à lire la ressource.

Code d'état HTTP : 403

ResourceNotFoundError

L'URI de ressource spécifié n'existe pas ou n'est exposé par aucune cible.

Code d'état HTTP : 404

ValidationError

L'URI fourni est mal formé ou absent.

Code d'état HTTP : 400

InternalServerError

Une erreur interne du serveur s’est produite.

Code d'état HTTP : 500
Erreurs MCP. Pour plus d'informations sur ces types d'erreurs, consultez la section Ressources de la documentation du Model Context Protocol (MCP).

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Liste des ressources de passerelle

Liste des modèles de ressources de passerelle