> For the complete documentation index, see [llms.txt](https://knowledgebase.fabricdata.com/insights/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://knowledgebase.fabricdata.com/insights/origin-insights-mcp/mcp-access.md).

# MCP access

There are three ways to connect Origin Insights MCP. The full guide is at [download.fabric-mcp.link](https://download.fabric-mcp.link/).

| **Endpoint**       | [https://insights.fabric-mcp.link](https://insights.fabric-mcp.link/) |
| ------------------ | --------------------------------------------------------------------- |
| **Suggested name** | Origin Insights                                                       |

## Option 1 — Claude Web (Connector) · recommended

The fastest way. No install, directly in Claude's web UI.

1. Go to [claude.ai](https://claude.ai/).
2. Your profile → **Settings → Connectors**.
3. **Add custom connector**.
4. Enter the **Name** (`Origin Insights`) and paste the **URL** `https://insights.fabric-mcp.link`, then save.

A browser window opens — sign in and grant access to finish the setup.

## Option 2 — Claude Desktop (Installer) · quick setup

An installer sets up the connection automatically, no file editing required.

| **Installer** | [download.fabric-mcp.link](https://download.fabric-mcp.link/) |
| ------------- | ------------------------------------------------------------- |
| **Platforms** | macOS and Windows                                             |
| **Requires**  | Claude Desktop                                                |

{% tabs %}
{% tab title="macOS" %}

1. Go to download.fabric-mcp.link and click **Download for macOS**.
2. Run the installer — it only updates the Claude Desktop configuration.
3. Claude Desktop may ask you to sign in — complete it in the browser.
4. In under a minute, you're set. Start any conversation to use Origin Insights.
   {% endtab %}

{% tab title="Windows" %}

1. Go to download.fabric-mcp.link and click **Download for Windows**.
2. If the browser flags the file, **Keep → Keep anyway** (standard browser check).
3. If Windows shows the blue SmartScreen warning, **More info → Run anyway**.
4. If Windows asks to allow network access for Node.js, **Allow** (needed for the MCP connection).
5. Claude Desktop may ask you to sign in — complete it in the browser.
6. In under a minute, you're set.
   {% endtab %}
   {% endtabs %}

## Option 3 — Claude Desktop (manual) · advanced

For restricted environments or anyone who prefers to set things up by hand.

| **Endpoint**         | `https://insights.fabric-mcp.link`                                |
| -------------------- | ----------------------------------------------------------------- |
| **Config (macOS)**   | `~/Library/Application Support/Claude/claude_desktop_config.json` |
| **Config (Windows)** | `%APPDATA%\Claude\claude_desktop_config.json`                     |

```json
{
  "mcpServers": {
    "Origin Insights": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "mcp-remote",
        "https://insights.fabric-mcp.link",
        "--client-name",
        "origin-insights"
      ]
    }
  }
}
```

Restart Claude Desktop. Look for the **hammer icon** at the bottom right — it confirms the connection is active.

## Option 4 — Programmatic access (connect an LLM / server-side)

The methods above use **browser sign-in** and are meant for people using a Claude client. When **your own code** talks to the MCP — an LLM agent, a backend service, a scheduled job — you connect over MCP streamable-HTTP and authenticate with an **OAuth 2.0 Bearer token**.

* **Endpoint:** `https://insights.fabric-mcp.link`
* **Transport:** streamable-HTTP (MCP)
* **Auth:** OAuth 2.0 — send `Authorization: Bearer <token>`

#### OAuth 2.0 endpoints

The server is a standard OAuth 2.0 authorization server (backed by Amazon Cognito). Discovery: `GET https://insights.fabric-mcp.link/.well-known/oauth-authorization-server`

| issuer                                    | `https://insights.fabric-mcp.link/`                |
| ----------------------------------------- | -------------------------------------------------- |
| authorization\_endpoint                   | `https://insights.fabric-mcp.link/oauth/authorize` |
| token\_endpoint                           | `https://insights.fabric-mcp.link/oauth/token`     |
| Supported grant (today)                   | **`authorization_code`** (+ PKCE)                  |
| Machine-to-machine (`client_credentials`) | Not enabled yet — see note below                   |

#### How to get a token today <a href="#how-to-get-a-token-today" id="how-to-get-a-token-today"></a>

The supported flow is **authorization\_code** (interactive). Complete the OAuth sign-in once (via a Claude client, or the `/oauth/authorize` flow) and reuse the resulting **Bearer token** from your backend. Store it in a secrets manager / environment variable — never commit it.

> The token is an OAuth Bearer issued by the server's OAuth layer (Cognito-backed). It expires — refresh it (re-run the OAuth flow or use the refresh token) when you get `401`.

#### Minimal client (Python)

```bash
pip install mcp
```

```python
import asyncio, os
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

URL = "https://insights.fabric-mcp.link/"
TOKEN = os.environ["ORIGIN_MCP_TOKEN"]          # OAuth Bearer — never hardcode

async def main():
    headers = {"Authorization": f"Bearer {TOKEN}"}
    async with streamablehttp_client(URL, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print("tools:", [t.name for t in tools.tools])
            res = await session.call_tool("titles", {"action": "search_titles", "query": "Toy Story"})
            print("".join(c.text for c in res.content if hasattr(c, "text")))

asyncio.run(main())
```

#### LLM agent loop (Python + Amazon Bedrock)

The LLM plans, the MCP executes. Discover tools at runtime, expose them to the model, and relay each tool result back until the model produces its final answer.

```python
import asyncio, os, boto3
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

URL = "https://insights.fabric-mcp.link/"
MODEL = "us.anthropic.claude-haiku-4-5-20251001-v1:0"
br = boto3.client("bedrock-runtime")

async def run(user_prompt):
    headers = {"Authorization": f"Bearer {os.environ['ORIGIN_MCP_TOKEN']}"}
    async with streamablehttp_client(URL, headers=headers) as (r, w, _):
        async with ClientSession(r, w) as s:
            await s.initialize()
            tools = (await s.list_tools()).tools          # don't hardcode names — discover them
            tool_cfg = {"tools": [
                {"toolSpec": {"name": t.name, "description": (t.description or "")[:300],
                              "inputSchema": {"json": t.inputSchema}}} for t in tools[:12]]}
            messages = [{"role": "user", "content": [{"text": user_prompt}]}]
            for _ in range(6):
                out = br.converse(modelId=MODEL, messages=messages, toolConfig=tool_cfg)["output"]["message"]
                messages.append(out)
                uses = [b["toolUse"] for b in out["content"] if "toolUse" in b]
                if not uses:
                    return "".join(b.get("text", "") for b in out["content"])
                results = []
                for tu in uses:
                    res = await s.call_tool(tu["name"], tu["input"])
                    text = "".join(c.text for c in res.content if hasattr(c, "text"))[:3000]
                    results.append({"toolResult": {"toolUseId": tu["toolUseId"], "content": [{"text": text}]}})
                messages.append({"role": "user", "content": results})
            return "Reached max tool rounds."

print(asyncio.run(run("How popular is Toy Story and where can I watch it?")))
```

> **Any LLM works** (OpenAI, Groq, Gemini, …): list the MCP tools, pass them as the model's tool/function schema, and feed `call_tool` results back to the model.

#### Machine-to-machine (`client_credentials`) — coming <a href="#machine-to-machine-client_credentials--coming" id="machine-to-machine-client_credentials--coming"></a>

For fully headless auth (no interactive login, self-refreshing), the server needs a `client_credentials` grant enabled. **This is not available yet.** Once enabled you'll get a `client_id` + `client_secret` + scope and can mint tokens directly:

```bash
# Available only after M2M is enabled on the auth server:
curl -s -X POST "https://auth-insights.fabric-mcp.link/oauth2/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "client_id=<CLIENT_ID>" \
  -d "client_secret=<CLIENT_SECRET>" \
  -d "scope=<RESOURCE_SERVER>/<SCOPE>"
# -> { "access_token": "<token>", "token_type": "Bearer", "expires_in": 3600 }
```

Need M2M access? Contact the Fabric Data team.

#### Notes

* **Discover tools at runtime** with `list_tools()`; names can change — don't hardcode them.
* Keep the tool set passed to the model **bounded** (\~12) for smaller, faster prompts.
* **Report tools** (`reports`, `present`) return a hosted **`report_url`**, not raw HTML.
* `401 / 403` → token expired or invalid; re-authenticate (OAuth) and retry.

## Troubleshooting

<details>

<summary>Origin Insights doesn't appear after setting up the connector</summary>

* Verify the URL is exactly `https://insights.fabric-mcp.link`.
* Make sure you completed the browser login after saving.
* Try removing and re-adding the connector.

</details>

<details>

<summary>Claude Desktop: no connection after the installer</summary>

* Confirm Claude Desktop was closed when you ran the installer, then reopen it.
* Windows: verify Node.js was granted network access.
* Complete any pending login in the browser.

</details>

## Support

For questions or issues, contact the Fabric Data team — see [Support and contact](/insights/support-and-contact.md).

***

> We hope you found this article helpful. If you have a question this article doesn't address, reach out on the [Service Desk](https://fabric.atlassian.net/servicedesk/customer/portal/336).