Create A Dotabase

This guide uses the dots CLI; the web app offers the same steps through its interface.

1. Create The Dotabase

A new Dotabase needs a name, a slug, and a row-id prefix. All three are required. The slug is the stable key everything else references; the prefix is what row ids are built from (for example READ-1, READ-2):

dots dotabases create --name "Reading list" --slug reading-list --prefix READ

The slug is what has to be unique — one per workspace. The prefix does not: two Dotabases may both allocate READ-1, because ids are numbered per Dotabase. A prefix is two to ten uppercase alphanumeric characters starting with a letter, and a handful of prefixes are reserved for the platform's own Dotabases. Numbering always continues above the highest id ever issued, so deleting a row leaves a permanent gap rather than freeing its id for the next write — an id you saw in an export never comes back pointing at something else.

You can pass an Operation Manual up front with --manual-purpose, or add a starting schema with --properties-file. Both are optional — start small and extend later. --properties-file, --views-file, and --behaviors-file each take a path to a file holding a top-level JSON array.

2. Give It A Schema

Rows carry typed properties defined by the Dotabase schema — a status select, a date, a number, a relation to another Dotabase, and more. When you create a row you set properties inline with --set; to define the schema itself, edit it in the app or pass --properties-file <path> on create. Start with the few properties you know you need; you can add more at any time.

The reading-list rows below use a status select, so declare it before the first row write. Save this as status-property.json:

{
  "id": "status",
  "key": "status",
  "display_name": "Status",
  "type": "select",
  "config": {
    "options": [
      { "id": "to-read", "name": "To read", "color": "ideas" },
      { "id": "read", "name": "Read", "color": "intelligence" }
    ]
  }
}

Append that property to the existing schema:

dots dotabases schema add-property reading-list --file status-property.json

The option ids are the values row writes use. A fresh Dotabase otherwise declares only title and body, and a write to any undeclared property is refused.

3. Add Rows

dots rows create reading-list --title "Thinking, Fast and Slow" --set status=to-read

A long body is easier to pass as a file than as an argument, so --body-file <path> sits beside --body <text> and the two are mutually exclusive. Tags go on with --tags, and the positional argument accepts the Dotabase's slug, its id, or its canonical human id.

4. Look At It

List what you created, then read a row back:

dots rows list reading-list --level scan
dots rows get reading-list READ-1

That pair is the reading pattern the CLI teaches: survey the collection cheaply, then pull the one row you chose back in full. --level scan keeps each row's identity — id, title, icon — and drops the rest, which is all the first line needs in order to hand the second line a row id. Without the flag a listing lands at summary, one tier wider; rows get names a single record, so it hands back the whole thing, body included, with no flag at all.

dots rows list narrows with --limit, --status, --tags, and --title-contains. --title-contains matches case-sensitively, so a search for thinking will not find Thinking, Fast and Slow. Those flags pick which rows come back and --level picks how much of each one does.

Once you have a few rows, switch between the table, board, and graph views in the app to read the same rows in each shape. To bring in existing notes instead of typing them, see Import from Markdown.

What Runs On Every Write

As a row is written, the Dotabase's behaviors enrich it. On a Dotabase you just created, that means an activity-log entry, a refresh of any computed properties, a word count, an embedding for semantic search, and a DIIICE classification. Pass --no-embedding or --no-diiice at create time to stand up a Dotabase without the last two.

The rest of the catalog is opt-in, bound per Dotabase when you want it. Tag inference is one of those, and so is every behavior that draws edges — a fresh Dotabase therefore connects nothing on its own, and rows stay unlinked until you either bind an edge behavior or create edges yourself.