---
title: "Quick start"
description: "From zero to your first note in five minutes: spin up an instance in a single container, create your first note, and connect an AI agent."
---

# Quick start

Notarium is a self-hosted knowledge base built as plain Markdown files on your own disk — one that **a human and an AI agent** work on as equals. No cloud, no proprietary format: notes live in folders, and git can be the source of truth.

This section is the shortest path from zero to a running instance: deploy Notarium in a single container, create your first note in the web editor, and connect your agent over MCP. The whole thing takes about five minutes.

> [!note] What you'll need
> Just **Docker** (or Docker Desktop) and a free port. Everything else — the web editor, the engine, and the MCP endpoint for agents — is already inside the image. There's no need to install Node, a database, or a vector index separately.

## How it works

The same knowledge base is open to two readers at once. The human works through the web editor, the agent through the MCP endpoint; both see the same note graph, and on disk it's just a tree of `.md` files.

```mermaid
flowchart LR
  human([Human]) -->|web editor| core
  agent([AI agent]) -->|MCP · start_session| core
  core[Notarium engine] --> files[(Markdown files<br/>on disk)]
  files -.->|git = source of truth| git[(Repository)]
```

The key principle is **file-first**: a note is a file, not a row in someone else's database. There's no need to export, because you're never really "inside" — the data is always yours and always on disk.

## Spin up an instance

The fastest way is to run the prebuilt image. It's self-contained: it brings up the engine, the web interface, and the MCP endpoint all at once.

```bash
# Pull the image and start the container
docker run -d --name notarium \
  -p 3000:3000 \
  -v notarium-data:/data \
  docouno/notarium:latest
```

A single `/data` volume holds all state: the metadata database, the indexes, your notes, and export artifacts. There's nothing more to configure — port `3000` and the data path `/data` are already baked into the image. The port to the left of `3000` can be changed to any free one.

Open `http://localhost:3000` — you'll be greeted by the **first-run setup screen**. It creates the instance owner (the first account) and a starter (personal) space. After that, you're in the editor.

> [!tip] Port and data
> You can change port `3000` by editing the left-hand number in `-p <yours>:3000`. The `docouno/notarium` image is public — this is the main install path (details and building from source are on the [Installation](/docs/getting-started/installation/) page). The `/data` volume survives when you recreate the container — but guard the volume itself: your data leaves with it.

What happens under the hood on first launch:

- the engine starts and serves the web interface on the port you specified;
- the tree of your spaces is initialized inside the `/data` volume;
- the setup screen creates the owner — the account that owns the instance.

## Next steps

The instance is up — three short steps come next. Each is covered on its own page:

| Step | Page | What you'll get |
|---|---|---|
| 1 | [Installation and launch](/docs/getting-started/installation/) | A walkthrough of `docker` / `make up`, volumes, and the setup screen |
| 2 | [Your first note](/docs/getting-started/first-note/) | The file tree, the web editor, saving to `.md` |
| 3 | [Connect an agent](/docs/getting-started/connect-agent/) | A token, the `POST /mcp` endpoint, calling `start_session` |

Want to grasp the whole model first? Take a look at the [Concepts](/docs/concepts/) section: spaces and projects, note types, the knowledge graph, and the access model for humans and agents.