Vector Stores

from langchain_openai import OpenAIEmbeddings
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# ===== The flow =====
# raw docs -> split -> embed -> store -> later: query -> retrieve top-k

emb = OpenAIEmbeddings(model='text-embedding-3-small')

# ===== Load + split =====
docs = TextLoader('handbook.md').load()
splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=120)
chunks = splitter.split_documents(docs)

# ===== Chroma (local, file-backed) =====
from langchain_chroma import Chroma
store = Chroma.from_documents(chunks, emb, persist_directory='./chroma')

# Query later:
results = store.similarity_search('how do refunds work?', k=4)
for r in results: print(r.page_content[:200])

# ===== Pinecone (managed) =====
from langchain_pinecone import PineconeVectorStore
import pinecone
pc = pinecone.Pinecone(api_key='...')
# Pre-create the index in the Pinecone console with the right dim (1536 for OpenAI small).
store2 = PineconeVectorStore.from_documents(chunks, emb, index_name='handbook')

# ===== Qdrant (open-source, self-host or cloud) =====
from langchain_qdrant import QdrantVectorStore
store3 = QdrantVectorStore.from_documents(
    chunks, emb,
    url='http://localhost:6333',
    collection_name='handbook',
)

# ===== Weaviate, Milvus, pgvector, FAISS =====
# Same shape: from_documents + similarity_search.

# ===== As a retriever =====
retriever = store.as_retriever(search_kwargs={'k': 4})
docs_for_q = retriever.invoke('how do refunds work?')

# Compose into a chain:
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template('Answer from this context:\n{context}\n\nQ: {q}\nA:')
llm = ChatOpenAI(model='gpt-4o-mini', temperature=0)
chain = (
    { 'context': retriever | (lambda d: '\n\n'.join(x.page_content for x in d)),
      'q': lambda x: x }
    | prompt | llm | StrOutputParser()
)
print(chain.invoke('how do refunds work?'))

# ===== Filtering / metadata =====
chunks_with_meta = [
    type(c)(page_content=c.page_content, metadata={'team': 'support', **c.metadata})
    for c in chunks
]
store.add_documents(chunks_with_meta)
results = store.similarity_search('refunds', k=4, filter={'team': 'support'})

# ===== Reranking =====
# Raw vector similarity is noisy. Add a reranker for top-N:
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CohereRerank
rerank = CohereRerank(model='rerank-english-v3.0', top_n=4)
reranked = ContextualCompressionRetriever(base_compressor=rerank, base_retriever=store.as_retriever(search_kwargs={'k': 20}))

# ===== Which store to pick =====
# Chroma     local prototypes; single-machine
# Pinecone   fully managed; great DX; pay per RU
# Qdrant     self-host or managed; filtering + payload features
# Weaviate   schema-rich; modular ML integrations
# Milvus     huge scale (billions of vectors)
# pgvector   already on Postgres? smallest moving parts
# FAISS      offline batch search; fastest pure ANN

# ===== Patterns to internalise =====
# - chunk_size 600-1000 with overlap 100-200; tune by corpus
# - Match embedding dim to the index (1536 for text-embedding-3-small)
# - Filter by metadata for multi-tenant corpora
# - Rerank when k > 5; it pays for itself in answer quality

# ===== Pitfalls =====
# - Mixing embedding models across writes + queries (must match)
# - Chunks too small -> sentences split, embeddings lose meaning
# - No metadata filter on shared corpora -> data leaks across tenants
# - Trusting cosine similarity > 0.7 = 'relevant' (varies per model)

from langchain_chroma import Chroma
store = Chroma.from_documents(chunks, emb, persist_directory='./chroma')
results = store.similarity_search('refund policy', k=4)