Initial commit

.env.example

@@ -0,0 +1,4 @@
+# Example environment variables for backend
+GOOGLE_API_KEY=your_google_api_key_here
+NEXT_PUBLIC_SUPABASE_URL=your_supabase_url_here
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key_here

README.md

@@ -0,0 +1,25 @@
+# Backend (FastAPI)
+
+## Structure
+- `api.py` — Main FastAPI app
+- `utils.py` — Helper functions
+- `requirements.txt` — Python dependencies
+- `.env.example` — Example environment variables
+
+## Running Locally
+```sh
+pip install -r requirements.txt
+uvicorn api:app --reload --host 0.0.0.0 --port 8000
+```
+
+## Deploying to Render
+- Push this folder to a GitHub repo
+- Use the following start command on Render:
+  ```
+  uvicorn api:app --host 0.0.0.0 --port 10000
+  ```
+- Add your environment variables in the Render dashboard
+
+---
+
+**Do not commit your real `.env` file! Use `.env.example` for reference.**

api.py

@@ -0,0 +1,80 @@
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from typing import List, Optional
+import numpy as np
+import io
+import os
+from dotenv import load_dotenv
+from pydub import AudioSegment
+from utils import (
+    authenticate,
+    split_documents,
+    build_vectorstore,
+    retrieve_context,
+    retrieve_context_approx,
+    build_prompt,
+    ask_gemini,
+    load_documents_gradio,
+    transcribe
+)
+
+load_dotenv()
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+client = authenticate()
+store = {"value": None}
+
+@app.post("/upload")
+async def upload(files: List[UploadFile] = File(...)):
+    if not files:
+        return JSONResponse({"status": "error", "message": "No files uploaded."}, status_code=400)
+    raw_docs = load_documents_gradio(files)
+    chunks = split_documents(raw_docs)
+    store["value"] = build_vectorstore(chunks)
+    return {"status": "success", "message": "Document processed successfully! You can now ask questions."}
+
+@app.post("/ask")
+async def ask(
+    text: Optional[str] = Form(None),
+    audio: Optional[UploadFile] = File(None)
+):
+    transcribed = None
+    if store["value"] is None:
+        return JSONResponse({"status": "error", "message": "Please upload and process a document first."}, status_code=400)
+    if text and text.strip():
+        query = text.strip()
+    elif audio is not None:
+        audio_bytes = await audio.read()
+        try:
+            audio_io = io.BytesIO(audio_bytes)
+            audio_seg = AudioSegment.from_file(audio_io)
+            y = np.array(audio_seg.get_array_of_samples()).astype(np.float32)
+            if audio_seg.channels == 2:
+                y = y.reshape((-1, 2)).mean(axis=1)  # Convert to mono
+            y /= np.max(np.abs(y))  # Normalize to [-1, 1]
+            sr = audio_seg.frame_rate
+            transcribed = transcribe((sr, y))
+            query = transcribed
+        except FileNotFoundError as e:
+            return JSONResponse({"status": "error", "message": "Audio decode failed: ffmpeg is not installed or not in PATH. Please install ffmpeg."}, status_code=400)
+        except Exception as e:
+            return JSONResponse({"status": "error", "message": f"Audio decode failed: {str(e)}"}, status_code=400)
+    else:
+        return JSONResponse({"status": "error", "message": "Please provide a question by typing or speaking."}, status_code=400)
+    if store["value"]["chunks"] <= 50:
+        top_chunks = retrieve_context(query, store["value"])
+    else:
+        top_chunks = retrieve_context_approx(query, store["value"])
+    prompt = build_prompt(top_chunks, query)
+    answer = ask_gemini(prompt, client)
+    return {"status": "success", "answer": answer.strip(), "transcribed": transcribed}

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+python-dotenv
+pydub
+numpy
+# Add any other dependencies your utils.py or backend needs

utils.py

@@ -0,0 +1,168 @@
+import os
+import getpass
+import faiss
+import numpy as np
+import warnings
+import logging
+
+# Suppress warnings
+logging.getLogger("pdfminer").setLevel(logging.ERROR)
+warnings.filterwarnings("ignore")
+
+from google import genai
+from google.genai import types
+from sentence_transformers import SentenceTransformer
+from transformers import pipeline
+from langchain_community.document_loaders import(
+    UnstructuredPDFLoader,
+    TextLoader,
+    CSVLoader,
+    JSONLoader,
+    UnstructuredPowerPointLoader,
+    UnstructuredExcelLoader,
+    UnstructuredXMLLoader,
+    UnstructuredWordDocumentLoader,
+)
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+
+def authenticate():
+  """Authenticates with the Google Generative AI API using an API key."""
+  api_key = os.environ.get("GOOGLE_API_KEY")
+  if not api_key:
+    api_key = getpass.getpass("Enter your API Key: ")
+  
+  client = genai.Client(api_key=api_key)
+  return client
+
+
+def load_documents_gradio(uploaded_files):
+    docs = []
+    for file in uploaded_files:
+        # For FastAPI UploadFile, save to a temp file
+        if hasattr(file, "filename") and hasattr(file, "file"):
+            import tempfile
+            suffix = os.path.splitext(file.filename)[1]
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                tmp.write(file.file.read())
+                tmp_path = tmp.name
+            file_path = tmp_path
+        else:
+            file_path = file.name  # For Gradio or other file types
+        # Detect type and load accordingly
+        if file_path.lower().endswith('.pdf'):
+            docs.extend(UnstructuredPDFLoader(file_path).load())
+        elif file_path.lower().endswith('.txt'):
+            docs.extend(TextLoader(file_path).load())
+        elif file_path.lower().endswith('.csv'):
+            docs.extend(CSVLoader(file_path).load())
+        elif file_path.lower().endswith('.json'):
+            docs.extend(JSONLoader(file_path).load())
+        elif file_path.lower().endswith('.pptx'):
+            docs.extend(UnstructuredPowerPointLoader(file_path).load())
+        elif file_path.lower().endswith('.xlsx'):
+            docs.extend(UnstructuredExcelLoader(file_path).load())
+        elif file_path.lower().endswith('.xml'):
+            docs.extend(UnstructuredXMLLoader(file_path).load())
+        elif file_path.lower().endswith('.docx'):
+            docs.extend(UnstructuredWordDocumentLoader(file_path).load())
+        else:
+            print(f'Unsupported File Type: {file_path}')
+    return docs
+
+
+def split_documents(docs, chunk_size=500, chunk_overlap=100):
+  """Splits documents into smaller chunks using RecursiveCharacterTextSplitter."""
+  splitter = RecursiveCharacterTextSplitter(
+    chunk_size=chunk_size, chunk_overlap=chunk_overlap
+  )
+  return splitter.split_documents(docs)
+
+
+def build_vectorstore(docs, embedding_model_name="all-MiniLM-L6-v2"):
+  """Builds a FAISS vector store from the document chunks."""
+  texts = [doc.page_content.strip() for doc in docs if doc.page_content.strip()]
+  if not texts:
+    raise ValueError("No valid text found in the documents.")
+
+  print(f"No. of Chunks: {len(texts)}")
+
+  model = SentenceTransformer(embedding_model_name)
+  embeddings = model.encode(texts)
+  print(embeddings.shape)
+
+  index = faiss.IndexFlatL2(embeddings.shape[1])
+  index.add(np.array(embeddings).astype("float32"))
+
+  return {
+    "index": index,
+    "texts": texts,
+    "embedding_model": model,
+    "embeddings": embeddings,
+    "chunks": len(texts)
+  }
+
+
+def retrieve_context(query, store, k=6):
+  """Retrieves the top-k context chunks most similar to the query."""
+  query_vec = store["embedding_model"].encode([query])
+  k = min(k, len(store["texts"]))
+  distances, indices = store["index"].search(query_vec, k)
+  return [store["texts"][i] for i in indices[0]]
+
+
+def retrieve_context_approx(query, store, k=6):
+  """Retrieves context chunks using approximate nearest neighbor search."""
+  ncells = 50
+  D = store["index"].d
+  index = faiss.IndexFlatL2(D)
+  nindex = faiss.IndexIVFFlat(index, D, ncells)
+  nindex.nprobe = 10
+
+  if not nindex.is_trained:
+    nindex.train(np.array(store["embeddings"]).astype("float32"))
+
+  nindex.add(np.array(store["embeddings"]).astype("float32"))
+  query_vec = store["embedding_model"].encode([query])
+  k = min(k, len(store["texts"]))
+  _, indices = nindex.search(np.array(query_vec).astype("float32"), k)
+  return [store["texts"][i] for i in indices[0]]
+
+
+def build_prompt(context_chunks, query):
+  """Builds the prompt for the Gemini API using context and query."""
+  context = "\n".join(context_chunks)
+  return f"""You are a highly knowledgeable and helpful assistant. Use the following context to generate a **detailed and step-by-step** answer to the user's question. Include explanations, examples, and reasoning wherever helpful.
+
+  Context:
+  {context}
+
+  Question: {query}
+  Answer:"""
+
+
+def ask_gemini(prompt, client):
+  """Calls the Gemini API with the given prompt and returns the response."""
+  response = client.models.generate_content(
+    model="gemini-2.0-flash",  # Or your preferred model
+    contents=[prompt],
+    config=types.GenerateContentConfig(max_output_tokens=2048, temperature=0.5, seed=42),
+  )
+  return response.text
+
+# Speech2Text:
+def transcribe(audio, model="openai/whisper-base.en"):
+  if audio is None:
+    raise ValueError("No audio detected!")
+  
+  transcriber = pipeline("automatic-speech-recognition", model=model)
+  sr, y = audio # Sampling rate (KHz) and y= amplitude array
+
+  if y.ndim > 1: # Convert to Mono (CH=1) if Stereo (CH=2; L & R)
+    y = y.mean(1)
+
+  y = y.astype(np.float32)
+  y /= np.max(np.abs(y)) # Normalizing the amplitude values in range [-1,1]
+
+  result = transcriber({"sampling_rate" : sr, "raw" : y})
+  return result["text"]