Rag-Implementation

.gitignore

@@ -0,0 +1,14 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+venv/
+.env
+
+# VSCode
+.vscode/
+
+# Streamlit
+frontend/.streamlit/

README.md

@@ -0,0 +1,3 @@
+# RAG Mini Project
+
+Project structure and setup instructions.

backend/__init__.py

@@ -0,0 +1 @@
+# Package marker

backend/chunker.py

@@ -0,0 +1,97 @@
+from nltk.tokenize import sent_tokenize
+import nltk
+import re
+
+# Download the new punkt_tab tokenizer
+try:
+    nltk.download('punkt_tab')
+except:
+    # Fallback if punkt_tab is not available
+    try:
+        nltk.download('punkt')
+    except:
+        print("Warning: NLTK punkt tokenizer not available")
+
+def chunk_text(text, chunk_size=200, overlap=50):
+    """
+    Chunk text into smaller segments with word-based overlap.
+    
+    Args:
+        text (str): Input text to chunk
+        chunk_size (int): Maximum words per chunk
+        overlap (int): Number of overlapping words between chunks
+    
+    Returns:
+        list: List of text chunks
+    """
+    try:
+        # Try using NLTK sentence tokenizer
+        sentences = sent_tokenize(text)
+    except LookupError:
+        # Fallback to regex-based sentence splitting if NLTK fails
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+    
+    chunks = []
+    current_chunk = []
+    current_length = 0
+
+    for sentence in sentences:
+        words = sentence.split()
+        word_count = len(words)
+
+        # If adding this sentence doesn't exceed chunk size
+        if current_length + word_count <= chunk_size:
+            current_chunk.append(sentence)
+            current_length += word_count
+        else:
+            # Finalize current chunk
+            if current_chunk:  # Only add non-empty chunks
+                chunks.append(" ".join(current_chunk))
+
+            # Handle overlap using words, not sentences
+            if overlap > 0 and current_chunk:
+                # Get last 'overlap' words from the end of current chunk
+                overlap_words = " ".join(current_chunk).split()[-overlap:]
+                current_chunk = [" ".join(overlap_words)]
+                current_length = len(overlap_words)
+            else:
+                current_chunk = []
+                current_length = 0
+
+            # Start new chunk with the current sentence
+            current_chunk.append(sentence)
+            current_length += word_count
+
+    # Add last remaining chunk
+    if current_chunk:
+        chunks.append(" ".join(current_chunk))
+
+    return chunks
+
+# Alternative chunking function without NLTK dependency
+def chunk_text_simple(text, chunk_size=200, overlap=50):
+    """
+    Simple text chunking without NLTK dependency.
+    
+    Args:
+        text (str): Input text to chunk
+        chunk_size (int): Maximum words per chunk
+        overlap (int): Number of overlapping words between chunks
+    
+    Returns:
+        list: List of text chunks
+    """
+    words = text.split()
+    chunks = []
+    
+    i = 0
+    while i < len(words):
+        # Get chunk_size words starting from position i
+        chunk_words = words[i:i + chunk_size]
+        chunks.append(" ".join(chunk_words))
+        
+        # Move forward by (chunk_size - overlap) words
+        i += max(1, chunk_size - overlap)
+    
+    return chunks

backend/embed_utils.py

@@ -0,0 +1,25 @@
+# backend/embed_utils.py
+
+from sentence_transformers import SentenceTransformer
+from backend.qdrant_client import qdrant_client, COLLECTION_NAME
+from qdrant_client.http.models import PointStruct
+from backend.chunker import chunk_text
+from backend.llm_client import query_llm
+import uuid
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+def process_document(text):
+    chunks = chunk_text(text)
+    vectors = model.encode(chunks)
+    points = [
+        PointStruct(id=str(uuid.uuid4()), vector=vec.tolist(), payload={"text": chunk})
+        for chunk, vec in zip(chunks, vectors)
+    ]
+    qdrant_client.upsert(collection_name=COLLECTION_NAME, points=points)
+
+def get_answer(question):
+    q_vector = model.encode([question])[0].tolist()
+    hits = qdrant_client.search(collection_name=COLLECTION_NAME, query_vector=q_vector, limit=3)
+    context = "\n".join(hit.payload["text"] for hit in hits)
+    return query_llm(prompt=question, context=context)

backend/llm_client.py

@@ -0,0 +1,20 @@
+from openai import OpenAI
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+api_key = os.getenv("OPENROUTER_API_KEY")
+model_name = os.getenv("OPENROUTER_MODEL", "sarvamai/sarvam-m:free")
+
+client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=api_key)
+
+def query_llm(prompt: str, context: str = "") -> str:
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": f"Context:\n{context}\n\nQuestion:\n{prompt}"}
+        ]
+    )
+    return response.choices[0].message.content

backend/main.py

@@ -0,0 +1,25 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
+from backend.embed_utils import process_document, get_answer
+import os
+
+app = FastAPI()
+
+@app.post("/upload")
+def upload_doc(file: UploadFile = File(...)):
+    try:
+        content = file.file.read().decode("utf-8")
+        process_document(content)
+        return {"status": "✅ Document processed and stored in vector DB."}
+    except UnicodeDecodeError:
+        raise HTTPException(status_code=400, detail="❌ File must be UTF-8 encoded plain text.")
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": f"⚠️ Internal Server Error: {str(e)}"})
+
+@app.get("/ask")
+def ask_question(question: str):
+    try:
+        answer = get_answer(question)
+        return {"answer": answer}
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": f"⚠️ Failed to retrieve answer: {str(e)}"})

backend/qdrant_client.py

@@ -0,0 +1,31 @@
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import VectorParams, Distance
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+QDRANT_HOST = os.getenv(
+    "QDRANT_HOST",
+    "https://af4d46cf-7554-4390-a899-d26487a92023.eu-central-1-0.aws.cloud.qdrant.io"
+)
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+COLLECTION_NAME = "rag_collection"
+
+qdrant_client = QdrantClient(
+    url=QDRANT_HOST,
+    api_key=QDRANT_API_KEY,
+    prefer_grpc=False,
+    check_compatibility=False,
+)
+
+# Optional: Print connection test
+print("✅ Connected to Qdrant via REST")
+
+# Create collection if not exists
+existing_collections = qdrant_client.get_collections().collections
+if COLLECTION_NAME not in [col.name for col in existing_collections]:
+    qdrant_client.recreate_collection(
+        collection_name=COLLECTION_NAME,
+        vectors_config=VectorParams(size=384, distance=Distance.COSINE),
+    )

frontend/app.py

@@ -0,0 +1,23 @@
+# Streamlit UI
+import streamlit as st
+import requests
+import nltk
+nltk.download('punkt')
+
+st.title("📄 RAG Mini App")
+
+st.subheader("Upload Document")
+uploaded_file = st.file_uploader("Upload a .txt file", type=["txt"])
+
+if uploaded_file:
+    content = uploaded_file.read().decode("utf-8")
+    response = requests.post("http://localhost:8000/upload", files={"file": ("doc.txt", content)})
+    st.success("Uploaded and processed.")
+
+st.subheader("Ask a Question")
+question = st.text_input("Enter your question")
+
+if st.button("Get Answer") and question:
+    response = requests.get("http://localhost:8000/ask", params={"question": question})
+    st.markdown("**Answer:**")
+    st.write(response.json()["answer"])

requirements.txt

@@ -0,0 +1,12 @@
+# Add your Python dependencies here
+fastapi
+uvicorn
+qdrant-client
+sentence-transformers
+streamlit
+openai
+python-dotenv
+requests
+nltk
+python-multipart
+