Deploy FastAPI backend for HF Space

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.env
+.venv/
+static/audio/
+temp_input_file/
+*.log

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    tesseract-ocr \
+    espeak-ng \
+    ffmpeg \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main_fastapi:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,23 @@
+---
+title: Offline Chatbot RAG Backend
+emoji: ⚡
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+---
+
+FastAPI backend for Offline Chatbot RAG.
+
+## Required Secrets
+
+Set these in your Space settings:
+
+- `GROQ_API_KEY`
+
+## Endpoints
+
+- `GET /health`
+- `POST /api/process` with form-data fields:
+  - `file`
+  - `query`

audio_result.py

@@ -0,0 +1,24 @@
+# import os
+# import streamlit as st
+from functions.translate import speech_to_text
+from functions.data_to_vectors import create_vectorstore
+# import pyttsx3
+from functions.llm_comm import llm_communication
+def rag(file, question):
+    print("🎤 Processing Audio File...")
+    # st.write("🎤 Processing Audio File...")
+    text = speech_to_text(file)
+    print(text)
+    vectorstore = create_vectorstore(str(text), "audio_store_chroma")
+
+    retrieval_chain = llm_communication(vectorstore)
+    # 8️⃣ Query pipeline
+    if question:
+        response = retrieval_chain.invoke({"input": question})
+        print(f"🧠 {question} {response['answer']}\n")
+        return response['answer']
+        # if st.button("🔊 Play Answer"):
+        #     # Initialize TTS engine
+        #     engine = pyttsx3.init()
+        #     engine.say(response['answer'])
+        #     engine.runAndWait()

csv_result.py

@@ -0,0 +1,29 @@
+# 1️⃣ Imports
+import pandas as pd
+from langchain.schema import Document
+import os
+from dotenv import load_dotenv
+from functions.data_to_vectors import create_vectorstore
+from functions.llm_comm import llm_communication
+# --- Load environment variables ---
+load_dotenv()
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+def rag(file, question):
+    print("📊 Processing CSV File...")
+    df = pd.read_csv(file)
+    print("Extracted DataFrame:")
+    print(df)
+    print(f"Chat Input: {question}")
+    # Convert each row into a Document
+    documents = [
+        Document(page_content=row.to_string()) 
+        for _, row in df.iterrows()
+    ]
+    vectorstore = create_vectorstore(str(documents), "csv_store_chroma")
+
+    retrieval_chain = llm_communication(vectorstore)
+    # 8️⃣ Query pipeline
+    if question:
+        response = retrieval_chain.invoke({"input": question})
+        print(f"🧠 {question} {response['answer']}\n")
+        return response['answer']

functions/data_to_vectors.py

@@ -0,0 +1,70 @@
+# __package__ = "functions"
+# from langchain.text_splitter import RecursiveCharacterTextSplitter
+# from langchain_huggingface import HuggingFaceEmbeddings
+# from langchain_community.vectorstores import Chroma
+# from langchain.schema import Document
+# def create_vectorstore(text,store):
+#     print("data loaded......")
+#     documents = [Document(page_content=text)]
+#     # Chunk text
+#     text_splitter = RecursiveCharacterTextSplitter(
+#         chunk_size=500,
+#         chunk_overlap=200
+#     )
+#     docs_chunks = text_splitter.split_documents(documents)
+    
+#     # Embeddings
+#     embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    
+#     # Chroma vectorstore
+#     vectorstore = Chroma.from_documents(
+#         documents=docs_chunks,
+#         embedding=embeddings,
+#         persist_directory=store
+#     )
+#     print(f"✅ Stored {len(docs_chunks)} chunks in ChromaDB")
+#     return vectorstore
+
+__package__ = "functions"
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import Chroma
+from langchain.schema import Document
+from sentence_transformers import SentenceTransformer
+from langchain.embeddings.base import Embeddings  # 👈 base class
+
+# Custom wrapper for SentenceTransformer
+class SentenceTransformerEmbeddings(Embeddings):
+    def __init__(self, model_name="sentence-transformers/all-MiniLM-L6-v2", device="cpu"):
+        self.model = SentenceTransformer(model_name, device=device)
+
+    def embed_documents(self, texts):
+        return self.model.encode(texts, convert_to_numpy=True).tolist()
+
+    def embed_query(self, text):
+        return self.model.encode([text], convert_to_numpy=True)[0].tolist()
+
+
+def create_vectorstore(text, store):
+    print("data loaded......")
+    documents = [Document(page_content=text)]
+    print(text)
+    # Chunk text
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500,
+        chunk_overlap=200
+    )
+    docs_chunks = text_splitter.split_documents(documents)
+
+    # Use custom embedding wrapper
+    embeddings = SentenceTransformerEmbeddings()
+
+    # Chroma vectorstore
+    vectorstore = Chroma.from_documents(
+        documents=docs_chunks,
+        embedding=embeddings,
+        persist_directory=store
+    )
+
+    print(f"✅ Stored {len(docs_chunks)} chunks in ChromaDB")
+    return vectorstore

functions/llm_comm.py

@@ -0,0 +1,15 @@
+
+from langchain_groq import ChatGroq
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain.chains import create_retrieval_chain
+from functions.main_prompt import in_prompt
+def llm_communication(vectorstore):
+    llm = ChatGroq(model="llama-3.3-70b-versatile")
+    # 4️⃣ Create prompt template
+    prompt = in_prompt
+    # 5️⃣ Convert vectorstore into retriever
+    retriever = vectorstore.as_retriever(search_kwargs={"k":3})  # retrieve top 3 chunks
+    # 6️⃣ Build document chain (stuffing docs into prompt)
+    doc_chain = create_stuff_documents_chain(llm, prompt)
+    # 7️⃣ Create retrieval chain
+    return create_retrieval_chain(retriever, doc_chain)

functions/main_prompt.py

@@ -0,0 +1,13 @@
+from langchain.prompts import ChatPromptTemplate
+in_prompt = ChatPromptTemplate.from_template(
+"""You are a precise document QA assistant. 
+Answer the user's question ONLY using the provided context. 
+Keep your response short, factual, and directly to the point. 
+Do NOT add extra explanations, summaries, or outside knowledge. 
+If the answer is not in the context, reply exactly:
+"The information required to answer this question was not found in the provided document."
+--- CONTEXT ---
+{context}
+--- USER QUESTION ---
+{input}
+--- ANSWER ---""")

functions/translate.py

@@ -0,0 +1,26 @@
+__package__ = "functions"
+from vosk import Model, KaldiRecognizer
+import wave
+import json
+# Load Vosk model (download small model first, e.g., vosk-model-small-en-us-0.15)
+def speech_to_text(input_file):
+    model = Model(r"vosk-model-small-en-us-0.15")
+    # Open WAV file
+    wf = wave.open(input_file, "rb")
+    rec = KaldiRecognizer(model, wf.getframerate())
+
+    text = ""
+    while True:
+        data = wf.readframes(4000)
+        if len(data) == 0:
+            break
+        if rec.AcceptWaveform(data):
+            res = json.loads(rec.Result())
+            text += res.get("text", "") + " "
+
+    # Get final part
+    res = json.loads(rec.FinalResult())
+    text += res.get("text", "")
+    print(text)
+    print("🎤 Transcription:")
+    return text

image_result.py

@@ -0,0 +1,24 @@
+# 1️⃣ Imports
+import pytesseract
+from PIL import Image
+import os
+from dotenv import load_dotenv
+from functions.data_to_vectors import create_vectorstore
+from functions.llm_comm import llm_communication
+# --- Load environment variables ---
+load_dotenv()
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+
+# Example: create/store vectorstore
+def rag(file_path,question):
+    image = Image.open(file_path)
+    text = pytesseract.image_to_string(image)
+    vectorstore = create_vectorstore(text,"image_store_chroma" )
+
+    retrieval_chain = llm_communication(vectorstore)
+    # 8️⃣ Query pipeline
+    if question:
+        response = retrieval_chain.invoke({"input": question})
+        print(f"🧠 {question} {response['answer']}\n")
+        return response['answer']
+

main_fastapi.py

@@ -0,0 +1,131 @@
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import aiofiles
+import asyncio
+import importlib
+from pathlib import Path
+import os
+import uuid
+
+BASE_DIR = Path(__file__).resolve().parent
+TEMP_DIR = BASE_DIR / "temp_input_file"
+STATIC_DIR = BASE_DIR / "static"
+STATIC_AUDIO_DIR = STATIC_DIR / "audio"
+
+TEMP_DIR.mkdir(parents=True, exist_ok=True)
+STATIC_AUDIO_DIR.mkdir(parents=True, exist_ok=True)
+
+app = FastAPI(title="Multi-Modal RAG Backend")
+
+# Keep open CORS so frontend hosted on GitHub Pages can call this API.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
+
+def _module_for_content_type(content_type: str):
+    if content_type.startswith("image/"):
+        return "image_result", "binary"
+    if content_type == "text/plain":
+        return "text_result", "text"
+    if content_type == "application/pdf":
+        return "pdf_result", "path"
+    if content_type in ("text/csv", "application/csv"):
+        return "csv_result", "path"
+    if content_type.startswith("audio/"):
+        return "audio_result", "path"
+    raise ValueError("Unsupported file type")
+
+
+async def save_file_tmp(file: UploadFile):
+    suffix = os.path.splitext(file.filename or "upload.bin")[1]
+    tmp_path = TEMP_DIR / f"{uuid.uuid4().hex}{suffix}"
+    async with aiofiles.open(tmp_path, "wb") as f:
+        while True:
+            chunk = await file.read(1024 * 1024)
+            if not chunk:
+                break
+            await f.write(chunk)
+    return tmp_path
+
+
+def process_file(path: Path, content_type: str, query: str):
+    if not content_type:
+        raise ValueError("Missing file content type")
+
+    module_name, mode = _module_for_content_type(content_type)
+
+    if module_name == "audio_result":
+        vosk_model = BASE_DIR / "vosk-model-small-en-us-0.15"
+        if not vosk_model.exists():
+            raise ValueError(
+                "Audio processing is not enabled on this deployment (Vosk model missing)."
+            )
+
+    module = importlib.import_module(module_name)
+
+    if mode == "binary":
+        with open(path, "rb") as f:
+            return module.rag(f, query)
+    if mode == "text":
+        with open(path, "r", encoding="utf-8") as f:
+            return module.rag(f, query)
+    return module.rag(str(path), query)
+
+
+def generate_tts(text: str):
+    try:
+        import pyttsx3
+    except Exception:
+        return None
+
+    filename = f"{uuid.uuid4().hex}.wav"
+    output_path = STATIC_AUDIO_DIR / filename
+
+    try:
+        engine = pyttsx3.init()
+        engine.save_to_file(text, str(output_path))
+        engine.runAndWait()
+    except Exception:
+        return None
+
+    return f"/static/audio/{filename}"
+
+
+@app.post("/api/process")
+async def process_endpoint(file: UploadFile = File(...), query: str = Form(...)):
+    tmp_path = await save_file_tmp(file)
+    loop = asyncio.get_running_loop()
+
+    try:
+        response = await loop.run_in_executor(
+            None,
+            process_file,
+            tmp_path,
+            file.content_type or "",
+            query,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    audio_url = await loop.run_in_executor(None, generate_tts, response)
+    return {"response": response, "audio_url": audio_url}
+
+
+@app.get("/")
+def root():
+    return {"status": "RAG backend running"}
+
+
+@app.get("/health")
+def health():
+    return {"ok": True}

pdf_result.py

@@ -0,0 +1,25 @@
+# 1️⃣ Imports
+import os
+from PyPDF2 import PdfReader
+from dotenv import load_dotenv
+from functions.data_to_vectors import create_vectorstore
+from functions.llm_comm import llm_communication
+# --- Load environment variables ---
+load_dotenv()
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+def rag(file_path,question):
+    print("📕 Processing PDF File...")
+    pdf_reader = PdfReader(file_path)
+    text = ""
+    for page in pdf_reader.pages:
+        text += page.extract_text() + "\n"
+        # Wrap in Document
+    vectorstore = create_vectorstore(text,"pdf_store_chroma" )
+
+    retrieval_chain = llm_communication(vectorstore)
+    # 8️⃣ Query pipeline
+    if question:
+        response = retrieval_chain.invoke({"input": question})
+        print(f"🧠 {question} {response['answer']}\n")
+        return response['answer']
+

requirements.txt

@@ -0,0 +1,18 @@
+fastapi
+uvicorn[standard]
+aiofiles
+python-multipart
+python-dotenv
+pandas
+PyPDF2
+pillow
+pytesseract
+chromadb
+langchain
+langchain-community
+langchain-core
+langchain-text-splitters
+langchain-groq
+sentence-transformers
+vosk
+pyttsx3

text_result.py

@@ -0,0 +1,24 @@
+import io
+import functions.data_to_vectors as dtv
+from functions.llm_comm import llm_communication
+from functions.data_to_vectors import create_vectorstore
+import sys # Import the sys module
+
+def rag(file_path, question):
+    print("📄 Processing TXT File...")
+    # file_path is already a file-like object
+    raw_bytes = file_path.read()  
+    if isinstance(raw_bytes, str):
+        text = raw_bytes  # already decoded
+    else:
+        text = raw_bytes.decode("utf-8")
+
+    print(text)
+    vectorstore = create_vectorstore(text,"text_store_chroma" )
+
+    retrieval_chain = llm_communication(vectorstore)
+    # 8️⃣ Query pipeline
+    if question:
+        response = retrieval_chain.invoke({"input": question})
+        print(f"🧠 {question} {response['answer']}\n")
+        return response['answer']