BYO Storage
Competitive single-thread latency, scale-to-zero idle cost, and capabilities no other store has.
MVS owns the storage job underneath: vectors on your own object storage, with dense, sparse and BM25 search over them. That job is one layer of the semantic layer for unstructured and multimodal data, the architecture that turns raw objects into named features and serves them through contracts an application can bind to.
Cost proof
And up to 25M vectors it costs at least 42% less.
On the self-serve plans, which run to 25M vectors, MVS costs at least 42% less a month than the cheapest alternative at every size in the table below, plan fee included. Larger deployments are on Enterprise. Idle namespaces scale to zero and vectors persist on your object storage.
Cost calculatorEstimate your monthly MVS bill based on vector count, dimensions, and usage. All pricing is pay-as-you-go with no upfront commitments.
vs Competitors: 50K vectors, 768d, concurrency=1
p50 Latency
QPS (concurrency=10)
Recall@10
MVS stores vectors on your object storage (S3/GCS/B2) with PQ-compressed indexes in RAM. Competitive latency at single-thread, scale-to-zero idle cost, 2x or more cheaper than Pinecone and Weaviate a month up to 25M vectors. Full benchmark methodology.
Pure Usage-Based Pricing
The same rates as on the pricing page. Every plan bills them on top of its monthly fee.
$1.56
per 1M vectors / month
Vectors stored
The largest monthly term
$0.023
per GB / month
Storage
S3 / GCS / B2 pass-through
$25
per GB / month
Hot Cache
PQ indexes in RAM
$2
per 1M writes
Writes
Upsert, update, delete
$2
per 1M queries
Queries
Idle namespaces scale to zero
How MVS compares at scale
| Vectors | MVS | Qdrant | Pinecone | Weaviate |
|---|---|---|---|---|
| 1M | $27 | $120 | $500 | $73 |
| 10M | $266 | $460 | $2,700 | $730 |
| 100M | $10,000Enterprise minimum | $1,255 | $25,000 | $7,300 |
| 1B | $10,000Enterprise minimum | $12,500 | $26,000 | $73,000 |
| 5B | $10,000Enterprise minimum | Contact sales | Contact sales | Contact sales |
| 10B | $15,710Enterprise minimum | Contact sales | Contact sales | Contact sales |
Competitor prices from public pricing calculators (768d, ~100 QPS). Qdrant = dedicated cluster; Pinecone = serverless read units; Weaviate = per-dimension pricing. MVS figures are computed from the rate card above at 768 dimensions: the plan's monthly fee plus vectors stored and storage, excluding the one-time load and queries. Above 25M vectors MVS is the Enterprise plan, priced by contract from a monthly minimum, which those rows show. Benchmark repo.
Already paying for Pinecone, Qdrant, or Weaviate?
Move every vector with one copy-pastable script. Your embeddings transfer as-is, nothing to re-embed, so there's no GPU bill. Build starts at $25/mo for up to 1M vectors.
Support Tiers
Same usage rates on every tier. Tiers gate support level, not features.
Build
$25/mo plus usage
Up to 1M vectors, usage-based
- All search types (dense, sparse, BM25, hybrid)
- Unlimited namespaces
- Schema-on-write & adaptive indexes
- Community support
Managed path
Need Mixpeek to extract the embeddings too?
Start with your own vectors in MVS. When you want faces, scenes, transcripts, OCR, or other features generated for the same objects, move that workload to Managed without rebuilding your retrieval layer.
What Managed adds
Feature extractors
Vision, audio, text -- embeddings generated for you on ingest
Automatic indexing
Upload a file, get searchable vectors without writing pipeline code
Pipeline orchestration
Multi-step processing with branching, retries, and monitoring
Webhooks and alerts
Real-time notifications on ingest completion, anomalies, and threshold triggers
How to upgrade
Same namespace
Your existing vectors, metadata, and indexes stay exactly where they are
No migration
Managed builds on top of MVS -- your data is already in the right place
One click in Studio
Toggle your namespace from Standalone to Managed in the dashboard
Incremental adoption
Start with one extractor, add more as you need them -- no all-or-nothing switch
Feature Comparison
S3 Vectors is a cheap index. MVS is a database with agent-native retrieval. Different tools.
| Capability | Pinecone | Qdrant | S3 Vectors | MVS |
|---|---|---|---|---|
| Database operations on your vectors | ||||
| Dense vector search (ANN)Approximate nearest neighbor search over high-dimensional embeddings. The baseline capability every vector store needs. | ||||
| Native dense + sparse + BM25 hybrid searchFuse semantic, sparse, and keyword relevance in one query plan. S3 Vectors is an index; MVS runs hybrid retrieval natively. | Dense + sparse | Dense + sparse | Dense + sparse + BM25 | |
| Semantic JOINs across namespacesJoin two namespaces by vector similarity, like a SQL JOIN but on embeddings. No denormalization or data duplication required. | ||||
| Aggregations (GROUP BY, COUNT, SUM, AVG)Run analytics directly on your vector store. Group documents by metadata fields and compute counts, averages, and sums without ETL. | ||||
| Cross-shard transactionsAtomic writes across multiple shards using two-phase commit, so multi-namespace changes remain all-or-nothing. | ||||
| Time-travel queriesQuery data as it existed at a past point in time by replaying the write-ahead log. Useful for debugging, auditing, and reproducibility. | ||||
| Object storage-native persistenceData lives in your object storage. S3 Vectors gives you a cheap index; MVS adds database operations on the same storage foundation. | ||||
| Built for agentic workloads | ||||
| Streaming partial resultsGet results as shards respond instead of waiting for every shard. Agents can evaluate early hits and decide whether to refine or cancel. | ||||
| Query cancellationCancel in-flight fan-out queries that an agent no longer needs. Freed shard work returns to the pool instead of burning through the loop. | ||||
| Per-agent budget limitsEnforce max queries, writes, and compute per agent or API key at the coordinator level. Prevent runaway autonomous loops from running up spend. | ||||
| Standing queriesRegister a persistent query that fires a webhook whenever a newly ingested document matches. | ||||
| Multi-stage retrieval pipelinesChain retrieval stages such as broad recall, filtering, joining, and reranking in one request instead of wiring round trips in application code. | ||||
| Query audit logFull audit trail of every query: who ran it, when, and what was returned. Agents need inspectable retrieval, not black-box calls. | ||||
Quick Start
Start searching in 60 seconds
Generate embeddings with any provider. Upsert to MVS. Search.
from openai import OpenAI
from mixpeek import Mixpeek
openai = OpenAI()
mvs = Mixpeek(api_key="YOUR_KEY")
# Generate embedding
resp = openai.embeddings.create(
model="text-embedding-3-small",
input="red sports car on a mountain road"
)
embedding = resp.data[0].embedding
# Upsert to MVS
mvs.namespaces.documents.upsert(
namespace="ns_demo",
documents=[{
"id": "doc_1",
"dense_embedding": embedding,
"metadata": {"source": "catalog", "type": "image"}
}]
)
# Search
results = mvs.namespaces.documents.search(
namespace="ns_demo",
queries=[{"vector": embedding, "top_k": 10}]
)Works with any provider that outputs a float array. Bring your own model, your own dimensions.
API Examples
Capabilities you will not find in any other vector database.
Write documents with dense, sparse, and metadata in a single call.
from mixpeek import Mixpeek
client = Mixpeek(api_key="YOUR_KEY")
client.namespaces.upsert(
namespace="products",
documents=[
{
"id": "doc-001",
"dense_embedding": [0.12, -0.34, ...], # 768-d
"sparse_embedding": {"tokens": [1204, 879], "weights": [0.9, 0.4]},
"metadata": {"category": "electronics", "price": 299.99},
"text": "Noise-cancelling wireless headphones"
}
]
)Write documents with dense, sparse, and metadata in a single call.
from mixpeek import Mixpeek
client = Mixpeek(api_key="YOUR_KEY")
client.namespaces.upsert(
namespace="products",
documents=[
{
"id": "doc-001",
"dense_embedding": [0.12, -0.34, ...], # 768-d
"sparse_embedding": {"tokens": [1204, 879], "weights": [0.9, 0.4]},
"metadata": {"category": "electronics", "price": 299.99},
"text": "Noise-cancelling wireless headphones"
}
]
)How it works
Your bucket in, your app out. Everything between is MVS.
Curious how writes become durable before they are searchable? How the write-ahead log works on object storage.
Vector search on object storage: common questions
How can I run vector search directly on object storage like S3 instead of a hosted vector database?
Use a vector store that treats the bucket as its storage layer and keeps only caches on compute. There are three common ways to do it. Amazon S3 Vectors adds vector buckets and vector indexes to S3 itself and answers similarity queries with metadata filters. LanceDB is an open-source library that writes tables in the Lance file format to a bucket and queries them from your own process. Object-storage-first databases such as Mixpeek Vector Store (MVS) and turbopuffer keep the durable copy in object storage and cache the hot index on memory and SSD, so you get a database API (upsert, filter, hybrid search) without paying for always-on replicas. With MVS you bring your own embeddings and write them with one call, for example client.namespaces.upsert(namespace="products", documents=[{"id": "doc-001", "dense_embedding": [...], "text": "..."}]), then query with dense, sparse and BM25 search over the same namespace.
What is an object-storage-native vector database?
An object-storage-native vector database is a vector store whose source of truth is a bucket (S3, GCS, Azure Blob or any S3-compatible store) instead of disks attached to its servers. Writes go to a write-ahead log stored as objects, indexes and snapshots are rebuilt from that log, and the servers hold caches they can lose without losing data. Storage and compute scale separately, so an idle namespace can drop to zero compute while its vectors stay in the bucket. The design follows a simple rule we build Mixpeek around: push compute to the data, and read from where the data already is.
How does MVS stay fast if the vectors live on S3?
MVS separates durability from serving. A write is acknowledged once it is in the write-ahead log on object storage, and a PUT to object storage costs tens of milliseconds where a local fsync costs tens of microseconds, so MVS batches many writes into one log segment. Queries never wait on that path: shards load compressed index structures into memory and SSD and answer from there, fanning out across shards and streaming partial results as each shard responds. Data that has not been used for a set number of days moves to colder tiers, which you control per namespace with the tiering setting (for example {"idle_days": {"cold": 90, "frozen": 365}}). How the log works end to end is in our write-ahead log guide.
Is MVS the same as Amazon S3 Vectors?
No. Both keep vectors on object storage, and they differ in what you can ask. Amazon S3 Vectors is a managed vector index inside S3 for dense similarity search with metadata filters. MVS is a database on the same storage foundation: it runs dense, sparse and BM25 hybrid search in one query, joins two namespaces by vector similarity, computes GROUP BY, COUNT, SUM and AVG over metadata, and gives agents streaming partial results, query cancellation and per-agent budget limits. The feature comparison table on this page lists each capability side by side with Pinecone and S3 Vectors.
Can MVS keep my vectors in my own S3 or GCS bucket?
Yes, on dedicated and self-hosted deployments. MVS writes its write-ahead log, snapshots and cold tier through one provider-agnostic layer, and you point that layer at your bucket with two settings: MVS_OBJECT_STORE_PROVIDER (s3, gcs, r2, tigris, wasabi, b2, minio, spaces or ceph) and MVS_BUCKET. Credentials come from the deployment environment, such as an IAM role on the pods or GCS workload identity, and are never stored in config. On the shared managed plane MVS stores data in Mixpeek-operated object storage.
How much object storage do my vectors need, and how is MVS billed?
Raw size is dimensions times 4 bytes for float32 vectors. A 768-dimension vector is 3,072 bytes, so 10 million of them are about 31 GB before metadata, and 1 billion are about 3 TB. MVS bills a flat monthly plan fee plus metered usage: vectors stored, storage per GB, writes and queries. The cost calculator in the pricing section on this page applies the current rate card to your vector count and dimensions.
How do I move my vectors from Pinecone or Weaviate to object storage?
Run the migration script for your database from github.com/mixpeek/mvs-migrate. It reads every vector with its ID and metadata from the source and writes it to an MVS namespace, so your embeddings transfer as they are and nothing is re-embedded. The per-database commands are on mixpeek.com/mvs/migrations. Keep the old index serving reads until a sample of queries returns the same top results from both, then switch traffic.
More on the design: write-ahead logs on object storage, the best vector databases compared and migration scripts.
Free Proof of Concept
See it working on your data
Book a 60-minute architecture review. We'll run MVS on your actual workload and benchmark it against your current vector database.
Ethan Steininger
Founder & CEO, Mixpeek
In 60 minutes, you will get:
42%+
Lower monthly cost,
up to 25M vectors
< 1hr
Typical migration
for 100M vectors
10B+
Vectors supported
per index
Benchmark, stated plainly
Competitive single-thread latency, scale-to-zero idle cost, and database operations the cheap object-storage indexes do not expose.
Review the benchmark methodologyNeed Mixpeek to extract the embeddings too?
Use MVS for your own vectors. When you need faces, scenes, transcripts, OCR, or multimodal embeddings generated from the same objects, move that workload to Managed without rebuilding retrieval.
Already stitching extractors, indexes, and retrievers together? Start with MVS, then climb to Managed
