Embeddings & Semantic Search

pip install openai numpy

import os
import numpy as np
from openai import OpenAI

# Initialize the client
# Make sure your OPENAI_API_KEY is set in your environment variables
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

print("Libraries loaded and client ready.")

Step 2: Get Your First Embedding

def get_embedding(text):
    """
    Takes a string of text and returns a list of floats (the vector).
    """
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    # Extract the vector from the response
    return response.data[0].embedding

# Let's test it
word = "Apple"
vector = get_embedding(word)

print(f"Word: {word}")
print(f"Vector length: {len(vector)}")
print(f"First 10 numbers: {vector[:10]}")

Step 3: The Math of Similarity (Cosine Similarity)

How do we compare two lists of 1,536 numbers? We calculate the "angle" between them.

* If the angle is 0, they are identical (Similarity = 1.0).

* If they point in opposite directions, they are opposites (Similarity = -1.0).

* If they are unrelated (90 degrees), the similarity is 0.

Add this function to your code:

def cosine_similarity(a, b):
    """
    Calculates the cosine similarity between two vectors.
    Returns a score between -1 (opposite) and 1 (identical).
    """
    # Convert lists to numpy arrays for faster math
    vec_a = np.array(a)
    vec_b = np.array(b)
    
    # The formula: (A . B) / (|A| * |B|)
    dot_product = np.dot(vec_a, vec_b)
    norm_a = np.linalg.norm(vec_a)
    norm_b = np.linalg.norm(vec_b)
    
    return dot_product / (norm_a * norm_b)

# Test the math
vec1 = [1, 1, 1]
vec2 = [1, 1, 1] # Identical
vec3 = [-1, -1, -1] # Opposite

print(f"Identical similarity: {cosine_similarity(vec1, vec2)}")
print(f"Opposite similarity: {cosine_similarity(vec1, vec3)}")

Step 4: The "Apple" Test

Now for the magic. We will compare the word "Apple" against "Fruit" and "iPhone".

Wait—"Apple" is ambiguous. Does the computer know which Apple we mean? Let's see if context changes the math.

print("\n--- The Apple Context Test ---")

# 1. Embed the word "Apple" alone
vec_apple = get_embedding("Apple")

# 2. Embed related concepts
vec_fruit = get_embedding("Fruit")
vec_iphone = get_embedding("iPhone")
vec_dog = get_embedding("Dog")

# 3. Compare
score_fruit = cosine_similarity(vec_apple, vec_fruit)
score_iphone = cosine_similarity(vec_apple, vec_iphone)
score_dog = cosine_similarity(vec_apple, vec_dog)

print(f"Similarity 'Apple' vs 'Fruit': {score_fruit:.4f}")
print(f"Similarity 'Apple' vs 'iPhone': {score_iphone:.4f}")
print(f"Similarity 'Apple' vs 'Dog':    {score_dog:.4f}")

But now, let's try Contextual Sentences.

print("\n--- Contextual Sentence Test ---")

sentence_1 = "I like to eat apples"
sentence_2 = "I like to use my iPhone"
sentence_3 = "The company Apple just released a new product"
sentence_4 = "The fruit apple is red and tasty"

# Let's see which sentence is closer to "The company Apple..." (Sentence 3)
vec_1 = get_embedding(sentence_1)
vec_2 = get_embedding(sentence_2)
vec_3 = get_embedding(sentence_3) # This is our anchor
vec_4 = get_embedding(sentence_4)

print(f"Query: '{sentence_3}'")
print(f"Score vs '{sentence_1}' (Fruit context): {cosine_similarity(vec_3, vec_1):.4f}")
print(f"Score vs '{sentence_2}' (Tech context):  {cosine_similarity(vec_3, vec_2):.4f}")

Step 5: Fixing the Support Bot

Let's solve the problem from the beginning of the lesson. We will build a semantic search loop.

print("\n--- Semantic Search Engine ---")

database = [
    "Wi-Fi signal is weak in the basement",
    "Billing: How to update credit card",
    "Router lights are not blinking",
    "Connection speed is very slow"
]

user_query = "My internet is dead"

# 1. Embed the query
query_vec = get_embedding(user_query)

# 2. Search the database
best_score = -1
best_match = ""

print(f"Query: {user_query}")

for entry in database:
    # Embed the database entry
    # (In production, you would do this once and save it, not every time!)
    entry_vec = get_embedding(entry)
    
    score = cosine_similarity(query_vec, entry_vec)
    print(f"  - '{entry}': {score:.4f}")
    
    if score > best_score:
        best_score = score
        best_match = entry

print(f"\nWINNER: '{best_match}' with score {best_score:.4f}")

Even though "My internet is dead" shares zero keywords with "Router lights are not blinking," the similarity score will be high (likely > 0.4 or 0.5), while "Billing" will be low.

You have just built a search engine that thinks like a human.

Now You Try

You have the basics. Now, experiment with these three extensions to solidify your knowledge.

Embed the English sentence "Where is the bathroom?"

Then, create a database with Spanish ("Donde esta el bano") and French ("Ou sont les toilettes").

Run the search. Does the English query match the Spanish text? (Spoiler: Yes, embeddings capture meaning across languages!)

Create a list of emotions: "Happy", "Sad", "Angry", "Excited".

Embed "Tragedy".

Write code to find the word with the lowest cosine similarity score (the most unrelated or opposite concept).

Challenge Project: The Relevance Sorter

Your challenge is to create a reusable function that takes a query and a list of documents, and returns the documents sorted from most relevant to least relevant.

query = "What should I feed my cat?"
docs = [
    "Toyota Camrys are reliable cars.",
    "Felines enjoy eating tuna and chicken.",
    "Dogs are loyal companions.",
    "It is raining outside."
]

Query: What should I feed my cat?
--------------------------------------------------
0.6521 - Felines enjoy eating tuna and chicken.
0.3412 - Dogs are loyal companions.
0.1205 - Toyota Camrys are reliable cars.
0.0912 - It is raining outside.