Repository backend for AI products

AI products want a repository: files for agents, a SQL database for your app, and version control over both. Lix provides all three in one system:

• 📄 Files, in any format. Text and Markdown, but also DOCX, XLSX, and CAD. Plugins map any format to versioned entities.
• 🗄️ SQL database. File content, app data, and history live in an ACID OLTP database. Query millions of rows with SQL.
• 🔀 Version control. Semantic changes: the clause, cell, or row that changed, not a byte blob. Review, merge, and roll back.
• ⚡ Real-time collaboration. People and agents share a repository and see changes as they happen.
• 🧩 Pluggable storage. Local filesystem, S3, or OPFS in the browser. Lix runs wherever your product runs.
• 🔒 Permissions (soon). Finance, legal, and contractors need different access. Permissions will live inside the repository: per file, per group, and versioned like any other change.

Getting started

JavaScript · Python · Rust · Go

npm install @lix-js/sdk

Run locally with LocalFilesystem:

import { LocalFilesystem, openLix } from "@lix-js/sdk";

const lix = await openLix({
  storage: new LocalFilesystem({ path: "./workspace", syncAllFiles: true }),
});

await lix.execute("INSERT INTO lix_file (path, content) VALUES ($1, $2)", [
  "/notes/status.txt",
  new TextEncoder().encode("ready"),
]);

Or against a server:

const lix = await openLix({
  server: {
    mode: "remote",
    url: "https://example.com/workspaces/acme",
  },
});

Prime use cases

Give customers a repository

Your product gives every customer their own repository: their files, their data, and the automations LLMs now write for them. Lix is simpler than git here: it embeds in your product, and your customers review and undo changes without branch, merge, or pull request vocabulary.

// One repository per customer, on your storage.
const lix = await openLix({
  storage: new S3Storage({ bucket: `customer-${customer.id}` }),
});

// The agent writes an automation. Lix records the change, no commit needed.
await lix.execute("INSERT INTO lix_file (path, content) VALUES ($1, $2)", [
  "/automations/booking.ts",
  code,
]);

// Your UI shows the diff. The customer clicks accept or undo.

Apps with version control

Build apps on a repository instead of a bare database. The app reads and writes SQL rows and normal files. History, review, rollback, and isolated branches for agents come from the substrate instead of app code.

App logic is plain SQL. History comes with it:

// A normal app write. Lix records the change automatically.
await lix.execute("UPDATE orders SET status = 'shipped' WHERE id = 1002");

// The history sidebar, diff view, and undo button are queries:
const changes = await lix.execute(`
  SELECT created_at, schema_key, entity_pk, snapshot_content
  FROM lix_change
  ORDER BY created_at DESC
`);

Update Lix files and rows in one ACID transaction. Lix records the history automatically.

Read more about semantic changes →

How Lix works

Files × database

Plugins map files to SQL rows. A paragraph, cell, or property becomes a row Lix can version.

The file stays a normal file on disk. The rows are queryable with SQL. Lix tracks every change to both.

Runs in-process as part of your infrastructure

Lix runs in-process with pluggable storage: in memory, on the local filesystem, or on an S3 bucket. Mix and match however it serves your infrastructure.

Existing VCS like Git assume a local POSIX filesystem, which makes them hard to embed and scale. See the Persistence and Storage docs.

Comparison

Git tracks files but has no SQL. PostgreSQL/SQLite have SQL but no files and no change history. Lix has all three.

Capability	Lix	Git	PostgreSQL / SQLite
Normal files	✅	✅	❌
SQL and transactions	✅	❌	✅
Branches and merging	✅	✅	❌
Diffs by cell, clause, or row	✅ via plugins	❌ text lines only	❌
Pluggable storage	✅	❌	❌

Learn more

• Getting Started Guide - Build your first app with Lix
• Documentation - Full API reference and guides
• Discord - Get help and join the community
• GitHub - Report issues and contribute

License

MIT