Shounak Acharya

MongoDB

Sneha Das Gupta

Senior Partner Solutions Architect

This article compares five retrieval strategies namely pre-filtering, vector search, full-text search, hybrid search, and graph-based retrieval for RAG.

Depth-first Hybrid Search for GraphRAG

Community

Artur Costa

Discover the power of MongoDB schema optimization in the second part of The Cost of Not Knowing MongoDB series. This deep dive explores the impact of different data modeling approaches, focusing on the Bucket Pattern and Computed Pattern to enhance query performance and storage efficiency. Learn how grouping data by month or quarter can significantly reduce index size and improve read operations, while pre-computing aggregations can optimize reporting. With real-world benchmarks, load test results, and practical TypeScript code, this guide demonstrates how strategic schema design can maximize MongoDB’s potential.

The cost of not knowing MongoDB (V5RX) - Part 2

Daniel Coupal

Senior Staff Developer Advocate

<div class="introduction">

## Introduction

In a [previous data modeling article](https://medium.com/mongodb/data-duplication-in-mongodb-and-modern-applications-5a5c1836d114), we described different data types and how they fare with data duplication. A many-to-many relationship with data that can't sustain data duplication may not be a good candidate for embedding the relationship or applying the Extended Reference Pattern. However, there is another way this relationship can still be optimized when working with the document model. 

</div>

<div class="content">

## The Single Collection Pattern

The Single Collection Pattern is inspired by the Single Table Pattern and adapted for the document model. The Single Table Pattern has been described extensively by Amazon employees. It is used in many DynamoDB applications to reduce costs, improve performance, and avoid some of the common pitfalls developers run into with NoSQL databases.

The pattern is sometimes called the Adjacency Pattern. The Single Collection Pattern groups related documents of different types into a single collection. The documents would have otherwise been in various collections. 

Three characteristics define the pattern:

 - All related documents that are frequently accessed together are stored in the same collection.
 - Relationships between the documents are stored as pointers or other structures within the document.
 - An index is built on the field or array that maps the relationships. Such an index supports retrieving all related documents in a single query without database join operations.

The pattern helps model many-to-many relationships, allowing one to keep only one copy of the information. This avoids using data duplication where the cost of the duplication exceeds the benefits.

There is an additional scenario where this pattern excels. This is the case where frequent updates are done on large documents. By breaking the document into smaller parts, a database engine that rewrites the whole document to disk for every change can perform smaller write operations and improve performance. 

If the pattern is used to model a many-to-many relationship, one must use an array of references and maintain these references bidirectionally, at least one reference to itself, as shown in the example later. For the other types of relationships, one can alternatively build the relationship through a single field. For example, let's take a customer that has many orders, and each order has many line items. We can create a field `_id` carrying the information for each document type and the relationship of that document to its parent document.

``` javascript
{
  "_id": "C12345",
  "doc_type": "customer",
  ...
}

{
  "_id": "C12345-I34562",
  "doc_type": "invoice",
  ...
}

{
  "_id": "C12345-I34562-L0001",
  "doc_type": "line item",
  ...
}
```

A query like this would retrieve an invoice and all its line items.
``` javascript
find({"_id": /^C12345-I34562/})
```

## A use case with the Single Collection Pattern

Let's use an application that allows students to see the status of the classes they follow in a given semester. A class document will be the specific instance of the class, in other words, the class taught by a professor at a given time. The primary entity of our system is the student. This is the central entity that is queried by the system.

If we were to embed one side of the relationship, it would be the classes, the secondary entity. Because the system updates many things about a class, such as the next session and the summary of the previous session, we don't want to duplicate the information for each student. It makes sense to keep the entities separated, but let's apply the Single Collection Pattern.

``` javascript
{
  "_id": "CS101-001",
  "doc_type": "class",
  "class_name": "Introduction to Programming",
  "course_id": "CS101",
  "instructor": {
    "name": "Dr. Emily Smith",
    "email": "emily.smith@example.com",
    "office_hours": "Tuesdays and Thursdays 2:00 PM - 4:00 PM"
  },
  "semester": "Spring 2025",
  "schedule": [
    {
      "day_time": "Monday 10:00 AM - 11:30 AM",
      "location": "Room 101, Science Building"
    },
    {
      "day_time": "Wednesday 10:00 AM - 11:30 AM",
      "location": "Room 101, Science Building"
    },
    {
      "day_time": "Friday 10:00 AM - 11:30 AM",
      "location": "Room 101, Science Building"
    }
  ],
  "current_topic": "Loops and Iterations",
  "next_class_time": "2025-01-09T10:00:00Z",
  "upcoming_session_summary": "We will explore different types of loops (for, while) and how to use them effectively in Python.",
  "links": [
    { "target": "CS101-001", "doc_type": "class" },
    { "target": "S10023", "doc_type": "student" },
    { "target": "S12345", "doc_type": "student" },
    ...
    { "target": "S12355", "doc_type": "student" }
  ]
}
```

Note the `doc_type` and `target` fields in the `links` array allow us to maintain the relationship between our entities and filter them by document type.

Example of a student document:
```javascript
{
  "_id": "S12345",
  "doc_type": "student",
  "name": "Jane Doe",
  "major": "Computer Science",
  "semester": "Spring 2025",
  "registered_classes": [
    {
      "course_id": "CS101",
      "class_instance_id": "CS101-001",
      "class_name": "Introduction to Programming"
    },
    {
      
      "course_id": "MATH201",
      "class_instance_id": "MATH201-002",
      "class_name": "Calculus II"
    }
  ],
  "links": [
    { "target": "CS101-001", "doc_type": "class" },
    { "target": "MATH201-002", "doc_type": "class" },
    { "target": "S12345", "doc_type": "student" }
  ]
}
```

If there is no need to query for all students in a given class, the `links` array does not need to include pointers to the classes. However, it needs to have one reference to itself so a query can return a "students" document and all associated "classes" documents.

Next, we index the `links` structure to optimize the queries.

```javascript
db.students_classes.createIndex({"links.target":1, "links.doc_type": 1})
```


The following query retrieves a student and all the classes they take without doing any joins, providing top performance.

```javascript
db.students_classes.find({"links.target": "S12345"})
```

The following query retrieves all the registered students in the CS101-001 class.

```javascript
db.students_classes.find({"doc_type": "student", "links.target": "CS101-001"})
```

</div>

<div class="summary">

## Conclusion

The Single Collection is excellent for modeling systems with high-velocity operations, low-latency requirements, and frequent write operations. For example, adding data in bits and pieces to documents over time. By breaking down a document, you avoid performance issues with storage engines that rewrite full documents upon any update. The other scenario where the pattern shines is its ability to model many-to-many relationships where data duplication would be a significant issue. 

On the downside, the pattern adds complexity to the code and the management of the references. One should prefer embedding or the Extended Reference Pattern for the scenarios where the solution prefers simplicity or data duplication is acceptable and manageable. If the requirement for performance is for reading many sections of data at once, one would prefer preassembling the different pieces of data in a document with the shape to be read; in other words, one would prefer a larger document where entities are embedded.

To learn more about the other patterns, look at the list in this [summary](https://mdb.link/Blogs-PatternsSummary) or the book [MongoDB Data Modeling and Schema Design](https://mdb.link/book-mongodb-data-modeling-schema-design) or take the free [Data Modeling classes at MongoDB University](https://learn.mongodb.com/learning-paths/data-modeling-for-mongodb).

</div>



This blog post series examines the common Schema Design Patterns that work well in MongoDB.

Building with Patterns: The Single Collection Pattern

Python

Java

JavaScript

Rust

Ruby

Kotlin

Bash

Swift

TypeScript

Node.js

Spring

Google Cloud

Serverless

FastApi

.NET

React

Xamarin

Postman API

Spark

Kafka

Flask

Quarkus

Django

Terraform

Docker

React Native

Parquet

Netlify

Android

Jetpack Compose

Mobile

Mongoose

Neurelo

Unity

GitHub Actions

RaspberryPi

Jupyter

Pandas

Vercel

GraphQL

Azure

Kubernetes

Next.js

Prisma

Schema

Change Streams

Time series

Aggregation Framework

Vector Search

Shell

Data Visualization

Charts

Security

Indexes

Sharding

Cloud Manager

Stream Processing

Atlas

Search

Data Federation

Online Archive

Multi-Cloud

Triggers

Data API

Connectors

Compass

Ops Manager

Introductory

Intermediate

Advanced

Partner

Student

Champion

Hubert Nguyen

This article highlights startups in the games industry that use MongoDB as a backend. Their teams describe why they chose MongoDB Atlas and how it makes their development more productive.

MongoDB Atlas for Gaming, Startups to Watch in 2023

Aasawari Sahasrabuddhe

Learn how to build modern, scalable REST APIs using API Platform with Symfony and MongoDB. This step-by-step guide covers everything from setting up a Symfony project and integrating MongoDB Atlas to performing CRUD operations and implementing custom validation. Discover how API Platform streamlines API development with robust features like OpenAPI documentation, advanced search, and data integrity enforcement. Perfect for developers looking to efficiently manage real-time database interactions and create high-performance web applications.

Building REST APIs With API Platform and MongoDB

Ravindar Karampuri

This article explains the MongoDB's Online Archival feature and its advantages.

Atlas Online Archive: Efficiently Manage the Data Lifecycle

Erik Hatcher

Atlas Search adds powerful, relevant, full-text lexical search on top of your data.

Atlas Search Playground: Easy Experimentation

Max Lautsch

This article describes how to implement the concept of “slowly changing dimensions” (SCD) in the MongoDB document model and how to efficiently query them.

Slowly Changing Dimensions and Their Application in MongoDB

Venkatesh Shanbhag

Yemi Falokun

By integrating MongoDB Atlas with Vertex AI Extensions, we offer a solution that enhances the accessibility and usability of the database.

Harnessing Natural Language for MongoDB Queries With Google Gemini

Marko Aleksendrić

Join guest author Marko Aleksendric to learn how to use MongoDB, Anthropic's Claude and Python to create a simple web application aimed to help a virtual friend in a foreign country translate the local news items.

Building a Foreign Correspondent With MongoDB, Anthropic's Claude, Python

Ricardo Mello

Discover the journey of mastering MongoDB with Spring Data! In Part 1, we explored the basics, including MongoTemplate vs. MongoRepository. Part 2 took us deeper into advanced queries and Spring's powerful features. Now, in Part 3, we'll focus on optimizing your application with strategies like read preferences and indexing

Spring Data Unlocked: Performance Optimization Techniques With MongoDB

Eoin Brazil

Explaining the MongoDB Atlas Sample Data and diving into its various datasets

The MongoDB Atlas Sample Datasets

Ashni Mehta

In this article, we’ll cover how to use some MongoDB features, and compare and contrast how they look and feel in Kotlin and Java.

Java vs Kotlin: Different Syntax, Same Possibilities

The focus of this series is to show how much performance you can gain when using MongoDB properly, following the best practices, studying your application needs, and using it to model your data.

The Cost of Not Knowing MongoDB

Luce Carter

After 8 years, the MongoDB C# Driver has a new major version, 3.0. Let’s take a look at the main features and changes developers need to be aware of.

The C# Driver Version 3.0 is Here! What Do You Need to Know?

Scott Kurowski

Leverage the mathematical properties of a population of db AI-embedded vectors to extract potential novel business intelligence.

Discover Latent Semantic Structure With Vector Clustering

This tutorial will focus on the different ways users can achieve exact matches as well as the pros and cons of each.

Exact Matches in Atlas Search: Beginners Guide

This article explores building a Quarkus application using MongoDB's vector search for smarter, context-aware search results. We'll cover generating embeddings with Gemini AI and creating a vector index in MongoDB. Learn how to enhance your application's search capabilities with this modern approach.

Building a Quarkus Application to Perform MongoDB Vector Search

Lauren Schaefer

Don't fall into the trap of this MongoDB Schema Design Anti-Pattern: Case-Insensitive Queries Without Case-Insensitive Indexes

Case-Insensitive Queries Without Case-Insensitive Indexes

Don't fall into the trap of this MongoDB Schema Design Anti-Pattern: Unnecessary Indexes

Unnecessary Indexes

Mark Smith

Learn how to use the new MongoDB Atlas serverless instances to keep your usage costs down.

Keeping Your Costs Down With MongoDB Atlas Serverless Instances

We developed an app that pulls daily stats from the YouTube API, stores them in an Atlas database, and displays them in a MongoDB Charts dashboard.

7 Things I Learned While Modeling Data for YouTube Stats

Learn how SQL terms and concepts map to MongoDB.

Mapping Terms and Concepts from SQL to MongoDB

Discover the 3 things you need to know when you switch from SQL to MongoDB.

3 Things to Know When You Switch from SQL to MongoDB

Don't fall into the trap of this MongoDB Schema Design Anti-Pattern: Separating Data That is Accessed Together

Separating Data That is Accessed Together

Don't fall into the trap of this MongoDB Schema Design Anti-Pattern: Bloated Documents

Bloated Documents

When happens when you have a massive number of collections? Turns out, they're not great. In this post, we'll examine why.

Massive Number of Collections

Andrew Morgan

A great feature of MongoDB is its flexible document model. This post shows how to use document validation on polymorphic collections.

Document Validation for Polymorphic Collections

Don't fall into the trap of this MongoDB Schema Design Anti-Pattern: Massive Arrays

Massive Arrays

Get a summary of the six MongoDB Schema Design Anti-Patterns. Plus, learn how MongoDB Atlas can help you spot the anti-patterns in your databases.

A Summary of Schema Design Anti-Patterns and How to Spot Them

Adit Shrimal

Varun Hande

Neil Chitre

Manav Middha

In this article, we will compare four popular natural language processing (NLP) techniques to find the most optimal solution for retrieving the most relevant results for a search query from a large corpus of products. 

Comparing NLP Techniques for Scalable Product Search

Duncan Blythe

Discover how you can use SuperDuperDB to describe complex AI pipelines built on MongoDB Atlas Vector Search and state of the art LLMs.

Using SuperDuperDB to Accelerate AI Development on MongoDB Atlas Vector Search

Pavel Duchovny

Explore the synergy of MongoDB Atlas, LangChain, and OpenAI GPT-4 in our cutting-edge AI Shop application.

AI Shop: The Power of LangChain, OpenAI, and MongoDB Atlas Working Together

Richmond Alake

Han Heloir

Discover how to build powerful multi-agent AI systems using AutoGen and MongoDB. This guide explores the integration of Microsoft's AutoGen framework with MongoDB's Atlas Vector Search, enabling efficient retrieval-augmented generation (RAG) and collaborative AI agents. Learn step-by-step implementation, from environment setup to agent configuration, and unlock the potential of scalable, context-aware AI solutions for complex data-driven tasks.

Multi-agent Systems With AutoGen and MongoDB

Robert Walters

MongoDB Documentation has released a series of tutorials based on a self-hosted Docker compose environment that includes all components needed.

Learn How to Leverage MongoDB Data Within Kafka with New Tutorials!

This article focuses on how Java developers can effectively manage unstructured data using MongoDB. The schema-less architecture, paired with its natural integration with Java’s POJO model, streamlines the handling of unstructured data, offering agility and scalability for modern applications.

Why Unstructured Data is a Good Fit for Java

This tutorial explores building a retrieval-augmented generation (RAG) pipeline by integrating Google’s Gemma 2 (2B) model, MongoDB, and LLM evaluation techniques. Gemma 2, a lightweight model with two billion parameters, is used for efficient response generation, while MongoDB acts as the vector database, enabling semantic search for relevant documents.

The tutorial demonstrates how to create an asset management assistant that analyzes market reports stored in MongoDB. It covers embedding generation, vector search, and the use of the DeepEval library to assess the relevance and faithfulness of LLM-generated responses. By combining these tools, the tutorial highlights an efficient approach to building AI-driven solutions with robust performance evaluation in a RAG pipeline.

Implementing Robust RAG Pipelines: Integrating Google's Gemma 2 (2B) Open Model, MongoDB, and LLM Evaluation Techniques

Fuat Sungur

Previously, we calculated simple moving average/exponential moving average on currencies based on a time window. Now, we increase the complexity!

Currency Analysis With Time Series Collections #3 — MACD and RSI Calculation

This article is about three features of MongoDB that deserve to be better known: TTL Indexes, Capped Collections, and Change Streams.

3 Underused MongoDB Features

Cassiano Ziegler Bein

We put resources and documentation (with plenty of examples using cURL) right in Postman, an API platform for building and using APIs.

Automate the Automation on MongoDB Atlas

Aydrian Howard

Learn how to use Rekognition along with Realm to supplement new content with information as it is inserted into the database.

Using AWS Rekognition to Analyse and Tag Uploaded Images

Michael Lynn

Atlas enables enhanced scalability and reduces dependence on fixed costs when deploying on premises instances of MongoDB. Learn how to reduce costs.

5 Ways to Reduce Costs With MongoDB Atlas

Joe Drumgoole

Wouldn't it be great if we could just jump on a local command line to look at our live clusters? I wrote a script to automate it.

How to Easily Pause and Resume MongoDB Atlas Clusters

Nuno Costa

Discover the new Resumable Initial Sync feature in MongoDB v4.4. It enables nodes doing initial sync to survive events like transient network errors.

Articles

Featured Articles

Depth-first Hybrid Search for GraphRAG

The cost of not knowing MongoDB (V5RX) - Part 2

Building with Patterns: The Single Collection Pattern

All Articles