DEV Community: Anaiya

Grab a Pint With Django-MongoDB-Backend, Voyage AI, and LangChain

Anaiya — Fri, 11 Apr 2025 10:00:00 +0000

This tutorial was written by Anaiya Raisinghani (Developer Advocate @ MongoDB)

DjangoCon Europe is just around the corner, and this year, it’s in Dublin, Ireland. This means two things:

I’m legally required to drink my first Guinness (yes, first ever!).
I obviously had to build an app to help me find the best pubs to accomplish my Guinness goal.

This full-stack, AI-powered Dublin City Center Pub Finder app is built using our new Django MongoDB Backend Python package, Voyage AI embeddings to best understand the queries, and LangChain to power our natural-language interface.

So, if you’re in Dublin and you really want a “Guinness, outside, with live music,” this Pub Finder will help you find the three best options!

Before we go into how it works and how you can build it yourself, let’s go over the platforms used.

What is our Django MongoDB Backend?

Our official Django MongoDB Backend was released for Public Preview back in February. This incredible Python package offers developers a ton of fantastic features, such as the ability to use Django models with confidence, Django admin support, native connecting from the settings.py file, MongoDB-specific querying optimizations, and more!

This combination of MongoDB’s document model, ecosystem of tools, and various advanced features allows for Django developers to build a multitude of complicated applications, simply.

LangChain MongoDB

LangChain is an open source framework used to build applications that are powered by large language models (LLMs). There are a variety of use cases for LangChain, such as document analysis, chat bots, retrieval-augmented generation (RAG), etc. It works by chaining together various components (links) to create a comprehensive workflow where each link performs various tasks in the process, such as accessing your data, calling the language model used, processing data, etc. Because these links are malleable, LangChain is known for its flexibility.

With our MongoDB LangChain Python integration, developers are able to integrate MongoDB Atlas Vector Search with LangChain to build generative AI and RAG applications!

What is Voyage AI and why are we using them?

Voyage AI provides world-class embedding models and rerankers for any AI application. They specialize in creating these state-of-the-art embedding models which help transform complex data (text, images, videos) into vectors that have extremely high accuracy, are competitive in the space, and allow for fast inference and multi-language support. Voyage AI was recently acquired by MongoDB with the goal of more accurate and context-aware AI queries inside applications.

Pre-requisites

This tutorial requires a number of pre-requisites in order to be successful:

An IDE of your choosing (this tutorial uses VSCode).
A MongoDB Atlas account.
A MongoDB Atlas cluster—the free tier will work perfectly. Please make sure your IP address is correctly configured.
A MongoDB Connection String (with the username, password, and database included in the string).
The dataset we are using for this tutorial. It has information on 40 pubs and wine bars in Dublin’s City Center with the address, the name, and five concatenated Google reviews. Please download this JSON file and add it to the root of your project directory.
A Voyage AI API key.

Background on data collecting

This section is for those who are interested in how I gathered the data used; it’s not necessary to recreate for this tutorial as long as you have access to the dataset in Kaggle.

While looking around on Google Maps, I saw that Temple Bar was one of the more popular locations in Dublin! The Google Maps Places API (New) allows for a maximum of 20 locations per API call. So, I did two API calls in this location, one for the tag “pub” and the other for the tag “wine_bar”. This way, I had 40 data points for my file and so we could have more options for places to grab a drink in Dublin.

From there, I saved all the places located from the Google Places API calls into a JSON document that I was able to upload into my project folder.

Now that we better understand the dataset, let’s get started on building out the tutorial.

Step 1: Create Django project using Django-MongoDB-Backend library

Our first step is to download the django-mongodb-backend package.
Please use the Django-MongoDB-Backend Quickstart to help you get up and running with setting up your Django and MongoDB integration.

First, we need to create a virtual environment.

Create a virtual environment

In your terminal, run:

python3.12 -m venv venv

Then:

source venv/bin/activate

Make sure you are running the correct Python version:

python --version

Once the virtual environment is up and running, let’s get started on our requirements.txt file.
Create a new file in your project, name it requirements.txt, and include the following:

python-dotenv==1.0.1
voyageai==0.3.2
langchain-voyageai==0.1.4
langchain-mongodb==0.5.0

You can also include:

django-mongodb-backend==5.1.0b1

And install it all in one go, but in a couple steps, I will show that you can use a pip command to install the django-mongodb-backend for reader clarity.

Install the requirements using:

pip install -r requirements.txt

Great, now we can go ahead and install the Django MongoDB Backend library.

Install the Django MongoDB Backend library

Run the following command:

pip install django-mongodb-backend

Once that’s run, we can create our Django project.
This template is the same as the default Django project template, but with a handful of crucial changes. It ensures MongoDB-specific migrations, and our settings.py file is modified so that Django uses an ObjectID value for each of our model’s primary keys. It also ensures we have MongoDB-specific app configurations for Django apps that have a default_auto_field set. This means we can create our own apps and set django_mongodb_backend.fields.ObjectIdAutoField.

So let’s create a new Django project. We can name it finder:


django-admin startproject finder --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/5.0.x.zip

Once run, we can see our file breakdown on the left-hand side of the project file:

Once we can see our project, we can update our database settings. Open up the finder file, select the settings.py file, and scroll down to the DATABASES setting. Please replace the “” with the specific cluster URI including the name of the sample database we are using. Mine looks like this:

DATABASES = {
   "default": django_mongodb_backend.parse_uri("mongodb+srv://<user>:<password>@cluster0.ytyyt.mongodb.net/dublinfinder?retryWrites=true&w=majority&appName=Cluster0"),
}

Once the connection string is properly in place, cd back into finder, or whatever the name of your root is.

Once you’re there, run this command:

python manage.py runserver

If properly connected, this will show that you have unapplied migrations and there will be a link. At that link, http://127.0.0.1:8000/, this screen will appear:

This is confirmation that the setup of our project has been successful! Now, we can create an actual application. Luckily, we have another template that can help us accomplish this.

Step 2: Create Django application

Make sure you’re at the root of your project (in my case, finder) and run the following command to create an application based on the MongoDB template. I am naming it dublinfinder:


python manage.py startapp dublinfinder --template https://github.com/mongodb-labs/django-mongodb-app/archive/refs/heads/5.0.x.zip

Once that’s correctly been downloaded, it’ll appear on the left-hand side of your project directory.

Step 3: Creating our models

Now that it's been created, we can create our models.py file. Django models are especially useful since they define the structure of our data based on our JSON format. To have a better understanding of our raw data, let’s quickly take a look at one example:

{
     "types": [
       "pub",
       "bar",
       "clothing_store",
       "store",
       "restaurant",
       "food",
       "point_of_interest",
       "establishment"
     ],
     "formattedAddress": "47-48 Temple Bar, Dublin 2, D02 N725, Ireland",
     "displayName": {
       "text": "The Temple Bar Pub",
       "languageCode": "en"
     },
     "reviews": "Best Irish Pub atmosphere Ive been too in ages! \n This location is well renowned around the world for all the smiles, happy vibes it procures but especially because of all the famous people who have been here as visitors or to perform. \n The food is also very good and the staff really nice, polite and efficient. \n Decorated like a true Irish pub with great live music always playing! \n FYI: There is an ATM machine in the basement beside the washrooms if you ever need real cash money. \n GOOD JOB TL;DR: The Original Temple Bar Pub in Dublin is a lively spot with great service, live music, and a fun crowd. A must-visit on any pub crawl! \n The Original Temple Bar Pub was a fantastic stop on our afternoon Dublin pub crawl. The atmosphere was lively, even on a Tuesday afternoon, with great live music adding to the experience. \n Our server, Dylan, was excellent, attentive, friendly, and even gave us great recommendations for our next stops. We also had a great chat with Ian K, which made the visit even more enjoyable. \n If you're looking for a classic Dublin pub experience with great service and entertainment, this is a must-visit! We stopped in because the outside of the building was decorated amazingly for Christmas, and we wanted a warm drink. The inside was also decorated well, the service was excellent,  and the food and drinks were great.  We ordered the cheese board and a hot chocolate with a shot of Bailey's Irish Cream. \n The cheese board came with 5 types of cheese, grapes, apples,  nuts, crackers,  and bread. It was also served with honey and another tomato-based sauce.  It was the perfect midday snack. \n The service was quick, and the live music was entertaining.  This is one of my new favorite places. The Temple Bar Pub is a decent enough Irish pub with a lively atmosphere and great live music. Its undoubtedly one of the most famous spots in Dublin, and the energy inside reflects that. The musicians were talented, and the overall vibe was enjoyable. \n That said, its extremely touristy which is expected given its location. If you're looking for an authentic, local pub experience, this probably isnt the place. The biggest downside? The price. Paying 12 for a pint of Guinness felt excessive, even by Dublin standards. \n Worth a visit for the experience, but be prepared to pay a premium for it. Visiting the Temple Bar was an unforgettable experience! The atmosphere was vibrant and lively, with people from all over the world coming together to enjoy the iconic spot. The live music added an incredible charm, showcasing talented local artists playing everything from traditional Irish folk to upbeat contemporary tunes. \n The bar offers an extensive selection of drinks almost overwhelming in the best way! We stuck to local beers, which didnt disappoint. Each sip was a true taste of Irelands brewing craft. While it was a bit pricey (as expected for such a famous spot), its absolutely worth it for the experience alone. \n Fun fact: The Temple Bar has been serving visitors for over 170 years, and despite its name, its not actually a temple! The name comes from Sir William Temple, who owned land in the area in the 17th century. Another fascinating tidbit Temple Bar is home to one of Irelands largest whiskey collections, so if youre a fan of whiskey, its a must-try. \n Did you know that the surrounding Temple Bar district is considered the cultural quarter of Dublin? Its filled with galleries, street performers, and quirky shops, making it the perfect area to explore before or after your visit to the bar. \n All in all, its a must-visit spot for anyone wanting to soak up Dublins unique character, music, and local flavors!"
   },

So we want to ensure that each document represents a “Place” with:

A list of types (array of strings).
A formatted address (a string).
A nested displayName (this will be our embedded document).
A reviews field (long text field that will later be used to generate embeddings).
An embedding field (voyage_embedding—this will store the embeddings we generate).

For help on structuring the models.py file, I recommend taking a look at our Raw Database Queries docs.

Our models.py file will look something like this:

from django.db import models
from django_mongodb_backend.fields import ArrayField, EmbeddedModelField
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.managers import MongoManager


# embedded, so it doesn't have its own collection
class DisplayName(EmbeddedModel):
   text = models.CharField(max_length=200)
   languageCode = models.CharField(max_length=10, blank=True, null=True)




# main model is our Places.
class Place(models.Model):
   types = ArrayField(models.CharField(max_length=50), blank=True, null=True)
   formattedAddress = models.CharField(max_length=300, blank=True, null=True)
   displayName = EmbeddedModelField(DisplayName, blank=True, null=True)
   reviews = models.TextField(blank=True, null=True)
   # this is where our embedding will go when generated.
   embedding = ArrayField(models.FloatField(), blank=True, null=True)


   objects = MongoManager()


   class Meta:
       db_table = "places"
       managed = False


   def __str__(self):
       return self.displayName.text

Once our models.py file is saved, we need to add our new application to the finder/settings.py file. Find the INSTALLED_APPS area and add in the new application. The name for this tutorial is dublinfinder.apps.DublinfinderConfig.

Now, we have our application started up, and we could essentially start putting in our views and urls and creating our templates, but we still need to embed our “reviews” field and put the data we are going to be working with into our MongoDB Atlas cluster. So let’s do that first and then we can go back.

Step 4: Embedding with Voyage AI

Please make sure you have a Voyage AI API key.

Create a new file in your project named .env and place your API key in it using VOYAGE_API_KEY. Once that’s set, create another file named reviews_embedding.py where we can put the script we will use to embed the reviews field of our JSON file.

import json
import voyageai


# using our API key
vo = voyageai.Client()


with open("guinness_wine_dublin_cleaned.json", "r") as f:
   data = json.load(f)


# focusing on "reviews" field since that's what we are embedding
reviews_list = [place.get("reviews", "") for place in data.get("places", [])]


# getting embeddings for the reviews using "voyage-3-lite"
result = vo.embed(reviews_list, model="voyage-3-lite", input_type="document")


# new field to hold the embeddings
for place, embedding in zip(data.get("places", []), result.embeddings):
   place["embedding"] = embedding


# writing embeddings back to a new file
with open("embedded_guinness_wine_dublin_cleaned2.json", "w") as f:
   json.dump(data, f, indent=2)

Here, we are setting our key, opening up our JSON file that’s already in our project, embedding the reviews field using Voyage AI’s “voyage-3-lite” embedding model, creating a new field to hold the embedding (that has the same name as what we clarified when creating our models.py file), and then creating a new JSON file that has the embeddings as a field. We want to save this to a new file so that we can upload that file to our MongoDB cluster.

Run the file using:

python reviews_embedding.py

When the new file is opened up, we can see our Voyage AI embeddings!

Once we have our embedded field ready, we can insert our documents into our MongoDB cluster.

Step 5: Inserting data into the MongoDB cluster

Because of the django-mongodb-backend installation, we already have pymongo downloaded in our environment, and we should have python-dotenv downloaded as well since we set it in the requirements.txt file above. Just to be sure, run this command in the root of your project:

pip install pymongo python-dotenv

Make sure to update your .env file as well with your MongoDB connection string. Please make sure to include the username, password, and database name in the connection string.

An example of how this will look in the .env file is:

MONGO_URI=“mongodb+srv://mongodb:<db_password>@cluster0.ytyyt.mongodb.net/<database>?retryWrites=true&w=majority&appName=Cluster0”

Once the connection string is safe in the .env file, we can create a new file at the root of the project named json_upload.py.

import json
import os
from pymongo import MongoClient
from dotenv import load_dotenv


load_dotenv()


# get the environment variable and connect
connection_string = os.getenv("MONGO_URI")
connect = MongoClient(connection_string)


# specify our database and collection
database = connect["dublinfinder"]
collection = database["placesinfo"]


# load in our json file
with open("embedded_guinness_wine_dublin_cleaned2.json", "r") as file:
   data = json.load(file)


# our json file starts with "places" so this is just making sure it fits
if isinstance(data,dict) and "places" in data:
   places = data["places"]


# use insert_many since we have 40 docs
result = collection.insert_many(places)

Run this file and check your MongoDB cluster:

As we can see, our data is saved in our cluster with our Voyage AI embeddings!

Now that we have successfully stored our data, we can get started on writing a script using the langchain-mongodb package to do some fun semantic search.

Step 6: LangChain-MongoDB

We want to integrate MongoDB Atlas Vector Search with LangChain to really get the most out of our embedded reviews.

Double check the requirements.txt file and make sure you have both the langchain-voyageai package and the langchain-mongodb package.

Before we continue with writing up our script, let’s first create our Atlas Vector Search index.

Do this by going into your cluster, clicking on the Atlas Search tab, and clicking on the green “Create Search Index” button.

Make sure to choose the “Vector Search” index. Keep the default name of the index of “vector_index” (or if you decide to change it, make sure this change is deployed across all necessary areas), and choose the database and collection our data is stored in.

Click the “Next” button.

Choose the path that contains the array of vector embeddings—it should be “embedding.” The number of dimensions is 512 because we used Voyage AI’s voyage-3-lite. If choosing a different model, please read up on Voyage AI’s text embeddings documentation to ensure you’re choosing the correct dimensions. For the similarity method, we are using cosine.

Once all that information is in, click “Next.” Review your Vector Search index on the page that pops up, and if all the information is correct, click “Create Vector Search Index.”

When the Vector Search index is ready, you’ll see a status change. Once that is up and running, let’s create our script to put everything to use.

Create a new file in your project’s root and name it langchain_integration.py.
We are using an embeddings object from the the Voyage AI documentation. It looks like this:

from langchain_voyageai import VoyageAIEmbeddings
embeddings = VoyageAIEmbeddings(
    voyage_api_key="[ Your Voyage API key ]", model="voyage-law-2"
)

And we are using the Vector Store sample code from MongoDB’s documentation. It looks like this:

from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearch
from pymongo import MongoClient

# Use some embedding model to generate embeddings
from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings

# Connect to your Atlas cluster
client = MongoClient("<connection-string>")
collection = client["<database-name>"]["<collection-name>"]

# Instantiate the vector store
vector_store = MongoDBAtlasVectorSearch(
   collection = collection,        # Collection to store embeddings
   embedding = FakeEmbeddings(),   # Embedding model to use
   index_name = "vector_index",    # Name of the vector search index
   relevance_score_fn = "cosine"   # Similarity score function, can also be "euclidean" or "dotProduct"
)

We will be connecting these two but changing a couple crucial aspects. The first thing we are changing is we are connecting from our connection string, so that needs to be added in. This means we are changing up parts from the Vector Store example code:

# vector store with our embeddings model
vector_store = MongoDBAtlasVectorSearch.from_connection_string(
   connection_string=connection_string,
   namespace=namespace,
   embedding_key="embedding",
   index_name="vector_index",
   text_key="reviews",
   embedding=embeddings

)

Please make sure to include the connection_string, the namespace, the embedding_key, and the text_key. Our text_key is our reviews.

Let’s put it all together:

import os
from dotenv import load_dotenv
from langchain_voyageai.embeddings import VoyageAIEmbeddings
from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearch
from pymongo import MongoClient


load_dotenv()
voyage_api_key = os.getenv("VOYAGE_API_KEY")
connection_string = os.getenv("MONGO_URI")




# this is our embeddings object.
embeddings = VoyageAIEmbeddings(
   voyage_api_key=voyage_api_key, 
   model="voyage-3-lite"                  
)
# this is your database.collection
namespace = "dublinfinder.placesinfo"


# vector store with our embeddings model
vector_store = MongoDBAtlasVectorSearch.from_connection_string(
   connection_string=connection_string,
   namespace=namespace,
   embedding_key="embedding",
   index_name="vector_index",
   text_key="reviews",
   embedding=embeddings

)


# similarity search
query = "I want to enjoy a Guinness outside. With some yummy food"


# LangChain automatically handles embedding the query
results = vector_store.similarity_search_with_score(query, k=3)


# post-process and make it look pretty
for doc, score in results:
   name = doc.metadata.get("displayName", {}).get("text", "Unknown")
   address = doc.metadata.get("formattedAddress", "Unknown")
   review_text = doc.page_content
   short_review = review_text[:200]


   print(f"Name: {name}")
   print(f"Address: {address}")
   print(f"Short review: {short_review}")
   print(f"Score: {score}")
   print()

If you look at the difference between the sample code we are working with and the code in our script, you will notice a handful of differences. This is because we need to account for entering our documents into our vector store, and this is done by using the connection_string method.

Awesome! We have great results when we run the query: “"I want to enjoy a Guinness outside. With some yummy food"

Let’s run one more query just to test if our results are accurate. Let’s chat about wine bars and cocktails.

I ran the query: “Wine bar with snacks and outdoor seating”

Awesome! Now, let’s work on incorporating this integration into our Django application, and finishing up all the other necessary Django files.

Step 7: Django

Our first step is to edit our views.py file. We already have our langchain_integration.py file, so now we need to transfer it over to our views.py file. The only difference here is that we are going to prompt for the query instead of hard coding it. Copy in the views.py file like this:

from django.shortcuts import render
import os
from dotenv import load_dotenv
from langchain_voyageai.embeddings import VoyageAIEmbeddings
from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearch


load_dotenv()


def search_places(request):
   # get query from user
   query = request.GET.get("query", "")
   results = []

   # same from our langchain_integration.py file
   if query:
       # use our API keys
       voyage_api_key = os.getenv("VOYAGE_API_KEY")
       connection_string = os.getenv("MONGO_URI")

       # this is our embeddings object.
       embeddings = VoyageAIEmbeddings(
           voyage_api_key=voyage_api_key,
           model="voyage-3-lite"
       )

       # this is your database.collection
       namespace = "dublinfinder.placesinfo"

       # vector store with our embeddings model
       vector_store = MongoDBAtlasVectorSearch.from_connection_string(
           connection_string=connection_string,
           namespace=namespace,
           embedding_key="embedding",
           index_name="vector_index",
           text_key="reviews",
           embedding=embeddings
       )


       # similarity search, LangChain handles embedding the query
       results_with_scores = vector_store.similarity_search_with_score(query, k=3)

       # post-process and make it look pretty
       processed_results = []
       maximum_char = 800


       for doc, score in results_with_scores:
           name = doc.metadata.get("displayName", {}).get("text", "Unknown")
           address = doc.metadata.get("formattedAddress", "Unknown")
           review_text = doc.page_content if doc.page_content else ""

           # refining it so we don't end in the middle of a sentence
           if len(review_text) > maximum_char:
               shortened = review_text[:maximum_char]
               last_period = shortened.rfind('.')
               if last_period != -1:
                   review = shortened[:last_period+1]

           processed_results.append({
               "name": name,
               "address": address,
               "review": review,
               "score": score
           })

       results = processed_results

   # template
   return render(request, "search_results.html", {"results": results, "query": query})

I also went ahead and added in a couple extra lines to make sure our reviews stopped at a period and not in the middle of a sentence. This is just for aesthetic reasons.

Now, we need to create our template. Create a new folder named templates and create a search_results.html file inside. Here is where you can put all your CSS and HTML to curate exactly how you’d like the front page of your site to look!

<!DOCTYPE html>
<html>
<head>
   <title>Dublin City Center Pub Finder</title>
   <!-- Import Lexend Deca font -->
   <link href="https://fonts.googleapis.com/css2?family=Lexend+Deca&display=swap" rel="stylesheet">
   <style>
       body {
           background-color: #0B3D0B; /* Dark green background */
           color: #ffffff;           /* White text */
           font-family: 'Lexend Deca', sans-serif;
           margin: 0;
           padding: 0;
       }
       .container {
           display: flex;
           flex-direction: column;
           align-items: center;
           min-height: 100vh;
           padding: 20px;
       }
       .header {
           font-size: 3em;
           margin-bottom: 20px;
           color: #ACE1AF; /* Light green for headings */
           text-align: center;
       }
       form {
           margin-bottom: 20px;
       }
       input[type="text"] {
           width: 300px;
           padding: 10px;
           border: none;
           border-radius: 4px;
           margin-right: 10px;
       }
       button[type="submit"] {
           padding: 10px 20px;
           background-color: #006400; /* Darker green */
           color: #ffffff;
           border: none;
           border-radius: 4px;
           cursor: pointer;
       }
       button[type="submit"]:hover {
           background-color: #008000;
       }
       .results {
           width: 80%;
           margin-top: 40px;
       }
       ul {
           list-style: none;
           padding: 0;
       }
       li {
           background-color: #013220; /* Dark green shade */
           margin-bottom: 15px;
           padding: 15px;
           border-radius: 5px;
       }
       .name {
           margin-bottom: 10px;
           font-weight: bold;
           color: #7FFF00;
       }
       .address, .review, .score {
           margin-bottom: 10px;
           font-weight: bold;
       }


       p {
           margin-top: 20px;
       }
   </style>
</head>
<body>
   <div class="container">
       <!-- Landing Page Header -->
       <div class="header">Dublin City Center Pub Finder</div>
       <!-- Search Form -->
       <form method="GET" action="{% url 'search_places' %}">
           <input type="text" name="query" value="{{ query }}" placeholder="Enter your query here">
           <button type="submit">Search</button>
       </form>
       <!-- Display Results if a Query is Present -->
       {% if query and results %}
           <div class="results">
               <h2>Results for "{{ query }}"</h2>
               <ul>
                   {% for place in results %}
                       <li>
                           <div class="name">{{ place.name }}</div>
                           <div class="address">Address: {{ place.address }}</div>
                           <div class="review">Review (excerpt): {{ place.review }}</div>
                           <div class="score">Similarity Score: {{ place.score }}</div>
                       </li>
                   {% endfor %}
               </ul>
           </div>
       {% elif query %}
           <p>No results found for "{{ query }}".</p>
       {% endif %}
   </div>


</body>
</html>

Once that’s in place, we can connect our URL so we have someplace to actually go.

Go over to the urls.py file and edit it like this:

from django.contrib import admin
from django.urls import path
from dublinfinder import views


urlpatterns = [
   path('admin/', admin.site.urls),
   path('search/', views.search_places, name='search_places'),
   path('', views.search_places, name='search_places')
]

This is just saying that when you open up the webpage, you’ll immediately see the text box prompting you to put in your query, and you’ll see the same if you type search/ at the end of the URL.

Go to where your manage.py file is located and run the command:

python manage.py runserver

Click on http://127.0.0.1:8000/ and search for a place!

My query is: “Guinness with outdoor seating”.

We have three great options to choose from!

Conclusion

Congratulations on building your own Dublin City Center Pub Finder! It’s partly a side project, partly an excuse to experience Dublin, and 100% built with tools that I’m super excited about: Django MongoDB Backend, Voyage AI, and LangChain.

Whether you’re building competitive AI applications, or just looking for a fun place to grab a drink, I hope this tutorial shows how powerful (and fun!) the intersection between Django, MongoDB, and AI is.

If you find yourself in Dublin for DjangoCon Europe, come see my talk.

Clone the GitHub repo for this project from our Gen AI Showcase!

For questions, please check out our MongoDB Developer Forum.

Build a Basic CRUD Application With Flask-PyMongo

Anaiya — Thu, 27 Feb 2025 14:00:00 +0000

This tutorial was written by Anaiya Raisinghani (Developer Advocate @ MongoDB)

In this tutorial, we will dive head first into utilizing MongoDB’s Flask-PyMongo library! We will build a basic CRUD (create, read, update, delete) Flask-PyMongo application and learn about how intuitive this library is for building fully functional Flask applications.

What is Flask?

Flask is a very lightweight web application framework where, by design, it makes creating simple applications quick and easy. While it started as a simple wrapper, it has quickly become one of the most popular Python frameworks for developers, as it’s easy to get started but allows for the ability to scale up to complex applications.

Since Flask is a microframework, it does not provide a database abstraction layer and keeps its core simple, but buildable. This is a huge advantage for developers since it’s incredibly malleable: Flask won’t force developers to make big application decisions—the power stays in the hands of the users.

Flask-PyMongo

This extension is so highly regarded for a multitude of reasons. It allows for seamless Flask integration, developers have direct access to PyMongo’s capabilities, and it provides support for advanced MongoDB features.

This library allows for simple configuration. Whereas before, developers needed extra lines of code in order to successfully connect to their MongoDB back end, now, developers can rely on Flask-PyMongo to pick up crucial settings (such as MONGO_URI) from their Flask app configuration. It allows for developers to use the entirety of the PyMongo API, meaning developers can use the full power of PyMongo for all their database needs. It also has a ton of support for more complex features available through MongoDB’s platform.

With all this in mind, let’s jump on in!

Pre-requisities

To be successful in this tutorial, developers will need a variety of pre-requisites:

A MongoDB Atlas cluster on the free tier. Please make sure to save the connection string someplace safe. Download the sample dataset. We will need it throughout the tutorial. Please make sure the cluster’s IP address is whitelisted for proper connectivity.
An IDE. This tutorial uses VSCode.
Python 3.10+.

Please make sure that the name of the sample dataset is in the connection string like such:

mongodb+srv://mongodb:<PASSWORD>@cluster0.qh7j8.mongodb.net/<DATABASE>?retryWrites=true&w=majority&appName=Cluster0

We are using the sample_mflix dataset for this tutorial.

Step 1: Create a virtual environment

Let’s go ahead and create our virtual environment.

In your root directory, run this command to create a directory called venv:

python3.12 -m venv venv

Then, activate it:

source venv/bin/activate

Verify the correct Python version is being used:

python —version

This tutorial is working with Python version 3.12.8.

Once the virtual environment is set up, let’s download the Flask-PyMongo library.

Step 2: Download Flask-PyMongo

In your terminal and in the root directory of your project, run this command:

pip install Flask-PyMongo

When installed, double check to make sure your Flask version is greater than 3.0 and your PyMongo version is greater than 4.0.

Great! Once that’s installed, we can create our app.py file.

Step 3: Create `app.py` file

At the top, we are going to put in our imports. We are using Flask and render_template, and we are going to be importing PyMongo from flask_pymongo.

from flask import Flask, render_template 
from flask_pymongo import PyMongo

We can instantiate our Flask app name, as well:

app = Flask(__name__)

Let’s now copy in our connection string. Please keep in mind this is not encouraged for production, and ensure any sensitive information is properly protected. This is for the sake of the tutorial. For heightened security, please store the connection string in a .env file.

CONNECTION_STRING = "mongodb+srv://mongodb:<PASSWORD>@cluster0.qh7j8.mongodb.net/sample_mflix?retryWrites=true&w=majority&appName=Cluster0
"
app.config["MONGO_URI"] = CONNECTION_STRING
mongo = PyMongo(app)

Before we create our app.route, let’s first create our index.html file. Do this by creating a subfolder called templates and then a file named index.html.

Here, you can put in any CSS and HTML of your choosing for the homepage to display what we decide to return from our app.route. I am just doing a simple page where we will display the title and plot of some of the movies from our sample_mflix collection.

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Movie List</title>
</head>
<body>
   <h1>Movies</h1>
   <ul>
       {% for movie in movies %}
           <li>
               <strong>Title:</strong> {{ movie.title }} <br>
               <strong>Plot:</strong> {{ movie.plot }}
           </li>
       {% endfor %}
   </ul>
</body>
</html>

Now that we have our index.html file set up, we can do our app.route:

@app.route("/")
def home_page():
   movies_lookup = mongo.db.movies.find(
       {},
       {"title": 1, "plot": 1}
       ).limit(5)
   return render_template("index.html", movies=movies_lookup)


if __name__ == '__main__':
   app.run(debug=True)

Here, we are returning five movie titles and their plots from our sample_mflix database and movies collection.

Once this is saved, run the command:

python app.py

Head over to the link: http://127.0.0.1:5000/.

Troubleshooting: If you are having issues here with connecting, please ensure you have the proper network IP address permissions and that you have incorporated the database name (sample_mflix) in your MongoDB connection string when inputting it when prompted.

Step 4: Insert a movie

Let’s insert a new movie into our collection. To do this, we will create a add_movie form page where the user can insert a movie title and plot of their choosing.

Add in request at the top of your app.py file. We will be creating a new @app.route named /add_movie for our methods GET and POST.

Here is what our route looks like:

@app.route('/add_movie', methods=['GET', 'POST'])
def add_movie():
   if request.method == 'POST':
       # access our add_movie form
       title = request.form['title']
       plot = request.form['plot']

       # info to create a new movie title and plot
       new_movie = {
           "title": title,
           "plot": plot
       }

       # insert our new movie
       mongo.db.movies.insert_one(new_movie)

       # have our success page pop up
       return render_template('add_movie_success.html', title=title, plot=plot)

   # for GET requests to add_movie, just display the form
   return render_template('add_movie.html')

Here is what our add_movie.html looks like:

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Add a Movie</title>
</head>
<body>
   <h1>Add a New Movie</h1>
   <form method="POST" action="{{ url_for('add_movie') }}">
       <label for="title">Title:</label>
       <input type="text" id="title" name="title" required><br><br>

       <label for="plot">Plot:</label>
       <textarea id="plot" name="plot" rows="4" cols="50" required></textarea><br><br>

       <button type="submit">Add Movie</button>
   </form>
</body>
</html>

And our add_movie_success.html page:

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Movie Added</title>
</head>
<body>
   <h1>Movie added to your collection!</h1>
   <p><strong>Title:</strong> {{ title }}</p>
   <p><strong>Plot:</strong> {{ plot }}</p>
   <a href="{{ url_for('add_movie') }}">Add another movie</a>
</body>
</html>

When we run our application and go to http://127.0.0.1:5000/add_movie,
this is what we see:

Let’s add in a title and plot. For my title, I am just going to do: “Anaiya’s Lyfe”. For my plot, I am going to do: “The life of Anaiya Raisinghani”.

Once entered I will see this:

When we refresh the homepage, we aren’t able to see the new movie. The easiest fix for this is to update our homepage route so that it shows us the five most recently added in movies. Do this by sorting by our ID field. The “-1” indicates sorting by descending order.

@app.route("/")
def home_page():
   # we want the 5 most recent movies
   movies_lookup = (mongo.db.movies
       .find({}, {"title": 1, "plot": 1})
       .sort("_id", -1)
       .limit(5)
   )
   return render_template("index.html", movies=movies_lookup)

Now, when we refresh the homepage, we can see our new movie:

But oops! I misspelled the word “Life”. Let’s create a new route so that we can update this movie.

Step 5: Update a document

We are going to do this in a similar manner to when we added in a new movie. We want to create a new route named /movie_update using the methods GET and POST. We will also create two new forms in our templates folder. It’s best practice to update the document using the “_id”, but for the sake of simplicity and emphasizing the Flask-PyMongo library, we can update on movie titles. This is also because we are aware there aren’t duplicates in the sample dataset.

Let’s first create the route we want:

@app.route('/update_movie', methods=['GET', 'POST'])
def update_movie():
   if request.method == 'POST':
       # current title
       old_title = request.form['old_title'] 


       new_title = request.form['new_title']  
       new_plot = request.form['new_plot']    


       # MongoDB update_one
       result = mongo.db.movies.update_one(
           {"title": old_title}, # Filter to find the existing document
           {"$set": {"title": new_title, "plot": new_plot}} # Fields to update
       )


       # show us what we changed
       return render_template(
           'update_movie_success.html',
           old_title=old_title,
           new_title=new_title,
           new_plot=new_plot
       )


   # for GET requests to update_movie, just display the form
   return render_template('update_movie.html')

Our update_movie.html will look like this:

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Update Movie</title>
</head>
<body>
   <h1>Update a Movie</h1>
   <form action="/update_movie" method="POST">
       <label for="old_title">Current Title:</label>
       <input type="text" id="old_title" name="old_title" required><br><br>


       <label for="new_title">New Title:</label>
       <input type="text" id="new_title" name="new_title"><br><br>


       <label for="new_plot">New Plot:</label><br>
       <textarea id="new_plot" name="new_plot" rows="4" cols="50"></textarea><br><br>


       <button type="submit">Update Movie</button>
   </form>
</body>
</html>

And our update movie success page will look like this:

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Movie Updated</title>
</head>
<body>
   <h1>Movie has been updated!</h1>
   <p><strong>Old Title:</strong> {{ old_title }}</p>
   <p><strong>New Title:</strong> {{ new_title }}</p>
   <p><strong>New Plot:</strong> {{ new_plot }}</p>


   <a href="{{ url_for('home_page') }}">Go back to Homepage</a>
</body>
</html>

When we head over to http://127.0.0.1:5000/update_movie, we will see this form:

Now, we can put in our current title, “Anaiya’s Lyfe”, and change the title to “Anaiya’s Life”. We can put whatever we like in the plot, or we can keep it the same.

Click on the “Go back to Homepage” button and we will see our change reflected!

Step 6: Delete a document

Now, let’s see how we can delete this movie. I’ve decided I no longer want it in my collection.

We can do this again by creating a new route for delete_movie.

@app.route('/delete_movie', methods=['GET', 'POST'])
def delete_movie():
   if request.method == 'POST':
       title = request.form['title']

       # using delete_one
       mongo.db.movies.delete_one({"title": title})

       return render_template('delete_movie_success.html', title=title)

   # for GET requests to delete_movie, just display the form
   return render_template('delete_movie.html')

Here, we are just rendering a form so that we can put in the title of the movie we want to delete. Then, we are making sure we get a page saying we were successful with deleting the movie.

Here are the form pages.

delete_movie.html:

<!DOCTYPE html>
<html>
<head>
   <meta charset="UTF-8">
   <title>Delete Movie</title>
</head>
<body>
   <h1>Delete a Movie</h1>
   <form action="/delete_movie" method="POST">
       <label for="title">Movie Title to Delete:</label>
       <input type="text" id="title" name="title" required><br><br>
       <button type="submit">Delete Movie</button>
   </form>
</body>
</html>

delete_movie_success.html:

<!DOCTYPE html>
<html>
<head>
   <meta charset="UTF-8">
   <title>Movie Deleted</title>
</head>
<body>
   <h1>Movie has been successfully deleted!</h1>
   <p>The movie with title "{{ title }}" has been deleted.</p>
   <a href="{{ url_for('home_page') }}">Go back to Homepage</a>
</body>
</html>

Go to http://127.0.0.1:5000/delete_movie.

Now, we can enter in our title, “Anaiya’s Life”, and hit “Delete Movie”.

When your movie has been successfully deleted, you will see this page. Now, click on the homepage and let’s double check that our movie has been removed from the list.

Our movie has been deleted!

Conclusion

In this tutorial, we have successfully created a basic CRUD application using the Flask-PyMongo library. We have seen how intuitive it is to get up and running with the library!

For more information, please visit the docs.

For any questions, please reach out to us in the Developer Forum.

Let’s Switch Things Up: Using MongoDB in an Intro Django Project

Anaiya — Mon, 03 Feb 2025 14:00:00 +0000

This article is written by Anaiya Raisinghani (Developer Advocate @ MongoDB)

Learning how to create your first Django application has never been easier—there is a vast number of resources for developers to follow, and we all know the best way to learn is by example. In this tutorial, we will go through one of the most popular Django tutorials, located on Django’s documentation site, named Writing your first Django app. But this tutorial comes with a twist: Instead of following the tutorial exactly, we will be implementing our django-mongodb-backend library where appropriate.

We will be taking you through the first two parts of this journey, since that is where the implementation will matter most. Once MongoDB is correctly configured as your database, you’ll be able to work with all the Django commands you know and love, without any other configurations.

Before we dive into the tutorial, let’s cover what this library is and why a developer would want to use Django and MongoDB together.

A summary of Django MongoDB Backend

This library, django-mongodb-backend, is a third-party database that integrates seamlessly with Django! Why would a Django developer want to use this library? It aligns with all the familiar steps and commands that Django developers are already accustomed to using in their projects, so besides defining the database backend engine when creating the application, there are no other configuration steps developers need to follow to get up and running.

This process is smooth because MongoDB is committed to supporting as many of Django’s fundamentals as possible. These features include but are not limited to: querying data through the Django QuerySet API, the Django admin panel, representing MongoDB documents through Django models, and more.

Why use a NoSQL database with Django?

There are a variety of reasons why a developer would prefer to use MongoDB in their Django project. MongoDB’s document model, its robust ecosystem of tools, and its inherent competitive advantage set it as a pioneer in the space. While Django and relational databases are the typical pair, using Django with MongoDB will truly accelerate your application.

While Django is known for its simplicity and rapid development, MongoDB completely simplifies data modeling. With these two in tandem—MongoDB as the database back end and Django as the web framework—developers can fully commit to building complex applications instead of starting from square one.

With all this in mind, let’s dive in!

Tutorial pre-reqs

An understanding of the django-mongodb-backend library
A MongoDB Atlas account
An IDE of your choosing—we are using VS Code
Python 3.10 or above

Create your MongoDB cluster

Our first step is to create our MongoDB cluster. We will be using the free tier. Please ensure the “Network Settings” in the cluster are correctly set up. This means making sure your IP address is included in the list of trusted addresses, or setting your cluster access to “Access from Anywhere." Please keep in mind “Access from Anywhere” is not encouraged for secure information, but for the sake of this tutorial, it will be fine. Ensure a secure username and password are set, as well. Once the cluster has been configured, copy and paste the connection string in a safe place as we will use it throughout the tutorial.

Once your cluster has been created, we can start.

Part 1: Basic request and response flow

Before we can get started, we need to create a virtual environment. This is crucial to ensure we can use isolated Python installations for various projects. Go ahead and run the commands below to create your virtual environment:

python3.12 -m venv venv

Then run:

source venv/bin/activate

Once you see the (venv) next to your directory name in your terminal, you’ll know that you correctly configured your virtual environment. Make sure that your Python version is correct (or 3.10 and above) by double checking with:

python —-version

Now, we can install Django 5.0. We can do this and install the MongoDB integration in the same step to make things easier for ourselves when we reach the database connection step.

pip install django-mongodb-backend

This will install both PyMongo and Django since we will need both for the integration. Once the install has completed successfully, we can create a new Django project:

django-admin startproject quickstart --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/5.0.x.zip

Please make sure the leading version numbers align with the Django version installed—e.g., the link above is for version 5.0.

This will be the structure of your new Django project.

Let’s test the development server to ensure that our Django project works. Make sure you’re in the quickstart root and run this line:

python manage.py runserver

If run correctly, the development server will start:

When you click on the link, you’ll see this page. Congratulations!

The Django development server has been correctly created. It’s a lightweight web server specifically built for rapid development.

Now that we know our environment is correctly configured, we can start building our actual project.

Creating the Polls app

Make sure that you’re in the same directory where you ran the server and run this command:

python manage.py startapp polls --template https://github.com/mongodb-labs/django-mongodb-app/archive/refs/heads/5.0.x.zip

This command created the directory polls. It looks like this.

Now, let’s write our first view! Open up the polls/views.py file and copy in the following code:

from django.http import HttpResponse
from django.shortcuts import render


def index(request):
  return HttpResponse("Hello! You've reached the Django MongoDB sample app landing page.")

This is our very basic view. Now, let’s access it in the browser. To do this, we need to map it to a URL. To define our URL configuration, create a file under the polls application named urls.py. Insert the following:

from django.urls import path


from . import views


urlpatterns = [
   path("", views.index, name="index"),
]

Please ensure your app directory looks like this:

Now, we need to configure our global URL configuration from our quickstart project to include the URL configuration that we just defined in our polls.urls. So we can do this by adding in an import for django.urls.include in quickstart/urls.py and inserting an include() in the urlspatterns list.

Here is the code to copy into our quickstart/urls.py file:

from django.contrib import admin
from django.urls import include, path


urlpatterns = [
   path("polls/", include("polls.urls")),
   path("admin/", admin.site.urls),
]

In this code snippet, the path() function expects at least two arguments, route and view. The include() function is for referencing the URL configurations.

You have successfully configured an index view into the URL configuration. Let’s ensure it’s working by running the server:

python manage.py runserver

Make sure you go to http://localhost:8000/polls/ in your browser and you’ll see the text that we defined from above!

Now that we have completed the basic request and response flow, let’s start incorporating our MongoDB database.

Part 2: Database set-up

Open up the quickstart/settings.py file. Head over to the DATABASES setting. Since we created our cluster through MongoDB Atlas, we can use the django_mongodb_backend.parse_uri(MONGODB_URI) function to parse in our connection string.

DATABASES = {
   "default": django_mongodb_backend.parse_uri(mongodb+srv://<username>:<password>@samplecluster.jkiff1s.mongodb.net/<database_name>?retryWrites=true&w=majority&appName=SampleCluster),
}
DATABASES["default"]["NAME"] = "pollsproject"

Make sure to specify the name of your database. This was created above when spinning up our cluster.

Take a look at the INSTALLED_APPS setting above where we just enabled our database configuration. By default, we have these six:

INSTALLED_APPS = [
   'quickstart.apps.MongoAdminConfig',
   'quickstart.apps.MongoAuthConfig',
   'quickstart.apps.MongoContentTypesConfig',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
]

Notice how instead of the traditional Django apps, we have MongoDB apps. django.contrib.admin has been replaced withquickstart.apps.MongoAdminConfig. django.contrib.auth has been replaced with quickstart.apps.MongoAuthConfig, and instead of django.contrib.contenttypes, we have quickstart.apps.MongoContentTypesConfig.

These are MongoDB versions of various Django apps. Each app that is included in our INSTALLED_APPS setting references the corresponding AppConfig.

Now, we need to run our migrate command to specifically create our history. For each migration we create, it will create a database and a collection. Our database name has been specified when we connected to our MongoDB database. We will be able to see a message for each migration that gets applied.

Now, run this command:

python manage.py migrate

When this command is run successfully, you will see this:

(venv) anaiya.raisinghani@M-FQJJWDQ4CK quickstart % python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying sessions.0001_initial... OK
(venv) anaiya.raisinghani@M-FQJJWDQ4CK quickstart %

Inside of our MongoDB Atlas cluster, we are able to see the collections created for each of the installed Django apps and their models. This includes auth-related collections, like users, groups, permissions, session management, and migrations tracking.

This indicates Django is successfully using MongoDB as the database back end and is creating the necessary collections for our apps!

Creating models

Now that our database has been successfully configured, we can define our models. This is the layout of our database.

Following along in the tutorial for our poll app, we will create a Question model and a Choice model. Our Question model has a question along with a publication date. The Choice model has two fields: the text field and a vote tally. Every single Choice is associated with a Question.

To incorporate these models, we will need to edit our polls/models.py file. Copy in the below code:

from django.db import models




class Question(models.Model):
   question_text = models.CharField(max_length=200)
   pub_date = models.DateTimeField("date published")




class Choice(models.Model):
   question = models.ForeignKey(Question, on_delete=models.CASCADE)
   choice_text = models.CharField(max_length=200)
   votes = models.IntegerField(default=0)

This code here tells Django to create a database schema we can use to access the QuerySet API for Question and Choice objects.

Let’s head over and activate our models so we can install the polls app.

For more information on the fields specified, please check out the Django project tutorial.

Activating our models

To include our app, we need to add it to the INSTALLED_APPS in the settings file. Since the class we are working with is called PollsConfig and it’s in the polls/apps.py file, the path is polls.apps.PollsConfig.

Head over to the quickstart/settings.py file and add this path to the INSTALLED_APPS setting. Once done, it will look like this:

INSTALLED_APPS = [
   'polls.apps.PollsConfig',
   'quickstart.apps.MongoAdminConfig',
   'quickstart.apps.MongoAuthConfig',
   'quickstart.apps.MongoContentTypesConfig',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
]

This lets Django know to install the polls app.

Run this command:

python manage.py makemigrations polls

Your output will look like this:

makemigrations allows Django to know the models have been created and these changes are going to be stored as a migration.

The way Django stores changes to models is through migrations, which is why they are crucial for applications. Reading the migration for a new model can be done through the sqlmigrate command. Even though we are using MongoDB as our database, with the django-mongodb-backend library, all Django commands are the same, making it easier than ever to get started. Run the command below to see the structure of our migration for our new model under polls/migrations/0001_initial.py:

python manage.py sqlmigrate polls 0001

Something very similar to the screenshot below will be produced through this command.

The output after this command will be different depending on the database decided on. This is what it will look like when utilizing MongoDB as your back end.

Let’s create our models in our database. Do this by running migrate again:

python manage.py migrate

We get this result:

Once this command has been run, check the polls/migrations/0001_initial.py file. It will look like this:

# Generated by Django 5.0.11 on 2025-01-21 23:34


import django.db.models.deletion
import django_mongodb_backend.fields
from django.db import migrations, models




class Migration(migrations.Migration):


   initial = True


   dependencies = [
   ]


   operations = [
       migrations.CreateModel(
           name='Question',
           fields=[
               ('id', django_mongodb_backend.fields.ObjectIdAutoField(primary_key=True, serialize=False)),
               ('question_text', models.CharField(max_length=200)),
               ('pub_date', models.DateTimeField(verbose_name='date published')),
           ],
       ),
       migrations.CreateModel(
           name='Choice',
           fields=[
               ('id', django_mongodb_backend.fields.ObjectIdAutoField(primary_key=True, serialize=False)),
               ('choice_text', models.CharField(max_length=200)),
               ('votes', models.IntegerField(default=0)),
               ('question', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='polls.question')),
           ],
       ),
   ]

As we can see, instead of Django’s BigAutoField or AutoField for our IDs, we have django_mongodb_backend.fields.ObjectIdAutoField.

Playing with the API

Pull up the Python shell with this command:

python manage.py shell

Import the model classes we just wrote with:

>>> from polls.models import Choice, Question

Take a look and check which questions are in the system:

# No questions are in the system yet.
>>> Question.objects.all()

There are none so this will be the response:

<QuerySet []>

Let’s create a new question.
First, import the timezone and ask a question:

>>> from django.utils import timezone
>>> q = Question(question_text="What's new?", pub_date=timezone.now())

Go ahead and save:

>>> q.save()

Take a look at the ID:

>>> q.id

The ID comes up as:

ObjectId('67903543e362728a32306c98')

Now, let’s take a look at the question we just created:

>>> q.question_text

We will see the question we asked:

"What's new?"

Let’s change the question by changing our attributes. Remember to call save() when done.

>>> q.question_text = "What's up?"
>>> q.save()

Let’s display all the questions we currently have in our database:

>>> Question.objects.all()
<QuerySet [<Question: Question object (67903543e362728a32306c98)>]>

We are able to see the ID, but that isn’t helpful for readability. Close the shell using exit().

Let’s add a string method to both our Question and Choice in our polls/models.py file:

import datetime


from django.db import models
from django.utils import timezone


class Question(models.Model):
   question_text = models.CharField(max_length=200)
   pub_date = models.DateTimeField("date published")


   def was_published_recently(self):
       return self.pub_date >= timezone.now() - datetime.timedelta(days=1)


   def __str__(self):
       return self.question_text






class Choice(models.Model):
   question = models.ForeignKey(Question, on_delete=models.CASCADE)
   choice_text = models.CharField(max_length=200)
   votes = models.IntegerField(default=0)


   def __str__(self):
       return self.choice_text

Let’s save our changes and start a new Python shell. Do this by running:

python manage.py shell

Check and see if our __str__() addition worked and if we are able to see the question asked from above:

>>> from polls.models import Choice, Question
>>> Question.objects.all()
<QuerySet [<Question: What's up?>]>

We are also able to view questions that start with specific keywords:

>>> filter = Question.objects.filter(question_text__startswith="What")
>>> filter
<QuerySet [<Question: What's up?>]>

We can also access the question through its ID:

>>> q = filter.first()
>>> Question.objects.get(pk=q.id)
<Question: What's up?>

Now, let’s give the question some choices.

We can display choices from our related object set (we do not have any so far):

>>> q.choice_set.all()
<QuerySet []>

Let’s create three choices:

>>> q.choice_set.create(choice_text="Not much", votes=0)
<Choice: Not much>
>>> q.choice_set.create(choice_text="The sky", votes=0)
<Choice: The sky>
>>> c = q.choice_set.create(choice_text="Just hacking again", votes=0)

We are able to have API access to our related question objects:

>>> c.question
<Question: What's up?>

And we are able to allow our question objects to have access to our choice objects:

>>> q.choice_set.all()
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>
>>> q.choice_set.count()
3

Now, let’s delete one of the choices we created. We can use delete() to accomplish this:

>>> c = q.choice_set.filter(choice_text__startswith="Just hacking")
>>> c.delete()
(1, {'polls.Choice': 1})

Exit the shell with exit().

Cool! Now, let’s head onto configuring the Django admin page.

Django admin page

To make things easier for developers, Django entirely automates the creation of admin sites for models. Please keep in mind that this admin site is not intended for all users, only site managers.

First, let’s create an admin user:

python manage.py createsuperuser

This will prompt for a Username, an Email address, and a Password. The Password will prompt twice:

Username: admin
Email address: admin@example.com
Password: **********
Password (again): *********
Superuser created successfully.

Once all the information is in, we can start the development server. Run the command below:

python manage.py runserver

Access the website: http://127.0.0.1:8000/admin/.
Here, there will be this admin screen:

Here, we can see our groups and users. These were provided through our 'quickstart.apps.MongoAuthConfig

Now, let’s make our poll app modifiable from this admin page. First, edit the polls/admin.py file to match the code below:

from django.contrib import admin
from .models import Question
admin.site.register(Question)

Once this file is saved, refresh the Django admin site and the Questions will be registered:

Now, we are free to edit the questions, if we wish!

Conclusion

In this tutorial, we covered the first two parts of the popular Django Getting Started tutorial. Instead of following the tutorial exactly, we changed up important aspects to integrate the new django-mongodb-backend library so we could use MongoDB as our database. We went over a ton of crucial information:

Creating a Django project
Starting up the development server
Creating an app within a project
Creating a view
Setting up the database
Creating models
Activating models
Interacting with the API
Interacting with Django’s admin interface

For more information on the django-mongodb-backend library, check out our GitHub, and please refer any questions to our Developer Forum!

The Key Benefits of Using a NoSQL Database in Django Development

Anaiya — Mon, 03 Feb 2025 14:00:00 +0000

This article is written by Anaiya Raisinghani (Developer Advocate @ MongoDB)

Those who are familiar with Django know how easy it is to create complex applications with just a few lines of code, but what happens when an application suddenly needs to scale? Or if it becomes necessary to incorporate vector search queries to stay ahead of competitors? Or if an application needs massive structural changes but can’t afford the downtime? For years, Django and relational databases have been a trustworthy pair, but let’s change things up and enter into a new era: Django with a document database like MongoDB.

There are a multitude of benefits of using a NoSQL database like MongoDB while building complex applications with Django. Let’s go over some of them.

Let’s cover our basics…

What is a NoSQL database?

A non-relational database is what’s most commonly referred to as a NoSQL database. This has to do with how data is stored inside the database—a non-relational database stores data in a non-tabular format and can be described as more flexible than a traditional, SQL-based relational database. How does this format make it more flexible? Take MongoDB’s document model approach as an example: Data is stored as documents, and these documents store data in a JSON format with a flexible schema. This flexibility allows MongoDB to effectively store and manage structured, semi-structured, and unstructured data, a capability where traditional relational databases often fall short. This key advantage to NoSQL databases allows for constant evolving and adaptation when working with data, since they support diverse data models and changing data requirements.

What is Django?

Django is a Python web framework known for helping developers build web applications as quickly as possible, while keeping development clean and maintainable. It’s especially known for its “batteries included” design—a way to implement a multitude of standard webserver capabilities through various mechanisms that developers need to build their applications, making it so developers don’t need to code crucial steps from scratch! Some of these mechanisms are: generating frontend HTML, handling session management, managing database connections, and handling route resolution.

Many of these mechanisms listed have a typical SQL back end, but what if these commonly used callbacks were replaced with MongoDB’s querying syntax? Keep reading to understand the benefits of using a NoSQL database with Django, and the incredible possibilities available for developers.

An overview of Django-MongoDB-Backend and the launch

Our library, django-mongodb-backend, is a third-party database back end that integrates seamlessly with Django. When a developer defines the database backend engine when creating their application, they can go ahead and specify a custom back end—such as django_mongodb_backend. As long as django-mongodb-backend is installed in your Python environment, Django will connect without issues.

django-mongodb-backend aligns with the familiar steps Django developers know and love. This process is smooth, particularly because MongoDB is determined to support as much of Django’s core features as possible. Some of these features include programmatic database connectivity in settings, representing MongoDB documents through Django models, querying data through the Django QuerySet API, the Django admin panel, etc.

Now that we’re familiar with the purpose of our library, let’s get into why developers should try it out.

Key benefits of using MongoDB with Django

MongoDB's document model
Data platform capability with MongoDB Atlas:
- Deploy anywhere, build and scale quickly without the hassle of managing infrastructure
- World class security/encryption
- Atlas Search
Advanced search and AI capabilities right out of the box:
- Leverage our native AI integrations for most popular AI frameworks such as LangChain, LlamaIndex, and Haystack
- Vector Search
Aggregation framework:
- Leverage MongoDB's powerful aggregation framework to perform complex queries and generate real-time analytics
Robust ecosystem of tools to provide world class developer experience

MongoDB’s document model

MongoDB’s document model is what sets it apart from other databases, but at its core, it aligns particularly well with Django’s proud mission—to ensure fast development while keeping the overall design clean. It truly is a natural fit for Django developers because it allows an intuitive way to map Django models to MongoDB documents, as the document model is all about storing and retrieving your data in a way that developers already think and work. MongoDB will allow for Django developers to create their models in a whole different way—developers won’t need to utilize JOINs in various use cases, as data that is accessed together should be stored together.

Just as Django is known for its rapid development and simplistic design, MongoDB truly simplifies data modeling. Hand in hand, with Django as the framework and MongoDB as the database, developers can focus on building full, complex applications instead of struggling with creating everything from scratch. The great advantage with this pair is developers can deal with any hierarchical data, semi-structured data, or rapidly evolving data, and MongoDB will store it in a way that feels natural.

Data platform capability

MongoDB isn’t just limited to how data is stored. With MongoDB Atlas, developers can help make managing data seamless through incredible features like Atlas Search for full-text and vector search capabilities. For more complex applications, MongoDB’s aggregation framework helps developers with difficult queries, transformations, and various analytics, directly on their data.

For a local project, creating an Atlas deployment using Docker is easier than ever! Developers can spin up a single-node replica set by pulling the Docker image and running it with an Atlas connection string. Already have an existing Atlas implementation? No worries, it’s possible to convert that into a local image if it’s running in Docker Compose. All developers need are the Atlas CLI and Docker to create with Django and MongoDB.

Developers can also feel fully confident in the security of their data with MongoDB. Our platform offers incredible encryption features, ensuring data is protected in transit, at rest, and in use. With client-side field-level encryption and queryable encryption, a developer's data protection needs will be fully accounted for throughout the entire data lifecycle.

With the flexibility of the document model, the power of MongoDB’s expansive data platform, and advanced tools, developers can truly build incredible applications.

Advanced search and AI capabilities

It’s crucial to stay competitive. MongoDB makes it easy to build incredibly powerful and competitive artificial intelligence applications. With our seamless integrations with frameworks like LangChain, LlamaIndex, and Haystack, developers can stay ahead of the game and build AI-powered chatbots, personalized recommendation engines, and so much more.

Our search capabilities are not isolated to full-text search. MongoDB covers all vector search and hybrid search needs. With MongoDB’s full-featured vector database capabilities, developers can truly stay ahead of the game by enabling intelligent semantic search over any kind of unstructured data, whether that is text, images, or audio. The opportunity to explore the combined power of vectors, MongoDB, and Django is truly only one pip install away.

For applications that require real-time data, MongoDB is meant to help deliver speed, scalability, and reliability. From instant data retrieval, to supporting high-performance applications with no required downtime, applications are built to stay responsive and ready to meet modern demands. The intersection of MongoDB and Django can truly raise the bar: Developers will have the flexibility and scalability of a NoSQL database while greatly benefiting from Django’s development framework.

Aggregation framework

Have a Django application with a lot of data and want to receive computed results from various records? The MongoDB aggregation framework can help. By using the built-in operators available, developers are able to do various complex analytics on servers that are already in use—no need to incorporate a third-party platform. The aggregation pipeline in MongoDB allows for robust data transformation and consolidated results from any collection of data.

Robust ecosystem of tools

MongoDB allows for Django developers to build how, when, and wherever they need, whether it’s with the open-source MongoDB Community or the fully managed MongoDB Atlas platform. There truly is a deployment option available for every developer, such as those who are trying a new project on the side with our free cloud database cluster, or those interested in creating enterprise-grade solutions.

Storing and querying data is just the tip of the iceberg when it comes to building applications. MongoDB offers a robust ecosystem of tools that are specifically designed to help enrich the development experience and truly simplify interactions with data. Whether a developer is working in VS Code with the MongoDB extension, using JetBrain’s Database Tools in PyCharm, or coding with the MongoDB Shell and Atlas CLI, MongoDB has everything you need to interact with your data. And for those developers who prefer a more intuitive database experience, MongoDB Compass is the answer. With tools like mongoimport and mongoexport, data management is incredibly simple, as well.

When a developer works with MongoDB, they are not just working with a database—they are working with a robust ecosystem of tools designed to enhance the entire development process from start to finish.

Best practices for implementing NoSQL with Django

To get started with using our django-mongodb-backend library, please check out our GitHub repo and our Quickstart for further direction.

Conclusion

This integration between Django and MongoDB is what developers need! The combination of MongoDB’s document model, vast ecosystem of tools, and advanced features like Atlas Search and AI integrations allows for Django developers to build complicated apps, simply. With the django-mongodb-backend library, integrating a NoSQL database into a Django project has never been easier. Everything is fully taken care of in the back end so Django developers can still use the same commands they’re used to, allowing for an easy transition from a relational to a non-relational database. Please keep in mind that our integration is currently in Public Preview and is only recommended for testing purposes.

Try it out for yourself today and let us know your thoughts in our Developer Forum!

Django MongoDB Backend Quickstart

Anaiya — Mon, 03 Feb 2025 14:00:00 +0000

This article is written by Anaiya Raisinghani (Developer Advocate @ MongoDB) and Nora Reidy (Technical Writer @ MongoDB)

Interested in diving into our Django MongoDB Backend integration? Follow along with this quickstart to create a Django application, connect that application to a MongoDB deployment, ensure your deployment is hosted on MongoDB Atlas, and interact with the data stored in your database using simple CRUD operations.

What is Django?

Let’s first go over what Django is. Django is a high speed model view controller framework for building web applications. There are a ton of key benefits of utilizing Django in projects, such as rapid development, a variety of services to choose from, great security, and impressive scalability. Django prides itself on being the best framework for producing flawless work efficiently. As we’ll see throughout this quickstart, it’s incredibly simple to get up and running with our Django MongoDB Backend integration.

Pre-requisites

To be successful with this quickstart, you’ll need a handful of resources:

An IDE. This tutorial uses Visual Studio Code.
Python 3.10 or later. We recommend using 3.12 in the environment.
A MongoDB Atlas cluster.

Create your MongoDB cluster

Please follow the steps to create a MongoDB cluster on our free tier cluster which is free forever. Please make sure that the “Network Settings” are correctly set up for easy connection to the cluster, and that a secure username and password have been chosen. Once the cluster is configured, please make sure the connection string is in a safe place for later use.

Load in the sample data to the cluster, and in the connection string, specify a connection to the sample database we are using, sample_mflix. Do this by adding the name of the database after the hostname, as shown in the code snippet below:

mongodb+srv://<username>:<password>@samplecluster.jkiff1s.mongodb.net/<database_name>?retryWrites=true&w=majority&appName=SampleCluster

Now that our cluster is ready, we can create our virtual environment!

Create your virtual environment

Our first step is to create our Python virtual environment. Virtual environments allow us to keep the necessary packages and libraries for a specific project in the correct environment without having to make changes globally that could impact other projects.

To do this, run:

python3.12 -m venv venv

Then, run:

source venv/bin/activate

Once the (venv) is next to the directory name in the terminal, the virtual environment is correctly configured. Make sure that the Python version is correct (3.10 and above) by double checking with:

python —version

Once the virtual environment is set up, we can install our Django integration!

Installing Django MongoDB Backend

To install the Django integration, please run the following command from the terminal:

pip install django-mongodb-backend

If both PyMongo and Django are installed in the environment, please ensure that the PyMongo version is between 4.6 and 5.0, and that the Django version is between 5.0 and 5.1.

When correctly run, this is what we’ll see in our terminal:

Once this step is complete, our integration is correctly downloaded along with the dependencies that include Django and PyMongo required for success.

Create your Django project!

We’re all set up to create our Django project. This django-mongodb-project template is about the same as the default Django project template, with a couple important changes. It includes MongoDB-specific migrations, and the settings.py file has been modified to make sure Django uses an ObjectId value for each model’s primary key. It also includes MongoDB-specific app configurations for Django apps that have default_auto_field set. This library allows us to create our own apps so we can set django_mongodb_backend.fields.ObjectIdAutoField.

Run this command to create a new Django project called quickstart:

django-admin startproject quickstart --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/5.0.x.zip

Once this command is run, it will show up on the left-hand side of the project file:

Once you can see the quickstart project, it’s time to update our database settings. To do this, go to the settings.py file under the quickstart folder and head over to the DATABASES setting. Replace the ”<connection string URI>” with the specific cluster URI including the name of the sample database:

DATABASES = {
  "default": django_mongodb_backend.parse_uri("<connection string URI>"),
}

Now, we can make sure that we have correctly installed the Django MongoDB Backend and our project is properly set up. Make sure to be in the quickstart folder and run this command:

python manage.py runserver

Click on the link or visit http://127.0.0.1:8000/. At this page, there will be a “Congratulations!” and a picture of a rocket:

Now that we know our setup has been successful, we can go ahead and create an actual application where we can interact with the sample data we previously downloaded! Let’s dive in.

Creating an application for our “sample_mflix” data

We are first going to create our sample_mflix application. Head into the root directory of your project and run this command to create an application based on our custom template:

python manage.py startapp sample_mflix --template https://github.com/mongodb-labs/django-mongodb-app/archive/refs/heads/5.0.x.zip

The django-mongodb-app template makes sure that your apps.py file includes the line: “default_auto_field = ‘django_mongodb.fields.ObjectIdAutoField’”. This ensures that instead of using the original Django BigAutoField for IDs, we are using MongoDB’s specific ObjectId feature.

Once you create your project, we are going to create models for our movie, viewer, and award data.

Create models for our movie, viewer, and award data

To create data models, all we have to do is open up our models.py file inside of our newly created sample_mflix directory and replace the entire file with the following code.

from django.db import models
from django.conf import settings
from django_mongodb_backend.fields import EmbeddedModelField, ArrayField
from django_mongodb_backend.models import EmbeddedModel

class Award(EmbeddedModel):
    wins = models.IntegerField(default=0)
    nominations = models.IntegerField(default=0)
    text = models.CharField(max_length=100)

class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    awards = EmbeddedModelField(Award, null=True, blank=True)
    genres = ArrayField(models.CharField(max_length=100), null=True, blank=True)

    class Meta:
        db_table = "movies"
        managed = False

    def __str__(self):
        return self.title

class Viewer(models.Model):
    name = models.CharField(max_length=100)
    email = models.CharField(max_length=200)

    class Meta:
        db_table = "users"
        managed = False

    def __str__(self):
        return self.name

The Movie model here represents our sample_mflix.movies collection and stores information about various movies! The Viewer model, on the other hand, represents the sample_mflix.users collection and stores important user details for a movie streaming platform. The Award model represents the embedded document values that are stored in the Movie model.

Once this is done and the models.py file is saved, let’s create views to display our data.

Create views to display our data

To display data from the sample_mflix database, we’ll add views to the views.py file. Open it up from your sample_mflix directory and replace the contents with the code below.

Here, we are displaying a landing page message and information about the Movie and Viewer models we configured above:

from django.http import HttpResponse
from django.shortcuts import render

from .models import Movie, Viewer

def index(request):
   return HttpResponse("Hello, world. You're at the application index.")

def recent_movies(request):
   movies = Movie.objects.order_by("-released")[:5]
   return render(request, "recent_movies.html", {"movies": movies})

def viewers_list(request):
   viewers = Viewer.objects.order_by("name")[:10]
   return render(request, "viewers_list.html", {"viewers": viewers})

Once we have finished this section, we are ready to move on and configure URLs for our views.

Configure URLs for our views

To be successful in this section, we need to create a new file called urls.py inside of our sample_mflix directory. This file maps the views we defined in the previous step to dedicated URLs.

Copy the code below into this new file:

from django.urls import path

from . import views

urlpatterns = [
   path("recent_movies/", views.recent_movies, name="recent_movies"),
   path("viewers_list/", views.viewers_list, name="viewers_list"),
   path("", views.index, name="index")
]

Once that has been copied in, we can go ahead to our quickstart/urls.py file and replace the file’s content with the code below:

from django.contrib import admin
from django.urls import include, path

urlpatterns = [

   path("admin/", admin.site.urls),
   path("", include("sample_mflix.urls")),
]

Once we’ve finished replacing the file’s content, we can create templates to properly format our data.

Create templates to format your data

First, create a templates subdirectory inside of the sample_mflix directory. Once this subdirectory is created, create a recent_movies.html file inside of it. We are going to copy in the following code to format the movie data requested by the recent_movies view:

<!-- templates/recent_movies.html -->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Recent Movies</title>
</head>
<body>
  <h1>Five Most Recent Movies</h1>
  <ul>
     {% for movie in movies %}
           <li>
              <strong>{{ movie.title }}</strong> (Released: {{ movie.released }})
           </li>
     {% empty %}
           <li>No movies found.</li>
     {% endfor %}
  </ul>
</body>
</html>

Create another file in this same templates subdirectory and call it viewers_list.html. This template formats the user data that is requested by our viewers_list view. Copy in the following code:

<!-- templates/viewers_list.html -->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Viewers List</title>
</head>
<body>
  <h1>Alphabetical Viewers List</h1>
  <table>
     <thead>
           <tr>
              <th>Name</th>
              <th>Email</th>
           </tr>
     </thead>
     <tbody>
           {% for viewer in viewers %}
              <tr>
                 <td>{{ viewer.name }}</td>
                 <td>{{ viewer.email }}</td>
              </tr>
           {% empty %}
              <tr>
                 <td colspan="2">No viewer found.</td>
              </tr>
           {% endfor %}
     </tbody>
  </table>
</body>
</html>

Now that your templates are in place, we can include our application inside of our project!

Including our application inside of our project

To do this, head over to the settings.py file nested in the quickstart directory and edit the INSTALLED_APPS section to look like this:

INSTALLED_APPS = [
   'sample_mflix.apps.SampleMflixConfig',
   'quickstart.apps.MongoAdminConfig',
   'quickstart.apps.MongoAuthConfig',
   'quickstart.apps.MongoContentTypesConfig',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
]

Once that has been done, we can create migrations for our new models.

Create migrations for your new models

We want to create migrations for our Movie, Award, and Viewer models and apply all these changes to the database. Head back to the root of your project and run the below commands:

python manage.py makemigrations sample_mflix
python manage.py migrate

Once the migrations are created, we have a basic Django MongoDB backend application! We can use this simple application to interact with our sample_mflix database. This means running basic CRUD operations on the data.

So, let’s go over how to do that.

Write data

We are going to be working with a Python shell, so head back into the project’s root directory and bring up the shell with this command:

python manage.py shell

Once you’re in your shell, we can import the necessary classes and modules for creating a datetime object. Do this by running the code below:

from sample_mflix.models import Movie, Award, Viewer
from django.utils import timezone
from datetime import datetime

Now, we’re ready to insert a movie into our database! We can do this by running the code below to create a Movie object that stores data about a movie named “Minari”, including its awards:

movie_awards = Award(wins=122, nominations=245, text="Won 1 Oscar")
movie = Movie.objects.create(
   title="Minari",
   plot="A Korean-American family moves to an Arkansas farm in search of their own American Dream",
   runtime=217,
   released=timezone.make_aware(datetime(2020, 1, 26)),
   awards=movie_awards,
   genres=["Drama", "Comedy"]
)

This Movie object actually stores incorrect data about the movie: the runtime value is listed as 217, but the correct value is 117.

Let’s fix this by running the code below:

movie.runtime = 117
movie.save()

Now, let’s insert a viewer into our database as well. We can do this by creating a Viewer object that stores data about a viewer named “Abigail Carter”. Run the following code to do so:

viewer = Viewer.objects.create(
   name="Abigail Carter",
   email="abigail.carter@fakegmail.com"

)

Let’s delete a Viewer object. A movie viewer by the name of “Alliser Thorne” is no longer a member of the movie streaming service. To remove this viewer, run the code below:

old_viewer = Viewer.objects.filter(name="Alliser Thorne").first()
old_viewer.delete()

Once that’s done, exit your shell using this command:

exit()

Ensure we are in the quickstart directory, and start the server using this command:

python manage.py runserver

Great! We can now go and make sure our Movies model was correctly inserted into the database. Do this by accessing the link:
http://127.0.0.1:8000/recent_movies/

This is what you’ll see, with our latest movie right on top:

Let’s check our Viewer model, as well. Visit the link: http://127.0.0.1:8000/viewers_list/.

There will be a list of 10 viewer names in our database. “Abigail Carter” will be at the top and the viewer “Alliser Thorne” will have been deleted:

Once these steps have been completed, documents in the sample_mflix sample database will have been inserted and edited.

Now, we can query the data inside of our database.

Reading back our data

Open up your Python shell again, and please make sure that you have imported the necessary modules from when you first created the Python shell back under the step, “Write Data.”

from sample_mflix.models import Movie, Award, Viewer
from django.utils import timezone
from datetime import datetime

Once your shell is ready to go, we can query our users collection for a specific email.

We want to query our sample_mflix.users collection for a user with the email ”jason_momoa@gameofthron.es”. Do this by running the following:

from sample_mflix.models import Movie, Viewer

Viewer.objects.filter(email="jason_momoa@gameofthron.es").first()

This will return the name of our user:

<Viewer: Khal Drogo>

Now, let’s query our movies collection for runtime values.
In the same shell, run the following code to find movies that have a runtime value that is less than 10:

Movie.objects.filter(runtime__lt=10)

This will return a list of matching movies, as seen in the screenshot below:

Once this step is finished, feel free to run queries on any data stored inside the MongoDB cluster!

Let’s create an admin site

It’s possible to create a Django admin site so that users can edit their data straight from a web interface.
Let’s first create an admin user. From the root directory run the following code:

python manage.py createsuperuser

The terminal will ask for a username, email address, and password. Enter the following information below to create a user with specified credentials:

Username: admin
Email address: admin@example.com
Password: <admin-password>
Password (again): <admin-password>

To enter the admin site, run the following code:

python manage.py runserver

Access the site by visiting http://127.0.0.1:8000/admin/. A login screen will appear:

Enter the name and password that was created previously to log on.

Here, the following information is presented and users can edit their project authentication configuration through selection of the Groups or Users rows in the Authentication and Authorization table.

Let’s edit the data in our users sample collection. Remember that this is represented by the Viewer model, which is not associated with the Users row as shown in the admin panel.

Head to the sample_mflix/admin.py file and paste in the code below:

from django.contrib import admin

from .models import Viewer

admin.site.register(Viewer)

Refresh the Django administration site and it will be updated:

Now, we are able to select a viewer object. Do this by clicking on the Viewers row of the SAMPLE_MFLIX table to see the list of viewers, as seen below:

At the top of the list, click on Abigail Carter. From here, we will be able to see the Name and Email.

Here, we are able to edit the information, if chosen. Users are able to edit any field and hit the SAVE button to save any changes.

Great job, you have just completed the Django MongoDB Backend Quickstart! In this quickstart, you:

Created a Django application.
Connected your Django application to a MongoDB deployment.
Ensured your deployment is hosted on MongoDB Atlas.
Interacted with the data that is stored inside of your cluster.
Created a Django admin page.

To learn more about Django MongoDB Backend, please visit the docs and our repository on GitHub. If you have any questions, please feel free to connect with us in our MongoDB Developer Forum.

Protect Client Data Using MongoDB Field Level Encryption With AWS KMS & AWS Lambda

Anaiya — Mon, 22 Jul 2024 15:54:02 +0000

This article is written by Devadyuti Das (Senior Solutions Architect - AWS) and Babu Srinivasan (Senior Partner Solutions Architect - MongoDB)

As the cloud becomes the preferred environment for an increasing number of customers, their system components — including applications, compute resources, storage, networks, and databases — are now operating in a more distributed manner. So in a way, customer data is moving continuously through network, servers, and storage from its origin to target. In this scenario, security and protection of the data is paramount and, hence, encrypting the data is of utmost importance. Encryption is the process of converting data into a coded form to prevent unauthorized access, making it significant in safeguarding sensitive information. Client-side encryption seeks to eliminate the potential for data to be viewed/intercepted by any third party on the above chain of data flow. Client-side encryption ensures that data and files that are stored in the cloud can only be viewed on the client side of the exchange.

In this blog, we'll explore how to enable client-side field level encryption (CSFLE), a feature that lets you encrypt data within your application before it is transmitted to MongoDB on AWS. By enabling CSFLE, you ensure that no MongoDB product can access your data in an unencrypted form.

Let’s look at the key services we are going to use to achieve this.

MongoDB Atlas is a multi-cloud database service from MongoDB. It streamlines the deployment and management of your databases, providing the flexibility required to develop robust and efficient global applications on your preferred cloud providers. MongoDB Atlas facilitates the on-demand deployment and management of databases, ensuring they are available whenever and wherever you need them.

AWS KMS allows you to create, manage, and control cryptographic keys across your applications and AWS services. By combining AWS Key Management System with the MongoDB encrypted storage engine, which automatically encrypts all cluster storage and snapshot volumes at rest, you can add an extra layer of security.

AWS Lambda is a compute service that executes your code in response to events and automatically manages the compute resources, facilitating the rapid development of modern, production-ready, serverless applications. By connecting to a MongoDB Atlas cluster, you can quickly begin building your functional code in any popular programming language.

Let’s look from a high level at what we are going to build from the following architecture.

Solution architecture

The above figure illustrates the architecture diagram for implementing MongoDB CSFLE on AWS infrastructure. The steps outlined below correspond to each numbered section in the diagram:

Set up an AWS account.
Configure a MongoDB Atlas cluster.
Create an AWS KMS master key.
Create APIs to enable client-side encryption using AWS Lambda.
Create a web application to test CSFLE.

Let’s get started!

Prerequisites

Step 1: Set up an AWS Account

Follow the step by step guide from the AWS docs to sign up for an AWS account and create an administrative user. If you have an existing AWS account and administrative user, please proceed to Step 2.

Step 2: Configure MongoDB Atlas cluster

Sign up for a MongoDB account by following the step by step guide. Then, set up and configure a MongoDB Atlas cluster on AWS.

For this blog, I have used eu-west-1 as the chosen region on AWS. Make sure you use a single region while following the instructions.

Complete the steps of creating an account, deploying a free cluster, creating a database user, and configuring network access.

During the ‘Manage the IP Access List’ step, we need to allow our code to access the MongoDB Atlas cluster. To do that, go to ‘Network Access’ and click +Add IP Address. For testing our blog, we want our service/application to access the MongoDB database from AWS. We’ll ‘Allow access from Anywhere’ with a time limit of ‘6 Hours’. Confirm once you choose the appropriate options. Please note that this configuration (0.0.0.0/0) is only for demo purposes and is not recommended for any production or production-like environments.

After creating a MongoDB Atlas cluster, copy the whole connection string for MongoDB driver connectivity (see figure below) and keep it safe to use at a later stage. If you forgot to capture this, you can go to Database -> Connect, click Connecting with MongoDB for VS Code, and copy the connection string.

The above figure shows the screenshot of the connect button on the MongoDB Atlas console.

The above screenshot shows the MongoDB connect for VS Code.

The above screenshot shows the connection string for the cluster.

Step 3: Create AWS KMS master key

Step 3a:
Create a new symmetric key in your preferred region (for this blog, we’ll use eu-west-1) by following the official AWS documentation on creating symmetric KMS keys. The key you create is your Customer Master Key. Choose a name and description that helps you identify it; these fields do not affect the functionality or configuration of your key.

In the Usage Permissions step of the key generation process, apply the following default key policy to allow Identity and Access Management (IAM) policies to grant access to your Customer Master Key. Replace the placeholder for the account principal with your 12-digit AWS account number, which can be found in the top right corner of your AWS console.

{
   "Id": "key-consolepolicy",
   "Version": "2012-10-17",
   "Statement": [
       {
           "Sid": "Enable IAM User Permissions",
           "Effect": "Allow",
           "Principal": {
              "AWS": "arn:aws:iam::<Your AWS account number>:root"
           },
           "Action": "kms:*",
           "Resource": "*"
       }
   ]
}

Record the Amazon Resource Name (ARN) and Region of your Customer Master Key. You will use these in later steps of this guide.

Step 3b:

Now, we will create an IAM user and grant the user permission to use the recently created KMS master key.
Navigate to the AWS IAM Console.

Create a new programmatic IAM user in the AWS Management Console by following the official AWS documentation on adding a user. This IAM user will serve as a service account for your CSFLE-enabled application. Your application will authenticate with AWS KMS using this IAM user to encrypt and decrypt your Data Encryption Keys (DEKs) with your Customer Master Key.

Ensure you record the following IAM credentials in the final step of creating your IAM user: Access key ID, Secret access key. You have one opportunity to record these credentials. If you do not record these credentials during this step, you must create another IAM user.

Step 3c:
Grant your IAM user kms:Encrypt and kms:Decrypt permissions for your remote master key.

The new client IAM user should not have administrative permissions for the master key. To keep your data secure, follow the principle of least privilege.

The following inline policy allows an IAM user to encrypt and decrypt with the Customer Master Key with the least privileges possible:

NOTE: Remote Master Key ARN
The following policy requires the ARN of the AWS KMS key you generated in this step of the guide.

{
   "Version": "2012-10-17",
   "Statement": [
       {
           "Effect": "Allow",
           "Action": [ 
               "kms:Decrypt", 
               "kms:Encrypt"
           ]
           "Resource": "<Amazon Resource Name (ARN) of your KMS master key"
       }
   ]
}

To apply the preceding policy to your IAM user, follow the adding IAM identity permissions guide in the AWS documentation.

Authenticate with IAM roles in production
When deploying your CSFLE-enabled application to a production environment, authenticate your application by using an IAM role instead of an IAM user.

To learn more about IAM roles, see the following pages in the official AWS documentation:

IAM roles

When to create an IAM role (instead of a user)

Step 4: Create APIs to enable client-side encryption

As for this solution, we want to enable client-side field level encryption completely automated, and the same has a dependency on Automatic Encryption Shared Library of MongoDB. This library is distributed specific to the operating system requirement for the client. In this scenario, we are going to use AWS Lambda in JavaScript for our client, so we’ll need to set up our development environment in Linux-x86_x64 (which is the supported runtime for AWS Lambda).

We have a few choices, like using AWS Cloud 9 or another Linux-based IDE. In this blog, we’ll learn how to set up your AWS Cloud 9 environment for AWS Lambda. The complete development environment set up — storing the MongoDB connection string and AWS KMS resource details, and building and deploying the code — requires a number of tasks to be completed, so we will use an existing GitHub repository to simplify. Please follow the instructions for csfle-service and once completed, come back to this blog to proceed.

After you have successfully deployed the APIs in AWS, let’s try to understand what we have done in the CSFLE service. The code for CSFLE APIs are inside the /mongodb-aws-csfle/csfle-service folder.

In CSFLE service, our objective is to create three APIs for customer profile information with some sensitive personal data to encrypt from the client (e.g., account information, email, date of birth, and phone number).

Let’s take a look at each file and what that is intended to achieve.

handler.js: This file holds the main Lambda functions for client-side field level encryption for MongoDB. There are three functions which will be delivered through API gateway.

saveCustomerCSFLE — API function to encrypt customer information like account details, date of birth, email, phone number, etc. before saving or updating in MongoDB using an encryption key

getCustomerWithKey — API function to retrieve customer information with a valid client encryption key

Note: Both the above functions need to initialise a MongoDB client instance with an encryption option parameter.

getCustomerNoKey — API function to retrieve customer information without a valid client encryption key

getCustomerSchema — Defines a schema for customers on what type of encryption will be applied for which specific fields for a customer. In my example, I have encrypted ‘date of birth’, ‘email’, ‘phone number’, and ‘account details’. Also, please note if you try to read a customer document on an attribute which is encrypted in your find method, use the ‘Deterministic’ algorithm and not ‘Random’.

secret.js: This contains a module function to call AWS Secrets Manager to fetch the secrets we stored for the MongoDB connection string and KMS key/provider details.
encrypt.js: This file holds all the key functions needed for client-side field level encryption as follows.

getKeyManagementProviderDetails — Fetches the KMSProvider and KMS master key details

getDataEncryptionKey — Generates or fetches the data encryption key in/from the keyVault collection in MongoDB based on the existence of the data encryption key

createUniqueIndex — Creates a unique index on keyAltNames attribute

createDataEncryptionKey — Generates the data encryption key in keyVault collection in MongoDB

getEncryptionOption — Collates all additional encryption options including the MongoDB shared encryption library for the MongoClient to execute CSFLE operations

mdb.js: This file holds the template for all MongoDB NodeJS driver client functions including creating a MongoClient instance and subsequent CRUD operations like insert, update, and find document(s).

serverless.yaml: This file holds the deployment descriptor for the whole serverless stack, including the Amazon API gateway endpoint definitions along with corresponding AWS Lambda functions.

Environment variables — like the MongoDB collection name, Automated Crypto Shared Library path, NodeJS version, etc.

Permission for API gateway to invoke the Lambda function, decrypt or encrypt using the AWS KMS encryption key and reading AWS Secrets Manager via AWS Identity and Access Management (IAM) policies

Optionally — Amazon Route 53 domain mapping for the API endpoints using Amazon CloudFront distribution

Step 5: Create a web application to test CSFLE

To test the above APIs we have deployed, we’ll create a simple React single page app(SPA). Get the instructions for the prerequisites of creating a Cognito authentication, setting up a development environment, and running the React web app. Once completed, please come back to continue reading this blog.

*Register a new user in CSFLE test web app
*

Open your browser and navigate to http://localhost:3000/.

The above screenshot shows the landing screen of the application.

Click sign in and complete the New User Sign-up using email, password, and confirmation code.

The above screenshot shows the signup/login page.

The above screenshot shows the registration page of the application.

The above screenshot shows the signup confirmation code page.

Once sign-up is completed, you will be redirected to the home page in a signed in state.

*Save a customer document with CSFLE
*

Click on Save Customer (CSFLE).

The above screenshot shows the landing screen of the application.

Complete dummy data for first name, last name, email, date of birth, and phone number and click Save Changes. You will receive an alert that the application is successfully updated.

The above screenshot shows the customer details updated screen of the application.

*Validate the saved document in MongoDB Atlas
*

Go to cloud.mongodb.com and log in to your MongoDB Atlas cluster. From ‘Browse Collections’, navigate to the ‘customer’ collection under the CSFLE database and you will able to see the document you just saved. The encrypted fields are masked with an asterisk (*).

The above screenshot shows the customer details in the MongoDB Atlas cluster.

Validate the saved document from the web app using the key

Open a browser and navigate to https://localhost:3000.

Click on Get Customer (With Key).

The above screenshot shows the landing screen of the application.

You should be able to see the information visible on the page with sensitive fields unencrypted.

The above screenshot show the customer details display screen.

*Validate the saved document from the web app without key
*

Open a browser and navigate to https://localhost:3000.

Click on Get Customer (No Key).

You should be able to see the information visible on the page with the sensitive fields encrypted.

The above screenshot displays the sensitive data in an encrypted format.

Conclusion

In this blog, we have dived deeper into the technical aspects of encrypting data in a client application before we send it over the network to MongoDB Atlas on AWS. However, the best way to learn new technologies and concepts is hands-on, so we recommend going through the GitHub repository thoroughly step by step and learn how to configure and run a dev environment to test client-side field level encryption.
If you’re interested to learn more about how you can use MongoDB Atlas on AWS to drive solutions and innovation for your customers, please read our MongoDB-AWS blogs.

Data Modeling: Good vs. Perfect

Anaiya — Tue, 13 Feb 2024 21:34:49 +0000

This article is written by Rafael Ochoa of Celebreak.

MongoDB schema is very flexible. This allows for building more accurate models adapted to different use cases. However, flexibility comes with a price. There are more factors to consider and more decisions to make when designing a data model.

There are good resources on the web to help you understand the possibilities from a data modeling point of view. Some of the most comprehensive ones are the patterns and antipatterns series from MongoDB. The former provides a good explanation of design patterns that could be used for different use cases, while the latter summarizes what you need to avoid when making design decisions.

This post is about a time we made a mistake in data modeling, the consequences, and what we learned from it.

The requirement

Our company, CeleBreak, organizes amateur football games. People pick games and pay to play through our mobile app. We hire the fields, provide the bibs and balls, and send an organizer to ensure the best experience for our customers.

In a simplified world, we have two collections, one for the users and one for the games, where games contain an embedded array of subdocuments with references to users. An external payments processor handles the payment flow, which is asynchronous, so the subdocuments have a status field to control the lifecycle of the guests, which starts in PREPARED and can change to CONFIRMED or CANCELED, depending on the result of the payment. They also contain information about whether the user attended the game or not. This is how this subdocument is defined:

const PlayerSchema = new Mongoose.Schema({
 status: { type: String, enum: ['PREPARED', 'CONFIRMED', 'CANCELED'], required: true, index: true },
 userId: { type: Mongoose.Types.ObjectId },
 preparedAt: { type: Date },
 confirmedAt: { type: Date },
 canceledAt: { type: Date },
 arrivedAt: { type: Date },
});

At some point, we received a requirement to display the number of games played for each user in the games’ player list on our operational website. This is how the player cards should look like there:

The analysis

When we designed our data structure, we decided to embed players in the game document. This makes it easy to get the list of players in a given game as we do in the players list view, and also simplifies the game-specific controls required to validate if a user can join a given game, for example, if the game still has available spots.

However, getting the history of games a user has played, as needed to fulfill the mentioned requirements, is more complicated. The information is split into different game documents, so we need to put them together to count them. To do so, we need to run a pipeline that looks up all games each user has participated in, then unwinds the array of guests of all these events to get only those of the user of interest and group them to get the count of games the user has played. An example can be seen on the Mongo Playground.

db.games.aggregate([
 {
   $match: {
     _id: gameId
   }
 },
 {
   $unwind: "$players"
 },
 {
   $match: {
     "players.status": "CONFIRMED"
   }
 },
 {
   $lookup: {
     from: "games",
     localField: "players.userId",
     foreignField: "players.userId",
     as: "gamesByUser"
   }
 },
 {
   $unwind: "$gamesByUser"
 },
 {
   $unwind: "$gamesByUser.players"
 },
 {
   $match: {
     $expr: {
       $eq: [
         "$gamesByUser.players.userId",
         "$players.userId"
       ]
     },
     "gamesByUser.players.status": "CONFIRMED"
   }
 },
 {
   $group: {
     _id: "$gamesByUser.players.userId",
     gamesPlayed: {
       $sum: 1
     }
   }
 }
])

This pipeline queries the game of interest and then looks up the same collection to get all the games any of these players have participated in. Each game is loaded with all its players, so we need to unwind the array and match only those subdocuments that correspond to the players of the game. This could become very inefficient. Because of that, we decided to update our data structure to find a better way.

This information was going to be presented in the context of users. Also, we considered that the number of games a user could join was not going to grow too fast (a few tens per year, in most cases). Finally, we wanted to reflect real-time changes, like status updates of the players or the games, to support further analysis, if needed.

Considering these conditions, we concluded that denormalizing games information in the user document was a good option. It’d make it simple to get the count of games for each user, and other user-specific analytics — like the date of the first and last games played — by only analyzing the denormalized array in the server. We decided to update the denormalized objects in real-time, to have a more powerful and accurate source of information, if needed.

This is the schema we implemented:

const DenormalizedGameSchema = new Mongoose.Schema({
 gameId: { type: Mongoose.Schema.Types.ObjectId, ref: 'Game' },
 status: { type: String, enum: ['CONFIRMED', 'CANCELED'] },
 players: {
   status: { type: String, enum: ['PREPARED', 'CONFIRMED', 'CANCELED'] },
 },
 startingAt: { type: Date },
});

The consequences

The first issue appeared when we were implementing the logic to keep the denormalized information up to date in real-time. At that moment, we didn’t have a system to react to DB changes, so we polluted critical flows with updates to the denormalized objects. This was difficult to maintain and led us to errors that caused data inconsistencies in some edge cases.

At some point, this code was a part of the flow that added players to games, which is the most critical of our system:

const userQuery = isDataDenormalized
 ? {
   _id: userId,
   denormalizedGames: { $elemMatch: { gameId } },
 } : {
   _id: userId,
 };


const userEventToAdd: UserDenormalizedEvent = {
 gameId,
 status: 'CONFIRMED',
 players: {
   status: 'CONFIRMED',
 },
 startingAt,
};


const userUpdate = isDataDenormalized
 ? {
   $set: {
     'denormalizedGames.$.players.status': 'CONFIRMED',
   },
 } : {
 $push: {
   'denormalizedData.events': userEventToAdd,
 },
};


await User.findOneAndUpdate(userQuery, userUpdate);

If a given game had already been denormalized, then we only needed to update the status of the player. Otherwise, we needed to add the full object to the array. This illustrates the complexity this solution implied, considering that similar code was present in other critical flows of our system.

Then, we observed an increment in the loading times of the players' list in some games. We found a few users who had participated in thousands of games, so the denormalized data arrays in their documents had grown to thousands of entries, making them very large. This effect appeared very soon because we ran a migration to denormalize existing data when this change went live.

What we got wrong (i.e., the learnings)

As the flaws of our decision became evident, we reviewed our analysis to find the root causes and moved forward to find a better solution. In this retrospective, we found two big issues.

First, we shouldn’t have assumed that the number of games a user played wouldn’t grow too fast. There is no limit to the number of events a user can join over time, so in real life, there are many cases where this assumption was wrong. To make it worse, these were our power users, who were present in many different games, so the loading time of all those events was affected. It shows that we didn’t have a good understanding of some aspects of our business when we made this change.

Second, we shouldn’t have added real-time updates to the denormalized objects. It wasn’t needed to fulfill the original requirement and we underestimated the complexity of doing it. It made us spend more time on the implementation and it was prone to errors. This is not fully related to data modeling, but it was a consequence of a design decision.

Bonus: our (current) solution

Based on our retrospective analysis, we decided to take a different approach that has been in place since then. We created a new collection to hold the denormalized game joins, with the information required to easily calculate these values without the risk of user documents growing too much. Also, as the analytics didn’t need real-time updates, we decided to only denormalize final data, which means that it’s done when the game finishes. To do so, we have a scheduled function that runs this pipeline to update the denormalized collection daily:

[
 {
   $match: {
     startingAt: {
       $gte: <YESTERDAY AT THE START OF THE DAY>,
       $lt: <TODAY AT THE START OF THE DAY>
     },
     status: 'CONFIRMED',
   },
 },
 {
   $project: {
     _id: 1,
     players: 1,
     startingAt: 1,
   },
 },
 {
   $unwind: '$players',
 },
 {
   $match: {
     'players.status': 'CONFIRMED',
   },
 },
 {
   $project: {
     _id: 0,
     eventId: '$_id',
     userId: '$players.userId',
     startingAt: '$startingAt',
   },
 },
 {
   $merge: {
     into: 'denorm_gameplayers',
     on: ['gameId', 'userId'],
     whenNotMatched: 'insert',
     whenMatched: 'replace',
   },
 },
];

It has a filter to add events of the previous day, and the configuration of the $merge stage ensures that if a document already exists for that user joining that game, it’ll be overwritten. This way, we avoid the need for real-time updates on documents, given that we only require analytics for information on games that have already ended.

Compared to our original situation (players' information embedded in the game object), this approach is better because we don’t need to load all the games with all the players each game has to then filter them all but the user of interest. In this case, we can get the documents of interest in one single action.

This approach also tackled the two issues we found in our analysis. First, all the information lives in a different place that can be consulted when needed, and the user document, which is one of the most important ones in our system, stays lean. Second, we isolated the logic to keep the denormalized information up to date according to our requirements, so our critical flows are simpler and less prone to errors.

We’ve also fulfilled new requirements based on this solution, like calculating the number of churned, reactivated, and new players in a given time frame.

Currently, the denormalized collection holds 575K documents in our production system, more than 1K are being added every day, and we haven’t faced a performance bottleneck nor a significant complexity increase due to it, so we consider that this solution has been successful.

We anticipated a few reasonable future use cases without trying to cover too much, reducing the complexity of the solution. We know requirements change and this may be insufficient in the future. At that moment, we’ll keep iterating on it and improving our familiarity with our data to make better decisions.

Conclusion

The biggest learning we had from this experience is that understanding the details of your data and your use case is as important as being aware of the capabilities and tradeoffs of the technology. This is challenging and case-specific, so it takes time and errors can happen. Aiming for perfection may lead to analysis paralysis, so we need to make decisions, and be flexible enough to review them and learn if they happen to be wrong. Finally, an honest and thorough retrospective analysis is what will help to make it better next time.

Find me on LinkedIn and X to keep the conversation going.

Interested in learning more about MongoDB Atlas?

Anaiya — Mon, 28 Nov 2022 15:27:57 +0000

Check out my latest YouTube video highlighting the many features and functionalities available!

What exactly IS middleware?

Anaiya — Wed, 16 Nov 2022 17:32:52 +0000

Confused about what exactly is middleware and its uses? Come read my recently published article below: https://www.mongodb.com/databases/middleware

DEV Community: Anaiya

Grab a Pint With Django-MongoDB-Backend, Voyage AI, and LangChain

What is our Django MongoDB Backend?

LangChain MongoDB

What is Voyage AI and why are we using them?

Pre-requisites

Background on data collecting

Step 1: Create Django project using Django-MongoDB-Backend library

Create a virtual environment

Install the Django MongoDB Backend library

Step 2: Create Django application

Step 3: Creating our models

Step 4: Embedding with Voyage AI

Step 5: Inserting data into the MongoDB cluster

Step 6: LangChain-MongoDB

Step 7: Django

Conclusion

Build a Basic CRUD Application With Flask-PyMongo

What is Flask?

Flask-PyMongo

Pre-requisities

Step 1: Create a virtual environment

Step 2: Download Flask-PyMongo

Step 3: Create app.py file

Step 4: Insert a movie

Step 5: Update a document

Step 6: Delete a document

Conclusion

Let’s Switch Things Up: Using MongoDB in an Intro Django Project

A summary of Django MongoDB Backend

Why use a NoSQL database with Django?

Tutorial pre-reqs

Create your MongoDB cluster

Part 1: Basic request and response flow

Creating the Polls app

Part 2: Database set-up

Creating models

Activating our models

Playing with the API

Django admin page

Conclusion

The Key Benefits of Using a NoSQL Database in Django Development

Let’s cover our basics…

What is a NoSQL database?

What is Django?

An overview of Django-MongoDB-Backend and the launch

Key benefits of using MongoDB with Django

MongoDB’s document model

Data platform capability

Advanced search and AI capabilities

Aggregation framework

Robust ecosystem of tools

Best practices for implementing NoSQL with Django

Conclusion

Django MongoDB Backend Quickstart

What is Django?

Pre-requisites

Create your MongoDB cluster

Create your virtual environment

Installing Django MongoDB Backend

Create your Django project!

Creating an application for our “sample_mflix” data

Create models for our movie, viewer, and award data

Create views to display our data

Configure URLs for our views

Create templates to format your data

Including our application inside of our project

Create migrations for your new models

Write data

Reading back our data

Let’s create an admin site

Protect Client Data Using MongoDB Field Level Encryption With AWS KMS & AWS Lambda

Solution architecture

Prerequisites

Step 1: Set up an AWS Account

Step 2: Configure MongoDB Atlas cluster

Step 3: Create AWS KMS master key

Step 4: Create APIs to enable client-side encryption

Step 5: Create a web application to test CSFLE

Data Modeling: Good vs. Perfect

Step 3: Create `app.py` file