Initial deployment to Hugging Face Spaces

.dockerignore

@@ -0,0 +1,40 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+logs/
+*.log
+
+.DS_Store
+.vscode/
+.idea/
+
+faiss_index/
+*.faiss
+
+workflow.png

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY pyproject.toml ./
+COPY requirements.txt* ./
+
+RUN pip install --no-cache-dir uv && \
+    uv pip install --system --no-cache -r pyproject.toml
+
+COPY . .
+
+EXPOSE 8000
+
+ENV PYTHONUNBUFFERED=1
+
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,47 @@
+---
+title: RAG Project - Learn with Transformers
+emoji: 🤖
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+# RAG Project - Learn with Transformers
+
+A production-ready Corrective Retrieval-Augmented Generation (CRAG) system built with LangChain, LangGraph, and FastAPI.
+
+## Features
+
+- **Intelligent Document Grading**: LLM evaluates retrieved documents for relevance
+- **Query Transformation**: Rewrites queries for better retrieval
+- **Web Search Fallback**: Tavily API integration when local docs insufficient
+- **Advanced Retrieval**: FAISS + FastEmbed + FlashRank reranking
+- **Agent Workflow**: LangGraph state machine with conditional routing
+
+## Tech Stack
+
+- **LLM**: Groq (openai/gpt-oss-120b)
+- **Embeddings**: FastEmbed (BAAI/bge-small-en-v1.5)
+- **Vector Store**: FAISS
+- **Reranker**: FlashRank (rank-T5-flan)
+- **Framework**: LangChain 0.3.x + LangGraph
+- **Web**: FastAPI + Uvicorn
+
+## Environment Variables
+
+Required secrets (set in Space Settings):
+- `GROQ_API_KEY`
+- `GOOGLE_API_KEY`
+- `LANGSMITH_API_KEY` (optional)
+- `TAVILY_API_KEY` (optional)
+
+## How It Works
+
+1. User query → FAISS retrieval with MMR
+2. FlashRank reranking
+3. LLM grades document relevance
+4. If poor quality → Transform query + Web search
+5. Generate answer with Groq LLM
+
+The app will automatically download "Attention Is All You Need" paper from ArXiv on first run.

app.py

@@ -0,0 +1,56 @@
+from fastapi import FastAPI, Request, Form
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from project.pipeline.agents import AgentWorkflow
+from project.logger.logging import get_logger
+import uvicorn
+
+logger = get_logger(__name__)
+
+app = FastAPI(title="Learn with Transformers")
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory="templates")
+
+agent = None
+
+
+@app.on_event("startup")
+async def startup_event():
+    global agent
+    logger.info("Initializing RAG pipeline...")
+    agent = AgentWorkflow()
+    agent.setup(use_attention_paper=True)
+    logger.info("RAG pipeline ready")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.post("/search", response_class=HTMLResponse)
+async def search(request: Request, query: str = Form(...)):
+    if not query.strip():
+        return templates.TemplateResponse(
+            "index.html", 
+            {"request": request, "error": "Please enter a question"}
+        )
+    
+    try:
+        answer = agent.run(query)
+        return templates.TemplateResponse(
+            "index.html",
+            {"request": request, "query": query, "answer": answer}
+        )
+    except Exception as e:
+        logger.error(f"Search failed: {str(e)}")
+        return templates.TemplateResponse(
+            "index.html",
+            {"request": request, "error": f"Error: {str(e)}"}
+        )
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

project/config/config.yaml

@@ -0,0 +1,20 @@
+embedding_model: 
+  provider: "fastembedding"
+  model_name : "BAAI/bge-small-en-v1.5"
+
+retriever:
+  search_type: "mmr"
+  top_k: 3
+
+llm:
+  provider: "langchain_groq"
+  model: "openai/gpt-oss-120b"
+  temperature: 0.1
+  max_tokens: 2048
+
+reranker:
+  model_name: "rank-T5-flan"
+  top_k: 3
+  cache_dir: null
+
+

project/exception/except.py

@@ -0,0 +1,26 @@
+import sys
+import traceback
+from typing import Optional
+
+
+class CustomException(Exception):
+    def __init__(self, error_message: str, error_detail: Optional[sys.exc_info] = None):
+        super().__init__(error_message)
+        self.error_message = error_message
+        
+        if error_detail:
+            _, _, exc_tb = error_detail
+            self.error_message = self._get_detailed_error_message(error_message, exc_tb)
+    
+    def _get_detailed_error_message(self, error_message: str, exc_tb) -> str:
+        file_name = exc_tb.tb_frame.f_code.co_filename
+        line_number = exc_tb.tb_lineno
+        
+        return f"Error in [{file_name}] at line [{line_number}]: {error_message}"
+    
+    def __str__(self):
+        return self.error_message
+    
+    def __repr__(self):
+        return f"{self.__class__.__name__}('{self.error_message}')"
+

project/logger/logging.py

@@ -0,0 +1,21 @@
+import os
+import logging
+from datetime import datetime
+
+LOG_DIR = "logs"
+os.makedirs(LOG_DIR, exist_ok=True)
+
+LOG_FILE = os.path.join(LOG_DIR, f"{datetime.now().strftime('%Y_%m_%d')}.log")
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s] %(levelname)s - %(name)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[
+        logging.FileHandler(LOG_FILE),
+        logging.StreamHandler()
+    ]
+)
+
+def get_logger(name: str) -> logging.Logger:
+    return logging.getLogger(name)

project/model/reranking.py

@@ -0,0 +1,61 @@
+from typing import List
+from langchain.schema import Document
+from flashrank.Ranker import Ranker, RerankRequest
+from project.utils.config_loader import load_config
+from project.logger.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class DocumentReranker:
+    
+    def __init__(self, config_path: str = None):
+        self.config = load_config(config_path)
+        reranker_config = self.config.get('reranker', {})
+        model_name = reranker_config.get('model_name', 'rank-T5-flan')
+        cache_dir = reranker_config.get('cache_dir')
+        self.top_k = reranker_config.get('top_k', 3)
+        
+        if cache_dir:
+            self.ranker = Ranker(model_name=model_name, cache_dir=cache_dir)
+        else:
+            self.ranker = Ranker(model_name=model_name)
+        
+        logger.info(f"FlashRank reranker initialized with model: {model_name}")
+    
+    def rerank(
+        self, 
+        query: str, 
+        documents: List[Document], 
+        top_k: int = None
+    ) -> List[Document]:
+        
+        if top_k is None:
+            top_k = self.top_k
+        
+        if not documents:
+            logger.warning("No documents to rerank")
+            return []
+        
+        passages = [
+            {
+                "id": i,
+                "text": doc.page_content,
+                "meta": doc.metadata
+            }
+            for i, doc in enumerate(documents)
+        ]
+        
+        rerank_request = RerankRequest(query=query, passages=passages)
+        
+        results = self.ranker.rerank(rerank_request)
+        
+        reranked_docs = []
+        for result in results[:top_k]:
+            doc_idx = result["id"]
+            original_doc = documents[doc_idx]
+            original_doc.metadata["rerank_score"] = result["score"]
+            reranked_docs.append(original_doc)
+        
+        logger.info(f"Reranked {len(documents)} documents, returning top {len(reranked_docs)}")
+        return reranked_docs

project/model/retriever.py

@@ -0,0 +1,93 @@
+from typing import List, Optional
+from langchain.schema import Document
+from langchain_community.vectorstores import FAISS
+from langchain.chains.query_constructor.base import AttributeInfo
+from langchain.retrievers.self_query.base import SelfQueryRetriever
+from project.utils.model_loader import ModelLoader
+from project.utils.config_loader import load_config
+from project.logger.logging import get_logger
+
+logger = get_logger(__name__)
+
+class DocumentRetriever:
+    def __init__(self, config_path: str = None):
+        self.config = load_config(config_path)
+        self.model_loader = ModelLoader(config_path)
+        self.embeddings = self.model_loader.load_embeddings()
+        self.llm = self.model_loader.load_llm()
+        self.vectorstore = None
+        self.retriever = None
+        logger.info("DocumentRetriever initialized")
+    
+    def create_vectorstore(self, documents: List[Document]) -> FAISS:
+        self.vectorstore = FAISS.from_documents(documents, self.embeddings)
+        logger.info(f"Vector store created with {len(documents)} documents")
+        return self.vectorstore
+    
+    def setup_self_query_retriever(
+        self,
+        document_content_description: str = "Research papers and technical documents",
+        metadata_field_info: Optional[List[AttributeInfo]] = None
+    ):
+        if self.vectorstore is None:
+            raise ValueError("Vector store not initialized. Call create_vectorstore first.")
+        
+        if metadata_field_info is None:
+            metadata_field_info = [
+                AttributeInfo(
+                    name="source",
+                    description="The source file or document name",
+                    type="string"
+                ),
+                AttributeInfo(
+                    name="page",
+                    description="The page number in the document",
+                    type="integer"
+                )
+            ]
+        
+        retriever_config = self.config.get('retriever', {})
+        
+        self.retriever = SelfQueryRetriever.from_llm(
+            llm=self.llm,
+            vectorstore=self.vectorstore,
+            document_contents=document_content_description,
+            metadata_field_info=metadata_field_info,
+            search_kwargs={
+                'k': retriever_config.get('top_k', 3)
+            },
+            enable_limit=True
+        )
+        
+        logger.info("Self-query retriever configured")
+        return self.retriever
+    
+    def retrieve(self, query: str) -> List[Document]:
+        if self.retriever is None:
+            raise ValueError("Retriever not initialized. Call setup_self_query_retriever first.")
+        
+        documents = self.retriever.invoke(query)
+        logger.info(f"Retrieved {len(documents)} documents for query")
+        return documents
+    
+    def get_base_retriever(self):
+        if self.vectorstore is None:
+            raise ValueError("Vector store not initialized.")
+        
+        retriever_config = self.config.get('retriever', {})
+        search_type = retriever_config.get('search_type', 'similarity')
+        top_k = retriever_config.get('top_k', 3)
+        
+        if search_type == 'mmr':
+            self.retriever = self.vectorstore.as_retriever(
+                search_type='mmr',
+                search_kwargs={'k': top_k, 'fetch_k': top_k * 2}
+            )
+        else:
+            self.retriever = self.vectorstore.as_retriever(
+                search_type='similarity',
+                search_kwargs={'k': top_k}
+            )
+        
+        logger.info(f"Base retriever configured with {search_type} search")
+        return self.retriever

project/pipeline/agents.py

@@ -0,0 +1,214 @@
+import os
+from typing import List, Literal
+from typing_extensions import TypedDict
+from pydantic import BaseModel, Field
+from langchain.schema import Document
+from langchain_core.output_parsers import StrOutputParser
+from langgraph.graph import END, StateGraph, START
+from project.pipeline.rag import RAGPipeline
+from project.utils.model_loader import ModelLoader
+from project.prompts.prompt_template import ROUTER_PROMPT, WEB_SEARCH_PROMPT
+from project.logger.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class GradeDocuments(BaseModel):
+    binary_score: str = Field(description="Documents are relevant to the question, 'yes' or 'no'")
+
+
+class GraphState(TypedDict):
+    question: str
+    generation: str
+    web_search: str
+    documents: List[str]
+
+
+class AgentWorkflow:
+    
+    def __init__(self, config_path: str = None):
+        self.config_path = config_path
+        self.model_loader = ModelLoader(config_path)
+        self.llm = self.model_loader.load_llm()
+        self.rag_pipeline = RAGPipeline(config_path)
+        self.web_search_tool = None
+        self._setup_web_search()
+        self.workflow = None
+        self.app = None
+        self._setup_graders()
+        logger.info("AgentWorkflow initialized")
+    
+    def _setup_web_search(self):
+        tavily_key = os.getenv("TAVILY_API_KEY")
+        if tavily_key:
+            try:
+                from langchain_community.tools.tavily_search import TavilySearchResults
+                self.web_search_tool = TavilySearchResults(k=3)
+                logger.info("Web search tool initialized")
+            except Exception as e:
+                logger.warning(f"Could not initialize web search: {str(e)}")
+                self.web_search_tool = None
+        else:
+            logger.warning("TAVILY_API_KEY not found, web search disabled")
+    
+    def _setup_graders(self):
+        grade_prompt = """You are a grader assessing relevance of a retrieved document to a user question.
+If the document contains keywords or semantic meaning related to the question, grade it as relevant.
+Give ONLY a binary score 'yes' or 'no' to indicate whether the document is relevant to the question.
+
+Retrieved document: {document}
+User question: {question}
+
+Answer (yes or no):"""
+        
+        self.grade_prompt_text = grade_prompt
+        self.retrieval_grader = self.llm | StrOutputParser()
+        
+        rewrite_prompt = """You are a question re-writer that converts an input question to a better version optimized for web search.
+Look at the input and try to reason about the underlying semantic intent/meaning.
+Provide only the improved question without any explanation.
+
+Initial question: {question}
+
+Improved question:"""
+        
+        self.rewrite_prompt_text = rewrite_prompt
+        self.question_rewriter = self.llm | StrOutputParser()
+    
+    def setup(self, pdf_path: str = None, use_attention_paper: bool = True):
+        self.rag_pipeline.setup(pdf_path=pdf_path, use_attention_paper=use_attention_paper)
+        self._build_graph()
+        logger.info("Agent workflow setup complete")
+    
+    def retrieve(self, state: GraphState):
+        logger.info("---RETRIEVE---")
+        question = state["question"]
+        documents = self.rag_pipeline.retriever.invoke(question)
+        return {"documents": documents, "question": question}
+    
+    def grade_documents(self, state: GraphState):
+        logger.info("---CHECK DOCUMENT RELEVANCE TO QUESTION---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        filtered_docs = []
+        web_search = "No"
+        
+        for d in documents:
+            prompt_filled = self.grade_prompt_text.format(
+                document=d.page_content[:500],
+                question=question
+            )
+            score = self.retrieval_grader.invoke(prompt_filled)
+            grade = score.strip().lower()
+            
+            if "yes" in grade:
+                logger.info("---GRADE: DOCUMENT RELEVANT---")
+                filtered_docs.append(d)
+            else:
+                logger.info("---GRADE: DOCUMENT NOT RELEVANT---")
+                web_search = "Yes"
+        
+        return {"documents": filtered_docs, "question": question, "web_search": web_search}
+    
+    def generate(self, state: GraphState):
+        logger.info("---GENERATE---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        generation = self.rag_pipeline.chain.invoke({"question": question})
+        return {"documents": documents, "question": question, "generation": generation}
+    
+    def transform_query(self, state: GraphState):
+        logger.info("---TRANSFORM QUERY---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        prompt_filled = self.rewrite_prompt_text.format(question=question)
+        better_question = self.question_rewriter.invoke(prompt_filled)
+        
+        return {"documents": documents, "question": better_question}
+    
+    def web_search(self, state: GraphState):
+        logger.info("---WEB SEARCH---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        if self.web_search_tool is None:
+            logger.warning("Web search tool not available, skipping")
+            return {"documents": documents, "question": question}
+        
+        try:
+            response = self.web_search_tool.invoke({"query": question})
+            
+            if not response:
+                logger.warning("No results from web search")
+                return {"documents": documents, "question": question}
+            
+            web_results = "\n".join([d["content"] for d in response if "content" in d])
+            web_doc = Document(page_content=web_results)
+            documents.append(web_doc)
+        except Exception as e:
+            logger.error(f"Web search failed: {str(e)}")
+        
+        return {"documents": documents, "question": question}
+    
+    def decide_to_generate(self, state: GraphState) -> Literal["transform_query", "generate"]:
+        logger.info("---ASSESS GRADED DOCUMENTS---")
+        documents = state.get("documents", [])
+        
+        if len(documents) == 0:
+            logger.info("---DECISION: NO RELEVANT DOCUMENTS, TRANSFORM QUERY---")
+            return "transform_query"
+        else:
+            logger.info("---DECISION: RELEVANT DOCUMENTS FOUND, GENERATE---")
+            return "generate"
+    
+    def _build_graph(self):
+        workflow = StateGraph(GraphState)
+        
+        workflow.add_node("retrieve", self.retrieve)
+        workflow.add_node("grade_documents", self.grade_documents)
+        workflow.add_node("generate", self.generate)
+        workflow.add_node("transform_query", self.transform_query)
+        workflow.add_node("web_search", self.web_search)
+        
+        workflow.add_edge(START, "retrieve")
+        workflow.add_edge("retrieve", "grade_documents")
+        workflow.add_conditional_edges(
+            "grade_documents",
+            self.decide_to_generate,
+            {
+                "transform_query": "transform_query",
+                "generate": "generate",
+            },
+        )
+        workflow.add_edge("transform_query", "web_search")
+        workflow.add_edge("web_search", "generate")
+        workflow.add_edge("generate", END)
+        
+        self.app = workflow.compile()
+        logger.info("LangGraph workflow compiled")
+    
+    def save_graph(self, output_path: str = "workflow.png"):
+        try:
+            from IPython.display import Image
+            graph_image = self.app.get_graph().draw_mermaid_png()
+            with open(output_path, "wb") as f:
+                f.write(graph_image)
+            logger.info(f"Workflow graph saved to {output_path}")
+        except Exception as e:
+            logger.error(f"Failed to save graph: {str(e)}")
+    
+    def run(self, question: str) -> str:
+        if self.app is None:
+            raise ValueError("Workflow not setup. Call setup() first.")
+        
+        inputs = {"question": question}
+        
+        for output in self.app.stream(inputs):
+            for key, value in output.items():
+                logger.info(f"Node '{key}' completed")
+        
+        final_generation = value.get("generation", "No answer generated")
+        return final_generation

project/pipeline/rag.py

@@ -0,0 +1,77 @@
+from typing import List, Dict, Any
+from langchain.schema import Document
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from project.source.data_preparation import DataPreparation
+from project.model.retriever import DocumentRetriever
+from project.model.reranking import DocumentReranker
+from project.utils.model_loader import ModelLoader
+from project.prompts.prompt_template import RAG_PROMPT
+from project.logger.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class RAGPipeline:
+    
+    def __init__(self, config_path: str = None):
+        self.config_path = config_path
+        self.model_loader = ModelLoader(config_path)
+        self.llm = self.model_loader.load_llm()
+        self.data_prep = DataPreparation()
+        self.retriever_module = DocumentRetriever(config_path)
+        self.reranker = DocumentReranker(config_path)
+        self.chain = None
+        self.retriever = None
+        logger.info("RAGPipeline initialized")
+    
+    def setup(self, pdf_path: str = None, use_attention_paper: bool = True):
+        chunks = self.data_prep.prepare_documents(
+            pdf_path=pdf_path,
+            use_attention_paper=use_attention_paper
+        )
+        
+        self.retriever_module.create_vectorstore(chunks)
+        self.retriever = self.retriever_module.get_base_retriever()
+        
+        self._build_chain()
+        logger.info("RAG pipeline setup complete")
+    
+    def _retrieve_and_rerank(self, query: str) -> List[Document]:
+        retrieved_docs = self.retriever.invoke(query)
+        reranked_docs = self.reranker.rerank(query, retrieved_docs)
+        return reranked_docs
+    
+    def _format_docs(self, docs: List[Document]) -> str:
+        return "\n\n".join([
+            f"Document {i+1}:\n{doc.page_content}" 
+            for i, doc in enumerate(docs)
+        ])
+    
+    def _build_chain(self):
+        self.chain = (
+            {
+                "context": lambda x: self._format_docs(
+                    self._retrieve_and_rerank(x["question"])
+                ),
+                "question": lambda x: x["question"]
+            }
+            | RAG_PROMPT
+            | self.llm
+            | StrOutputParser()
+        )
+        logger.info("RAG chain built successfully")
+    
+    def invoke(self, query: str) -> str:
+        if self.chain is None:
+            raise ValueError("Pipeline not setup. Call setup() first.")
+        
+        response = self.chain.invoke({"question": query})
+        logger.info(f"Query processed successfully")
+        return response
+    
+    def get_retrieved_documents(self, query: str) -> List[Document]:
+        if self.retriever is None:
+            raise ValueError("Pipeline not setup. Call setup() first.")
+        
+        return self._retrieve_and_rerank(query)

project/prompts/prompt_template.py

@@ -0,0 +1,66 @@
+from langchain_core.prompts import ChatPromptTemplate
+
+
+RAG_PROMPT = ChatPromptTemplate.from_messages([
+    ("system", """You are an expert AI assistant specializing in analyzing and answering questions about research papers and technical documents.
+
+Your task is to provide accurate, detailed, and well-structured answers based solely on the provided context.
+
+Guidelines:
+- Answer questions using ONLY the information from the provided context
+- If the answer cannot be found in the context, clearly state "I cannot find this information in the provided documents"
+- Provide specific details, citations, and examples when available in the context
+- Structure your responses clearly with proper formatting
+- If the context contains relevant equations, formulas, or technical details, include them in your answer
+- Be concise but comprehensive
+- Maintain technical accuracy
+
+Context:
+{context}
+
+Question: {question}
+
+Answer:"""),
+])
+
+
+ROUTER_PROMPT = ChatPromptTemplate.from_messages([
+    ("system", """You are an intelligent routing assistant that determines the best source to answer a user's question.
+
+Analyze the user's question and decide:
+1. "rag" - If the question is about technical documents, research papers, or specific domain knowledge that would be in stored documents
+2. "websearch" - If the question requires current information, recent events, real-time data, or general knowledge not in documents
+
+Your response must be either "rag" or "websearch" only.
+
+Examples:
+- "What is the attention mechanism in transformers?" → rag
+- "What's the weather today?" → websearch
+- "Explain the architecture described in the paper" → rag
+- "Who won the latest Nobel Prize?" → websearch
+
+Question: {question}
+
+Route:"""),
+])
+
+
+WEB_SEARCH_PROMPT = ChatPromptTemplate.from_messages([
+    ("system", """You are a helpful AI assistant that provides accurate and up-to-date information using web search results.
+
+Your task is to answer the user's question based on the search results provided.
+
+Guidelines:
+- Synthesize information from multiple search results
+- Provide accurate and current information
+- Cite sources when relevant
+- If search results are insufficient, acknowledge limitations
+- Structure your response clearly
+
+Search Results:
+{search_results}
+
+Question: {question}
+
+Answer:"""),
+])

project/source/data_preparation.py

@@ -0,0 +1,95 @@
+import os
+from pathlib import Path
+from typing import List, Optional
+from langchain_community.document_loaders import PyPDFLoader, ArxivLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+from project.logger.logging import get_logger
+
+logger = get_logger(__name__)
+
+class DataPreparation:
+    def __init__(
+        self,
+        data_dir: str = "data",
+        chunk_size: int = 1000,
+        chunk_overlap: int = 200
+    ):
+        self.data_dir = Path(data_dir)
+        self.data_dir.mkdir(exist_ok=True)
+        
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            length_function=len,
+            separators=["\n\n", "\n", " ", ""]
+        )
+        logger.info(f"DataPreparation initialized with chunk_size={chunk_size}")
+    
+    def load_attention_paper(self, arxiv_id: str = "1706.03762") -> List[Document]:
+        pdf_path = self.data_dir / "attention-is-all-you-need.pdf"
+
+        if pdf_path.exists():
+            logger.info(f"Loading PDF from local file: {pdf_path}")
+            return self._load_pdf(str(pdf_path))
+
+        logger.info(f"PDF not found locally. Downloading from ArXiv: {arxiv_id}")
+        try:
+            loader = ArxivLoader(query=arxiv_id, load_max_docs=1)
+            documents = loader.load()
+            if documents:
+                logger.info(f"Successfully downloaded paper from ArXiv")
+                return documents
+            else:
+                raise ValueError("No documents returned from ArXiv")
+                
+        except Exception as e:
+            logger.error(f"Failed to download from ArXiv: {str(e)}")
+            raise
+    
+    def _load_pdf(self, pdf_path: str) -> List[Document]:
+        try:
+            loader = PyPDFLoader(pdf_path)
+            documents = loader.load()
+            logger.info(f"Loaded {len(documents)} pages from PDF")
+            return documents
+        except Exception as e:
+            logger.error(f"Failed to load PDF: {str(e)}")
+            raise
+    
+    def load_custom_pdf(self, pdf_path: str) -> List[Document]:
+        if not Path(pdf_path).exists():
+            raise FileNotFoundError(f"PDF not found: {pdf_path}")
+        
+        return self._load_pdf(pdf_path)
+    
+    def split_documents(self, documents: List[Document]) -> List[Document]:
+        try:
+            chunks = self.text_splitter.split_documents(documents)
+            logger.info(f"Split documents into {len(chunks)} chunks")
+            return chunks
+        except Exception as e:
+            logger.error(f"Failed to split documents: {str(e)}")
+            raise
+    
+    def prepare_documents(
+        self, 
+        pdf_path: Optional[str] = None,
+        use_attention_paper: bool = True
+    ) -> List[Document]:
+        try:
+            if pdf_path:
+                documents = self.load_custom_pdf(pdf_path)
+            elif use_attention_paper:
+                documents = self.load_attention_paper()
+            else:
+                raise ValueError("Either provide pdf_path or set use_attention_paper=True")
+            
+            chunks = self.split_documents(documents)
+            
+            logger.info(f"Document preparation complete: {len(chunks)} chunks ready")
+            return chunks
+            
+        except Exception as e:
+            logger.error(f"Document preparation failed: {str(e)}")
+            raise

project/utils/config_loader.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+import yaml
+from typing import Dict, Any
+
+
+def load_config(config_path: str = None) -> Dict[str, Any]:
+    if config_path is None:
+        base_dir = Path(__file__).parent.parent
+        config_path = base_dir / "config" / "config.yaml"
+    else:
+        config_path = Path(config_path)
+    
+    if not config_path.exists():
+        raise FileNotFoundError(f"Config file not found: {config_path}")
+    
+    with open(config_path, 'r', encoding='utf-8') as file:
+        config = yaml.safe_load(file)
+    
+    return config

project/utils/model_loader.py

@@ -0,0 +1,61 @@
+import os
+from typing import Any
+from dotenv import load_dotenv
+from langchain_groq import ChatGroq
+from langchain_community.embeddings import FastEmbedEmbeddings
+from project.utils.config_loader import load_config
+from project.logger.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ModelLoader:
+    def __init__(self, config_path: str = None):
+        load_dotenv()
+        self.config = load_config(config_path)
+        self._load_api_keys()
+        logger.info("ModelLoader initialized")
+    
+    def _load_api_keys(self):
+        groq_key = os.getenv('GROQ_API_KEY')
+        
+        if groq_key:
+            os.environ['GROQ_API_KEY'] = groq_key
+            logger.info("GROQ API key loaded")
+        
+    
+    def load_llm(self) -> Any:
+        llm_config = self.config.get('llm', {})
+        provider = llm_config.get('provider', 'langchain_groq')
+        
+        try:
+            if provider == 'langchain_groq':
+                model = ChatGroq(
+                    model=llm_config.get('model', 'openai/gpt-oss-20b'),
+                    temperature=llm_config.get('temperature', 0.1),
+                    max_tokens=llm_config.get('max_tokens', 2048)
+                )
+                logger.info(f"Loaded Groq LLM: {llm_config.get('model')}")
+                return model
+            else:
+                raise ValueError(f"Unsupported LLM provider: {provider}")
+        except Exception as e:
+            logger.error(f"Failed to load LLM: {str(e)}")
+            raise
+    
+    def load_embeddings(self) -> Any:
+        embed_config = self.config.get('embedding_model', {})
+        provider = embed_config.get('provider', 'fastembedding')
+        
+        try:
+            if provider == 'fastembedding':
+                embeddings = FastEmbedEmbeddings(
+                    model_name=embed_config.get('model_name', 'BAAI/bge-small-en-v1.5')
+                )
+                logger.info(f"Loaded FastEmbed: {embed_config.get('model_name')}")
+                return embeddings
+            else:
+                raise ValueError(f"Unsupported embedding provider: {provider}")
+        except Exception as e:
+            logger.error(f"Failed to load embeddings: {str(e)}")
+            raise

requirements.txt

@@ -0,0 +1,20 @@
+arxiv
+chromadb
+faiss-cpu
+fastembed
+fastapi
+flashrank
+google-generativeai
+jinja2
+langchain
+langchain-chroma
+langchain-community
+langchain-google-genai
+langchain-groq
+langgraph
+pypdf
+python-dotenv
+python-multipart
+rapidocr-onnxruntime
+tiktoken
+uvicorn

static/styles.css

@@ -0,0 +1,217 @@
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    padding: 20px;
+}
+
+.container {
+    max-width: 900px;
+    width: 100%;
+    background: white;
+    border-radius: 20px;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+    overflow: hidden;
+}
+
+header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 60px 40px;
+}
+
+.header-content {
+    display: grid;
+    grid-template-columns: 1fr auto;
+    gap: 40px;
+    align-items: center;
+}
+
+.header-text {
+    text-align: left;
+}
+
+.header-image {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+
+.header-image img {
+    max-width: 220px;
+    height: auto;
+    border-radius: 10px;
+    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.3);
+    background: white;
+    padding: 10px;
+}
+
+.main-title {
+    font-size: 3.5rem;
+    font-weight: 800;
+    letter-spacing: 2px;
+    margin-bottom: 15px;
+    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+.subtitle {
+    font-size: 1.2rem;
+    opacity: 0.9;
+    font-weight: 300;
+}
+
+main {
+    padding: 40px;
+}
+
+.search-form {
+    margin-bottom: 30px;
+}
+
+.search-box {
+    display: flex;
+    gap: 10px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    border-radius: 50px;
+    overflow: hidden;
+}
+
+.search-input {
+    flex: 1;
+    padding: 18px 30px;
+    border: 2px solid #e0e0e0;
+    border-radius: 50px 0 0 50px;
+    font-size: 1.1rem;
+    outline: none;
+    transition: border-color 0.3s;
+}
+
+.search-input:focus {
+    border-color: #667eea;
+}
+
+.search-button {
+    padding: 18px 40px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    border-radius: 0 50px 50px 0;
+    font-size: 1.1rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: transform 0.2s;
+}
+
+.search-button:hover {
+    transform: scale(1.05);
+}
+
+.search-button:active {
+    transform: scale(0.95);
+}
+
+.error-box {
+    background: #fee;
+    border-left: 4px solid #f44;
+    padding: 15px 20px;
+    border-radius: 5px;
+    color: #c33;
+    margin-bottom: 20px;
+}
+
+.results {
+    margin-top: 30px;
+}
+
+.question-box {
+    background: #f8f9fa;
+    padding: 20px;
+    border-radius: 10px;
+    margin-bottom: 20px;
+    border-left: 4px solid #667eea;
+}
+
+.question-box h3 {
+    color: #667eea;
+    margin-bottom: 10px;
+    font-size: 1.2rem;
+}
+
+.question-box p {
+    font-size: 1.1rem;
+    color: #333;
+}
+
+.answer-box {
+    background: #ffffff;
+    padding: 25px;
+    border-radius: 10px;
+    border: 2px solid #e0e0e0;
+}
+
+.answer-box h3 {
+    color: #764ba2;
+    margin-bottom: 15px;
+    font-size: 1.2rem;
+}
+
+.answer-content {
+    line-height: 1.8;
+    color: #444;
+    font-size: 1rem;
+    white-space: pre-wrap;
+}
+
+footer {
+    background: #f8f9fa;
+    text-align: center;
+    padding: 20px;
+    color: #666;
+    font-size: 0.9rem;
+}
+
+@media (max-width: 768px) {
+    .main-title {
+        font-size: 2.5rem;
+    }
+    
+    .header-content {
+        grid-template-columns: 1fr;
+        gap: 20px;
+    }
+    
+    .header-text {
+        text-align: center;
+    }
+    
+    .header-image img {
+        max-width: 200px;
+    }
+    
+    .search-box {
+        flex-direction: column;
+    }
+    
+    .search-input,
+    .search-button {
+        border-radius: 50px;
+        border: 2px solid #e0e0e0;
+    }
+    
+    header {
+        padding: 40px 20px;
+    }
+    
+    main {
+        padding: 20px;
+    }
+}

templates/index.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RAG PROJECT PIPELINE</title>
+    <link rel="stylesheet" href="/static/styles.css">
+    <script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
+    <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
+    <script>
+        window.MathJax = {
+            tex: {
+                inlineMath: [['$', '$'], ['\\(', '\\)']],
+                displayMath: [['$$', '$$'], ['\\[', '\\]']],
+                processEscapes: true
+            }
+        };
+    </script>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <div class="header-content">
+                <div class="header-text">
+                    <h1 class="main-title">LEARN ABOUT TRANSFORMERS</h1>
+                    <p class="subtitle">Ask questions about the "Attention Is All You Need Research Paper AKA Transformers."</p>
+                </div>
+                <div class="header-image">
+                    <img src="https://i.postimg.cc/gjtCYK7R/transformer-architecture-converted.png" alt="Transformer Architecture" />
+                </div>
+            </div>
+        </header>
+
+        <main>
+            <form method="post" action="/search" class="search-form">
+                <div class="search-box">
+                    <input 
+                        type="text" 
+                        name="query" 
+                        placeholder="What is the attention mechanism?" 
+                        class="search-input"
+                        value="{{ query or '' }}"
+                        autofocus
+                    >
+                    <button type="submit" class="search-button">Search</button>
+                </div>
+            </form>
+
+            {% if error %}
+            <div class="error-box">
+                <p>{{ error }}</p>
+            </div>
+            {% endif %}
+
+            {% if query and answer %}
+            <div class="results">
+                <div class="question-box">
+                    <h3>Question:</h3>
+                    <p>{{ query }}</p>
+                </div>
+                
+                <div class="answer-box">
+                    <h3>Answer:</h3>
+                    <div class="answer-content">{{ answer | safe }}</div>
+                </div>
+            </div>
+            {% endif %}
+        </main>
+
+        <footer>
+            <p>Powered by RAG Pipeline with Corrective RAG (CRAG)</p>
+        </footer>
+    </div>
+    
+    <script>
+        // Trigger MathJax rendering after page load
+        if (window.MathJax) {
+            MathJax.typesetPromise();
+        }
+    </script>
+</body>
+</html>