# Mimesis

> Mimesis is a personal memory you own that works across every AI you use. You bring your notes and past conversations, decide which facts are true, and give each of your AI assistants a personality you control. Any assistant you connect gets exactly the context you approved — and nothing you didn't. It is a good fit for anyone who uses more than one AI assistant and is tired of re-introducing themselves, and for builders who run their own agents and want a curated, auditable memory instead of one that drifts as it invents facts.

## What it does

- One memory you own, portable across every AI (Claude, ChatGPT, your own agents, anything that speaks MCP).
- You approve what becomes a memory: assistants propose facts; nothing durable is saved until you keep it.
- Per-agent personas: give each assistant its own personality/voice (e.g. a SOUL.md), scoped to that agent only.
- Prompt-aware context: for each task it compiles the few relevant memories that fit the model's context window, and shows what it included, excluded, and why.
- Provenance: raw originals are preserved (SHA-256) before anything is derived, so every memory traces back to its source.
- Private by design: your memory lives in your own store, retrieval runs locally (no data sent to external models/embedding services to work), obvious secrets are refused before storage, and you can export or delete everything at any time.

## How it differs

Mimesis is not a chatbot and not a vector database you query. It is a control layer for personal memory: the human owns the memory and decides what is true, agents can only propose, and every memory is reviewable, explainable, and reversible. It connects to assistants over the Model Context Protocol (MCP), plus an HTTP API and a CLI.

## Pages

- [How it works](https://mimesis.ai/index.html): the problem (every AI forgets you, or remembers wrong) and the four steps — bring what you have, keep what's true, get the right context, share it on your terms.
- [Docs — connect an AI](https://mimesis.ai/docs.html): connect an assistant over MCP, call the HTTP API, use the CLI, and import existing notes.
- [Pricing](https://mimesis.ai/pricing.html): Free (one person, core memory + review), Pro ($12/month — unlimited connected agents, agent personas, guided onboarding interview, all imports), Team ($29/person/month — isolated per-member memory, admin review policy, audit log).
- [Privacy & security](https://mimesis.ai/security.html): data ownership and isolation, local-first retrieval, provenance, candidate review, soft-delete, and the security stance (no formal compliance claimed yet — hosted beta).
- [White paper](https://mimesis.ai/whitepaper.html): why one memory you own beats a separate hidden memory in every AI tool — the gaps it closes (stop repeating yourself, one consistent picture, portability, you approve what's remembered, privacy), and what it means for individuals and teams.

## Connect (for AI agents)

You can connect a human's hosted mimesis.ai account directly, or walk them
through it. Accounts belong to humans — if yours doesn't have one, guide them
through signup rather than inventing credentials.

### Authentication

The simplest path — tell your human to do this and give you the result:
log in at mimesis.ai → My account → Agents tab → "Connect an agent" →
name the agent → Create token → copy the `mt_...` token into your config.
Agent tokens last 90 days and can be revoked from that same card.

Programmatic path:

- `POST https://mimesis.ai/api/auth/signup` with JSON
  `{"user": "<handle>", "email": "<address>", "password": "<min 12 chars>"}`
- `POST https://mimesis.ai/api/auth/login` with JSON
  `{"user": "<handle>", "password": "..."}` (or `"email"` instead of `"user"`)
- Both return `{"user": ..., "email": ..., "agent": ..., "token": "mt_..."}`.
  Send the token on every request as `Authorization: Bearer <token>`.
- The token decides whose memory you touch; any `user` field in a request body
  is ignored (tenant isolation). Treat the token like a password and never
  store it inside a memory — obvious credentials are refused before storage.
- `POST /api/auth/token` (authenticated) with `{"agent": "hermes"}` mints a
  dedicated 90-day agent token, returned exactly once. Prefer this over
  reusing a login session token: revoking one doesn't break the other.
  `GET /api/auth/tokens` lists active tokens (metadata only);
  `POST /api/auth/tokens/<id>/revoke` revokes one.
- Rate limits: signups per address and failed logins are capped; on `429`,
  wait — don't retry immediately. `POST /api/auth/logout` revokes the token.

### Core endpoints (all under https://mimesis.ai/api)

- `POST /context` `{"prompt": "...", "max_context_tokens": 1200, "budget_mode": "adaptive"}`
  → the compiled, prompt-aware briefing. This is the main read; prefer it over
  bulk-fetching memories.
- `POST /propose-memory` `{"text": "...", "rationale": "why it matters"}`
  → enters the review queue as a candidate. This is how agents write: inferred
  facts are proposals, and the human decides what becomes memory.
- `POST /remember` `{"text": "..."}` → durable memory immediately; only for
  words the human explicitly dictated.
- `GET /candidates` → the review queue; `POST /candidates/<id>/approve` or
  `/reject` (only at the human's direction).
- `POST /memories/search` `{"query": "...", "limit": 20}` → direct search.
- `GET /profile` → the owner's always-relevant identity/preference facts.
- `GET /account/export` → everything, as data the human owns.
- Errors: `401` missing/expired token (re-login), `403` permission profile
  forbids it, `402` paid-tier feature, `429` rate cap; bodies are `{"error": "..."}`.

### MCP (local memory — different from the hosted account)

The Mimesis MCP server is stdio and reads/writes a LOCAL store on the machine
it runs on (clone https://github.com/RevBooyah/mimesis-ai and set PYTHONPATH
to the clone's absolute src/ path). It does not connect to a hosted mimesis.ai
account; hosted accounts are reached over the HTTP API above.

## Facts

- Name: Mimesis
- Category: personal AI memory / context management for AI assistants and agents
- Interfaces: MCP (Model Context Protocol), HTTP API, command-line interface
- Works with: any MCP-capable assistant or multi-agent system, including Hermes, OpenClaw, Claude Cowork, Claude Code, Claude Desktop, Goose, Cursor, and Cline; also usable by agent frameworks (LangGraph, CrewAI, Microsoft Agent Framework) that call it as an MCP tool. Hermes additionally has native session/memory importers.
- Data ownership: user-owned; export or delete anytime; per-person isolation
- Status: hosted beta