Add FastAPI app and Dockerfile

.gitattributes

@@ -0,0 +1,2 @@
+documents/*.pdf filter=lfs diff=lfs merge=lfs -text
+chroma_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+.venv
+all-libraries.txt
+
+.env.local
+.env*

Dockerfile

@@ -0,0 +1,39 @@
+# Dockerfile
+
+# Use a base image with Python installed. Python 3.10 or 3.11 are good choices.
+# We choose a Debian-based image for compatibility with apt_packages.
+FROM python:3.10-slim-buster
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Install system dependencies needed for pdf2image (Poppler) and pytesseract (Tesseract)
+# These correspond to the apt_packages listed in your requirements.txt comments.
+RUN apt-get update && apt-get install -y \
+    libpoppler-dev \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    tesseract-ocr-tur \
+    # Add other languages if needed, e.g., tesseract-ocr-all for all languages
+    # If you remove apt_packages from requirements.txt, ensure these are here.
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements.txt and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of your application code
+# This copies app.py, the src/ folder, and the documents/ folder.
+COPY . .
+
+# Set the environment variable for Tesseract if it's not in the default path
+# This might be needed if Tesseract's executable isn't directly on PATH inside the container.
+# Tesseract is often installed to /usr/bin/tesseract or similar in Linux containers.
+# It's good practice to explicitly tell pytesseract where to find it.
+ENV TESSDATA_PREFIX=/usr/share/tesseract-ocr/4.00/tessdata
+ENV TESSERACT_CMD=/usr/bin/tesseract
+
+# Command to run your FastAPI application using Uvicorn
+# 0.0.0.0 makes it accessible from outside the container
+# 7860 is the default port Hugging Face Spaces expects for web applications
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,78 @@
+# app.py
+
+import os
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import sys
+
+# Add src to the Python path so we can import modules from it
+# This is crucial for deployment environments where 'src' might not be automatically recognized
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'src')))
+
+# Import your DocumentRAG class and other necessary components from your backend script
+# Make sure your rag_backend.py has `embedding_model` defined globally or passed correctly
+from compassia import DocumentRAG, embedding_model, pdf_document_paths, extract_text_from_pdf, ocr_pdf, chunk_text # Import all needed functions/variables
+
+# --- Initialize the RAG system globally ---
+# This ensures the model loads and indexing happens once when the FastAPI app starts
+# and persists across requests within the same process.
+# ChromaDB will save its data to the './chroma_db' directory within the Space.
+print("--- FastAPI App Startup: Initializing RAG System ---")
+rag_system = DocumentRAG(
+    embedding_model=embedding_model,
+    persist_directory="./chroma_db", # ChromaDB will store data here in the Space
+    collection_name="pdf_documents_collection",
+    chunk_size=700, # Match your existing chunk size
+    overlap=100     # Match your existing overlap
+)
+
+# --- Index documents on startup ---
+# This loop will run when the FastAPI app first starts.
+# It uses ChromaDB's persistence, so documents already indexed will be skipped.
+print("--- FastAPI App Startup: Indexing Documents (ChromaDB persistence) ---")
+for pdf_path in pdf_document_paths:
+    # Ensure the path is correct relative to the Space's filesystem
+    full_pdf_path = os.path.join(os.path.dirname(__file__), pdf_path)
+    if os.path.exists(full_pdf_path):
+        rag_system.add_document(full_pdf_path) # Call add_document on rag_system
+    else:
+        print(f"API Error: PDF file not found at {full_pdf_path}. Ensure it's deployed with your app in the 'documents' folder.")
+print("--- FastAPI App Startup: Document indexing complete ---")
+
+
+# --- FastAPI Application Instance ---
+app = FastAPI(
+    title="Compassia AI PDF Chat API",
+    description="Backend API for querying PDFs using DeepSeek (via OpenRouter) and BGE-M3 embeddings.",
+    version="0.1.0",
+)
+
+# Pydantic model for request body validation
+class QueryRequest(BaseModel):
+    question: str
+
+# --- API Endpoint Definition ---
+@app.post("/ask-pdf/")
+async def ask_pdf_endpoint(request: QueryRequest):
+    """
+    Answers a question about the indexed PDF documents using RAG.
+    """
+    try:
+        # Pass an empty list for pdf_paths as documents are already indexed in ChromaDB
+        answer = rag_system.answer_question(request.question, [])
+        return {"answer": answer}
+    except Exception as e:
+        print(f"Error processing /ask-pdf/ request: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Basic health check endpoint
+@app.get("/")
+async def root():
+    return {"message": "Compassia AI PDF Chat API is running. Use /ask-pdf/ for queries."}
+
+# You can run this locally for testing:
+# if __name__ == "__main__":
+#     # This part runs locally if you execute app.py directly
+#     # For deployment, uvicorn is typically run via a command line.
+#     uvicorn.run(app, host="0.0.0.0", port=8000)

chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91452e6331387e73b3f0da0f1370e2824a647883d3970cb2c014200504189419
+size 4104192

compassia.py

@@ -0,0 +1,404 @@
+import requests
+import os
+import io
+import re
+import uuid # For generating unique IDs for ChromaDB
+from PIL import Image
+
+# For text extraction from PDFs (non-OCR)
+from pdfminer.high_level import extract_text_to_fp
+from pdfminer.layout import LAParams
+
+# For image-based PDFs (OCR)
+from pdf2image import convert_from_path
+import pytesseract
+
+# For embeddings and vector search
+from FlagEmbedding import BGEM3FlagModel # Using BGEM3FlagModel directly as per your latest code
+import chromadb # pip install chromadb
+
+# --- IMPORTANT: Configure Paths for Tesseract and Poppler ---
+# If Tesseract is not in your system's PATH, uncomment and set this:
+# pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'
+
+# If pdf2image gives errors about poppler, uncomment and set this:
+# poppler_path = r'C:\path\to\poppler\bin'
+
+# --- OpenRouter DeepSeek API Configuration ---
+API_KEY = os.getenv("DEEPSEEK_R1_V3_API_KEY")
+if API_KEY:
+    API_KEY = API_KEY.strip()
+
+if not API_KEY:
+    raise ValueError("API key is not set. Please set the DEEPSEEK_R1_V3_API_KEY environment variable with your OpenRouter key.")
+
+API_URL = 'https://openrouter.ai/api/v1/chat/completions'
+HEADERS = {
+    'Authorization': f'Bearer {API_KEY}',
+    'Content-Type': 'application/json'
+}
+
+# --- Embedding Model Configuration (Local BGE-M3) ---
+# IMPORTANT: This assumes you've run 'pip install -U FlagEmbedding'
+# BGE-M3 is multilingual, which is good for Turkish PDFs.
+# You might need to download the model weights the first time it's initialized.
+# Ensure you have enough RAM/VRAM for the model.
+print("Loading FlagEmbedding (BGE-M3) model...")
+try:
+    # Initialize BGEM3FlagModel. It will download weights to Hugging Face cache
+    # the first time, hence the need for disk space.
+    embedding_model = BGEM3FlagModel('BAAI/bge-m3', use_fp16=True)
+    print("FlagEmbedding (BGE-M3) model loaded successfully.")
+except Exception as e:
+    print(f"Error loading FlagEmbedding model: {e}")
+    print("Ensure you have resolved disk space issues for model download and have enough memory.")
+    print("You might need to adjust 'use_fp16' based on your hardware (e.g., False for CPU/older GPUs).")
+    exit(1) # Exit if embedding model fails to load
+
+# --- PDF Processing Functions ---
+
+def extract_text_from_pdf(pdf_path: str) -> str:
+    """
+    Extracts text from a PDF. Tries direct text extraction first.
+    If sparse text is found (suggesting image-based PDF), it performs OCR.
+    """
+    print(f"Attempting direct text extraction from: {pdf_path}")
+    output_string = io.StringIO()
+    with open(pdf_path, 'rb') as fp:
+        try:
+            # Use LAParams for better layout analysis
+            extract_text_to_fp(fp, output_string, laparams=LAParams())
+            text = output_string.getvalue()
+            # Basic check: if text is very short for a non-empty PDF, it might be image-based
+            if len(text.strip()) < 100 and os.path.getsize(pdf_path) > 10000: # Check file size as well
+                print("Direct extraction yielded sparse text. Attempting OCR...")
+                return ocr_pdf(pdf_path)
+            return text
+        except Exception as e:
+            print(f"Direct PDF text extraction failed ({e}). Attempting OCR...")
+            return ocr_pdf(pdf_path)
+
+def ocr_pdf(pdf_path: str) -> str:
+    """
+    Performs OCR on a PDF file using pdf2image and pytesseract.
+    Requires Tesseract and Poppler to be installed and in system PATH.
+    """
+    all_text = []
+    try:
+        # Convert PDF pages to images. Higher DPI for better OCR.
+        # Pass poppler_path=poppler_path if it's not in your system's PATH
+        images = convert_from_path(pdf_path, dpi=300) # You can adjust dpi for quality vs. speed
+
+        print(f"  Performing OCR on {len(images)} pages...")
+        for i, img in enumerate(images):
+            # Optional: Basic image preprocessing for better OCR
+            # img = img.convert('L') # Convert to grayscale
+            # img = img.point(lambda x: 0 if x < 128 else 255, '1') # Binarize
+
+            # Perform OCR (lang='eng+tur' for English and Turkish support)
+            page_text = pytesseract.image_to_string(img, lang='eng+tur')
+            all_text.append(page_text)
+            print(f"    Page {i+1} OCR complete.")
+
+    except Exception as e:
+        print(f"OCR process failed: {e}")
+        print("Please ensure Tesseract OCR and Poppler are correctly installed and their executables are in your system's PATH.")
+        return "" # Return empty string if OCR fails
+
+    return "\n".join(all_text)
+
+def chunk_text(text: str, max_chunk_size: int = 700, overlap: int = 100) -> list[str]:
+    """
+    Splits text into chunks of a maximum size with optional overlap.
+    Aims to split by paragraphs/sentences first, then by word.
+    Note: Increased max_chunk_size to 700 to match your previous code's `chunk_size` for RAG.
+    """
+    if not text:
+        return []
+
+    # Simple paragraph-based chunking
+    paragraphs = re.split(r'\n\s*\n', text)
+    chunks = []
+    current_chunk = []
+    current_chunk_len = 0
+
+    for para in paragraphs:
+        if not para.strip():
+            continue
+
+        # If adding paragraph plus a separator exceeds max_chunk_size,
+        # or if the current_chunk is already substantial and adding this makes it too big,
+        # then finalize the current chunk.
+        if current_chunk_len + len(para) + len('\n\n') > max_chunk_size:
+            if current_chunk: # Only append if current_chunk is not empty
+                chunks.append("\n\n".join(current_chunk))
+                current_chunk = []
+                current_chunk_len = 0
+
+            # If a single paragraph is larger than max_chunk_size, split it by words
+            if len(para) > max_chunk_size:
+                words = para.split(' ')
+                sub_chunk = []
+                sub_chunk_len = 0
+                for word in words:
+                    if sub_chunk_len + len(word) + len(' ') > max_chunk_size:
+                        chunks.append(" ".join(sub_chunk))
+                        sub_chunk = [word]
+                        sub_chunk_len = len(word)
+                    else:
+                        sub_chunk.append(word)
+                        sub_chunk_len += len(word) + len(' ')
+                if sub_chunk: # Add remaining sub-chunk
+                    chunks.append(" ".join(sub_chunk))
+            else: # Paragraph fits into a new chunk
+                current_chunk.append(para)
+                current_chunk_len += len(para) + len('\n\n')
+        else: # Paragraph fits into the current chunk
+            current_chunk.append(para)
+            current_chunk_len += len(para) + len('\n\n')
+
+    if current_chunk: # Add any remaining text
+        chunks.append("\n\n".join(current_chunk))
+    
+    # Apply overlap: This is a simplistic overlap implementation.
+    # For more robust RAG, consider sentence-window retrieval or more advanced chunking libraries.
+    final_chunks_with_overlap = []
+    for i in range(len(chunks)):
+        chunk = chunks[i]
+        if i > 0 and overlap > 0:
+            # Take a portion of the previous chunk to overlap
+            prev_chunk_part = chunks[i-1][-overlap:]
+            chunk = prev_chunk_part + "\n" + chunk
+        final_chunks_with_overlap.append(chunk)
+
+    return final_chunks_with_overlap
+
+
+# --- RAG Core Functions with ChromaDB ---
+
+class DocumentRAG:
+    def __init__(self, embedding_model, persist_directory="./chroma_db", collection_name="pdf_docs", chunk_size=700, overlap=100):
+        self.embedding_model = embedding_model
+        self.chunk_size = chunk_size
+        self.overlap = overlap
+        self.persist_directory = persist_directory
+        self.collection_name = collection_name
+        
+        # Initialize ChromaDB client and collection
+        print(f"Initializing ChromaDB at: {self.persist_directory}")
+        self.client = chromadb.PersistentClient(path=self.persist_directory)
+        
+        # Get or create the collection
+        self.collection = self.client.get_or_create_collection(
+            name=self.collection_name,
+            # Genkit uses 'cosine' by default. 'l2' (Euclidean) or 'ip' (Inner Product)
+            # are also common. BGE-M3 generally uses cosine.
+            metadata={"hnsw:space": "cosine"}
+        )
+        print(f"ChromaDB collection '{self.collection_name}' ready.")
+
+    def _generate_chunk_id(self, pdf_path: str, chunk_idx: int) -> str:
+        """Generates a unique ID for each chunk based on file path and index."""
+        # Use UUID to ensure uniqueness even if paths are similar or contain problematic chars
+        return f"{os.path.basename(pdf_path)}_{chunk_idx}_{uuid.uuid4().hex}"
+
+    def add_document(self, pdf_path: str):
+        print(f"Adding document: {pdf_path}")
+        
+        # Check if the document has already been indexed in ChromaDB
+        # We'll use the file path as a simple way to check if _any_ chunk from this PDF exists.
+        # A more robust check might involve hashing the file content or checking specific metadata.
+        results = self.collection.get(
+            where={"source": pdf_path},
+            limit=1
+        )
+        if results and results['ids']:
+            print(f"  Document '{pdf_path}' already in ChromaDB. Skipping re-indexing.")
+            return
+
+        extracted_text = extract_text_from_pdf(pdf_path)
+        if not extracted_text:
+            print(f"Warning: No text extracted from {pdf_path}. Skipping.")
+            return
+
+        chunks = chunk_text(extracted_text, self.chunk_size, self.overlap)
+        if not chunks:
+            print(f"Warning: No chunks generated for {pdf_path}. Skipping.")
+            return
+
+        # Prepare data for ChromaDB
+        documents_to_add = []
+        metadatas_to_add = []
+        ids_to_add = []
+
+        print(f"  Generating embeddings for {len(chunks)} chunks and preparing for ChromaDB...")
+        
+        # BGE-M3's encode method returns a dictionary for dense, sparse, etc.
+        # We need the 'dense_vecs' for standard vector search.
+        encoded_results = self.embedding_model.encode(
+            chunks, 
+            batch_size=32, # Adjust batch_size if out of memory
+            return_dense=True, 
+            return_sparse=False, 
+            return_colbert_vecs=False
+        )
+        
+        # Extract only the dense vectors for ChromaDB
+        chunk_embeddings = encoded_results["dense_vecs"]
+
+        # Ensure embeddings are normalized if using cosine similarity with IP index,
+        # but ChromaDB's 'cosine' space handles this internally.
+        # If using FAISS with IP, you'd normalize here:
+        # from numpy.linalg import norm
+        # chunk_embeddings = chunk_embeddings / norm(chunk_embeddings, axis=1, keepdims=True)
+
+
+        for i, chunk in enumerate(chunks):
+            unique_id = self._generate_chunk_id(pdf_path, i)
+            documents_to_add.append(chunk)
+            metadatas_to_add.append({"source": pdf_path, "chunk_id": i})
+            ids_to_add.append(unique_id)
+        
+        # Add to ChromaDB collection
+        self.collection.add(
+            documents=documents_to_add,
+            embeddings=chunk_embeddings.tolist(), # Convert numpy array to list of lists
+            metadatas=metadatas_to_add,
+            ids=ids_to_add
+        )
+        
+        print(f"  {len(documents_to_add)} chunks from '{pdf_path}' added to ChromaDB.")
+        print(f"  Total chunks in collection: {self.collection.count()}")
+
+    def retrieve_context(self, query: str, top_k: int = 3) -> list[str]:
+        """
+        Retrieves top_k most relevant document chunks for a given query from ChromaDB.
+        """
+        if self.collection.count() == 0:
+            print("Error: No documents indexed in ChromaDB. Cannot retrieve context.")
+            return []
+
+        print(f"Retrieving context for query: '{query}'")
+        
+        # Encode the query using the embedding model
+        query_embedding_result = self.embedding_model.encode(
+            [query], 
+            batch_size=1,
+            return_dense=True, 
+            return_sparse=False, 
+            return_colbert_vecs=False
+        )
+        query_embedding = query_embedding_result["dense_vecs"].tolist() # Get dense vector and convert to list
+
+        # Query ChromaDB
+        results = self.collection.query(
+            query_embeddings=query_embedding,
+            n_results=top_k,
+            include=['documents', 'distances', 'metadatas']
+        )
+        
+        retrieved_chunks_texts = []
+        if results and results['documents']:
+            for i, doc_text in enumerate(results['documents'][0]):
+                source_info = results['metadatas'][0][i].get('source', 'Unknown Source')
+                chunk_id_info = results['metadatas'][0][i].get('chunk_id', 'N/A')
+                distance_info = results['distances'][0][i] # Smaller distance is more similar for cosine
+
+                retrieved_chunks_texts.append(doc_text)
+                print(f"  Retrieved chunk {i+1} (distance: {distance_info:.4f}) from '{source_info}' (chunk {chunk_id_info}).")
+        else:
+            print("  No relevant chunks found in ChromaDB.")
+            
+        return retrieved_chunks_texts
+
+    def answer_question(self, question: str, pdf_paths: list[str]) -> str:
+        """
+        Answers a question by ensuring PDFs are indexed, retrieving context,
+        and querying DeepSeek.
+        """
+        # Ensure documents are added for specified paths.
+        # This will now intelligently skip already indexed documents.
+        for path in pdf_paths:
+            self.add_document(path)
+
+        # Get relevant context from ChromaDB
+        context_chunks = self.retrieve_context(question)
+        context = "\n\n".join(context_chunks)
+
+        if not context:
+            print("Warning: No relevant context found. Answering based on general knowledge or indicating lack of information.")
+            context_prompt = ""
+        else:
+            context_prompt = f"Using the following context:\n\n{context}\n\n"
+
+        # Construct prompt for DeepSeek
+        messages = [
+            {"role": "system", "content": "You are an AI assistant specialized in answering questions based on provided context. If the answer is not in the context, state that explicitly. If you cannot answer based *solely* on the context, politely indicate that the information is not available in the provided documents."},
+            {"role": "user", "content": f"{context_prompt}Question: {question}"}
+        ]
+
+        # Call DeepSeek API via OpenRouter
+        print("\nSending request to DeepSeek API...")
+        data = {
+            "model": "deepseek/deepseek-chat:free", # Using the specified free model
+            "messages": messages,
+            "temperature": 0.5, # Adjust for creativity vs. factualness
+            "max_tokens": 500, # Limit response length
+        }
+
+        response = requests.post(API_URL, json=data, headers=HEADERS)
+
+        if response.status_code == 200:
+            ai_response = response.json()
+            answer = ai_response['choices'][0]['message']['content']
+            print("\nDeepSeek Response:")
+            print(answer)
+            return answer
+        else:
+            error_message = f"Failed to fetch data from DeepSeek API. Status Code: {response.status_code}. Response: {response.text}"
+            print(error_message)
+            return f"Error: Could not get an answer from the AI. Details: {error_message}"
+
+# --- Main execution logic ---
+if __name__ == "__main__":
+    # Initialize the RAG system with ChromaDB persistence
+    # The 'chroma_db' directory will be created in your project root.
+    rag_system = DocumentRAG(
+        embedding_model=embedding_model,
+        persist_directory="./chroma_db", # This is where your vector DB will be saved
+        collection_name="pdf_documents_collection", # A unique name for your collection
+        chunk_size=700,
+        overlap=100
+    )
+
+    # --- Define your PDF documents ---
+    # Replace with the actual paths to your PDF files.
+    # For testing, ensure 'documents' directory exists and contains your PDFs.
+    pdf_document_paths = [
+        "documents/heracles_tr.pdf", # Heracles TR PDF path
+        "documents/heracles_en.pdf", # Heracles EN PDF path
+        # Add more PDF paths here if you have them
+        "documents/ogrenci_katki_payi_ogrenim_ucretleri.pdf",
+        "documents/Ogrenci_Liderligi_Burs_Programi_Sozlesme_Metni_2024-2025.pdf",
+        "documents/tmv-bursluluk-yonergesi.pdf"
+    ]
+
+    # --- Add PDFs to the RAG system for indexing ---
+    # This will now process only new or unindexed documents.
+    print("\n--- Indexing Documents ---")
+    for pdf_path in pdf_document_paths:
+        if os.path.exists(pdf_path):
+            rag_system.add_document(pdf_path)
+        else:
+            print(f"Error: PDF file not found at {pdf_path}. Please check the path.")
+
+    # --- Start Chat Loop ---
+    print("\n--- PDF Chat with DeepSeek (Type 'quit' to exit) ---")
+    while True:
+        user_question = input("\nYour question about the PDF(s): ")
+        if user_question.lower() == 'quit':
+            print("Exiting chat.")
+            break
+        
+        # No need to pass pdf_document_paths here; documents are already in ChromaDB
+        rag_system.answer_question(user_question, []) # Pass an empty list, as documents are in DB

documents/Ogrenci_Liderligi_Burs_Programi_Sozlesme_Metni_2024-2025.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd1dc09026b3212985f74ff6c9f322f9c40883039911b034c84a879ddb1531bd
+size 177096

documents/heracles_en.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:010a6ea71343b7d41f5b0a907f7487448e72c5dad1d37ab333e0b936d4bf5c4a
+size 581483

documents/heracles_tr.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9879afb2856c8f8c5177ea1470607f5b4a45b49ffa6fd241b24e657a2f8e7a8
+size 564377

documents/ogrenci_katki_payi_ogrenim_ucretleri.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb0d72f118f8cf4c8bf8c3212ced62de48c3808b4325ce473cbd1c4418594e8d
+size 549275

documents/tmv-bursluluk-yonergesi.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa5e97a0f06393484000d42b9258ca68ecf823b777661064c44683dc7602963d
+size 337112

requirements.txt

@@ -0,0 +1,16 @@
+requests
+pdf2image
+pytesseract
+FlagEmbedding 
+python-dotenv 
+pdfminer.six   
+Pillow  
+faiss-cpu
+
+chromadb
+fastapi
+uvicorn # For serving the FastAPI application
+
+# System dependencies for Tesseract and Poppler on Linux
+# Hugging Face Spaces uses apt-get for these
+apt_packages = python3-dev libtesseract-dev libleptonica-dev poppler-utils