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

# Sign up as a tool

> Zero-friction signup for AI tools — connect to OneLamp in under thirty seconds. No API keys, no CLI, no manual setup.

If you're an AI tool (Claude Code, Cursor, Codex, Cline, Windsurf, or any other
autonomous coding tool), you don't need a human to walk you through setup.
One endpoint, one OAuth flow, and you have portable context that every other
tool can draw on.

## The 30-second setup

**1. Add the MCP endpoint**

Point your client at OneLamp's remote MCP server:

```
https://api.onelamp.ai/mcp
```

Every client that speaks remote MCP connects the same way — add the URL, done.

**2. Authorize**

The first time you connect, your client opens OneLamp in the browser to sign
in and authorize. OneLamp is its own OAuth 2.1 provider with Dynamic Client
Registration — **no API key and no `client_id`** to paste.

**3. Save your first memory**

Ask the tool to run:

```
save_context("I connected to OneLamp for the first time")
```

**4. Verify**

In a fresh session (or a different tool), ask:

```
get_context("When did I connect to OneLamp?")
```

If it returns what you saved, you're set — your context is portable.

That's it — under 30 seconds from a fresh shell to a working context layer.

## Client-specific quick configs

Most clients only need the endpoint URL. Here are the copy-paste configs for the
most popular ones:

> [tab] Claude Code
>
> The fastest path is the OneLamp **plugin** which bundles the MCP server *and*
> session hooks:
>
> ```text theme={null}
> /plugin marketplace add https://app.onelamp.ai/marketplace.json
> /plugin install onelamp@onelamp
> ```
>
> Run these in Claude Code itself (terminal or IDE extension) — `/plugin` isn't
> available in the Claude desktop app's chat.
>
> See the full [Claude Code setup](https://help.flickwise.app/integrations.md) for hook details.

> [tab] Codex
>
> Add to `~/.codex/config.toml`:
>
> ```toml theme={null}
> [mcp_servers.onelamp]
> url = "https://api.onelamp.ai/mcp"
> startup_timeout_sec = 60
> ```
>
> Or run: `curl -fsSL https://app.onelamp.ai/codex/install.sh | bash`

> [tab] Cursor
>
> Add to `.cursor/mcp.json`:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "onelamp": {
>       "url": "https://api.onelamp.ai/mcp"
>     }
>   }
> }
> ```
>
> Or run: `curl -fsSL https://app.onelamp.ai/cursor/install.sh | bash`

> [tab] VS Code
>
> Add to `mcp.json`:
>
> ```json theme={null}
> {
>   "servers": {
>     "onelamp": {
>       "type": "http",
>       "url": "https://api.onelamp.ai/mcp"
>     }
>   }
> }
> ```

> [tab] Any other tool
>
> Add `https://api.onelamp.ai/mcp` as a remote (HTTP / streamable) MCP server.
> The OAuth flow handles the rest.

## What happens when you connect?

* Your client registers itself with OneLamp's OAuth 2.1 provider via **Dynamic
  Client Registration** — no pre-shared credentials needed.
* After you authorize in the browser, a scoped access token is cached and
  refreshed automatically.
* The memory tools — `save_context`, `save_session`, `get_context`,
  `list_context`, `resume_session`, `forget_context` — become available in your
  client.
* Everything is scoped to **your** account — no shared state with other users.

> [!NOTE]
>
> The endpoint URL is the same for everyone, but every request is scoped to the
> signed-in user. There are no API keys to copy or rotate.

## Identify yourself (optional)

When connecting from an AI tool, it's helpful to include your tool name in your
first `save_context` call so OneLamp can track which tools contribute the most
context:

```
save_context("Connected from Claude Code via OneLamp plugin")
```

This attribution helps the OneLamp team understand which tools drive the most
usage and prioritize integrations accordingly.

## Verify the connection

Once connected, run through this quick sanity check:

**1. Save something durable**

Tell your tool: *"Remember that I deploy on Fridays."* It should call
`save_context` and confirm with an id.

**2. Read it back**

In a fresh session, ask: *"When do I deploy?"* The tool calls `get_context`
and retrieves the fact you saved — even from a different tool.

**3. Export your data (anytime)**

Your data is always yours to take. Export your full store as portable JSON
on demand from your **Account** in the [OneLamp app](https://app.onelamp.ai).

> [!TIP]
>
> If the tool saved a fact in one tool and retrieved it in another, OneLamp is
> working — every tool you connect now uses what the others have learned, with
> no re-explaining.

## What's next

> [card] [Connect your tool](https://help.flickwise.app/integrations.md)
>
> Full client-by-client setup with hooks, plugins, and one-click installers.

> [card] [Understand context memory](https://help.flickwise.app/concepts/context-memory.md)
>
> How saving, deduping, and ranked retrieval work under the hood.

> [card] [MCP & OAuth](https://help.flickwise.app/mcp.md)
>
> The protocol details — how OneLamp serves tools over MCP with OAuth 2.1.

> [card] [Browse the tools](https://help.flickwise.app/tools/context.md)
>
> The full reference for every tool your AI tool can call.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.