Embeddings & Vector DB interview questions & answers

Ek bada sa map imagine kar jahan har word ya sentence ko uski meaning ke hisaab se jagah milti hai — spelling ke hisaab se nahi. Is map pe "dog" aur "puppy" bilkul paas paas baithe honge, "dog" aur "cat" thoda door honge (phir bhi same "animals" wale area mein), aur "dog" aur "laptop" map ke bilkul opposite corners mein honge. Wahi map computer ko ek embedding deta hai.

In an embedding, koi bhi text (ek word, sentence, ya poora paragraph) numbers ki ek list — ek vector — mein convert ho jaata hai jo uski meaning capture karta hai. In Python, wo vector bas ek list (ya NumPy array) hoti hai floats ki, jaise [0.023, -0.045, 0.089, ...], jo aksar 1536 numbers lambi hoti hai. Do texts jinki meaning similar hai, unke vectors is "meaning space" mein paas paas aa jaate hain; unrelated text door chala jaata hai. Computer kabhi words "padhta" nahi — bas number patterns compare karta hai, aur similar meaning matlab similar numbers.

Yahi difference hai purane-style keyword search aur modern semantic search mein. Keyword search literal words match karta hai — "AI" search karo toh "artificial intelligence" wala document nahi dikhega jab tak exact word "AI" na ho. Semantic search embeddings compare karta hai, toh "artificial intelligence", "AI", aur "machine learning" — teeno meaning-space mein paas hote hain aur match ho jaate hain, chahe words bilkul alag ho.

🌍 Real-world example: Amazon pe "warm winter jacket" search karne pe "insulated coat for cold weather" naam ki listing bhi dikh jaati hai — ek bhi word common nahi, par meaning bahut close hai. Yahi hai semantic search, embeddings ki wajah se, keyword match nahi.

💡 Embedding = numbers ki ek list (vector) jo kisi text ki meaning represent karti hai.

💡 Vector = numbers ki ordered list, jaise [0.2, -0.5, 0.8]. Har embedding ek vector hota hai.

💡 Meaning space = wo imaginary multi-dimensional map jahan embeddings rehte hain; similar meanings paas baithti hain, alag meanings door.

💡 Semantic search = meaning se result dhundna (embeddings compare karke) — exact keywords match karne ke bajaye.

Standard definition (interview me bolo): An embedding is a numerical vector representation of text that captures its semantic meaning, such that texts with similar meaning have vectors that are close together in vector space.

from openai import OpenAI

client = OpenAI()

def get_embedding(text):
    """Convert text into a meaning-vector using an embedding model."""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

vector = get_embedding("I love Python for AI")

print(vector[:5])       # peek at first 5 numbers
print(len(vector))      # total dimensions in the vector

Embedding model ko ek translator samajh jo kisi bhi sentence ko ek fixed set of GPS coordinates me convert kar deta hai, ek badi 'meaning map' pe. Tu ye map khud kabhi nahi padhta — bas sentence translator (model) ko de deta hai aur wo tujhe numbers ki ek list wapas deta hai: coordinates. Similar meaning wale sentences us map pe paas-paas ke coordinates pe land karte hain.

Python me, ye translator OpenAI client ka embeddings.create() method hai. Tu isse model (kaunsa translator use karna hai, jaise text-embedding-3-small) aur input (tera text) deta hai, aur ye ek response object return karta hai jisme vector — coordinates — hote hain. Ek diye gaye model se aane wala har vector hamesha same length ka hota hai: text-embedding-3-small hamesha 1536 numbers deta hai, chahe tera sentence 3 words ka ho ya 300 words ka. Yehi fixed size hai jo vector database ko lakhon sentences turant compare karne deta hai.

Real apps me tu ek time pe ek sentence embed kam hi karta hai — tu texts ki ek list input me pass karta hai, aur ek API call har text ke liye ek vector return karti hai, wahi order me jisme tune bheje the. Ye 'batching' loop me ek-ek karke API call karne se fast aur sasta hai.

🌍 Real-world example: Ek search engine 10,000 product descriptions ko ek baar (batches me) embed karta hai aur vectors store kar leta hai. Jab user "warm winter jacket" search karta hai, sirf wahi ek query embed hoti hai aur stored 10,000 se compare hoti hai — koi keyword matching nahi, pure meaning matching.

💡 Embedding vector = fixed-length numbers ki list jo model kisi text ke liye return karta hai. 💡 Dimensions = us list me kitne numbers hain (1536 for text-embedding-3-small). 💡 Batching = ek API call me kai texts bhejna, har text ke liye alag call karne ke bajaye.

Sabse important rule: stored documents aur jo query se search kar raha hai, dono ke liye hamesha same embedding model use kar. text-embedding-3-small aur text-embedding-3-large points ko alag-alag maps pe rakhte hain — ek se aaya vector, doosre se aaye vector se compare karna meaningless hai, chahe dono 'numbers ki lists' hi kyun na dikhein. Scale pe ye bhi yaad rakh ki embedding calls paise aur time lete hain, isliye ek call me kai texts batch karna (har text ke liye alag call karne ke bajaye) dono bachata hai.

Standard definition (interview me bolo): An embedding API call sends text to an embedding model (e.g. OpenAI text-embedding-3-small) and returns a fixed-length numeric vector representing that text's meaning; the same model must be used to embed both the stored documents and the search query.

from openai import OpenAI

client = OpenAI()  # reads your API key from the environment

texts = [
    "Python is great for AI",
    "JavaScript rules the web"
]

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=texts   # a LIST -> batched in one call
)

embeddings = [item.embedding for item in response.data]

print(f"Got {len(embeddings)} vectors")
print(f"Each vector has {len(embeddings[0])} dimensions")
print(f"First 5 values of vector 0: {embeddings[0][:5]}")

Kya bana rahe hain: Ek chhota par complete semantic search engine — ek script jo kisi sawaal ka jawab meaning se deti hai, exact words match karke nahi. Tum ise ek chhota knowledge base doge (jaise, FAQ answers), aur ye kisi bhi query ke liye sabse relevant answers dhoondh legi — chahe query bilkul alag words use kare. Yahi ek script exact retrieval engine hai har RAG (Retrieval-Augmented Generation) app ke peeche jo tum kabhi banaoge. Chapter 4 mein tum is script ke top results ko ek LLM ko doge final answer likhwaane ke liye — yahi RAG ki poori trick hai.

---

Step 0 — Mental model (pehle padho, 30 second)

Keyword search poochti hai: "kya is document mein ye exact words hain?" — ye "AI programming" search karne pe "machine learning coding" wale document ko poori tarah miss kar degi, jabki dono ka matlab lagbhag same hai.

Semantic search alag sawaal poochti hai: "kya ye document us cheez ke close matlab rakhta hai jo main pooch raha hoon?" Ye ye karti hai har text piece ko ek embedding mein badal ke — numbers ki ek list (vector) jo uska meaning capture karti hai — fir ye measure karke ki us "meaning-space" mein do vectors kitne close hain. Close vectors = close meaning.

Poora engine char beats hai, repeat hote hue:

1. Embed — har document ko ek baar, shuru mein — har doc ke text ko vector mein badlo.
2. Store — har (text, vector) pair ko kahin rakho jaha baad mein loop kar sako (ek plain Python list chhote project ke liye kaafi hai; ChromaDB jaisa vector DB tab lete ho jab millions docs ho jaayein).
3. Embed — user ki query ko waise hi, same embedding model use karke.
4. Rank: query vector aur har stored vector ke beech cosine similarity compute karo, sort karo, aur top-k texts return karo.

💡 Cosine similarity = -1 aur 1 ke beech ka ek number (practically, text embeddings ke liye, roughly 0 se 1) jo do vectors ke beech ka angle measure karta hai. 1 ka matlab "same direction mein point kar rahe" (same meaning), 0 ka matlab unrelated.

🌍 Real-world example: yahi exact loop — docs ek baar embed karo, query embed karo, rank karo, top-k return karo — ChatGPT ke custom GPTs mein "search", Notion AI ke "ask your workspace", aur har customer-support chatbot ke peeche chalta hai jo company ke help docs se jawab deta hai. Wo bas in-memory list ki jagah scale pe real vector database use karte hain.

---

Step 1 — Knowledge base: documents ki ek list

documents = [
    "To reset your password, go to Settings > Security and click 'Reset Password'.",
    "Our refund policy allows returns within 30 days of purchase with a valid receipt.",
    "You can upgrade to the Pro plan anytime from the Billing page in your dashboard.",
    "The mobile app is available for both iOS and Android from their respective stores.",
    "To cancel your subscription, go to Billing > Manage Plan > Cancel Subscription.",
    "We support UPI, credit cards, and net banking for all payments in India.",
]

Ho ye raha hai: documents bas ek plain Python list of strings hai — isse zyada kuch nahi. Real app mein ye FAQ answers, support-ticket resolutions, ya product doc chunks ho sakte hain jo database se aaye hon. Is poore project ka point hai: is list ko meaning se search karne layak banao.

---

Step 2 — Har document ko EK BAAR embed karo

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=documents          # batch -- SAARE documents ke liye ek API call
)

doc_vectors = [item.embedding for item in response.data]

Ho ye raha hai: client.embeddings.create(model=..., input=documents) poori list ek hi HTTPS request mein bhejta hai — API list accept karti hai, to tumhe loop karke ise chhe alag baar call nahi karna padta (slower + costlier). Reply ka .data result objects ki ek list hai same order mein jo documents hai, aur har ek pe item.embedding asli vector hai — text-embedding-3-small ke liye ye 1536 floats ki list hai. Is line ke baad, doc_vectors[i] documents[i] ka meaning-vector hai — same index, same order, to tum hamesha ek ko dusre se map kar sakte ho.

💡 Embedding model = wo AI model jiska sirf ek kaam hai — text → vector. text-embedding-3-small (1536 dimensions) is tarah ke project ke liye OpenAI ka sasta, solid default hai.

Crucial rule: tum documents ko ek baar embed karte ho, shuru mein, har search pe nahi — yahi poori performance win hai. Real app ye step data-ingestion time pe karega aur vectors cache kar lega (ek file, database column, ya vector DB mein); har user query pe saare documents dobara embed NAHI karega.

---

Step 3 — (text, vector) pairs store karo

# Sabse simple "vector store": tuples ki ek Python list
vector_store = list(zip(documents, doc_vectors))
# vector_store[i] = (documents[i], doc_vectors[i])

Ho ye raha hai: zip(documents, doc_vectors) har document ko uske apne vector ke saath pair karta hai, position by position, aur list(...) use (text, vector) tuples ki list mein badal deta hai. Ye hi ek vector store hai — bas sabse chhota possible wala. Ek real vector store (ChromaDB, Pinecone, pgvector) bilkul yahi kaam karta hai — (text/metadata, vector) ko saath rakhna — par ek index add karta hai taaki millions ke beech nearest vectors milliseconds mein mil jaayein, ek-ek karke loop kiye bina.

💡 Vector database = ek store jo bahut saare vectors rakhne aur unmein se nearest ones fast dhoondhne ke liye bana hai, approximate-nearest-neighbor (ANN) index (jaise HNSW) use karke, har vector se ek-ek karke compare karne ki jagah. Is project jaise mutthi-bhar documents ke liye, plain list genuinely theek hai — ChromaDB/Pinecone/pgvector tab chahiye jab thousands-se-millions documents ho jaayein.

---

Step 4 — User ki query embed karo (same model, hamesha)

query = "How do I get my money back?"

query_response = client.embeddings.create(
    model="text-embedding-3-small",   # documents wale model se MATCH hona chahiye
    input=query
)
query_vector = query_response.data[0].embedding

Ho ye raha hai: Notice karo, query mein matching document ("Our refund policy allows returns within 30 days...") se koi bhi word common nahi hai — na "money", na "back", koi overlap nahi. Keyword search kuch nahi dhoondh paati. Semantic search fir bhi ise dhoondh legi, kyunki dono sentences isi cheez ke baare mein hain — refund lena — aur unke embeddings meaning-space mein close land karenge.

Wo rule jo sab kuch tod deta hai agar skip karo: query ko EXACTLY wahi model se embed karna chahiye jo documents ke liye use hua tha (text-embedding-3-small yahaan, -large ya ada-002 nahi). Alag embedding models vectors ko alag, incompatible spaces mein rakhte hain — ek -small query vector ko -large document vectors se compare karna meaningless numbers deta hai, chahe koi error na aaye.

---

Step 5 — Har document ko cosine similarity se rank karo

import numpy as np

def cosine_similarity(a, b):
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

scored = []
for text, vector in vector_store:
    score = cosine_similarity(query_vector, vector)
    scored.append((score, text))

scored.sort(reverse=True)   # highest similarity pehle

Ho ye raha hai, traced: cosine_similarity(a, b) dot(a, b) / (norm(a) * norm(b)) compute karta hai — dot product measure karta hai ki do vectors kitna same direction mein point karte hain, aur dono norms (lengths) se divide karna vector magnitude ka effect hata deta hai, sirf angle reh jaata hai unke beech. for text, vector in vector_store: loop har stored tuple ko unpack karta hai — Chapter 1 wala hi tuple-unpacking pattern — aur single query_vector ke against har document ke liye ek similarity score compute karta hai. scored end mein (score, text) tuples ki list ban jaati hai; scored.sort(reverse=True) tuples ko by default unke pehle element se sort karta hai, jo exactly score hai, to sabse similar document index 0 pe aa jaata hai.

💡 Cosine similarity ek line mein: dot(a, b) / (|a| * |b|) — same formula chahe tum ise haath se NumPy mein likho ya ChromaDB/Pinecone/pgvector ko internally ek index pe chalane do.

---

Step 6 — Top-k sabse relevant documents return karo

top_k = 2
top_results = scored[:top_k]

for score, text in top_results:
    print(f"{score:.4f}  ->  {text}")

Ho ye raha hai: scored[:top_k] sorted list ko slice karke sirf best top_k results tak rakh deta hai — ek plain Python list slice, kuch naya nahi. Loop har (score, text) pair ko unpack karta hai aur similarity score ko matching document ke saath print karta hai. Ye search engine ka final output hai: "How do I get my money back?" diya jaaye to top result refund-policy wala document hai, pure meaning se ranked.

---

🔎 Poora flow (wiring ka recap, embed → store → query → rank → return)

1. documents — strings ki plain list, tumhara knowledge base.
2. client.embeddings.create(model=..., input=documents) — ek batched API call SAARE documents ko ek baar embed karta hai; doc_vectors[i] index se documents[i] ke saath match karta hai.
3. vector_store = list(zip(documents, doc_vectors)) — sabse simple vector store: (text, vector) tuples ek list mein. (Is line ko ChromaDB se badlo aur baaki pipeline mein kuch nahi badalta.)
4. client.embeddings.create(model=..., input=query) — user ki query ko wahi exact model se embed karo jo documents ke liye use hua tha.
5. cosine_similarity(query_vector, vector) vector_store pe loop mein — har document ko query ke against score karo.
6. scored.sort(reverse=True) fir scored[:top_k] — rank karo aur sirf best matches rakho.
7. print(...) top-k (score, text) results ka — done.

Is chapter ka har embeddings concept yahaan dikhta hai: text → vector (Step 2/4), ek vector store (Step 3), cosine similarity + ranking (Step 5/6). vector_store ko ek real ChromaDB collection se badlo aur is pipeline ki shape mushkil se badalti hai — tum khud list banane ki jagah collection.add(documents=..., ids=...) call karoge, aur manual loop ki jagah collection.query(query_texts=[query], n_results=top_k) — ChromaDB internally exactly Steps 2-3-5-6 karta hai, plain loop ki jagah ANN index ke saath.

---

🚀 Ye HI RAG ka retrieval half hai

RAG (Retrieval-Augmented Generation) exactly yahi pipeline hai, plus ek aur step. top_results ko sirf print karne ki jagah, tum unka text jod ke ek LLM prompt mein paste karoge — "Answer the user's question using ONLY this context: {top_results}. Question: {query}" — aur LLM ko ek natural-language answer likhne doge jo tumhare real documents pe grounded ho, raw matches print karne ki jagah. Chapter 4 (RAG) exactly wahaan se shuru hota hai jahaan ye script khatam hoti hai: ye top_results leta hai aur Chapter 1 ke client.responses.create(...) mein feed karta hai. Jo bhi piece tumne abhi banaya — embed, store, query, rank, top-k — wo sab retrieval hai; sirf final "in docs se answer karo" wala LLM step naya hai.

---

✅ Jo tumne abhi seekha — aur aage kya hai

• Semantic search = ek baar embed karo, query embed karo, cosine-rank karo, top-k return karo — char beats, aur is project ne char ke char end-to-end trace kiye.
• Documents ek baar embed hote hain, shuru mein — har query pe kabhi re-embed nahi; yahi performance aur cost win hai.
• Query ko documents wale hi embedding model se embed karna zaroori hai, warna similarity scores meaningless ho jaate hain.
• Vector store bas (text, vector) pairs hai — ek Python list ek real (tiny) vector store hai; ChromaDB/Pinecone/pgvector wahi idea hai scale ke liye ek ANN index ke saath.
• Cosine similarity meaning se rank karta hai, shared words se nahi — isliye "How do I get my money back?" ne zero overlapping words hone ke bawajood sahi tarah refund-policy sentence match kiya.
• Ye RAG ka retrieval half hai. Chapter 4 top_results ko seedha ek LLM prompt mein plug karta hai grounded, natural-language answer generate karne ke liye.

Standard definition (interview me bolo): A semantic search engine embeds a fixed set of documents once into vectors using an embedding model, stores each vector alongside its original text, embeds an incoming query with that same model, ranks every stored document by cosine similarity to the query vector, and returns the top-k highest-scoring documents — the exact retrieval step that RAG systems feed into an LLM to generate grounded answers.

import os
import numpy as np
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Step 1: the knowledge base
documents = [
    "To reset your password, go to Settings > Security and click 'Reset Password'.",
    "Our refund policy allows returns within 30 days of purchase with a valid receipt.",
    "You can upgrade to the Pro plan anytime from the Billing page in your dashboard.",
    "The mobile app is available for both iOS and Android from their respective stores.",
    "To cancel your subscription, go to Billing > Manage Plan > Cancel Subscription.",
    "We support UPI, credit cards, and net banking for all payments in India.",
]

# Step 2: embed every document ONCE (batched, one API call)
response = client.embeddings.create(model="text-embedding-3-small", input=documents)
doc_vectors = [item.embedding for item in response.data]

# Step 3: store (text, vector) pairs -- the simplest possible vector store
vector_store = list(zip(documents, doc_vectors))


def cosine_similarity(a, b):
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


def semantic_search(query, top_k=2):
    # Step 4: embed the query with the SAME model used for documents
    query_vector = client.embeddings.create(
        model="text-embedding-3-small", input=query
    ).data[0].embedding

    # Step 5: rank every document by cosine similarity
    scored = [(cosine_similarity(query_vector, vec), text) for text, vec in vector_store]
    scored.sort(reverse=True)

    # Step 6: return the top-k most relevant documents
    return scored[:top_k]


query = "How do I get my money back?"
for score, text in semantic_search(query, top_k=2):
    print(f"{score:.4f}  ->  {text}")