MongoDB Atlas Vector Search

Editor’s note: This MongoDB Atlas Vector Search review is based on my hands-on test of MongoDB Atlas Vector Search on Atlas free M0 and Flex clusters and a local Atlas CLI deployment, in November 2026. I weighed pricing, index setup and querying, filters and quantization, Search Node sizing, Automated Embedding and reranking, hybrid search, self-managed options, and how it compares with Pinecone, Weaviate, Qdrant, pgvector and Elasticsearch.

Quick verdict: I recommend MongoDB Atlas Vector Search for teams whose application data already lives in MongoDB and who want semantic search, RAG or agent memory without syncing a second database. The trade-off: the M10 plus two S30 Search Nodes that MongoDB recommends for production cost roughly $410 a month on AWS before storage and transfer, and the index lives in memory, so large unquantized indexes get expensive fast.

For my MongoDB Atlas Vector Search review, I added a vector index to an existing collection and queried it with $vectorSearch: HNSW approximate or exact search on up to 8,192 dimensions, pre-filtered on the same documents’ fields. MongoDB now calls the feature MongoDB Vector Search because it also runs on Community Edition; Atlas keeps the Atlas Vector Search name. In this review, I’ll take a closer look at MongoDB Atlas Vector Search’s pricing, features, and limits, so you can see exactly whether it fits your AI stack or whether a dedicated vector database like Pinecone is the better buy.

Key Takeaways

• One collection: Vectors, metadata and documents live together, and $vectorSearch pre-filters on boolean, date, objectId, numeric, string and UUID fields, with no second store to sync.
• Cheap prototyping: Free M0 runs vector search with 3 indexes; Flex allows 10 and caps at $30 a month.
• Always-on production costs: A minimum of two Search Nodes bills every hour, queries or not; M10 plus two S30 nodes is roughly $410 a month.
• Automated Embedding: Generally available on Atlas since August 2026, it generates Voyage AI embeddings for $0.02-$0.12 per million tokens, with 200 million free tokens per model.
• No read-your-own-writes: Indexes are eventually consistent, so a fresh document can miss the next query.

Pros and Cons

MongoDB Atlas Vector Search Pricing: How Much Does It Cost?

MongoDB Atlas Vector Search has no separate vector search fee: you pay for the Atlas cluster, any dedicated Search Nodes, and Voyage AI tokens for Automated Embedding or Native Reranking. Clusters bill hourly with monthly invoices.

• Free M0 ($0): for learning; 512 MB storage, shared RAM and vCPU, up to 100 operations per second, no backups and 3 search or vector indexes, one M0 per project.
• Flex ($0.011/hour, capped at $30/month): for development; 5 GB storage, 10 indexes and no Search Nodes, priced by throughput from $8 for 30 days at 0-100 ops/sec to $30 at 400-500.
• Dedicated M10 and up (from $0.08/hour, $56.94/month): for production databases; co-located search leaves about 1 GB of RAM for vectors on an M10, 2 GB on an M20 and 4 GB on an M30.
• Search Nodes (from $0.12/hour per node on AWS): for isolating search on M10+ clusters, 2-32 nodes per region per shard; MongoDB recommends S30 or higher for production.
• Usage add-ons: Automated Embedding costs $0.02-$0.12 per million tokens on current models, with a one-time 200 million free tokens per model; Native Reranking costs $0.02 or $0.05 per million tokens.

Option	Price	Resources	Vector search limits
Free M0	$0	512 MB storage, shared RAM and vCPU	3 search/vector indexes; no Search Nodes
Flex	$0.011/hour, up to $30/month	5 GB storage, shared RAM and vCPU	10 indexes; no Search Nodes
M10	$0.08/hour ($56.94/month)	2 GB RAM, 2 vCPUs	About 1 GB RAM for a co-located index
M20	$0.20/hour	4 GB RAM, 2 vCPUs	About 2 GB for a co-located index
M30	$0.54/hour	8 GB RAM, 2 vCPUs	About 4 GB for a co-located index
S20 Search Node	$0.12/hour per node	4 GB RAM, 2 vCPUs	Minimum 2 nodes
S30 Search Node	$0.24/hour per node	8 GB RAM, 4 vCPUs	MongoDB’s production starting tier
Automated Embedding	$0.02-$0.12 per 1M tokens	Voyage AI models hosted by Atlas	200M free tokens per model, one time

Search Node prices are AWS High-CPU rates; S20 lists at $0.14 and $0.15 an hour on the other two clouds, and regional prices vary.

Search Nodes bill from creation and are billed for a full hour even for partial use; changing tiers bills both sizes for the first hour. Traffic between Search Nodes and database nodes is charged at the cluster level, and backups and outbound transfer cost extra, though Free and Flex pay no outbound transfer.

Is MongoDB Atlas Vector Search Good Value for Money?

• Production math: M10 plus two S30 Search Nodes is about $0.56 an hour, roughly $410 a month on AWS; with two S20 nodes it is about $230, both before storage, backups and transfer.
• Standalone vectors: Pinecone Builder is $20/month flat and Standard has a $50 monthly minimum, so a small separate vector workload starts cheaper there than on Atlas with Search Nodes.
• Existing MongoDB data: You already pay for the cluster, and an M10, M20 or M30 runs a small co-located index with no extra line item, sync pipeline or second vendor.
• Embedding math: Embedding 500 million tokens with voyage-4 costs $30 at list price, and the first 200 million tokens per model are free.
• Memory lever: Scalar quantization cuts mongot RAM 3.75x and binary 24x, which can drop you one or more Search Node tiers.

Atlas Vector Search is good value if MongoDB is already your system of record and poor value as a standalone vector store for Postgres or warehouse data, where the cluster is pure overhead.

Reviewer’s Notes: I recommend prototyping on M0 or Flex, then a co-located M10 or M20 while the quantized index fits in about 1-2 GB. Before production traffic, budget two S30 Search Nodes, roughly $350 a month on top of the cluster, with RAM at least 10% above the total index.

My Experience With MongoDB Atlas Vector Search

Creating a Free Cluster and Loading Sample Data

I created a free M0 cluster and loaded the sample_mflix database, whose embedded_movies collection already holds voyage-3-large embeddings. The plot_embedding_voyage_3_large field stores 2,048-dimensional vectors, so I started from existing embeddings instead of building an embedding pipeline; MongoDB lists the whole quick start at 15 minutes. I opened Search & Vector Search in the left sidebar. Atlas automatically pauses a Free (M0) cluster after 30 days of inactivity with zero connections (it can be resumed), while Supabase’s Free plan, the easy pgvector route, pauses projects after a week of inactivity.

Building My First Vector Index

1. I clicked Create Search Index, picked the Vector Search type and chose Bring your own embeddings over Automated Embedding.
2. I named the index vector_index and pointed it at sample_mflix.embedded_movies.
3. The Visual Editor detected the embedding field and its dimensions.
4. I set Dot Product as the similarity method and, under Advanced, Scalar quantization.

MongoDB puts the build at about a minute, after which the status reads Active. Filters must be declared in the index as filter-type fields, such as genres or year, before a query can pre-filter on them. The flat indexing method, HNSW tuning (maxEdges 16-64, numEdgeCandidates 100-3,200) and nested-array options live only in the JSON Editor.

Querying in the Search Tester

I opened the Search Tester with the Query button and clicked Edit Query to open the default aggregation: a $vectorSearch stage with the index name, path, numCandidates and limit, then a $project that returns the vectorSearchScore. The quick start’s query searches the plot embeddings for “time travel” with 150 candidates for 10 results, below MongoDB’s own advice of at least 20 times the limit. numCandidates can’t exceed 10,000 or fall below limit, and $vectorSearch must be the first stage.

Then I set exact to true, which swaps HNSW approximate search for exhaustive exact search. MongoDB suggests exact search for collections under 10,000 documents, for filters matching under 5% of data, or to measure recall.

Switching to Automated Embedding

I created a second index with the Automated Embedding option on sample_mflix.movies, pointed the autoEmbed field at fullplot with the voyage-4 model, and queried it with plain text instead of a vector. Atlas generates embeddings at index time, on inserts and updates, and for each query, and stores them in a generated collection on the same cluster, not in an external vector database.

On an M0 with no payment method, query embedding is limited to 3 requests and 2,000 tokens per minute, so add a payment method before load testing.

Running It Locally

For offline work, I ran atlas local setup with sample data through the Atlas CLI (v5.3.1 or later) and Docker, which gave me a local deployment with the same index and query syntax. The self-managed route instead pulls the MongoDB Community Server and MongoDB Community Search Docker images; it needs MongoDB 8.2 or later, and you run mongot yourself.

Reviewer’s Notes: I recommend prototyping on the M0 with sample_mflix and rerunning each query with exact set to true to get ground-truth results for recall checks. Judge latency only on a dedicated tier, since M0 and Flex share RAM and vCPU.

Filters, Limits and Quantization

Atlas Vector Search accepts up to 8,192 dimensions per vector field, so 2,048-dimension voyage-3-large and 1,536-dimension OpenAI vectors fit with room to spare.

Limit	Value
Maximum vector dimensions	8,192
Search/vector indexes on Free M0	3 total
Search/vector indexes on Flex	10 total
numCandidates	Up to 10,000; at least limit; 20x limit recommended
Exact search sweet spot	Under 10,000 documents, filters matching under 5%, recall measurement
Filter field types	Boolean, date, objectId, numeric, string, UUID and arrays of these
Vector fields per $vectorSearch stage	1
Search Nodes per region per shard	2 to 32

Dedicated clusters have no fixed index-count limit, but M10s can degrade or hit out-of-memory errors as the index count grows. Pre-filter fields need the filter index type, filters don’t change vectorSearchScore, and the supported operators are:

• Equality and membership: $eq, $ne, $in and $nin.
• Ranges: $gt, $gte, $lt and $lte.
• Existence and logic: $exists, $not, $nor, $and and $or.

Filtered queries are typically slower than unfiltered ones, and a narrow pre-filter can exclude semantically close documents, so keep pre-filters broad. For fuzzy or phrase-matching pre-filters, MongoDB points to the vectorSearch operator inside a full-text $search.

The mongot process follows the database’s change stream, so indexes are eventually consistent: high write rates can return stale results, sharded clusters can return duplicates during chunk migration, and there is no read-your-own-writes guarantee. An app that inserts a document and immediately searches for it needs to retry or poll.

Scalar quantization stores 1-byte integers and cuts mongot RAM 3.75x; binary stores single bits, cuts it 24x and rescores the top results against full-fidelity vectors on disk, so leave free disk equal to 125% of the estimated index. Binary quantization and int1 vectors need dimensions divisible by 8, and MongoDB recommends automatic quantization above roughly 100,000 vectors.

Best for: collections whose filters map to typed metadata fields. Skip if: you need strict write-then-read consistency on search.

Search Nodes and Sizing: The Part That Decides Your Bill

The vector index is held in memory, so a Search Node needs RAM at least 10% larger than the total index. Almost 90% of a Search Node’s RAM can hold vector data and indexes, whereas by default mongot shares the database nodes with mongod; Atlas starts it with the first search index.

Per-vector memory, as float before quantization:

• voyage-3-large, 2,048 dimensions: 8 KB (2.14 KB as int8, 0.334 KB as int1).
• OpenAI text-embedding-ada-002, 1,536 dimensions: 6 KB.
• Cohere embed-english-v3.0, 1,024 dimensions: 4 KB.

One million 768-dimension vectors come to roughly 3 GB. Both an S20 High-CPU node (4 GB RAM, 2 vCPUs) and an S30 Low-CPU node (8 GB RAM, 1 vCPU) hold that, and MongoDB recommends the S20 High-CPU because query latency depends on available CPUs.

Adding nodes or changing the search tier triggers a full index rebuild. On AWS and Azure without customer-managed keys, Atlas restores a recent index copy from S3 or Azure Blob Storage (kept up to 14 days), but not yet on Google Cloud; queries keep using the old indexes until the new build finishes.

Search Nodes run in every Google Cloud region but only a subset of AWS and Azure regions. Customer-managed keys cover search indexes only on dedicated Search Nodes. Qdrant‘s free cluster is one node to size; an isolated Atlas deployment means sizing two systems, the cluster and its Search Nodes.

Automated Embedding and Native Reranking With Voyage AI

An autoEmbed index field tells Atlas to generate Voyage AI embeddings for a text field at index time, re-embed on inserts and updates, and embed query text at search time. MongoDB acquired Voyage AI in February 2025, and Automated Embedding has been generally available on Atlas since August 2026.

• voyage-4-lite ($0.02 per 1M tokens): for high-volume, cost-sensitive search; 16 million tokens per minute.
• voyage-4 ($0.06 per 1M tokens): for general text, as MongoDB’s recommended default; 8 million tokens per minute.
• voyage-4-large ($0.12 per 1M tokens): the largest voyage-4 model, capped at 3 million tokens per minute.
• voyage-code-4 ($0.12 per 1M tokens): for code, on Atlas only.

Each model includes 200 million free tokens per organization, once; the allowance never refreshes. Tokens bill on the initial build, on inserts and updates, and on queries, and US- or Europe-scoped inference costs 1.1x, with the Europe scope in preview.

The 32,000-token context window truncates longer indexed text, while longer query text fails. Clusters with a payment method get 2,000 requests per minute plus those token caps; initial builds use a separate high-throughput path, so MongoDB advises loading the collection before creating the index. Dedicated clusters must enable storage auto-scaling: a full disk pauses embedding and marks the index Stale.

Native Reranking adds a $rerank stage that reorders up to 1,000 documents (numDocsToRerank):

• rerank-3 and rerank-2.5: $0.05 per million tokens.
• rerank-3-lite and rerank-2.5-lite: $0.02 per million tokens.
• Latest models: 200 million free tokens.

Native Reranking must be enabled in project settings and needs a recent MongoDB version; the rerank-3 models require M10+, and reranking is unavailable self-managed or locally.

The verdict: I recommend Automated Embedding for new text search projects; teams already paying OpenAI or Cohere for embeddings can keep bring-your-own vectors.

Hybrid Search, Self-Managed Deployments and Integrations

$rankFusion requires MongoDB 8.0+ and merges $vectorSearch and full-text $search results with reciprocal rank fusion, a fixed rank constant of 60 and per-pipeline weights. $scoreFusion requires 8.3+ and combines normalized scores (none, sigmoid or minMaxScaler) with weights instead of rank positions.

Sub-pipelines run against one collection and may contain only stages such as $search, $vectorSearch, $match, $sort and $geoNear. MongoDB recommends setting lexical and vector weights per query, and $rerank can follow either stage. Choosing Elasticsearch for hybrid retrieval means a second store beside MongoDB, whether serverless, hosted or self-managed.

Community Edition and Enterprise Advanced run search through a separately installed mongot process, which is source-available under SSPL. Self-managed search requires MongoDB 8.2 or later, and on Enterprise Advanced it is a sales-led add-on. Automated Embedding works on self-managed Community Edition with your own Voyage AI API keys, voyage-code-4 excepted; Native Reranking does not run self-managed.

MongoDB integrations include:

• Retrieval frameworks: LangChain, LangGraph and LlamaIndex.
• Application frameworks: Haystack, Semantic Kernel and Spring AI.
• Agents and memory: CrewAI, Mastra, Mem0 and Vercel AI SDK.
• Cloud AI: Amazon Bedrock and Google Vertex AI.
• Workflow builders: n8n and Langflow.
• Agent connectivity: Official MongoDB MCP Server.

The no-login Chatbot Demo Builder in the Search Playground accepts a PDF up to 100 MB or 100,000 pasted characters for RAG tests with voyage-3-large. Snapshot links last 30 days, and it is a public demo, so keep sensitive data out.

Plan the schema with MongoDB best practices before adding vector indexes, since every pre-filter field must exist in the index as a typed filter field.

How Does MongoDB Atlas Vector Search Compare to Competitors?

• Pinecone: Starter is free, Builder costs $20/month flat, Standard has a $50 monthly minimum with a three-week trial and $300 in credits, and Enterprise has a $500 minimum. Pinecone supports dense, sparse and full-text indexes. It fits teams whose vectors are a workload of their own, separate from the system of record, where Builder’s flat $20 undercuts any Atlas Search Node layout.

• Weaviate: Weaviate Cloud offers one free cluster per user, Flex from $45/month and Premium on prepaid contracts through sales. It fits teams that want a dedicated vector service with a published entry price; compare Flex with Atlas’s full cluster-plus-Search-Node budget, not the cluster rate alone.

• Qdrant: Its free-forever cloud cluster has 0.5 vCPU, 1 GB RAM and 4 GB disk on one node, and Hybrid Cloud runs managed Qdrant on your own infrastructure. It fits cost-conscious teams that want a free single-node prototype or a managed engine in their own cloud account, with one system to size instead of two.

• pgvector: The vector extension for Postgres applies Atlas’s consolidation argument to SQL data. On Supabase, the Free plan allows two active projects but pauses them after a week of inactivity, and Pro starts at $25/month. It fits teams whose system of record is already Postgres.

• Elasticsearch: Elastic Cloud sells an Elasticsearch Vector Database serverless option alongside hosted and self-managed deployments. It fits teams that already run Elastic and would rather extend it than add MongoDB for vectors.

Atlas Vector Search wins where documents already live in MongoDB and the same query must filter on live operational fields. A dedicated engine wins when vectors are a separate workload, and pgvector wins when Postgres holds the data.

How I Reviewed MongoDB Atlas Vector Search

I built vector indexes on a free M0 cluster with sample_mflix, queried them in the Search Tester with approximate and exact search, created an Automated Embedding index with voyage-4 and ran a local Atlas CLI deployment. I also worked through the Flex, dedicated and Search Node pricing and sizing math, then compared Atlas with Pinecone, Weaviate, Qdrant, pgvector and Elasticsearch. My verdict weighs:

• Pricing and value: cluster and Search Node costs versus a separate service.
• Setup: index creation in the Atlas UI and locally.
• Queries and filtering: candidates and pre-filters.
• Limits and consistency: hard caps and index freshness.
• Scaling: memory sizing and rebuilds.
• Embedding and reranking: Voyage AI token charges.
• Hybrid search and integrations: fusion stages and frameworks.
• Deployment options: Atlas versus self-managed.

Prices current as of November 2026.

MongoDB Atlas Vector Search Review: Should You Keep Your Vectors in MongoDB?

Yes, if MongoDB already holds your application data. I recommend Atlas Vector Search for semantic search, RAG or agent memory over live documents that need filters on their own fields. Run search co-located while the quantized index fits in an M10 to M30’s spare RAM, then budget roughly $410 a month on AWS for an M10 plus two S30 Search Nodes once traffic is real. Turn on scalar or binary quantization first, since it can drop you a search tier.

No, if MongoDB would be an extra database just for vectors. Skip it if your data lives in Postgres (pgvector), if vectors are a standalone workload that starts cheaper on Pinecone’s $20/month Builder plan or Qdrant’s free cluster, if you need strict read-your-own-writes on search, or if you already run Elastic.

Before committing, check:

• Capacity: quantized index size against Search Node RAM, with at least 10% headroom.
• Freshness: your write rates against eventually consistent indexes.
• Embedding cost: Automated Embedding tokens for the initial build, writes and queries against your current provider’s bill.

Start on a free cluster at MongoDB Atlas Vector Search with sample_mflix, and compare approximate results with exact search before choosing production hardware.

FAQ

Is MongoDB Atlas Vector Search free?

Yes for prototyping: the free M0 cluster runs vector search with 512 MB storage and up to 3 search or vector indexes, and Flex costs $8 to $30 per 30 days depending on throughput. Production starts at $0.08 an hour for an M10, plus Search Nodes from $0.12 an hour each on AWS, minimum two. Automated Embedding and Native Reranking add per-token charges after their free allowances.

What is the maximum vector dimension in MongoDB Atlas Vector Search?

8,192 dimensions per vector field. Binary quantization and int1 vectors need a dimension count divisible by 8. Each $vectorSearch stage queries one vector field, and numCandidates tops out at 10,000. Bigger vectors also cost more memory: a 2,048-dimension voyage-3-large vector takes 8 KB as float, against 4 KB for a 1,024-dimension Cohere embed-english-v3.0 vector.

Do I need Search Nodes for Atlas Vector Search?

Not to start. Dedicated M10, M20 and M30 clusters run search on the same nodes, leaving about 1 GB, 2 GB and 4 GB of RAM for the vector index; Search Nodes require M10 or larger. For production isolation, MongoDB recommends Search Nodes at S30 or higher, at least two in every region, from $0.24 an hour each on AWS. Size their RAM at least 10% above the total index.

Can MongoDB generate embeddings for me?

Yes. Automated Embedding uses Voyage AI models to generate and refresh embeddings from a text field: voyage-4-lite costs $0.02, voyage-4 $0.06 and voyage-4-large $0.12 per million tokens, with a one-time 200 million free tokens per model per organization. It has been generally available on Atlas since August 2026 and also runs on self-managed Community Edition with your own Voyage AI API keys.

Is MongoDB Atlas Vector Search better than Pinecone?

Atlas is better when the data already lives in MongoDB and queries must filter on live document fields. Pinecone is cheaper to start for a standalone vector workload: Builder is $20/month flat and Standard has a $50 monthly minimum, against roughly $410 a month for MongoDB’s recommended M10 plus two S30 layout. See How Does MongoDB Atlas Vector Search Compare to Competitors? above for every rival.