Bump version: 0.24.3-beta.0 → 0.24.3

Bump version: 0.24.2 → 0.24.3-beta.0
ci: remove more mentions of node (#2595 )
2025-12-23 13:29:57 +00:00 · 2025-08-15 18:02:04 +00:00 · 2025-08-15 18:02:04 +00:00 · 2025-08-15 11:01:02 -07:00 · 2025-08-15 10:38:58 -07:00 · 2025-08-15 09:51:19 -07:00
39 changed files with 2100 additions and 502 deletions
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -56,22 +56,11 @@ jobs:
        with:
          node-version: 20
          cache: 'npm'
-          cache-dependency-path: node/package-lock.json
      - name: Install node dependencies
        working-directory: node
        run: |
          sudo apt update
          sudo apt install -y protobuf-compiler libssl-dev
-      - name: Build node
-        working-directory: node
-        run: |
-          npm ci
-          npm run build
-          npm run tsc
-      - name: Create markdown files
-        working-directory: node
-        run: |
-          npx typedoc --plugin typedoc-plugin-markdown --out ../docs/src/javascript src/index.ts
      - name: Build docs
        working-directory: docs
        run: |
--- a/.github/workflows/docs_test.yml
+++ b/.github/workflows/docs_test.yml
@@ -58,51 +58,3 @@ jobs:
      run: |
        cd docs/test/python
        for d in *; do cd "$d"; echo "$d".py; python "$d".py; cd ..; done
-  test-node:
-    name: Test doc nodejs code
-    runs-on: ubuntu-24.04
-    timeout-minutes: 60
-    strategy:
-      fail-fast: false
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-        lfs: true
-    - name: Print CPU capabilities
-      run: cat /proc/cpuinfo
-    - name: Set up Node
-      uses: actions/setup-node@v4
-      with:
-        node-version: 20
-    - name: Install protobuf
-      run: |
-        sudo apt update
-        sudo apt install -y protobuf-compiler
-    - name: Install dependecies needed for ubuntu
-      run: |
-        sudo apt install -y libssl-dev
-        rustup update && rustup default
-    - name: Rust cache
-      uses: swatinem/rust-cache@v2
-    - name: Install node dependencies
-      run: |
-        sudo swapoff -a
-        sudo fallocate -l 8G /swapfile
-        sudo chmod 600 /swapfile
-        sudo mkswap /swapfile
-        sudo swapon /swapfile
-        sudo swapon --show
-        cd node
-        npm ci
-        npm run build-release
-        cd ../docs
-        npm install
-    - name: Test
-      env:
-        LANCEDB_URI: ${{ secrets.LANCEDB_URI }}
-        LANCEDB_DEV_API_KEY: ${{ secrets.LANCEDB_DEV_API_KEY }}
-      run: |
-        cd docs
-        npm t
--- a/.github/workflows/nodejs.yml
+++ b/.github/workflows/nodejs.yml
@@ -79,7 +79,7 @@ jobs:
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
-        cache-dependency-path: node/package-lock.json
+        cache-dependency-path: nodejs/package-lock.json
    - uses: Swatinem/rust-cache@v2
    - name: Install dependencies
      run: |
@@ -137,7 +137,7 @@ jobs:
      with:
        node-version: 20
        cache: 'npm'
-        cache-dependency-path: node/package-lock.json
+        cache-dependency-path: nodejs/package-lock.json
    - uses: Swatinem/rust-cache@v2
    - name: Install dependencies
      run: |
--- a/.gitignore
+++ b/.gitignore
@@ -31,9 +31,6 @@ python/dist
 *.node
 **/node_modules
 **/.DS_Store
-node/dist
-node/examples/**/package-lock.json
-node/examples/**/dist
 nodejs/lancedb/native*
 dist

--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -11,8 +11,6 @@ Project layout:
 * `nodejs`: The Typescript bindings, using napi-rs
 * `java`: The Java bindings

-(`rust/ffi` and `node/` are for a deprecated package. You can ignore them.)
-
 Common commands:

 * Check for compiler errors: `cargo check --features remote --tests --examples`
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1721,9 +1721,9 @@ dependencies = [

 [[package]]
 name = "crunchy"
-version = "0.2.2"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"

 [[package]]
 name = "crypto-bigint"
@@ -2837,11 +2837,12 @@ checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"

 [[package]]
 name = "fsst"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "548190a42654ce848835b410ae33f43b4d55cb24548fd0a885a289a1d5a95019"
 dependencies = [
 "arrow-array",
- "rand 0.8.5",
+ "rand 0.9.1",
 ]

 [[package]]
@@ -3951,8 +3952,9 @@ dependencies = [

 [[package]]
 name = "lance"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94bafd9d9a9301c1eac48892ec8016d4d28204d4fc55f2ebebee9a7af465e152"
 dependencies = [
 "arrow",
 "arrow-arith",
@@ -3999,7 +4001,7 @@ dependencies = [
 "pin-project",
 "prost",
 "prost-types",
- "rand 0.8.5",
+ "rand 0.9.1",
 "roaring",
 "serde",
 "serde_json",
@@ -4014,8 +4016,9 @@ dependencies = [

 [[package]]
 name = "lance-arrow"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97ebcd8edc2b534e8ded20c97c8928e275160794af91ed803a3d48d8d2a88d8"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4027,13 +4030,14 @@ dependencies = [
 "getrandom 0.2.16",
 "half",
 "num-traits",
- "rand 0.8.5",
+ "rand 0.9.1",
 ]

 [[package]]
 name = "lance-core"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce5c1849d07985d6a5011aca9de43c7a42ec4c996d66ef3f2d9896c227cc934c"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4055,7 +4059,7 @@ dependencies = [
 "object_store",
 "pin-project",
 "prost",
- "rand 0.8.5",
+ "rand 0.9.1",
 "roaring",
 "serde_json",
 "snafu",
@@ -4068,8 +4072,9 @@ dependencies = [

 [[package]]
 name = "lance-datafusion"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d355c087bc66d85e36cfb428465f585b13971e1e13585dd2b6886a54d8a7d9a4"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -4097,8 +4102,9 @@ dependencies = [

 [[package]]
 name = "lance-datagen"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "110d4dedfe02e9cff8f11cfb64a261755da7ee9131845197efeec8b659cc5513"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -4107,15 +4113,16 @@ dependencies = [
 "chrono",
 "futures",
 "hex",
- "rand 0.8.5",
+ "rand 0.9.1",
 "rand_xoshiro",
 "random_word 0.5.0",
 ]

 [[package]]
 name = "lance-encoding"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66750006299a2fb003091bc290eb1fe2a5933e35236d921934131f3e4629cd33"
 dependencies = [
 "arrayref",
 "arrow",
@@ -4143,7 +4150,7 @@ dependencies = [
 "prost",
 "prost-build",
 "prost-types",
- "rand 0.8.5",
+ "rand 0.9.1",
 "seq-macro",
 "snafu",
 "tokio",
@@ -4154,8 +4161,9 @@ dependencies = [

 [[package]]
 name = "lance-file"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c639062100610a075e01fd455173348b2fccea10cb0e89f70e38a3183c56022"
 dependencies = [
 "arrow-arith",
 "arrow-array",
@@ -4189,8 +4197,9 @@ dependencies = [

 [[package]]
 name = "lance-index"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ae67a048a51fb525d1bfde86d1b39118462277e7e7a7cd0e7ba866312873532"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -4228,7 +4237,7 @@ dependencies = [
 "object_store",
 "prost",
 "prost-build",
- "rand 0.8.5",
+ "rand 0.9.1",
 "rayon",
 "roaring",
 "serde",
@@ -4243,8 +4252,9 @@ dependencies = [

 [[package]]
 name = "lance-io"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc86c7307e2d3d895cfefa503f986edcbdd208eb0aa89ba2c75724ba04bce843"
 dependencies = [
 "arrow",
 "arrow-arith",
@@ -4273,7 +4283,7 @@ dependencies = [
 "path_abs",
 "pin-project",
 "prost",
- "rand 0.8.5",
+ "rand 0.9.1",
 "serde",
 "shellexpand",
 "snafu",
@@ -4284,8 +4294,9 @@ dependencies = [

 [[package]]
 name = "lance-linalg"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "769f910b6f2ad5eb4d1b3071c533b619351e61e0dfca74f13c98680a8e6476e9"
 dependencies = [
 "arrow-array",
 "arrow-buffer",
@@ -4300,7 +4311,7 @@ dependencies = [
 "lance-core",
 "log",
 "num-traits",
- "rand 0.8.5",
+ "rand 0.9.1",
 "rayon",
 "tokio",
 "tracing",
@@ -4308,8 +4319,9 @@ dependencies = [

 [[package]]
 name = "lance-table"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffbeafa8a3e97b5b3a06f06d69b0cefe56e65c64a33f674c40c113b797328bd2"
 dependencies = [
 "arrow",
 "arrow-array",
@@ -4333,7 +4345,7 @@ dependencies = [
 "prost",
 "prost-build",
 "prost-types",
- "rand 0.8.5",
+ "rand 0.9.1",
 "rangemap",
 "roaring",
 "serde",
@@ -4347,14 +4359,15 @@ dependencies = [

 [[package]]
 name = "lance-testing"
-version = "0.32.1"
-source = "git+https://github.com/lancedb/lance.git?tag=v0.32.1-beta.2#2d57f221d3f13a96b1eac5b072c07a92b52e93cf"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "535a3bba37625cd515a7172a8d0d138f86822acef9fa9425ad1e050ef88bf92f"
 dependencies = [
 "arrow-array",
 "arrow-schema",
 "lance-arrow",
 "num-traits",
- "rand 0.8.5",
+ "rand 0.9.1",
 ]

 [[package]]
@@ -6236,11 +6249,11 @@ dependencies = [

 [[package]]
 name = "rand_xoshiro"
-version = "0.6.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
+checksum = "f703f4665700daf5512dcca5f43afa6af89f09db47fb56be587f80636bda2d41"
 dependencies = [
- "rand_core 0.6.4",
+ "rand_core 0.9.3",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,5 @@
 [workspace]
-members = [
-    "rust/lancedb",
-    "nodejs",
-    "python",
-    "java/core/lancedb-jni",
-]
+members = ["rust/lancedb", "nodejs", "python", "java/core/lancedb-jni"]
 # Python package needs to be built by maturin.
 exclude = ["python"]
 resolver = "2"
@@ -20,16 +15,14 @@ categories = ["database-implementations"]
 rust-version = "1.78.0"

 [workspace.dependencies]
-lance = { "version" = "=0.32.1", "features" = [
-    "dynamodb",
-], "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
-lance-io = { "version" = "=0.32.1", "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
-lance-index = { "version" = "=0.32.1", "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
-lance-linalg = { "version" = "=0.32.1", "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
-lance-table = { "version" = "=0.32.1", "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
-lance-testing = { "version" = "=0.32.1", "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
-lance-datafusion = { "version" = "=0.32.1", "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
-lance-encoding = { "version" = "=0.32.1", "tag" = "v0.32.1-beta.2", "git" = "https://github.com/lancedb/lance.git" }
+lance = { "version" = "=0.33.0", "features" = ["dynamodb"] }
+lance-io = "=0.33.0"
+lance-index = "=0.33.0"
+lance-linalg = "=0.33.0"
+lance-table = "=0.33.0"
+lance-testing = "=0.33.0"
+lance-datafusion = "=0.33.0"
+lance-encoding = "=0.33.0"
 # Note that this one does not include pyarrow
 arrow = { version = "55.1", optional = false }
 arrow-array = "55.1"
@@ -62,12 +55,11 @@ rand = "0.9"
 regex = "1.10"
 lazy_static = "1"
 semver = "1.0.25"
+crunchy = "0.2.4"
 # Temporary pins to work around downstream issues
 # https://github.com/apache/arrow-rs/commit/2fddf85afcd20110ce783ed5b4cdeb82293da30b
 chrono = "=0.4.41"
 # https://github.com/RustCrypto/formats/issues/1684
 base64ct = "=1.6.0"
-# Workaround for: https://github.com/eira-fransham/crunchy/issues/13
-crunchy = "=0.2.2"
 # Workaround for: https://github.com/Lokathor/bytemuck/issues/306
 bytemuck_derive = ">=1.8.1, <1.9.0"
--- a/ci/update_lockfiles.sh
+++ b/ci/update_lockfiles.sh
@@ -15,16 +15,13 @@ cargo metadata --quiet > /dev/null
 pushd nodejs || exit 1
 npm install --package-lock-only --silent
 popd
-pushd node || exit 1
-npm install --package-lock-only --silent
-popd

 if git diff --quiet --exit-code; then
  echo "No lockfile changes to commit; skipping amend."
 elif $AMEND; then
-  git add Cargo.lock nodejs/package-lock.json node/package-lock.json
+  git add Cargo.lock nodejs/package-lock.json
  git commit --amend --no-edit
 else
-  git add Cargo.lock nodejs/package-lock.json node/package-lock.json
+  git add Cargo.lock nodejs/package-lock.json
  git commit -m "Update lockfiles"
 fi
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -103,6 +103,264 @@ markdown_extensions:
      permalink: ""

 nav:
+  - Home:
+      - LanceDB: index.md
+      - 🏃🏼‍♂️ Quick start: basic.md
+      - 📚 Concepts:
+          - Vector search: concepts/vector_search.md
+          - Indexing:
+              - IVFPQ: concepts/index_ivfpq.md
+              - HNSW: concepts/index_hnsw.md
+          - Storage: concepts/storage.md
+          - Data management: concepts/data_management.md
+      - 🔨 Guides:
+          - Working with tables: guides/tables.md
+          - Building a vector index: ann_indexes.md
+          - Vector Search: search.md
+          - Full-text search (native): fts.md
+          - Full-text search (tantivy-based): fts_tantivy.md
+          - Building a scalar index: guides/scalar_index.md
+          - Hybrid search:
+              - Overview: hybrid_search/hybrid_search.md
+              - Comparing Rerankers: hybrid_search/eval.md
+              - Airbnb financial data example: notebooks/hybrid_search.ipynb
+          - Late interaction with MultiVector search:
+              - Overview: guides/multi-vector.md
+              - Example: notebooks/Multivector_on_LanceDB.ipynb
+          - RAG:
+              - Vanilla RAG: rag/vanilla_rag.md
+              - Multi-head RAG: rag/multi_head_rag.md
+              - Corrective RAG: rag/corrective_rag.md
+              - Agentic RAG: rag/agentic_rag.md
+              - Graph RAG: rag/graph_rag.md
+              - Self RAG: rag/self_rag.md
+              - Adaptive RAG: rag/adaptive_rag.md
+              - SFR RAG: rag/sfr_rag.md
+              - Advanced Techniques:
+                  - HyDE: rag/advanced_techniques/hyde.md
+                  - FLARE: rag/advanced_techniques/flare.md
+          - Reranking:
+              - Quickstart: reranking/index.md
+              - Cohere Reranker: reranking/cohere.md
+              - Linear Combination Reranker: reranking/linear_combination.md
+              - Reciprocal Rank Fusion Reranker: reranking/rrf.md
+              - Cross Encoder Reranker: reranking/cross_encoder.md
+              - ColBERT Reranker: reranking/colbert.md
+              - Jina Reranker: reranking/jina.md
+              - OpenAI Reranker: reranking/openai.md
+              - AnswerDotAi Rerankers: reranking/answerdotai.md
+              - Voyage AI Rerankers: reranking/voyageai.md
+              - Building Custom Rerankers: reranking/custom_reranker.md
+              - Example: notebooks/lancedb_reranking.ipynb
+          - Filtering: sql.md
+          - Versioning & Reproducibility:
+              - sync API: notebooks/reproducibility.ipynb
+              - async API: notebooks/reproducibility_async.ipynb
+          - Configuring Storage: guides/storage.md
+          - Migration Guide: migration.md
+          - Tuning retrieval performance:
+              - Choosing right query type: guides/tuning_retrievers/1_query_types.md
+              - Reranking: guides/tuning_retrievers/2_reranking.md
+              - Embedding fine-tuning: guides/tuning_retrievers/3_embed_tuning.md
+      - 🧬 Managing embeddings:
+          - Understand Embeddings: embeddings/understanding_embeddings.md
+          - Get Started: embeddings/index.md
+          - Embedding functions: embeddings/embedding_functions.md
+          - Available models:
+              - Overview: embeddings/default_embedding_functions.md
+              - Text Embedding Functions:
+                  - Sentence Transformers: embeddings/available_embedding_models/text_embedding_functions/sentence_transformers.md
+                  - Huggingface Embedding Models: embeddings/available_embedding_models/text_embedding_functions/huggingface_embedding.md
+                  - Ollama Embeddings: embeddings/available_embedding_models/text_embedding_functions/ollama_embedding.md
+                  - OpenAI Embeddings: embeddings/available_embedding_models/text_embedding_functions/openai_embedding.md
+                  - Instructor Embeddings: embeddings/available_embedding_models/text_embedding_functions/instructor_embedding.md
+                  - Gemini Embeddings: embeddings/available_embedding_models/text_embedding_functions/gemini_embedding.md
+                  - Cohere Embeddings: embeddings/available_embedding_models/text_embedding_functions/cohere_embedding.md
+                  - Jina Embeddings: embeddings/available_embedding_models/text_embedding_functions/jina_embedding.md
+                  - AWS Bedrock Text Embedding Functions: embeddings/available_embedding_models/text_embedding_functions/aws_bedrock_embedding.md
+                  - IBM watsonx.ai Embeddings: embeddings/available_embedding_models/text_embedding_functions/ibm_watsonx_ai_embedding.md
+                  - Voyage AI Embeddings: embeddings/available_embedding_models/text_embedding_functions/voyageai_embedding.md
+              - Multimodal Embedding Functions:
+                  - OpenClip embeddings: embeddings/available_embedding_models/multimodal_embedding_functions/openclip_embedding.md
+                  - Imagebind embeddings: embeddings/available_embedding_models/multimodal_embedding_functions/imagebind_embedding.md
+                  - Jina Embeddings: embeddings/available_embedding_models/multimodal_embedding_functions/jina_multimodal_embedding.md
+          - User-defined embedding functions: embeddings/custom_embedding_function.md
+          - Variables and secrets: embeddings/variables_and_secrets.md
+          - "Example: Multi-lingual semantic search": notebooks/multi_lingual_example.ipynb
+          - "Example: MultiModal CLIP Embeddings": notebooks/DisappearingEmbeddingFunction.ipynb
+      - 🔌 Integrations:
+          - Tools and data formats: integrations/index.md
+          - Pandas and PyArrow: python/pandas_and_pyarrow.md
+          - Polars: python/polars_arrow.md
+          - DuckDB: python/duckdb.md
+          - Datafusion: python/datafusion.md
+          - LangChain:
+              - LangChain 🔗: integrations/langchain.md
+              - LangChain demo: notebooks/langchain_demo.ipynb
+              - LangChain JS/TS 🔗: https://js.langchain.com/docs/integrations/vectorstores/lancedb
+          - LlamaIndex 🦙:
+              - LlamaIndex docs: integrations/llamaIndex.md
+              - LlamaIndex demo: notebooks/llamaIndex_demo.ipynb
+          - Pydantic: python/pydantic.md
+          - Voxel51: integrations/voxel51.md
+          - PromptTools: integrations/prompttools.md
+          - dlt: integrations/dlt.md
+          - phidata: integrations/phidata.md
+          - Genkit: integrations/genkit.md
+      - 🎯 Examples:
+          - Overview: examples/index.md
+          - 🐍 Python:
+              - Overview: examples/examples_python.md
+              - Build From Scratch: examples/python_examples/build_from_scratch.md
+              - Multimodal: examples/python_examples/multimodal.md
+              - Rag: examples/python_examples/rag.md
+              - Vector Search: examples/python_examples/vector_search.md
+              - Chatbot: examples/python_examples/chatbot.md
+              - Evaluation: examples/python_examples/evaluations.md
+              - AI Agent: examples/python_examples/aiagent.md
+              - Recommender System: examples/python_examples/recommendersystem.md
+              - Miscellaneous:
+                  - Serverless QA Bot with S3 and Lambda: examples/serverless_lancedb_with_s3_and_lambda.md
+                  - Serverless QA Bot with Modal: examples/serverless_qa_bot_with_modal_and_langchain.md
+          - 👾 JavaScript:
+              - Overview: examples/examples_js.md
+              - Serverless Website Chatbot: examples/serverless_website_chatbot.md
+              - YouTube Transcript Search: examples/youtube_transcript_bot_with_nodejs.md
+              - TransformersJS Embedding Search: examples/transformerjs_embedding_search_nodejs.md
+          - 🦀 Rust:
+              - Overview: examples/examples_rust.md
+      - 📓 Studies:
+          - ↗Improve retrievers with hybrid search and reranking: https://blog.lancedb.com/hybrid-search-and-reranking-report/
+      - 💭 FAQs: faq.md
+      - 🔍 Troubleshooting: troubleshooting.md
+      - ⚙️ API reference:
+          - 🐍 Python: python/python.md
+          - 👾 JavaScript (vectordb): javascript/modules.md
+          - 👾 JavaScript (lancedb): js/globals.md
+          - 🦀 Rust: https://docs.rs/lancedb/latest/lancedb/
+
+  - Quick start: basic.md
+  - Concepts:
+      - Vector search: concepts/vector_search.md
+      - Indexing:
+          - IVFPQ: concepts/index_ivfpq.md
+          - HNSW: concepts/index_hnsw.md
+      - Storage: concepts/storage.md
+      - Data management: concepts/data_management.md
+  - Guides:
+      - Working with tables: guides/tables.md
+      - Working with SQL: guides/sql_querying.md
+      - Building an ANN index: ann_indexes.md
+      - Vector Search: search.md
+      - Full-text search (native): fts.md
+      - Full-text search (tantivy-based): fts_tantivy.md
+      - Building a scalar index: guides/scalar_index.md
+      - Hybrid search:
+          - Overview: hybrid_search/hybrid_search.md
+          - Comparing Rerankers: hybrid_search/eval.md
+          - Airbnb financial data example: notebooks/hybrid_search.ipynb
+      - Late interaction with MultiVector search:
+          - Overview: guides/multi-vector.md
+          - Document search Example: notebooks/Multivector_on_LanceDB.ipynb
+      - RAG:
+          - Vanilla RAG: rag/vanilla_rag.md
+          - Multi-head RAG: rag/multi_head_rag.md
+          - Corrective RAG: rag/corrective_rag.md
+          - Agentic RAG: rag/agentic_rag.md
+          - Graph RAG: rag/graph_rag.md
+          - Self RAG: rag/self_rag.md
+          - Adaptive RAG: rag/adaptive_rag.md
+          - SFR RAG: rag/sfr_rag.md
+          - Advanced Techniques:
+              - HyDE: rag/advanced_techniques/hyde.md
+              - FLARE: rag/advanced_techniques/flare.md
+      - Reranking:
+          - Quickstart: reranking/index.md
+          - Cohere Reranker: reranking/cohere.md
+          - Linear Combination Reranker: reranking/linear_combination.md
+          - Reciprocal Rank Fusion Reranker: reranking/rrf.md
+          - Cross Encoder Reranker: reranking/cross_encoder.md
+          - ColBERT Reranker: reranking/colbert.md
+          - Jina Reranker: reranking/jina.md
+          - OpenAI Reranker: reranking/openai.md
+          - AnswerDotAi Rerankers: reranking/answerdotai.md
+          - Building Custom Rerankers: reranking/custom_reranker.md
+          - Example: notebooks/lancedb_reranking.ipynb
+      - Filtering: sql.md
+      - Versioning & Reproducibility:
+          - sync API: notebooks/reproducibility.ipynb
+          - async API: notebooks/reproducibility_async.ipynb
+      - Configuring Storage: guides/storage.md
+      - Migration Guide: migration.md
+      - Tuning retrieval performance:
+          - Choosing right query type: guides/tuning_retrievers/1_query_types.md
+          - Reranking: guides/tuning_retrievers/2_reranking.md
+          - Embedding fine-tuning: guides/tuning_retrievers/3_embed_tuning.md
+  - Managing Embeddings:
+      - Understand Embeddings: embeddings/understanding_embeddings.md
+      - Get Started: embeddings/index.md
+      - Embedding functions: embeddings/embedding_functions.md
+      - Available models:
+          - Overview: embeddings/default_embedding_functions.md
+          - Text Embedding Functions:
+              - Sentence Transformers: embeddings/available_embedding_models/text_embedding_functions/sentence_transformers.md
+              - Huggingface Embedding Models: embeddings/available_embedding_models/text_embedding_functions/huggingface_embedding.md
+              - Ollama Embeddings: embeddings/available_embedding_models/text_embedding_functions/ollama_embedding.md
+              - OpenAI Embeddings: embeddings/available_embedding_models/text_embedding_functions/openai_embedding.md
+              - Instructor Embeddings: embeddings/available_embedding_models/text_embedding_functions/instructor_embedding.md
+              - Gemini Embeddings: embeddings/available_embedding_models/text_embedding_functions/gemini_embedding.md
+              - Cohere Embeddings: embeddings/available_embedding_models/text_embedding_functions/cohere_embedding.md
+              - Jina Embeddings: embeddings/available_embedding_models/text_embedding_functions/jina_embedding.md
+              - AWS Bedrock Text Embedding Functions: embeddings/available_embedding_models/text_embedding_functions/aws_bedrock_embedding.md
+              - IBM watsonx.ai Embeddings: embeddings/available_embedding_models/text_embedding_functions/ibm_watsonx_ai_embedding.md
+          - Multimodal Embedding Functions:
+              - OpenClip embeddings: embeddings/available_embedding_models/multimodal_embedding_functions/openclip_embedding.md
+              - Imagebind embeddings: embeddings/available_embedding_models/multimodal_embedding_functions/imagebind_embedding.md
+              - Jina Embeddings: embeddings/available_embedding_models/multimodal_embedding_functions/jina_multimodal_embedding.md
+      - User-defined embedding functions: embeddings/custom_embedding_function.md
+      - Variables and secrets: embeddings/variables_and_secrets.md
+      - "Example: Multi-lingual semantic search": notebooks/multi_lingual_example.ipynb
+      - "Example: MultiModal CLIP Embeddings": notebooks/DisappearingEmbeddingFunction.ipynb
+  - Integrations:
+      - Overview: integrations/index.md
+      - Pandas and PyArrow: python/pandas_and_pyarrow.md
+      - Polars: python/polars_arrow.md
+      - DuckDB: python/duckdb.md
+      - Datafusion: python/datafusion.md
+      - LangChain 🦜️🔗↗: integrations/langchain.md
+      - LangChain.js 🦜️🔗↗: https://js.langchain.com/docs/integrations/vectorstores/lancedb
+      - LlamaIndex 🦙↗: integrations/llamaIndex.md
+      - Pydantic: python/pydantic.md
+      - Voxel51: integrations/voxel51.md
+      - PromptTools: integrations/prompttools.md
+      - dlt: integrations/dlt.md
+      - phidata: integrations/phidata.md
+      - Genkit: integrations/genkit.md
+  - Examples:
+      - examples/index.md
+      - 🐍 Python:
+          - Overview: examples/examples_python.md
+          - Build From Scratch: examples/python_examples/build_from_scratch.md
+          - Multimodal: examples/python_examples/multimodal.md
+          - Rag: examples/python_examples/rag.md
+          - Vector Search: examples/python_examples/vector_search.md
+          - Chatbot: examples/python_examples/chatbot.md
+          - Evaluation: examples/python_examples/evaluations.md
+          - AI Agent: examples/python_examples/aiagent.md
+          - Recommender System: examples/python_examples/recommendersystem.md
+          - Miscellaneous:
+              - Serverless QA Bot with S3 and Lambda: examples/serverless_lancedb_with_s3_and_lambda.md
+              - Serverless QA Bot with Modal: examples/serverless_qa_bot_with_modal_and_langchain.md
+      - 👾 JavaScript:
+          - Overview: examples/examples_js.md
+          - Serverless Website Chatbot: examples/serverless_website_chatbot.md
+          - YouTube Transcript Search: examples/youtube_transcript_bot_with_nodejs.md
+          - TransformersJS Embedding Search: examples/transformerjs_embedding_search_nodejs.md
+      - 🦀 Rust:
+          - Overview: examples/examples_rust.md
+  - Studies:
+      - studies/overview.md
+      - ↗Improve retrievers with hybrid search and reranking: https://blog.lancedb.com/hybrid-search-and-reranking-report/
  - API reference:
      - Overview: api_reference.md
      - Python: python/python.md
--- a/docs/src/concepts/data_management.md
+++ b/docs/src/concepts/data_management.md
@@ -13,7 +13,7 @@ The following concepts are important to keep in mind:
 - Data is versioned, with each insert operation creating a new version of the dataset and an update to the manifest that tracks versions via metadata

 !!! note
-    1. First, each version contains metadata and just the new/updated data in your transaction. So if you have 100 versions, they aren't 100 duplicates of the same data. However, they do have 100x the metadata overhead of a single version, which can result in slower queries.  
+    1. First, each version contains metadata and just the new/updated data in your transaction. So if you have 100 versions, they aren't 100 duplicates of the same data. However, they do have 100x the metadata overhead of a single version, which can result in slower queries.
    2. Second, these versions exist to keep LanceDB scalable and consistent. We do not immediately blow away old versions when creating new ones because other clients might be in the middle of querying the old version. It's important to retain older versions for as long as they might be queried.

 ## What are fragments?
@@ -37,6 +37,10 @@ Depending on the use case and dataset, optimal compaction will have different re
 - It’s always better to use *batch* inserts rather than adding 1 row at a time (to avoid too small fragments). If single-row inserts are unavoidable, run compaction on a regular basis to merge them into larger fragments.
 - Keep the number of fragments under 100, which is suitable for most use cases (for *really* large datasets of >500M rows, more fragments might be needed)

+!!! note
+
+    LanceDB Cloud/Enterprise supports [auto-compaction](https://docs.lancedb.com/enterprise/architecture/architecture#write-path) which automatically optimizes fragments in the background as data changes.
+
 ## Deletion

 Although Lance allows you to delete rows from a dataset, it does not actually delete the data immediately. It simply marks the row as deleted in the `DataFile` that represents a fragment. For a given version of the dataset, each fragment can have up to one deletion file (if no rows were ever deleted from that fragment, it will not have a deletion file). This is important to keep in mind because it means that the data is still there, and can be recovered if needed, as long as that version still exists based on your backup policy.
@@ -50,13 +54,9 @@ Reindexing is the process of updating the index to account for new data, keeping

 Both LanceDB OSS and Cloud support reindexing, but the process (at least for now) is different for each, depending on the type of index.

-When a reindex job is triggered in the background, the entire data is reindexed, but in the interim as new queries come in, LanceDB will combine results from the existing index with exhaustive kNN search on the new data. This is done to ensure that you're still searching on all your data, but it does come at a performance cost. The more data that you add without reindexing, the impact on latency (due to exhaustive search) can be noticeable.
+In LanceDB OSS, re-indexing happens synchronously when you call either `create_index` or `optimize` on a table. In LanceDB Cloud, re-indexing happens asynchronously as you add and update data in your table.

-### Vector reindex
+By default, queries will search new data even if it has yet to be indexed. This is done using brute-force methods, such as kNN for vector search, and combined with the fast index search results. This is done to ensure that you're always searching over all your data, but it does come at a performance cost. Without reindexing, adding more data to a table will make queries slower and more expensive. This behavior can be disabled by setting the [fast_search](https://lancedb.github.io/lancedb/python/python/#lancedb.query.AsyncQuery.fast_search) parameter which will instruct the query to ignore un-indexed data.

-* LanceDB Cloud supports incremental reindexing, where a background process will trigger a new index build for you automatically when new data is added to a dataset
+* LanceDB Cloud/Enterprise supports [automatic incremental reindexing](https://docs.lancedb.com/core#vector-index) for vector, scalar, and FTS indices, where a background process will trigger a new index build for you automatically when new data is added or modified in a dataset
 * LanceDB OSS requires you to manually trigger a reindex operation -- we are working on adding incremental reindexing to LanceDB OSS as well
-
-### FTS reindex
-
-FTS reindexing is supported in both LanceDB OSS and Cloud, but requires that it's manually rebuilt once you have a significant enough amount of new data added that needs to be reindexed. We [updated](https://github.com/lancedb/lancedb/pull/762) Tantivy's default heap size from 128MB to 1GB in LanceDB to make it much faster to reindex, by up to 10x from the default settings.
--- a/docs/src/js/classes/Query.md
+++ b/docs/src/js/classes/Query.md
@@ -14,7 +14,7 @@ A builder for LanceDB queries.

 ## Extends

- [`QueryBase`](QueryBase.md)&lt;`NativeQuery`&gt;
+- `StandardQueryBase`&lt;`NativeQuery`&gt;

 ## Properties

@@ -26,7 +26,7 @@ protected inner: Query | Promise<Query>;

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`inner`](QueryBase.md#inner)
+`StandardQueryBase.inner`

 ## Methods

@@ -73,7 +73,7 @@ AnalyzeExec verbose=true, metrics=[]

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`analyzePlan`](QueryBase.md#analyzeplan)
+`StandardQueryBase.analyzePlan`

 ***

@@ -107,7 +107,7 @@ single query)

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`execute`](QueryBase.md#execute)
+`StandardQueryBase.execute`

 ***

@@ -143,7 +143,7 @@ const plan = await table.query().nearestTo([0.5, 0.2]).explainPlan();

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`explainPlan`](QueryBase.md#explainplan)
+`StandardQueryBase.explainPlan`

 ***

@@ -164,7 +164,7 @@ Use [Table#optimize](Table.md#optimize) to index all un-indexed data.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`fastSearch`](QueryBase.md#fastsearch)
+`StandardQueryBase.fastSearch`

 ***

@@ -194,7 +194,7 @@ Use `where` instead

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`filter`](QueryBase.md#filter)
+`StandardQueryBase.filter`

 ***

@@ -216,7 +216,7 @@ fullTextSearch(query, options?): this

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`fullTextSearch`](QueryBase.md#fulltextsearch)
+`StandardQueryBase.fullTextSearch`

 ***

@@ -241,7 +241,7 @@ called then every valid row from the table will be returned.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`limit`](QueryBase.md#limit)
+`StandardQueryBase.limit`

 ***

@@ -325,6 +325,10 @@ nearestToText(query, columns?): Query
 offset(offset): this
 ```

+Set the number of rows to skip before returning results.
+
+This is useful for pagination.
+
 #### Parameters

 * **offset**: `number`
@@ -335,7 +339,7 @@ offset(offset): this

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`offset`](QueryBase.md#offset)
+`StandardQueryBase.offset`

 ***

@@ -388,7 +392,7 @@ object insertion order is easy to get wrong and `Map` is more foolproof.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`select`](QueryBase.md#select)
+`StandardQueryBase.select`

 ***

@@ -410,7 +414,7 @@ Collect the results as an array of objects.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`toArray`](QueryBase.md#toarray)
+`StandardQueryBase.toArray`

 ***

@@ -436,7 +440,7 @@ ArrowTable.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`toArrow`](QueryBase.md#toarrow)
+`StandardQueryBase.toArrow`

 ***

@@ -471,7 +475,7 @@ on the filter column(s).

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`where`](QueryBase.md#where)
+`StandardQueryBase.where`

 ***

@@ -493,4 +497,4 @@ order to perform hybrid search.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`withRowId`](QueryBase.md#withrowid)
+`StandardQueryBase.withRowId`
--- a/docs/src/js/classes/QueryBase.md
+++ b/docs/src/js/classes/QueryBase.md
@@ -15,12 +15,11 @@ Common methods supported by all query types

 ## Extended by

- [`Query`](Query.md)
- [`VectorQuery`](VectorQuery.md)
+- [`TakeQuery`](TakeQuery.md)

 ## Type Parameters

-• **NativeQueryType** *extends* `NativeQuery` \| `NativeVectorQuery`
+• **NativeQueryType** *extends* `NativeQuery` \| `NativeVectorQuery` \| `NativeTakeQuery`

 ## Implements

@@ -141,104 +140,6 @@ const plan = await table.query().nearestTo([0.5, 0.2]).explainPlan();

 ***

-### fastSearch()
-
-```ts
-fastSearch(): this
-```
-
-Skip searching un-indexed data. This can make search faster, but will miss
-any data that is not yet indexed.
-
-Use [Table#optimize](Table.md#optimize) to index all un-indexed data.
-
-#### Returns
-
-`this`
-
-***
-
-### ~~filter()~~
-
-```ts
-filter(predicate): this
-```
-
-A filter statement to be applied to this query.
-
-#### Parameters
-
-* **predicate**: `string`
-
-#### Returns
-
-`this`
-
-#### See
-
-where
-
-#### Deprecated
-
-Use `where` instead
-
-***
-
-### fullTextSearch()
-
-```ts
-fullTextSearch(query, options?): this
-```
-
-#### Parameters
-
-* **query**: `string` \| [`FullTextQuery`](../interfaces/FullTextQuery.md)
-
-* **options?**: `Partial`&lt;[`FullTextSearchOptions`](../interfaces/FullTextSearchOptions.md)&gt;
-
-#### Returns
-
-`this`
-
-***
-
-### limit()
-
-```ts
-limit(limit): this
-```
-
-Set the maximum number of results to return.
-
-By default, a plain search has no limit.  If this method is not
-called then every valid row from the table will be returned.
-
-#### Parameters
-
-* **limit**: `number`
-
-#### Returns
-
-`this`
-
-***
-
-### offset()
-
-```ts
-offset(offset): this
-```
-
-#### Parameters
-
-* **offset**: `number`
-
-#### Returns
-
-`this`
-
-***
-
 ### select()

 ```ts
@@ -328,37 +229,6 @@ ArrowTable.

 ***

-### where()
-
-```ts
-where(predicate): this
-```
-
-A filter statement to be applied to this query.
-
-The filter should be supplied as an SQL query string.  For example:
-
-#### Parameters
-
-* **predicate**: `string`
-
-#### Returns
-
-`this`
-
-#### Example
-
-```ts
-x > 10
-y > 0 AND y < 100
-x > 5 OR y = 'test'
-
-Filtering performance can often be improved by creating a scalar index
-on the filter column(s).
-```
-
-***
-
 ### withRowId()

 ```ts
--- a/docs/src/js/classes/Session.md
+++ b/docs/src/js/classes/Session.md
@@ -9,7 +9,8 @@
 A session for managing caches and object stores across LanceDB operations.

 Sessions allow you to configure cache sizes for index and metadata caches,
-which can significantly impact performance for large datasets.
+which can significantly impact memory use and performance. They can
+also be re-used across multiple connections to share the same cache state.

 ## Constructors

@@ -24,8 +25,11 @@ Create a new session with custom cache sizes.
 # Parameters

 - `index_cache_size_bytes`: The size of the index cache in bytes.
+  Index data is stored in memory in this cache to speed up queries.
  Defaults to 6GB if not specified.
 - `metadata_cache_size_bytes`: The size of the metadata cache in bytes.
+  The metadata cache stores file metadata and schema information in memory.
+  This cache improves scan and write performance.
  Defaults to 1GB if not specified.

 #### Parameters
--- a/docs/src/js/classes/Table.md
+++ b/docs/src/js/classes/Table.md
@@ -674,6 +674,48 @@ console.log(tags); // { "v1": { version: 1, manifestSize: ... } }

 ***

+### takeOffsets()
+
+```ts
+abstract takeOffsets(offsets): TakeQuery
+```
+
+Create a query that returns a subset of the rows in the table.
+
+#### Parameters
+
+* **offsets**: `number`[]
+    The offsets of the rows to return.
+
+#### Returns
+
+[`TakeQuery`](TakeQuery.md)
+
+A builder that can be used to parameterize the query.
+
+***
+
+### takeRowIds()
+
+```ts
+abstract takeRowIds(rowIds): TakeQuery
+```
+
+Create a query that returns a subset of the rows in the table.
+
+#### Parameters
+
+* **rowIds**: `number`[]
+    The row ids of the rows to return.
+
+#### Returns
+
+[`TakeQuery`](TakeQuery.md)
+
+A builder that can be used to parameterize the query.
+
+***
+
 ### toArrow()

 ```ts
--- a/docs/src/js/classes/TakeQuery.md
+++ b/docs/src/js/classes/TakeQuery.md
@@ -0,0 +1,265 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / TakeQuery
+
+# Class: TakeQuery
+
+A query that returns a subset of the rows in the table.
+
+## Extends
+
+- [`QueryBase`](QueryBase.md)&lt;`NativeTakeQuery`&gt;
+
+## Properties
+
+### inner
+
+```ts
+protected inner: TakeQuery | Promise<TakeQuery>;
+```
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`inner`](QueryBase.md#inner)
+
+## Methods
+
+### analyzePlan()
+
+```ts
+analyzePlan(): Promise<string>
+```
+
+Executes the query and returns the physical query plan annotated with runtime metrics.
+
+This is useful for debugging and performance analysis, as it shows how the query was executed
+and includes metrics such as elapsed time, rows processed, and I/O statistics.
+
+#### Returns
+
+`Promise`&lt;`string`&gt;
+
+A query execution plan with runtime metrics for each step.
+
+#### Example
+
+```ts
+import * as lancedb from "@lancedb/lancedb"
+
+const db = await lancedb.connect("./.lancedb");
+const table = await db.createTable("my_table", [
+  { vector: [1.1, 0.9], id: "1" },
+]);
+
+const plan = await table.query().nearestTo([0.5, 0.2]).analyzePlan();
+
+Example output (with runtime metrics inlined):
+AnalyzeExec verbose=true, metrics=[]
+ ProjectionExec: expr=[id@3 as id, vector@0 as vector, _distance@2 as _distance], metrics=[output_rows=1, elapsed_compute=3.292µs]
+  Take: columns="vector, _rowid, _distance, (id)", metrics=[output_rows=1, elapsed_compute=66.001µs, batches_processed=1, bytes_read=8, iops=1, requests=1]
+   CoalesceBatchesExec: target_batch_size=1024, metrics=[output_rows=1, elapsed_compute=3.333µs]
+    GlobalLimitExec: skip=0, fetch=10, metrics=[output_rows=1, elapsed_compute=167ns]
+     FilterExec: _distance@2 IS NOT NULL, metrics=[output_rows=1, elapsed_compute=8.542µs]
+      SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST], metrics=[output_rows=1, elapsed_compute=63.25µs, row_replacements=1]
+       KNNVectorDistance: metric=l2, metrics=[output_rows=1, elapsed_compute=114.333µs, output_batches=1]
+        LanceScan: uri=/path/to/data, projection=[vector], row_id=true, row_addr=false, ordered=false, metrics=[output_rows=1, elapsed_compute=103.626µs, bytes_read=549, iops=2, requests=2]
+```
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`analyzePlan`](QueryBase.md#analyzeplan)
+
+***
+
+### execute()
+
+```ts
+protected execute(options?): RecordBatchIterator
+```
+
+Execute the query and return the results as an
+
+#### Parameters
+
+* **options?**: `Partial`&lt;[`QueryExecutionOptions`](../interfaces/QueryExecutionOptions.md)&gt;
+
+#### Returns
+
+[`RecordBatchIterator`](RecordBatchIterator.md)
+
+#### See
+
+ - AsyncIterator
+of
+ - RecordBatch.
+
+By default, LanceDb will use many threads to calculate results and, when
+the result set is large, multiple batches will be processed at one time.
+This readahead is limited however and backpressure will be applied if this
+stream is consumed slowly (this constrains the maximum memory used by a
+single query)
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`execute`](QueryBase.md#execute)
+
+***
+
+### explainPlan()
+
+```ts
+explainPlan(verbose): Promise<string>
+```
+
+Generates an explanation of the query execution plan.
+
+#### Parameters
+
+* **verbose**: `boolean` = `false`
+    If true, provides a more detailed explanation. Defaults to false.
+
+#### Returns
+
+`Promise`&lt;`string`&gt;
+
+A Promise that resolves to a string containing the query execution plan explanation.
+
+#### Example
+
+```ts
+import * as lancedb from "@lancedb/lancedb"
+const db = await lancedb.connect("./.lancedb");
+const table = await db.createTable("my_table", [
+  { vector: [1.1, 0.9], id: "1" },
+]);
+const plan = await table.query().nearestTo([0.5, 0.2]).explainPlan();
+```
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`explainPlan`](QueryBase.md#explainplan)
+
+***
+
+### select()
+
+```ts
+select(columns): this
+```
+
+Return only the specified columns.
+
+By default a query will return all columns from the table.  However, this can have
+a very significant impact on latency.  LanceDb stores data in a columnar fashion.  This
+means we can finely tune our I/O to select exactly the columns we need.
+
+As a best practice you should always limit queries to the columns that you need.  If you
+pass in an array of column names then only those columns will be returned.
+
+You can also use this method to create new "dynamic" columns based on your existing columns.
+For example, you may not care about "a" or "b" but instead simply want "a + b".  This is often
+seen in the SELECT clause of an SQL query (e.g. `SELECT a+b FROM my_table`).
+
+To create dynamic columns you can pass in a Map<string, string>.  A column will be returned
+for each entry in the map.  The key provides the name of the column.  The value is
+an SQL string used to specify how the column is calculated.
+
+For example, an SQL query might state `SELECT a + b AS combined, c`.  The equivalent
+input to this method would be:
+
+#### Parameters
+
+* **columns**: `string` \| `string`[] \| `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
+
+#### Returns
+
+`this`
+
+#### Example
+
+```ts
+new Map([["combined", "a + b"], ["c", "c"]])
+
+Columns will always be returned in the order given, even if that order is different than
+the order used when adding the data.
+
+Note that you can pass in a `Record<string, string>` (e.g. an object literal). This method
+uses `Object.entries` which should preserve the insertion order of the object.  However,
+object insertion order is easy to get wrong and `Map` is more foolproof.
+```
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`select`](QueryBase.md#select)
+
+***
+
+### toArray()
+
+```ts
+toArray(options?): Promise<any[]>
+```
+
+Collect the results as an array of objects.
+
+#### Parameters
+
+* **options?**: `Partial`&lt;[`QueryExecutionOptions`](../interfaces/QueryExecutionOptions.md)&gt;
+
+#### Returns
+
+`Promise`&lt;`any`[]&gt;
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`toArray`](QueryBase.md#toarray)
+
+***
+
+### toArrow()
+
+```ts
+toArrow(options?): Promise<Table<any>>
+```
+
+Collect the results as an Arrow
+
+#### Parameters
+
+* **options?**: `Partial`&lt;[`QueryExecutionOptions`](../interfaces/QueryExecutionOptions.md)&gt;
+
+#### Returns
+
+`Promise`&lt;`Table`&lt;`any`&gt;&gt;
+
+#### See
+
+ArrowTable.
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`toArrow`](QueryBase.md#toarrow)
+
+***
+
+### withRowId()
+
+```ts
+withRowId(): this
+```
+
+Whether to return the row id in the results.
+
+This column can be used to match results between different queries. For
+example, to match results from a full text search and a vector search in
+order to perform hybrid search.
+
+#### Returns
+
+`this`
+
+#### Inherited from
+
+[`QueryBase`](QueryBase.md).[`withRowId`](QueryBase.md#withrowid)
--- a/docs/src/js/classes/VectorQuery.md
+++ b/docs/src/js/classes/VectorQuery.md
@@ -16,7 +16,7 @@ This builder can be reused to execute the query many times.

 ## Extends

- [`QueryBase`](QueryBase.md)&lt;`NativeVectorQuery`&gt;
+- `StandardQueryBase`&lt;`NativeVectorQuery`&gt;

 ## Properties

@@ -28,7 +28,7 @@ protected inner: VectorQuery | Promise<VectorQuery>;

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`inner`](QueryBase.md#inner)
+`StandardQueryBase.inner`

 ## Methods

@@ -91,7 +91,7 @@ AnalyzeExec verbose=true, metrics=[]

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`analyzePlan`](QueryBase.md#analyzeplan)
+`StandardQueryBase.analyzePlan`

 ***

@@ -248,7 +248,7 @@ single query)

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`execute`](QueryBase.md#execute)
+`StandardQueryBase.execute`

 ***

@@ -284,7 +284,7 @@ const plan = await table.query().nearestTo([0.5, 0.2]).explainPlan();

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`explainPlan`](QueryBase.md#explainplan)
+`StandardQueryBase.explainPlan`

 ***

@@ -305,7 +305,7 @@ Use [Table#optimize](Table.md#optimize) to index all un-indexed data.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`fastSearch`](QueryBase.md#fastsearch)
+`StandardQueryBase.fastSearch`

 ***

@@ -335,7 +335,7 @@ Use `where` instead

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`filter`](QueryBase.md#filter)
+`StandardQueryBase.filter`

 ***

@@ -357,7 +357,7 @@ fullTextSearch(query, options?): this

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`fullTextSearch`](QueryBase.md#fulltextsearch)
+`StandardQueryBase.fullTextSearch`

 ***

@@ -382,7 +382,7 @@ called then every valid row from the table will be returned.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`limit`](QueryBase.md#limit)
+`StandardQueryBase.limit`

 ***

@@ -480,6 +480,10 @@ the minimum and maximum to the same value.
 offset(offset): this
 ```

+Set the number of rows to skip before returning results.
+
+This is useful for pagination.
+
 #### Parameters

 * **offset**: `number`
@@ -490,7 +494,7 @@ offset(offset): this

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`offset`](QueryBase.md#offset)
+`StandardQueryBase.offset`

 ***

@@ -637,7 +641,7 @@ object insertion order is easy to get wrong and `Map` is more foolproof.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`select`](QueryBase.md#select)
+`StandardQueryBase.select`

 ***

@@ -659,7 +663,7 @@ Collect the results as an array of objects.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`toArray`](QueryBase.md#toarray)
+`StandardQueryBase.toArray`

 ***

@@ -685,7 +689,7 @@ ArrowTable.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`toArrow`](QueryBase.md#toarrow)
+`StandardQueryBase.toArrow`

 ***

@@ -720,7 +724,7 @@ on the filter column(s).

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`where`](QueryBase.md#where)
+`StandardQueryBase.where`

 ***

@@ -742,4 +746,4 @@ order to perform hybrid search.

 #### Inherited from

-[`QueryBase`](QueryBase.md).[`withRowId`](QueryBase.md#withrowid)
+`StandardQueryBase.withRowId`
--- a/docs/src/js/globals.md
+++ b/docs/src/js/globals.md
@@ -33,6 +33,7 @@
 - [Table](classes/Table.md)
 - [TagContents](classes/TagContents.md)
 - [Tags](classes/Tags.md)
+- [TakeQuery](classes/TakeQuery.md)
 - [VectorColumnOptions](classes/VectorColumnOptions.md)
 - [VectorQuery](classes/VectorQuery.md)

--- a/docs/src/js/interfaces/TimeoutConfig.md
+++ b/docs/src/js/interfaces/TimeoutConfig.md
@@ -44,3 +44,17 @@ optional readTimeout: number;
 The timeout for reading data from the server in seconds. Default is 300
 seconds (5 minutes). This can also be set via the environment variable
 `LANCE_CLIENT_READ_TIMEOUT`, as an integer number of seconds.
+
+***
+
+### timeout?
+
+```ts
+optional timeout: number;
+```
+
+The overall timeout for the entire request in seconds. This includes
+connection, send, and read time. If the entire request doesn't complete
+within this time, it will fail. Default is None (no overall timeout).
+This can also be set via the environment variable `LANCE_CLIENT_TIMEOUT`,
+as an integer number of seconds.
--- a/nodejs/test/table.test.ts
+++ b/nodejs/test/table.test.ts
@@ -287,6 +287,12 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
      expect(res2[1].id).toEqual(data2.id);
    });

+    it("should support take queries", async () => {
+      await table.add([{ id: 1 }, { id: 2 }, { id: 3 }]);
+      const res = await table.takeOffsets([1, 2]).toArrow();
+      expect(res.getChild("id")?.toJSON()).toEqual([2, 3]);
+    });
+
    it("should return the table as an instance of an arrow table", async () => {
      const arrowTbl = await table.toArrow();
      expect(arrowTbl).toBeInstanceOf(ArrowTable);
@@ -557,7 +563,7 @@ describe("When creating an index", () => {

    // test offset
    rst = await tbl.query().limit(2).offset(1).nearestTo(queryVec).toArrow();
-    expect(rst.numRows).toBe(1);
+    expect(rst.numRows).toBe(2);

    // test nprobes
    rst = await tbl.query().nearestTo(queryVec).limit(2).nprobes(50).toArrow();
@@ -696,7 +702,7 @@ describe("When creating an index", () => {

    // test offset
    rst = await tbl.query().limit(2).offset(1).nearestTo(queryVec).toArrow();
-    expect(rst.numRows).toBe(1);
+    expect(rst.numRows).toBe(2);

    // test ef
    rst = await tbl.query().limit(2).nearestTo(queryVec).ef(100).toArrow();
--- a/nodejs/examples/ann_indexes.test.ts
+++ b/nodejs/examples/ann_indexes.test.ts
@@ -12,7 +12,7 @@ test("ann index examples", async () => {
    // --8<-- [start:ingest]
    const db = await lancedb.connect(databaseDir);

-    const data = Array.from({ length: 5_000 }, (_, i) => ({
+    const data = Array.from({ length: 1_000 }, (_, i) => ({
      vector: Array(128).fill(i),
      id: `${i}`,
      content: "",
@@ -24,8 +24,8 @@ test("ann index examples", async () => {
    });
    await table.createIndex("vector", {
      config: lancedb.Index.ivfPq({
-        numPartitions: 10,
-        numSubVectors: 16,
+        numPartitions: 30,
+        numSubVectors: 8,
      }),
    });
    // --8<-- [end:ingest]
--- a/nodejs/lancedb/index.ts
+++ b/nodejs/lancedb/index.ts
@@ -59,6 +59,7 @@ export {
  Query,
  QueryBase,
  VectorQuery,
+  TakeQuery,
  QueryExecutionOptions,
  FullTextSearchOptions,
  RecordBatchIterator,
--- a/nodejs/lancedb/query.ts
+++ b/nodejs/lancedb/query.ts
@@ -15,6 +15,7 @@ import {
  RecordBatchIterator as NativeBatchIterator,
  Query as NativeQuery,
  Table as NativeTable,
+  TakeQuery as NativeTakeQuery,
  VectorQuery as NativeVectorQuery,
 } from "./native";
 import { Reranker } from "./rerankers";
@@ -50,7 +51,7 @@ export class RecordBatchIterator implements AsyncIterator<RecordBatch> {
 /* eslint-enable */

 class RecordBatchIterable<
-  NativeQueryType extends NativeQuery | NativeVectorQuery,
+  NativeQueryType extends NativeQuery | NativeVectorQuery | NativeTakeQuery,
 > implements AsyncIterable<RecordBatch>
 {
  private inner: NativeQueryType;
@@ -107,8 +108,9 @@ export interface FullTextSearchOptions {
 *
 * @hideconstructor
 */
-export class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery>
-  implements AsyncIterable<RecordBatch>
+export class QueryBase<
+  NativeQueryType extends NativeQuery | NativeVectorQuery | NativeTakeQuery,
+> implements AsyncIterable<RecordBatch>
 {
  /**
   * @hidden
@@ -133,56 +135,6 @@ export class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery>
      fn(this.inner);
    }
  }
-  /**
-   * A filter statement to be applied to this query.
-   *
-   * The filter should be supplied as an SQL query string.  For example:
-   * @example
-   * x > 10
-   * y > 0 AND y < 100
-   * x > 5 OR y = 'test'
-   *
-   * Filtering performance can often be improved by creating a scalar index
-   * on the filter column(s).
-   */
-  where(predicate: string): this {
-    this.doCall((inner: NativeQueryType) => inner.onlyIf(predicate));
-    return this;
-  }
-  /**
-   * A filter statement to be applied to this query.
-   * @see where
-   * @deprecated Use `where` instead
-   */
-  filter(predicate: string): this {
-    return this.where(predicate);
-  }
-
-  fullTextSearch(
-    query: string | FullTextQuery,
-    options?: Partial<FullTextSearchOptions>,
-  ): this {
-    let columns: string[] | null = null;
-    if (options) {
-      if (typeof options.columns === "string") {
-        columns = [options.columns];
-      } else if (Array.isArray(options.columns)) {
-        columns = options.columns;
-      }
-    }
-
-    this.doCall((inner: NativeQueryType) => {
-      if (typeof query === "string") {
-        inner.fullTextSearch({
-          query: query,
-          columns: columns,
-        });
-      } else {
-        inner.fullTextSearch({ query: query.inner });
-      }
-    });
-    return this;
-  }

  /**
   * Return only the specified columns.
@@ -241,33 +193,6 @@ export class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery>
    return this;
  }

-  /**
-   * Set the maximum number of results to return.
-   *
-   * By default, a plain search has no limit.  If this method is not
-   * called then every valid row from the table will be returned.
-   */
-  limit(limit: number): this {
-    this.doCall((inner: NativeQueryType) => inner.limit(limit));
-    return this;
-  }
-
-  offset(offset: number): this {
-    this.doCall((inner: NativeQueryType) => inner.offset(offset));
-    return this;
-  }
-
-  /**
-   * Skip searching un-indexed data. This can make search faster, but will miss
-   * any data that is not yet indexed.
-   *
-   * Use {@link Table#optimize} to index all un-indexed data.
-   */
-  fastSearch(): this {
-    this.doCall((inner: NativeQueryType) => inner.fastSearch());
-    return this;
-  }
-
  /**
   * Whether to return the row id in the results.
   *
@@ -403,6 +328,100 @@ export class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery>
  }
 }

+export class StandardQueryBase<
+    NativeQueryType extends NativeQuery | NativeVectorQuery,
+  >
+  extends QueryBase<NativeQueryType>
+  implements ExecutableQuery
+{
+  constructor(inner: NativeQueryType | Promise<NativeQueryType>) {
+    super(inner);
+  }
+
+  /**
+   * A filter statement to be applied to this query.
+   *
+   * The filter should be supplied as an SQL query string.  For example:
+   * @example
+   * x > 10
+   * y > 0 AND y < 100
+   * x > 5 OR y = 'test'
+   *
+   * Filtering performance can often be improved by creating a scalar index
+   * on the filter column(s).
+   */
+  where(predicate: string): this {
+    this.doCall((inner: NativeQueryType) => inner.onlyIf(predicate));
+    return this;
+  }
+  /**
+   * A filter statement to be applied to this query.
+   * @see where
+   * @deprecated Use `where` instead
+   */
+  filter(predicate: string): this {
+    return this.where(predicate);
+  }
+
+  fullTextSearch(
+    query: string | FullTextQuery,
+    options?: Partial<FullTextSearchOptions>,
+  ): this {
+    let columns: string[] | null = null;
+    if (options) {
+      if (typeof options.columns === "string") {
+        columns = [options.columns];
+      } else if (Array.isArray(options.columns)) {
+        columns = options.columns;
+      }
+    }
+
+    this.doCall((inner: NativeQueryType) => {
+      if (typeof query === "string") {
+        inner.fullTextSearch({
+          query: query,
+          columns: columns,
+        });
+      } else {
+        inner.fullTextSearch({ query: query.inner });
+      }
+    });
+    return this;
+  }
+
+  /**
+   * Set the maximum number of results to return.
+   *
+   * By default, a plain search has no limit.  If this method is not
+   * called then every valid row from the table will be returned.
+   */
+  limit(limit: number): this {
+    this.doCall((inner: NativeQueryType) => inner.limit(limit));
+    return this;
+  }
+
+  /**
+   * Set the number of rows to skip before returning results.
+   *
+   * This is useful for pagination.
+   */
+  offset(offset: number): this {
+    this.doCall((inner: NativeQueryType) => inner.offset(offset));
+    return this;
+  }
+
+  /**
+   * Skip searching un-indexed data. This can make search faster, but will miss
+   * any data that is not yet indexed.
+   *
+   * Use {@link Table#optimize} to index all un-indexed data.
+   */
+  fastSearch(): this {
+    this.doCall((inner: NativeQueryType) => inner.fastSearch());
+    return this;
+  }
+}
+
 /**
 * An interface for a query that can be executed
 *
@@ -419,7 +438,7 @@ export interface ExecutableQuery {}
 *
 * @hideconstructor
 */
-export class VectorQuery extends QueryBase<NativeVectorQuery> {
+export class VectorQuery extends StandardQueryBase<NativeVectorQuery> {
  /**
   * @hidden
   */
@@ -679,13 +698,24 @@ export class VectorQuery extends QueryBase<NativeVectorQuery> {
  }
 }

+/**
+ * A query that returns a subset of the rows in the table.
+ *
+ * @hideconstructor
+ */
+export class TakeQuery extends QueryBase<NativeTakeQuery> {
+  constructor(inner: NativeTakeQuery) {
+    super(inner);
+  }
+}
+
 /** A builder for LanceDB queries.
 *
 * @see {@link Table#query}, {@link Table#search}
 *
 * @hideconstructor
 */
-export class Query extends QueryBase<NativeQuery> {
+export class Query extends StandardQueryBase<NativeQuery> {
  /**
   * @hidden
   */
--- a/nodejs/lancedb/table.ts
+++ b/nodejs/lancedb/table.ts
@@ -35,6 +35,7 @@ import {
 import {
  FullTextQuery,
  Query,
+  TakeQuery,
  VectorQuery,
  instanceOfFullTextQuery,
 } from "./query";
@@ -336,6 +337,20 @@ export abstract class Table {
   */
  abstract query(): Query;

+  /**
+   * Create a query that returns a subset of the rows in the table.
+   * @param offsets The offsets of the rows to return.
+   * @returns A builder that can be used to parameterize the query.
+   */
+  abstract takeOffsets(offsets: number[]): TakeQuery;
+
+  /**
+   * Create a query that returns a subset of the rows in the table.
+   * @param rowIds The row ids of the rows to return.
+   * @returns A builder that can be used to parameterize the query.
+   */
+  abstract takeRowIds(rowIds: number[]): TakeQuery;
+
  /**
   * Create a search query to find the nearest neighbors
   * of the given query
@@ -665,6 +680,14 @@ export class LocalTable extends Table {
    await this.inner.waitForIndex(indexNames, timeoutSeconds);
  }

+  takeOffsets(offsets: number[]): TakeQuery {
+    return new TakeQuery(this.inner.takeOffsets(offsets));
+  }
+
+  takeRowIds(rowIds: number[]): TakeQuery {
+    return new TakeQuery(this.inner.takeRowIds(rowIds));
+  }
+
  query(): Query {
    return new Query(this.inner);
  }
--- a/nodejs/src/query.rs
+++ b/nodejs/src/query.rs
@@ -12,6 +12,7 @@ use lancedb::query::Query as LanceDbQuery;
 use lancedb::query::QueryBase;
 use lancedb::query::QueryExecutionOptions;
 use lancedb::query::Select;
+use lancedb::query::TakeQuery as LanceDbTakeQuery;
 use lancedb::query::VectorQuery as LanceDbVectorQuery;
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
@@ -319,6 +320,79 @@ impl VectorQuery {
    }
 }

+#[napi]
+pub struct TakeQuery {
+    inner: LanceDbTakeQuery,
+}
+
+#[napi]
+impl TakeQuery {
+    pub fn new(query: LanceDbTakeQuery) -> Self {
+        Self { inner: query }
+    }
+
+    #[napi]
+    pub fn select(&mut self, columns: Vec<(String, String)>) {
+        self.inner = self.inner.clone().select(Select::dynamic(&columns));
+    }
+
+    #[napi]
+    pub fn select_columns(&mut self, columns: Vec<String>) {
+        self.inner = self.inner.clone().select(Select::columns(&columns));
+    }
+
+    #[napi]
+    pub fn with_row_id(&mut self) {
+        self.inner = self.inner.clone().with_row_id();
+    }
+
+    #[napi(catch_unwind)]
+    pub async fn execute(
+        &self,
+        max_batch_length: Option<u32>,
+        timeout_ms: Option<u32>,
+    ) -> napi::Result<RecordBatchIterator> {
+        let mut execution_opts = QueryExecutionOptions::default();
+        if let Some(max_batch_length) = max_batch_length {
+            execution_opts.max_batch_length = max_batch_length;
+        }
+        if let Some(timeout_ms) = timeout_ms {
+            execution_opts.timeout = Some(std::time::Duration::from_millis(timeout_ms as u64))
+        }
+        let inner_stream = self
+            .inner
+            .execute_with_options(execution_opts)
+            .await
+            .map_err(|e| {
+                napi::Error::from_reason(format!(
+                    "Failed to execute query stream: {}",
+                    convert_error(&e)
+                ))
+            })?;
+        Ok(RecordBatchIterator::new(inner_stream))
+    }
+
+    #[napi]
+    pub async fn explain_plan(&self, verbose: bool) -> napi::Result<String> {
+        self.inner.explain_plan(verbose).await.map_err(|e| {
+            napi::Error::from_reason(format!(
+                "Failed to retrieve the query plan: {}",
+                convert_error(&e)
+            ))
+        })
+    }
+
+    #[napi(catch_unwind)]
+    pub async fn analyze_plan(&self) -> napi::Result<String> {
+        self.inner.analyze_plan().await.map_err(|e| {
+            napi::Error::from_reason(format!(
+                "Failed to execute analyze plan: {}",
+                convert_error(&e)
+            ))
+        })
+    }
+}
+
 #[napi]
 #[derive(Debug, Clone)]
 pub struct JsFullTextQuery {
--- a/nodejs/src/table.rs
+++ b/nodejs/src/table.rs
@@ -15,7 +15,7 @@ use napi_derive::napi;
 use crate::error::NapiErrorExt;
 use crate::index::Index;
 use crate::merge::NativeMergeInsertBuilder;
-use crate::query::{Query, VectorQuery};
+use crate::query::{Query, TakeQuery, VectorQuery};

 #[napi]
 pub struct Table {
@@ -187,6 +187,44 @@ impl Table {
        Ok(Query::new(self.inner_ref()?.query()))
    }

+    #[napi(catch_unwind)]
+    pub fn take_offsets(&self, offsets: Vec<i64>) -> napi::Result<TakeQuery> {
+        Ok(TakeQuery::new(
+            self.inner_ref()?.take_offsets(
+                offsets
+                    .into_iter()
+                    .map(|o| {
+                        u64::try_from(o).map_err(|e| {
+                            napi::Error::from_reason(format!(
+                                "Failed to convert offset to u64: {}",
+                                e
+                            ))
+                        })
+                    })
+                    .collect::<Result<Vec<_>>>()?,
+            ),
+        ))
+    }
+
+    #[napi(catch_unwind)]
+    pub fn take_row_ids(&self, row_ids: Vec<i64>) -> napi::Result<TakeQuery> {
+        Ok(TakeQuery::new(
+            self.inner_ref()?.take_row_ids(
+                row_ids
+                    .into_iter()
+                    .map(|o| {
+                        u64::try_from(o).map_err(|e| {
+                            napi::Error::from_reason(format!(
+                                "Failed to convert row id to u64: {}",
+                                e
+                            ))
+                        })
+                    })
+                    .collect::<Result<Vec<_>>>()?,
+            ),
+        ))
+    }
+
    #[napi(catch_unwind)]
    pub fn vector_search(&self, vector: Float32Array) -> napi::Result<VectorQuery> {
        self.query()?.nearest_to(vector)
--- a/nodejs/typedoc.json
+++ b/nodejs/typedoc.json
@@ -2,6 +2,7 @@
  "intentionallyNotExported": [
    "lancedb/native.d.ts:Query",
    "lancedb/native.d.ts:VectorQuery",
+    "lancedb/native.d.ts:TakeQuery",
    "lancedb/native.d.ts:RecordBatchIterator",
    "lancedb/native.d.ts:NativeMergeInsertBuilder"
  ],
--- a/python/.bumpversion.toml
+++ b/python/.bumpversion.toml
@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.24.2"
+current_version = "0.24.3"
 parse = """(?x)
    (?P<major>0|[1-9]\\d*)\\.
    (?P<minor>0|[1-9]\\d*)\\.
--- a/python/Cargo.toml
+++ b/python/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lancedb-python"
-version = "0.24.2"
+version = "0.24.3"
 edition.workspace = true
 description = "Python bindings for LanceDB"
 license.workspace = true
--- a/python/python/lancedb/query.py
+++ b/python/python/lancedb/query.py
@@ -28,6 +28,7 @@ import pyarrow.fs as pa_fs
 import pydantic

 from lancedb.pydantic import PYDANTIC_VERSION
+from lancedb.background_loop import LOOP

 from . import __version__
 from .arrow import AsyncRecordBatchReader
@@ -48,6 +49,7 @@ if TYPE_CHECKING:
    from ._lancedb import FTSQuery as LanceFTSQuery
    from ._lancedb import HybridQuery as LanceHybridQuery
    from ._lancedb import VectorQuery as LanceVectorQuery
+    from ._lancedb import TakeQuery as LanceTakeQuery
    from ._lancedb import PyQueryRequest
    from .common import VEC
    from .pydantic import LanceModel
@@ -910,7 +912,7 @@ class LanceQueryBuilder(ABC):
        ProjectionExec: expr=[vector@0 as vector, _distance@2 as _distance]
          GlobalLimitExec: skip=0, fetch=10
            FilterExec: _distance@2 IS NOT NULL
-              SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST], preserve_partitioning=[false]
+              SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST, _rowid@1 ASC NULLS LAST], preserve_partitioning=[false]
                KNNVectorDistance: metric=l2
                  LanceRead: uri=..., projection=[vector], ...

@@ -2041,11 +2043,11 @@ class LanceHybridQueryBuilder(LanceQueryBuilder):
        >>> plan = table.search(query).explain_plan(True)
        >>> print(plan) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
        ProjectionExec: expr=[vector@0 as vector, _distance@2 as _distance]
-        GlobalLimitExec: skip=0, fetch=10
-          FilterExec: _distance@2 IS NOT NULL
-            SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST], preserve_partitioning=[false]
-              KNNVectorDistance: metric=l2
-                LanceRead: uri=..., projection=[vector], ...
+          GlobalLimitExec: skip=0, fetch=10
+            FilterExec: _distance@2 IS NOT NULL
+              SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST, _rowid@1 ASC NULLS LAST], preserve_partitioning=[false]
+                KNNVectorDistance: metric=l2
+                  LanceRead: uri=..., projection=[vector], ...

        Parameters
        ----------
@@ -2139,7 +2141,11 @@ class LanceHybridQueryBuilder(LanceQueryBuilder):


 class AsyncQueryBase(object):
-    def __init__(self, inner: Union[LanceQuery, LanceVectorQuery]):
+    """
+    Base class for all async queries (take, scan, vector, fts, hybrid)
+    """
+
+    def __init__(self, inner: Union[LanceQuery, LanceVectorQuery, LanceTakeQuery]):
        """
        Construct an AsyncQueryBase

@@ -2149,27 +2155,14 @@ class AsyncQueryBase(object):
        self._inner = inner

    def to_query_object(self) -> Query:
+        """
+        Convert the query into a query object
+
+        This is currently experimental but can be useful as the query object is pure
+        python and more easily serializable.
+        """
        return Query.from_inner(self._inner.to_query_request())

-    def where(self, predicate: str) -> Self:
-        """
-        Only return rows matching the given predicate
-
-        The predicate should be supplied as an SQL query string.
-
-        Examples
-        --------
-
-        >>> predicate = "x > 10"
-        >>> predicate = "y > 0 AND y < 100"
-        >>> predicate = "x > 5 OR y = 'test'"
-
-        Filtering performance can often be improved by creating a scalar index
-        on the filter column(s).
-        """
-        self._inner.where(predicate)
-        return self
-
    def select(self, columns: Union[List[str], dict[str, str]]) -> Self:
        """
        Return only the specified columns.
@@ -2208,42 +2201,6 @@ class AsyncQueryBase(object):
            raise TypeError("columns must be a list of column names or a dict")
        return self

-    def limit(self, limit: int) -> Self:
-        """
-        Set the maximum number of results to return.
-
-        By default, a plain search has no limit.  If this method is not
-        called then every valid row from the table will be returned.
-        """
-        self._inner.limit(limit)
-        return self
-
-    def offset(self, offset: int) -> Self:
-        """
-        Set the offset for the results.
-
-        Parameters
-        ----------
-        offset: int
-            The offset to start fetching results from.
-        """
-        self._inner.offset(offset)
-        return self
-
-    def fast_search(self) -> Self:
-        """
-        Skip searching un-indexed data.
-
-        This can make queries faster, but will miss any data that has not been
-        indexed.
-
-        !!! tip
-            You can add new data into an existing index by calling
-            [AsyncTable.optimize][lancedb.table.AsyncTable.optimize].
-        """
-        self._inner.fast_search()
-        return self
-
    def with_row_id(self) -> Self:
        """
        Include the _rowid column in the results.
@@ -2251,27 +2208,6 @@ class AsyncQueryBase(object):
        self._inner.with_row_id()
        return self

-    def postfilter(self) -> Self:
-        """
-        If this is called then filtering will happen after the search instead of
-        before.
-        By default filtering will be performed before the search.  This is how
-        filtering is typically understood to work.  This prefilter step does add some
-        additional latency.  Creating a scalar index on the filter column(s) can
-        often improve this latency.  However, sometimes a filter is too complex or
-        scalar indices cannot be applied to the column.  In these cases postfiltering
-        can be used instead of prefiltering to improve latency.
-        Post filtering applies the filter to the results of the search.  This
-        means we only run the filter on a much smaller set of data.  However, it can
-        cause the query to return fewer than `limit` results (or even no results) if
-        none of the nearest results match the filter.
-        Post filtering happens during the "refine stage" (described in more detail in
-        @see {@link VectorQuery#refineFactor}).  This means that setting a higher refine
-        factor can often help restore some of the results lost by post filtering.
-        """
-        self._inner.postfilter()
-        return self
-
    async def to_batches(
        self,
        *,
@@ -2295,7 +2231,9 @@ class AsyncQueryBase(object):
            complete within the specified time, an error will be raised.
        """
        return AsyncRecordBatchReader(
-            await self._inner.execute(max_batch_length, timeout)
+            await self._inner.execute(
+                max_batch_length=max_batch_length, timeout=timeout
+            )
        )

    async def to_arrow(self, timeout: Optional[timedelta] = None) -> pa.Table:
@@ -2429,7 +2367,7 @@ class AsyncQueryBase(object):
        ProjectionExec: expr=[vector@0 as vector, _distance@2 as _distance]
          GlobalLimitExec: skip=0, fetch=10
            FilterExec: _distance@2 IS NOT NULL
-              SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST], preserve_partitioning=[false]
+              SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST, _rowid@1 ASC NULLS LAST], preserve_partitioning=[false]
                KNNVectorDistance: metric=l2
                  LanceRead: uri=..., projection=[vector], ...

@@ -2454,7 +2392,98 @@ class AsyncQueryBase(object):
        return await self._inner.analyze_plan()


-class AsyncQuery(AsyncQueryBase):
+class AsyncStandardQuery(AsyncQueryBase):
+    """
+    Base class for "standard" async queries (all but take currently)
+    """
+
+    def __init__(self, inner: Union[LanceQuery, LanceVectorQuery]):
+        """
+        Construct an AsyncStandardQuery
+
+        This method is not intended to be called directly.  Instead, use the
+        [AsyncTable.query][lancedb.table.AsyncTable.query] method to create a query.
+        """
+        super().__init__(inner)
+
+    def where(self, predicate: str) -> Self:
+        """
+        Only return rows matching the given predicate
+
+        The predicate should be supplied as an SQL query string.
+
+        Examples
+        --------
+
+        >>> predicate = "x > 10"
+        >>> predicate = "y > 0 AND y < 100"
+        >>> predicate = "x > 5 OR y = 'test'"
+
+        Filtering performance can often be improved by creating a scalar index
+        on the filter column(s).
+        """
+        self._inner.where(predicate)
+        return self
+
+    def limit(self, limit: int) -> Self:
+        """
+        Set the maximum number of results to return.
+
+        By default, a plain search has no limit.  If this method is not
+        called then every valid row from the table will be returned.
+        """
+        self._inner.limit(limit)
+        return self
+
+    def offset(self, offset: int) -> Self:
+        """
+        Set the offset for the results.
+
+        Parameters
+        ----------
+        offset: int
+            The offset to start fetching results from.
+        """
+        self._inner.offset(offset)
+        return self
+
+    def fast_search(self) -> Self:
+        """
+        Skip searching un-indexed data.
+
+        This can make queries faster, but will miss any data that has not been
+        indexed.
+
+        !!! tip
+            You can add new data into an existing index by calling
+            [AsyncTable.optimize][lancedb.table.AsyncTable.optimize].
+        """
+        self._inner.fast_search()
+        return self
+
+    def postfilter(self) -> Self:
+        """
+        If this is called then filtering will happen after the search instead of
+        before.
+        By default filtering will be performed before the search.  This is how
+        filtering is typically understood to work.  This prefilter step does add some
+        additional latency.  Creating a scalar index on the filter column(s) can
+        often improve this latency.  However, sometimes a filter is too complex or
+        scalar indices cannot be applied to the column.  In these cases postfiltering
+        can be used instead of prefiltering to improve latency.
+        Post filtering applies the filter to the results of the search.  This
+        means we only run the filter on a much smaller set of data.  However, it can
+        cause the query to return fewer than `limit` results (or even no results) if
+        none of the nearest results match the filter.
+        Post filtering happens during the "refine stage" (described in more detail in
+        @see {@link VectorQuery#refineFactor}).  This means that setting a higher refine
+        factor can often help restore some of the results lost by post filtering.
+        """
+        self._inner.postfilter()
+        return self
+
+
+class AsyncQuery(AsyncStandardQuery):
    def __init__(self, inner: LanceQuery):
        """
        Construct an AsyncQuery
@@ -2588,7 +2617,7 @@ class AsyncQuery(AsyncQueryBase):
        return AsyncFTSQuery(self._inner.nearest_to_text({"query": query}))


-class AsyncFTSQuery(AsyncQueryBase):
+class AsyncFTSQuery(AsyncStandardQuery):
    """A query for full text search for LanceDB."""

    def __init__(self, inner: LanceFTSQuery):
@@ -2867,7 +2896,7 @@ class AsyncVectorQueryBase:
        return self


-class AsyncVectorQuery(AsyncQueryBase, AsyncVectorQueryBase):
+class AsyncVectorQuery(AsyncStandardQuery, AsyncVectorQueryBase):
    def __init__(self, inner: LanceVectorQuery):
        """
        Construct an AsyncVectorQuery
@@ -2950,7 +2979,7 @@ class AsyncVectorQuery(AsyncQueryBase, AsyncVectorQueryBase):
        return AsyncRecordBatchReader(results, max_batch_length=max_batch_length)


-class AsyncHybridQuery(AsyncQueryBase, AsyncVectorQueryBase):
+class AsyncHybridQuery(AsyncStandardQuery, AsyncVectorQueryBase):
    """
    A query builder that performs hybrid vector and full text search.
    Results are combined and reranked based on the specified reranker.
@@ -3054,7 +3083,7 @@ class AsyncHybridQuery(AsyncQueryBase, AsyncVectorQueryBase):
            CoalesceBatchesExec: target_batch_size=1024
              GlobalLimitExec: skip=0, fetch=10
                FilterExec: _distance@2 IS NOT NULL
-                  SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST], preserve_partitioning=[false]
+                  SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST, _rowid@1 ASC NULLS LAST], preserve_partitioning=[false]
                    KNNVectorDistance: metric=l2
                      LanceRead: uri=..., projection=[vector], ...
        <BLANKLINE>
@@ -3102,3 +3131,252 @@ class AsyncHybridQuery(AsyncQueryBase, AsyncVectorQueryBase):
        results.append(await self._inner.to_fts_query().analyze_plan())

        return "\n".join(results)
+
+
+class AsyncTakeQuery(AsyncQueryBase):
+    """
+    Builder for parameterizing and executing take queries.
+    """
+
+    def __init__(self, inner: LanceTakeQuery):
+        super().__init__(inner)
+
+
+class BaseQueryBuilder(object):
+    """
+    Wraps AsyncQueryBase and provides a synchronous interface
+    """
+
+    def __init__(self, inner: AsyncQueryBase):
+        self._inner = inner
+
+    def to_query_object(self) -> Query:
+        return self._inner.to_query_object()
+
+    def select(self, columns: Union[List[str], dict[str, str]]) -> Self:
+        """
+        Return only the specified columns.
+
+        By default a query will return all columns from the table.  However, this can
+        have a very significant impact on latency.  LanceDb stores data in a columnar
+        fashion.  This
+        means we can finely tune our I/O to select exactly the columns we need.
+
+        As a best practice you should always limit queries to the columns that you need.
+        If you pass in a list of column names then only those columns will be
+        returned.
+
+        You can also use this method to create new "dynamic" columns based on your
+        existing columns. For example, you may not care about "a" or "b" but instead
+        simply want "a + b".  This is often seen in the SELECT clause of an SQL query
+        (e.g. `SELECT a+b FROM my_table`).
+
+        To create dynamic columns you can pass in a dict[str, str].  A column will be
+        returned for each entry in the map.  The key provides the name of the column.
+        The value is an SQL string used to specify how the column is calculated.
+
+        For example, an SQL query might state `SELECT a + b AS combined, c`.  The
+        equivalent input to this method would be `{"combined": "a + b", "c": "c"}`.
+
+        Columns will always be returned in the order given, even if that order is
+        different than the order used when adding the data.
+        """
+        self._inner.select(columns)
+        return self
+
+    def with_row_id(self) -> Self:
+        """
+        Include the _rowid column in the results.
+        """
+        self._inner.with_row_id()
+        return self
+
+    def to_batches(
+        self,
+        *,
+        max_batch_length: Optional[int] = None,
+        timeout: Optional[timedelta] = None,
+    ) -> pa.RecordBatchReader:
+        """
+        Execute the query and return the results as an Apache Arrow RecordBatchReader.
+
+        Parameters
+        ----------
+
+        max_batch_length: Optional[int]
+            The maximum number of selected records in a single RecordBatch object.
+            If not specified, a default batch length is used.
+            It is possible for batches to be smaller than the provided length if the
+            underlying data is stored in smaller chunks.
+        timeout: Optional[timedelta]
+            The maximum time to wait for the query to complete.
+            If not specified, no timeout is applied. If the query does not
+            complete within the specified time, an error will be raised.
+        """
+        async_iter = LOOP.run(self._inner.execute(max_batch_length, timeout))
+
+        def iter_sync():
+            try:
+                while True:
+                    yield LOOP.run(async_iter.__anext__())
+            except StopAsyncIteration:
+                return
+
+        return pa.RecordBatchReader.from_batches(async_iter.schema, iter_sync())
+
+    def to_arrow(self, timeout: Optional[timedelta] = None) -> pa.Table:
+        """
+        Execute the query and collect the results into an Apache Arrow Table.
+
+        This method will collect all results into memory before returning.  If
+        you expect a large number of results, you may want to use
+        [to_batches][lancedb.query.AsyncQueryBase.to_batches]
+
+        Parameters
+        ----------
+        timeout: Optional[timedelta]
+            The maximum time to wait for the query to complete.
+            If not specified, no timeout is applied. If the query does not
+            complete within the specified time, an error will be raised.
+        """
+        return LOOP.run(self._inner.to_arrow(timeout))
+
+    def to_list(self, timeout: Optional[timedelta] = None) -> List[dict]:
+        """
+        Execute the query and return the results as a list of dictionaries.
+
+        Each list entry is a dictionary with the selected column names as keys,
+        or all table columns if `select` is not called. The vector and the "_distance"
+        fields are returned whether or not they're explicitly selected.
+
+        Parameters
+        ----------
+        timeout: Optional[timedelta]
+            The maximum time to wait for the query to complete.
+            If not specified, no timeout is applied. If the query does not
+            complete within the specified time, an error will be raised.
+        """
+        return LOOP.run(self._inner.to_list(timeout))
+
+    def to_pandas(
+        self,
+        flatten: Optional[Union[int, bool]] = None,
+        timeout: Optional[timedelta] = None,
+    ) -> "pd.DataFrame":
+        """
+        Execute the query and collect the results into a pandas DataFrame.
+
+        This method will collect all results into memory before returning.  If you
+        expect a large number of results, you may want to use
+        [to_batches][lancedb.query.AsyncQueryBase.to_batches] and convert each batch to
+        pandas separately.
+
+        Examples
+        --------
+
+        >>> import asyncio
+        >>> from lancedb import connect_async
+        >>> async def doctest_example():
+        ...     conn = await connect_async("./.lancedb")
+        ...     table = await conn.create_table("my_table", data=[{"a": 1, "b": 2}])
+        ...     async for batch in await table.query().to_batches():
+        ...         batch_df = batch.to_pandas()
+        >>> asyncio.run(doctest_example())
+
+        Parameters
+        ----------
+        flatten: Optional[Union[int, bool]]
+            If flatten is True, flatten all nested columns.
+            If flatten is an integer, flatten the nested columns up to the
+            specified depth.
+            If unspecified, do not flatten the nested columns.
+        timeout: Optional[timedelta]
+            The maximum time to wait for the query to complete.
+            If not specified, no timeout is applied. If the query does not
+            complete within the specified time, an error will be raised.
+        """
+        return LOOP.run(self._inner.to_pandas(flatten, timeout))
+
+    def to_polars(
+        self,
+        timeout: Optional[timedelta] = None,
+    ) -> "pl.DataFrame":
+        """
+        Execute the query and collect the results into a Polars DataFrame.
+
+        This method will collect all results into memory before returning.  If you
+        expect a large number of results, you may want to use
+        [to_batches][lancedb.query.AsyncQueryBase.to_batches] and convert each batch to
+        polars separately.
+
+        Parameters
+        ----------
+        timeout: Optional[timedelta]
+            The maximum time to wait for the query to complete.
+            If not specified, no timeout is applied. If the query does not
+            complete within the specified time, an error will be raised.
+
+        Examples
+        --------
+
+        >>> import asyncio
+        >>> import polars as pl
+        >>> from lancedb import connect_async
+        >>> async def doctest_example():
+        ...     conn = await connect_async("./.lancedb")
+        ...     table = await conn.create_table("my_table", data=[{"a": 1, "b": 2}])
+        ...     async for batch in await table.query().to_batches():
+        ...         batch_df = pl.from_arrow(batch)
+        >>> asyncio.run(doctest_example())
+        """
+        return LOOP.run(self._inner.to_polars(timeout))
+
+    def explain_plan(self, verbose: Optional[bool] = False):
+        """Return the execution plan for this query.
+
+        Examples
+        --------
+        >>> import asyncio
+        >>> from lancedb import connect_async
+        >>> async def doctest_example():
+        ...     conn = await connect_async("./.lancedb")
+        ...     table = await conn.create_table("my_table", [{"vector": [99, 99]}])
+        ...     query = [100, 100]
+        ...     plan = await table.query().nearest_to([1, 2]).explain_plan(True)
+        ...     print(plan)
+        >>> asyncio.run(doctest_example()) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+        ProjectionExec: expr=[vector@0 as vector, _distance@2 as _distance]
+          GlobalLimitExec: skip=0, fetch=10
+            FilterExec: _distance@2 IS NOT NULL
+              SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST, _rowid@1 ASC NULLS LAST], preserve_partitioning=[false]
+                KNNVectorDistance: metric=l2
+                  LanceRead: uri=..., projection=[vector], ...
+
+        Parameters
+        ----------
+        verbose : bool, default False
+            Use a verbose output format.
+
+        Returns
+        -------
+        plan : str
+        """  # noqa: E501
+        return LOOP.run(self._inner.explain_plan(verbose))
+
+    def analyze_plan(self):
+        """Execute the query and display with runtime metrics.
+
+        Returns
+        -------
+        plan : str
+        """
+        return LOOP.run(self._inner.analyze_plan())
+
+
+class LanceTakeQueryBuilder(BaseQueryBuilder):
+    """
+    Builder for parameterizing and executing take queries.
+    """
+
+    def __init__(self, inner: AsyncTakeQuery):
+        super().__init__(inner)
--- a/python/python/lancedb/remote/table.py
+++ b/python/python/lancedb/remote/table.py
@@ -26,7 +26,7 @@ from lancedb.common import DATA, VEC, VECTOR_COLUMN_NAME
 from lancedb.merge import LanceMergeInsertBuilder
 from lancedb.embeddings import EmbeddingFunctionRegistry

-from ..query import LanceVectorQueryBuilder, LanceQueryBuilder
+from ..query import LanceVectorQueryBuilder, LanceQueryBuilder, LanceTakeQueryBuilder
 from ..table import AsyncTable, IndexStatistics, Query, Table, Tags


@@ -617,6 +617,12 @@ class RemoteTable(Table):
    def stats(self):
        return LOOP.run(self._table.stats())

+    def take_offsets(self, offsets: list[int]) -> LanceTakeQueryBuilder:
+        return LanceTakeQueryBuilder(self._table.take_offsets(offsets))
+
+    def take_row_ids(self, row_ids: list[int]) -> LanceTakeQueryBuilder:
+        return LanceTakeQueryBuilder(self._table.take_row_ids(row_ids))
+
    def uses_v2_manifest_paths(self) -> bool:
        raise NotImplementedError(
            "uses_v2_manifest_paths() is not supported on the LanceDB Cloud"
--- a/python/python/lancedb/table.py
+++ b/python/python/lancedb/table.py
@@ -51,6 +51,7 @@ from .query import (
    AsyncFTSQuery,
    AsyncHybridQuery,
    AsyncQuery,
+    AsyncTakeQuery,
    AsyncVectorQuery,
    FullTextQuery,
    LanceEmptyQueryBuilder,
@@ -58,6 +59,7 @@ from .query import (
    LanceHybridQueryBuilder,
    LanceQueryBuilder,
    LanceVectorQueryBuilder,
+    LanceTakeQueryBuilder,
    Query,
 )
 from .util import (
@@ -1103,6 +1105,66 @@ class Table(ABC):
        """
        raise NotImplementedError

+    @abstractmethod
+    def take_offsets(self, offsets: list[int]) -> LanceTakeQueryBuilder:
+        """
+        Take a list of offsets from the table.
+
+        Offsets are 0-indexed and relative to the current version of the table.  Offsets
+        are not stable.  A row with an offset of N may have a different offset in a
+        different version of the table (e.g. if an earlier row is deleted).
+
+        Offsets are mostly useful for sampling as the set of all valid offsets is easily
+        known in advance to be [0, len(table)).
+
+        No guarantees are made regarding the order in which results are returned.  If
+        you desire an output order that matches the order of the given offsets, you will
+        need to add the row offset column to the output and align it yourself.
+
+        Parameters
+        ----------
+        offsets: list[int]
+            The offsets to take.
+
+        Returns
+        -------
+        pa.RecordBatch
+            A record batch containing the rows at the given offsets.
+        """
+
+    @abstractmethod
+    def take_row_ids(self, row_ids: list[int]) -> LanceTakeQueryBuilder:
+        """
+        Take a list of row ids from the table.
+
+        Row ids are not stable and are relative to the current version of the table.
+        They can change due to compaction and updates.
+
+        No guarantees are made regarding the order in which results are returned.  If
+        you desire an output order that matches the order of the given ids, you will
+        need to add the row id column to the output and align it yourself.
+
+        Unlike offsets, row ids are not 0-indexed and no assumptions should be made
+        about the possible range of row ids.  In order to use this method you must
+        first obtain the row ids by scanning or searching the table.
+
+        Even so, row ids are more stable than offsets and can be useful in some
+        situations.
+
+        There is an ongoing effort to make row ids stable which is tracked at
+        https://github.com/lancedb/lancedb/issues/1120
+
+        Parameters
+        ----------
+        row_ids: list[int]
+            The row ids to take.
+
+        Returns
+        -------
+        AsyncTakeQuery
+            A query object that can be executed to get the rows.
+        """
+
    @abstractmethod
    def _execute_query(
        self,
@@ -1648,6 +1710,12 @@ class LanceTable(Table):
        """Get the current version of the table"""
        return LOOP.run(self._table.version())

+    def take_offsets(self, offsets: list[int]) -> LanceTakeQueryBuilder:
+        return LanceTakeQueryBuilder(self._table.take_offsets(offsets))
+
+    def take_row_ids(self, row_ids: list[int]) -> LanceTakeQueryBuilder:
+        return LanceTakeQueryBuilder(self._table.take_row_ids(row_ids))
+
    @property
    def tags(self) -> Tags:
        """Tag management for the table.
@@ -4030,6 +4098,58 @@ class AsyncTable:
        """
        await self._inner.restore(version)

+    def take_offsets(self, offsets: list[int]) -> AsyncTakeQuery:
+        """
+        Take a list of offsets from the table.
+
+        Offsets are 0-indexed and relative to the current version of the table.  Offsets
+        are not stable.  A row with an offset of N may have a different offset in a
+        different version of the table (e.g. if an earlier row is deleted).
+
+        Offsets are mostly useful for sampling as the set of all valid offsets is easily
+        known in advance to be [0, len(table)).
+
+        Parameters
+        ----------
+        offsets: list[int]
+            The offsets to take.
+
+        Returns
+        -------
+        pa.RecordBatch
+            A record batch containing the rows at the given offsets.
+        """
+        return AsyncTakeQuery(self._inner.take_offsets(offsets))
+
+    def take_row_ids(self, row_ids: list[int]) -> AsyncTakeQuery:
+        """
+        Take a list of row ids from the table.
+
+        Row ids are not stable and are relative to the current version of the table.
+        They can change due to compaction and updates.
+
+        Unlike offsets, row ids are not 0-indexed and no assumptions should be made
+        about the possible range of row ids.  In order to use this method you must
+        first obtain the row ids by scanning or searching the table.
+
+        Even so, row ids are more stable than offsets and can be useful in some
+        situations.
+
+        There is an ongoing effort to make row ids stable which is tracked at
+        https://github.com/lancedb/lancedb/issues/1120
+
+        Parameters
+        ----------
+        row_ids: list[int]
+            The row ids to take.
+
+        Returns
+        -------
+        AsyncTakeQuery
+            A query object that can be executed to get the rows.
+        """
+        return AsyncTakeQuery(self._inner.take_row_ids(row_ids))
+
    @property
    def tags(self) -> AsyncTags:
        """Tag management for the dataset.
--- a/python/python/tests/test_query.py
+++ b/python/python/tests/test_query.py
@@ -1327,6 +1327,34 @@ def test_query_timeout(tmp_path):
        )


+def test_take_queries(tmp_path):
+    db = lancedb.connect(tmp_path)
+    data = pa.table(
+        {
+            "idx": range(100),
+        }
+    )
+    table = db.create_table("test", data)
+
+    # Take by offset
+    assert list(
+        sorted(table.take_offsets([5, 2, 17]).to_pandas()["idx"].to_list())
+    ) == [
+        2,
+        5,
+        17,
+    ]
+
+    # Take by row id
+    assert list(
+        sorted(table.take_row_ids([5, 2, 17]).to_pandas()["idx"].to_list())
+    ) == [
+        2,
+        5,
+        17,
+    ]
+
+
@pytest.mark.asyncio
 async def test_query_timeout_async(tmp_path):
    db = await lancedb.connect_async(tmp_path)
--- a/python/python/tests/test_table.py
+++ b/python/python/tests/test_table.py
@@ -290,7 +290,7 @@ def test_add_struct(mem_db: DBConnection):
        }
    )
    data = [{"s_list": [{"b": 1, "a": 2}, {"b": 4}]}]
-    table = mem_db.create_table("test", schema=schema)
+    table = mem_db.create_table("test2", schema=schema)
    table.add(data)


--- a/python/src/query.rs
+++ b/python/src/query.rs
@@ -13,10 +13,12 @@ use lancedb::index::scalar::{
    BooleanQuery, BoostQuery, FtsQuery, FullTextSearchQuery, MatchQuery, MultiMatchQuery, Occur,
    Operator, PhraseQuery,
 };
+use lancedb::query::QueryBase;
 use lancedb::query::QueryExecutionOptions;
 use lancedb::query::QueryFilter;
 use lancedb::query::{
-    ExecutableQuery, Query as LanceDbQuery, QueryBase, Select, VectorQuery as LanceDbVectorQuery,
+    ExecutableQuery, Query as LanceDbQuery, Select, TakeQuery as LanceDbTakeQuery,
+    VectorQuery as LanceDbVectorQuery,
 };
 use lancedb::table::AnyQuery;
 use pyo3::prelude::{PyAnyMethods, PyDictMethods};
@@ -488,6 +490,76 @@ impl Query {
    }
 }

+#[pyclass]
+pub struct TakeQuery {
+    inner: LanceDbTakeQuery,
+}
+
+impl TakeQuery {
+    pub fn new(query: LanceDbTakeQuery) -> Self {
+        Self { inner: query }
+    }
+}
+
+#[pymethods]
+impl TakeQuery {
+    pub fn select(&mut self, columns: Vec<(String, String)>) {
+        self.inner = self.inner.clone().select(Select::dynamic(&columns));
+    }
+
+    pub fn select_columns(&mut self, columns: Vec<String>) {
+        self.inner = self.inner.clone().select(Select::columns(&columns));
+    }
+
+    pub fn with_row_id(&mut self) {
+        self.inner = self.inner.clone().with_row_id();
+    }
+
+    #[pyo3(signature = (max_batch_length=None, timeout=None))]
+    pub fn execute(
+        self_: PyRef<'_, Self>,
+        max_batch_length: Option<u32>,
+        timeout: Option<Duration>,
+    ) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.inner.clone();
+        future_into_py(self_.py(), async move {
+            let mut opts = QueryExecutionOptions::default();
+            if let Some(max_batch_length) = max_batch_length {
+                opts.max_batch_length = max_batch_length;
+            }
+            if let Some(timeout) = timeout {
+                opts.timeout = Some(timeout);
+            }
+            let inner_stream = inner.execute_with_options(opts).await.infer_error()?;
+            Ok(RecordBatchStream::new(inner_stream))
+        })
+    }
+
+    pub fn explain_plan(self_: PyRef<'_, Self>, verbose: bool) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.inner.clone();
+        future_into_py(self_.py(), async move {
+            inner
+                .explain_plan(verbose)
+                .await
+                .map_err(|e| PyRuntimeError::new_err(e.to_string()))
+        })
+    }
+
+    pub fn analyze_plan(self_: PyRef<'_, Self>) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.inner.clone();
+        future_into_py(self_.py(), async move {
+            inner
+                .analyze_plan()
+                .await
+                .map_err(|e| PyRuntimeError::new_err(e.to_string()))
+        })
+    }
+
+    pub fn to_query_request(&self) -> PyQueryRequest {
+        PyQueryRequest::from(AnyQuery::Query(self.inner.clone().into_request()))
+    }
+}
+
 #[pyclass]
 #[derive(Clone)]
 pub struct FTSQuery {
--- a/python/src/table.rs
+++ b/python/src/table.rs
@@ -5,7 +5,7 @@ use std::{collections::HashMap, sync::Arc};
 use crate::{
    error::PythonErrorExt,
    index::{extract_index_params, IndexConfig},
-    query::Query,
+    query::{Query, TakeQuery},
 };
 use arrow::{
    datatypes::{DataType, Schema},
@@ -568,6 +568,20 @@ impl Table {
        Ok(Tags::new(self.inner_ref()?.clone()))
    }

+    #[pyo3(signature = (offsets))]
+    pub fn take_offsets(self_: PyRef<'_, Self>, offsets: Vec<u64>) -> PyResult<TakeQuery> {
+        Ok(TakeQuery::new(
+            self_.inner_ref()?.clone().take_offsets(offsets),
+        ))
+    }
+
+    #[pyo3(signature = (row_ids))]
+    pub fn take_row_ids(self_: PyRef<'_, Self>, row_ids: Vec<u64>) -> PyResult<TakeQuery> {
+        Ok(TakeQuery::new(
+            self_.inner_ref()?.clone().take_row_ids(row_ids),
+        ))
+    }
+
    /// Optimize the on-disk data by compacting and pruning old data, for better performance.
    #[pyo3(signature = (cleanup_since_ms=None, delete_unverified=None, retrain=None))]
    pub fn optimize(
--- a/rust/lancedb/Cargo.toml
+++ b/rust/lancedb/Cargo.toml
@@ -65,7 +65,11 @@ http = { version = "1", optional = true } # Matching what is in reqwest
 uuid = { version = "1.7.0", features = ["v4"], optional = true }
 polars-arrow = { version = ">=0.37,<0.40.0", optional = true }
 polars = { version = ">=0.37,<0.40.0", optional = true }
-hf-hub = { version = "0.4.1", optional = true, default-features = false, features = ["rustls-tls", "tokio", "ureq"]}
+hf-hub = { version = "0.4.1", optional = true, default-features = false, features = [
+    "rustls-tls",
+    "tokio",
+    "ureq",
+] }
 candle-core = { version = "0.9.1", optional = true }
 candle-transformers = { version = "0.9.1", optional = true }
 candle-nn = { version = "0.9.1", optional = true }
@@ -119,3 +123,16 @@ required-features = ["sentence-transformers"]
 [[example]]
 name = "bedrock"
 required-features = ["bedrock"]
+
+[[example]]
+name = "simple"
+
+[[example]]
+name = "full_text_search"
+
+[[example]]
+name = "ivf_pq"
+
+[[example]]
+name = "hybrid_search"
+required-features = ["sentence-transformers"]
--- a/rust/lancedb/examples/hybrid_search.rs
+++ b/rust/lancedb/examples/hybrid_search.rs
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+use arrow_array::{RecordBatch, RecordBatchIterator, StringArray};
+use arrow_schema::{DataType, Field, Schema};
+use futures::TryStreamExt;
+use lance_index::scalar::FullTextSearchQuery;
+use lancedb::index::scalar::FtsIndexBuilder;
+use lancedb::index::Index;
+use lancedb::{
+    arrow::IntoArrow,
+    connect,
+    embeddings::{
+        sentence_transformers::SentenceTransformersEmbeddings, EmbeddingDefinition,
+        EmbeddingFunction,
+    },
+    query::{QueryBase, QueryExecutionOptions},
+    Result, Table,
+};
+use std::{iter::once, sync::Arc};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let tempdir = tempfile::tempdir().unwrap();
+    let tempdir = tempdir.path().to_str().unwrap();
+    let embedding = SentenceTransformersEmbeddings::builder().build()?;
+    let embedding = Arc::new(embedding);
+    let db = connect(tempdir).execute().await?;
+    db.embedding_registry()
+        .register("sentence-transformers", embedding.clone())?;
+
+    // Create the table with embeddings
+    let table = db
+        .create_table("vectors", make_data())
+        .add_embedding(EmbeddingDefinition::new(
+            "facts",
+            "sentence-transformers",
+            Some("embeddings"),
+        ))?
+        .execute()
+        .await?;
+
+    // Create the FTS index
+    create_index(&table).await?;
+
+    // Perform a hybrid search using the FTS index and embeddings
+    let query_str = "world records";
+    let query = Arc::new(StringArray::from_iter_values(once(query_str)));
+    let query_vector = embedding.compute_query_embeddings(query)?;
+    let mut results = table
+        .query()
+        .full_text_search(FullTextSearchQuery::new(query_str.to_owned()))
+        .nearest_to(query_vector)?
+        .limit(5)
+        .execute_hybrid(QueryExecutionOptions::default())
+        .await?;
+
+    while let Some(batch) = results.try_next().await? {
+        let out = batch
+            .column_by_name("facts")
+            .unwrap()
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        for text in out.iter() {
+            if let Some(text) = text {
+                println!("Result: {}", text);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn make_data() -> impl IntoArrow {
+    let schema = Schema::new(vec![Field::new("facts", DataType::Utf8, false)]);
+
+    let facts = StringArray::from_iter_values(vec![
+        "Albert Einstein was a theoretical physicist.",
+        "The capital of France is Paris.",
+        "The Great Wall of China is one of the Seven Wonders of the World.",
+        "Python is a popular programming language.",
+        "Mount Everest is the highest mountain in the world.",
+        "Leonardo da Vinci painted the Mona Lisa.",
+        "Shakespeare wrote Hamlet.",
+        "The human body has 206 bones.",
+        "The speed of light is approximately 299,792 kilometers per second.",
+        "Water boils at 100 degrees Celsius.",
+        "The Earth orbits the Sun.",
+        "The Pyramids of Giza are located in Egypt.",
+        "Coffee is one of the most popular beverages in the world.",
+        "Tokyo is the capital city of Japan.",
+        "Photosynthesis is the process by which plants make their food.",
+        "The Pacific Ocean is the largest ocean on Earth.",
+        "Mozart was a prolific composer of classical music.",
+        "The Internet is a global network of computers.",
+        "Basketball is a sport played with a ball and a hoop.",
+        "The first computer virus was created in 1983.",
+        "Artificial neural networks are inspired by the human brain.",
+        "Deep learning is a subset of machine learning.",
+        "IBM's Watson won Jeopardy! in 2011.",
+        "The first computer programmer was Ada Lovelace.",
+        "The first chatbot was ELIZA, created in the 1960s.",
+    ]);
+    let schema = Arc::new(schema);
+    let rb = RecordBatch::try_new(schema.clone(), vec![Arc::new(facts)]).unwrap();
+    Box::new(RecordBatchIterator::new(vec![Ok(rb)], schema))
+}
+
+async fn create_index(table: &Table) -> Result<()> {
+    table
+        .create_index(&["facts"], Index::FTS(FtsIndexBuilder::default()))
+        .execute()
+        .await?;
+    Ok(())
+}
--- a/rust/lancedb/src/query.rs
+++ b/rust/lancedb/src/query.rs
@@ -1206,6 +1206,144 @@ impl HasQuery for VectorQuery {
    }
 }

+/// A builder for LanceDB take queries.
+///
+/// See [`crate::Table::query`] for more details on queries
+///
+/// A `TakeQuery` is a query that is used to select a subset of rows
+/// from a table using dataset offsets or row ids.
+///
+/// See [`ExecutableQuery`] for methods that can be used to execute
+/// the query and retrieve results.
+///
+/// This query object can be reused to issue the same query multiple
+/// times.
+#[derive(Debug, Clone)]
+pub struct TakeQuery {
+    parent: Arc<dyn BaseTable>,
+    request: QueryRequest,
+}
+
+impl TakeQuery {
+    /// Create a new `TakeQuery` that will return rows at the given offsets.
+    ///
+    /// See [`crate::Table::take_offsets`] for more details.
+    pub fn from_offsets(parent: Arc<dyn BaseTable>, offsets: Vec<u64>) -> Self {
+        let filter = format!(
+            "_rowoffset in ({})",
+            offsets
+                .iter()
+                .map(|o| o.to_string())
+                .collect::<Vec<_>>()
+                .join(",")
+        );
+        Self {
+            parent,
+            request: QueryRequest {
+                filter: Some(QueryFilter::Sql(filter)),
+                ..Default::default()
+            },
+        }
+    }
+
+    /// Create a new `TakeQuery` that will return rows with the given row ids.
+    ///
+    /// See [`crate::Table::take_row_ids`] for more details.
+    pub fn from_row_ids(parent: Arc<dyn BaseTable>, row_ids: Vec<u64>) -> Self {
+        let filter = format!(
+            "_rowid in ({})",
+            row_ids
+                .iter()
+                .map(|o| o.to_string())
+                .collect::<Vec<_>>()
+                .join(",")
+        );
+        Self {
+            parent,
+            request: QueryRequest {
+                filter: Some(QueryFilter::Sql(filter)),
+                ..Default::default()
+            },
+        }
+    }
+
+    /// Convert the `TakeQuery` into a `QueryRequest`.
+    pub fn into_request(self) -> QueryRequest {
+        self.request
+    }
+
+    /// Return the current `QueryRequest` for the `TakeQuery`.
+    pub fn current_request(&self) -> &QueryRequest {
+        &self.request
+    }
+
+    /// Return only the specified columns.
+    ///
+    /// By default a query will return all columns from the table.  However, this can have
+    /// a very significant impact on latency.  LanceDb stores data in a columnar fashion.  This
+    /// means we can finely tune our I/O to select exactly the columns we need.
+    ///
+    /// As a best practice you should always limit queries to the columns that you need.
+    ///
+    /// You can also use this method to create new "dynamic" columns based on your existing columns.
+    /// For example, you may not care about "a" or "b" but instead simply want "a + b".  This is often
+    /// seen in the SELECT clause of an SQL query (e.g. `SELECT a+b FROM my_table`).
+    ///
+    /// To create dynamic columns use [`Select::Dynamic`] (it might be easier to create this with the
+    /// helper method [`Select::dynamic`]).  A column will be returned for each tuple provided.  The
+    /// first value in that tuple provides the name of the column.  The second value in the tuple is
+    /// an SQL string used to specify how the column is calculated.
+    ///
+    /// For example, an SQL query might state `SELECT a + b AS combined, c`.  The equivalent
+    /// input to [`Select::dynamic`] would be `&[("combined", "a + b"), ("c", "c")]`.
+    ///
+    /// Columns will always be returned in the order given, even if that order is different than
+    /// the order used when adding the data.
+    pub fn select(mut self, selection: Select) -> Self {
+        self.request.select = selection;
+        self
+    }
+
+    /// Return the `_rowid` meta column from the Table.
+    pub fn with_row_id(mut self) -> Self {
+        self.request.with_row_id = true;
+        self
+    }
+}
+
+impl HasQuery for TakeQuery {
+    fn mut_query(&mut self) -> &mut QueryRequest {
+        &mut self.request
+    }
+}
+
+impl ExecutableQuery for TakeQuery {
+    async fn create_plan(&self, options: QueryExecutionOptions) -> Result<Arc<dyn ExecutionPlan>> {
+        let req = AnyQuery::Query(self.request.clone());
+        self.parent.clone().create_plan(&req, options).await
+    }
+
+    async fn execute_with_options(
+        &self,
+        options: QueryExecutionOptions,
+    ) -> Result<SendableRecordBatchStream> {
+        let query = AnyQuery::Query(self.request.clone());
+        Ok(SendableRecordBatchStream::from(
+            self.parent.clone().query(&query, options).await?,
+        ))
+    }
+
+    async fn explain_plan(&self, verbose: bool) -> Result<String> {
+        let query = AnyQuery::Query(self.request.clone());
+        self.parent.explain_plan(&query, verbose).await
+    }
+
+    async fn analyze_plan_with_options(&self, options: QueryExecutionOptions) -> Result<String> {
+        let query = AnyQuery::Query(self.request.clone());
+        self.parent.analyze_plan(&query, options).await
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use std::{collections::HashSet, sync::Arc};
@@ -1219,9 +1357,10 @@ mod tests {
    use arrow_schema::{DataType, Field as ArrowField, Schema as ArrowSchema};
    use futures::{StreamExt, TryStreamExt};
    use lance_testing::datagen::{BatchGenerator, IncrementingInt32, RandomVector};
+    use rand::seq::IndexedRandom;
    use tempfile::tempdir;

-    use crate::{connect, database::CreateTableMode, Table};
+    use crate::{connect, database::CreateTableMode, index::Index, Table};

    #[tokio::test]
    async fn test_setters_getters() {
@@ -1327,7 +1466,7 @@ mod tests {

        while let Some(batch) = stream.next().await {
            // pre filter should return 10 rows
-            assert!(batch.expect("should be Ok").num_rows() == 10);
+            assert_eq!(batch.expect("should be Ok").num_rows(), 10);
        }

        let query = table
@@ -1342,7 +1481,7 @@ mod tests {
        // should only have one batch
        while let Some(batch) = stream.next().await {
            // pre filter should return 10 rows
-            assert!(batch.expect("should be Ok").num_rows() == 9);
+            assert_eq!(batch.expect("should be Ok").num_rows(), 10);
        }
    }

@@ -1802,4 +1941,197 @@ mod tests {
        assert_eq!(0, batch.num_rows());
        assert_eq!(2, batch.num_columns());
    }
+
+    // TODO: Implement a good FTS test data generator in lance_datagen.
+    fn fts_test_data(nrows: usize) -> RecordBatch {
+        let schema = Arc::new(ArrowSchema::new(vec![
+            ArrowField::new("text", DataType::Utf8, false),
+            ArrowField::new("id", DataType::Int32, false),
+        ]));
+
+        let ids: Int32Array = (1..=nrows as i32).collect();
+
+        // Sample 1 - 3 tokens for each string value
+        let tokens = ["a", "b", "c", "d", "e"];
+        use rand::{rng, Rng};
+
+        let mut rng = rng();
+        let text: StringArray = (0..nrows)
+            .map(|_| {
+                let num_tokens = rng.random_range(1..=3); // 1 to 3 tokens
+                let selected_tokens: Vec<&str> = tokens
+                    .choose_multiple(&mut rng, num_tokens)
+                    .cloned()
+                    .collect();
+                Some(selected_tokens.join(" "))
+            })
+            .collect();
+
+        RecordBatch::try_new(schema, vec![Arc::new(text), Arc::new(ids)]).unwrap()
+    }
+
+    async fn run_query_request(table: &dyn BaseTable, query: AnyQuery) -> RecordBatch {
+        use lance::io::RecordBatchStream;
+        let stream = table.query(&query, Default::default()).await.unwrap();
+        let schema = stream.schema();
+        let batches = stream.try_collect::<Vec<_>>().await.unwrap();
+        arrow::compute::concat_batches(&schema, &batches).unwrap()
+    }
+
+    async fn test_pagination(table: &dyn BaseTable, full_query: AnyQuery, page_size: usize) {
+        // Get full results
+        let full_results = run_query_request(table, full_query.clone()).await;
+
+        // Then use limit & offset to do paginated queries, assert each
+        // is the same as a slice of the full results
+        let mut offset = 0;
+        while offset < full_results.num_rows() {
+            let mut paginated_query = full_query.clone();
+            let limit = page_size.min(full_results.num_rows() - offset);
+            match &mut paginated_query {
+                AnyQuery::Query(query)
+                | AnyQuery::VectorQuery(VectorQueryRequest { base: query, .. }) => {
+                    query.limit = Some(limit);
+                    query.offset = Some(offset);
+                }
+            }
+            let paginated_results = run_query_request(table, paginated_query).await;
+            let expected_slice = full_results.slice(offset, limit);
+            assert_eq!(
+                paginated_results, expected_slice,
+                "Paginated results do not match expected slice at offset {}, for page size {}",
+                offset, page_size
+            );
+            offset += page_size;
+        }
+    }
+
+    #[tokio::test]
+    async fn test_pagination_with_scan() {
+        let db = connect("memory://test").execute().await.unwrap();
+        let table = db
+            .create_table("test_table", make_non_empty_batches())
+            .execute()
+            .await
+            .unwrap();
+        let query = AnyQuery::Query(table.query().into_request());
+        test_pagination(table.base_table().as_ref(), query.clone(), 3).await;
+        test_pagination(table.base_table().as_ref(), query, 10).await;
+    }
+
+    #[tokio::test]
+    async fn test_pagination_with_fts() {
+        let db = connect("memory://test").execute().await.unwrap();
+        let data = fts_test_data(400);
+        let schema = data.schema();
+        let data = RecordBatchIterator::new(vec![Ok(data)], schema);
+        let table = db.create_table("test_table", data).execute().await.unwrap();
+
+        table
+            .create_index(&["text"], Index::FTS(Default::default()))
+            .execute()
+            .await
+            .unwrap();
+        let query = table
+            .query()
+            .full_text_search(FullTextSearchQuery::new("test".into()))
+            .into_request();
+        let query = AnyQuery::Query(query);
+        test_pagination(table.base_table().as_ref(), query.clone(), 3).await;
+        test_pagination(table.base_table().as_ref(), query, 10).await;
+    }
+
+    #[tokio::test]
+    async fn test_pagination_with_vector_query() {
+        let db = connect("memory://test").execute().await.unwrap();
+        let table = db
+            .create_table("test_table", make_non_empty_batches())
+            .execute()
+            .await
+            .unwrap();
+        let query_vector = vec![0.1_f32, 0.2, 0.3, 0.4];
+        let query = table
+            .query()
+            .nearest_to(query_vector.as_slice())
+            .unwrap()
+            .limit(50)
+            .into_request();
+        let query = AnyQuery::VectorQuery(query);
+        test_pagination(table.base_table().as_ref(), query.clone(), 3).await;
+        test_pagination(table.base_table().as_ref(), query, 10).await;
+    }
+
+    #[tokio::test]
+    async fn test_take_offsets() {
+        let tmp_dir = tempdir().unwrap();
+        let table = make_test_table(&tmp_dir).await;
+
+        let results = table
+            .take_offsets(vec![5, 1, 17])
+            .execute()
+            .await
+            .unwrap()
+            .try_collect::<Vec<_>>()
+            .await
+            .unwrap();
+
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].num_rows(), 3);
+        assert_eq!(results[0].num_columns(), 2);
+
+        let mut ids = results[0]
+            .column_by_name("id")
+            .unwrap()
+            .as_primitive::<Int32Type>()
+            .values()
+            .to_vec();
+        ids.sort();
+
+        assert_eq!(ids, vec![1, 5, 17]);
+
+        // Select specific columns
+        let results = table
+            .take_offsets(vec![5, 1, 17])
+            .select(Select::Columns(vec!["vector".to_string()]))
+            .execute()
+            .await
+            .unwrap()
+            .try_collect::<Vec<_>>()
+            .await
+            .unwrap();
+
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].num_rows(), 3);
+        assert_eq!(results[0].num_columns(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_take_row_ids() {
+        let tmp_dir = tempdir().unwrap();
+        let table = make_test_table(&tmp_dir).await;
+
+        let results = table
+            .take_row_ids(vec![5, 1, 17])
+            .execute()
+            .await
+            .unwrap()
+            .try_collect::<Vec<_>>()
+            .await
+            .unwrap();
+
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].num_rows(), 3);
+        assert_eq!(results[0].num_columns(), 2);
+
+        let mut ids = results[0]
+            .column_by_name("id")
+            .unwrap()
+            .as_primitive::<Int32Type>()
+            .values()
+            .to_vec();
+
+        ids.sort();
+
+        assert_eq!(ids, vec![1, 5, 17]);
+    }
 }
--- a/rust/lancedb/src/table.rs
+++ b/rust/lancedb/src/table.rs
@@ -62,8 +62,8 @@ use crate::index::{
 };
 use crate::index::{IndexConfig, IndexStatisticsImpl};
 use crate::query::{
-    IntoQueryVector, Query, QueryExecutionOptions, QueryFilter, QueryRequest, Select, VectorQuery,
-    VectorQueryRequest, DEFAULT_TOP_K,
+    IntoQueryVector, Query, QueryExecutionOptions, QueryFilter, QueryRequest, Select, TakeQuery,
+    VectorQuery, VectorQueryRequest, DEFAULT_TOP_K,
 };
 use crate::utils::{
    default_vector_column, supported_bitmap_data_type, supported_btree_data_type,
@@ -401,6 +401,7 @@ pub enum Filter {
 }

 /// A query that can be used to search a LanceDB table
+#[derive(Debug, Clone)]
 pub enum AnyQuery {
    Query(QueryRequest),
    VectorQuery(VectorQueryRequest),
@@ -1078,6 +1079,54 @@ impl Table {
        Query::new(self.inner.clone())
    }

+    /// Extract rows from the dataset using dataset offsets.
+    ///
+    /// Dataset offsets are 0-indexed and relative to the current version of the table.
+    /// They are not stable.  A row with an offset of N may have a different offset in a
+    /// different version of the table (e.g. if an earlier row is deleted).
+    ///
+    /// Offsets are useful for sampling as the set of all valid offsets is easily
+    /// known in advance to be [0, len(table)).
+    ///
+    /// No guarantees are made regarding the order in which results are returned.  If you
+    /// desire an output order that matches the order of the given offsets, you will need
+    /// to add the row offset column to the output and align it yourself.
+    ///
+    /// Parameters
+    /// ----------
+    /// offsets: list[int]
+    ///     The offsets to take.
+    ///
+    /// Returns
+    /// -------
+    /// pa.RecordBatch
+    ///     A record batch containing the rows at the given offsets.
+    pub fn take_offsets(&self, offsets: Vec<u64>) -> TakeQuery {
+        TakeQuery::from_offsets(self.inner.clone(), offsets)
+    }
+
+    /// Extract rows from the dataset using row ids.
+    ///
+    /// Row ids are not stable and are relative to the current version of the table.
+    /// They can change due to compaction and updates.
+    ///
+    /// Even so, row ids are more stable than offsets and can be useful in some situations.
+    ///
+    /// There is an ongoing effort to make row ids stable which is tracked at
+    /// https://github.com/lancedb/lancedb/issues/1120
+    ///
+    /// No guarantees are made regarding the order in which results are returned.  If you
+    /// desire an output order that matches the order of the given ids, you will need
+    /// to add the row id column to the output and align it yourself.
+    /// Parameters
+    /// ----------
+    /// row_ids: list[int]
+    ///     The row ids to take.
+    ///
+    pub fn take_row_ids(&self, row_ids: Vec<u64>) -> TakeQuery {
+        TakeQuery::from_row_ids(self.inner.clone(), row_ids)
+    }
+
    /// Search the table with a given query vector.
    ///
    /// This is a convenience method for preparing a vector query and
@@ -2339,20 +2388,13 @@ impl BaseTable for NativeTable {

            let (_, element_type) = lance::index::vector::utils::get_vector_type(schema, &column)?;
            let is_binary = matches!(element_type, DataType::UInt8);
+            let top_k = query.base.limit.unwrap_or(DEFAULT_TOP_K) + query.base.offset.unwrap_or(0);
            if is_binary {
                let query_vector = arrow::compute::cast(&query_vector, &DataType::UInt8)?;
                let query_vector = query_vector.as_primitive::<UInt8Type>();
-                scanner.nearest(
-                    &column,
-                    query_vector,
-                    query.base.limit.unwrap_or(DEFAULT_TOP_K),
-                )?;
+                scanner.nearest(&column, query_vector, top_k)?;
            } else {
-                scanner.nearest(
-                    &column,
-                    query_vector.as_ref(),
-                    query.base.limit.unwrap_or(DEFAULT_TOP_K),
-                )?;
+                scanner.nearest(&column, query_vector.as_ref(), top_k)?;
            }
            scanner.minimum_nprobes(query.minimum_nprobes);
            if let Some(maximum_nprobes) = query.maximum_nprobes {
Author	SHA1	Message	Date
Lance Release	bb809abd4b	Bump version: 0.24.3-beta.0 → 0.24.3	2025-08-15 18:02:04 +00:00
Lance Release	c87530f7a3	Bump version: 0.24.2 → 0.24.3-beta.0	2025-08-15 18:02:04 +00:00
Will Jones	1eb1beecd6	ci: remove more mentions of node (#2595 ) I promise this time I tested it locally :)	2025-08-15 11:01:02 -07:00
Yuval Lifshitz	ce550e6c45	feat: add missing rust examples (#2583 ) all 3 example are running now with: ``` cargo run --example simple cargo run --example full_text_search cargo run --example ivf_pq ``` Signed-off-by: Yuval Lifshitz <ylifshit@ibm.com> Co-authored-by: Weston Pace <weston.pace@gmail.com>	2025-08-15 10:38:58 -07:00
Will Jones	d3bae1f3a3	ci: drop old node mention (#2594 ) This broke release here: https://github.com/lancedb/lancedb/actions/runs/16993824504/job/48179542912	2025-08-15 09:51:19 -07:00
Will Jones	dcf53c4506	fix: limit and offset support paginating through FTS and vector search results (#2592 ) Adds tests to ensure that users can paginate through simple scan, FTS, and vector search results using `limit` and `offset`. Tests upstream work: https://github.com/lancedb/lance/pull/4318 Closes #2459	2025-08-15 08:55:12 -07:00
Ryan Green	941eada703	docs: update indexing and compaction docs (#2362 ) <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit - Documentation - Clarified and expanded explanations of data management concepts in LanceDB. - Added notes on automatic background fragment compaction and incremental reindexing support in LanceDB Cloud/Enterprise. - Updated details on disabling interim exhaustive kNN search during background reindexing. - Improved formatting and removed outdated FTS reindexing subsection. <!-- end of auto-generated comment: release notes by coderabbit.ai --> --------- Co-authored-by: Will Jones <willjones127@gmail.com>	2025-08-15 12:41:47 -02:30
Weston Pace	ed640a76d9	feat: add take_offsets and take_row_ids (#2584 ) These operations have existed in lance for a long while and many users need to drop down to lance for this capability. This PR adds the API and implements it using filters (e.g. `_rowid IN (...)`) so that in doesn't currently add any load to `BaseTable`. I'm not sure that is sustainable as base table implementations may want to specialize how they handle this method. However, I figure it is a good starting point. In addition, unlike Lance, this API does not currently guarantee anything about the order of the take results. This is necessary for the fallback filter approach to work (SQL filters cannot guarantee result order)	2025-08-15 06:48:24 -07:00
Will Jones	296205ef96	feat: upgrade lance to v0.33.0 (#2591 ) https://github.com/lancedb/lance/releases/tag/v0.33.0	2025-08-14 12:11:19 -07:00
Weston Pace	16beaaa656	ci: fix broken CI checks (#2585 )	2025-08-13 10:05:57 -07:00
Tomoko Uchida	4ff87b1f4a	feat: add hybrid search example in Rust (#2579 ) Hello! I'm new to lancedb and interested in the Rust SDK. I couldn't find a good hybrid search example in Rust, so I created one. ## Usage ```bash $ cargo run --quiet --example hybrid_search --features=sentence-transformers Result: Python is a popular programming language. Result: Mount Everest is the highest mountain in the world. Result: The first computer programmer was Ada Lovelace. Result: Coffee is one of the most popular beverages in the world. Result: Basketball is a sport played with a ball and a hoop. ```	2025-08-12 08:22:19 -07:00
Shawn	0532ef2358	chore(deps): update crunchy to 0.2.4 (#2581 ) Hi, I'm try to build goose (rely on lancedb) for android/termux. Found out some depsendencies need to update. https://github.com/block/goose/pull/3890 0.2.4 update - nmathewson Fix cross-compilation between windows and non-windows. https://github.com/shawn111/lancedb/actions/runs/16871317860 windows and linux build passed https://github.com/shawn111/lancedb/actions/runs/16871859398 Signed-off-by: Shawn Wang <shawn111@gmail.com>	2025-08-11 18:00:00 -07:00
BubbleCal	dcf7334c1f	chore: upgrade lance to v0.32.2-beta.1 (#2580 ) Signed-off-by: BubbleCal <bubble-cal@outlook.com>	2025-08-08 17:00:54 +08:00