Vector Embeddings
& Similarity Search

import google.generativeai as genai
import numpy as np
from typing import List
import os
from dotenv import load_dotenv

load_dotenv()

# Configure Gemini
genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

def get_embedding(text: str, model_name: str = "models/embedding-001") -> List[float]:
    """Get embedding for a single text using Gemini"""
    model = genai.GenerativeModel(model_name)
    result = genai.embed_content(
        model=model_name,
        content=text,
        task_type="retrieval_document",  # or "retrieval_query" for queries
        title="Embedding"
    )
    return result['embedding']

def get_embeddings_batch(texts: List[str], model_name: str = "models/embedding-001") -> List[List[float]]:
    """Get embeddings for multiple texts efficiently"""
    embeddings = []
    
    # Process in batches (Gemini supports batch embedding)
    for text in texts:
        result = genai.embed_content(
            model=model_name,
            content=text,
            task_type="retrieval_document"
        )
        embeddings.append(result['embedding'])
    
    return embeddings

# Example usage
text = "Machine learning is a subset of artificial intelligence"
embedding = get_embedding(text)

print(f"Text: {text}")
print(f"Embedding dimension: {len(embedding)}")
print(f"First 10 values: {embedding[:10]}")

# Batch processing
texts = [
    "Python is a programming language",
    "Python is a type of snake",
    "JavaScript is used for web development",
    "Coffee is a popular beverage"
]

embeddings = get_embeddings_batch(texts)
print(f"\nGenerated {len(embeddings)} embeddings")

# Compare embedding approaches
text = "The quick brown fox jumps over the lazy dog"

# Gemini embedding
gemini_embedding = get_embedding(text, model_name="models/embedding-001")

# Alternative: Using Sentence Transformers (open source)
from sentence_transformers import SentenceTransformer

# Load a pre-trained model
st_model = SentenceTransformer('all-MiniLM-L6-v2')
st_embedding = st_model.encode(text)

# Compare results
comparison = {
    "Gemini": {
        "dimensions": len(gemini_embedding),
        "sample_values": gemini_embedding[:5],
        "magnitude": np.linalg.norm(gemini_embedding)
    },
    "Sentence-Transformers": {
        "dimensions": len(st_embedding),
        "sample_values": st_embedding[:5].tolist(),
        "magnitude": np.linalg.norm(st_embedding)
    }
}

# Display comparison
for model, info in comparison.items():
    print(f"\nModel: {model}")
    print(f"Dimensions: {info['dimensions']}")
    print(f"Magnitude: {info['magnitude']:.4f}")
    print(f"Sample: {[f'{v:.4f}' for v in info['sample_values']]}")

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from typing import List, Tuple

def calculate_cosine_similarity(vec1: List[float], vec2: List[float]) -> float:
    """Calculate cosine similarity between two vectors"""
    vec1 = np.array(vec1)
    vec2 = np.array(vec2)
    
    # Manual calculation
    dot_product = np.dot(vec1, vec2)
    magnitude1 = np.linalg.norm(vec1)
    magnitude2 = np.linalg.norm(vec2)
    
    if magnitude1 == 0 or magnitude2 == 0:
        return 0.0
    
    return dot_product / (magnitude1 * magnitude2)

def calculate_euclidean_distance(vec1: List[float], vec2: List[float]) -> float:
    """Calculate Euclidean distance between two vectors"""
    return np.linalg.norm(np.array(vec1) - np.array(vec2))

def find_most_similar(
    query_embedding: List[float], 
    embeddings: List[List[float]], 
    texts: List[str],
    method: str = "cosine"
) -> List[Tuple[str, float]]:
    """Find most similar texts to query"""
    similarities = []
    
    for i, embedding in enumerate(embeddings):
        if method == "cosine":
            similarity = calculate_cosine_similarity(query_embedding, embedding)
        else:  # euclidean
            # Convert distance to similarity (inverse)
            distance = calculate_euclidean_distance(query_embedding, embedding)
            similarity = 1 / (1 + distance)  # Convert to 0-1 range
        
        similarities.append((texts[i], similarity))
    
    # Sort by similarity (descending)
    similarities.sort(key=lambda x: x[1], reverse=True)
    return similarities

# Example: How to create embeddings for RAG applications
# These documents would typically come from your knowledge base
documents = [
    "The cat sat on the mat",
    "A feline rested on the rug",
    "The dog played in the park",
    "Machine learning is fascinating",
    "Deep learning is a subset of ML"
]

# Create embeddings for your vector database (Chroma, Pinecone, etc.)
# Note: You need the get_embedding and get_embeddings_batch functions from the previous section
import google.generativeai as genai
import os
from dotenv import load_dotenv

load_dotenv()
genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

def get_embedding(text: str, model_name: str = "models/embedding-001") -> List[float]:
    """Get embedding for a single text using Gemini"""
    result = genai.embed_content(
        model=model_name,
        content=text,
        task_type="retrieval_document"
    )
    return result['embedding']

def get_embeddings_batch(texts: List[str]) -> List[List[float]]:
    """Get embeddings for multiple texts efficiently"""
    embeddings = []
    for text in texts:
        embedding = get_embedding(text)
        embeddings.append(embedding)
    return embeddings

embeddings = get_embeddings_batch(documents)

# User query for retrieval augmented generation
query = "A kitten was sleeping on the carpet"
query_embedding = get_embedding(query)

# RAG vector search - find similar documents for context
cosine_results = find_most_similar(query_embedding, embeddings, documents, method="cosine")
euclidean_results = find_most_similar(query_embedding, embeddings, documents, method="euclidean")

print("Query:", query)
print("\nCosine Similarity Results:")
for text, score in cosine_results[:3]:
    print(f"  {score:.4f}: {text}")

print("\nEuclidean Distance Results:")
for text, score in euclidean_results[:3]:
    print(f"  {score:.4f}: {text}")