Aperol Spritze de verão com queries geoespaciais e pesquisa vetorial do MongoDB

1
!pip install googlemaps
2
!pip install openai==0.28

1
import googlemaps
2
import getpass
3
import openai

1
# google API Key
2
google_api_key = getpass.getpass(prompt= "Put in Google API Key here")
3
map_client = googlemaps.Client(key=google_api_key)
4
# openAI API Key
5
openai_api_key = getpass.getpass(prompt= "Put in OpenAI API Key here")

1
# set your key
2
openai.api_key = openai_api_key
3
4
# embedding model we are using
5
EMBEDDING_MODEL = "text-embedding-3-small"
6
7
# our embedding function
8
def get_embedding(text):
9
 response = openai.Embedding.create(input=text, model=EMBEDDING_MODEL)
10
 return response['data'][0]['embedding']

1
# for Google Maps API we need to use a radius in meters. Let's first change our miles to meters
2
def miles_to_meters(miles):
3
   return miles * 1609.344

1
middle_of_west_village = (40.73490473393682, -74.00521094160642)
2
search_radius = miles_to_meters(0.4) # West Village is small so just do less than half a mile.
3
spritz_finder = 'aperol spritz'

1
# making the API call using our places_nearby method and our parameters
2
response = map_client.places_nearby(
3
   location=middle_of_west_village,
4
   radius=search_radius,
5
   keyword=spritz_finder
6
)

1
{
2
"html_attributions": [],
3
"results":
4
 [
5
   {
6
     "business_status": "OPERATIONAL",
7
     "geometry":
8
       {
9
         "location": { "lat": -33.8587323, "lng": 151.2100055 },
10
         "viewport":
11
           {
12
             "northeast":
13
               { "lat": -33.85739847010727, "lng": 151.2112436298927 },
14
             "southwest":
15
               { "lat": -33.86009812989271, "lng": 151.2085439701072 },
16
           },

1
# find information we want: use the Nearby Places documentation to figure out which fields you want
2
spritz_locations = []
3
for location in response.get('results', []):
4
   location_detail = map_client.place(
5
       place_id=location['place_id'], fields=['name', 'formatted_address', 'geometry', 'reviews', 'rating']
6
   )
7
8
9
   # these are the specific details we want to be saved as fields in our documents
10
   details = location_detail.get('result', {})
11
12
13
   # we want to embed the five reviews so lets extract and join together
14
   location_reviews = details.get('reviews', [])
15
   store_reviews = [review['text'] for review in location_reviews[:5]]
16
   joined_reviews = " ".join(store_reviews)
17
18
19
   # generate embedding on your reviews
20
   embedding_reviews = get_embedding(joined_reviews)
21
22
23
   # we know that the longitude and latitude is nested inside Geometry and Location.
24
   # so let's grab it using .get and then format it how we want.
25
   geometry = details.get('geometry', {})
26
   location = geometry.get('location', {})
27
28
29
   # both are nested under location so open it up
30
   longitude = location.get('lng')
31
   latitude = location.get('lat')
32
33
34
   location_info = {
35
       'name': details.get('name'),
36
       'address': details.get('formatted_address'),
37
38
39
       # MongoDB geospatial queries require GeoJSON formatting
40
       'location': {
41
           'type': 'Point',
42
           'coordinates': [longitude, latitude]
43
       },
44
       'rating': details.get('rating'),
45
       'reviews': store_reviews,
46
       'embedding': embedding_reviews
47
   }
48
   spritz_locations.append(location_info)

1
# print our spritz information
2
for location in spritz_locations:
3
   print(f"Name: {location['name']}, Address: {location['address']}, Coordinates: {location['location']}, Rating: {location['rating']}, Reviews: {location['reviews']}, Embedding: {location['embedding']}")

1
# install pymongo
2
!pip install pymongo

1
from pymongo import MongoClient
2
3
# set up your MongoDB connection
4
connection_string = getpass.getpass(prompt= "Enter connection string WITH USER + PASS here")
5
client = MongoClient(connection_string)
6
7
# name your database and collection anything you want since it will be created when you enter your data
8
database = client['spritz_summer']
9
collection = database['spritz_locations_WV']
10
11
# insert our spritz locations
12
collection.insert_many(spritz_locations)

1
# create a Vector Search Index so we can use it
2
{
3
"fields": [
4
  {
5
    "numDimensions": 1536,
6
    "path": "embedding",
7
    "similarity": "cosine",
8
    "type": "vector"
9
  }
10
]
11
}

1
# You have to embed your queries just the same way you embedded your documents.
2
# my query
3
query_description = "outdoor seating quick service"
4
5
# we need to embed the query as well, since our documents are embedded
6
query_vector = get_embedding(query_description)

1
spritz_near_me_vector = [
2
   {
3
       '$vectorSearch': {
4
           'index': 'vector_index',
5
           'path': 'embedding',
6
           'queryVector': query_vector,
7
           'numCandidates': 15,
8
           'limit': 5
9
       }
10
   },
11
   {
12
       "$project": {
13
           "_id": 1,  # we want to keep this in place so we can search again using GeoNear
14
           "name": 1,
15
           "rating": 1,
16
           "reviews": 1
17
           #"address": 1,
18
           #"location": 1,
19
           #"embedding": 1
20
       }
21
   }
22
]

1
spritz_near_me_vector_results = list(collection.aggregate(spritz_near_me_vector))
2
for result in spritz_near_me_vector_results:
3
   print(result)

1
# now, we want to take the _ids from our above pipeline so we can use it to geo search
2
spritz_near_me_ids = [result['_id'] for result in spritz_near_me_vector_results]
3
print(spritz_near_me_ids)

1
collection.create_index( { "location" : "2dsphere" } )

1
# use the $geoNear operator to return documents that are at least 100 meters and at most 1000 meters from our specified GeoJSON point.
2
spritz_near_me_geo = [
3
   {
4
       "$geoNear": {
5
           "near": {
6
               "type": "Point",
7
               "coordinates": [-74.0059456749148, 40.73781277366724]
8
           },
9
           # here we are saying that we only want to use the sample size from above
10
           "query": {"_id": {"$in": spritz_near_me_ids}},
11
           "minDistance": 100,
12
           "maxDistance": 1000,
13
           "spherical": True,
14
           "distanceField": "dist.calculated"
15
       }
16
   },
17
   {
18
       "$project": {
19
           "_id": 0,
20
           "name": 1,
21
           "address": 1,
22
           "rating": 1,
23
           "dist.calculated": 1,
24
           #"location": 1,
25
           #"embedding": 1
26
       }
27
   },
28
   {
29
       "$limit": 3
30
   },
31
   {
32
       "$sort": {
33
           "dist.calculated": 1
34
       }
35
   }
36
]

1
spritz_near_me_geo_results = collection.aggregate(spritz_near_me_geo)
2
for result in spritz_near_me_geo_results:
3
   print(result)

1
# create a 2dsphere index on our location field
2
collection.create_index({"location": "2dsphere"})
3
4
# our $geoNear pipeline
5
spritz_near_me_geo = [
6
   {
7
       "$geoNear": {
8
           "near": {
9
               "type": "Point",
10
               "coordinates": [-74.0059456749148, 40.73781277366724]
11
           },
12
           "minDistance": 100,
13
           "maxDistance": 1000,
14
           "spherical": True,
15
           "distanceField": "dist.calculated"
16
       }
17
   },
18
   {
19
       "$project": {
20
           "_id": 1,
21
           "dist.calculated": 1
22
       }
23
   }
24
]
25
26
# list of ID's and distances so we can use them as our sample size
27
places_ids = list(collection.aggregate(spritz_near_me_geo))
28
distances = {result['_id']: result['dist']['calculated'] for result in places_ids} # have to create a new dictionary to keep our distances
29
spritz_near_me_ids = [result['_id'] for result in places_ids]
30
# print(spritz_near_me_ids)

1
# our vector search index that was created inside of MongoDB Atlas
2
vector_search_index = {
3
   "fields": [
4
       {
5
           "numDimensions": 1536,
6
           "path": "embedding",
7
           "similarity": "cosine",
8
           "type": "vector"
9
       },
10
       {
11
           "type": "filter",
12
           "path": "_id"
13
       }
14
   ]
15
}

1
# vector search pipeline
2
spritz_near_me_vector = [
3
   {
4
       '$vectorSearch': {
5
           'index': 'vector_index',
6
           'path': 'embedding',
7
           'queryVector': query_vector,
8
           'numCandidates': 15,
9
           'limit': 3,
10
           'filter': {"_id": {'$in': spritz_near_me_ids}}
11
       }
12
   },
13
   {
14
       "$project": {
15
           "_id": 1,  # we want to keep this in place
16
           "name": 1,
17
           "rating": 1,
18
           "dist.calculated": 1
19
           #"reviews": 1
20
           # "address": 1,
21
           # "location": 1,
22
           # "embedding": 1
23
       }
24
   }
25
]
26
27
spritz_near_me_vector_results = collection.aggregate(spritz_near_me_vector)
28
for result in spritz_near_me_vector_results:
29
   result['dist.calculated'] = distances.get(result['_id'])
30
   print(result)