> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mcp-use.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Resources

> List and read MCP server resources

Resources are URI-addressed content exposed by MCP servers.

```typescript theme={null}
import { MCPClient } from "@mcp-use/client";

const client = new MCPClient({
  mcpServers: {
    demo: { url: "http://localhost:3000/mcp" },
  },
});

try {
  const connection = await client.connect("demo");

  const { resources } = await connection.listAllResources();
  for (const resource of resources) {
    console.log(resource.uri, resource.name, resource.mimeType);
  }

  const result = await connection.readResource("file:///config.json");
  for (const content of result.contents) {
    if ("text" in content) {
      console.log(content.text);
    }
  }
} finally {
  await client.close();
}
```

Use `listAllResources()` when you want the complete resource list. It follows
pagination cursors for you and returns `{ resources }`.

## Paginate resources

`listResources(cursor?)` returns an envelope with `resources` and an optional
`nextCursor`. Handle the cursor yourself when you want to process one page at a
time:

```typescript theme={null}
import type { MCPConnection } from "@mcp-use/client";

async function logResourcePages(connection: MCPConnection): Promise<void> {
  let cursor: string | undefined;

  do {
    const page = await connection.listResources(cursor);
    for (const resource of page.resources) {
      console.log(resource.uri);
    }
    cursor = page.nextCursor;
  } while (cursor);
}
```

## Resource templates

Parameterized URIs such as `db://users/{id}` are discovered with
`listResourceTemplates()`. Its result contains `resourceTemplates` and may
contain `nextCursor`. The current `MCPConnection` method retrieves the first
template page and does not accept a cursor argument.

```typescript theme={null}
const page = await connection.listResourceTemplates();

for (const template of page.resourceTemplates) {
  console.log(template.uriTemplate, template.name);
}
```

Resolve a template to a concrete URI in your application, then pass that URI to
`readResource(uri)`.

## Subscribe to updates

If the server supports resource subscriptions, subscribe and unsubscribe with
the same concrete URI:

```typescript theme={null}
await connection.subscribeToResource("file:///config.json");

// Receive notifications/resources/updated through your notification handler.

await connection.unsubscribeFromResource("file:///config.json");
```

## React

`useMcpServer` exposes the resource contents envelope returned by
`readResource(uri)`:

```tsx theme={null}
import { useMcpServer } from "@mcp-use/client/react";

export function ReadResourceButton({ uri }: { uri: string }) {
  const server = useMcpServer("demo");

  async function handleRead() {
    if (server?.state !== "ready") return;

    const { contents } = await server.readResource(uri);
    console.log(contents);
  }

  return (
    <button disabled={server?.state !== "ready"} onClick={handleRead}>
      Read resource
    </button>
  );
}
```

## Reference

[`MCPConnection`](https://mcp-use-typescript-api-reference.vercel.app/modules/_mcp-use_client.index.html#mcpconnection) —
`listResources`, `listAllResources`, `listResourceTemplates`, `readResource`,
`subscribeToResource`, and `unsubscribeFromResource`.