Document RAG

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain.schema import Document

# Documents with rich metadata
documents = [
    Document(
        page_content="Section 4.2: Employees receive 20 days PTO annually.",
        metadata={
            "source": "employee_handbook.pdf",
            "section": "benefits",
            "page": 42,
            "year": 2024,
            "department": "HR"
        }
    ),
    Document(
        page_content="API rate limits are 1000 requests per minute.",
        metadata={
            "source": "api_docs.pdf",
            "section": "limits",
            "page": 15,
            "year": 2024,
            "department": "Engineering"
        }
    ),
    # ... more documents
]

# Create vectorstore
vectorstore = FAISS.from_documents(documents, OpenAIEmbeddings())

# Filtered retrieval - only search HR documents
results = vectorstore.similarity_search(
    "vacation policy",
    k=5,
    filter={"department": "HR"}
)

# Multiple filter conditions
results = vectorstore.similarity_search(
    "rate limits",
    k=5,
    filter={"source": "api_docs.pdf", "year": 2024}
)

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

def generate_with_citations(query: str, chunks: list) -> dict:
    """Generate answer with inline citations."""

    # Format chunks with citation markers
    context_parts = []
    for i, chunk in enumerate(chunks):
        source = chunk.metadata.get("source", "Unknown")
        page = chunk.metadata.get("page", "N/A")
        context_parts.append(f"[{i+1}] (Source: {source}, Page: {page})\n{chunk.page_content}")

    context = "\n\n".join(context_parts)

    prompt = ChatPromptTemplate.from_messages([
        ("system", """Answer questions using ONLY the provided context.
Include inline citations like [1], [2] when referencing sources.
If the context doesn't contain the answer, say "I don't have enough information."
Always cite your sources."""),
        ("user", """Context:
{context}

Question: {question}

Answer with citations:""")
    ])

    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    chain = prompt | llm

    response = chain.invoke({
        "context": context,
        "question": query
    })

    # Extract citations used
    import re
    citations_used = set(re.findall(r'\[(\d+)\]', response.content))

    return {
        "answer": response.content,
        "sources": [
            {
                "citation": f"[{i+1}]",
                "source": chunks[i].metadata.get("source"),
                "page": chunks[i].metadata.get("page"),
                "text": chunks[i].page_content[:200] + "..."
            }
            for i in range(len(chunks))
            if str(i+1) in citations_used
        ]
    }

# Usage
result = generate_with_citations("What is the vacation policy?", retrieved_chunks)
print(result["answer"])
print("\nSources:")
for source in result["sources"]:
    print(f"  {source['citation']}: {source['source']}, page {source['page']}")

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from sentence_transformers import CrossEncoder
import numpy as np

class ProductionRAG:
    def __init__(self):
        self.embeddings = OpenAIEmbeddings()
        self.llm = ChatOpenAI(model="gpt-4o", temperature=0)
        self.reranker = CrossEncoder('BAAI/bge-reranker-large')
        self.vectorstore = None

    def ingest(self, documents: list):
        """Ingest documents with smart chunking."""
        splitter = RecursiveCharacterTextSplitter(
            chunk_size=500,
            chunk_overlap=50,
            separators=["\n\n", "\n", ". ", " "]
        )
        chunks = splitter.split_documents(documents)
        self.vectorstore = FAISS.from_documents(chunks, self.embeddings)
        return len(chunks)

    def retrieve(self, query: str, k: int = 10,
                 rerank_k: int = 5, filters: dict = None) -> list:
        """Retrieve with optional filtering and reranking."""
        # Stage 1: Vector retrieval
        if filters:
            candidates = self.vectorstore.similarity_search(query, k=k, filter=filters)
        else:
            candidates = self.vectorstore.similarity_search(query, k=k)

        if len(candidates) <= rerank_k:
            return candidates

        # Stage 2: Reranking
        pairs = [[query, doc.page_content] for doc in candidates]
        scores = self.reranker.predict(pairs)
        ranked_indices = np.argsort(scores)[::-1][:rerank_k]

        return [candidates[i] for i in ranked_indices]

    def generate(self, query: str, chunks: list) -> dict:
        """Generate answer with citations."""
        context_parts = []
        for i, chunk in enumerate(chunks):
            source = chunk.metadata.get("source", "Unknown")
            page = chunk.metadata.get("page", "N/A")
            context_parts.append(
                f"[{i+1}] (Source: {source}, Page: {page})\n{chunk.page_content}"
            )

        prompt = ChatPromptTemplate.from_messages([
            ("system", """Answer using ONLY the provided context.
Include inline citations [1], [2], etc. when referencing sources.
If context is insufficient, say so. Always cite sources."""),
            ("user", "Context:\n{context}\n\nQuestion: {question}")
        ])

        chain = prompt | self.llm
        response = chain.invoke({
            "context": "\n\n".join(context_parts),
            "question": query
        })

        return {
            "answer": response.content,
            "chunks": chunks
        }

    def query(self, question: str, filters: dict = None) -> dict:
        """Full RAG pipeline."""
        chunks = self.retrieve(question, filters=filters)
        return self.generate(question, chunks)

# Usage
rag = ProductionRAG()
num_chunks = rag.ingest(documents)
print(f"Indexed {num_chunks} chunks")

result = rag.query(
    "What is the vacation policy?",
    filters={"department": "HR"}
)
print(result["answer"])

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

# Prepare evaluation data
eval_data = {
    "question": [
        "What is the vacation policy?",
        "How do I reset my password?"
    ],
    "answer": [
        "Employees receive 20 days PTO annually [1].",
        "You can reset via the self-service portal [1]."
    ],
    "contexts": [
        ["Section 4.2: Employees receive 20 days PTO annually."],
        ["Password reset is available in the IT self-service portal."]
    ],
    "ground_truth": [
        "20 days paid time off per year",
        "Use the self-service portal"
    ]
}

dataset = Dataset.from_dict(eval_data)

# Run evaluation
results = evaluate(
    dataset,
    metrics=[
        context_precision,
        context_recall,
        faithfulness,
        answer_relevancy
    ]
)

print(results)
# Output:
# {'context_precision': 0.92, 'context_recall': 0.88,
#  'faithfulness': 0.95, 'answer_relevancy': 0.91}