AI工作流

Quick Start

import Ablo from '@abloatai/ablo';
import { defineSchema, model, z } from '@abloatai/ablo/schema';

Register the schema once (init scaffolds this `ablo.d.ts`), and every type
is one parameter away — no `typeof schema` re-stating, anywhere:

type WeatherReport = Model<'weatherReports'>; // fully typed from YOUR schema

(The same `Register` binding types every hook and client — it's the
TanStack-Router pattern: declare the source of truth once, everything
infers from it.)


const schema = defineSchema({
  weatherReports: model({
    location: z.string(),
    status: z.enum(['pending', 'ready']),
    forecast: z.string().optional(),
  }),
});

const ablo = Ablo({
  schema,
  apiKey: process.env.ABLO_API_KEY, // written to .env.local by `npx ablo push`
  databaseUrl: process.env.DATABASE_URL, // your Postgres — rows live here, never with Ablo
});

await ablo.ready();

const created = await ablo.weatherReports.create({
  data: {
    location: 'Stockholm',
    status: 'pending',
  },
});

// An agent claims the row, does its slow work, then writes back. While the
// claim is held nobody else can overwrite it; anyone else who tries waits in
// line and re-reads the result. This is the whole point of Ablo.
await using claim = await ablo.weatherReports.claim({ id: created.id });
const report = claim.data;
const forecast = await fetchForecast(report.location); // slow: API or LLM call
await ablo.weatherReports.update({ id: report.id, data: { status: 'ready', forecast } });

const ready = ablo.weatherReports.get(created.id);
console.log({ id: ready?.id, status: ready?.status });

await ablo.dispose();

Expected output:

{ id: '...', status: 'ready' }

Configuration

Ablo({ ... }) takes three things: your schema, your key, and your database — the last either as databaseUrl here or as a signed Data Source endpoint in your app. Every other option has correct defaults:

Keep apiKey in trusted server runtimes. In the browser, <AbloProvider> authenticates with the signed-in user's session; the raw-key path is gated behind dangerouslyAllowBrowser for server-proxy setups only. Advanced hooks (custom fetch, logging, observability, transport overrides) live in Client Behavior.

Production Reference

• Version History & Migration Guide — every breaking change, what to change, and which version introduced it. Read before bumping a minor.
• Identity & Sync Groups — use your own authentication; tell Ablo who's connecting and how org / team / user map to sync-group scope.
• Schema Contract — one schema becomes typed model clients, React reads, agent writes, Data Source shape, and schema push.
• Guarantees — confirmed writes, stale-write protection, claim coordination, and agent lifecycle.
• Integration Guide — integrate React, your database, multiplayer, and agents.
• React — <AbloProvider>, useAblo, presence, status, and bootstrap gating.
• Coordination — claim / claim.state / claim.queue / claim.release reference: hold a row across slow agent work, and observe the line waiting behind it.
• Client Behavior — options, errors, retries, timeouts, and public imports.
• Connect Your Database — connect your Postgres by connection string (databaseUrl) or signed endpoint; your database is the system of record either way.
• Existing Python Backend — migrate existing Python endpoints to multiplayer and agent-safe writes gradually.
• AI SDK Tool — use Ablo inside an AI SDK tool call.
• Server Agent — schema-backed worker.