ParticleDB | The database for AI agents

context before action

Better agents start
with better context.

An agent’s decisions depend on the data it receives. When context is scattered across systems, every task inherits the work of finding it, joining it and keeping it current.

ParticleDB brings relational facts, vector memory and live operational data into one engine. Prepare context with SQL. Apply your logic with Particles. Give the agent the information it needs for the next step.

Meet ParticleDB →

DATA ENGINES

RelationalTables & transactions

Key-valueKeys & coordination

Vector searchMemory & retrieval

AnalyticsQueries on live data

ParticleDBOne durable engine

AgentsContext & state

WorkflowsSteps & coordination

ParticlesYour code beside data

the platform

One engine behind every step.

The data your agents need. The state your application depends on. The code that brings them together.

Relational SQL

Store relational facts and application state with SQL, joins and ACID transactions.

A transaction

db.execute("CREATE TABLE accounts (id BIGINT PRIMARY KEY, balance BIGINT)")
db.execute("INSERT INTO accounts VALUES (1, 100), (2, 0)")
with db.transaction() as tx:  # commits on exit, rolls back on error
    tx.execute("UPDATE accounts SET balance = balance - $1 WHERE id = $2", [30, 1])
    tx.execute("UPDATE accounts SET balance = balance + $1 WHERE id = $2", [30, 2])
print(db.query("SELECT id, balance FROM accounts ORDER BY id"))

Output

[{'id': 1, 'balance': 70}, {'id': 2, 'balance': 30}]

await db.execute('CREATE TABLE accounts (id BIGINT PRIMARY KEY, balance BIGINT)');
await db.execute('INSERT INTO accounts VALUES (1, 100), (2, 0)');
await db.transaction(async tx => {  // commits on return, rolls back on throw
  await tx.execute('UPDATE accounts SET balance = balance - $1 WHERE id = $2', [30, 1]);
  await tx.execute('UPDATE accounts SET balance = balance + $1 WHERE id = $2', [30, 2]);
});
console.log((await db.query('SELECT id, balance FROM accounts ORDER BY id')).rows);

Output

[ { id: 1, balance: 70 }, { id: 2, balance: 30 } ]

db.execute("CREATE TABLE accounts (id BIGINT PRIMARY KEY, balance BIGINT)");
db.execute("INSERT INTO accounts VALUES (1, 100), (2, 0)");
db.transaction(tx -> { // returns normally: commit; throws: rollback
    tx.execute("UPDATE accounts SET balance = balance - ? WHERE id = ?", 30L, 1L);
    tx.execute("UPDATE accounts SET balance = balance + ? WHERE id = ?", 30L, 2L);
    return null;
});
System.out.println(db.query("SELECT id, balance FROM accounts ORDER BY id").getRows());

Output

[Row{id=1, balance=70}, Row{id=2, balance=30}]

db.Exec(ctx, "CREATE TABLE accounts (id BIGINT PRIMARY KEY, balance BIGINT)")
db.Exec(ctx, "INSERT INTO accounts VALUES (1, 100), (2, 0)")
err := particledb.BeginFunc(ctx, db, particledb.TxOptions{}, func(tx *particledb.Tx) error {
	if _, err := tx.Exec(ctx, "UPDATE accounts SET balance = balance - $1 WHERE id = $2", 30, 1); err != nil {
		return err // an error rolls back
	}
	_, err := tx.Exec(ctx, "UPDATE accounts SET balance = balance + $1 WHERE id = $2", 30, 2)
	return err // nil commits
})
rows, _ := db.Query(ctx, "SELECT id, balance FROM accounts ORDER BY id")
balances, _ := particledb.CollectRows(rows, particledb.RowToMap)
fmt.Println(balances, err)

Output

[map[balance:70 id:1] map[balance:30 id:2]] <nil>

db.execute("CREATE TABLE accounts (id BIGINT PRIMARY KEY, balance BIGINT)", &[])?;
db.execute("INSERT INTO accounts VALUES (1, 100), (2, 0)", &[])?;
db.transaction(|tx| { // Ok commits, Err rolls back
    tx.execute("UPDATE accounts SET balance = balance - 30 WHERE id = 1", &[])?;
    tx.execute("UPDATE accounts SET balance = balance + 30 WHERE id = 2", &[])?;
    Ok(())
})?;
for row in db.query("SELECT id, balance FROM accounts ORDER BY id", &[])?.rows {
    println!("{:?}", row.values());
}

Output

[Int64(1), Int64(70)]
[Int64(2), Int64(30)]

CREATE TABLE accounts (id BIGINT PRIMARY KEY, balance BIGINT);
INSERT INTO accounts VALUES (1, 100), (2, 0);
BEGIN;
UPDATE accounts SET balance = balance - 30 WHERE id = 1;
UPDATE accounts SET balance = balance + 30 WHERE id = 2;
COMMIT;
SELECT id, balance FROM accounts ORDER BY id;

Output

1|70
2|30

Key-value

Use Redis-compatible key-value structures for queues, locks, counters and rate limits, backed by the same durable engine.

A rate-limit counter with a TTL

hits = db.kv_incr("rate:agent:1")            # 1, 2, 3 ... per call
db.kv_command("EXPIRE", "rate:agent:1", 60)  # the window resets after 60 s
print(hits)

Output

const hits = await db.kv.incr('rate:agent:1');                // 1, 2, 3 ... per call
await db.query('SELECT KV_EXPIRE($1, 60)', ['rate:agent:1']);  // the window resets after 60 s
console.log(hits);

Output

long hits = db.kv().incr("rate:agent:1", 1); // 1, 2, 3 ... per call
db.kv().expire("rate:agent:1", 60);          // the window resets after 60 s
System.out.println(hits);

Output

hits, _ := db.KVIncr(ctx, []byte("rate:agent:1"))       // 1, 2, 3 ... per call
db.Exec(ctx, "SELECT KV_EXPIRE($1, 60)", "rate:agent:1") // the window resets after 60 s
fmt.Println(hits)

Output

let key = Value::String("rate:agent:1".into());
let hits = db.query_one("SELECT KV_INCR($1)", &[key.clone()])?.unwrap(); // 1, 2, 3 ... per call
db.query("SELECT KV_EXPIRE($1, 60)", &[key])?; // the window resets after 60 s
println!("{}", hits.get::<i64>(0)?);

Output

SELECT KV_INCR('rate:agent:1');        -- 1, 2, 3 ... per call
SELECT KV_EXPIRE('rate:agent:1', 60);  -- the window resets after 60 s

Output

1
1

Vector search

Query vectors and relational facts together, with embeddings stored beside the data they describe.

Nearest memories by vector distance

db.execute("CREATE TABLE memories (id BIGINT PRIMARY KEY, note TEXT, embedding VECTOR(3))")
db.execute("INSERT INTO memories VALUES (1, 'refund policy', '[1,0,0]'), "
           "(2, 'shipping times', '[0,1,0]'), (3, 'return window', '[0.9,0.1,0]')")
print(db.query("SELECT id, note FROM memories ORDER BY embedding <-> $1 LIMIT 2", ["[1,0,0]"]))

Output

[{'id': 1, 'note': 'refund policy'}, {'id': 3, 'note': 'return window'}]

await db.execute('CREATE TABLE memories (id BIGINT PRIMARY KEY, note TEXT, embedding VECTOR(3))');
await db.execute(`INSERT INTO memories VALUES (1, 'refund policy', '[1,0,0]'),
  (2, 'shipping times', '[0,1,0]'), (3, 'return window', '[0.9,0.1,0]')`);
const { rows } = await db.query('SELECT id, note FROM memories ORDER BY embedding <-> $1 LIMIT 2', ['[1,0,0]']);
console.log(rows);

Output

[ { id: 1, note: 'refund policy' }, { id: 3, note: 'return window' } ]

db.execute("CREATE TABLE memories (id BIGINT PRIMARY KEY, note TEXT, embedding VECTOR(3))");
db.execute("INSERT INTO memories VALUES (1, 'refund policy', '[1,0,0]'), "
    + "(2, 'shipping times', '[0,1,0]'), (3, 'return window', '[0.9,0.1,0]')");
System.out.println(db.query("SELECT id, note FROM memories ORDER BY embedding <-> ? LIMIT 2",
    "[1,0,0]").getRows());

Output

[Row{id=1, note=refund policy}, Row{id=3, note=return window}]

db.Exec(ctx, "CREATE TABLE memories (id BIGINT PRIMARY KEY, note TEXT, embedding VECTOR(3))")
db.Exec(ctx, `INSERT INTO memories VALUES (1, 'refund policy', '[1,0,0]'),
	(2, 'shipping times', '[0,1,0]'), (3, 'return window', '[0.9,0.1,0]')`)
rows, _ := db.Query(ctx, "SELECT id, note FROM memories ORDER BY embedding <-> $1 LIMIT 2", "[1,0,0]")
nearest, _ := particledb.CollectRows(rows, particledb.RowToMap)
fmt.Println(nearest)

Output

[map[id:1 note:refund policy] map[id:3 note:return window]]

db.execute("CREATE TABLE memories (id BIGINT PRIMARY KEY, note TEXT, embedding VECTOR(3))", &[])?;
db.execute("INSERT INTO memories VALUES (1, 'refund policy', '[1,0,0]'), \
    (2, 'shipping times', '[0,1,0]'), (3, 'return window', '[0.9,0.1,0]')", &[])?;
let query = Value::Vector(vec![1.0, 0.0, 0.0]);
for row in db.query("SELECT id, note FROM memories ORDER BY embedding <-> $1 LIMIT 2", &[query])?.rows {
    println!("{:?}", row.values());
}

Output

[Int64(1), String("refund policy")]
[Int64(3), String("return window")]

CREATE TABLE memories (id BIGINT PRIMARY KEY, note TEXT, embedding VECTOR(3));
INSERT INTO memories VALUES (1, 'refund policy', '[1,0,0]'),
  (2, 'shipping times', '[0,1,0]'), (3, 'return window', '[0.9,0.1,0]');
SELECT id, note FROM memories ORDER BY embedding <-> '[1,0,0]' LIMIT 2;

Output

1|refund policy
3|return window

Live analytics

Analyze operational data where it lives, with columnar execution, no ETL and no second copy.

An aggregate over live rows

db.execute("CREATE TABLE runs (agent TEXT, ms BIGINT)")
db.execute("INSERT INTO runs VALUES ('planner', 120), ('planner', 90), ('critic', 200)")
print(db.query("SELECT agent, COUNT(*) AS runs, SUM(ms)::BIGINT AS total_ms "
               "FROM runs GROUP BY agent ORDER BY agent"))

Output

[{'agent': 'critic', 'runs': 1, 'total_ms': 200}, {'agent': 'planner', 'runs': 2, 'total_ms': 210}]

await db.execute("CREATE TABLE runs (agent TEXT, ms BIGINT)");
await db.execute("INSERT INTO runs VALUES ('planner', 120), ('planner', 90), ('critic', 200)");
console.log((await db.query(`SELECT agent, COUNT(*) AS runs, SUM(ms)::BIGINT AS total_ms
  FROM runs GROUP BY agent ORDER BY agent`)).rows);

Output

[
  { agent: 'critic', runs: 1, total_ms: 200 },
  { agent: 'planner', runs: 2, total_ms: 210 }
]

db.execute("CREATE TABLE runs (agent TEXT, ms BIGINT)");
db.execute("INSERT INTO runs VALUES ('planner', 120), ('planner', 90), ('critic', 200)");
System.out.println(db.query("SELECT agent, COUNT(*) AS runs, SUM(ms)::BIGINT AS total_ms "
    + "FROM runs GROUP BY agent ORDER BY agent").getRows());

Output

[Row{agent=critic, runs=1, total_ms=200}, Row{agent=planner, runs=2, total_ms=210}]

db.Exec(ctx, "CREATE TABLE runs (agent TEXT, ms BIGINT)")
db.Exec(ctx, "INSERT INTO runs VALUES ('planner', 120), ('planner', 90), ('critic', 200)")
rows, _ := db.Query(ctx, `SELECT agent, COUNT(*) AS runs, SUM(ms)::BIGINT AS total_ms
	FROM runs GROUP BY agent ORDER BY agent`)
report, _ := particledb.CollectRows(rows, particledb.RowToMap)
fmt.Println(report)

Output

[map[agent:critic runs:1 total_ms:200] map[agent:planner runs:2 total_ms:210]]

db.execute("CREATE TABLE runs (agent TEXT, ms BIGINT)", &[])?;
db.execute("INSERT INTO runs VALUES ('planner', 120), ('planner', 90), ('critic', 200)", &[])?;
for row in db.query("SELECT agent, COUNT(*) AS runs, SUM(ms)::BIGINT AS total_ms \
    FROM runs GROUP BY agent ORDER BY agent", &[])?.rows {
    println!("{:?}", row.values());
}

Output

[String("critic"), Int64(1), Int64(200)]
[String("planner"), Int64(2), Int64(210)]

CREATE TABLE runs (agent TEXT, ms BIGINT);
INSERT INTO runs VALUES ('planner', 120), ('planner', 90), ('critic', 200);
SELECT agent, COUNT(*) AS runs, SUM(ms)::BIGINT AS total_ms
FROM runs GROUP BY agent ORDER BY agent;

Output

critic|1|200
planner|2|210

Particles

Bring your code beside the data with Particles: scoring, transforms and tools callable from SQL.

1 / agent_tools.py

from particledb import scalar

@scalar
def agent_priority(impact: float, confidence: float) -> float:
    return impact * confidence

2 / load it when the server starts

particledb start ... --python-functions ./agent_tools.py

Add the flag to the quickstart start command. Included in the free edition. The server runs the module with the python3 on its PATH, which needs Python 3.11 or newer and pip install particledb; checked on the standard 1.1.19-rc.17 download. Requirements

3 / call it from any client

print(db.query("SELECT agent_priority($1, $2) AS priority", [0.5, 0.75]))

Output

[{'priority': 0.375}]

console.log(await db.queryOne('SELECT agent_priority($1, $2) AS priority', [0.5, 0.75]));

Output

{ priority: 0.375 }

System.out.println(db.queryOne("SELECT agent_priority(?, ?) AS priority", 0.5, 0.75));

Output

Row{priority=0.375}

var priority float64
db.QueryRow(ctx, "SELECT agent_priority($1, $2)", 0.5, 0.75).Scan(&priority)
fmt.Println(priority)

Output

0.375

let args = [Value::Float64(0.5), Value::Float64(0.75)];
let row = db.query_one("SELECT agent_priority($1, $2)", &args)?.unwrap();
println!("{}", row.get::<f64>(0)?);

Output

0.375

SELECT agent_priority(0.5, 0.75) AS priority;

Output

0.375

why one engine

Less glue. More building.

Your application keeps them aligned.

A relational database for state. A key-value store for coordination. A vector database for memory. A warehouse for analytics. Plus sync jobs and dual writes.

One shared foundation.

Serve all four workloads from one durable engine, with Particles running your code beside the data.

built for your stack

Use the tools you already know.

PostgreSQL-compatible SQL for psql, JDBC and your ORM. Redis-compatible key-value access. Check the published clients and release versions for your application.

PostgreSQL compatibility →Python · TypeScript · Go · Java · C# · Rust →

start building

Build your next AI agent on ParticleDB.

One durable engine for its memory, state, coordination, analytics and your code. Free for developers.

Start free →Releases and clients →

curl -fsSL https://get.particledb.ai | bash

HTTP API: localhost:7173 · Web console: localhost:7174

The databasefor AI agents.

Better agents startwith better context.

One engine behind every step.

Relational SQL

Key-value

Vector search

Live analytics

Particles

Less glue. More building.

Your application keeps them aligned.

One shared foundation.

Use the tools you already know.

Build your next AI agent on ParticleDB.

The database
for AI agents.

Better agents start
with better context.