Mongo on foojay.io - Friends of OpenJDK

Aggregation Optimization in MongoDB: Unnecessary Unwinds (Part 2)

Thu, 25 Jun 2026 10:01:00 +0000

And why MongoDB might be a better relational database than you ever realized.

Design reviews are one-on-one meetings where MongoDB experts deliver advice on data modeling best practices and application design challenges. In this series, we are going to explore common real-life scenarios where design reviews helped developers achieve meaningful success with MongoDB.

This article was written by Graeme Robinson. Find him on LinkedIn .

In Part 1 of this series , we described a use case based on a recent design review I conducted with a team at a MongoDB customer. The team in question was new to MongoDB, and the approach they had taken to both modeling their data and then subsequently querying it was very “RDBMS-like.” As a result, query performance was significantly slower than their SLA called for.

Aggregation Optimization in MongoDB: A Case Study From the Field (Part 1)

Tue, 23 Jun 2026 13:17:32 +0000

And why MongoDB might be a better relational database than you ever realized.

This article was written by Graeme Robinson. Find him on LinkedIn .

MongoDB is often described as a non-relational database, but whenever we store data in a database, there are relationships within that data. Depending on the type of database we use, though, how we model those relationships may change. As my colleague Rick Houlihan has often pointed out , there really is no such thing as non-relational data.

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 2: Conversational Memory

Wed, 10 Jun 2026 19:23:46 +0000

This is the second article in a three-part series. Part 1 covered the RAG foundation — loading runbooks into a vector store and wiring them to a language model. Part 3 will introduce stateful workflow checkpointing with pause and resume.

The Problem with Stateless Chat

In the first part of the series, we successfully created a chat interface where an operator can ask questions and receive answers based on the actual content of the runbooks they have uploaded and embedded in the system. For example, they can ask in the chat, “What should I check when my server’s CPU usage exceeds 80%?” and the assistant retrieves the relevant sections from the various runbooks and assembles a coherent and concrete response.

Introduction to CQRS using MongoDB

Tue, 09 Jun 2026 10:00:00 +0000

In enterprise environments, projects often begin with a simple structure: one model, one service, and one document, using a single class and data transfer object for both read and write operations. While this unified approach works at first, it becomes problematic as requirements grow. Operations become more complex, requiring additional validations, rules, and constraints. Over time, read operations may demand different formats, such as aggregations, summaries, or custom views. Relying on a single model for both reading and writing leads to maintenance challenges and inefficient queries. This approach can result in returning unnecessary data or omitting required information, violating the single responsibility principle and making the design less effective.

MongoDB as a Vector Database for AI Agents-MongoDB

Thu, 04 Jun 2026 10:00:00 +0000

Modern artificial intelligence systems are continually evolving. Large Language Models, or LLMs, have become the backbone of modern applications and help build conversational interfaces, like GPS, to more integrated content. However, LLMs lack memory and the capacity to retain content across interactions because they are stateless. And these limitations led to the building of AI agents. These AI agents build beyond simple prompt-response interactions into more autonomous, task-oriented workflows.

These agents are not just model invocations; rather, they are an orchestration layer that combines reasoning with capabilities like retrieval, memory, and tool execution. While developing these agents, a database with the ability to store and retrieve semantically meaningful data is needed, which is where vector databases come into the picture.

What is Sharding in MongoDB and When Should You Use It?

Tue, 02 Jun 2026 22:15:00 +0000

A Practical Introduction to Horizontal Scaling

When building applications, most developers start with a single database server.

At the beginning, everything works perfectly.

Your application might have:

A few thousand users
Manageable traffic
Datasets that easily fit on one machine

But as your application grows, something interesting starts to happen.

Queries take longer.

Write operations slow down.

The database server starts hitting CPU, RAM, or storage limits.

At this stage, many engineers ask an important question:

Exploring MongoT

Thu, 28 May 2026 21:02:49 +0000

Let’s explore this fascinating and awesome Java project from MongoDB - MongoT!

You can check out the source code here:

git clone https://github.com/mongodb/mongot

MongoT is a wrapper around the amazing Java search engine: Lucene .

Lucene is a powerful search toolkit built around an inverted token index structure that enables advanced text search capabilities, including ranked results, autocomplete, synonyms, fuzzy matching, highlighting, and faceting — all with high performance regardless of dataset size. Unlike MongoDB’s native query engine, it can efficiently search across multiple indexes simultaneously by intersecting lists of ordinal document IDs in parallel, using optimization techniques like skip-lists, ordinal compression, and document frequency ordering. It also supports indexing of various field types (integers, dates, keywords, etc.) and has expanded into vector search, enabling semantic similarity search by meaning rather than exact text matching.

AI-Powered Code Review Assistant: Automated Code Analysis with Spring AI and MongoDB

Thu, 14 May 2026 17:09:39 +0000

Code reviews catch bugs before they ship, but they take time. Most teams rely on manual review or basic linters that flag syntax issues but miss deeper problems like subtle resource leaks, poor exception handling, or security anti-patterns. Static analysis tools help, but they work with rigid rules that cannot generalize across code variations. A rule that catches catch (Exception e) {} will miss catch (Throwable t) { return null; }, even though both are the same underlying problem.

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 1: RAG Foundation

Thu, 07 May 2026 19:22:11 +0000

This is the first article in a three-part series. Part 2 covers short-term and long-term memory; Part 3 introduces stateful workflow checkpointing with pause/resume.

The problem

It’s 2 a.m. Suddenly, an alert pops up indicating abnormal CPU usage on the payment services. The on-call engineer opens their laptop, logs into the monitoring dashboards, and begins the hunt. One by one, he searches the runbooks on Confluence, checks the Slack chats, and opens the GitHub wikis and documents shared during the design phase. By the time he finds any useful information, ten minutes have already passed.

When Should You Use a Cache With MongoDB?

Tue, 05 May 2026 15:23:30 +0000

From time to time, I’ll run a design review for an application being migrated from a relational database onto MongoDB, where the customer shares an architectural diagram showing a caching layer (typically Redis) sitting between the app server and MongoDB.

I like to keep the architecture as simple as possible—after all, each layer brings its own complexity and management costs—so I’ll ask why the caching layer is there. Of course, the answer is always that it’s there to speed up data access. This reveals a misunderstanding of both the reason why caching layers were created and what MongoDB provides.

Large-Scale ETL Pipeline Architecture

Fri, 01 May 2026 19:23:04 +0000

Modern data-driven systems. ETL pipelines are no longer simply scheduled background processes that run silently overnight, one after another. They are the backbone of real-time analytics, powering operational dashboards and recommendation systems. They enable machine learning workflows.

This evolution, while creating enormous benefits, has—with the increase in data volume and the decrease in latency tolerance—called into question the traditional sequential ETL approach. A bottleneck for the speed is now required.

Building a Personalized Content Delivery System

Thu, 23 Apr 2026 15:10:45 +0000

Recommendation engines have a reputation for requiring specialized ML infrastructure: matrix factorization pipelines, training jobs, and model serving layers. That is one way to do it, but not the only way. If your data already lives in MongoDB and your application runs on Spring Boot, you can build a practical recommendation system using tools you already have. MongoDB aggregation pipelines handle the scoring math server-side, and Atlas Vector Search adds semantic matching without a separate vector database.

Distributed Cache Invalidation Patterns

Tue, 21 Apr 2026 13:52:03 +0000

Caching is one of the most powerful tools developers have at their disposal for optimizing application performance. Caching systems can significantly reduce latency and reduce the load on databases or external systems by storing frequently accessed data as close as possible to the application layer. The result? Improved responsiveness and overall system usability.

In small monolithic applications, cache management is usually very simple. A service retrieves data from a database, stores it in memory, and fulfills subsequent requests by retrieving the data directly from the cache. When the data changes, the cache key is invalidated or updated.

CQRS in Java: Separating Reads and Writes Cleanly

Thu, 16 Apr 2026 20:25:28 +0000

What you’ll learn

How the MongoDB Spring repository can be used to abstract MongoDB operations
Separating Reads and Writes in your application
How separating these can make schema design changes easier
Why you should avoid save() and saveAll() functions in Spring

The Command Query Responsibility Segregation (CQRS) pattern is a design method that segregates data access into separate services for reading and writing data. This allows a higher level of maintainability in your applications, especially if the schema or requirements change frequently. This pattern was originally developed with separate read and write sources in mind. However, implementing CQRS for a single data source is an effective way to abstract data from the application and make maintenance easier in the future. In this blog, we will use Spring Boot with MongoDB in order to create a CQRS pattern-based application.

Building a Kotlin App with Spring Boot and MongoDB Search

Thu, 09 Apr 2026 15:21:05 +0000

One of my favorite activities is traveling and exploring the world. You know that feeling of discovering a new place and thinking, “How have I not been here before?” It’s with that sensation that I’m always motivated to seek out new places to discover. Often, when searching for a place to stay, we’re not entirely sure what we’re looking for or what experiences we’d like to have. For example, we might want to rent a room in a city with a view of a castle. Finding something like that can seem difficult, right? However, there is a way to search for information accurately using MongoDB Search.

Manage HTTP Sessions with Spring Session MongoDB

Tue, 07 Apr 2026 15:19:10 +0000

Spring Session MongoDB is a library that enables Spring applications to store and manage HTTP session data in MongoDB rather than relying on container-specific session storage. In traditional deployments, session state is often tied to a single application instance, which makes scaling across multiple servers difficult. By integrating Spring Session with MongoDB, session data can be persisted beyond application restarts and shared across instances in a cluster, enabling scalable distributed applications with minimal configuration.

Java Faceted Full-Text Search API Using MongoDB Atlas Search

Thu, 02 Apr 2026 16:27:30 +0000

This is going to be a fun, practical tutorial demonstrating how to build a Java faceted full-text search API (like the ones powering sites like Amazon)!

We’ll use an interesting dataset which showcases how you can effectively pair machine learning/AI-generated data with more traditional search to produce fast, cheap, repeatable, and intuitive search engines.

TL;DR: If you (like me!) are less about words and more about code, you can jump straight in. Check it out and run it locally like this:

MongoDB Search Score Breakdown

Tue, 31 Mar 2026 15:05:08 +0000

Full-text search powers all of our digital lives — googling for this and that; asking Siri where to find a tasty, nearby dinner; shopping at Amazon; and so on. We receive relevant results, often even in spite of our typos, voice transcription mistakes, or vaguely formed queries. We have grown accustomed to expecting the best results for our searching intentions, right there, at the top.

But now it’s your turn, dear developer, to build the same satisfying user experience into your Atlas-powered application.

Modeling One-to-Many Relationships in Java with MongoDB

Thu, 26 Mar 2026 15:50:30 +0000

In a relational database, modeling a one-to-many relationship is straightforward: you create two tables and connect them with a foreign key. When you need the data together, you write a JOIN. In MongoDB, you have a choice, and that choice has a direct impact on your application’s performance, scalability, and maintainability.

Consider a common scenario: a BlogPost that has many Comment objects. In Java, this is a natural List<Comment> field on the post. But when it comes time to persist that relationship in MongoDB, you need to decide how to store it. Should the comments live inside the blog post document? Or should they sit in their own collection, connected by references?

Clean Architecture with Spring Boot and MongoDB

Tue, 24 Mar 2026 16:43:14 +0000

Most Spring Boot tutorials tightly wire everything together. Controllers call services, services call repositories, and MongoDB annotations like @Document and @Field sit right next to your business logic. It works until you need to swap the database, test logic in isolation, or reuse domain rules in a different context.

Clean Architecture enforces one rule: source code dependencies always point inward. Your business logic never imports Spring or MongoDB classes. The database becomes a pluggable detail at the outermost layer, something you can replace without rewriting core application code.

Building Reactive Data Streams with Project Reactor

Thu, 19 Mar 2026 15:13:31 +0000

Creating Non-Blocking Streaming Endpoints for High-Throughput Applications

There are problems that only occur in production. Or rather, we only notice them in production.

We have created an application that exposes clean APIs, according to all standards. You have modeled the domain elegantly and efficiently: all load tests show reassuring data. CPU usage is reasonable, to say the least. However, there is a problem: when traffic exceeds a threshold, the system slows down. Response time latency becomes inconsistent; threads stack up on top of each other. Response times increase unpredictably, and application customers begin to complain about this situation.

Language Learning Flashcard System - Part 1

Tue, 17 Mar 2026 16:39:58 +0000

My native language is Spanish. I’ve been learning (and butchering) English my whole life. But at some point, I felt confident with English and wanted to learn Japanese. Big mistake. This is a totally different beast: three writing systems (Hiragana ひらがな, Katakana カタカナ and Kanji 漢字), a completely different grammar, no relation whatsoever with European languages… I needed help. And tools to learn. And one of them is Space Repetition System based apps.

Atlas Online Archive: Efficiently Manage the Data Lifecycle

Thu, 12 Mar 2026 14:55:00 +0000

Problem statement

In the production environment, in a MongoDB Atlas database, a collection contains massive amounts of data stored, including aged and current data. However, aged data is not frequently accessed through applications, and the data piles up daily in the collection, leading to performance degradation and cost consumption. This results in needing to upgrade the cluster tier size to maintain sufficient resources according to workload, as it would be difficult to continue with the existing tier size.

Event-Driven Architecture in Java and Kafka

Tue, 10 Mar 2026 18:35:42 +0000

Reactive Java is well suited to modern streaming, event driven applications. In this article, we’ll walk through an example of such an application using Reactive Java with MongoDB. Specifically, we’re going to cover:

Why Reactive Java was introduced and how it differs from more traditional Java programming.
Details of some of the key elements of Reactive Java - Mono , Flux and flatMap.
A walk through of a sample application, comparing a Reactive version of the code using the Reactive Streams MongoDB driver, with a more traditional version of the code using the synchronous MongoDB driver.

Streaming Data - The Air Traffic Control Example.

As a key part of global initiatives to modernize national airspace systems, many national aviation authorities have introduced mandates requiring most non-military aircraft transmit GPS based location data using a system known as Automatic Dependent Surveillance Broadcast, or “ADS-B”.

Role-Based Access Control in Java Applications

Thu, 05 Mar 2026 20:31:49 +0000

We often work with Java applications where security begins and ends with authentication. The JWT token is validated, Spring Security is integrated, and an identity provider is added, thinking that this type of configuration is sufficiently secure.

The real problem is that authentication only answers one question: who are you? In real applications, we also have to answer another question, which is often more complex and more dangerous to get wrong: what are you allowed to do?

Data Enrichment in MongoDB

Tue, 03 Mar 2026 16:10:36 +0000

In a recent design review, a customer was enriching new data as it came in. As the enrichment process was fairly complex, they ran into some issues with concurrency. To solve this, they decided that data should go into a staging collection rather than the main collection that held the data. This did nothing to help with concurrency issues and actually created more work on the database side of things when enrichment was complete.

How to Build a Search Service in Java with MongoDB

Fri, 27 Feb 2026 18:28:09 +0000

We need to code our way from the search box to our search index. Performing a search and rendering the results in a presentable fashion, itself, is not a tricky endeavor: Send the user’s query to the search server, and translate the response data into some user interface technology. However, there are some important issues that need to be addressed, such as security, error handling, performance, and other concerns that deserve isolation and control.

MongoDB and the Raft Algorithm

Tue, 24 Feb 2026 15:47:27 +0000

MongoDB’s replica set architecture uses distributed consensus to ensure consistency, availability, and fault tolerance across nodes. At the core of this architecture is the Raft consensus algorithm, which breaks the complexities of distributed consensus into manageable operations: leader election, log replication, and commitment. This document explores how MongoDB integrates and optimizes Raft for its high-performance replication needs.{#1c95}

Raft Roles and MongoDB’s Replica Set

In Raft, nodes can assume one of three roles: leader , follower , or candidate . MongoDB maps these roles to its architecture seamlessly. The primary node functions as the leader, handling all client write operations and coordinating replication. The secondaries serve as followers, maintaining copies of the primary’s data. A node transitions to the candidate role during an election, triggered by leader unavailability.{#5e79}

Ports and Adapters in Java: Keeping Your Core Clean

Thu, 19 Feb 2026 16:13:59 +0000

Introduction

If we want to evolve our Java system over time, architecture is more important than the choice of framework. Very often, teams realize too late that what was supposed to be a simple persistence layer at the beginning ended up influencing and overwhelming the entire application design. MongoDB annotations end up in domain models, repository abstractions mirror collections, and business logic becomes an integral part of the infrastructure.

Hexagonal architecture, also known as Ports and Adapters, offers an architectural model that aims to avoid this problem. It involves the correct attribution of responsibilities to the various application layers. It encourages us to consider external systems (databases, message brokers, HTTP APIs, MCP servers) as details rather than pillars at the center of our design.

Optimizing the MongoDB Java Driver

Tue, 17 Feb 2026 15:33:56 +0000

Co-authored by Slav Babanin.

Donald Knuth {#https://www-cs-faculty.stanford.edu/~knuth/}, widely recognized as the ‘father of the analysis of algorithms,’ warned against premature optimization—spending effort on code that appears inefficient but is not on the critical path. He observed that programmers often focus on the wrong 97% of the codebase. Real performance gains come from identifying and optimizing the critical 3%. But, how can you identify the critical 3%? Well, that’s where the philosophy of ’never guess, always measure’ comes in.

MongoDB Sharding: What to Know Before You Shard a Collection

Thu, 12 Feb 2026 16:47:52 +0000

When we think about a system that operates at scale, we are usually talking about an application that needs to serve millions of users. This often happens when an application suddenly becomes popular and usage grows much faster than expected. As more people start using it, the system naturally begins to struggle to keep up with the load.

More users mean more requests, more data being generated, and more pressure on the database. If nothing is done, bottlenecks start to appear and the overall performance of the system degrades. There are two traditional ways to deal with this problem: vertical scaling and horizontal scaling.

Reactive Java with Project Reactor

Tue, 10 Feb 2026 14:32:03 +0000

Introduction: Why Reactive Java Still Matters

Over the past decade, the Java ecosystem has gradually abandoned the idea that increasing the number of threads is the scalable solution to growing load. Cloud-native implementations, containerized workloads, and high-I/O applications have highlighted the inefficiencies of the traditional synchronous thread-per-request model.

Reactive programming is not a panacea, a miracle solution. Certainly, it does not make applications “faster” by default. What it offers, when applied correctly, is the ability to predict behavior under load, better resource utilization, and explicit control over data flow. For systems that handle high concurrency, streaming data, or variable traffic patterns, these characteristics are hugely relevant.

MongoDB 8.0 Migration Guide: What You Need to Know Before Upgrading

Thu, 05 Feb 2026 14:56:13 +0000

Have you ever wondered why updates and upgrades are so essential for any system? Well, it’s no secret: They ensure that systems remain relevant and efficient. With MongoDB, it’s no different. Whenever we think about updating, we seek efficiency, security, performance, and other benefits that come with updated systems. However, every update introduces changes that need to be carefully managed. In this article, we will cover some of the new features of MongoDB version 8.0 and highlight the key considerations you should take into account before migrating to this new version.

GraphQL for Java Developers: Building a Flexible Data Layer

Tue, 03 Feb 2026 15:43:07 +0000

For many years, REST has been the standard architectural style for creating APIs in the Java ecosystem. Frameworks such as Spring MVC and, more recently, Spring WebFlux make it easy to expose HTTP endpoints with the REST paradigm, supported by well-structured service layers. In many cases, this model works well and serves as the basis for numerous enterprise solutions.

However, as applications grow and frontend requirements become more dynamic, REST-based APIs are beginning to show their limitations. Multiple endpoints that return rigid DTOs often lead to over-fetching, under-fetching, and a proliferation of specialised endpoints created to meet slightly different customer needs. Over time, APIs become more difficult to evolve without introducing radical changes.

Abstracting Data Access in Java With the DAO Pattern

Thu, 29 Jan 2026 16:37:06 +0000

The Data Access Object (DAO) pattern is a structural pattern that isolates your application’s business logic from persistence operations. By using an abstract API, the DAO pattern hides all the complexity of performing CRUD operations against your database—whether that’s MongoDB, a relational database, or any other storage mechanism.

This separation is crucial: Your business logic shouldn’t care whether you’re using MongoDB’s flexible document model or a rigid SQL schema. The DAO pattern ensures both layers can evolve independently.

Introduction to Behavior Driving Development with Java and MongoDB

Tue, 27 Jan 2026 16:35:53 +0000

When we face software development, the biggest mistake is about delivering what the client wants. It sounds like a cliché, but after decades, we are still facing this problem. One good way to solve it is to start the test focusing on what the business needs.

Behavior-driven development (BDD) is a software development methodology where the focus is on behavior and the domain terminology or ubiquitous language. It utilizes a shared, natural language to define and test software behaviors from the user’s perspective. BDD builds upon test-driven development (TDD) by focusing on scenarios that are relevant to the business. These scenarios are written as plain-language specifications that can be automated as tests, simultaneously serving as living documentation.

MongoDB and WiredTiger: A Journey Through the Storage Engine

Thu, 18 Dec 2025 20:26:28 +0000

Databases are the backbone of modern applications, and MongoDB stands out with its flexibility and scalability. Central to its functionality is the WiredTiger storage engine. WiredTiger, as MongoDB’s default engine, seamlessly merges document-level concurrency for high throughput, advanced compression techniques for optimized storage, and an in-memory architecture for rapid data access.{#e668}

With the addition of write-ahead logging for robust durability and the sophistication of MultiVersion Concurrency Control for snapshot-like data views, WiredTiger harmoniously orchestrates MongoDB’s data management.{#6fac}

Inside the Engine: Performance Relay of MongoDB 8.0

Tue, 16 Dec 2025 20:16:42 +0000

In environments where microseconds dictate competitive advantage, MongoDB 8.0 delivers a meticulously tuned execution pipeline that transforms raw network packets into sub-millisecond query responses at global scale.{#e2e4}

This reference traces a single trade query through every internal boundary network ingress, scheduling, security, parsing, planning, execution, storage‐engine internals, indexing, replication, sharding, change streams, time‐series buckets, backup, and monitoring illustrating how MongoDB 8.0’s per-CPU allocators, active-work profiling, SIMD-vectorized execution, adaptive bucketization, compact resume tokens, and refined journaling coalesce into a seamless, predictable performance engine.{#e2e4}

Building Java Microservices with the Repository Pattern

Thu, 11 Dec 2025 23:19:10 +0000

What you’ll learn

How the MongoDB Spring repository can be used to abstract MongoDB operations
Ensuring data access is separate from core application logic
Why you should avoid save() and saveAll() functions in Spring
Why schema and index design still matters in this case

The repository pattern is a design method that allows for abstraction between business logic and the data of an application. This allows for retrieving and saving/updating objects without exposing the technical details of how that data is stored in the main application. In this blog, we will use Spring Boot with MongoDB in order to create a repository pattern-based application.

Spring Boot 4 - OpenTelemetry Guide

Wed, 10 Dec 2025 09:09:58 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. In this second article, I will dive deep into integration of Observability framework i.e., OpenTelemetry with SpringBoot.

As an architect and developer, when I engage in system design—whether it involves monolithic architecture, microservices, or contemporary cloud-native applications—I have made the integration of observability patterns utilizing open-telemetry tools a standard practice. Through observability, we can monitor application behavior via metrics, logs, and traces that we trigger

Optimizing MongoDB Queries in Java Applications

Tue, 09 Dec 2025 17:45:09 +0000

Modern Java applications often struggle with performance bottlenecks that have little to do with the JVM itself. In most cases, the culprit lies deeper in how the application interacts with its database. Slow queries, missing indexes, or inefficient access patterns can quietly degrade user experience, increase latency, and inflate infrastructure costs. MongoDB, known for its flexibility and document-oriented design, can deliver remarkable performance when used correctly. However, that performance can quickly diminish when queries and indexes are not aligned with real-world access patterns.

Building Systems That Know Why They Exist ~ When Data, Logic, and Intent Finally Align

Thu, 04 Dec 2025 19:06:35 +0000

Every software system begins with intent. A human decision. A statement of what should exist, how it should behave, and why it matters. But somewhere along the way, that intent dies. It’s decomposed into documentation, user stories, and scattered logic. It becomes a shadow of itself fragmented across layers of code, processes, and people who no longer remember what it was meant to achieve.{#7cd1}

We’ve automated infrastructure. We’ve scripted configurations. We’ve even made AI write code for us. But we’ve never automated understanding . Our systems execute brilliantly yet comprehend nothing. They operate without memory of purpose. They run, but they do not know why.{#657d}

Atlas Searching with the Java Driver

Tue, 02 Dec 2025 17:28:43 +0000

Dear fellow developer, welcome!

Atlas Search is a full-text search engine embedded in MongoDB Atlas that gives you a seamless, scalable experience for building relevance-based app features. Built on Apache Lucene, Atlas Search eliminates the need to run a separate search system alongside your database. The gateway to Atlas Search is the $search aggregation pipeline stage.

The $search stage, as one of the newest members of the MongoDB aggregation pipeline family, has gotten native, convenient support added to various language drivers. Driver support helps developers build concise and readable code. This article delves into using the Atlas Search support built into the MongoDB Java driver, where we’ll see how to use the driver, how to handle `$search` features that don’t yet have native driver convenience methods or have been released after the driver was released, and a glimpse into Atlas Search relevancy scoring. Let’s get started!

Navigating the Nuances of GraphRAG vs. RAG

Thu, 20 Nov 2025 21:28:52 +0000

While large language models (LLMs) hold immense promise for building AI applications and agentic systems, ensuring they generate reliable and trustworthy outputs remains a persistent challenge. Effective data management—particularly how data is stored, retrieved, and accessed—is crucial to overcoming this issue. Retrieval-augmented generation (RAG) has emerged as a widely adopted strategy, grounding LLMs in external knowledge beyond their original training data.

The standard, or baseline, implementation of RAG typically relies on a vector-based approach. While effective for retrieving contextually relevant documents and references, vector-based RAG faces limitations in other situations, particularly when applications require robust reasoning capabilities and the ability to understand complex relationships between diverse concepts spread across large knowledge bases. This can lead to outputs that disappoint or even mislead end-users.

Service Layer Pattern in Java With Spring Boot

Tue, 18 Nov 2025 14:40:26 +0000

In modern software design, it is important to develop code that is clean and maintainable. One way developers do this is using the Service Layer pattern.

What you’ll learn

In this article, you’ll learn:

What the Service Layer pattern is and why it matters.
How it fits with the MVC architecture.
How to implement it in a real Spring Boot application.
How to add MongoDB with minimal code.
Best practices and common mistakes to avoid.

What is the Service Layer pattern?

The Service Layer pattern is an architectural pattern that defines an application’s boundary with a layer of services that establishes a set of available operations and coordinates the application’s response in each operation.

Beyond Keywords: Hybrid Search With Atlas and Vector Search (Part 3)

Thu, 13 Nov 2025 13:56:23 +0000

Bringing together semantic vectors and exact keyword matching with $rankFusion

If you’ve been following along this series, you already know we started by giving our movie search app the ability to understand meaning—not just keywords—using semantic search, as discussed in Part 1: Implementing Semantic Search in Java With Spring Data . Then, we made it even smarter by adding filters and optimizing performance with embedding strategies in Part 2: Optimizing Vector Search With Filters and Caching .

The Cost of Not Knowing MongoDB - Part 3: (appV6R0 to appV6R4)

Tue, 11 Nov 2025 19:31:10 +0000

Welcome to the third and final part of the series “The Cost of Not Knowing MongoDB.” Building upon the foundational optimizations explored in Part 1 and Part 2 , this article delves into advanced MongoDB design patterns that can dramatically transform application performance.

In Part 1 , we improved application performance by concatenating fields, changing data types, and shortening field names. In Part 2 , we implemented the Bucket Pattern and Computed Pattern and optimized the aggregation pipeline to achieve even better performance.

Modeling Relationships With Hibernate ORM and MongoDB

Tue, 04 Nov 2025 17:08:49 +0000

In theprevious article —Getting Started With Hibernate ORM and MongoDB—we learned how to configure Hibernate to work with MongoDB, create an entity, and perform basic CRUD operations using the familiar Hibernate API.

If you haven’t read that first part yet, I recommend starting there before continuing. It covers the project setup, dependencies, and the fundamentals that we’ll build upon here.

In this second part, we’ll extend our application to model relationships between entities—introducing a Review entity and linking it to our existing Book class. This will allow us to explore more advanced capabilities of the MongoDB Hibernate integration, including:

Getting Started With Hibernate ORM and MongoDB

Tue, 04 Nov 2025 17:06:26 +0000

For years, Hibernate ORM has been one of the most popular frameworks in the Java ecosystem. It was built to simplify data persistence by letting developers work with Java objects instead of SQL statements, a technique known as object-relational mapping (ORM).

Traditionally, Hibernate ORM has been tightly associated with relational databases like PostgreSQL, MySQL, and Oracle. It manages connections, transactions, and entity state behind the scenes, and even provides Hibernate Query Language (HQL) so you can query your data using Java entity names rather than table names.

The Pitfall of Increasing Read Capacity by Reading From Secondary Nodes in a MongoDB Replica Set

Thu, 30 Oct 2025 15:23:31 +0000

The scenario

Imagine we are responsible for managing the MongoDB cluster that supports our country’s national financial payment system, similar toPix in Brazil. Our application was designed to be read-heavy, with one write operation for every 20 read operations.

WithBlack Friday approaching, a critical period for our national financial payment system, we have been entrusted with the crucial task of creating a scaling plan for our cluster to handle the increased demand during this shopping spree. Given that our system is read-heavy, we are exploring ways to enhance the read performance and capacity of our cluster.

How MongoDB Decides What to Forget?

Tue, 28 Oct 2025 14:00:39 +0000

Inside MongoDB’s storage engine, WiredTiger , nothing happens by accident.{#4cf7}

Every page in memory exists under policy — governed, measured, and continuously evaluated against the limits of RAM, I/O bandwidth, and checkpoint cadence. Eviction is not cleanup. It’s runtime arbitration between volatility and durability.{#ba51}

When the process starts, WiredTiger allocates a fixed memory region known as the cache arena typically 50% of physical RAM. Within that space live B-tree pages : internal nodes, leaf nodes, and history-store entries. Each page carries operational metadata: dirty, clean, hazard-protected, in-use, last_access_time, and generation . This metadata feeds into a per-page score, which informs the eviction subsystem’s next decision.{#61cb}

Beyond Keywords: Optimizing Vector Search with Filters and Caching (Part 2)

Thu, 23 Oct 2025 15:44:38 +0000

Enhancing precision with pre-filters and reducing costs with embedding caching

Welcome back! If you landed here without reading Part 1: Beyond Keywords: Implementing Semantic Search in Java With Spring Data , I recommend going back and checking it first so the steps in this article make more sense in sequence.

This is the second part of a three-part series where we’re building a movie search application. So far, our app supports semantic search using vector queries with Spring Data and Voyage AI. In this article, we’ll take things further:

The Cost of Not Knowing MongoDB - Part 2

Tue, 21 Oct 2025 14:26:51 +0000

This is the second part of the series “The Cost of Not Knowing MongoDB,” where we go through many ways we can model our MongoDB schemas for the same application and have different performances. In the first part of the series, we concatenated fields, changed data types, and short-handed field names to improve the application performance. In this second part, as discussed in the issues and improvement of appV4 , the performance gains will be achieved by analyzing the application behavior and how it stores and reads its data, leading us to the use of the Bucket Pattern and the Computed Pattern .

Beyond Keywords: Implementing Semantic Search in Java With Spring Data (Part 1)

Thu, 16 Oct 2025 13:39:59 +0000

Building a semantic movie search app with embeddings and vector queries

Have you ever tried to search for something such as a product, a song, or a movie but couldn’t quite remember its exact name? Maybe you recall only a clue—a desert pyramid, a short melody, or “that ship that hit an iceberg.” Keyword search struggles with that. Vector search doesn’t: It lets you search by meaning.

It works by turning text into embeddings, vectors (arrays of numbers) that capture semantic similarity, so results are ranked by what they mean, not just what they say.

The Cost of Not Knowing MongoDB (Part 1)

Tue, 14 Oct 2025 13:43:42 +0000

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

To show these possible gains, a dummy application will be presented, and many possible implementations of it using MongoDB will be developed and load-tested. There will be implementations for all levels of MongoDB knowledge: beginner, intermediate, senior, and mind-blowing (🤯) .

Keywords Meet Vectors: Hybrid Search on MongoDB

Thu, 09 Oct 2025 14:49:49 +0000

In the previous issues, I explained how to run a local MongoDB Atlas cluster using Atlas CLI , what vector search is, and how to use it . Now, let’s take a closer look at hybrid search.

Reading time: 4–5 min

What is hybrid search?

Hybrid search in MongoDB brings together two complementary search techniques:

Full text search (BM25 via Atlas Search )—optimized for exact keyword matches, powered by Lucene inside mongot. Perfect when users expect documents that literally contain their query terms.

Vector search (kNN via Atlas Vector Search )—optimized for semantic similarity. It uses dense embeddings from ML models to find conceptually related content, even when no keywords match.

On their own, each method has advantages and limitations. Text search misses context (“non-linear crime story” won’t return Memento). Pure semantic search may return results that are semantically aligned but sometimes not practically useful. Hybrid search combines the strengths of both, ensuring results are contextually relevant and precise.

Working with Geo Location Data in MongoDB

Tue, 07 Oct 2025 14:01:53 +0000

MongoDB makes it really easy to work with location data (sometimes called Geo Data) by simplifying how to store this type of data and streamlining how you query for it so you can easily create “find nearby” queries, or plot your location data with ease!

Let’s start with the basics: modeling your data, indexing it properly, running geo queries, and then displaying results on a map.

Model Your Data with GeoJSON

Agents Meet Databases: The Future of Agentic Architectures

Thu, 02 Oct 2025 15:01:49 +0000

With 2025 hailed as “the year of agents” by NVIDIA CEO Jensen Huang and OpenAI CPO Kevin Weil , AI agents are increasingly of interest to organizations across industries. These autonomous systems will often need to interact with databases, where much of the world’s valuable data resides. According to IDC’s Data Age 2025 report , enterprises will manage nearly 60% of the world’s data by 2025, most of it organized in databases. As a result, databases will be central to agentic architectures, and the success of agent deployments will depend on how well they connect and interact with them.

Building an AI Semantic Movie Recommender with Vector Search

Tue, 30 Sep 2025 13:23:18 +0000

Last time, we created a vector search index in a local MongoDB Atlas cluster . Now, let’s put it to work with a real case: building an AI-powered movie recommender that suggests films similar to The Matrix–without any shared keywords.

🕒 Reading time: 3-4 min

🎯 The challenge

This demo will be entirely based on the pre-generated vector embeddings already stored in the sample_mflix dataset—no API calls and no new model runs. Everything will remain local. If you haven’t done it yet, learn how in this article 👉 Loading embeddings into MongoDB

Introduction to Data-Driven Testing with Java and MongoDB

Thu, 25 Sep 2025 13:53:57 +0000

As applications expand, the complexity of the rules they enforce also increases. In many systems, these rules are embedded within the data, primarily in database queries that filter, join, or compute based on real-world conditions. However, the tests for these queries are often shallow, repetitive, or, worse yet, completely absent. When there is an error in the database logic, the application may still compile successfully, but the business can suffer significant consequences.

Power your AI application with Vector Search

Tue, 23 Sep 2025 16:23:37 +0000

Most major database vendors, like MongoDB , are adding vector search capabilities to their products. It’s becoming a standard feature as demand for AI-powered applications grows.

🕒 Reading time: 3-4 min

🧠 What is vector search needed for?

MongoDB Vector Search enables semantic queries. For example, finding support tickets with similar meanings even if they use different words. It also powers hybrid search by combining exact keyword matches like “error 500” with semantically similar phrases like “server failure”. Another use case is personalization, such as recommending articles similar to those a user has read.

From Zero to Vector Hero - Locally! (Vector Search)

Thu, 18 Sep 2025 15:25:23 +0000

In the previous issue, I explained how to run a local MongoDB Atlas cluster using Atlas CLI - no cloud account required. If you missed it, read it here 👉 Run an Atlas cluster locally in minutes. Now let’s see how to use Vector Search in that local environment.

🕒 Reading time: 3-4 min

🧠 Explaining the Embedding Workflow

After launching your local MongoDB Atlas cluster and running the show dbs command in mongosh, you’ll see only the default system databases: admin, config, and local. These are used internally by MongoDB and contain no user data or vector embeddings at this point.

Best Practices for Deploying MongoDB in Kubernetes

Tue, 16 Sep 2025 19:01:34 +0000

Kubernetes , also known as K8s, is an open-source system that simplifies the deployment, scaling, and management of containerized applications. You define your application’s desired state, such as the number of instances (pods ) or how they communicate, and Kubernetes works continuously to ensure that state is met. It excels at running stateless workloads, where pods can be replaced at any time without impacting application state or user data. Think of web servers or REST APIs: If a pod crashes, Kubernetes simply spins up a replacement and everything continues as expected.

MongoDB Schemas in Java

Thu, 11 Sep 2025 13:15:02 +0000

If (like me!) you prefer to read code rather than a long and boring article, jump straight to the example! TLDR; here’s the code .

You can clone and run the tests like this:

git clone https://github.com/luketn/mongodb-schemas-in-java 
cd mongodb-schemas-in-java 
mvn test

And if you want to play with the example API visually (like I do!) and you have a local Mongo or an Atlas Cluster with the Weather Sample data, run:

Building REST APIs in Java with Spring Boot

Tue, 09 Sep 2025 14:51:10 +0000

REST has become the default choice for building web services, and for good reason. It’s straightforward to implement, easy for clients to consume, and built directly on top of the same principles of the web itself.

HTTP already gives us well-defined methods (GET, POST, PUT, DELETE), built-in caching, redirect support, secure transport via TLS, and widespread tooling support across platforms. REST doesn’t reinvent the web—it uses it.

REST is not a protocol or a rigid standard. It’s a lightweight architectural approach that encourages scalable, evolvable, and interoperable services. Its creator, Roy Fielding, helped define many of the specs that underpin the web today.

MongoDB Aggregations: Organizing Recipes by Meal Type with $group

Thu, 04 Sep 2025 05:31:22 +0000

In this series, we’re exploring different MongoDB aggregation operators by applying them to a recipe collection. I hope you’ll follow along with each post!

MongoDB Aggregations Series

MongoDB Aggregations: Finding Cooking Times with $min and $max
MongoDB Aggregations: Organizing Recipes by Meal Type with $group

As part of this series, we are imagining you’re building a recipe website. For this post, we are adding some new features to our site, including allowing users to browse recipes by meal type—breakfast, lunch, dinner, etc.

Copy of Queryable Encryption with Spring Data MongoDB: How to Query Encrypted Fields

Tue, 02 Sep 2025 19:00:24 +0000

Information is one of the most valuable assets in computing and keeping it protected is even more critical. When we talk about data protection, it’s not just about preventing breaches or leaks; it’s also about complying with privacy regulations and protecting user data.

MongoDB provides strong encryption capabilities, including in transit, at rest, and in use. The Queryable Encryption feature falls into the in use category. It allows data to be encrypted on the client side, so that even with access to the database and its credentials, no one can read the protected fields without the proper encryption key. At the same time, it supports querying over encrypted fields, making it possible to filter, match, or retrieve data without compromising confidentiality.

What happens when a Primary fails in a MongoDB replica set?

Tue, 26 Aug 2025 15:14:03 +0000

In distributed systems, high availability is not a luxury—it’s a necessity. And one of the very important parts of that is automatic failovers. What are automatic failovers and how do they work? Let’s see today!

These concepts are actually similar in every database, but as MongoDB is natively built for replica-sets, we will talk about that here, whereas other DB systems need 3rd-party or managed systems to implement the same.

Managing MongoDB Database Changes Using Liquibase Pro

Wed, 20 Aug 2025 14:21:51 +0000

This article explores how Liquibase and MongoDB can be integrated with Git actions to implement source control for database changes.

What is Liquibase?

Liquibase is an open-source tool designed to manage version control for database schema changes. It allows developers to simplify and automate the process of applying database updates across various database platforms.

By using database-independent formats like XML, YAML, or JSON, Liquibase enables teams to define changes in a consistent and structured way. In a Java project, these updates are organized into files containing changesets, which outline the specific instructions needed to modify or refactor the database schema.

Domain-Driven Design in Java: A Practical Guide

Fri, 15 Aug 2025 09:30:31 +0000

While waiting for your flight in an airport, have you ever wondered how much behind-the-scenes planning it takes to keep an airport running smoothly? Every day, thousands of flights take off and land, passengers rush through terminals, and staff work tirelessly to make sure everything unfolds without a hitch. What looks like chaos on the surface is actually the result of a highly coordinated system—a kind of “brain” that’s always working in the background to manage logistics, adapt to surprises, and keep the airport humming along.

Enforcing Governance in MongoDB Atlas with Resource Policies

Wed, 13 Aug 2025 12:52:05 +0000

The growing adoption of MongoDB Atlas as a managed database platform increasingly demands mechanisms that align security, compliance, and governance. In April 2025, MongoDB introduced a critical feature for this purpose: Resource Policies .

This article presents the concept and capabilities of Resource Policies, highlights their importance in enterprise environments, and demonstrates how to use them effectively via Terraform — ensuring that essential configurations rely not only on best practices but also on enforceable and auditable constraints.

Run an Atlas cluster locally in minutes

Tue, 05 Aug 2025 07:33:47 +0000

You no longer need a cloud account to try MongoDB Atlas features. Spin up a fully compatible local cluster in seconds, with no login, no credit card, and no friction.

🕒 Reading time: 2-3 min

🍃 What is the MongoDB Atlas Platform?

MongoDB Atlas is a fully managed, multi-cloud data platform provided by MongoDB Inc. It allows you to deploy and run MongoDB clusters on Amazon Web Services (AWS), Google Cloud Platform (GCP), and Microsoft Azure, with full support for replica sets (for high availability), sharding (for horizontal scalability), and multi-cloud deployments. Atlas handles infrastructure, backups, security, scaling, and monitoring out of the box. It also extends the core MongoDB server capabilities with a set of integrated features.

Why Mirroring Production in Dev Helps You Avoid Costly Mistakes

Mon, 28 Jul 2025 13:31:10 +0000

Many developers start building their applications with MongoDB using a free M0 cluster or a local environment. While this is common and convenient, it can lead to issues that could easily be avoided by using a more robust setup, such as a development cluster that closely mirrors production. Problems like inefficient queries, missing indexes, or even costly mistakes often go unnoticed in limited environments like M0 or local setups.

In this article, we’ll explore why your development environment should closely reflect your production environment, and how using an M10+ cluster with tools like Query Profiler and Performance Advisor can help you catch performance issues early and build with confidence.

MongoDB ACID Transactions With Java

Wed, 23 Jul 2025 14:39:45 +0000

A database is constantly under pressure. Real-time applications, exponential growth of data, and multiple operations may hit the system at once. Without coordination, this can lead to race conditions, conflicts, and ultimately, the dreaded inconsistent data! To address this, MongoDB supports transactions .

Transactions let us group multiple operations together so they either all succeed or none take effect, a concept known as atomicity . MongoDB’s document model already provides atomicity at the single-document level, which covers a lot of use cases. But when you need atomicity across multiple documents or collections, transactions are the answer.

How to Make a RAG Application With LangChain4j

Thu, 17 Jul 2025 20:42:12 +0000

Retrieval-augmented generation, or RAG, introduces some serious capabilities to your large language models (LLMs). These applications can answer questions about your specific corpus of knowledge, while leveraging all the nuance and sophistication of a traditional LLM.

This tutorial will take you through the ins and outs of creating a Q&A chatbot using RAG. The application will:

Retrieve data from a MongoDB Atlas database.
Embed and store documents as vector embeddings.
Use LangChain4J to query the database and augment LLM prompts with the retrieved data.
Enable secure, scalable, and efficient AI-powered applications.

If you want to see the completed application, it is available in the GitHub repository .

The Great Data Reimagination: From Static to Agile in the AI Era

Tue, 15 Jul 2025 13:44:06 +0000

We’re in the middle of a fundamental change in how enterprise software works. In the next decade, your database will become your AI.

Just five years ago, choosing the right kind of database to support their applications presented complexity for many developers: relational or NoSQL? Structured or unstructured? Flexible or predictable? They didn’t know exactly what their data would look like in six months, but what they did know was that it was certain to change. This led many to make a rebel’s choice to reject the rigid structure of SQL databases for something more fluid and adaptable.

Building a Spring Boot CRUD Application Using MongoDB’s Relational Migrator

Tue, 08 Jul 2025 19:05:43 +0000

Imagine this: You’re working with a relational database that’s served you well for years, but now your applications demand flexibility, scalability, and faster development cycles. Transitioning from structured tables to MongoDB’s dynamic, schema-less JSON documents might be daunting. That’s where MongoDB’s Relational Migrator becomes your secret weapon.

The Relational Migrator tool built by MongoDB no longer only supports migrating data from relational databases to MongoDB. Rather, it supports features like code generation and also a query converter that converts a relational database, such as a Postgres query, or queries from views and stored procedures, into a MongoDB query.

Data Modeling for Java Developers: Structuring With PostgreSQL and MongoDB

Thu, 03 Jul 2025 21:02:16 +0000

Application and system designs have always been considered the most essential step in application development. All the later steps and technologies to be used depend on how the system has been designed. If you are a Java developer, choosing the right approach can mean distinguishing between a rigid, complex schema and a nimble, scalable solution. If you are a Java developer who works with PostgreSQL or other relational databases, you understand the pain of representing the many-to-many relationships between the tables.

Java Virtual Threads in Action: Optimizing MongoDB Operation

Tue, 01 Jul 2025 08:12:24 +0000

Virtual threads have become one of the most popular resources in Java and are trending inside the language. Indeed, this resource introduced a cheap way to create threads inside the JVM. In this tutorial, we will explain how to use it with MongoDB.

You can find all the code presented in this tutorial in the GitHub repository :

git clone [email protected]:soujava/mongodb-virtual-threads.git

Prerequisites

For this tutorial, you’ll need:

How to Identify the Underlying Causes of Connection Timeout Errors for MongoDB With Java

Thu, 26 Jun 2025 12:13:44 +0000

Java developers and MongoDB are like Aladdin and the Genie from Arabian Nights. Developers rub the lamp with their wildest NoSQL wishes, and MongoDB swoops in, granting Spring Boot microservices and REST APIs the magic they need to soar. But every so often, a Jafar-like menace swoops in, forcing our Aladdin (Java devs) to wrestle with sleepless nights. One such villainous foe is the connection timeout, locking APIs in a cave of wonders with no escape, leaving developers yearning for a magic carpet fix.

Clean and Modular Java: A Hexagonal Architecture Approach

Tue, 24 Jun 2025 08:03:50 +0000

One of the discussions that always leaves me with both doubts and excitement is the one about system architecture. Ever since I started diving deeper into programming, I’ve encountered questions like how to separate packages and modules: is it really worth creating so many divisions? I must admit, it’s often complicated to understand or make decisions without being fully sure that I’m doing the right thing.

Right from the start, I want to make it clear that this content will definitely spark a lot of discussion around best practices and whether what I’m doing is correct — but, above all, I guarantee it will be fun!

Multi-cloud Strategies With MongoDB Atlas

Thu, 19 Jun 2025 11:49:29 +0000

In the technological world, the cloud has become more prevalent. It brings many benefits, including flexibility, scalability, faster innovation, and collaboration. Plus, when it comes to data storage and access with databases, it allows data to be located closer to the user for lower latency and thus, faster performance.

Most people have heard of the big cloud providers, such as Azure from Microsoft, Google Cloud, and Amazon Web Services (AWS). But when it comes to a business selecting a cloud provider, how do you choose?

Your Complete Guide to Diagnose Slow Queries in MongoDB

Tue, 17 Jun 2025 04:06:04 +0000

MongoDB is built to be fast. The real win comes from knowing how to keep it that way, even as your app grows and your data gets more complex.

This tutorial is for those developers and engineers who want to understand how MongoDB behaves when queries or writes slow down. We’re not here to hand you indexing tips or premature advice about schema design. We’re here to walk through the actual tools MongoDB gives you to observe, measure, and reason about query performance, before you start optimizing anything.

Java Concurrency Best Practices for MongoDB

Thu, 12 Jun 2025 15:30:29 +0000

In a multi-threaded, distributed environment like MongoDB, when clients execute queries concurrently, operations interleave with one another if they are not isolated, whether those operations involve single-document or multi-document operations.

For instance, Client C1’s read operation might observe the effects of a write performed by Client C2, even if that write has not yet been made durable. When at least one of the concurrent operations is a write and isolation is not enforced, this can lead to undesirable outcomes, such as:

MongoDB Aggregation Framework: A Beginner’s Guide

Thu, 05 Jun 2025 06:20:02 +0000

Finding exactly the data we need isn’t always a simple task.

You’ve probably faced situations where you needed to filter information, group it, and even perform calculations to produce a final result.

And often, delivering this processed data to the client is essential for the application’s success. MongoDB offers two main ways to fetch data:

Testing MongoDB Atlas Search Java Apps Using TestContainers

Thu, 29 May 2025 18:07:27 +0000

This will be an exploration of testing MongoDB Atlas Search solutions written in Java using TestContainers and JUnit5. We’ll start simple and build up to more advanced uses which load seed data and provide an environment for consistent and easy to maintain tests.

TLDR; if (like me!) you want to get straight to the code rather than reading lots of tedious words:

git clone https://github.com/luketn/mongodb-atlas-local-testcontainers.git
cd mongodb-atlas-local-testcontainers
mvn test

What is MongoDB Atlas Search, anyway?

MongoDB Atlas Search is an extension to the built-in indexing capabilities that are part of MongoDB itself, using the awesome open source indexing and query library Lucene . MongoDB has built a wrapper around Lucene called mongot .

Understanding BSON: A Beginner’s Guide to MongoDB’s Data Format

Thu, 22 May 2025 08:05:06 +0000

When working with MongoDB, it’s easy to think you’re dealing with JSON. After all, the queries, documents, and API responses all look like JSON. But MongoDB is not storing JSON. It’s storing BSON—a binary format designed for efficient storage and fast traversal.

BSON (Binary JSON) is more than just a binary version of JSON. It introduces additional data types like ObjectId, Decimal128, and Timestamp, allowing MongoDB to handle more complex data structures and ensure data integrity. While we might rarely interact with raw BSON directly, understanding how MongoDB stores and processes BSON documents can help us write more efficient queries, handle data conversions properly, and debug unexpected behavior.

Building a Real-Time AI Fraud Detection System with Spring Kafka and MongoDB

Wed, 14 May 2025 14:30:08 +0000

In this tutorial, we’ll build a real-time fraud detection system using MongoDB Atlas Vector Search, Apache Kafka, and AI-generated embeddings. We’ll demonstrate how MongoDB Atlas Vector Search can be used to detect anomalies in a stream of financial transactions by analyzing a user’s transaction history and identifying suspicious behavior based on LLM-generated embeddings.

Our solution will monitor MongoDB Change Streams using the Java synchronous driver, triggering vector searches on each new transaction to detect potential fraud. While this approach works well for our demo, and for many use cases, we’ll also discuss its limitations. Throughout the tutorial, I’ll cover alternative strategies to optimize performance, whether you need higher transaction throughput, faster fraud detection, or a more scalable architecture.