Your Utari persona — like Jeremy AI — lives in your Utari dashboard, but you don't have to leave your favorite tools to talk to it. Utari runs a hosted MCP server for your persona, so any MCP‑compatible app — Claude Code, Cursor, Claude Desktop, or claude.ai on the web — can chat with it as you, with the same memory and the same conversations you see on the web.

What is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI apps connect to outside tools and data. Utari exposes your persona as an MCP server; you connect your client to it with a personal connect token, and from then on your client can talk to your persona.

What you can do once connected

The connection gives your client three tools. You won't usually call these by hand — you just talk to your assistant in plain language and it decides when to use them:

send_message — Start a new conversation with your persona, or continue an existing one (by passing a conversation_id).
get_response — If a reply is still being written when send_message returns, fetch it with the run_id (or conversation_id).
persona_info — Ask which persona you're connected to (its name, community, and runtime).

Who can connect, and who pays

Any member of the instance — and the instance owner — can create a connection.
All usage is billed to the instance owner, exactly like chatting on the web. Members don't need their own billing.
Everything runs through your instance's normal rules — rate limits, budgets, and access controls all still apply.

Before you start

An MCP‑capable client: Claude Code (CLI), Cursor, Claude Desktop, or claude.ai on the web (a plan that supports custom connectors).
Access to your instance's web app (for example https://jeremy.utari.ai), signed in.

Step 1 — Create a connection token

Open your instance's web app and sign in.
Open General Settings (from your avatar / the top bar).
Go to the MCP tab.
Click Create connection, give it a label you'll recognize (e.g. "Claude Code on my laptop"), and confirm.
Copy what you need. You'll be shown:
- a ready‑to‑paste claude mcp add command (for Claude Code),
- a connector URL with the token built in (for claude.ai on the web),
- the raw token and server URL (for any other client).

The token is shown only once. If you lose it, revoke that connection and create a new one — you can't view it again.

Step 2 — Connect your client

Claude Code (CLI)

Paste the command from the dialog, or build it yourself:

claude mcp add --transport http jeremy-ai https://persona-mcp.utari.ai/mcp/ \
  --header "Authorization: Bearer <YOUR_TOKEN>"

Confirm it's connected with claude mcp list, then ask Claude Code to use the jeremy-ai server.

Cursor

Add an HTTP MCP server in Cursor's settings, or in ~/.cursor/mcp.json:

{
  "mcpServers": {
    "jeremy-ai": {
      "url": "https://persona-mcp.utari.ai/mcp/",
      "headers": { "Authorization": "Bearer <YOUR_TOKEN>" }
    }
  }
}

Claude Desktop

Add the same server URL and Authorization: Bearer <YOUR_TOKEN> header to your MCP configuration, then restart Claude Desktop.

claude.ai (web)

claude.ai's "Add custom connector" dialog only has a URL field — there's no place for a header — so the token travels in the URL instead:

Go to Settings → Connectors → Add custom connector.
Name: your persona (e.g. Jeremy AI).
Remote MCP server URL: paste the connector URL from the dialog. It looks like:
```
https://persona-mcp.utari.ai/mcp/?k=<YOUR_TOKEN>
```
Leave the OAuth Client ID/Secret fields blank, and save.

Because your token is part of this URL, treat the whole URL like a password — don't share it or paste it anywhere public.

Step 3 — Talk to your persona

Now just chat. Behind the scenes:

Your first message starts a new conversation.
Follow‑ups continue the same conversation, with full memory of what you've discussed.
If a reply takes a moment, your client fetches it automatically.

Try things like "Draft a follow‑up email to the lead we spoke about yesterday" or "What did we decide about the Q3 campaign?" — your persona answers in character, using everything it knows about you.

Where your conversations live

Every conversation you have over MCP is a real thread in your Utari dashboard:

Open your web app and you'll see the same conversation there.
You can pick it up on the web, or back in your client — it's one shared thread.
Your persona's memory carries across both, exactly like the web chat.

Managing your connections

Back in General Settings → MCP you can:

See every connection, when it was created, and when it was last used.
Revoke any connection — it stops working on its very next call.

Tip: create a separate connection per device or tool, so you can revoke one without disturbing the others.

Security & privacy

Each token is scoped to you and your persona only — it can't read or touch anyone else's conversations.
Revoke anytime; revoked tokens are refused immediately.
If your account is deleted, the token stops working.
Tokens last 90 days — create a fresh one when it expires.
The claude.ai ?k= URL contains your token; keep it private.

Troubleshooting

Every call says "missing Authorization header" / unauthorized: your client isn't sending the token. Header clients need Authorization: Bearer <token>; claude.ai needs the full …/mcp/?k=<token> URL.
"invalid connect token": the token is wrong, expired, or revoked — create a new one.
"conversation not found for this connection": the conversation_id isn't one of your persona's threads.
Payment or rate‑limit errors: usage is billed to the instance owner — a payment error means the owner's account needs attention; a rate‑limit error means you've been going fast, so wait a moment and retry.
claude.ai errors after an update: remove the connector and add it again.

FAQ

Which persona am I connected to? Ask your client to run persona_info, or check the label you gave the connection.

Can I connect to more than one persona? Yes — add one connector (one token) per persona.

Do I need my own API key or billing? No. Usage is billed to the instance owner, just like the web app.

Connect Claude Code, Cursor, or claude.ai to your Utari persona (MCP)