Hubert Nguyen

Sr. Developer Advocate

Welcome to this MongoDB Stream Processing tutorial! In this guide, we will quickly set up a coding workflow and have you write and run your first Stream Processing Instance in no time. In a very short time, we'll learn how to create a new stream processor instance, conveniently code and execute stream processors from Visual Studio Code, and simply aggregate stream data, thus opening the door to a whole new field of the MongoDB Atlas modern database.

What we'll cover
----------------

- Prerequisites
- Setup
- Create a stream processor instance
- Set up Visual Studio Code
- The anatomy of a stream processor
- Let's execute a stream processor!
- Hard-coded data in $source declaration
- Simplest stream processor
- Stream processing aggregation
- Add time stamps to the data

Prerequisites
-------------

-   Basic knowledge of the [MongoDB Aggregation Pipeline](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) and [Query API](https://www.mongodb.com/docs/manual/query-api/)

-   Ideally, read the [official high-level Atlas Stream Processing overview](https://www.mongodb.com/docs/atlas/atlas-sp/overview/) 

-   A live MongoDB Atlas cluster that supports stream processing

-   Visual Studio Code + [MongoDB for VS Code extension](https://www.mongodb.com/products/tools/vs-code)

## Setup
### Create an Atlas stream processing instance

We need to have an Atlas Stream Processing Instance (SPI) ready. Follow the steps in the tutorial [Get Started with Atlas Stream Processing: Creating Your First Stream Processor](https://www.mongodb.com/developer/products/atlas/create-first-stream-processor/)  until we have our connection string and username/password, then come back here.

Don't forget to [add your IP address to the Atlas Network Access](https://www.mongodb.com/docs/atlas/security/ip-access-list/#std-label-access-list) to allow the client to access the instance.

### Set up Visual Studio Code for MongoDB Atlas Stream Processing

Thanks to the MongoDB for VS Code extension, we can rapidly develop stream processing (SP) aggregation pipelines and run them directly from inside a VS Code MongoDB playground. This provides a much better developer experience. In the rest of this article, we'll be using VS Code.

Such a playground is a NodeJS environment where we can execute JS code interacting with a live stream processor on MongoDB Atlas. To get started, install [VS Code](https://code.visualstudio.com/) and the [MongoDB for VS Code extension](https://www.mongodb.com/products/tools/vs-code).

Below is a great tutorial about installing the extension. It also lists some shell commands we'll need later.

-   **Tutorial**: [Introducing Atlas Stream Processing Support Within the MongoDB for VS Code Extension](https://www.mongodb.com/developer/products/atlas/introducing-atlas-stream-processing-support-mongodb-vs-code-extension/)

-   **Goal**: If everything works, we should see our live SP connection in the MongoDB Extension tab.

![connecting an Atlas Stream Processor in Visual Studio Code][1]

The anatomy of a stream processor 
----------------------------------

Within a stream processing instance (=cluster), it is possible to create and run multiple stream processors (=stream processing pipelines) simultaneously.

A single stream processor (SP) is very similar to a [MongoDB aggregation pipeline](https://www.mongodb.com/basics/aggregation-pipeline). It is described by an array of processing stages. However, there are some differences. The most basic SP can be created using only its data source (we'll have executable examples next).

```
// our array of stages
// source is defined earlier
sp_aggregation_pipeline = [source]
sp.createStreamProcessor("SP_NAME", sp_aggregation_pipeline, <OPTIONS>)
```

A more realistic stream processor would contain at least one aggregation stage, and there can be a large number of stages performing various operations to the incoming data stream. There's a generous limit of 16MB for the total processor size.

```
sp_aggregation_pipeline = [source, stage_1, stage_2...]
sp.createStreamProcessor("SP_NAME", sp_aggregation_pipeline, <OPTIONS>)
```

To increase the development loop velocity, there's an sp.process() function which starts an ephemeral stream processor that won't persist in your stream processing instance.

Let's execute a stream processor!
---------------------------------

Let's create basic stream processors and build our way up. First, we need to have some data! Atlas Stream Processing supports [several data sources](https://www.mongodb.com/docs/atlas/atlas-sp/sp-agg-source/) for incoming streaming events. These sources include:

-   Hard-coded data declaration in $source.
-   Kafka streams.
-   MongoDB Atlas databases.

### Hard-coded data in $source declaration

For quick testing or self-contained examples, having a small set of hard-coded data is a very convenient way to produce events. We can declare an array of events. Here's an extremely simple example, and note that we'll make some tweaks later to cover different use cases.

### Simplest stream processor

In VS Code, we run an ephemeral stream processor with sp.process(). This way, we don't have to use sp.createStreamProcessor() and sp.<SPNAME>.drop() constantly as we would for SPs meant to be saved permanently in the instance.

```
src_hard_coded  = {
  $source: {
    // our hard-coded dataset
    documents: [
      {'id':  'entity_1', 'value':  1},
      {'id':  'entity_1', 'value':  3},
      {'id':  'entity_2', 'value':  7},
      {'id':  'entity_1', 'value':  4},
      {'id':  'entity_2', 'value':  1}
     ]
    }
  }
sp.process( [src_hard_coded] );
```

Upon running this playground, we should see data coming out in the VS Code "OUTPUT" tab (CTRL+SHIFT+U to make it appear)

**Note**: It can take a few seconds for the SP to be uploaded and executed, so don't expect an immediate output.

```
{
  id: 'entity_1',
  value: 1,
  _ts: 2024-02-14T18:52:33.704Z,
  _stream_meta: { timestamp: 2024-02-14T18:52:33.704Z }
}
{
  id: 'entity_1',
  value: 3,
  _ts: 2024-02-14T18:52:33.704Z,
  _stream_meta: { timestamp: 2024-02-14T18:52:33.704Z }
}
...
```

This simple SP can be used to ensure that data is coming into the SP and there are no problems upstream with our source. Timestamps data was generated at ingestion time.

Stream processing aggregation
-----------------------------

Building on what we have, adding a simple aggregation pipeline to our SP is easy. Below, we're adding a $group stage to aggregate/accumulate incoming messages' "value" field into an array for the requested interval.

Note that the "w" stage (w stands for "Window") of the SP pipeline contains an aggregation pipeline inside. With Stream Processing, we have aggregation pipelines in the stream processing pipeline.

This stage features a [$tumblingWindow](https://www.mongodb.com/docs/atlas/atlas-sp/overview/#tumbling-windows) which defines the time length the aggregation will be running against. Remember that streams are supposed to be continuous, so a window is similar to a buffer.

interval defines the time length of a window. Since the window is a continuous data stream, we can only aggregate on a slice at a time.

idleTimeout defines how long the $source can remain idle before closing the window. This is useful if the stream is not sustained.

```
src_hard_coded  = {
  $source: {
    // our hard-coded dataset
    documents: [
      {'id':  'entity_1', 'value':  1},
      {'id':  'entity_1', 'value':  3},
      {'id':  'entity_2', 'value':  7},
      {'id':  'entity_1', 'value':  4},
      {'id':  'entity_2', 'value':  1}
     ]
    }
  }

w  = {
  $tumblingWindow: {
    // This is the slice of time we want to look at every iteration
    interval: {size:  NumberInt(2), unit:  "second"},
    // If no additional data is coming in, idleTimeout defines when the window is forced to close
    idleTimeout : {size:  NumberInt(2), unit:  "second"},
    "pipeline": [
      {
        '$group': {
            '_id':  '$id',
            'values': { '$push':  "$value" }
          }
        }
      ]
    }
  }
sp_pipeline = [src_hard_coded, w];
sp.process( sp_pipeline );
```

Let it run for a few seconds, and we should get an output similar to the following. $group will create one document per incoming "id" field and aggregate the relevant values into a new array field, "values."

```
{
  _id: 'entity_2',
  values: [ 7, 1 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-14T19:29:46.000Z,
    windowEndTimestamp: 2024-02-14T19:29:48.000Z
  }
}
{
  _id: 'entity_1',
  values: [ 1, 3, 4 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-14T19:29:46.000Z,
    windowEndTimestamp: 2024-02-14T19:29:48.000Z
  }
}
```
Depending on the $tumblingWindow settings, the aggregation will output several documents that match the timestamps. For example, these settings...

```
...
$tumblingWindow: {
    interval: {size:  NumberInt(10), unit:  "second"},
    idleTimeout : {size:  NumberInt(10), unit:  "second"},
...
``` 

...will yield the following aggregation output:
```
{
  _id: 'entity_1',
  values: [ 1 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-13T14:51:30.000Z,
    windowEndTimestamp: 2024-02-13T14:51:40.000Z
  }
}
{
  _id: 'entity_1',
  values: [ 3, 4 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-13T14:51:40.000Z,
    windowEndTimestamp: 2024-02-13T14:51:50.000Z
  }
}
{
  _id: 'entity_2',
  values: [ 7, 1 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-13T14:51:40.000Z,
    windowEndTimestamp: 2024-02-13T14:51:50.000Z
  }
}
```

See how the windowStartTimestamp and windowEndTimestamp fields show the 10-second intervals as requested (14:51:30 to 14:51:40 etc.).

### Additional learning resources: building aggregations

Atlas Stream Processing uses the MongoDB Query API. You can learn more about the MongoDB Query API with the [official Query API documentation](https://www.mongodb.com/docs/manual/query-api/), [free] [interactive course](https://learn.mongodb.com/courses/mongodb-aggregation), and [tutorial](https://www.mongodb.com/developer/products/atlas/getting-started-atlas-mongodb-query-language-mql/).

Important: Stream Processing aggregation pipelines do not support all database aggregation operations and have additional operators specific to streaming, like $tumblingWindow. Check the [official Stream Processing aggregation documentation](https://www.mongodb.com/docs/atlas/atlas-sp/stream-aggregation/).

### Add timestamps to the data

Even when we hard-code data, there's an opportunity to provide a timestamp in case we want to perform $sort operations and better mimic a real use case. This would be the equivalent of an event-time timestamp embedded in the message.

There are many other types of timestamps if we use a live Kafka stream (producer-assigned, server-side, ingestion-time, and more). Add a timestamp to our messages and use the document's  "timeField" property to make it the authoritative stream timestamp.

```
src_hard_coded  = {
  $source: {
    // define our event "timestamp_gps" as the _ts
    timeField: { '$dateFromString': { dateString:  '$timestamp_msg' } },
    // our hard-coded dataset
    documents: [
      {'id':  'entity_1', 'value':  1, 'timestamp_msg':  '2024-02-13T14:51:39.402336'},
      {'id':  'entity_1', 'value':  3, 'timestamp_msg':  '2024-02-13T14:51:41.402674'},
      {'id':  'entity_2', 'value':  7, 'timestamp_msg':  '2024-02-13T14:51:43.402933'},
      {'id':  'entity_1', 'value':  4, 'timestamp_msg':  '2024-02-13T14:51:45.403352'},
      {'id':  'entity_2', 'value':  1, 'timestamp_msg':  '2024-02-13T14:51:47.403752'}
     ]
    }
  }
```

At this point, we have everything we need to test new pipelines and create proofs of concept in a convenient and self-contained form. In a subsequent article, we will demonstrate how to connect to various streaming sources.

## Tip and tricks

At the time of publishing, Atlas Stream Processing is in public preview and there are a number of [known Stream Processing limitations](https://www.mongodb.com/docs/atlas/atlas-sp/limitations/#std-label-atlas-sp-limitations) that you should be aware of, such as regional data center availability, connectivity with other Atlas projects, and user privileges.

When running an ephemeral stream processor via sp.process(), many errors (JSON serialization issue, late data, divide by zero, $validate errors) that might have gone to a dead letter queue (DLQ) are sent to the default output to help you debug.

For SPs created with sp.createStreamProcessor(), you'll have to configure your DLQ manually. Consult the documentation for this. On the ["Manage Stream Processor" documentation page](https://www.mongodb.com/docs/atlas/atlas-sp/manage-stream-processor/), search for "Define a DLQ."

After merging data into an Atlas database, it is possible to use existing pipeline aggregation building tools in the [Atlas GUI's builder](https://www.mongodb.com/docs/atlas/atlas-ui/agg-pipeline/) or [MongoDB Compass](https://www.mongodb.com/docs/compass/upcoming/aggregation-pipeline-builder/) to create and debug pipelines. Since these tools are meant for the core database API, remember that some operators are not supported by stream processors, and streaming features like windowing are not currently available.

## Conclusion

With that, you should have everything you need to get your first stream processor up and running. In a future post, we will dive deeper into connecting to different sources of data for your stream processors.

If you have any questions, [share them in our community forum](https://www.mongodb.com/community/forums/c/atlas/stream-processing/171), meet us during local [MongoDB User Groups (MUGs)](https://www.mongodb.com/community/forums/c/user-groups/11), or come check out one of our [MongoDB .local](https://www.mongodb.com/events/mongodb-local) events.

## References

-   [MongoDB Atlas Stream Processing Documentation](https://www.mongodb.com/docs/atlas/atlas-sp/overview/)

-   [Introducing Atlas Stream Processing - Simplifying the Path to Reactive, Responsive, Event-Driven Apps](https://www.mongodb.com/blog/post/introducing-atlas-stream-processing-simplifying-path-reactive-responsive-even-driven-apps)

-   [The Challenges and Opportunities of Processing Streaming Data](https://www.mongodb.com/blog/post/challenges-opportunities-processing-streaming-data)

- [Atlas Stream Processing is Now in Public Preview](https://www.mongodb.com/blog/post/atlas-stream-processing-now-in-public-preview) (Feb 13, 2024)


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt9fc619823204a23c/65fcd88eba94f0ad8e7d1460/atlas-stream-processor-connected-visual-studio-code.png

Learn to set up and run your first MongoDB Atlas stream processor. Discover how to create instances, code in Visual Studio Code, and aggregate stream data.

Introduction to Atlas Stream Processing Development

Pavel Duchovny

Lead Developer Advocate


The AI pillar has become a significant consideration in modern applications. The enterprise industry is very interested in modernizing and involving AI models in enterprise applications. However, using publicly available APIs and relying on public services will not suit all enterprises, especially if they require high-scale and secure data segregation.

Having said that, increasingly, more enterprises are moving to the cloud to build applications at scale in fast, competitive cycles, utilizing smart and robust deployment services. This is where the MongoDB Atlas modern database and the Anyscale AI compute platform come in.

[Anyscale](https://www.anyscale.com/) is a platform for running distributed applications using [Ray,](https://www.ray.io/) an open-source framework for building scalable applications. Integrating [MongoDB Atlas](https://mongodb.com/try) with Anyscale and [PyMongo](https://www.mongodb.com/docs/languages/python/pymongo-driver/current/), can help you efficiently manage and analyze large datasets by leveraging Ray's distributed computing capabilities while using MongoDB as the backend database.

Using Anyscale for fast and efficient LLM inference and MongoDB Atlas scalable vector indexing for contextual search, users can build and deploy super scalable, AI-based retrieval-augmented generation (RAG) flows and agentic systems.

In this tutorial, we will cover the following main aspects of creating a scalable RAG back end for your application:
- Deploy a scalable vector store using MongoDB Atlas.
- Deploy the required embedding model and LLM on Anyscale.
- Connect the vector store with your deployed service using PyMongo and Anyscale services.

## Deploy your Atlas cluster

If you have not created an Atlas cluster, follow our [guide](https://www.mongodb.com/docs/guides/atlas/cluster/).

Get the [MongoDB connection string](https://mongodb-developer.github.io/ai-agents-lab/docs/mongodb-atlas/get-connection-string) and allow access from relevant IP addresses. For this tutorial, you will use the `0.0.0.0/0` network access list. 

For production deployments, users can manage [VPCs and private networks](https://docs.anyscale.com/1.0.0/cloud-deployment/aws/manage-clouds) on the Anyscale platform and connect them securely via [VPC peering or cloud private endpoints to Atlas](https://www.mongodb.com/docs/atlas/setup-cluster-security/).

## Create a collection and Atlas vector index

Using the Data Explorer or a Compass connection, create the following collection to host our application context for the RAG process. Use database name `anyscale_db` and collection name `stories`. Once the collection is created, head to the Atlas Search tab (or the Index tab in Compass using the Atlas search toggle) and create the following [vector index](https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-type/):

**name : vector_index**

```json
{
  "fields": [
    {
      "type": "vector",
      "path": "embedding",
      "numDimensions": 1024,
      "similarity": "cosine"
    }
  ]
}
```
## Sign up for an Anyscale account

[Register for an account](https://console.anyscale.com/register/ha?utm_source=mongodb_devcenter&utm_content=blog&referrer_url=https://www.mongodb.com/developer/) and get free compute credits to try out the Anyscale platform.

### Deploy self-hosted models for the RAG service

Anyscale offers a [simple-to-follow template](https://console.anyscale.com/v2/template-preview/endpoints_v2) that you can launch from within the [Anyscale platform](https://console.anyscale.com) to optimally self-host the models for your RAG service leveraging ray-LLM. ray-LLM makes use of best-in-class optimizations from inference libraries like [vLLM](https://docs.vllm.ai/en/latest/) and offers an OpenAI-compatible API for our deployed models.

With Anyscale, you get the flexibility to choose the hardware and autoscaling configurations for the models so you can trade off cost and performance given your use case.

For the purposes of our guide, we will:
- Launch [this template](https://console.anyscale.com/v2/template-preview/endpoints_v2) to deploy the embedding model `thenlper/gth-large`.
- Launch [this template](https://console.anyscale.com/v2/template-preview/endpoints_v2) to deploy the LLM model `llama-2-70b`.

We will use the default values given they offer a good starting point for hardware and autoscaling configurations.

To read more about the template used, view the [Anyscale documentation page](https://docs.anyscale.com/examples/deploy-llms/).

Please note that some models require approval on the Hugging Face website.

Once you deploy the above models, you should have two working services with accessible API URL and bearer tokens:

Let's say that the embedding deployed service is on:
```
https://XXXXXXXXXXXX.anyscaleuserdata.com
```
Take note of the embedding bearer as it will be used as our API key for embedding related tasks.

The LLM is deployed to another endpoint:
```
https://YYYYYYYYYYYYY.anyscaleuserdata.com
```
Take note of the LLM bearer as it will be used as our API key for LLM-related tasks.

## Build the RAG service

### Create a workspace in the Anyscale platform

Create a workspace template to build our RAG service. We recommend you launch the [Intro to Services template](https://console.anyscale.com/v2/template-preview/service-intro) to get a running workspace that showcases how to deploy your first Anyscale service.

You can think of an Anyscale workspace as an IDE (Visual Studio) running against an elastically scalable compute cluster.
![Workspaces][1]

We will use this workspace to create all our services.

Let's start by specifying the dependencies and environment variables that our RAG service will require…
```shell
pip install pymongo openai fastapi 
```

…by clicking on the Dependencies tab as shown in the screenshot below:
![Dependencies][2]

You will need to place the API keys as environment variables in Workspace > YOUR NAME > Dependencies:

- Place the embedding bearer as an environment variable in the workspace: 
  - `EMBEDDING_API_KEY`
- Place the LLM bearer as an environment variable in our workspace: 
  - `LLM_API_KEY`
- Place your Atlas connection string (e.g., `mongodb+srv://<user>:<pass>@cluster0.abcd.mongodb.net/`):
  - `MONGODB_ATLAS_URI`

Remember to replace the values with your cluster connection string and your keys.

Now, you can use those services to build your RAG service to use private embedding endpoints and LLM. Those are compatible with the OpenAI client, and therefore, you can use the OpenAI client as part of our MongoDB RAG service as follows.

Create a new file named `main.py` in the root directory of the workspace.

```python
from typing import Any
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from pymongo import MongoClient
import os
import openai
from dotenv import load_dotenv
from ray import serve
import logging

# Initialize FastAPI
fastapi = FastAPI()

# Initialize logger
logger = logging.getLogger("ray.serve")

# Data model for the request
class QueryModel(BaseModel):
   query: str

@serve.deployment
@serve.ingress(fastapi)
class MongoDBRag:

   def __init__(self):
       # MongoDB connection
       client = MongoClient(os.getenv("MONGODB_ATLAS_URI"))
       db = client["anyscale_db"]
       self.collection = db["stories"]

       # AI Client initialization
       # LLM endpoint for text generation
       self.openai_llm = openai.OpenAI(
           base_url="https://YYYYYYYYYYYYY.anyscaleuserdata.com/v1",
           api_key=os.getenv('LLM_API_KEY')
       )

       # Embedding endpoint for vector embeddings
       self.openai_embedding = openai.OpenAI(
           base_url="https://XXXXXXXXXXXX.anyscaleuserdata.com/v1",
           api_key=os.getenv('EMBEDDING_API_KEY')
       )

   @fastapi.post("/rag_endpoint/")
   async def rag_endpoint(self, query: QueryModel) -> Any:
       try:
           # Generate embedding for the input query
           embedding = self.openai_embedding.embeddings.create(
               model="thenlper/gte-large",
               input=query.query,
           )

           # Perform vector search in MongoDB to find relevant context
           context = list(self.collection.aggregate([
               {"$vectorSearch": {
                   "queryVector": embedding.data[0].embedding,
                   "index": "vector_index",
                   "numCandidates": 3,
                   "path": "embedding",
                   "limit": 1
               }},
               {
                   "$project": {
                       "_id": 0,
                       "embedding": 0
                   }
               }
           ]))

           # Construct prompt with context and query
           prompt = f""" Based on the following context please answer and elaborate the user query.
           context: {context}

           query: {query.query}
           Answer: """

           # Generate response using LLM
           chat_completion = self.openai_llm.chat.completions.create(
               model="meta-llama/Llama-2-70b-chat-hf",
               messages=[
                   {"role": "system", "content": "You are a helpful QA assistant"},
                   {"role": "user", "content": prompt}
               ],
               temperature=0.7
           )

           answer = chat_completion.choices[0].message.content

           return answer

       except Exception as e:
           raise HTTPException(status_code=500, detail=str(e))

# Bind the deployment
my_app = MongoDBRag.bind()
```

This service utilizes [Ray Serve](https://docs.ray.io/en/latest/serve/index.html) integrated with [FastAPI](https://fastapi.tiangolo.com/) to connect [MongoDB Atlas](https://www.mongodb.com/lp/cloud/atlas) with the embedding model and the LLM services that we previously deployed.

With [Ray Serve](https://docs.ray.io/en/latest/serve/index.html), we get to define an automatically scalable deployment by decorating a class where:
- All state initialization (e.g., loading model weights, creating database and client connections) is defined under the "__init__" method.
- HTTP routes are defined by wrapping a method with the corresponding FastAPI decorator like we did with the `rag_endpoint` method.

To generate a sample subset of data to test our RAG service, we suggest running the code snippet below (eg. `generate_embeddings.py`):

```python
from pymongo import MongoClient
import os
import openai
from dotenv import load_dotenv

client = MongoClient(os.getenv("MONGODB_ATLAS_URI"))
db = client["anyscale_db"]
collection = db["stories"]

# Embedding endpoint for vector embeddings
openai_embedding = openai.OpenAI(
    base_url="https://XXXXXXXXXXXX.anyscaleuserdata.com/v1",
    api_key=os.getenv('EMBEDDING_API_KEY')
)

def generate_data() -> str:
    # Sample data to be inserted into MongoDB
    data = [
        "Karl lives in NYC and works as a chef",
        "Rio lives in Brasil and works as a barman",
        "Jessica lives in Paris and works as a programmer."
    ]

    for info in data:
        # Generate embedding for each piece of information
        embedding = openai_embedding.embeddings.create(
            model="thenlper/gte-large",
            input=info,
        )

        # Update or insert the data with its embedding into MongoDB
        collection.update_one(
            {'story': info},
            {'$set': {'embedding': embedding.data[0].embedding}},
            upsert=True
        )

    return "Data Ingested Successfully"

generate_data()
```
You can now access the service. Let's ingest the data to create the collection with embeddings and populate our “stories” collection with three sample documents:

```
 data = [
               "Karl lives in NYC and works as a chef",
               "Rio lives in Brasil and works as a barman",
               "Jessica lives in Paris and works as a programmer."
           ]
```

Use the following command to load data:
```shell
python generate.py
```
The collection was added with the following stories and embeddings:
![Embedded Docs][3]

Note for scaling out text embedding generation, you can follow the [workspace template for computing text embeddings at scale](https://console.anyscale.com/v2/template-preview/text-embeddings). This template leverages best practices for batch inference of embedding models to maximize the throughput of the underlying heterogeneous cluster of CPUs and GPUs.

Now, run the service locally:
```bash
serve run main:my_app --non-blocking
```



Now, the RAG endpoint is active on rag_endpoint: 
```python
payload = {"query": "Main character list"}


# Perform the POST request
response = requests.post("http://localhost:8000/rag_endpoint", json=payload)

# Print the response in JSON format
print(response.json())
```
The expected output:
```
Based on the provided context, the main character list is:


1. Jessica
2. Rio
3. Karl
```
## Deploy the RAG service

Now that you have tested the service by running locally within the workspace, you can proceed to deploy it as a standalone Anyscale service which is accessible via a URL and bearer token to external users.

```
anyscale services deploy  main:my_app --name=my-rag-service
```



Once the command is successfully propagated, you will get the service endpoint URL and its “bearer” token for authorization:
```
(anyscale +2.0s) Starting new service 'my-rag-service'.
(anyscale +4.5s) Using workspace runtime dependencies env vars: {'MONGODB_ATLAS_URI': '<YOUR_URI>', 'LLM_API_KEY': '<YOURKEY>',  'EMBEDDING_API_KEY': '<YOURKEY>'}.
(anyscale +4.5s) Uploading local dir '.' to cloud storage.
(anyscale +5.5s) Including workspace-managed pip dependencies.
(anyscale +6.1s) Service 'my-rag-service' deployed.
(anyscale +6.1s) View the service in the UI: 'https://console.anyscale.com/services/service2_wx8ar3cbuf84g9u87g3yvx2cq8'
(anyscale +6.1s) Query the service once it's running using the following curl command:
(anyscale +6.1s) curl -H 'Authorization: Bearer xxxxxxx' https://my-rag-service-yyyy.xxxxxxxxxxxx.s.anyscaleuserdata.com/
```


### Navigate to the services tab

The service you deployed will be visible under the Services tab on the Anyscale platform:
![Deployed Service][4]

Once the service is healthy, you will be able to access it via the provided URL and credentials the same way that you did in the workspace:
```shell
curl -X POST \
     -H "Authorization: Bearer XXXX" \
     -H "Content-Type: application/json" \
    https://my-rag-service-yyyy.cld-yga7qm8f6yamqev7.s.anyscaleuserdata.com/rag_endpoint/ \
     --data-raw '{"query": "What are the main character names?" }'
"The main character names mentioned in the stories are Jessica, Karl and Rio."
```
## Conclusion

Integrating MongoDB with Anyscale and PyMongo enables powerful distributed data processing and analysis workflows. By combining MongoDB's flexible document model, Atlas built-in scalability, and vector search capabilities with Anyscale's distributed computing platform, developers can build scalable RAG pipelines and AI-powered applications.

### Key takeaways

- **MongoDB Atlas** provides a managed database solution with vector indexing for semantic search.
- **Anyscale** offers a platform for running distributed Python applications using Ray.
- **PyMongo** allows easy interaction with MongoDB from Python. These technologies enable the building of performant RAG systems that can scale.

This tutorial walked through setting up a basic RAG service using MongoDB, Anyscale, and open-source language models. For production use cases, consider:

- Fine-tuning models on domain-specific data.
- Implementing caching and batching for improved performance.
- Adding monitoring and observability.
- Scaling up compute resources as needed.

Integrating MongoDB and Anyscale opens up exciting possibilities for building AI applications that can efficiently process and reason over large datasets. We encourage you to explore further and push the boundaries of what's possible with these powerful tools.

Please join our [forums](https://community.mongodb.com) and set up your [Atlas account](https://www.mongodb.com/try) with [Anyscale](https://console.anyscale.com/register/ha?utm_source=mongodb_devcenter&utm_content=blog&referrer_url=https://www.mongodb.com/developer/)!


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt9c80f3aead0a4f06/6697851e258470e44adcd79f/Workspaces.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4c42c58ddad7ec4f/6697854a05282f1a63b22dcc/Depnd.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta0107f7a0ca96a16/669786791e4e7e31dfb681c2/Docs.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt94d637d35fd88db4/6697864f6c101915ba397dad/DeployedService.png

This tutorial guides you through integrating MongoDB Atlas with Anyscale and PyMongo to build scalable AI-powered retrieval-augmented generation (RAG) services. Learn how to deploy self-hosted models, set up a vector store, and connect your services to efficiently process and analyze large datasets using Ray's distributed computing capabilities.


Building AI and RAG Apps With MongoDB, Anyscale and PyMongo

MongoDB

Aasawari Sahasrabuddhe

Community Engineer

Building applications with frameworks and libraries always makes the job simpler. And who doesn't like a simple life when it comes to building complicated applications? When it comes to Java applications, choosing Spring Data as the framework helps you reduce boilerplate code for setting up the configurations. Similar to Spring, to build Quarkus applications, you can make use of Panache. Panache is a Quarkus-specific library that simplifies the development of your Hibernate-based persistence layer.

Panache in Quarkus simplifies data access by minimizing boilerplate with built-in CRUD operations and type-safe queries. It supports both the Active Record and Repository patterns, allowing flexibility in architecture. Panache is tightly integrated with Quarkus, leveraging fast startup times and a low memory footprint, making it ideal for cloud-native and serverless environments. It also provides easy pagination, supports dynamic and named queries, and works seamlessly with Hibernate ORM and JPA, enhancing productivity while keeping code clean and efficient.

In this tutorial, we will be making a Quarkus application with Panache to perform some basic CRUD with aggregations to show the efficiency of working with Panache. The API allows you to perform basic CRUD operations like adding, updating, finding, and deleting books. It also supports aggregation to the group and counts books by genre.

## Prerequisites

1. A free Atlas cluster. You can [create your first Atlas cluster](https://www.mongodb.com/cloud/atlas/register?utm_source=google&utm_campaign=search_gs_pl_evergreen_atlas_general_prosp-brand_gic-null_apac-in_ps-all_desktop_eng_lead&utm_term=get%20started%20mongodb&utm_medium=cpc_paid_search&utm_ad=p&utm_ad_campaign_id=6501677905&adgroup=150907552314&cq_cmp=6501677905&gad_source=1&gclid=Cj0KCQiArby5BhCDARIsAIJvjIRIzHceWRjQ34eBb45FooOt-aHhCC5Fx5fy_Kv3mbrvihnPDC0DytoaAvLCEALw_wcB) for absolutely free\!
2. Java version 21 and above. Click on [Downloads](https://www.oracle.com/in/java/technologies/downloads/) for the latest version.
3. An IDE of your choice.
4. Maven or Gradle as per choice.

## Setting up the project

Before we get into the actual implementation part of the APIs, let's consider two of the most important things.

1. You can create your free cluster by following the steps mentioned in the [documentation](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/) or using an existing cluster.
2. Create a Quarkus project with Maven using the below command.

```
mvn io. quarkus:quarkus-maven-plugin:create \
    -DprojectGroupId=io.quarkus.platform \
    -DprojectArtifactId=quarkus-bom \
    -DclassName="com.example.BookResource" \
    -Dpath="/books"
```

3. Now, add the below dependencies to the pom.xml.

```
    <dependencies>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-arc</artifactId>
        </dependency>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-rest-client-jackson</artifactId>
            <version>3.16.2</version>
        </dependency>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-resteasy-reactive-jackson</artifactId>
            <version>3.15.1</version>
        </dependency>
        <dependency>
            <groupId>io.rest-assured</groupId>
            <artifactId>rest-assured</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-mongodb-panache</artifactId>
        </dependency>

    </dependencies>
```

4. Build the complete application and download the dependencies:

```
mvn clean install
```

## Creating REST API endpoints

Once the project is set up, the next step is to add the API endpoints. In this tutorial, we will use the Book collection from the Atlas cluster. The model class in the Quarkus project will add the fields inside the collection, and the next step will be to perform operations on the collection.   
The Book collection in the Atlas collection will look like the following:

```
{
_id: ..
title: ..
author: ..
genre: ..
year: ..
}
```

### **API endpoints**

* **Insert one book**: The first step will be to insert the documents inside the collection. To do so, we need to add the function in the resource class in the project. A resource class is a class that implements the PanacheRepository and provides methods to manipulate entities.

Add the below code to the resource class, which injects the repository class to implement the methods, and then create the POST call.

```java
    @Inject
    BookRepository bookRepository;   
 @POST
    public Response addBook(Book book) {
        bookRepository.persist(book);
        return Response.status(Response.Status.CREATED).entity(book).build();
    }
```

This would insert a simple document at a time inside the collection.

The BookRepository class with the below code:

```java
import com.quarkusWithPanache.model.Book;
import io.quarkus.mongodb.panache.PanacheMongoRepository;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class BookRepository implements PanacheMongoRepository<Book> {
}
```



* **Bulk write**: The insert method will insert the documents one by one inside the collection. If there are hundreds or thousands of documents, it will take a long time to insert the documents. To save time and resources with every call, the bulk write will insert all the documents in one go. To do so, add the below code, which will perform the bulk insert.

```java
 @POST
    @Path("/bulk")
    public Response bulkAddBooks(List<Book> books) {
        // Prepare documents for bulk write
        List<Document> documents = new ArrayList<>();
        for (Book book : books) {
            documents.add(new Document("title", book.title)
                    .append("author", book.author)
                    .append("genre", book.genre)
                    .append("year", book.year));
        }
        getCollection().insertMany(documents);

        return Response.status(Response.Status.CREATED).entity(books).build();
    }
```

The getCollection method returns the database and collection name from **import com.mongodb.client.MongoCollection** package.

* **Find all books:** Once all the books are inserted inside the collection, the next step is to retrieve the documents from the collection. To get all the books, create the below API call as:

```java
@GET
    public List<Book> getAllBooks() {
        return bookRepository.listAll();
    }
```

* **Find one book by ID**: To retrieve a specific book from the collection based on the \_id, the below API call would fetch a single document that matches the condition.

```java
@GET
    @Path("/{id}")
    public Book getBookById(@PathParam("id") String id) {
        return bookRepository.findById(new ObjectId(id));
    }
```

* **Delete book by ID**: Similar to retrieving a single document from the collection, the delete one will delete the single document based on the matching \_id. To do so, use the below-created API.

```java
    @DELETE
    @Path("/{id}")
    public Response deleteBook(@PathParam("id") String id) {
        boolean deleted = bookRepository.deleteById(new ObjectId(id));
        return deleted ? Response.noContent().build() : Response.status(Response.Status.NOT_FOUND).build();
    }
```


* **Update a book**: Finally, to update the document based on the \_id value, use the below code with the updated field values.

```java
@PUT
    @Path("/{id}")
    public Response updateBook(@PathParam("id") String id, Book book) {
        Book entity = bookRepository.findById(new ObjectId(id));
        if (entity == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        entity.title = book.title;
        entity.author = book.author;
        entity.genre = book.genre;
        entity.year = book.year;
        bookRepository.update(entity);
        return Response.ok(entity).build();
    }
```

* **Aggregation (genre count)**: Apart from performing basic CRUD operations, if you wish to perform an aggregation operation, you can use the code as below. As an example, this aggregation will perform a genre field and count the genres.

```java
@GET
    @Path("/aggregate/genre-count")
    public Response countBooksByGenre() {

        List<Document> pipeline = new ArrayList<>();
        pipeline.add(new Document("$group", new Document("_id", "$genre")
                .append("count", new Document("$sum", 1))));

        List<Document> result = getCollection()
                .aggregate(pipeline)
                .into(new ArrayList<>());

        return Response.ok(result).build();
    }
```

## Testing the API

To test the API, we can use the following `cURL` commands to interact with the server. Make sure the application is running on `http://localhost:8080` before sending the requests.

### **Insert one book:**

```
curl -X POST "http://localhost:8080/books" -H "Content-Type: application/json" -d '{                        
  "title": "Quarkus in Action",
  "author": "John Doe",
  "genre": "Programming",
  "year": 2023
}'
```


### **Bulk insert**

```
curl -X POST http://localhost:8080/books/bulk \
   -H "Content-Type: application/json" \
   -d '[
        {
            "title": "The Midnight Library",
            "author": "Matt Haig",
            "genre": "Fiction",
            "year": 2020
        },
                {
            "title": "Sapiens: A Brief History of Humankind",
            "author": "Yuval Noah Harari",
            "genre": "Non-Fiction",
            "year": 2011
        },
        .......
    ]'

```

### **Find all books**:

```
curl -X GET "http://localhost:8080/books" | jq
```

**Find one book:**

```
curl -X GET "http://localhost:8080/books/672f873b421eaa0c3e4da49f" | jq
```

### **Delete one book:**

```
curl -X DELETE "http://localhost:8080/books/673f81b65750de0757a4bbfb" | jq
```

### **Update one book:**

```
curl -X PUT "http://localhost:8080/books/672f856f421eaa0c3e4da49e" \
   -H "Content-Type: application/json" \
   -d '{
         "title": "Quarkus in Action",
         "author": "John Doe",
         "genre": "Programming",
         "year": 2021
       }'
```

### **Aggregation: Genre count**

```
curl -X GET "http://localhost:8080/books/aggregate/genre-count" | jq
```

This would give the output for the count of all the genres.

The complete code for the application is available on the [GitHub repository.](https://github.com/mongodb-developer/quarkus-panache-with-mongodb)

## Conclusion

In this tutorial, we explored how to harness the power of Panache in a Quarkus application to simplify CRUD operations and implement aggregation queries. By leveraging Panache's built-in functionalities, we reduced boilerplate code, making development faster and more efficient. From inserting single and multiple documents to retrieving, updating, and deleting them, we demonstrated how Panache integrates seamlessly with MongoDB to handle data operations. Additionally, we showcased how to perform aggregations, such as counting books by genre, to extract meaningful insights from data.

Panache's ability to work with Hibernate ORM and JPA, combined with Quarkus's low memory footprint and fast startup times, makes it an ideal choice for building cloud-native, serverless, and highly performant applications. With Panache, developers can focus on business logic while maintaining clean and readable code.

If you wish to learn more about MongoDB and its concepts, like vector search, read our tutorial on [MongoDB Vector Search with Quarkus](https://www.mongodb.com/developer/products/mongodb/mongodb-vector-search-with-quarkus/) on the MongoDB [Developer Center](https://www.mongodb.com/developer/), and find more interesting topics. For any questions related to the above or MongoDB, don’t forget to pay a visit to the [MongoDB community forum](https://www.mongodb.com/community/forums/) and be a part of an interesting discussion. 

In this tutorial, we will learn about building a Quarkus application with Panache and MongoDB. Panache is a Quarkus-specific library that simplifies the development of your Hibernate-based persistence layer. 


Building Quarkus Application with MongoDB and Panache

Python

JavaScript

Java

Swift

Rust

Ruby

TypeScript

Bash

Kotlin

Node.js

Quarkus

Vercel

Netlify

FastApi

Pandas

Flask

Django

Azure

Google Cloud

Docker

.NET

Next.js

Serverless

React Native

Parquet

Android

Jetpack Compose

Mobile

Mongoose

Neurelo

React

Unity

Xamarin

Postman API

Spark

GitHub Actions

RaspberryPi

Jupyter

Kafka

Spring

Terraform

GraphQL

Kubernetes

Prisma

Change Streams

Aggregation Framework

Security

Vector Search

Stream Processing

Shell

Data Visualization

Cloud Manager

Charts

Indexes

Time series

Schema

Sharding

Atlas

Search

Data API

Multi-Cloud

Data Federation

Online Archive

Triggers

Compass

Connectors

Ops Manager

Introductory

Intermediate

Advanced

Champion

Community

Student

Partner

Explore how BuildShip integrates with MongoDB to create AI-driven multi-agent systems. Learn how the Claude Assistant, in collaboration with MongoDB's scalable Atlas platform, can deliver dynamic conversational AI solutions. From backend aggregation to frontend interaction, discover the step-by-step integration to build scalable, interactive AI systems effortlessly.

Building AI Multi-Agents with BuildShip and MongoDB

Otavio Santana

This tutorial introduces building a Java application with MongoDB and Helidon, a framework for lightweight, cloud-native microservices. You'll learn to set up Helidon with MongoDB, create a tool management API, and configure a Docker-based MongoDB instance or connect to MongoDB Atlas. The guide covers creating and using a MongoDB repository with Jakarta Data, building a REST API for CRUD operations, and implementing pagination. Sample code is available on GitHub to help you follow along seamlessly and build scalable, high-performance microservices.

Introduction to MongoDB and Helidon

Learn how to integrate MongoDB Atlas Search with BuildShip to create advanced, powerful search functionalities in your applications using a low-code/no-code interface. With MongoDB's full-text, vector, and hybrid search capabilities, BuildShip makes it easy to add rich, relevant search experiences without extensive coding.

MongoDB Atlas Search Integration with BuildShip

Mark Smith

Query, group, and join data in MongoDB using aggregation pipelines with Rust.

Getting Started with Aggregation Pipelines in Rust

Query, group, and join data in MongoDB using aggregation pipelines with Python.

Getting Started with Aggregation Pipelines in Python

Lauren Schaefer

Learn how to execute the CRUD (create, read, update, and delete) operations in MongoDB using Node.js in this step-by-step tutorial.

MongoDB and Node.js 3.3.2 Tutorial - CRUD Operations

Maxime Beugnet

In this quickstart, learn how to use Change Streams using the MongoDB Java driver, with five different examples to showcase certain features.

Java - Change Streams

Nic Raboy

Learn how to get started with MongoDB Atlas and the MongoDB Query API.

Getting Started with Atlas and the MongoDB Query API

Discover how to analyze your data using MongoDB's Aggregation Framework and Node.js.

Aggregation Framework with Node.js Tutorial

Aggregation Framework with Node.js 3.3.2 Tutorial

Learn how to use the Aggregation Pipeline using the MongoDB Java Driver.

Java - Aggregation Pipeline

Explore the integration of Haystack with MongoDB Atlas to build robust retrieval-augmented generation (RAG) pipelines. 

Building RAG Pipelines With Haystack and MongoDB Atlas

Kushagra Kesav

In this tutorial, explore the capabilities of LangChain, LlamaIndex, and PyMongo with step-by-step instructions to use their methods for effective searching. 

Quickstart Guide to RAG Application Using LangChain and LlamaIndex

Anaiya Raisinghani

Learn some of the best practices for using Flask and MongoDB so you can set yourself up for success.

Best Practices for Using Flask and MongoDB

Joe Drumgoole

With multi-document ACID transactions, we wrap a set of database operations inside a start and commit transaction call so the external view meets constraints.

Introduction to Multi-Document ACID Transactions in Python

Michael Lynn

Welcome to Part 2 of this guide for MongoDB and PHP. Let's cover connecting to a database instance, creating/inserting a document with PHP, and more!

Creating, Reading, Updating, and Deleting MongoDB Documents With PHP

Viraj Thakrar

Learn how to leverage MongoDB's powerful aggregation framework with PHP to process and analyze large datasets efficiently. This comprehensive guide covers advanced techniques for user engagement analysis, content preference tracking, and real-time data processing using MongoDB's aggregation pipelines and change streams.

Complex Aggregation Pipelines with Vanilla PHP and MongoDB

Learn how to use MongoDB and PHP! The first article of this series addresses the installation and configuration of your development environment.

Getting Set Up to Run PHP With MongoDB

Explore the seamless integration of Quarkus, GraalVM, and MongoDB for lightning-fast CRUD RESTful APIs. Harness Quarkus' rapid startup time and Kubernetes compatibility for streamlined deployment.

How to Build a CRUD Application With MongoDB, Quarkus, and GraalVM

Joel Lord

Out of the box, Rails integrates with a traditional relational database, but this can easily be changed to use MongoDB. The instructions are in our getting started guide. However, if you simply want to create a fully functional application, you can use the MongoDB Rails template, as explained in this tutorial.

Building Rails Applications With the MongoDB Template

Jesse Hall

MongoDB Atlas serverless instances are now generally available! In this article, we deploy an Atlas serverless instance and perform basic CRUD operations.

MongoDB Atlas Serverless Instances: Quick Start

Learn how Mongoose, a library for MongoDB, helps you structure and access data with ease. Mongoose is “elegant MongoDB object modeling for Node.js."

Getting Started With MongoDB & Mongoose

Getting a MongoDB Atlas database created and linked to your Vercel project has never been easier. In this tutorial, we get everything set up in minutes.

How to Connect MongoDB Atlas to Vercel Using the New Integration

MongoDB is a great database for data science and analysis. Now, with PyMongoArrow, it integrates with Apache Arrow, Python's Numpy, and Pandas libraries.

PyMongoArrow: Bridging the Gap Between MongoDB and Your Data Analysis App

Bun is the JavaScript runtime that uses WebKit's JavaScriptCore as the JavaScript engine, which is different from Node.js, which uses V8.

Getting Started With Bun and MongoDB

This tutorial explains on connecting a Minecraft Java application with MongoDB Atlas cluster. 

Getting started with Minecraft and MongoDB

Aaron Bassett

In this quick start, we will create a CRUD (Create, Read, Update, Delete) app showing how you can integrate MongoDB with your FastAPI projects.

Getting Started With MongoDB and FastAPI

In this quick start, we will create a CRUD (Create, Read, Update, Delete) app showing how you can integrate MongoDB with your Sanic projects.

Getting Started With MongoDB and Sanic

In this quick start, we will create a CRUD (Create, Read, Update, Delete) app showing how you can integrate MongoDB with your Starlette projects.

Getting Started With MongoDB and Starlette

This notebook demonstrates how to integrate MongoDB with AWS Bedrock to build AI agents. It covers setting up the environment, configuring the database, and creating an AI agent using AWS Bedrock services, with practical examples and code snippets.

MongoDB With Bedrock Agent: Quick Tutorial

Learn how to quickly and easily start building .NET Core applications that interact with MongoDB Atlas for create, read, update, and delete (CRUD) operations.

Build Your First .NET Core Application with MongoDB Atlas

Sujee Maniyam

This quick start will guide you through how to perform vector search using MongoDB Atlas and OpenAI API. 

Quick Start 2: Vector Search With MongoDB and OpenAI

Explore the 'MongoDB One-Click Starters: A Comprehensive Guide' for an in-depth look at deploying MongoDB with Netlify, Vercel, Heroku, and Render. This guide covers essential features, ideal use cases, and step-by-step deployment instructions to kickstart your MongoDB projects.

Single Click to Success: Deploying on Netlify, Vercel, Heroku, and Render with Atlas

In this tutorial, we will learn how to setup MongoDB Atlas in the Cloud, load sample data and query it using the PyMongo library.

Quick Start: Getting Started With MongoDB Atlas and Python

Learn how to accomplish ACID transactions and logical sessions with MongoDB and the Go programming language (Golang).

Multi-Document ACID Transactions in MongoDB with Go

Learn how to use the client side field level encryption using the MongoDB Java Driver.

Java - Client Side Field Level Encryption

In this tutorial you'll learn more about multi-document ACID transaction in MongoDB with Java. You'll understand why they are necessary in some cases and how they work.

Java - MongoDB Multi-Document ACID Transactions

Learn how to use the native mapping of POJOs using the MongoDB Java Driver.

Java - Mapping POJOs

Learn how to use MongoDB with Java in this tutorial on CRUD operations with example code and walkthrough!

Getting Started with MongoDB and Java - CRUD Operations Tutorial

Node.js and MongoDB is a powerful pairing and in this Quick Start series we show you how.

Connect to a MongoDB Database Using Node.js

MongoDB Cheat Sheet by MongoDB for our awesome MongoDB Community <3.

MongoDB Cheat Sheet

Discover how to react to changes in your MongoDB database using change streams implemented in Node.js and Atlas triggers.

Change Streams & Triggers with Node.js Tutorial

Discover how to implement multi-document transactions in MongoDB using Node.js.

How to Use MongoDB Transactions in Node.js

MongoDB and Node.js Tutorial - CRUD Operations

Andrew Morgan

Change streams let you run your own logic when data changes in your MongoDB collections.  This post shows how to consume MongoDB change stream events from your Swift app.

Working with Change Streams from Your Swift Application

You can improve application performance by storing together data that’s accessed together. This can be done through embedding sub-documents, or by storing related documents in the same collection — even when they have different shapes. This post explains how to work with these polymorphic MongoDB collections from your Swift app.

Working with the MongoDB Single-Collection Pattern in Swift

What is the GDELT dataset and how to work with it and MongoDB and participate in the MongoDB World Hackathon '22

An Introduction to GDELT Data

Learn how to quickly and easily deploy a MongoDB Atlas cluster using a variety of methods such as CloudFormation, Terraform, the CLI, and more.

5 Different Ways to Deploy a Free Database with MongoDB Atlas

Learn how to use change streams to react to changes to MongoDB documents, databases, and clusters in real-time using the Go programming language.

Quickstarts

Featured Quickstarts

Introduction to Atlas Stream Processing Development

Building AI and RAG Apps With MongoDB, Anyscale and PyMongo

Building Quarkus Application with MongoDB and Panache

All Quickstarts