Instead of: [Entire PDF] + Question → LLM → Answer

RAG does:   Question → Find relevant chunks → [Top 4 chunks] + Question → LLM → Answer

PDF → Extract Text → Split into Chunks → Embed Chunks → Store in FAISS

Question → Embed Question → FAISS Search → Top-K Chunks → LLM → Answer

pip install streamlit langchain langchain-community langchain-core \
  langchain-text-splitters faiss-cpu pypdf sentence-transformers \
  python-dotenv groq torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/cpu

GROQ_API_KEY=gsk_xxxxxxxxxxxxxxxxxxxxxxxx

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.runnables import RunnableLambda
from groq import Groq
from dotenv import load_dotenv
import tempfile, os

load_dotenv()

EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
GROQ_MODEL      = "llama-3.1-8b-instant"
GROQ_API_KEY    = os.getenv("GROQ_API_KEY")

def load_and_index(uploaded_files):
    all_chunks = []

    for uploaded_file in uploaded_files:
        # Save to temp file so PyPDFLoader can read it
        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
            tmp.write(uploaded_file.read())
            tmp_path = tmp.name

        loader    = PyPDFLoader(tmp_path)
        documents = loader.load()
        os.unlink(tmp_path)  # clean up

        # Tag each page with its source filename
        for doc in documents:
            doc.metadata["source_file"] = uploaded_file.name

        # Split into overlapping chunks
        splitter = RecursiveCharacterTextSplitter(
            chunk_size=500,
            chunk_overlap=50,  # overlap prevents losing info at boundaries
        )
        chunks = splitter.split_documents(documents)
        all_chunks.extend(chunks)

    # Embed and index
    embeddings = HuggingFaceEmbeddings(
        model_name=EMBEDDING_MODEL,
        model_kwargs={"device": "cpu"},
    )
    vectorstore = FAISS.from_documents(all_chunks, embeddings)
    return vectorstore

def answer_question(question: str, context: str, history: list) -> str:
    client = Groq(api_key=GROQ_API_KEY)

    messages = [
        {
            "role": "system",
            "content": """You are an intelligent assistant and expert tutor.
Given relevant excerpts from a PDF document and a question:
1. Explain the concept thoroughly in simple, clear language
2. Use the document as your primary source but add helpful context
3. Structure answers with bullet points when helpful
4. Always cite which file and page the information came from
5. End with a key takeaway in one sentence"""
        }
    ]

    # Inject last 6 messages as conversational memory
    for h in history[-6:]:
        messages.append({"role": h["role"], "content": h["content"]})

    messages.append({
        "role": "user",
        "content": f"Context:\n{context}\n\nQuestion: {question}"
    })

    response = client.chat.completions.create(
        model=GROQ_MODEL,
        messages=messages,
        temperature=0.3,
        max_tokens=1024,
    )
    return response.choices[0].message.content.strip()

def build_qa_chain(vectorstore):
    retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

    def run_chain(inputs: dict):
        docs    = retriever.invoke(inputs["question"])
        context = "\n\n".join(
            f"[{doc.metadata.get('source_file')} | Page {doc.metadata.get('page', 0)+1}]\n{doc.page_content}"
            for doc in docs
        )
        answer = answer_question(
            inputs["question"],
            context,
            inputs.get("history", [])
        )
        return answer, docs

    return run_chain, retriever

import streamlit as st
from rag_pipeline import load_and_index, build_qa_chain
from dotenv import load_dotenv

load_dotenv()

st.set_page_config(page_title="PDF Q&A Pro", page_icon="📄", layout="wide")
st.title("📄 PDF Q&A Pro")

# Sidebar: upload
with st.sidebar:
    uploaded_files = st.file_uploader(
        "Upload PDFs", type="pdf", accept_multiple_files=True
    )
    if uploaded_files:
        file_key = "_".join(sorted(f.name for f in uploaded_files))
        if st.session_state.get("file_key") != file_key:
            with st.spinner("Indexing PDFs..."):
                vs = load_and_index(uploaded_files)
                st.session_state.qa_fn, st.session_state.retriever = build_qa_chain(vs)
                st.session_state.file_key = file_key
                st.session_state.messages = []
            st.success("Ready!")

# Chat interface
for msg in st.session_state.get("messages", []):
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

if question := st.chat_input("Ask anything about your PDFs..."):
    st.session_state.messages.append({"role": "user", "content": question})
    with st.chat_message("user"):
        st.markdown(question)

    with st.chat_message("assistant"):
        with st.spinner("Thinking..."):
            answer, sources = st.session_state.qa_fn({
                "question": question,
                "history": st.session_state.messages[:-1],
            })
        st.markdown(answer)

        with st.expander("📚 Sources"):
            for i, doc in enumerate(sources, 1):
                st.markdown(
                    f"**Chunk {i}** — `{doc.metadata.get('source_file')}` "
                    f"| Page {doc.metadata.get('page', 0)+1}"
                )
                st.caption(doc.page_content[:300] + "...")

    st.session_state.messages.append({"role": "assistant", "content": answer})

python -m streamlit run app.py

# OLD (broken in v0.2+)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.prompts import PromptTemplate

# NEW (correct)
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import PromptTemplate

import requests

models = ["google/flan-t5-large", "facebook/bart-large-cnn", "deepset/roberta-base-squad2"]
token  = "hf_yourtoken"
headers = {"Authorization": f"Bearer {token}"}

for model in models:
    r = requests.post(
        f"https://router.huggingface.co/hf-inference/models/{model}",
        headers=headers,
        json={"inputs": "test"}
    )
    print(f"{model}: {r.status_code}")

Extractive (roberta-squad2):
Q: "What is machine learning?"
A: "a subset of artificial intelligence"  ← just copied from PDF

Generative (Llama 3.1):
Q: "What is machine learning?"
A: "Machine learning is a branch of AI that enables computers to learn 
   patterns from data without being explicitly programmed. According to 
   page 3 of your document..."  ← actual explanation

'InferenceClient' object has no attribute 'post'

import requests

def call_hf_api(prompt, token, model_url):
    response = requests.post(
        model_url,
        headers={"Authorization": f"Bearer {token}"},
        json={"inputs": prompt, "options": {"wait_for_model": True}},
        timeout=60
    )
    return response.json()[0]["generated_text"]

"Use only the context to answer. Do not make up information."

"You are an expert tutor. Explain thoroughly in simple language. 
Add examples. Structure with bullets. Cite sources. End with a key takeaway."