Your AI's memory.
One file. No daemon.

01  /  Mechanism

Search in two stages, not one.

    query
      |
      v
   +--------------------------+     stage 1 — deterministic
   |  search_documents        |     fts5 trigram + bm25
   +--------------------------+     no model, no network, no guessing
      |
      |  matched chunks
      v
   +--------------------------+     the only bridge between stages.
   |  seed  (max 3)           |     nothing else crosses it.
   +--------------------------+
      |
      v
   +--------------------------+     stage 2 — expansion
   |  search_knowledge        |     one-hop graph traversal
   +--------------------------+     seeded, never global
      |
      v
    source document                 every result traces back here

What it won't do

• Search the entire database semantically on every query
• Quietly fall back to embeddings when your keywords miss
• Extract entities or invent relations behind your back
• Ask you for a model, a GPU, or an API key before it starts

What you get instead

• The same query returns the same result, every time
• Zero hits means zero hits — and zero hidden cost
• Your client's model does the thinking; the database stays boring
• It works on a laptop, on a plane, or on a $40 single-board computer

03  /  The file

Everything lives in one file.

  hadano.db
  |
  +-- documents ... doc_id, title, body, sha256, created_at
  +-- chunks ...... 800 codepoints, 100 overlap, deterministic
  +-- chunks_fts .. FTS5, trigram tokenizer .......... stage 1
  +-- vec_chunks .. sqlite-vec vec0, soon ............ stage 2
  +-- edges ....... src, rel, dst, doc_id ............ stage 2
  +-- audit_log ... request_id, args, rows, duration_ms
  |
  '-- WAL, foreign keys on, secure_delete on

04  /  Install

Two steps. One dependency.

Not yet published. The package name below is reserved but the release isn't on PyPI, so this is what setup will look like, not a command that works today. The full walkthrough is in get started, and every parameter is in the manual.

# 1. install
pip install hadano-ai-cabinet

# 2. register it with your MCP client
{
  "mcpServers": {
    "hadano": {
      "type": "stdio",
      "command": "python",
      "args": ["-m", "hadano.server"],
      "env": { "HADANO_DB": "~/hadano.db" }
    }
  }
}

The seven tools

06  /  Pricing

Using it is free. Always.

                                                     price    writer
  phase 1   LOCAL        hadano.db on your own disk . free         1
            |
            |  same package, same file format, same seven tools
            v
  phase 2   CLOUD API    hadano.db on our server ..... $10         1
            |
            |  swap where the file lives. nothing else changes.
            v
  phase 3   BYOS         hadano.db in your bucket .... $10         1

  one writer at every step — so there is no conflict resolution,
  no vector clocks, and no sync client for you to install.

  phases 2 and 3 are one subscription. which storage it uses is your
  call, and the price does not change either way.

Only phase 1 exists today, and it isn't published yet. Phases 2 and 3 are the intended direction, not a commitment to a date. The price shown is planned, in USD, billed up front; the annual plan is one charge for twelve months. There is no introductory rate that expires — what you sign up at is what you keep paying. Whichever storage you pick, the service is provided as is and we do not warrant the contents of your database. Dump and restore exist so that a copy is always yours to take, and keeping one is your job, not ours.

07  /  Design

Built to be inspected.

08  /  Questions

Frequently asked.

Does it need an API key, a GPU, or a model download?

No. Search is keyword matching over SQLite FTS5 plus graph traversal, so the database starts and answers queries with no model present.

Does my data leave my machine?

Not when you run it locally, which is the only way it runs today. The local build makes no network calls at all — it reads and writes one SQLite file on your disk and talks to your AI client over stdio. The hosted tier on the roadmap is opt-in and separate; local will not start phoning home because it exists.

Which MCP clients work with it?

Any client that speaks MCP over stdio — Claude Code, Claude Desktop, Cursor, and others. Registration is the few lines of JSON shown above.

How is this different from a vector database?

A vector database searches embeddings across the whole corpus on every query. Hadano runs deterministic keyword search first, then expands from at most three chunks that keyword search actually matched. Cost stays bounded, and every result traces back to a source document.

Can several people share one knowledge base?

Not today. A local database has one writer, and that constraint is what keeps the design small enough to reason about. Shared access is what the hosted tier on the roadmap is for.

Can it run on a Raspberry Pi?

Yes. Idle memory is 27.4 MB and there's no daemon, so it runs anywhere Python and SQLite run.

What happens when I delete a document?

Its chunks, full-text rows, vectors, and edges go in the same transaction, and the database runs with secure_delete on, so the bytes get overwritten instead of sitting in free pages.

When can I actually install it?

Not yet. The core is built and tested, and the numbers on this page are real measurements, but the package and the source repository aren't public. This page exists so you can see the design before that happens.

Is it really free for commercial use?

Yes. There are no seat counts, no document caps, and no telemetry. The paid tier is the hosted API, and only if you want it. The core is released under the Apache License 2.0, which includes an explicit patent grant.