Upload 6 files

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim
+
+# Prevent Python from writing pyc files
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Install system dependencies (required for sklearn / xgboost)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy and install dependencies first (better caching)
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Hugging Face expects port 7860
+EXPOSE 7860
+
+# Start FastAPI
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

RAG.py

@@ -0,0 +1,310 @@
+from langgraph.graph import StateGraph, START, END
+from typing import TypedDict, Annotated
+from langchain_groq import ChatGroq
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langgraph.graph.message import add_messages
+from langchain_core.tools import tool
+from dotenv import load_dotenv
+from langgraph.checkpoint.memory import MemorySaver
+import os
+from langchain_community.vectorstores import FAISS
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+load_dotenv()
+
+
+#===========================================
+# Load FAISS DB & Reload Logic [FEATURE ADDED]
+#===========================================
+
+FAISS_DB_PATH = "vectorstore/db_faiss"
+embeddings = OpenAIEmbeddings(model='text-embedding-3-small')
+
+# Global variable for the database
+db = None
+
+def reload_vector_store():
+    """
+    Reloads the FAISS index from disk. 
+    Call this function after a new file is ingested.
+    """
+    global db
+    if os.path.exists(FAISS_DB_PATH):
+        print(f"Loading FAISS from {FAISS_DB_PATH}...")
+        try:
+            db = FAISS.load_local(
+                FAISS_DB_PATH, 
+                embeddings, 
+                allow_dangerous_deserialization=True
+            )
+            print("Vector store loaded successfully.")
+        except Exception as e:
+            print(f"Error loading vector store: {e}")
+            db = None
+    else:
+        print("Warning: No Vector DB found. Please run ingestion first.")
+        db = None 
+
+# Initial Load
+reload_vector_store()
+
+
+#===========================================
+# Class Schema
+#===========================================
+
+class Ragbot_State(TypedDict):
+    query       :   str
+    context     :   list[str]
+    metadata    :   list[dict]
+    RAG         :   bool
+    web_search  :   bool
+    model_name  :   str
+    web_context :   str
+    response    :   Annotated[list[BaseMessage], add_messages]
+
+#===========================================
+# LLM'S
+#===========================================
+
+
+llm_kimi2       =   ChatGroq(model='moonshotai/kimi-k2-instruct-0905', streaming=True, temperature=0.4)
+llm_gpt         =   ChatOpenAI(model='gpt-4.1-nano', streaming=True, temperature=0.2)
+llm_gpt_oss     =   ChatGroq(model='openai/gpt-oss-120b', streaming=True, temperature=0.3)
+llm_lamma4      =   ChatGroq(model='meta-llama/llama-4-scout-17b-16e-instruct', streaming=True, temperature=0.5)
+llm_qwen3       =   ChatGroq(model='qwen/qwen3-32b', streaming=True, temperature=0.5)
+
+def get_llm(model_name: str):
+    if model_name == "kimi2":
+        return llm_kimi2
+    elif model_name == "gpt":
+        return llm_gpt
+    elif model_name == "gpt_oss":
+        return llm_gpt_oss
+    elif model_name == "lamma4":
+        return llm_lamma4
+    elif model_name == "qwen3":
+        return llm_qwen3
+    else:
+        return llm_gpt   # fallback if no match
+
+#===========================================
+# Search tool
+#===========================================
+
+@tool
+def tavily_search(query: str) -> dict:
+    """
+    Perform a real-time web search using Tavily.
+    """
+    try:
+        search = TavilySearchResults(max_results=2)
+        results = search.run(query)
+        return {"query": query, "results": results}
+    except Exception as e:
+        return {"error": str(e)}
+    
+#===========================================
+# fetching web context
+#===========================================
+
+def fetch_web_context(state: Ragbot_State):
+    user_query = state["query"]
+
+    enriched_query = f"""
+Fetch the latest, accurate, and up-to-date information about:
+{user_query}
+
+Focus on:
+- recent news
+- official announcements
+- verified sources
+- factual data
+"""
+
+    web_result = tavily_search.run(enriched_query)
+
+    return {
+        "web_context": str(web_result)
+    }
+
+#===========================================
+# db search
+#===========================================
+
+@tool
+def faiss_search(query: str) -> str:
+    """Search the FAISS vectorstore and return relevant documents."""
+    # Check global db variable
+    if db is None:
+        return "No documents have been uploaded yet.", []
+
+    try:
+        results = db.similarity_search(query, k=3)
+        context = "\n\n".join([doc.page_content for doc in results])
+        metadata = [doc.metadata for doc in results]
+        return context, metadata
+    except Exception as e:
+        return f"Error searching vector store: {str(e)}", []
+
+#===========================================
+# router
+#===========================================
+
+
+def router(state: Ragbot_State):
+    if state["RAG"]:
+        return "fetch_context"
+
+    if state["web_search"]:
+        return "fetch_web_context"
+
+    return "chat"
+
+#===========================================
+# fetching context
+#===========================================
+
+def fetch_context(state: Ragbot_State):
+    query = state["query"]
+    context, metadata = faiss_search.invoke({"query": query})
+    return {"context": [context], "metadata": [metadata]}
+
+
+#===========================================
+# system prompt
+#===========================================
+
+
+SYSTEM_PROMPT = SystemMessage(
+    content="""
+You are an intelligent conversational assistant and retrieval-augmented AI system built by Junaid.
+
+Your role is to:
+- Engage naturally in conversation like a friendly, helpful chatbot.
+- Answer general questions using your own knowledge when no external context is provided.
+- When relevant context is provided, use it accurately to answer user questions.
+- Seamlessly switch between casual conversation and knowledge-based answering.
+
+Guidelines:
+- If context is provided and relevant, use it as the primary source of truth.
+- If context is not provided or not relevant, respond using your general knowledge.
+- Do not hallucinate or invent information.
+- If you are unsure or the information is not available, clearly state that.
+- Be clear, concise, and helpful in all responses.
+- Maintain a natural, human-like conversational tone.
+- Never mention internal implementation details such as embeddings, vector databases, or system architecture.
+
+You are designed to provide reliable, accurate, and engaging assistance.
+"""
+)
+
+#===========================================
+# Chat function
+#===========================================
+
+def chat(state:Ragbot_State):
+    query = state['query']
+    context = state['context']
+    metadata = state['metadata']
+    web_context = state['web_context']
+    model_name = state.get('model_name', 'gpt')
+
+    history = state.get("response", [])
+
+    # [CHANGED] Updated Prompt to include History so it remembers your name
+    prompt = f"""
+You are an expert assistant designed to answer user questions using multiple information sources.
+
+Source Priority Rules (STRICT):
+1. **Conversation History**: Check if the answer was provided in previous messages (e.g., user's name, previous topics).
+2. If the provided Context contains the answer, use ONLY the Context.
+3. If the Context does not contain the answer and Web Context is available, use the Web Context.
+4. If neither Context nor Web Context contains the answer, use your general knowledge.
+5. Do NOT invent or hallucinate facts.
+6. If the answer cannot be determined, clearly say so.
+
+User Question:
+{query}
+
+Retrieved Context (Vector Database):
+{context}
+
+Metadata:
+{metadata}
+
+Web Context (Real-time Search):
+{web_context}
+
+Final Answer:
+"""
+
+    selected_llm = get_llm(model_name)
+    messages = [SYSTEM_PROMPT] + history + [HumanMessage(content=prompt)]
+    response = selected_llm.invoke(messages)
+    return {
+        'response': [
+            HumanMessage(content=query), 
+            response
+        ]
+    }
+
+#===========================================
+# Graph Declaration
+#===========================================
+
+# Keeping MemorySaver as requested (Note: RAM only, wipes on restart)
+memory = MemorySaver()
+graph = StateGraph(Ragbot_State)
+
+graph.add_node("fetch_context", fetch_context)
+graph.add_node("fetch_web_context", fetch_web_context)
+graph.add_node("chat", chat)
+
+graph.add_conditional_edges(
+    START,
+    router,
+    {
+        "fetch_context": "fetch_context",
+        "fetch_web_context": "fetch_web_context",
+        "chat": "chat"
+    }
+)
+
+graph.add_edge("fetch_context", "chat")
+graph.add_edge("fetch_web_context", "chat")
+graph.add_edge("chat", END)
+
+app = graph.compile(checkpointer=memory)
+
+
+#===========================================
+# Helper Function
+#===========================================
+
+def ask_bot(query: str, use_rag: bool = False, use_web: bool = False, thread_id: str = "1"):
+    config = {"configurable": {"thread_id": thread_id}}
+    inputs = {
+        "query": query,
+        "RAG": use_rag,
+        "web_search": use_web,
+        "context": [],
+        "metadata": [],
+        "web_context": "",
+    }
+    
+    result = app.invoke(inputs, config=config)
+    last_message = result['response'][-1]
+    
+    return last_message.content
+
+
+"""print("--- Conversation 1 ---")
+# User says hello and gives name
+response = ask_bot("Hi, my name is Junaid", thread_id="session_A")
+print(f"Bot: {response}")
+
+# User asks for name (RAG and Web are OFF)
+response = ask_bot("What is my name?", thread_id="session_A")
+print(f"Bot: {response}")"""

app.py

@@ -0,0 +1,119 @@
+import os
+import shutil
+from fastapi.responses import FileResponse
+import asyncio
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException, BackgroundTasks
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from utils import STT, TTS
+from data_ingestion import Ingest_Data 
+from RAG import app as rag_app, Ragbot_State, reload_vector_store
+
+# Initialize FastAPI
+app = FastAPI(title="LangGraph RAG Chatbot", version="1.0")
+
+# --- Pydantic Models ---
+class ChatRequest(BaseModel):
+    query: str
+    thread_id: str = "default_user"
+    use_rag: bool = False
+    use_web: bool = False
+    model_name: str = "gpt"
+
+class TTSRequest(BaseModel):
+    text: str
+    voice: str = "en-US-AriaNeural"
+
+
+# --- Endpoints ---
+
+@app.get("/")
+def health_check():
+    return {"status": "running", "message": "Bot is ready"}
+
+@app.post("/upload")
+async def upload_document(
+    file: UploadFile = File(...), 
+    background_tasks: BackgroundTasks = BackgroundTasks()
+):
+    try:
+        temp_filename = f"temp_{file.filename}"
+
+        with open(temp_filename, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        def process_and_reload(path):
+            try:
+                result = Ingest_Data(path)
+                print(f"Ingestion Result: {result}")
+                reload_vector_store()
+                
+            except Exception as e:
+                print(f"Error processing background task: {e}")
+            finally:
+                if os.path.exists(path):
+                    os.remove(path)
+
+        background_tasks.add_task(process_and_reload, temp_filename)
+
+        return {
+            "message": "File received. Processing started in background.", 
+            "filename": file.filename
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/chat")
+async def chat_endpoint(request: ChatRequest):
+    config = {"configurable": {"thread_id": request.thread_id}}
+    
+    inputs = {
+        "query": request.query,
+        "RAG": request.use_rag,
+        "web_search": request.use_web,
+        "model_name": request.model_name,
+        "context": [],
+        "metadata": [],
+        "web_context": "",
+    }
+
+    async def event_generator():
+        async for event in rag_app.astream_events(inputs, config=config, version="v1"):
+            kind = event["event"]
+            if kind == "on_chat_model_stream":
+                content = event["data"]["chunk"].content
+                
+                if content:
+                    data = content.replace("\n", "\\n")
+                    yield f"data: {data}\n\n"
+
+    return StreamingResponse(
+        event_generator(), 
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+# ---------------- STT ---------------- #
+@app.post("/stt")
+async def transcribe_audio(file: UploadFile = File(...)):
+    try:
+        return await STT(file)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ---------------- TTS ---------------- #
+@app.post("/tts")
+async def text_to_speech(req: TTSRequest):
+    try:
+        audio_path = await TTS(req.text, req.voice)
+        return FileResponse(audio_path, media_type="audio/mpeg", filename="output.mp3")
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

data_ingestion.py

@@ -0,0 +1,67 @@
+import os
+import logging
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.vectorstores import FAISS
+from langchain_openai import OpenAIEmbeddings
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# 1. Setup Logging (Better than print for Servers)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+embeddings = OpenAIEmbeddings(model='text-embedding-3-small')
+
+# 2. Add arguments for flexible paths
+def Ingest_Data(pdf_path: str, vector_db_path: str = "vectorstore/db_faiss"):
+    """
+    Ingests a PDF, splits it, and saves the vector store.
+    Returns a dict with status to send back to the Frontend.
+    """
+    try:
+        logger.info(f"Starting ingestion for: {pdf_path}")
+
+        # Validation: Check if file exists
+        if not os.path.exists(pdf_path):
+            raise FileNotFoundError(f"The file {pdf_path} was not found.")
+
+        # Load
+        loader = PyPDFLoader(pdf_path)
+        pages = loader.load_and_split()
+        
+        if not pages:
+            return {"status": "error", "message": "PDF contains no text."}
+
+        # Split
+        splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=250)
+        docs = splitter.split_documents(pages)
+        logger.info(f"Processing {len(docs)} chunks...")
+
+        # Embed & Save
+        # Note: This is CPU/Network intensive. In FastAPI, 
+        # ensure you run this in a BackgroundTask or ThreadPool.
+        db = FAISS.from_documents(docs, embeddings) 
+        db.save_local(vector_db_path)
+        
+        logger.info(f"Saved vectorstore to {vector_db_path}")
+
+        # 3. Return JSON-friendly data
+        return {
+            "status": "success",
+            "chunks_processed": len(docs),
+            "db_path": vector_db_path,
+            "message": "File successfully ingested and indexed."
+        }
+
+    except Exception as e:
+        logger.error(f"Ingestion failed: {str(e)}")
+        return {
+            "status": "failed", 
+            "error": str(e)
+        }
+    
+
+    
+#Ingest_Data("MLBOOK.pdf")

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+python-multipart
+python-dotenv
+langchain-groq
+langchain-openai
+langchain-community
+langchain-huggingface
+langgraph
+faiss-cpu
+edge-tts
+groq

utils.py

@@ -0,0 +1,55 @@
+import os
+from uuid import uuid4
+import edge_tts
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = Groq()
+
+# ==================================================
+# 🎧 SPEECH TO TEXT
+# ==================================================
+
+async def STT(audio_file):
+    os.makedirs("uploads", exist_ok=True)
+    file_path = f"uploads/{uuid4().hex}.wav"
+
+    with open(file_path, "wb") as f:
+        f.write(await audio_file.read())
+
+    with open(file_path, "rb") as f:
+        transcription = client.audio.transcriptions.create(
+            file=f,
+            model="whisper-large-v3-turbo",
+            response_format="verbose_json",
+            temperature=0.0
+        )
+    
+    # Optional: cleanup the uploaded file after processing
+    # os.remove(file_path)
+
+    return {
+        "text": transcription.text,
+        "segments": transcription.segments,
+        "language": transcription.language
+    }
+
+
+# ==================================================
+# 🗣️ TEXT TO SPEECH
+# ==================================================
+
+async def TTS(text: str, voice: str = "en-US-AriaNeural") -> str:
+    """
+    Converts text to speech and saves it to a file.
+    Returns the path to the generated audio file.
+    """
+    os.makedirs("outputs", exist_ok=True)
+    filename = f"outputs/{uuid4().hex}.mp3"
+    
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(filename)
+    
+    return filename