# Connect your AI to Claude, Cursor and more

> Give Claude, Cursor, VS Code or any MCP client access to your uare.ai AI in about two minutes.

Your MCP server lets your AI work inside the tools you already use, as you. It's a remote server that speaks the streamable HTTP transport and authenticates with your personal API key:

```text
https://app.uare.ai/api/v1/mcp
```

> [!NOTE]
> This server is for you alone. For people in assistants such as ChatGPT and Claude, uare.ai runs a separate server with no key, the [uare.ai Experts MCP server](/docs/mcp/experts), for the experts it lists. [Two MCP servers](/docs/concepts#two-mcp-servers) compares them.

## 1. Create an API key

1. Open [Settings → API keys](https://app.uare.ai/chat-with-me?settings=api-keys) in uare.ai. Settings also opens with ⌘, on a Mac or Ctrl+, elsewhere.
2. Select **Generate new key** and name it after the client you'll use, for example *Claude Desktop*.
3. Copy the key.

> [!WARNING]
> The key is shown only once. Anyone who has it can use your AI with your private context, so keep it somewhere safe and never commit it.

Keys start with `uare_pk_`. [API keys](/docs/mcp/api-keys) covers revoking and replacing them.

## 2. Add the server to your client

Pick your client. Claude Code, Cursor and VS Code read the key from a `UARE_API_KEY` environment variable or a secure prompt, so it never sits in their config. Claude Desktop needs the key in its config file, so keep that file private.

```bash title="Claude Code"
claude mcp add --transport http uare https://app.uare.ai/api/v1/mcp \
  --header 'Authorization: Bearer ${UARE_API_KEY}'
```

```json title="Cursor"
{
  "mcpServers": {
    "uare": {
      "url": "https://app.uare.ai/api/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${env:UARE_API_KEY}"
      }
    }
  }
}
```

```json title="VS Code"
{
  "inputs": [
    {
      "type": "promptString",
      "id": "uare-api-key",
      "description": "uare.ai API key",
      "password": true
    }
  ],
  "servers": {
    "uare": {
      "type": "http",
      "url": "https://app.uare.ai/api/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${input:uare-api-key}"
      }
    }
  }
}
```

```json title="Claude Desktop"
{
  "mcpServers": {
    "uare": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://app.uare.ai/api/v1/mcp",
        "--header",
        "Authorization: Bearer ${UARE_API_KEY}"
      ],
      "env": {
        "UARE_API_KEY": "uare_pk_your_key_here"
      }
    }
  }
}
```

Where each one goes:

- **Claude Code**: run the command in your terminal. Keep the single quotes: Claude Code stores `${UARE_API_KEY}` itself and reads the variable each time it connects, so `export UARE_API_KEY=uare_pk_...` in the shell you start it from. With double quotes, your shell would write the key into Claude Code's config.
- **Cursor**: `~/.cursor/mcp.json` for every project, or `.cursor/mcp.json` in one project. Cursor reads `${env:UARE_API_KEY}` from the environment it was started in, so a Cursor opened from the Dock won't see a key exported in your shell. In that case, put the key directly in the header and keep the file out of version control.
- **VS Code**: `.vscode/mcp.json` in your workspace. VS Code asks for the key the first time the server starts and stores it securely.
- **Claude Desktop**: Settings, then **Developer**, then **Edit Config**. Restart Claude Desktop after saving. Claude Desktop connects through [`mcp-remote`](https://www.npmjs.com/package/mcp-remote), which needs Node.js. On Windows, see below.

### Claude Desktop on Windows

On Windows, Claude Desktop doesn't escape the spaces inside `args` when it starts `npx`, so mcp-remote gets the `Authorization` header in pieces. mcp-remote's own workaround is a header argument with no spaces, with the whole value, `Bearer` included, in the environment variable:

```json
{
  "mcpServers": {
    "uare": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://app.uare.ai/api/v1/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer uare_pk_your_key_here"
      }
    }
  }
}
```

Keep `Authorization:${AUTH_HEADER}` exactly as it is, with no space after the colon.

> [!TIP]
> When you generate a key in uare.ai, the dialog also offers a ready-to-paste config for Claude Desktop and Cursor with your key filled in. On Windows, change its Claude Desktop header as shown above.

## 3. Try it

Ask your client to use uare, for example:

- "Use uare to draft a LinkedIn post about what we learned launching our beta."
- "Ask my uare AI how it would reply to this email: …"
- "Use uare's decide tool: should I take the offer from A or from B?"
- "Ask uare to find the latest email from my accountant."

The client picks the matching tool: [`generate_post`](/docs/mcp/tools#generate_post), [`respond_as_me`](/docs/mcp/tools#respond_as_me), [`decide`](/docs/mcp/tools#decide) or [`act`](/docs/mcp/tools#act).

## Use the tools from your own code

Your own server can call the tools too, for features only you use, such as a "draft a post in my voice" button in your site's admin. Connect with an MCP SDK and your key. In Node.js, with the official SDK:

```bash
npm install @modelcontextprotocol/sdk
```

```js title="draft-post.mjs"
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({ name: "my-site-admin", version: "1.0.0" });
await client.connect(
  new StreamableHTTPClientTransport(new URL("https://app.uare.ai/api/v1/mcp"), {
    requestInit: { headers: { Authorization: `Bearer ${process.env.UARE_API_KEY}` } },
  }),
);

const result = await client.callTool({
  name: "generate_post",
  arguments: { topic: "What we learned launching our beta", platform: "linkedin" },
});
// generate_post answers with one text block holding its JSON result.
const { post } = JSON.parse(result.content[0].text);
console.log(post);

await client.close();
```

Results come back as JSON in text blocks: one block for a single result, one block per entry for a list such as `list_skills`. The [tools reference](/docs/mcp/tools) lists each tool's fields.

> [!CAUTION]
> Run this on your server, behind your own sign-in. The key acts as you, with your private context: never send it to a browser, and never use these tools to answer your website's visitors. Visitors get the [website widget](/docs/website/quickstart), the [public API](/docs/api/build-your-own) or, in assistants, the [uare.ai Experts MCP server](/docs/mcp/experts).

## Limits

- 120 requests per minute for each key owner, and 600 per minute from one network address before authentication.
- Changes through your connected apps wait for [`confirm_action`](/docs/mcp/tools#confirm_action). A confirmation token works once and expires after about 10 minutes.

## Next steps

- [Tools reference](/docs/mcp/tools): every tool, its parameters and what it returns.
- [Troubleshooting](/docs/mcp/troubleshooting): what each error means and how to fix it.
- [uare.ai Experts MCP server](/docs/mcp/experts): the public server, with no key, through which assistants reach listed experts' AIs as visitors.