> 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).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://knowledgebase.fabricdata.com/insights/origin-insights-mcp/mcp-access.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.