Temporal-Semantic Index

Time-Partitioned Vector Search

Traditional vector indexes treat all data as a flat collection. VectorScaleDB's proprietary temporal-semantic index serves the one unified representation that every ingested domain — genomics, finance, robotics, sensors — collapses into, partitioning it by time so time-bounded search never has to scan irrelevant history.

Temporal Partitioning

Automatic time-based organization

Incoming vectors are automatically organized by their temporal context. Older data is sealed and optimized for read performance while active data accepts high-throughput concurrent writes.

Configurable partitioning granularity (minutes, hours, days)
Automatic lifecycle management across partitions
Sealed partitions optimized for query performance
Lock-free concurrent ingestion on active partitions

Adaptive Indexing

Performance that adapts to your data

VectorScaleDB automatically adjusts its indexing strategy based on data characteristics and access patterns. Hot data receives aggressive indexing for sub-millisecond queries; cold data uses memory-efficient representations.

Automatic optimization based on data temperature
Tiered index strategies matching access frequency
Memory-efficient representations for archival data
Parallel index construction for high ingestion rates

Cross-Temporal Behavioral Continuity

The proprietary innovation that makes VectorScaleDB more than a partitioned vector store. Behavioral continuity links track entity trajectories across time boundaries, enabling queries that span arbitrary time ranges seamlessly.

Behavioral Linking

Cross-chunk entity continuity

When a chunk seals, the index identifies entities whose vectors appear in both the sealing chunk and the next. Entities are automatically linked across time boundaries for seamless cross-chunk trajectory queries.

Query Traversal

Follow trajectories across time

Continuity edges allow the query planner to traverse from a match in one chunk to related vectors in adjacent chunks without re-searching. This dramatically reduces multi-chunk query latency.

Edge Maintenance

Automatic pruning and rebalancing

Continuity edges are pruned when chunks are compacted or archived. Automatic memory management keeps overhead bounded while preserving the most behaviorally significant connections.

Sub-Millisecond KNN Search

Time-bounded nearest neighbor search that returns results faster than a single network round-trip.

Performance

Parallel chunk search with early termination

The query planner identifies which chunks overlap the requested time range and searches them in parallel. Results are merged using a bounded priority queue with early termination — once enough high-quality results are found, remaining chunks are skipped.

Parallel search across all matching chunks
Early termination when result quality converges
Intelligent chunk-level filtering eliminates irrelevant data before search
SIMD-accelerated distance computation (AVX2/NEON)

Accuracy

Tunable recall vs. latency tradeoff

Per-query accuracy vs. latency tradeoff control lets applications choose the right balance for each request. VectorScaleDB exposes this as a simple per-query parameter, from fast approximate results to exhaustive exact search.

Per-query accuracy tuning
Default parameters tuned for 99%+ recall at sub-millisecond latency
Exact KNN fallback for small chunk sizes
Recall metrics exposed via /v1/metrics

Snapshot & Restore

Full index durability with point-in-time recovery. Never rebuild an index from scratch again.

Snapshots

Incremental, non-blocking snapshots

Incremental snapshots capture the full index state. Only sealed chunks are included — active writes are protected by the durability layer. Snapshots are incremental: only chunks modified since the last snapshot are written.

Recovery

Fast restore with automatic recovery

On restart, the index loads the latest snapshot and automatically recovers any writes that occurred after the snapshot. This brings the index back to its exact pre-crash state in seconds, regardless of total index size.

Advanced Index Features

Research-driven enhancements that accelerate search and reduce memory footprint without sacrificing recall.

Pre-Filter

Rapid candidate elimination

A proprietary pre-filter stage rapidly eliminates non-matching candidates before full-precision evaluation, reducing computation by an order of magnitude while maintaining recall above 99%. Operates at SIMD speed for near-zero overhead.

Pyramid

Multi-resolution hierarchical search

A proprietary multi-resolution hierarchy enables coarse-to-fine search across multiple resolution levels. Initial filtering uses compact representations for speed; final ranking uses full-precision vectors for accuracy. Faster and more memory-efficient than flat full-dimensionality search.

Unified Temporal + Semantic Query Planning

The query planner understands both temporal predicates and vector similarity natively, optimizing across both dimensions simultaneously rather than treating them as separate filter steps.

How It Works

Temporal-semantic query planning in action

When a query specifies both a time range and a target vector, the planner doesn't simply filter by time and then search by vector (or vice versa). Instead, it selects an optimal execution strategy based on the query shape: narrow time ranges use chunk-direct search, wide ranges use continuity-edge traversal, and point queries use the entity index for O(1) lookup.

# Python: Temporal KNN query with the VectorScaleDB SDK
import vectorscaledb

client = vectorscaledb.Client("https://api.vectorscaledb.com")

# Find the 10 most similar entities within the last 24 hours
results = client.query.temporal_knn(
    embedding=[0.12, -0.34, 0.56, 0.78, -0.91, 0.23],
    k=10,
    time_range={
        "start": "2026-03-08T00:00:00Z",
        "end": "2026-03-09T00:00:00Z"
    },
    entity_type="TRACKED_OBJECT",
    accuracy=200  # Higher recall for this query
)

for result in results:
    print(f"Entity: {result.entity_id}")
    print(f"  Similarity: {result.similarity:.4f}")
    print(f"  Timestamp:  {result.timestamp}")
    print(f"  Chunk:      {result.chunk_id}")
    print(f"  Latency:    {result.latency_ms}ms")

# Example output:
# Entity: vehicle-0042
#   Similarity: 0.9714
#   Timestamp:  2026-03-08T14:22:01Z
#   Chunk:      chunk-2026-03-08-14
#   Latency:    0.82ms