Walleye, managed.

Lakeday runs Walleye instances for you: LanceDB with every write durable in object storage. Connect with any LanceDB SDK.

One free month. No card.

Worked example

Parse a stream straight into a table.

Read records off a socket, a log tail or a queue, batch them, and write them into a table with the stock LanceDB client. There is no Lakeday SDK to learn: the client speaks the LanceDB remote protocol to db.lakeday.ai, names your instance as its database, and authenticates with an access token made for that instance.

Python

pip install lancedb pyarrow
import json, os, sys
import lancedb, pyarrow as pa

db = lancedb.connect(
    "db://" + os.environ["LAKEDAY_INSTANCE_ID"],  # the instance id is the database
    api_key=os.environ["LAKEDAY_TOKEN"],
    host_override="https://db.lakeday.ai",
)

schema = pa.schema([
    pa.field("id", pa.int64()),
    pa.field("body", pa.string()),
    pa.field("embedding", pa.list_(pa.float32(), 768)),
])
table = (
    db.open_table("events")
    if "events" in db.list_tables().tables
    else db.create_table("events", schema=schema)
)

rows = []
for line in sys.stdin:               # one JSON record per line
    event = json.loads(line)
    rows.append({
        "id": event["id"],
        "body": event["body"],
        "embedding": embed(event["body"]),
    })
    if len(rows) < 500:
        continue
    # Returns once the batch is durable in object storage.
    table.add(pa.Table.from_pylist(rows, schema=schema))
    rows = []

if rows:
    table.add(pa.Table.from_pylist(rows, schema=schema))

print(table.count_rows())
print(table.search(embed("checkout failed")).limit(5).to_list())

JavaScript

npm install @lancedb/lancedb
import * as lancedb from "@lancedb/lancedb";
import { createInterface } from "node:readline";

const db = await lancedb.connect(`db://${process.env.LAKEDAY_INSTANCE_ID}`, {
  apiKey: process.env.LAKEDAY_TOKEN,
  hostOverride: "https://db.lakeday.ai",
});

const names = await db.tableNames();
let table = names.includes("events") ? await db.openTable("events") : null;
let rows = [];

async function flush() {
  if (rows.length === 0) return;
  // Resolves once the batch is durable in object storage.
  if (table) await table.add(rows);
  else table = await db.createTable("events", rows);
  rows = [];
}

for await (const line of createInterface({ input: process.stdin })) {
  const event = JSON.parse(line);
  rows.push({
    id: event.id,
    body: event.body,
    embedding: await embed(event.body),
  });
  if (rows.length === 500) await flush();
}
await flush();

const query = table.search(await embed("checkout failed"));
console.log(await table.countRows());
console.log(await query.limit(5).toArray());

This is where durability earns its place. add does not return until the batch is durable in the instance's own object storage, so a crash mid-stream, whether the writer's, the instance's or the network's, loses nothing it acknowledged. The instance comes back with everything it acknowledged, and the count you printed is the count that is still there. Each writer and reader can hold its own scoped token, and revoking one restarts nothing.

Pricing

One rate per instance.

Every instance is always on, billed per second while it runs. No plans, no organization fee and no seat charges.

Ramp

One node. Every write is durable in object storage before it is acknowledged.

Ramp rates. A month is 730 hours.
Cache vCPUs Memory Disk Price
small 1 shared 2 GiB 8 GB $39 a month $0.054 an hour
medium 2 shared 4 GiB 16 GB $79 a month $0.108 an hour
large 4 shared 8 GiB 32 GB $149 a month $0.204 an hour
xlarge 8 shared 16 GiB 64 GB $299 a month $0.410 an hour

Launch

Three nodes behind one address. The rate covers all three.

Launch rates. A month is 730 hours.
Cache vCPUs Memory Disk Price
small 2 dedicated 8 GiB 32 GB $799 a month $1.095 an hour
medium 4 dedicated 16 GiB 64 GB $1,499 a month $2.053 an hour
large 8 dedicated 32 GiB 128 GB $2,999 a month $4.108 an hour
xlarge 16 dedicated 64 GiB 256 GB $5,999 a month $8.218 an hour

Usage, on either shape

Storage
$0.05 per GB-month. 10 GB included per ramp instance, 100 GB per launch instance.
Egress
$0.05 per GB after 100 GB per organization each month.

One free month. Your first ramp small instance is free for 30 days. No card needed.

Sign up

How it works

Durable in object storage.
Served from memory and disk.

  1. Every write is durable before it is acknowledged.

    A write is acknowledged only once it is durable in the instance's own object storage. A Ramp instance commits each write to object storage before it acknowledges it; a Launch instance replicates it across a quorum of its three nodes first and reaches object storage within a second.

  2. Reads come from memory and disk.

    Hot fragments and indexes live in a thin cache on the node. Tables can be larger than the cache; colder data is read from object storage on demand. The cache is disposable and is rebuilt from object storage whenever a node is replaced, so losing a node loses no acknowledged write.

  3. One node or three.

    Ramp is a single node. Launch is three nodes behind the same connection, each serving the LanceDB API, with a write quorum of two. Each table is owned by one of the three, so losing a node costs no acknowledged write, and costs service to that node's tables until it is back. Move from Ramp to Launch with a stop, a resize and a start.

Read about durability

Your tables. Your bucket.

Create your first instance.

Sign up Read the docs