@@ -36,22 +38,22 @@ the underlying object storage; no pod talks to another one directly.
"fontFamily": "Inter, sans-serif", "fontSize": "18px"
}}}%%
flowchart LR
- Q["Query node
hashes (db, table) to one WAL node"]
+ Q["Query node
routes each table's shards to an RTE node"]
- subgraph W0["WAL node A — owns table 'frames'"]
+ subgraph W0["RTE node A"]
direction TB
- S0["Shard 0
ShardWriter"]
- S1["Shard 1
ShardWriter"]
- S2["Shard 2
ShardWriter"]
+ S0["Shard 0 — table 'frames'"]
+ S1["Shard 0 — table 'events'"]
end
- subgraph W1["WAL node B — owns table 'events'"]
+ subgraph W1["RTE node B"]
direction TB
- S3["Shard 0
ShardWriter"]
+ S2["Shard 0 — table 'metrics'"]
end
- Q -- "writes + reads for 'frames'" --> W0
- Q -- "writes + reads for 'events'" --> W1
+ Q -- "'frames'" --> W0
+ Q -- "'events'" --> W0
+ Q -- "'metrics'" --> W1
classDef default fill:#1e1b19,stroke:#4c443f,stroke-width:1px,color:#f4ebe8
```
@@ -67,22 +69,22 @@ flowchart LR
"fontFamily": "Inter, sans-serif", "fontSize": "18px"
}}}%%
flowchart LR
- Q["Query node
hashes (db, table) to one WAL node"]
+ Q["Query node
routes each table's shards to an RTE node"]
- subgraph W0["WAL node A — owns table 'frames'"]
+ subgraph W0["RTE node A"]
direction TB
- S0["Shard 0
ShardWriter"]
- S1["Shard 1
ShardWriter"]
- S2["Shard 2
ShardWriter"]
+ S0["Shard 0 — table 'frames'"]
+ S1["Shard 0 — table 'events'"]
end
- subgraph W1["WAL node B — owns table 'events'"]
+ subgraph W1["RTE node B"]
direction TB
- S3["Shard 0
ShardWriter"]
+ S2["Shard 0 — table 'metrics'"]
end
- Q -- "writes + reads for 'frames'" --> W0
- Q -- "writes + reads for 'events'" --> W1
+ Q -- "'frames'" --> W0
+ Q -- "'events'" --> W0
+ Q -- "'metrics'" --> W1
classDef default fill:#ffffff,stroke:#ad9e95,stroke-width:1px,color:#221d19
```
@@ -91,25 +93,16 @@ flowchart LR
## Shards scale one table, replicas scale the cluster {#shards-vs-replicas}
`RTEWriteSpec::bucket(column, num_buckets)` splits a table into `num_buckets`
-**table shards**, each a separate, independently-appending `ShardWriter`. A
-shard's identity is derived from the table's own URI
-(`uuid_v5(WAL_SHARD_NS, "{table_uri}#{i}")`), not assigned by an operator, so
-a shard survives the table being claimed by a different pod later.
+**table shards**, each a separate, independently-appending stream, giving the
+table that many parallel write paths instead of one. A shard's identity is
+derived from the table itself, not assigned by an operator, so a shard
+survives the table being claimed by a different RTE node later.
-This is where the horizontal scaling actually happens, and where its limit
-is: **one WAL node owns every shard of a given table.** Splitting `frames`
-into 8 shards gives it 8 independent append streams, all still served by the
-one pod that owns `frames` -- it raises that table's own ceiling, not the
-number of pods working on it. Adding WAL node replicas instead spreads
-*other* tables' ownership across more pods, raising how many tables the
-cluster can serve, not how fast any single one of them can write.
-
-
-A single table's write throughput is capped by one pod's capacity, however
-many shards you give it. A workload that needs to exceed one pod's ceiling on
-one table is not solved by adding shards -- there is no path to spreading one
-table's shards across multiple WAL nodes today.
-
+This is where the horizontal scaling actually happens: splitting `frames`
+into 8 shards gives it 8 independent append streams instead of 1, raising
+that table's own write ceiling. Adding RTE node replicas spreads shard
+ownership across more nodes, so the cluster can host more tables -- and more
+shards -- without any one node becoming a bottleneck for everything it serves.
`RTEWriteSpec::identity(column)` and `RTEWriteSpec::unsharded()` both resolve
to a single table shard -- `bucket` is the sharding mode that actually
@@ -121,22 +114,22 @@ scaling.
A table shard is the unit of capacity: measured runs show it sustaining
roughly 85-90 MB/s of durable append before acknowledgement, and throughput
scaling nearly linearly with shard count up to at least 8 shards on one
-pod -- the bottleneck is the durable write itself, not CPU or memory. This
+node -- the bottleneck is the durable write itself, not CPU or memory. This
is observed capacity, not an enforced quota; nothing in the deployment caps
a shard's or a table's throughput below it. [Contact
-support](https://www.lancedb.com/contact) if your workload needs more than
-one pod's worth of capacity for a single table.
+support](https://www.lancedb.com/contact) if your workload needs more write
+throughput than this provides.
## What to read next {#next}
-
+
Enable RTE and write to a table; the same call on Embedded or Enterprise.
MemWAL, shards, memtables and SSTables -- the shared architecture.
-
+
How reads combine the WAL tier's fresh rows with the base table across the fleet.
diff --git a/docs/web/enterprise/distributed-search.mdx b/docs/web/enterprise/distributed-search.mdx
index d9ea2b3a3..617c24508 100644
--- a/docs/web/enterprise/distributed-search.mdx
+++ b/docs/web/enterprise/distributed-search.mdx
@@ -1,6 +1,6 @@
---
-title: "Distributed search"
-sidebarTitle: "Distributed search"
+title: "Distributed Search"
+sidebarTitle: "Distributed Search"
description: "How LanceDB Enterprise distributes index execution and table-data reads."
icon: "network-wired"
availability:
diff --git a/docs/web/enterprise/distributed-write.mdx b/docs/web/enterprise/distributed-write.mdx
index 46624d04b..73df91cf1 100644
--- a/docs/web/enterprise/distributed-write.mdx
+++ b/docs/web/enterprise/distributed-write.mdx
@@ -1,6 +1,6 @@
---
-title: "Distributed write"
-sidebarTitle: "Distributed write"
+title: "Distributed Write"
+sidebarTitle: "Distributed Write"
description: "How LanceDB Enterprise distributes a CTAS import's writes across plan executors."
icon: upload
availability:
diff --git a/docs/web/enterprise/gpu-refresh-execution.mdx b/docs/web/enterprise/gpu-refresh-execution.mdx
deleted file mode 100644
index 7fcacf4b5..000000000
--- a/docs/web/enterprise/gpu-refresh-execution.mdx
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: "GPU Refresh Execution"
-tag: "Early access"
-sidebarTitle: "GPU Refresh Execution"
-description: "A computed column or materialized view filled by a GPU Function schedules its refresh workers the same way GPU Function execution does in Data Curation."
-icon: microchip
-keywords: ["gpu", "gpu class", "scheduling", "refresh", "computed column", "function"]
-availability:
- embedded: unavailable
- enterprise: available
----
-
-
Early access
-
-A [computed column](/feature-engineering/add-computed-column) or
-[materialized view](/feature-engineering/materialized-views) filled by a
-registered [Function](/curation/create-function) with `gpu=True` refreshes
-through the exact same placement path as
-[GPU Function execution](/curation/gpu-function-execution) in Data
-Curation -- refreshing a column is not a separate scheduling code path
-from calling the Function directly, just a different caller.
-
-
-
-```mermaid
-%%{init: {"theme": "base", "themeVariables": {
- "background": "#171513", "primaryColor": "#1e1b19", "primaryTextColor": "#f4ebe8",
- "primaryBorderColor": "#4c443f", "lineColor": "#847770", "textColor": "#f4ebe8",
- "edgeLabelBackground": "#171513", "fontFamily": "Inter, sans-serif", "fontSize": "18px"
-}}}%%
-flowchart LR
- F["Function registered with
gpu=True, gpu_class"] --> A{"Who requests
a worker?"}
- A -->|"You, directly"| D["Data Curation:
GPU Function execution"]
- A -->|"A refresh job"| R["Feature Engineering:
computed column / MV refresh"]
- D --> P["Same GPU-class placement,
same capacity-wait behavior"]
- R --> P
- classDef default fill:#1e1b19,stroke:#4c443f,stroke-width:1px,color:#f4ebe8
- classDef accent fill:#2a1810,stroke:#e8582d,stroke-width:1.5px,color:#f4ebe8
- class P accent
-```
-
-
-
-
-
-```mermaid
-%%{init: {"theme": "base", "themeVariables": {
- "background": "#ffffff", "primaryColor": "#ffffff", "primaryTextColor": "#221d19",
- "primaryBorderColor": "#ad9e95", "lineColor": "#6b625c", "textColor": "#221d19",
- "edgeLabelBackground": "#ffffff", "fontFamily": "Inter, sans-serif", "fontSize": "18px"
-}}}%%
-flowchart LR
- F["Function registered with
gpu=True, gpu_class"] --> A{"Who requests
a worker?"}
- A -->|"You, directly"| D["Data Curation:
GPU Function execution"]
- A -->|"A refresh job"| R["Feature Engineering:
computed column / MV refresh"]
- D --> P["Same GPU-class placement,
same capacity-wait behavior"]
- R --> P
- classDef default fill:#ffffff,stroke:#ad9e95,stroke-width:1px,color:#221d19
- classDef accent fill:#fff1ec,stroke:#e8582d,stroke-width:1.5px,color:#221d19
- class P accent
-```
-
-
-
-The Function's `gpu_class` (or the deployment's `default`) resolves to the
-same node selector, tolerations and resource name either way, and a
-refresh that needs more GPU capacity than is currently free waits the
-same way a direct call would -- see
-[Waiting for capacity](/curation/gpu-function-execution#capacity) for that
-behavior in full. [Adaptive Execution](/enterprise/adaptive-execution)'s
-resource-consumption-based sizing applies here too: a refresh's GPU
-utilization is measured and fed back into sizing the *next* part the same
-way CPU and memory are.
-
-A single refresh can also override the Function's registered placement for
-that run -- see
-[Configure workers and resources](/feature-engineering/refresh-column#resources)
-for the `gpu_class`/`gpu_count` options on `refresh_column_async` and the
-equivalent SQL `WITH (...)` clause.
-
-## What to read next {#next}
-
-
-
- The full placement and capacity-wait mechanism this page reuses.
-
-
- How a refresh's resource class, part size and worker count adjust themselves.
-
-
- Override GPU class and count for one refresh call.
-
-
diff --git a/docs/web/enterprise/horizontal-scaling.mdx b/docs/web/enterprise/horizontal-scaling.mdx
index 7ecb4c5a0..8b8f5c6fa 100644
--- a/docs/web/enterprise/horizontal-scaling.mdx
+++ b/docs/web/enterprise/horizontal-scaling.mdx
@@ -211,7 +211,7 @@ placement.
## Scaling interfaces {#scaling-interfaces}
-- [Distributed search](/enterprise/distributed-search) for how a query
+- [Distributed Search](/enterprise/distributed-search) for how a query
divides across query nodes and plan executors generally.
- [Architecture](/index#architecture) for the components a replica group
is made of.
diff --git a/docs/web/enterprise/intelligent-auto-maintenance.mdx b/docs/web/enterprise/intelligent-auto-maintenance.mdx
index 4b52cc267..38cbdd2a5 100644
--- a/docs/web/enterprise/intelligent-auto-maintenance.mdx
+++ b/docs/web/enterprise/intelligent-auto-maintenance.mdx
@@ -11,7 +11,7 @@ availability:
Keeping a table in good condition takes several different kinds of work --
compacting files, catching indexes up, cleaning old versions, folding a
-real-time write tier into the base table -- each with its own trigger. In
+RTE write tier into the base table -- each with its own trigger. In
LanceDB Enterprise, a fleet of agent processes decides when each of these
needs to run, continuously, per table, in the background across your
cluster -- nothing to schedule, trigger, or monitor by hand unless you want
@@ -92,7 +92,7 @@ whichever ones are due:
1. **WAL index catch-up.** Checked first and gated by nothing else, because
it is correctness-driven rather than discretionary: while an index lags
- behind the compacted generation, the real-time write tier cannot trim its
+ behind the compacted generation, the RTE write tier cannot trim its
log. See [RTE Compaction](/enterprise/realtime-engine-compaction).
2. **Index operations.** Reindexing a column, unless a compaction that
cannot defer its remap is about to run this same tick -- deferred-remap
@@ -100,7 +100,7 @@ whichever ones are due:
[Incremental Indexing](/indexing/incremental-indexing).
3. **Compaction.** Whether enough small fragments or deleted rows have
accumulated to merge. See [Compaction](/maintenance/compaction) and
- [Distributed compaction](/enterprise/distributed-compaction).
+ [Distributed Compaction](/enterprise/distributed-compaction).
4. **Cleanup.** Independent of the other four -- it can always run in
parallel with them. [See below](#cleanup) for exactly when it's due.
5. **Deferred-remap catch-up.** The batched, amortized follow-up for index
diff --git a/docs/web/enterprise/realtime-engine-compaction.mdx b/docs/web/enterprise/realtime-engine-compaction.mdx
index 5451111ad..e04429ab8 100644
--- a/docs/web/enterprise/realtime-engine-compaction.mdx
+++ b/docs/web/enterprise/realtime-engine-compaction.mdx
@@ -8,7 +8,7 @@ availability:
enterprise: available
---
-[Distributed compaction](/enterprise/distributed-compaction) merges small
+[Distributed Compaction](/enterprise/distributed-compaction) merges small
base-table fragments and reclaims deleted rows -- the same operation
[Compaction](/maintenance/compaction) describes for LanceDB Embedded. A
table with the [real time engine](/tables/realtime-engine) enabled has a
@@ -191,7 +191,7 @@ Either way, the bound also assumes a free compaction slot when
the shard becomes eligible; an eligible shard can wait in queue behind
`WAL_COMPACT_CONCURRENCY` other passes already running, so the actual
delay can run longer than the trigger alone suggests. See
-[Real Time reads](/search/realtime-read)
+[RTE reads](/search/realtime-read)
for what a live RTE read sees instead.
## What to read next {#next}
@@ -200,7 +200,7 @@ for what a live RTE read sees instead.
The MemWAL format, shards, and WAL nodes this page assumes.
-
+
The unrelated, ordinary compaction every table -- WAL-enabled or not -- gets.
diff --git a/docs/web/enterprise/slurm-refresh-scheduling.mdx b/docs/web/enterprise/slurm-refresh-scheduling.mdx
deleted file mode 100644
index 48fb85985..000000000
--- a/docs/web/enterprise/slurm-refresh-scheduling.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "Slurm Scheduling"
-sidebarTitle: "Slurm Scheduling"
-description: "A computed column or materialized view refresh launches worker pods through the same SUNK-backed scheduling configuration as any other job worker."
-icon: "server"
-keywords: ["slurm", "sunk", "scheduling", "refresh", "computed column"]
-availability:
- embedded: unavailable
- enterprise: available
----
-
-This page is about [Slurm scheduling](/curation/slurm-scheduling) as it
-applies to a computed column or materialized view refresh specifically --
-the mechanism itself is covered in depth on that Data Curation page. A
-refresh's top-level job -- the one that shows up in `SHOW JOBS` -- is an
-agent-launched job worker like any other, and shares the full scheduling
-configuration: node selector, tolerations, scheduler name and
-termination grace period alike.
-
-
-That job's own *child* workers -- the ones that actually plan, finalize
-and run a Function during the refresh -- are different: they inherit the
-scheduler name, but not the termination grace period, so they launch
-with Kubernetes' 30-second default regardless of the shared
-configuration. See [What SUNK changes](/curation/slurm-scheduling#what-changes)
-for why that matters on most SUNK deployments, and confirm with your
-deployment operator before running a Function-backed refresh there.
-
-
-## What to read next {#next}
-
-
-
- The full scheduling configuration this page reuses.
-
-
- GPU-specific placement for a refresh's Function workers.
-
-
diff --git a/docs/web/enterprise/tiered-index-cache.mdx b/docs/web/enterprise/tiered-index-cache.mdx
index f807f04ae..0e54a2575 100644
--- a/docs/web/enterprise/tiered-index-cache.mdx
+++ b/docs/web/enterprise/tiered-index-cache.mdx
@@ -67,21 +67,25 @@ flowchart LR
Where enabled, the index disk tier and the
[data page cache](/enterprise/data-page-cache)'s disk tier draw from one
-combined disk allocation per executor: a configurable percentage of the
-provisioned volume (90% by default, leaving headroom for filesystem
-metadata and kubelet usage), out of which the index disk tier reserves its
-own configurable share of the *full* provisioned volume. On a 200 GiB
-volume, the 90% default leaves 180 GiB combined; reserving 25% of the full
-200 GiB (50 GiB) for the index disk tier leaves the remaining 130 GiB for
-data pages. An exact byte split overrides the percentage split when you
-need one tier sized precisely rather than proportionally. Setting the
-index disk tier's share to zero disables it while leaving the in-memory
-index cache and the data page cache's disk tier untouched.
+combined, configurable disk allocation per executor, split between the two
+tiers so neither one needs its own dedicated volume.
+
+## Why it matters {#why-it-matters}
+
+Vector, full-text, and scalar indexes can easily outgrow available memory
+on large tables. Without this cache, an eviction means re-reading and
+re-deserializing that index from object storage on the next request --
+slow, and repeated on every eviction. Spilling to local disk instead keeps
+index lookups fast even when the working set is larger than memory, without
+giving every executor enough memory to hold every index at once.
+
+[Contact us](https://www.lancedb.com/contact) to learn more about how
+caching is sized and tuned for your workload.
## Index cache interfaces {#interfaces}
-- [Cache Prewarm](/enterprise/cache-prewarm) for how `startup_prewarm_idx`
- warms this cache ahead of the first request.
+- [Cache Prewarm](/enterprise/cache-prewarm) for warming this cache ahead
+ of the first request.
- [Data Page Cache](/enterprise/data-page-cache) for the related cache
that holds raw table data pages instead of deserialized index structures.
- [Vector indexes](/indexing/vector-index), [full-text indexes](/indexing/fts-index),
diff --git a/docs/web/indexing/gpu-indexing.mdx b/docs/web/indexing/gpu-indexing.mdx
index 35169d93b..8370bfba1 100644
--- a/docs/web/indexing/gpu-indexing.mdx
+++ b/docs/web/indexing/gpu-indexing.mdx
@@ -82,7 +82,7 @@ you need to [install PyTorch with CUDA support](https://pytorch.org/get-started/
Keeping an index up-to-date as new data arrives.
-
- How a GPU-bound Function's worker gets scheduled -- the same GPU-placement story for Functions instead of index builds.
+
+ Running these GPU workers alongside training on shared Slurm-scheduled infrastructure.
diff --git a/docs/web/ingestion/define-storage-integration.mdx b/docs/web/ingestion/define-storage-integration.mdx
index 8da9eda33..446d47d22 100644
--- a/docs/web/ingestion/define-storage-integration.mdx
+++ b/docs/web/ingestion/define-storage-integration.mdx
@@ -48,14 +48,6 @@ CREATE STORAGE INTEGRATION raw
STORAGE_AWS_ACCESS_KEY_ID_SECRET = aws_key_id
STORAGE_AWS_SECRET_ACCESS_KEY_SECRET = aws_key_secret
```
-
-
-{/*
-Draft for the storage-integration SDK release (#4618). Keep this section
-unpublished until create_storage_integration ships in a release; it is not
-in v0.41.0.
-
-
```python Python icon="python"
db.create_storage_integration(
"raw", "s3://customer-data/raw/",
@@ -70,7 +62,6 @@ db.create_storage_integration(
aws_secret_access_key_secret="aws_key_secret",
)
```
-
```rust
use lancedb::storage_integration::CreateStorageIntegrationRequest;
@@ -84,7 +75,6 @@ let info = db.create_storage_integration(
).await?;
```
-*/}
### Google Cloud Storage {#gcp}
@@ -95,14 +85,6 @@ CREATE STORAGE INTEGRATION gcs
STORAGE_PREFIX = 'gs://customer-data/raw/'
GCP_CREDENTIALS_JSON_SECRET = gcp_service_account
```
-
-
-{/*
-Draft for the storage-integration SDK release (#4618). Keep this section
-unpublished until create_storage_integration ships in a release; it is not
-in v0.41.0.
-
-
```python Python icon="python"
db.create_storage_integration(
"gcs", "gs://customer-data/raw/",
@@ -111,7 +93,6 @@ db.create_storage_integration(
)
```
-*/}
The Secret holds the full service-account JSON key. GCP has no
role-based alternative.
@@ -128,14 +109,6 @@ CREATE STORAGE INTEGRATION blobs
STORAGE_AZURE_CLIENT_ID_SECRET = azure_client
STORAGE_AZURE_CLIENT_SECRET_SECRET = azure_credential
```
-
-
-{/*
-Draft for the storage-integration SDK release (#4618). Keep this section
-unpublished until create_storage_integration ships in a release; it is not
-in v0.41.0.
-
-
```python Python icon="python"
db.create_storage_integration(
"blobs", "az://customer-data/raw/",
@@ -147,7 +120,6 @@ db.create_storage_integration(
)
```
-*/}
All four options are required together; there is no role-based
alternative for Azure.
@@ -161,14 +133,6 @@ CREATE STORAGE INTEGRATION hub
STORAGE_PREFIX = 'hf://datasets/owner/private/data/'
HUGGINGFACE_TOKEN_SECRET = hf_token
```
-
-
-{/*
-Draft for the storage-integration SDK release (#4618, #4775). Keep this
-section unpublished until create_storage_integration ships in a release;
-it is not in v0.41.0.
-
-
```python Python icon="python"
db.create_storage_integration(
"hub", "hf://datasets/owner/private/data/",
@@ -177,7 +141,6 @@ db.create_storage_integration(
)
```
-*/}
`HUGGINGFACE_TOKEN_SECRET` is required to create this integration; omitting
it is rejected, not treated as anonymous. For anonymous access at
diff --git a/docs/web/ingestion/import.mdx b/docs/web/ingestion/import.mdx
index 0dbe02139..0affeb4cf 100644
--- a/docs/web/ingestion/import.mdx
+++ b/docs/web/ingestion/import.mdx
@@ -45,7 +45,7 @@ Azure examples.
## How the import runs {#distributed}
-See [Distributed write](/enterprise/distributed-write) for how an import's
+See [Distributed Write](/enterprise/distributed-write) for how an import's
writes divide across plan executors, and when a small import instead runs
as one local task.
@@ -65,7 +65,7 @@ omits the destination's unflushed data.
Query and import HuggingFace or object-storage datasets in full.
-
+
How an import's writes divide across plan executors.
diff --git a/docs/web/ingestion/realtime-write.mdx b/docs/web/ingestion/realtime-write.mdx
index c2d389c33..ead2362f3 100644
--- a/docs/web/ingestion/realtime-write.mdx
+++ b/docs/web/ingestion/realtime-write.mdx
@@ -1,5 +1,5 @@
---
-title: "Real Time writes"
+title: "RTE writes"
sidebarTitle: "RTE Write"
description: "Enable the real time engine on a table and absorb small, frequent writes cheaply, each one committed in milliseconds."
icon: "bolt"
@@ -12,7 +12,7 @@ availability:
The [real time engine](/tables/realtime-engine) puts an LSM-style write tier in
front of a table, turning many small writes into a few large commits. This
page covers enabling it and writing to a table; for querying an RTE table, see
-[Real Time reads](/search/realtime-read).
+[RTE reads](/search/realtime-read).
`table.enable_rte(spec)` is the same call on both connections, but what it
does underneath differs:
@@ -22,7 +22,7 @@ does underneath differs:
there is no separate serving layer to scale or configure.
- **Enterprise** forwards the call to the server, which runs it on a
dedicated, horizontally scalable WAL-node tier instead of your table's
- query-serving fleet. See [Distributed Real Time Write](/enterprise/distributed-real-time-write)
+ query-serving fleet. See [Distributed RTE Write](/enterprise/distributed-real-time-write)
for how that tier shards a table's writes and the throughput limits that come with it.
## Getting started {#getting-started}
@@ -162,7 +162,7 @@ conditional updates or deleting rows missing from the source, are rejected.
Writes go through `merge_insert` on the primary key, and are visible to queries
-immediately — see [Real Time reads](/search/realtime-read) for querying them
+immediately — see [RTE reads](/search/realtime-read) for querying them
back:
@@ -232,13 +232,13 @@ your own machine's resources.
An Enterprise table can be split into shards that write independently, with
each shard's durable-append throughput bounded by its WAL node's own
capacity -- measured, not an enforced cap. See
-[Distributed Real Time Write](/enterprise/distributed-real-time-write#throughput)
+[Distributed RTE Write](/enterprise/distributed-real-time-write#throughput)
for the numbers.
## Next steps {#next-steps}
-- [Real Time reads](/search/realtime-read) — query an RTE table
-- [Distributed Real Time Write](/enterprise/distributed-real-time-write) — how Enterprise shards and scales this
+- [RTE reads](/search/realtime-read) — query an RTE table
+- [Distributed RTE Write](/enterprise/distributed-real-time-write) — how Enterprise shards and scales this
- [How the real time engine works](/tables/realtime-engine#memwal-format)
- [Merge insert](/ingestion/merge-insert)
- [`ALTER TABLE ... SET RTE`](/sql/ddl/table#properties)
diff --git a/docs/web/quickstart.mdx b/docs/web/quickstart.mdx
index 11d0ed4ac..5bd9a3efe 100644
--- a/docs/web/quickstart.mdx
+++ b/docs/web/quickstart.mdx
@@ -10,13 +10,6 @@ import { PyQuickstartData, PyQuickstartCreateTable, PyQuickstartAddData, PyQuick
This quickstart uses LanceDB Embedded with a local database and works without an account or API key.
LanceDB Embedded runs in your application's process; your data can live on local disk or in object storage.
-
-Using LanceDB Enterprise? Only the connection changes. In step 2, use the
-[Enterprise](#connect-to-lancedb-enterprise) connection with your deployment's database URI, API key, and endpoint
-in place of the local directory. The remaining steps use the same API, except
-steps 5 and 6, which need Enterprise either way.
-
-
## 1\. Install LanceDB {#1-install-lancedb}
Choose your language. Python uses Pandas to display the search results. TypeScript needs Node.js 22.18 or later to run the `.mts` example directly.
diff --git a/docs/web/search/realtime-read.mdx b/docs/web/search/realtime-read.mdx
index e586a1eac..19c5bc2ab 100644
--- a/docs/web/search/realtime-read.mdx
+++ b/docs/web/search/realtime-read.mdx
@@ -1,5 +1,5 @@
---
-title: "Real Time reads"
+title: "RTE reads"
sidebarTitle: "RTE Read"
description: "Query a table with the real time engine enabled and get writes back within milliseconds of being written, merged transparently with the base table."
icon: "magnifying-glass"
@@ -12,9 +12,9 @@ availability:
A table with the [real time engine](/tables/realtime-engine) enabled queries
the same way as any other table — nothing about `search`, filtering, or SQL
changes. This page covers what you get back; for enabling RTE and writing to
-a table, see [Real Time writes](/ingestion/realtime-write). For how Enterprise
+a table, see [RTE writes](/ingestion/realtime-write). For how Enterprise
combines these results across machines, see
-[Distributed Real Time Read](/enterprise/distributed-real-time-read).
+[Distributed RTE Read](/enterprise/distributed-real-time-read).
## Query a real time table {#query}
@@ -25,7 +25,7 @@ moment ago is already reflected:
```python Python icon="python"
-# continuing the `frames` table connected and written to in Real Time writes
+# continuing the `frames` table connected and written to in RTE writes
import numpy as np
query_vector = np.random.rand(frames.schema.field("embedding").type.list_size).astype("float32")
@@ -57,7 +57,7 @@ maintained-index rules for vector, full-text, and scalar search, just with no
network hop to a separate serving tier. There is no WAL node to route to and
nothing to combine across machines: a query against an RTE-enabled Embedded
table already reads the fresh tier together with the base table in one call.
-See [Distributed Real Time Read](/enterprise/distributed-real-time-read) for
+See [Distributed RTE Read](/enterprise/distributed-real-time-read) for
what Enterprise adds on top when that fresh tier is served by a separate
machine from the one answering the rest of the query.
@@ -77,8 +77,8 @@ available.
## Next steps {#next-steps}
-- [Real Time writes](/ingestion/realtime-write) — enable RTE and write to a table
-- [Distributed Real Time Read](/enterprise/distributed-real-time-read) — combining results across machines in Enterprise
+- [RTE writes](/ingestion/realtime-write) — enable RTE and write to a table
+- [Distributed RTE Read](/enterprise/distributed-real-time-read) — combining results across machines in Enterprise
- [How the real time engine works](/tables/realtime-engine#memwal-format)
- [Hybrid search](/search/hybrid-search)
- [Vector search](/search/vector-search)
diff --git a/docs/web/tables/realtime-engine.mdx b/docs/web/tables/realtime-engine.mdx
index f058cc836..5c6983cc5 100644
--- a/docs/web/tables/realtime-engine.mdx
+++ b/docs/web/tables/realtime-engine.mdx
@@ -25,7 +25,7 @@ table, and nothing about how you query that table changes.
RTE is built on **MemWAL**, a log-structured-merge (LSM) format that Lance
itself defines -- the structure Enterprise serves is part of the open Lance
format, not a layer bolted on beside it. A table with RTE enabled is divided
-into one or more **shards** (see [Real Time writes](/ingestion/realtime-write#primary-key)
+into one or more **shards** (see [RTE writes](/ingestion/realtime-write#primary-key)
for enabling and sizing them), and each shard holds:
- A **memtable**: the active, in-memory table for that shard's newest rows,
@@ -49,8 +49,8 @@ later folds SSTables into the base table, catching its indexes up as it goes.
This section describes LanceDB Enterprise's serving layer. LanceDB Embedded
runs the same MemWAL mechanics directly against the local dataset, in one
process -- there is no separate node to route to or scale; see
-[Real Time writes](/ingestion/realtime-write#getting-started) and
-[Real Time reads](/search/realtime-read#embedded) for what that looks like.
+[RTE writes](/ingestion/realtime-write#getting-started) and
+[RTE reads](/search/realtime-read#embedded) for what that looks like.
RTE's Enterprise serving layer is a dedicated component, separate from the
[query nodes and plan executors](/enterprise/distributed-search)
@@ -81,13 +81,13 @@ pods are never both appending to the same shard's WAL at once.
Every query runs against the base table and the fresh tier -- every shard's
memtable and not-yet-compacted SSTables -- in parallel. Fresh rows supersede
base rows with the same primary key, and the two are merged into one result.
-See [Real Time reads](/search/realtime-read) for what this means for query
+See [RTE reads](/search/realtime-read) for what this means for query
results.
## Next steps {#next-steps}
-- [Real Time writes](/ingestion/realtime-write) — enable RTE and write to a table
-- [Real Time reads](/search/realtime-read) — query an RTE table
-- [Distributed Real Time Write](/enterprise/distributed-real-time-write) — how Enterprise shards and scales writes
-- [Distributed Real Time Read](/enterprise/distributed-real-time-read) — how Enterprise combines reads across machines
+- [RTE writes](/ingestion/realtime-write) — enable RTE and write to a table
+- [RTE reads](/search/realtime-read) — query an RTE table
+- [Distributed RTE Write](/enterprise/distributed-real-time-write) — how Enterprise shards and scales writes
+- [Distributed RTE Read](/enterprise/distributed-real-time-read) — how Enterprise combines reads across machines
- [RTE Compaction](/enterprise/realtime-engine-compaction) — how Enterprise folds shards into the base table