Vector Databases Explained for Beginners

import numpy as np
import faiss

# Create some sample vectors (128-dimensional)
dimension = 128
nb_vectors = 10000
vectors = np.random.random((nb_vectors, dimension)).astype('float32')

# Create a FAISS index for fast lookup
index = faiss.IndexFlatL2(dimension)  # L2 means Euclidean distance
index.add(vectors)  # Add vectors to the index

# Search for similar vectors
k = 5  # Number of nearest neighbors to find
query_vector = np.random.random((1, dimension)).astype('float32')
distances, indices = index.search(query_vector, k)

print(f"Found {k} nearest neighbors at indices: {indices}")
print(f"With distances: {distances}")

import pinecone
from sentence_transformers import SentenceTransformer

# Initialize connection to Pinecone
pinecone.init(api_key="YOUR_API_KEY", environment="us-west1-gcp")

# Create or connect to an index
index_name = "product-recommendations"
dimension = 384  # Depends on your embedding model

# Create index if it doesn't exist
if index_name not in pinecone.list_indexes():
    pinecone.create_index(name=index_name, dimension=dimension, metric="cosine")

# Connect to the index
index = pinecone.Index(index_name)

# Create embeddings from text
model = SentenceTransformer('all-MiniLM-L6-v2')
products = [
    "Wireless noise-cancelling headphones",
    "Bluetooth portable speaker",
    "Smart home assistant device"
]
product_ids = ["prod-101", "prod-102", "prod-103"]
embeddings = model.encode(products).tolist()

# Insert vectors with metadata
vectors_with_ids = list(zip(product_ids, embeddings, [{"category": "electronics"} for _ in products]))
index.upsert(vectors=vectors_with_ids)

# Query for similar products
query = "Headset for video calls"
query_embedding = model.encode([query]).tolist()[0]
results = index.query(vector=query_embedding, top_k=2, include_metadata=True)

print(f"Query: {query}")
for match in results['matches']:
    print(f"Product ID: {match['id']}, Score: {match['score']}")
    print(f"Metadata: {match['metadata']}")

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

# Create sample documents
documents = [
    "How to install Python on Windows",
    "Setting up a virtual environment in Python",
    "Python basics for beginners",
    "Advanced data structures in Python",
    "Web development with Django framework"
]

# Create embeddings
model = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = model.encode(documents)
dimension = embeddings.shape[1]

# Create FAISS index
index = faiss.IndexFlatL2(dimension)
index.add(np.array(embeddings).astype('float32'))

# Search function
def semantic_search(query, top_k=2):
    query_vector = model.encode([query]).astype('float32')
    distances, indices = index.search(query_vector, top_k)
    results = [{"document": documents[idx], "score": 1 - (dist/2)} 
              for idx, dist in zip(indices[0], distances[0])]
    return results

# Example search
results = semantic_search("How do I get started with Python?")
for result in results:
    print(f"Document: {result['document']}")
    print(f"Relevance: {result['score']:.4f}")
    print()

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.document_loaders import TextLoader
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
import os

# Set OpenAI API key
os.environ["OPENAI_API_KEY"] = "your-api-key"

# 1. Load document
loader = TextLoader("company_handbook.txt")
documents = loader.load()

# 2. Split text into chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
texts = text_splitter.split_documents(documents)

# 3. Create embeddings and vector store
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(texts, embeddings)

# 4. Create QA chain
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

# 5. Ask questions
question = "What is our company's vacation policy?"
answer = qa_chain.run(question)
print(answer)

import numpy as np
import faiss
from sentence_transformers import SentenceTransformer

# Sample product data
products = [
    {"id": 1, "name": "Wireless Gaming Mouse", "description": "High precision wireless gaming mouse with RGB lighting"},
    {"id": 2, "name": "Mechanical Keyboard", "description": "Tactile mechanical keyboard for gaming enthusiasts"},
    {"id": 3, "name": "Ultra-wide Monitor", "description": "34-inch curved ultra-wide monitor for immersive gaming"},
    {"id": 4, "name": "Gaming Headset", "description": "Surround sound gaming headset with noise-cancelling mic"},
    {"id": 5, "name": "Gaming Chair", "description": "Ergonomic gaming chair with lumbar support and adjustable armrests"}
]

# Generate embeddings for products
model = SentenceTransformer('all-MiniLM-L6-v2')
product_descriptions = [p["description"] for p in products]
product_embeddings = model.encode(product_descriptions)

# Create FAISS index
dimension = product_embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(np.array(product_embeddings).astype('float32'))

# Recommendation function
def get_recommendations(product_id, top_k=2):
    # Get product by ID
    product = next((p for p in products if p["id"] == product_id), None)
    if not product:
        return []
    
    # Create query vector from product description
    query_vector = model.encode([product["description"]]).astype('float32')
    
    # Find similar products
    distances, indices = index.search(query_vector, top_k + 1)  # +1 because the product itself will be included
    
    # Filter out the query product and format results
    recommendations = []
    for idx, dist in zip(indices[0], distances[0]):
        if products[idx]["id"] != product_id:  # Skip the query product
            recommendations.append({
                "product": products[idx],
                "similarity_score": 1 - (dist/2)  # Convert distance to similarity score
            })
    
    return recommendations[:top_k]  # Return only top_k recommendations

# Example: Get recommendations for product ID 2 (Mechanical Keyboard)
recommendations = get_recommendations(product_id=2)
print(f"Recommendations for {products[1]['name']}:")
for rec in recommendations:
    print(f"- {rec['product']['name']} (Score: {rec['similarity_score']:.4f})")
    print(f"  {rec['product']['description']}")
    print()