# innernet — full context for AI agents > the internet, but yours. innernet is an AI memory layer: one MCP endpoint > (https://innernet.live/api/mcp) that gives every AI tool you use — Claude, > ChatGPT, Cursor, Cline, Zed, and any MCP client — the same living, versioned > memory of your projects and yourself. What makes it different, in one paragraph: notes apps store flat text you maintain by hand, and each AI vendor's built-in memory is locked to that vendor. innernet inverts both — an agent maintains a structured, versioned world model (context maps with dimensions, nodes, commits, and branches), and delivers it platform-agnostically over MCP, so the same memory follows you across every tool. It works for code and for creative/business thinking alike, and it is yours: exportable and deletable on demand, private by default at the database row level. Short manifest: https://innernet.live/llms.txt Site: https://innernet.live · Docs: https://innernet.live/docs Blog/updates: https://innernet.live/company (RSS: https://innernet.live/company/feed.xml) Corpus last revised: 2026-07-17 --- # innernet docs Source: https://innernet.live/docs versioned context for ideas and code — read by every AI you connect. innernet is a **versioned context system** for ideas and code. You save structured context once; every AI you connect reads it live. No copy-paste between sessions, no re-explaining yourself to every new chat. There are two ways in: - **MCP** — connect any MCP-aware client (Claude Code, Claude Desktop, Cursor, ChatGPT, Cline, Zed) to one URL and your context follows you across tools. [Connect an AI →](/docs/connect) - **REST API + SDK** — build apps and agents on the same memory layer: namespaced memories for your own users, branchable versioned context maps, ranked search. [API guide →](/docs/api) ## the shape of it Each **project** is a Context Map: **dimensions** (markdown documents like `vision` or `technical`), **nodes** (structured entities — people, decisions, artifacts), and a **commit log** (append-only history of every change). Branches fork the whole map; merges bring direction back to trunk. On top of the raw stores, each project carries a **capture protocol** — instructions telling the AI *what to save and how*, tuned to this project. A logistics project and a screenplay don't get the same advice. > **Why this shape.** Other tools store flat notes you maintain by hand. innernet separates the maintenance loop (an agent consolidates) from the storage (dimensions + nodes + commits). The AI does the upkeep; you do the thinking. ## where to start - [Get started in two minutes](/docs/getting-started) - [For Developers — memory that versions with your code](/docs/for-developers) - [Connect Claude, Cursor, or ChatGPT](/docs/connect) - [The Context Map model](/docs/concepts) - [Build on the REST API](/docs/api) - [TypeScript SDK](/docs/sdk) - [Every MCP tool, with examples](/docs/mcp-tools) - [How we handle your data](/docs/security) - [Questions & answers](/docs/faq) --- # getting started Source: https://innernet.live/docs/getting-started zero to your first context map in two minutes. Two minutes from zero to your first context map. You'll create an account, connect an AI client, and save your first project. (Building software against the API instead? Skip to the [API quickstart](/docs/api).) ## 1. sign up Visit [innernet.live/signup](/signup). Email magic link is the default; we don't set tracking cookies. ## 2. connect an AI client Point any MCP-aware client at one URL: ```text https://innernet.live/api/mcp ``` On first use the client opens a **browser sign-in (OAuth 2.1)** — you approve once and it holds a scoped token from then on. You never copy a key by hand. Per-client walkthroughs (Claude Code, Claude Desktop, Cursor, ChatGPT, Cline, Zed) are in [Connect an AI](/docs/connect). ## 3. save your first context In any AI conversation, say: ```text Save this conversation to a new innernet project called "my-first-project". ``` The AI calls `innernet_save_context` under the hood. The project appears immediately at [innernet.live/dashboard](/dashboard). ## 4. load it next time Open a brand-new session — any client, any time: ```text Load my-first-project from innernet. ``` The AI lists your projects, loads the map, and reads the project's **capture protocol** — instructions about what kinds of context to keep current going forward. ## 5. optional: your first API call Mint a key at [innernet.live/developers](/developers), then: ```bash curl https://innernet.live/api/v1/projects \ -H "Authorization: Bearer innernet_..." ``` ## next - [Understand the capture protocol](/docs/capture-protocol) - [Dimensions, nodes, commits, branches](/docs/concepts) - [The REST API](/docs/api) --- # questions & answers Source: https://innernet.live/docs/faq the short answers — what innernet is, how it connects, and how it compares. The short answers, in one place. For the longer story, start at [getting started](/docs/getting-started). ## what is innernet? a memory that keeps itself. it watches the work you do across your ai tools, holds the decisions, preferences and context, and hands them back, current, to whatever you open next. ## how does it connect? one endpoint. paste innernet.live/api/mcp into any mcp tool, sign in once, and it reads and writes the same memory. about two minutes, nothing to install. ## which ai tools work today? claude code, claude desktop, chatgpt, cursor, cline, antigravity, and anything else that speaks mcp. a rest api and anchor file cover everything else. ## is my memory private? yes. row-level security means only you can read your rows; tokens are hashed; sensitive fields can be encrypted at rest. nothing is read until you connect a tool and turn it on. ## what happens to my data if i leave? it's yours to take. export everything, delete everything, on demand. ## do i have to change how i work? no. innernet listens where you already think. you keep using your tools exactly as you do, and the memory accumulates on its own. ## what is mcp, and why does innernet use it? mcp (model context protocol) is the open standard ai tools use to talk to external servers — claude, chatgpt, cursor and most modern clients speak it natively. innernet is delivered as one mcp server, which is why a single url connects your memory to every tool at once instead of needing a plugin per app. ## what is a context map? each project in innernet is a context map: dimensions (markdown documents like vision or technical), nodes (structured entities — people, decisions, artifacts), and an append-only commit log. branches fork the whole map so you can hold two directions in tension and merge the one that wins. ## how is innernet different from notion, obsidian, or a notes app? those store flat notes that you maintain by hand. innernet inverts it: an agent maintains a structured, versioned world model for you — consolidating captures, keeping dimensions current, versioning every change. the memory is the artifact, not the notes. ## how is innernet different from claude's or chatgpt's built-in memory? built-in memory is locked to one vendor and can't be exported, branched, or read by your other tools. innernet is platform-agnostic: the same memory is read live by claude, chatgpt, cursor, and any mcp client — and it's yours to export or delete at any time. ## does innernet only work for code? no. context maps are free-form — a brand, a screenplay, a company, a research thread all get their own shape. it works for creative and business thinking as much as engineering. ## can i import my existing chatgpt or claude history? yes. innernet imports your scattered claude and chatgpt memory and organizes it into a hierarchical project tree — that first import is usually the moment it clicks. ## can i build my own product on innernet? yes. a rest api and typescript sdk expose the same memory layer for your own apps and agents: namespaced memories per end-user, versioned context maps, and ranked search. keys are minted at innernet.live/developers. ## still curious? - [Get started in two minutes](/docs/getting-started) - [Connect Claude, Cursor, or ChatGPT](/docs/connect) - [How we handle your data](/docs/security) - Or just ask: [connect@innernet.live](mailto:connect@innernet.live) --- # for developers Source: https://innernet.live/docs/for-developers memory that versions with your code. Connect once — it just works. **Memory that versions with your code.** innernet rides along on the work you already do — every commit captured, every push consolidated — so the context behind your codebase never goes stale. Connect once, and it follows the project. > **git for thinking.** Your code is already versioned, branchable, and shared on clone. Your *context* — the why behind a decision, the shape of the architecture, the thread you were mid-pull on — isn't. innernet gives that the same treatment: versioned, branchable, and inherited by every teammate and every AI that opens the repo. ## connect once One command links the repo to its memory. It installs the git hooks and writes the MCP config, then steps out of the way: ```bash npx innernet connect ``` That's the whole setup. `connect` links this repository to an innernet project, drops a committed `.innernet` anchor at the root, installs the post-commit / pre-push hooks, and registers the hosted MCP endpoint with whatever AI clients it finds. From then on, innernet follows the project — across machines, across sessions, across tools. ## ambient on git You don't run innernet. It runs *on your commits.* - **Every commit is captured.** The post-commit hook lands the diff context and message as a fast capture — no prompt, no friction, no flow broken. - **Every push consolidates.** The pre-push hook folds the captures since the last push into the project's dimensions — at the right frequency, not on every keystroke and not so rarely it forgets. The two-loop rhythm matches how you actually work: capture is cheap and immediate, consolidation is careful and batched. Memory that rides on git means the record stays current *because* you're shipping, not in spite of it. > Nothing to remember to do. The moments you'd normally lose — *why did we drop that dependency, what was the migration plan, who owns this service* — get written down as a side effect of the commits you were making anyway. ## MCP-native innernet speaks **MCP** (Model Context Protocol). Every MCP-aware editor reads the same project memory live — **Claude Code, Cursor, Cline, Zed**, and anything else that speaks the protocol. One endpoint, one config: ```text https://innernet.live/api/mcp ``` Drop this into any client's MCP config: ```json { "mcpServers": { "innernet": { "url": "https://innernet.live/api/mcp", "transport": "http" } } } ``` `npx innernet connect` writes that for you. Or wire it by hand — Claude Code is a one-liner: ```bash claude mcp add --transport http innernet https://innernet.live/api/mcp ``` On first use the client opens a **browser sign-in (OAuth 2.1)**; you approve once and it holds a scoped token from then on. You never paste a key into a chat. Per-client walkthroughs live in [Connect an AI](/docs/connect). ## the `.innernet` anchor `connect` commits a small `.innernet` file to the repo root. That file is the tie between *this codebase* and *its memory* — it records the project slug and endpoint, nothing secret. Because it's committed, the link travels with the repo. A teammate clones, runs `npx innernet connect`, and inherits the same context map — same dimensions, same decision log, same branchable history. No onboarding doc to read, no tribal knowledge to transfer. The repo carries its own memory. > One repo, one memory, shared on clone. The context isn't a wiki someone has to maintain on the side — it's part of the project, versioned right alongside the code. ## git for thinking Your context map is versioned the way your code is: - **Commits** — every save and capture is an append-only entry with a message and a trigger. You can read what changed, when, and why. - **Branches** — fork the whole context map to explore a divergent direction — a different architecture, an alternative API shape — without disturbing trunk. Diff it, then merge it back when the direction wins. - **Inherited on clone** — the `.innernet` anchor means new teammates start from the full, current picture instead of an empty mental model. This is the part flat memory tools can't do: two contradictory versions of a design held in tension on purpose, instead of "resolved" by whichever note was written last. ## where to go next - [Connect Claude Code, Cursor, Cline, or Zed](/docs/connect) - [The Context Map model — dimensions, nodes, commits, branches](/docs/concepts) - [Build on the REST API](/docs/api) - [TypeScript SDK](/docs/sdk) - [Mint an API key for CLI & CI](/developers) --- # the context map Source: https://innernet.live/docs/concepts dimensions, nodes, commits, branches — and why memory is structured this way. Every innernet project is a **Context Map** — a structured world model the AI maintains on your behalf. It has four layers. ## dimensions Long-form markdown documents. Free-form, named per project. Common names: `vision`, `product`, `roadmap`, `technical`, `decisions`, `brand`, `voice`. The names are emergent — they reflect what *this* project needs to remember, not a fixed schema. A dimension grows over time. The AI re-reads it on load and re-writes it on save, consolidating new captures into the existing prose rather than appending endlessly. ## nodes Typed structured entities: `person`, `artifact`, `concept`, `decision`, `project`, `stakeholder`. Each has an `id`, a `type`, and a JSON content blob shaped to its type. Nodes are for things that need a stable identity across dimensions — a person referenced in `vision` and again in `stakeholders` is one node, not two strings. ## commits Append-only history. Every save, capture, or branch operation adds a commit with a hash, parent hash, summary, and trigger (`genesis`, `manual`, `sync`, `mcp`, `api`, …). This is what makes innernet *versioned* — you can read what happened, when, and why. Captures land here first: `innernet_capture` (or `POST /v1/projects/{slug}/captures`) appends to the log fast, and the background consolidator folds them into dimensions on the next sync. Two loops: capture is cheap and immediate, consolidation is careful and async. ## branches A fork of the entire Context Map at a commit. Use branches to explore a divergent direction — a different positioning, an alternative architecture — without losing the trunk. `park` archives a branch, `merge` rejoins it. Branching works everywhere: hosted [MCP tools](/docs/mcp-tools#branches-versioned-forkable-context), the [REST API](/docs/api#version-everything-commits-branches) (`POST …/branches`, `…/diff`, `…/merge`), the [SDK](/docs/sdk#versioning-branches-and-commits), and the CLI. > Branches are the thing flat memory stores can't do: two contradictory versions of an idea held in tension on purpose, instead of "resolved" by whichever was written last. ## memories vs. context The [REST API](/docs/api) adds a second, simpler store: **memories** — flat, namespaced records for apps you build (scoped to *your* end-users, agents, and runs). Use memories when you're building a product that needs per-user recall; use the Context Map when the thing being remembered is a project's evolving world model. Both are searchable through one [search endpoint](/docs/api#search-everything). ## personal memory — the Self Map Separate from any project, innernet keeps one **Self Map** per account: atomic facts about *you* (voice, tools, preferences, working style), each carrying a disclosure class — `private · self · trusted · work · public`. Project loads include a disclosure-gated slice so every tool already knows how you work. Private facts never cross MCP. See [Privacy & security](/docs/security). --- # capture protocol Source: https://innernet.live/docs/capture-protocol per-project instructions that tell the AI what to save and what to skip. Each innernet project carries a **capture protocol** — markdown instructions that innernet returns to your AI when it loads the project. The protocol tells the AI *what kinds of context to keep current* and *what to skip*, tuned to this specific project. ## why it exists A logistics planning project and a screenplay should not get the same advice about what to save. A logistics project wants commitments, stakeholders, and risks tracked precisely; it probably doesn't care about prose voice. A screenplay is the opposite. The capture protocol gives the AI project-specific guidance instead of one generic instruction. ## how it works On `innernet_load_project`, the response includes a `capture_protocol` field. The AI reads it once at session start and lets it shape every subsequent `innernet_save_context` and `innernet_capture` call. Default protocols are baked in by project type (`product`, `code`, `brand`, `creative`, `org`). You can override them per project at any time — via the dashboard, or by asking the AI to call `innernet_set_capture_protocol`. ## tuning the protocol After a few sessions you'll notice the AI saving things you don't need, or missing things you do. That's the signal to refine. In any session, say: ```text Update my capture protocol — stop saving design rationale, start saving every commitment with a date. ``` The AI reads the current protocol, edits it, and calls `innernet_set_capture_protocol` to persist it. Future sessions inherit the new behaviour. ## defaults by type Five built-ins ship today: `product`, `code`, `brand`, `creative`, `org`, plus a catch-all for any other type. If you find yourself wanting a new type-default (say, `research`), open an issue with the protocol text you'd propose. --- # connect an AI Source: https://innernet.live/docs/connect one URL, OAuth sign-in, done — wiring for every MCP client. innernet speaks MCP (Model Context Protocol). Anything MCP-aware can read and write your projects with one config line. > **You only ever paste a URL.** Every client below is configured with just the endpoint — `https://innernet.live/api/mcp`. On first use the client opens a **browser sign-in (OAuth 2.1)**; you approve at innernet.live and the client holds a scoped token from then on. You never copy a key by hand, and you should **never paste an API key into an AI chat** — keys are for the CLI and scripts only. ## Claude Code One command: ```bash claude mcp add --transport http innernet https://innernet.live/api/mcp ``` The browser sign-in runs on first tool call. From then on, every `claude` session can load and save your context maps. ## Claude Desktop Open your dashboard's [connections](/?panel=connections) panel, press connect on Claude Desktop, sign in, approve. Manual install: add to `~/Library/Application Support/Claude/claude_desktop_config.json`: ```json { "mcpServers": { "innernet": { "url": "https://innernet.live/api/mcp", "transport": "http" } } } ``` ## Cursor Settings → MCP → Add Server. Paste the URL, let the OAuth sign-in run. Same flow for **Cline**, **Continue**, **Zed**, and any custom MCP client — URL-only config, no key. ## ChatGPT (Deep Research connector) ChatGPT requires a confidential OAuth client. The [connections](/?panel=connections) flow generates one automatically — you'll see `client_id` and `client_secret` exactly once; paste both into ChatGPT's connector setup. ChatGPT drives innernet through its `search` and `fetch` tools, which run real full-text search over your maps. ## protocol notes - Transport: streamable HTTP (single POST endpoint). Protocol revisions `2025-06-18`, `2025-03-26`, and `2024-11-05` are all accepted and negotiated on `initialize`. - **Resources**: every project map is exposed as `innernet://project/{slug}/map` (JSON), and dimensions as `innernet://project/{slug}/dimension/{name}` (markdown). - JSON-RPC batches are accepted. - Rate limit: 240 calls/min per account — far above any real session. ## API keys — CLI & scripts only For non-interactive access (the `innernet` CLI, cron, CI) mint a key at [/developers](/developers) and send it as `Authorization: Bearer innernet_...`. If an AI ever asks you to paste a key into chat to "connect innernet", that's wrong — give it the URL and let OAuth run. ## trouble? ```bash curl https://innernet.live/api/mcp ``` You should get JSON with the tool list. HTML back means the URL is wrong; a 401 means the token is missing or expired (re-run the sign-in). Still stuck? The [status endpoint and error shapes](/docs/api#errors-rate-limits) apply to MCP too. --- # REST API Source: https://innernet.live/docs/api auth, memories, context maps, and search over plain HTTPS. Everything innernet stores is reachable over plain REST at `https://innernet.live/api/v1`. Three resource families: - **Context** — projects → dimensions → captures: the structured world-model innernet maintains. - **Versioning** — commits, branches, diff, merge: fork an idea-space, evolve it in isolation, fold it back. The part no flat memory store can do. - **Memories** — a flat, namespaced store for apps you build: scope rows to *your own* end-users, agents, and runs. Plus ranked full-text **search** across all of it, and the owner's **Self Map** behind disclosure gates. The machine-readable spec lives at [/api/v1/openapi.json](/api/v1/openapi.json). ## authentication Mint an API key at [innernet.live/developers](/developers). Keys are shown **once**, stored hashed, carry `read` and/or `write` scopes, and can be revoked individually (up to 10 active keys). ```bash curl https://innernet.live/api/v1/projects \ -H "Authorization: Bearer innernet_..." ``` OAuth 2.1 access tokens (the ones MCP clients hold) work on every endpoint too. ## add and recall memories ```bash # remember something about one of YOUR users curl -X POST https://innernet.live/api/v1/memories \ -H "Authorization: Bearer innernet_..." \ -H "Content-Type: application/json" \ -d '{ "content": "Prefers concise answers; works in TypeScript.", "user_id": "user_42", "tags": ["preference"] }' # recall them later curl "https://innernet.live/api/v1/memories?user_id=user_42&limit=20" \ -H "Authorization: Bearer innernet_..." ``` `user_id`, `agent_id`, and `run_id` are *your* namespaces — innernet keeps each end-user's memories separate under your account. `metadata` is free-form JSON; `tags` are filterable. ## search everything ```bash curl "https://innernet.live/api/v1/search?q=pricing+decision" \ -H "Authorization: Bearer innernet_..." ``` One query ranks across dimensions, nodes, captures, projects, and memories, returning highlighted snippets with kind + ref so you can fetch the source. Scope to one project with `&project=slug`. ## read and write context ```bash # the full map curl https://innernet.live/api/v1/projects/my-product \ -H "Authorization: Bearer innernet_..." # one dimension curl https://innernet.live/api/v1/projects/my-product/dimensions/roadmap \ -H "Authorization: Bearer innernet_..." # replace it (writes a commit) curl -X PUT https://innernet.live/api/v1/projects/my-product/dimensions/roadmap \ -H "Authorization: Bearer innernet_..." \ -H "Content-Type: application/json" \ -d '{"content": "# Roadmap\n\n- ship v1", "commit_message": "trim roadmap"}' # append a capture (consolidated into dimensions on next sync) curl -X POST https://innernet.live/api/v1/projects/my-product/captures \ -H "Authorization: Bearer innernet_..." \ -H "Content-Type: application/json" \ -d '{"content": "Decided: usage-based pricing.", "tags": ["decision"]}' ``` ## version everything: commits & branches This is the part no other memory API has. Every save and capture is a **commit**; a **branch** forks the whole context map so two versions of an idea can exist at once — then diff and merge when a direction wins. ```bash # history curl https://innernet.live/api/v1/projects/my-product/commits \ -H "Authorization: Bearer innernet_..." # fork the map at its current head curl -X POST https://innernet.live/api/v1/projects/my-product/branches \ -H "Authorization: Bearer innernet_..." -H "Content-Type: application/json" \ -d '{"name": "pricing-experiment", "summary": "what if usage-based?"}' # work on the branch — trunk untouched curl -X PUT https://innernet.live/api/v1/projects/my-product/branches/pricing-experiment/dimensions/pricing \ -H "Authorization: Bearer innernet_..." -H "Content-Type: application/json" \ -d '{"content": "# Pricing\n\nUsage-based, $0.005/1k ops."}' # what changed vs trunk? curl https://innernet.live/api/v1/projects/my-product/branches/pricing-experiment/diff \ -H "Authorization: Bearer innernet_..." # the experiment won — fold it back (records a merge commit, bumps head) curl -X POST https://innernet.live/api/v1/projects/my-product/branches/pricing-experiment/merge \ -H "Authorization: Bearer innernet_..." ``` Not ready to decide? `PATCH` the branch with `{"status": "parked"}` — it's archived with its overlay intact, revivable any time. Merge semantics are branch-wins (same as the CLI); conflict-aware merge is on the roadmap. ## personal memory over the API The account owner's **Self Map** — atomic facts with disclosure classes — is readable and writable with the same key. `private` facts never cross the API, whatever ceiling you ask for. ```bash # facts up to a disclosure ceiling (self | trusted | work | public) curl "https://innernet.live/api/v1/self/facts?max_disclosure=work" \ -H "Authorization: Bearer innernet_..." # queue a fact-candidate (the consolidator distills it on next sync) curl -X POST https://innernet.live/api/v1/self/capture \ -H "Authorization: Bearer innernet_..." -H "Content-Type: application/json" \ -d '{"content": "Prefers dark mode everywhere.", "dimension_hint": "preferences"}' ``` And any project load can carry the owner's context with it — `GET /v1/projects/{slug}?include_self=1` appends a disclosure-gated `personal_context` slice, so an app you build knows *how you work* the moment it loads *what you're working on*. ## errors & rate limits Every error is one shape: ```json { "error": { "code": "not_found", "message": "Project not found: my-product" } } ``` | status | code | meaning | | --- | --- | --- | | 401 | `unauthorized` | Missing/invalid bearer token | | 403 | `insufficient_scope` | Key lacks `read` or `write` | | 404 | `not_found` | Resource doesn't exist (or isn't yours) | | 400 | `invalid_body` / `invalid_query` | Malformed request | | 429 | `rate_limited` | Over 300 req/min — honor `Retry-After` | CORS is open (`Access-Control-Allow-Origin: *`), so browser apps work — but never ship a write-scoped key to a browser; mint a read-only key instead. ## endpoint reference --- # TypeScript SDK Source: https://innernet.live/docs/sdk @innernet/sdk — the typed client for the REST API. `@innernet/sdk` is a zero-dependency typed client for the [REST API](/docs/api). Node 18+, Bun, Deno, edge runtimes — anywhere `fetch` exists. ```bash npm install @innernet/sdk ``` ## quickstart ```ts import { Innernet } from '@innernet/sdk' const innernet = new Innernet({ apiKey: process.env.INNERNET_API_KEY! }) // remember something about one of your users await innernet.memories.add({ content: 'Prefers concise answers; works in TypeScript.', userId: 'user_42', tags: ['preference'], }) // recall before responding const { memories } = await innernet.memories.list({ userId: 'user_42', limit: 20 }) // search the whole graph — context maps AND memories const { results } = await innernet.search('pricing decision') ``` ## context maps ```ts const { projects } = await innernet.projects.list() const map = await innernet.projects.get('my-product') const dim = await innernet.dimensions.get('my-product', 'roadmap') await innernet.dimensions.put('my-product', 'roadmap', { content: '# Roadmap\n\n- ship v1', commitMessage: 'trim roadmap', }) await innernet.captures.create('my-product', { content: 'Decided: usage-based pricing.', tags: ['decision'], }) ``` ## versioning — branches and commits ```ts // fork, work, diff, merge — git for thinking, typed await innernet.branches.create('my-product', { name: 'pricing-experiment', summary: 'what if usage-based?', }) await innernet.branches.putDimension('my-product', 'pricing-experiment', 'pricing', { content: '# Pricing\n\nUsage-based, $0.005/1k ops.', }) const { diff } = await innernet.branches.diff('my-product', 'pricing-experiment') // { dimensions: { added: [], modified: ['pricing'], … }, nodes: { … } } await innernet.branches.merge('my-product', 'pricing-experiment') // branch wins // …or shelve it instead: await innernet.branches.park('my-product', 'pricing-experiment') const { commits } = await innernet.commits.list('my-product') ``` ## personal memory ```ts // disclosure-gated — private never crosses the API const { facts } = await innernet.self.facts({ maxDisclosure: 'work' }) await innernet.self.capture({ content: 'Prefers dark mode everywhere.', dimensionHint: 'preferences', }) // load a project WITH the owner's context attached const map = await innernet.projects.get('my-product', { includeSelf: true }) ``` ## errors Every non-2xx throws `InnernetApiError` with `.status`, `.code`, and `.message`; 429s carry `.retryAfter` (seconds). Idempotent GETs retry once automatically on 429/5xx. ```ts import { InnernetApiError } from '@innernet/sdk' try { await innernet.projects.get('nope') } catch (err) { if (err instanceof InnernetApiError && err.status === 404) { // create it, or move on } } ``` ## in an agent loop The pattern that makes agents feel continuous — recall → act → remember: ```ts async function answer(userId: string, question: string) { const { memories } = await innernet.memories.list({ userId, limit: 20 }) const reply = await llm.complete({ system: `What you know about this user:\n${memories.map(m => '- ' + m.content).join('\n')}`, user: question, }) await innernet.memories.add({ content: `Asked about: ${question}`, userId, runId: crypto.randomUUID() }) return reply } ``` --- # MCP tools Source: https://innernet.live/docs/mcp-tools all 31 hosted tools — context, branches, capture, personal memory, tasks, artifacts. Every tool below is callable by any MCP client connected to `https://innernet.live/api/mcp` (JSON-RPC 2.0, `Authorization: Bearer `). Most users never call them directly — the AI client wraps them. ## context maps | tool | what it does | | --- | --- | | `innernet_list_projects` | List your context maps — slug, name, type, tagline, last update. | | `innernet_load_project` | Load a full map: dimensions, nodes, recent commits, capture protocol, and a disclosure-gated slice of your Self Map. | | `innernet_save_context` | Create/update a project. Upserts dimensions and nodes by name — merge, never wipe. | | `innernet_get_dimension` | Read one dimension's markdown without loading the whole map. | | `innernet_get_capture_protocol` | Read the per-project capture instructions. | | `innernet_set_capture_protocol` | Replace the capture protocol (owner only). | ## branches — versioned, forkable context | tool | what it does | | --- | --- | | `innernet_list_branches` | A project's branches with status and fork-from commits. | | `innernet_branch_new` | Fork the map at its head — the branch gets a full overlay snapshot of dimensions + nodes. | | `innernet_branch_diff` | Added / modified / removed / unchanged, branch vs trunk. | | `innernet_branch_park` | Archive without merging (overlay preserved); `park: false` revives. | | `innernet_branch_merge` | Fold the branch into trunk (branch wins), record a merge commit, bump the head. | ## capture & search | tool | what it does | | --- | --- | | `innernet_capture` | Capture a note/decision/insight. Without `project_slug` the Concierge auto-routes it (project, Personal Memory, both, or discard) — and the raw content is persisted *before* any routing, so a routing failure can never lose it. | | `search` | Ranked full-text search across dimensions, nodes, captures, projects, and memories. (Also drives ChatGPT Deep Research.) | | `fetch` | A project's full content as one markdown blob (ChatGPT Deep Research). | ## personal memory — the Self Map | tool | what it does | | --- | --- | | `innernet_self_capture` | Save a fact-candidate about *you* to the cloud Self queue. | | `innernet_self_status` | Counts: facts, pending candidates, open questions, by dimension/disclosure. | | `innernet_self_facts` | Read facts up to a disclosure ceiling (`private` never crosses MCP). | | `innernet_self_sync` | Run the consolidator over pending candidates now. | | `innernet_triage` | Ask the Concierge where a piece of content belongs without committing (or commit with `commit: true`). | ## tasks | tool | what it does | | --- | --- | | `innernet_task_list` | The project's ordered task board. | | `innernet_task_create` | Add a task. | | `innernet_task_update` | Update fields/status. | | `innernet_task_complete` | Mark done. | | `innernet_task_reorder` | Reorder the board. | ## artifacts — live documents | tool | what it does | | --- | --- | | `innernet_artifact_start` | Open a living document for a research/build session. | | `innernet_artifact_append` | Land a raw fragment (fast). The fold into the document runs server-side after the response. | | `innernet_artifact_status` | Active artifact + pending fragment count. | | `innernet_artifact_read` | Read the current document. | | `innernet_artifact_list` | All artifacts in a project. | | `innernet_artifact_stop` | Final fold, then mark done. | ## ambient | tool | what it does | | --- | --- | | `innernet_ambient` | The off-switch (and tuning surface) for ambient behaviour — session recognition, auto-artifacts, task nudges. | ## protocol - Revisions `2025-06-18` / `2025-03-26` / `2024-11-05`, negotiated on `initialize`. - **Resources**: `innernet://project/{slug}/map` (JSON) and `innernet://project/{slug}/dimension/{name}` (markdown), listed via `resources/list`. - JSON-RPC batch requests accepted. Rate limit 240 calls/min/account. - Prefer the REST API for scripted access — that's what it's for. MCP is for AI clients. --- # privacy & security Source: https://innernet.live/docs/security rls everywhere, hashed credentials, optional encryption at rest, full export/delete. Memory is intimate data. The defensive posture is documented in three places: [/privacy](/privacy) (policy), [/terms](/terms), and the public [security policy](https://github.com/your-innernet/.github/blob/main/SECURITY.md) on GitHub — how to report, what's in scope, and the platform posture. ## the short version - **Row-level security on every table.** Cross-user reads are rejected at the database, not just the application. - **Credentials hashed at rest.** OAuth access/refresh tokens and API keys are stored as SHA-256 hashes — a DB dump does not produce usable credentials. API keys are shown once at creation and never again. - **Service-role behind the auth gate.** The MCP and REST routes validate your bearer token application-side, then use a server-only key to call locked-down RPCs. The public anon key cannot read or write your data. - **Refresh-token rotation with replay refusal.** Refresh tokens are single-use (with a 60-second retry grace); replays outside the window are refused. - **Disclosure classes on Personal Memory.** Every Self fact carries `private · self · trusted · work · public`. `private` never crosses MCP or the API; project loads only ever include the trusted/work/public slice. - **Optional encryption at rest** for dimensions, per project, with a passphrase only you hold. We cannot read encrypted content — and if you lose the passphrase, neither can you. We say so before you enable it. - **Audit log** of privileged events on your account. You can read your own log; we cannot edit it. - **Export and delete** are one-click from [/account](/account). Deletion is immediate and irreversible; backups purge within 30 days. ## what we don't promise - **End-to-end encryption through the AI's context window.** Once your AI client reads a dimension, the content is in the AI provider's process and possibly their logs. We document this; we can't prevent it. - **Tamper-evident commits.** The commit log is append-only by convention; commits aren't signed today. - **Multi-region failover.** Single region for now. ## reporting a vulnerability Email [yours@innernet.live](mailto:yours@innernet.live?subject=security) with "security" in the subject — the full policy lives in the org's [SECURITY.md](https://github.com/your-innernet/.github/blob/main/SECURITY.md). We triage within 72 hours.