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

python3.12 -m venv venv

source venv/bin/activate

python --version

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

django-mongodb-backend==5.1.0b1

pip install -r requirements.txt

pip install django-mongodb-backend

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

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

python manage.py runserver

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

{
     "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!"
   },

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

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)

python reviews_embedding.py

pip install pymongo python-dotenv

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

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)

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

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"
)

# 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
)

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() 

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})

<!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>

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')
]

python manage.py runserver