RAG Applications (LLM + Embedding)

═══ INDEXING PHASE (offline) ═══

Documents ──→ [Document Loader] ──→ Raw Text
                                         │
                                    [Text Splitter]
                                         │
                                      Chunks (e.g., 512 tokens each)
                                         │
                                   [Embedding Model]
                                         │
                                    Dense Vectors (e.g., 1536-dim)
                                         │
                                   [Vector Database]  ──→  Stored & Indexed
                                   (with metadata)


═══ QUERY PHASE (online, per request) ═══

User Query ──→ [Embedding Model] ──→ Query Vector
                                            │
                                      [Vector Search]  (top-k similar)
                                            │
                                      Retrieved Chunks (k=5-20)
                                            │
                                       [Reranker]  (optional but recommended)
                                            │
                                      Top Chunks (k=3-5, reranked)
                                            │
                               ┌────────────┴────────────┐
                               │     PROMPT TEMPLATE      │
                               │  System: You are a ...   │
                               │  Context: {chunks}       │
                               │  Question: {query}       │
                               └────────────┬────────────┘
                                            │
                                        [LLM]
                                            │
                                     Generated Answer
                                    (with source citations)

from langchain_community.document_loaders import (
    PyPDFLoader,           # PDF files
    UnstructuredMarkdownLoader,  # Markdown files
    CSVLoader,             # CSV/spreadsheet data
    WebBaseLoader,         # Web pages
    GitLoader,             # Git repositories
    NotionDirectoryLoader, # Notion exports
    ConfluenceLoader,      # Confluence pages (via API)
    SlackDirectoryLoader,  # Slack message exports
)

# Example: Load a PDF
loader = PyPDFLoader("company_handbook.pdf")
documents = loader.load()
print(f"Loaded {len(documents)} pages")

from langchain.text_splitter import (
    RecursiveCharacterTextSplitter,
    MarkdownHeaderTextSplitter,
    TokenTextSplitter,
)

# Recursive splitting (recommended default)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,        # Max characters per chunk
    chunk_overlap=200,      # Overlap between chunks
    separators=["\n\n", "\n", ". ", " ", ""]  # Priority order
)
chunks = splitter.split_documents(documents)

# Markdown-aware splitting (for structured docs)
headers_to_split = [
    ("#", "h1"),
    ("##", "h2"),
    ("###", "h3"),
]
md_splitter = MarkdownHeaderTextSplitter(headers_to_split)
md_chunks = md_splitter.split_text(markdown_text)

print(f"Split into {len(chunks)} chunks")

import os
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# ── Step 1: Load Documents ──
loader = PyPDFLoader("company_handbook.pdf")
documents = loader.load()
print(f"Loaded {len(documents)} pages")

# ── Step 2: Chunk Documents ──
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
)
chunks = splitter.split_documents(documents)
print(f"Created {len(chunks)} chunks")

# ── Step 3: Create Embeddings & Store in ChromaDB ──
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",
    collection_name="company_docs",
)
print("Vector store created and persisted")

# ── Step 4: Create Retriever ──
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5},  # Return top 5 chunks
)

# ── Step 5: Create RAG Prompt ──
rag_prompt = ChatPromptTemplate.from_template("""
You are a helpful assistant that answers questions based on the provided context.
Use ONLY the context below to answer. If the context doesn't contain the answer,
say "I don't have enough information to answer this question."

Always cite which document/section your answer comes from.

Context:
{context}

Question: {question}

Answer:""")

# ── Step 6: Create LLM ──
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# ── Step 7: Build RAG Chain ──
def format_docs(docs):
    return "\n\n---\n\n".join(
        f"[Source: {doc.metadata.get('source', 'unknown')}, "
        f"Page {doc.metadata.get('page', '?')}]\n{doc.page_content}"
        for doc in docs
    )

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# ── Step 8: Query! ──
answer = rag_chain.invoke("What is our company's remote work policy?")
print(answer)

import anthropic
import chromadb
from openai import OpenAI

# ── Initialize clients ──
claude = anthropic.Anthropic()
openai_client = OpenAI()
chroma = chromadb.PersistentClient(path="./chroma_db")
collection = chroma.get_or_create_collection("company_docs")

# ── Embed and store documents (one-time) ──
def index_documents(texts, metadatas, ids):
    """Embed texts and store in ChromaDB."""
    response = openai_client.embeddings.create(
        model="text-embedding-3-small",
        input=texts,
    )
    embeddings = [item.embedding for item in response.data]
    collection.add(
        documents=texts,
        embeddings=embeddings,
        metadatas=metadatas,
        ids=ids,
    )

# ── Retrieve relevant chunks ──
def retrieve(query, top_k=5):
    """Embed query and search for similar chunks."""
    response = openai_client.embeddings.create(
        model="text-embedding-3-small",
        input=[query],
    )
    query_embedding = response.data[0].embedding
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=top_k,
    )
    return results

# ── Generate answer with Claude ──
def rag_query(question):
    """Full RAG pipeline: retrieve context, then generate with Claude."""
    # Retrieve relevant chunks
    results = retrieve(question)
    context_chunks = results["documents"][0]
    metadatas = results["metadatas"][0]

    # Format context with source info
    context = "\n\n---\n\n".join(
        f"[Source: {m.get('source', 'unknown')}]\n{chunk}"
        for chunk, m in zip(context_chunks, metadatas)
    )

    # Generate with Claude
    message = claude.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system="""You are a helpful assistant. Answer questions using ONLY
the provided context. Cite your sources. If the context doesn't
contain enough information, say so clearly.""",
        messages=[{
            "role": "user",
            "content": f"Context:\n{context}\n\nQuestion: {question}",
        }],
    )
    return message.content[0].text

# ── Use it ──
answer = rag_query("What are the vacation day policies?")
print(answer)

import weaviate

client = weaviate.connect_to_local()
collection = client.collections.get("Documents")

# Hybrid search: combines BM25 (keyword) + vector (semantic)
results = collection.query.hybrid(
    query="remote work policy for engineering team",
    alpha=0.7,   # 0.7 = 70% semantic, 30% keyword
    limit=10,
    return_metadata=weaviate.classes.query.MetadataQuery(score=True),
)

for obj in results.objects:
    print(f"Score: {obj.metadata.score:.3f} | {obj.properties['text'][:100]}")

import cohere

co = cohere.Client()

# Initial retrieval returns 20 candidates
initial_results = retriever.get_relevant_documents(query, k=20)

# Rerank to find the best 5
rerank_response = co.rerank(
    model="rerank-v3.5",
    query=query,
    documents=[doc.page_content for doc in initial_results],
    top_n=5,
)

# Use reranked results for LLM context
reranked_docs = [initial_results[r.index] for r in rerank_response.results]
for r in rerank_response.results:
    print(f"Score: {r.relevance_score:.3f} | Index: {r.index}")

def hyde_retrieve(query, retriever, llm):
    """Generate hypothetical answer, embed it, search with that."""
    # Step 1: Generate hypothetical answer
    hypothetical = llm.invoke(
        f"Write a detailed paragraph that would answer this question: {query}"
    )

    # Step 2: Use hypothetical answer as the search query
    # This embeds the hypothetical answer instead of the short query
    results = retriever.get_relevant_documents(hypothetical.content)
    return results

def decompose_and_retrieve(complex_query, llm, retriever):
    """Break complex query into sub-queries, retrieve for each."""
    # Decompose
    decomposition = llm.invoke(
        f"""Break this complex question into 2-4 simpler sub-questions
that can be answered independently:

Question: {complex_query}

Return each sub-question on a new line, numbered."""
    )
    sub_queries = decomposition.content.strip().split("\n")

    # Retrieve for each sub-query
    all_docs = []
    for sub_q in sub_queries:
        docs = retriever.get_relevant_documents(sub_q)
        all_docs.extend(docs)

    # Deduplicate
    seen = set()
    unique_docs = []
    for doc in all_docs:
        if doc.page_content not in seen:
            seen.add(doc.page_content)
            unique_docs.append(doc)

    return unique_docs

from ragas import evaluate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_precision,
    context_recall,
)
from datasets import Dataset

# Prepare evaluation dataset
eval_data = {
    "question": ["What is the remote work policy?", ...],
    "answer": [rag_answer_1, ...],          # RAG system outputs
    "contexts": [[chunk_1, chunk_2], ...],  # Retrieved chunks
    "ground_truth": ["Employees can work...", ...],  # Expected answers
}
dataset = Dataset.from_dict(eval_data)

# Run evaluation
results = evaluate(
    dataset,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
)
print(results)
# {'faithfulness': 0.92, 'answer_relevancy': 0.88,
#  'context_precision': 0.85, 'context_recall': 0.79}

# Stream with Anthropic Claude
with claude.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=system_prompt,
    messages=[{"role": "user", "content": prompt_with_context}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)