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

# Room MCP

> Programmatically list a room's workflows and feature views, and download their data.

**Room MCP** gives you programmatic access to the contents of a [room](/concepts/rooms). Unlike [Agent MCP](/integrations/mcp-api-integration) — which talks to a single deployed agent — Room MCP lets you enumerate a room's **workflows** and their **feature views**, then download the underlying data as Parquet.

This is ideal for pulling Corvic-processed data into your own data stack, notebooks, or downstream pipelines.

## Endpoint and credentials

|             | Value                                  |
| ----------- | -------------------------------------- |
| **MCP URL** | `https://api.corvic.live/mcp/`         |
| **Auth**    | `Authorization: Bearer <ACCESS_TOKEN>` |
| **Room ID** | The numeric ID of the target room      |

<Warning>
  Never hard-code your access token. Load it from an environment variable or secrets manager, and keep it out of source control.
</Warning>

## Room MCP tools

| Tool                 | Description                                                           |
| -------------------- | --------------------------------------------------------------------- |
| `list_data_apps`     | List the workflows in a room (paginated).                             |
| `list_feature_views` | List a workflow's feature views; each entry includes a Parquet `url`. |

<Note>
  In the API, workflows are identified as **data apps** (`list_data_apps`, `data_app_id`). These map to the [Workflows](/features/workflows) you build on the canvas.
</Note>

## Prerequisites

Install the MCP and HTTP client libraries:

```bash theme={null}
pip install mcp httpx
```

## Example

This script connects to Room MCP, lists the workflows in a room, lists a workflow's feature views, and downloads a feature view's Parquet payload.

```python theme={null}
import asyncio

import httpx
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client

MCP_URL = "https://api.corvic.live/mcp/"
ACCESS_TOKEN = "<YOUR_ACCESS_TOKEN>"  # load from env/secrets, do not hard-code
ROOM_ID = "<YOUR_ROOM_ID>"


async def run():
    headers = {"Authorization": f"Bearer {ACCESS_TOKEN}"}

    async with (
        httpx.AsyncClient(
            headers=headers,
            follow_redirects=True,
        ) as httpx_client,
        streamable_http_client(MCP_URL, http_client=httpx_client) as (read, write, _),
    ):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # 1. List the workflows (data apps) in this room (paginated).
            data_apps = await session.call_tool(
                "list_data_apps",
                arguments={"room_id": ROOM_ID, "entries_per_page": 5, "cursor": None},
            )
            print(data_apps.content[0].text)

            # 2. Pick a data_app_id from the response above, then list its
            #    feature views. Each entry includes a parquet `url`.
            # data_app_id = "<DATA_APP_ID>"
            # feature_views = await session.call_tool(
            #     "list_feature_views",
            #     arguments={"data_app_id": data_app_id, "entries_per_page": 5, "cursor": None},
            # )
            # print(feature_views.content[0].text)

            # 3. Download a feature view's parquet payload using the same
            #    Bearer token the MCP server accepts.
            # parquet_bytes = (await httpx_client.get(feature_view_url)).content


asyncio.run(run())
```

## How it works

<Steps>
  <Step title="Connect">
    Open a `streamable_http_client` to the MCP URL with your Bearer token, then start a `ClientSession` and call `initialize()`.
  </Step>

  <Step title="List workflows">
    Call `list_data_apps` with the `room_id` (paginate with `entries_per_page` and `cursor`).
  </Step>

  <Step title="List feature views">
    Pick a `data_app_id` from the result and call `list_feature_views`. Each feature view includes a Parquet `url`.
  </Step>

  <Step title="Download the data">
    Fetch the feature view's `url` with the same authenticated HTTP client to get the raw Parquet bytes.
  </Step>
</Steps>

## Related

<CardGroup cols={2}>
  <Card title="MCP Overview" icon="diagram-project" href="/integrations/mcp-overview">
    Agent vs. room access and credentials.
  </Card>

  <Card title="Agent MCP" icon="robot" href="/integrations/mcp-api-integration">
    Talk to a deployed agent instead.
  </Card>

  <Card title="Workflows" icon="window" href="/features/workflows">
    Build the pipelines exposed here.
  </Card>

  <Card title="Corvic Tables" icon="eye" href="/concepts/feature-views">
    Understand feature views and tables.
  </Card>
</CardGroup>