Update README.md

README.md

@@ -91,3 +91,109 @@ viz(bakeries)
 It created a nice interactive map with tooltips.
 
 ![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c4da8719565937fb268b32/QIolrK2nlrENnkWlE6TFh.png)
+
+## Remote Semantic Search 
+
+You can even perform semantic search remotely without downloading the whole file.
+Without using any index on the data (like HNSW or ANN etc.) but by simply brute forcing, it takes 3:14 mins on my machine to query the example file for Italy remotely. 
+It weighs ~5Gb and consists of 3.029.191 rows. I used https://huggingface.co/minishlab/M2V_multilingual_output as multilingual embeddings.
+I will write a detailed tutorial on the processing in the near future.
+
+```python
+import duckdb
+from model2vec import StaticModel
+import pandas as pd
+import numpy as np
+
+model = StaticModel.from_pretrained("minishlab/m2v_multilingual_output")
+
+def search_similar_locations(query_vector, top_k=10, db_path=""):
+    """
+    Search for locations with similar embedding vectors using cosine similarity.
+    
+    Args:
+        query_vector (list): The embedding vector to compare against
+        top_k (int): Number of similar locations to return
+        db_path (str): Path to the parquet file containing the embeddings and geometries
+        
+    Returns:
+        pandas.DataFrame: DataFrame containing the top_k most similar locations with their coordinates
+    """
+    
+    # Convert query vector to numpy array
+    query_vector = np.array(query_vector).astype(np.float32)
+
+    # Install and load the vss extension
+    con = duckdb.connect()
+    try:
+        #con.execute("INSTALL vss;")
+        #con.execute("INSTALL spatial;")
+        con.execute("LOAD vss;")
+        con.execute("LOAD spatial;")
+    except Exception as e:
+        print(f"Error installing/loading vss extension: {str(e)}")
+        con.close()
+        return None
+    
+    # Define a custom cosine similarity function for use in SQL
+    def cosine_similarity(arr1, arr2):
+      if arr1 is None or arr2 is None:
+          return None
+      
+      arr1 = np.array(arr1)
+      arr2 = np.array(arr2)
+      
+      norm_arr1 = np.linalg.norm(arr1)
+      norm_arr2 = np.linalg.norm(arr2)
+      
+      if norm_arr1 == 0 or norm_arr2 == 0:
+          return 0.0  # To handle zero vectors
+      
+      return np.dot(arr1, arr2) / (norm_arr1 * norm_arr2)
+
+    con.create_function('cosine_similarity', cosine_similarity, ['FLOAT[]', 'FLOAT[]'], 'DOUBLE') # Specify parameter types, then return type
+
+    # Construct the SQL query
+    query = f"""
+    WITH location_data AS (
+        SELECT *,
+               embeddings::FLOAT[] as embedding_arr -- Cast embedding to FLOAT[]
+        FROM '{db_path}' 
+        --LIMIT 1_000
+    )
+    SELECT 
+        name,
+        -- geometry,
+        ST_X(ST_GeomFromWKB(geometry)) as longitude,
+        ST_Y(ST_GeomFromWKB(geometry)) as latitude,
+        cosine_similarity(embedding_arr, ?::FLOAT[]) as cosine_sim
+    FROM location_data
+    ORDER BY cosine_sim DESC
+    LIMIT {top_k};
+    """
+    
+    # Execute query and return results as DataFrame
+    try:
+        result = con.execute(query, parameters=(query_vector,)).df()  # Pass parameters as a tuple
+        con.close()
+        return result
+    except Exception as e:
+        print(f"Error executing query: {str(e)}")
+        con.close()
+        return None
+
+    # Search for similar locations
+results = search_similar_locations(
+    query_vector=model.encode("ski and snowboard"),
+    top_k=50,
+    db_path='hf://datasets/do-me/foursquare_places_100M/foursquare_places_italy_embeddings.parquet' # can also be a local file
+)
+
+results
+```
+
+The resulting pandas df: 
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c4da8719565937fb268b32/VkDGOHmSthVJtDeyof9KL.png)
+
+Note that the cosine similarity function could also be rewritten to run fully in DuckDB.