Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

3.6 KB
Raw Blame
---
title: Reading Resources
sidebarTitle: Resources
description: Access static and templated data sources from MCP servers.
icon: folder-open
---

import { VersionBadge } from '/snippets/version-badge.mdx'

<VersionBadge version="2.0.0" />

Use this when you need to read data from server-exposed resources like configuration files, generated content, or external data sources.

Resources are data sources exposed by MCP servers. They can be static files with fixed content, or dynamic templates that generate content based on parameters in the URI.

## Reading Resources

Read a resource using its URI:

```python
async with client:
    content = await client.read_resource("file:///path/to/README.md")
    # content -> list[TextResourceContents | BlobResourceContents]

    # Access text content
    if hasattr(content[0], 'text'):
        print(content[0].text)

    # Access binary content
    if hasattr(content[0], 'blob'):
        print(f"Binary data: {len(content[0].blob)} bytes")
```

Resource templates generate content based on URI parameters. The template defines a pattern like `weather://{city}/current`, and you fill in the parameters when reading:

```python
async with client:
    # Read from a resource template
    weather_content = await client.read_resource("weather://london/current")
    print(weather_content[0].text)
```

## Content Types

Resources return different content types depending on what they expose.

Text resources include configuration files, JSON data, and other human-readable content:

```python
async with client:
    content = await client.read_resource("resource://config/settings.json")

    for item in content:
        if hasattr(item, 'text'):
            print(f"Text content: {item.text}")
            print(f"MIME type: {item.mime_type}")
```

Binary resources include images, PDFs, and other non-text data. They arrive as `BlobResourceContents`, whose `blob` field is a base64 **string**, so decode it before writing bytes to disk:

```python
import base64

from mcp_types import BlobResourceContents

async with client:
    content = await client.read_resource("resource://images/logo.png")

    for item in content:
        if isinstance(item, BlobResourceContents):
            data = base64.b64decode(item.blob)
            print(f"Binary content: {len(data)} bytes")
            print(f"MIME type: {item.mime_type}")

            # Save to file
            with open("downloaded_logo.png", "wb") as f:
                f.write(data)
```

## Multi-Server Clients

When using multi-server clients, the server name is inserted after the URI scheme, so `weather://icons/sunny` on the `weather` server becomes `weather://weather/icons/sunny`:

```python
async with client:  # Multi-server client
    weather_icons = await client.read_resource("weather://weather/icons/sunny")
    templates = await client.read_resource("resource://assistant/templates/list")
```

## Version Selection

<VersionBadge version="3.0.0" />

When a server exposes multiple versions of a resource, you can request a specific version:

```python
async with client:
    # Read the highest version (default)
    content = await client.read_resource("data://config")

    # Read a specific version
    content_v1 = await client.read_resource("data://config", version="1.0")
```

See [Version Discovery](/servers/versioning#version-discovery) for how to discover available versions.

## Raw Protocol Access

For complete control, use `read_resource_mcp()` which returns the full MCP protocol object:

```python
async with client:
    result = await client.read_resource_mcp("resource://example")
    # result -> mcp_types.ReadResourceResult
```