Adding Main functionality for backend with endpoints(query,upload)

src/core/llm.py

@@ -0,0 +1,39 @@
+import ollama
+import os
+
+# --- Ollama Client Initialization ---
+
+def get_ollama_client():
+    """Initializes and returns the Ollama client."""
+    host = os.environ.get("OLLAMA_HOST", "http://localhost:11434")
+    return ollama.Client(host=host)
+
+# --- Prompt Generation ---
+
+def format_prompt(query: str, context: list[dict]) -> str:
+    """Formats the prompt for the LLM with the retrieved context."""
+    context_str = "\n".join([item['payload']['text'] for item in context])
+    prompt = f"""**Instruction**:
+Answer the user's query based *only* on the provided context.
+If the context does not contain the answer, state that you cannot answer the question with the given information.
+Do not use any prior knowledge.
+
+**Context**:
+{context_str}
+
+**Query**:
+{query}
+
+**Answer**:
+"""
+    return prompt
+
+# --- LLM Interaction ---
+
+def generate_response(client: ollama.Client, model: str, prompt: str):
+    """Generates a response from the LLM."""
+    response = client.chat(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response['message']['content']

src/core/models.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+class QueryRequest(BaseModel):
+    query: str
+
+class QueryResponse(BaseModel):
+    answer: str
+    source_documents: list[dict]

src/core/processing.py

@@ -0,0 +1,25 @@
+import fitz  # PyMuPDF
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from sentence_transformers import SentenceTransformer
+
+def parse_pdf(file_path: str) -> str:
+    """Extracts text from a PDF file."""
+    doc = fitz.open(file_path)
+    text = ""
+    for page in doc:
+        text += page.get_text()
+    doc.close()
+    return text
+
+def chunk_text(text: str) -> list[str]:
+    """Splits text into smaller chunks."""
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200,
+        length_function=len
+    )
+    return text_splitter.split_text(text)
+
+def get_embedding_model(model_name: str = 'all-MiniLM-L6-v2'):
+    """Loads the sentence-transformer model."""
+    return SentenceTransformer(model_name)

src/core/vector_store.py

@@ -0,0 +1,46 @@
+from qdrant_client import QdrantClient, models
+import os
+
+# --- Qdrant Client Initialization ---
+
+def get_qdrant_client():
+    """Initializes and returns the Qdrant client."""
+    # Get Qdrant host from environment variable, default to localhost if not set
+    host = os.environ.get("QDRANT_HOST", "localhost")
+    client = QdrantClient(host=host, port=6333)
+    return client
+
+# --- Collection Management ---
+
+def create_collection_if_not_exists(client: QdrantClient, collection_name: str, vector_size: int):
+    """Creates a Qdrant collection if it doesn't already exist."""
+    try:
+        client.get_collection(collection_name=collection_name)
+    except Exception: # If the collection does not exist, this will raise an exception
+        client.create_collection(
+            collection_name=collection_name,
+            vectors_config=models.VectorParams(size=vector_size, distance=models.Distance.COSINE),
+        )
+
+# --- Vector Operations ---
+
+def upsert_vectors(client: QdrantClient, collection_name: str, vectors, payloads):
+    """Upserts vectors and their payloads into the specified collection."""
+    client.upsert(
+        collection_name=collection_name,
+        points=models.Batch(
+            ids=None,  # Let Qdrant assign IDs
+            vectors=vectors,
+            payloads=payloads
+        ),
+        wait=True
+    )
+
+def search_vectors(client: QdrantClient, collection_name: str, query_vector, limit: int = 5):
+    """Searches for similar vectors in the collection."""
+    return client.search(
+        collection_name=collection_name,
+        query_vector=query_vector,
+        limit=limit,
+        with_payload=True
+    )

src/main.py

@@ -1,7 +1,107 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, UploadFile, File, HTTPException
+import shutil
+import os
+from .core.processing import parse_pdf, chunk_text, get_embedding_model
+from .core.vector_store import get_qdrant_client, create_collection_if_not_exists, upsert_vectors, search_vectors
+from .core.llm import get_ollama_client, format_prompt, generate_response
+from .core.models import QueryRequest, QueryResponse
 
 app = FastAPI()
 
+# --- Constants ---
+UPLOADS_DIR = "uploads"
+QDRANT_COLLECTION_NAME = "knowledge_base"
+OLLAMA_MODEL = "llama3"
+
+# --- Application Startup ---
+# Create uploads directory if it doesn't exist
+if not os.path.exists(UPLOADS_DIR):
+    os.makedirs(UPLOADS_DIR)
+
+# Load models and clients on startup
+embedding_model = get_embedding_model()
+qdrant_client = get_qdrant_client()
+ollama_client = get_ollama_client()
+
+# Get the size of the embeddings from the model
+embedding_size = embedding_model.get_sentence_embedding_dimension()
+
+# Create the Qdrant collection if it doesn't exist
+create_collection_if_not_exists(qdrant_client, QDRANT_COLLECTION_NAME, embedding_size)
+
+# --- API Endpoints ---
+@app.post("/upload")
+def upload_file(file: UploadFile = File(...)):
+    if not file.filename.lower().endswith(".pdf"):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only PDFs are supported.")
+
+    file_path = os.path.join(UPLOADS_DIR, file.filename)
+    
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error saving file: {e}")
+        
+    try:
+        text = parse_pdf(file_path)
+        if not text.strip():
+            raise HTTPException(status_code=400, detail="Could not extract text from the PDF.")
+
+        chunks = chunk_text(text)
+        embeddings = embedding_model.encode(chunks)
+        payloads = [{"text": chunk, "source": file.filename} for chunk in chunks]
+
+        upsert_vectors(qdrant_client, QDRANT_COLLECTION_NAME, embeddings, payloads)
+
+    except Exception as e:
+        os.remove(file_path)
+        raise HTTPException(status_code=500, detail=f"Error processing and storing file: {e}")
+    finally:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+    return {
+        "filename": file.filename,
+        "message": f"Successfully uploaded, processed, and stored.",
+        "num_chunks_stored": len(chunks)
+    }
+
+@app.post("/query", response_model=QueryResponse)
+def query_knowledge_base(request: QueryRequest):
+    try:
+        # 1. Embed the user's query
+        query_embedding = embedding_model.encode(request.query)
+
+        # 2. Search for relevant documents in Qdrant
+        search_results = search_vectors(
+            client=qdrant_client,
+            collection_name=QDRANT_COLLECTION_NAME,
+            query_vector=query_embedding,
+            limit=3  # Retrieve top 3 most relevant chunks
+        )
+
+        # 3. Format the prompt for the LLM
+        prompt = format_prompt(request.query, search_results)
+
+        # 4. Generate a response from the LLM
+        answer = generate_response(ollama_client, OLLAMA_MODEL, prompt)
+
+        # 5. Extract source documents for citation
+        source_documents = [
+            {
+                "source": result.payload["source"],
+                "text": result.payload["text"],
+                "score": result.score
+            }
+            for result in search_results
+        ]
+
+        return QueryResponse(answer=answer, source_documents=source_documents)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during query: {e}")
+
 @app.get("/health")
 def health_check():
     return {"status": "ok"}