Initial WorkWise backend deployment

.env.example

@@ -0,0 +1,23 @@
+# Faiss (local index) Configuration
+FAISS_INDEX_PATH=data/faiss.index
+FAISS_PAYLOADS_PATH=data/faiss_payloads.json
+
+# Qdrant Configuration
+QDRANT_URL=http://localhost:6333
+QDRANT_API_KEY=
+QDRANT_COLLECTION_NAME=jira_tickets
+
+# Hugging Face Configuration
+HF_API_URL=https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.1
+HF_TOKEN=your_huggingface_token_here
+
+# Embedding Model
+EMBEDDING_MODEL=sentence-transformers/all-MiniLM-L6-v2
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000
+LOG_LEVEL=info
+
+# CORS
+ALLOWED_ORIGINS=http://localhost:5173,https://your-frontend.pages.dev

app.py

@@ -0,0 +1,17 @@
+import gradio as gr
+from fastapi import FastAPI
+from app.main import app as fastapi_app  # your existing FastAPI app
+
+# Mount FastAPI under Gradio
+gradio_app = gr.Blocks()
+gradio_app.launch = lambda *args, **kwargs: None  # Dummy launch; not used
+
+# Hugging Face expects a variable called `app`
+app = FastAPI()
+
+@app.get("/")
+def root():
+    return {"message": "WorkWise Backend (Faiss + FastAPI) on ZeroGPU"}
+
+# Mount your existing FastAPI app
+app.mount("/api", fastapi_app)

app/__init__.py

@@ -0,0 +1,2 @@
+"""WorkWise Backend Application"""
+__version__ = "1.0.0"

app/config.py

@@ -0,0 +1,38 @@
+"""Configuration management for WorkWise backend"""
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings:
+    """Application settings loaded from environment variables"""
+    
+    # Faiss (local) configuration
+    FAISS_INDEX_PATH: str = os.getenv("FAISS_INDEX_PATH", "data/faiss.index")
+    FAISS_PAYLOADS_PATH: str = os.getenv("FAISS_PAYLOADS_PATH", "data/faiss_payloads.json")
+
+    # Qdrant Configuration
+    QDRANT_URL: str = os.getenv("QDRANT_URL", "http://localhost:6333")
+    QDRANT_API_KEY: str = os.getenv("QDRANT_API_KEY", "")
+    QDRANT_COLLECTION_NAME: str = os.getenv("QDRANT_COLLECTION_NAME", "jira_tickets")
+    
+    # Hugging Face Configuration
+    HF_API_URL: str = os.getenv("HF_API_URL", "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.1")
+    HF_TOKEN: str = os.getenv("HF_TOKEN", "")
+    
+    # Embedding Model
+    EMBEDDING_MODEL: str = os.getenv("EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+    
+    # Server Configuration
+    HOST: str = os.getenv("HOST", "0.0.0.0")
+    PORT: int = int(os.getenv("PORT", 8000))
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "info")
+    
+    # CORS
+    ALLOWED_ORIGINS: list = os.getenv("ALLOWED_ORIGINS", "http://localhost:5173").split(",")
+    
+    # Vector Search
+    TOP_K: int = 5
+    SCORE_THRESHOLD: float = 0.5
+
+settings = Settings()

app/main.py

@@ -0,0 +1,61 @@
+"""Main FastAPI application entry point"""
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.config import settings
+from app.routes import ingest_routes, ask_routes, metrics_routes
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+app = FastAPI(
+    title="WorkWise API",
+    description="RAG-powered Jira analytics application",
+    version="1.0.0"
+)
+
+# CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(ingest_routes.router, prefix="/api", tags=["Ingestion"])
+app.include_router(ask_routes.router, prefix="/api", tags=["Query"])
+app.include_router(metrics_routes.router, prefix="/api", tags=["Metrics"])
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "status": "online",
+        "service": "WorkWise API",
+        "version": "1.0.0"
+    }
+
+@app.get("/health")
+async def health_check():
+    """Detailed health check"""
+    info = vector_store.get_collection_info()
+    return {
+        "status": "healthy",
+        "index_path": settings.FAISS_INDEX_PATH,
+        "payloads_path": settings.FAISS_PAYLOADS_PATH,
+        "vectors_count": info.get("vectors_count", 0)
+
+        #"qdrant_url": settings.QDRANT_URL,
+        #"collection": settings.QDRANT_COLLECTION_NAME
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app.main:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        reload=True,
+        log_level=settings.LOG_LEVEL
+    )

app/models/__init__.py

@@ -0,0 +1 @@
+"""Data models for WorkWise"""

app/models/jira_schema.py

@@ -0,0 +1,52 @@
+"""Pydantic models for Jira ticket data"""
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from datetime import datetime
+
+class JiraTicket(BaseModel):
+    """Jira ticket schema"""
+    ticket_id: str = Field(..., description="Unique ticket identifier")
+    summary: str = Field(..., description="Ticket summary")
+    description: Optional[str] = Field(None, description="Detailed description")
+    status: str = Field(..., description="Current status")
+    priority: str = Field(..., description="Priority level")
+    assignee: Optional[str] = Field(None, description="Assigned team member")
+    reporter: str = Field(..., description="Ticket creator")
+    project: str = Field(..., description="Project name")
+    created_date: str = Field(..., description="Creation timestamp")
+    resolved_date: Optional[str] = Field(None, description="Resolution timestamp")
+    issue_type: str = Field(..., description="Type of issue")
+    labels: Optional[str] = Field(None, description="Comma-separated labels")
+
+class IngestRequest(BaseModel):
+    """Request model for data ingestion"""
+    file_path: str = Field(..., description="Path to Jira data file")
+
+class IngestResponse(BaseModel):
+    """Response model for data ingestion"""
+    status: str
+    records_indexed: int
+    message: Optional[str] = None
+
+class QueryRequest(BaseModel):
+    """Request model for RAG queries"""
+    query: str = Field(..., description="Natural language question")
+
+class ChartData(BaseModel):
+    """Chart data structure"""
+    type: str = Field(..., description="Chart type: bar, line, pie")
+    data: List[dict] = Field(..., description="Chart data points")
+
+class QueryResponse(BaseModel):
+    """Response model for RAG queries"""
+    answer: str
+    chart: Optional[ChartData] = None
+    sources: Optional[List[str]] = None
+
+class MetricsResponse(BaseModel):
+    """Response model for metrics endpoint"""
+    avg_resolution_time: str
+    open_tickets: int
+    closed_tickets: int
+    sla_compliance: str
+    total_tickets: int

app/routes/__init__.py

@@ -0,0 +1 @@
+"""API route modules"""

app/routes/ask_routes.py

@@ -0,0 +1,83 @@
+"""Routes for RAG queries"""
+from fastapi import APIRouter, HTTPException
+from app.models.jira_schema import QueryRequest, QueryResponse
+from app.services.retriever import retriever
+from app.services.generator import generator
+from app.utils.response_builder import build_query_response, extract_chart_intent
+from app.utils.logger import setup_logger
+from collections import Counter
+
+logger = setup_logger(__name__)
+router = APIRouter()
+
+@router.post("/ask", response_model=QueryResponse)
+async def ask_question(request: QueryRequest):
+    """
+    Answer natural language questions using RAG
+    
+    - Retrieves relevant Jira tickets
+    - Generates answer using LLM
+    - Optionally includes visualizations
+    """
+    try:
+        logger.info(f"Processing query: {request.query}")
+        
+        # Retrieve relevant documents
+        results = retriever.retrieve(request.query)
+        
+        if not results:
+            return build_query_response(
+                answer="I couldn't find any relevant Jira tickets for your question. Please try rephrasing or check if data has been ingested.",
+                sources=[]
+            )
+        
+        # Format context
+        context = retriever.format_context(results)
+        
+        # Generate answer
+        answer = generator.generate_rag_response(request.query, context)
+        
+        # Extract source ticket IDs
+        sources = [r['payload'].get('ticket_id', 'Unknown') for r in results[:3]]
+        
+        # Check if visualization is needed
+        chart_type = extract_chart_intent(request.query)
+        chart_data = None
+        
+        if chart_type:
+            chart_data = _generate_chart_data(results, chart_type, request.query)
+        
+        return build_query_response(
+            answer=answer,
+            chart_type=chart_type,
+            chart_data=chart_data,
+            sources=sources
+        )
+    
+    except Exception as e:
+        logger.error(f"Query failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+def _generate_chart_data(results, chart_type, query):
+    """Generate chart data from retrieved results"""
+    payloads = [r['payload'] for r in results]
+    
+    # Status distribution
+    if 'status' in query.lower():
+        status_counts = Counter(p.get('status', 'Unknown') for p in payloads)
+        return [{"label": k, "value": v} for k, v in status_counts.items()]
+    
+    # Priority distribution
+    elif 'priority' in query.lower():
+        priority_counts = Counter(p.get('priority', 'Unknown') for p in payloads)
+        return [{"label": k, "value": v} for k, v in priority_counts.items()]
+    
+    # Project distribution
+    elif 'project' in query.lower():
+        project_counts = Counter(p.get('project', 'Unknown') for p in payloads)
+        return [{"label": k, "value": v} for k, v in project_counts.items()]
+    
+    # Default: status breakdown
+    else:
+        status_counts = Counter(p.get('status', 'Unknown') for p in payloads)
+        return [{"label": k, "value": v} for k, v in status_counts.items()]

app/routes/ingest_routes.py

@@ -0,0 +1,52 @@
+"""Routes for data ingestion"""
+from fastapi import APIRouter, HTTPException
+from app.models.jira_schema import IngestRequest, IngestResponse
+from app.services.data_ingestion import DataIngestionService
+from app.services.embeddings import embedding_service
+from app.services.vector_store import vector_store
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+router = APIRouter()
+
+@router.post("/ingest", response_model=IngestResponse)
+async def ingest_data(request: IngestRequest):
+    """
+    Ingest Jira data from CSV/JSON file
+    
+    - Parses the file
+    - Generates embeddings
+    - Stores in Qdrant vector database
+    """
+    try:
+        logger.info(f"Starting ingestion from: {request.file_path}")
+        
+        # Load data
+        records = DataIngestionService.load_data(request.file_path)
+        
+        if not records:
+            raise HTTPException(status_code=400, detail="No records found in file")
+        
+        # Extract searchable text
+        texts = [record.get('searchable_text', '') for record in records]
+        
+        # Generate embeddings
+        embeddings = embedding_service.embed_batch(texts)
+        
+        # Create collection (recreates if exists)
+        vector_store.create_collection(vector_size=embedding_service.get_dimension())
+        
+        # Store vectors
+        count = vector_store.upsert_vectors(embeddings, records)
+        
+        logger.info(f"Successfully indexed {count} records")
+        
+        return IngestResponse(
+            status="success",
+            records_indexed=count,
+            message=f"Successfully ingested and indexed {count} Jira tickets"
+        )
+    
+    except Exception as e:
+        logger.error(f"Ingestion failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

app/routes/metrics_routes copy.py

@@ -0,0 +1,76 @@
+"""Routes for aggregate metrics"""
+from fastapi import APIRouter, HTTPException
+from app.models.jira_schema import MetricsResponse
+from app.services.vector_store import vector_store
+from app.utils.logger import setup_logger
+import pandas as pd
+
+logger = setup_logger(__name__)
+router = APIRouter()
+
+@router.get("/metrics", response_model=MetricsResponse)
+async def get_metrics():
+    """
+    Get aggregate metrics from Jira data
+
+    - Average resolution time
+    - Open/closed ticket counts
+    - SLA compliance percentage
+    """
+    try:
+        logger.info("Calculating metrics...")
+
+        info = vector_store.get_collection_info()
+        total_tickets = info.get('vectors_count', 0)
+        if total_tickets == 0:
+            raise HTTPException(status_code=404, detail="No data available. Please ingest data first.")
+
+        # Pull a sample or all payloads from the sidecar store
+        payloads = vector_store.get_payloads_sample(limit=100)
+        if not payloads:
+            raise HTTPException(status_code=404, detail="Unable to retrieve metrics data")
+
+        # Calculate metrics
+        open_statuses = {'Open', 'In Progress', 'To Do'}
+        closed_statuses = {'Closed', 'Done', 'Resolved'}
+
+        open_tickets = sum(1 for p in payloads if (p.get('status') or '') in open_statuses)
+        closed_tickets = sum(1 for p in payloads if (p.get('status') or '') in closed_statuses)
+
+        # Average resolution time (days)
+        resolution_times = []
+        for p in payloads:
+            created = p.get('created_date')
+            resolved = p.get('resolved_date')
+            if created and resolved:
+                try:
+                    c = pd.to_datetime(created)
+                    r = pd.to_datetime(resolved)
+                    delta = (r - c).days
+                    if delta >= 0:
+                        resolution_times.append(delta)
+                except Exception:
+                    pass
+
+        avg_resolution = (sum(resolution_times) / len(resolution_times)) if resolution_times else 0.0
+        avg_resolution_str = f"{avg_resolution:.1f} days"
+
+        # SLA compliance: resolved within 5 days
+        sla_threshold = 5
+        sla_compliant = sum(1 for t in resolution_times if t <= sla_threshold)
+        sla_pct = (sla_compliant / len(resolution_times) * 100) if resolution_times else 0.0
+        sla_compliance_str = f"{sla_pct:.0f}%"
+
+        return MetricsResponse(
+            avg_resolution_time=avg_resolution_str,
+            open_tickets=open_tickets,
+            closed_tickets=closed_tickets,
+            sla_compliance=sla_compliance_str,
+            total_tickets=total_tickets
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Metrics calculation failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

app/routes/metrics_routes.py.qdrant

@@ -0,0 +1,80 @@
+"""Routes for aggregate metrics"""
+from fastapi import APIRouter, HTTPException
+from app.models.jira_schema import MetricsResponse
+from app.services.vector_store import vector_store
+from app.services.data_ingestion import DataIngestionService
+from app.utils.logger import setup_logger
+from datetime import datetime
+import pandas as pd
+
+logger = setup_logger(__name__)
+router = APIRouter()
+
+@router.get("/metrics", response_model=MetricsResponse)
+async def get_metrics():
+    """
+    Get aggregate metrics from Jira data
+    
+    - Average resolution time
+    - Open/closed ticket counts
+    - SLA compliance percentage
+    """
+    try:
+        logger.info("Calculating metrics...")
+        
+        # Get collection info
+        info = vector_store.get_collection_info()
+        total_tickets = info.get('vectors_count', 0)
+        
+        if total_tickets == 0:
+            raise HTTPException(status_code=404, detail="No data available. Please ingest data first.")
+        
+        # For MVP, retrieve sample of tickets to calculate metrics
+        # In production, this would query all tickets or use aggregated stats
+        from app.services.retriever import retriever
+        sample_results = retriever.retrieve("all tickets", top_k=100)
+        
+        if not sample_results:
+            raise HTTPException(status_code=404, detail="Unable to retrieve metrics data")
+        
+        payloads = [r['payload'] for r in sample_results]
+        
+        # Calculate metrics
+        open_tickets = sum(1 for p in payloads if p.get('status') in ['Open', 'In Progress', 'To Do'])
+        closed_tickets = sum(1 for p in payloads if p.get('status') in ['Closed', 'Done', 'Resolved'])
+        
+        # Calculate average resolution time
+        resolution_times = []
+        for p in payloads:
+            if p.get('created_date') and p.get('resolved_date'):
+                try:
+                    created = pd.to_datetime(p['created_date'])
+                    resolved = pd.to_datetime(p['resolved_date'])
+                    delta = (resolved - created).days
+                    if delta >= 0:
+                        resolution_times.append(delta)
+                except:
+                    pass
+        
+        avg_resolution = sum(resolution_times) / len(resolution_times) if resolution_times else 0
+        avg_resolution_str = f"{avg_resolution:.1f} days"
+        
+        # Calculate SLA compliance (simplified: tickets resolved within 5 days)
+        sla_threshold = 5
+        sla_compliant = sum(1 for t in resolution_times if t <= sla_threshold)
+        sla_compliance = (sla_compliant / len(resolution_times) * 100) if resolution_times else 0
+        sla_compliance_str = f"{sla_compliance:.0f}%"
+        
+        return MetricsResponse(
+            avg_resolution_time=avg_resolution_str,
+            open_tickets=open_tickets,
+            closed_tickets=closed_tickets,
+            sla_compliance=sla_compliance_str,
+            total_tickets=total_tickets
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Metrics calculation failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

app/services/__init__.py

@@ -0,0 +1 @@
+"""Business logic services"""

app/services/data_ingestion.py

@@ -0,0 +1,89 @@
+"""Data ingestion service for parsing Jira exports"""
+import pandas as pd
+import json
+from typing import List, Dict, Any
+from pathlib import Path
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+class DataIngestionService:
+    """Handles parsing and preprocessing of Jira data files"""
+    
+    @staticmethod
+    def parse_csv(file_path: str) -> List[Dict[str, Any]]:
+        """Parse Jira CSV export"""
+        try:
+            df = pd.read_csv(file_path)
+            logger.info(f"Loaded {len(df)} records from {file_path}")
+            
+            # Normalize column names
+            df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_')
+            
+            # Convert to list of dictionaries
+            records = df.to_dict('records')
+            
+            # Clean and structure data
+            processed_records = []
+            for record in records:
+                processed = DataIngestionService._clean_record(record)
+                processed_records.append(processed)
+            
+            return processed_records
+        
+        except Exception as e:
+            logger.error(f"Error parsing CSV: {str(e)}")
+            raise
+    
+    @staticmethod
+    def parse_json(file_path: str) -> List[Dict[str, Any]]:
+        """Parse Jira JSON export"""
+        try:
+            with open(file_path, 'r') as f:
+                data = json.load(f)
+            
+            if isinstance(data, dict) and 'issues' in data:
+                records = data['issues']
+            elif isinstance(data, list):
+                records = data
+            else:
+                raise ValueError("Unexpected JSON structure")
+            
+            logger.info(f"Loaded {len(records)} records from {file_path}")
+            return [DataIngestionService._clean_record(r) for r in records]
+        
+        except Exception as e:
+            logger.error(f"Error parsing JSON: {str(e)}")
+            raise
+    
+    @staticmethod
+    def _clean_record(record: Dict[str, Any]) -> Dict[str, Any]:
+        """Clean and normalize a single record"""
+        # Handle missing values
+        for key, value in record.items():
+            if pd.isna(value) or value == '' or value == 'None':
+                record[key] = None
+        
+        # Create searchable text representation
+        text_fields = ['summary', 'description', 'status', 'priority', 'project']
+        text_parts = []
+        
+        for field in text_fields:
+            if field in record and record[field]:
+                text_parts.append(f"{field}: {record[field]}")
+        
+        record['searchable_text'] = " | ".join(text_parts)
+        
+        return record
+    
+    @staticmethod
+    def load_data(file_path: str) -> List[Dict[str, Any]]:
+        """Load data from file (auto-detect format)"""
+        file_ext = Path(file_path).suffix.lower()
+        
+        if file_ext == '.csv':
+            return DataIngestionService.parse_csv(file_path)
+        elif file_ext == '.json':
+            return DataIngestionService.parse_json(file_path)
+        else:
+            raise ValueError(f"Unsupported file format: {file_ext}")

app/services/embeddings.py

@@ -0,0 +1,41 @@
+"""Embedding generation service using sentence-transformers"""
+from sentence_transformers import SentenceTransformer
+from typing import List
+import numpy as np
+from app.config import settings
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+class EmbeddingService:
+    """Generate embeddings for text using sentence-transformers"""
+    
+    def __init__(self):
+        """Initialize the embedding model"""
+        logger.info(f"Loading embedding model: {settings.EMBEDDING_MODEL}")
+        self.model = SentenceTransformer(settings.EMBEDDING_MODEL)
+        self.dimension = self.model.get_sentence_embedding_dimension()
+        logger.info(f"Embedding dimension: {self.dimension}")
+    
+    def embed_text(self, text: str) -> List[float]:
+        """Generate embedding for a single text"""
+        embedding = self.model.encode(text, convert_to_numpy=True)
+        return embedding.tolist()
+    
+    def embed_batch(self, texts: List[str], batch_size: int = 32) -> List[List[float]]:
+        """Generate embeddings for a batch of texts"""
+        logger.info(f"Embedding {len(texts)} texts...")
+        embeddings = self.model.encode(
+            texts,
+            batch_size=batch_size,
+            show_progress_bar=True,
+            convert_to_numpy=True
+        )
+        return embeddings.tolist()
+    
+    def get_dimension(self) -> int:
+        """Return embedding dimension"""
+        return self.dimension
+
+# Global instance
+embedding_service = EmbeddingService()

app/services/generator.py

@@ -0,0 +1,88 @@
+"""LLM generation service using Hugging Face Inference API"""
+import requests
+from typing import Dict, Any, Optional
+from app.config import settings
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+class GeneratorService:
+    """Handles text generation using Hugging Face models"""
+    
+    def __init__(self):
+        self.api_url = settings.HF_API_URL
+        self.headers = {"Authorization": f"Bearer {settings.HF_TOKEN}"}
+    
+    def generate(
+        self,
+        prompt: str,
+        max_tokens: int = 512,
+        temperature: float = 0.7
+    ) -> str:
+        """Generate text using the LLM"""
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": max_tokens,
+                "temperature": temperature,
+                "return_full_text": False
+            }
+        }
+        
+        try:
+            logger.info("Calling Hugging Face API...")
+            response = requests.post(
+                self.api_url,
+                headers=self.headers,
+                json=payload,
+                timeout=30
+            )
+            response.raise_for_status()
+            
+            result = response.json()
+            
+            # Handle different response formats
+            if isinstance(result, list) and len(result) > 0:
+                generated_text = result[0].get('generated_text', '')
+            elif isinstance(result, dict):
+                generated_text = result.get('generated_text', '')
+            else:
+                generated_text = str(result)
+            
+            logger.info("Generation successful")
+            return generated_text.strip()
+        
+        except requests.exceptions.RequestException as e:
+            logger.error(f"API request failed: {str(e)}")
+            # Fallback to simple response
+            return self._fallback_response(prompt)
+    
+    def _fallback_response(self, prompt: str) -> str:
+        """Fallback response when API fails"""
+        return "I apologize, but I'm unable to generate a response at the moment. Please try again later."
+    
+    def generate_rag_response(
+        self,
+        query: str,
+        context: str
+    ) -> str:
+        """Generate response using RAG pattern"""
+        prompt = self._build_rag_prompt(query, context)
+        return self.generate(prompt)
+    
+    def _build_rag_prompt(self, query: str, context: str) -> str:
+        """Build RAG prompt template"""
+        prompt = f"""<s>[INST] You are WorkWise, an AI assistant specialized in analyzing Jira project data. Answer the user's question based on the provided context.
+
+Context:
+{context}
+
+User Question: {query}
+
+Provide a clear, concise answer based on the context. If the context doesn't contain enough information, say so. [/INST]</s>
+
+Answer:"""
+        return prompt
+
+# Global instance
+generator = GeneratorService()

app/services/retriever.py

@@ -0,0 +1,66 @@
+"""Retrieval service for semantic search"""
+from typing import List, Dict, Any
+from app.services.embeddings import embedding_service
+from app.services.vector_store import vector_store
+from app.config import settings
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+class RetrieverService:
+    """Handles semantic search over vector database"""
+    
+    def __init__(self):
+        self.embedding_service = embedding_service
+        self.vector_store = vector_store
+    
+    def retrieve(self, query: str, top_k: int = None) -> List[Dict[str, Any]]:
+        """Retrieve relevant documents for a query"""
+        if top_k is None:
+            top_k = settings.TOP_K
+        
+        # Generate query embedding
+        logger.info(f"Retrieving documents for query: {query}")
+        query_embedding = self.embedding_service.embed_text(query)
+        
+        #FAISS
+        results = self.vector_store.search(
+            query_vector=query_embedding,
+            limit=top_k,
+            score_threshold=settings.SCORE_THRESHOLD
+        )
+
+        #Qdrant
+        # Search vector database
+        # results = self.vector_store.search(
+        #     query_vector=query_embedding,
+        #     limit=top_k,
+        #     score_threshold=settings.SCORE_THRESHOLD
+        # )            
+
+        
+        logger.info(f"Retrieved {len(results)} documents")
+        return results
+    
+    def format_context(self, results: List[Dict[str, Any]]) -> str:
+        """Format retrieved documents into context string"""
+        context_parts = []
+        
+        for idx, result in enumerate(results, 1):
+            payload = result['payload']
+            score = result['score']
+            
+            context_parts.append(f"[Document {idx}] (Relevance: {score:.2f})")
+            context_parts.append(f"Ticket: {payload.get('ticket_id', 'N/A')}")
+            context_parts.append(f"Project: {payload.get('project', 'N/A')}")
+            context_parts.append(f"Status: {payload.get('status', 'N/A')}")
+            context_parts.append(f"Priority: {payload.get('priority', 'N/A')}")
+            context_parts.append(f"Summary: {payload.get('summary', 'N/A')}")
+            if payload.get('description'):
+                context_parts.append(f"Description: {payload['description'][:200]}...")
+            context_parts.append("")
+        
+        return "\n".join(context_parts)
+
+# Global instance
+retriever = RetrieverService()

app/services/vector_store.py

@@ -0,0 +1,141 @@
+"""Faiss vector store service (replaces Qdrant)"""
+from typing import List, Dict, Any, Optional
+from app.config import settings
+from app.utils.logger import setup_logger
+
+import os
+import json
+import faiss
+import numpy as np
+
+logger = setup_logger(__name__)
+
+def _normalize(vectors: np.ndarray) -> np.ndarray:
+    """L2-normalize vectors so inner product equals cosine similarity."""
+    norms = np.linalg.norm(vectors, axis=1, keepdims=True) + 1e-12
+    return vectors / norms
+
+class VectorStoreService:
+    """
+    Manages a Faiss index + sidecar payload store.
+    - Index: Faiss IndexFlatIP (cosine via normalization)
+    - Payloads: JSON list aligned to vector IDs
+    - Persistence: saves/loads index + payloads from disk
+    """
+
+    def __init__(self):
+        self.index: Optional[faiss.Index] = None
+        self.dimension: Optional[int] = None
+        self.payloads: List[Dict[str, Any]] = []
+        self.index_path = settings.FAISS_INDEX_PATH
+        self.payloads_path = settings.FAISS_PAYLOADS_PATH
+
+        self._load_if_exists()
+
+    # ---------- Persistence ----------
+
+    def _load_if_exists(self):
+        """Load index + payloads if the files exist."""
+        if os.path.exists(self.index_path) and os.path.exists(self.payloads_path):
+            try:
+                self.index = faiss.read_index(self.index_path)
+                self.dimension = self.index.d  # type: ignore[attr-defined]
+                with open(self.payloads_path, "r", encoding="utf-8") as f:
+                    self.payloads = json.load(f)
+                logger.info(
+                    f"Loaded Faiss index ({self.dimension}d) with {self.index.ntotal} vectors"  # type: ignore
+                )
+            except Exception as e:
+                logger.error(f"Failed to load Faiss store; starting fresh. Error: {e}")
+                self.index = None
+                self.payloads = []
+                self.dimension = None
+
+    def _save(self):
+        """Persist index + payloads to disk."""
+        if self.index is not None:
+            faiss.write_index(self.index, self.index_path)
+        with open(self.payloads_path, "w", encoding="utf-8") as f:
+            json.dump(self.payloads, f, ensure_ascii=False)
+
+    # ---------- Collection lifecycle ----------
+
+    def create_collection(self, vector_size: int):
+        """
+        (Re)create a fresh Faiss index (cosine via normalized vectors).
+        WARNING: This clears existing data.
+        """
+        self.dimension = vector_size
+        self.index = faiss.IndexFlatIP(vector_size)  # inner product
+        self.payloads = []
+        self._save()
+        logger.info(f"Created Faiss collection: dim={vector_size}")
+
+    # ---------- Upsert/Search ----------
+
+    def upsert_vectors(
+        self,
+        vectors: List[List[float]],
+        payloads: List[Dict[str, Any]]
+    ) -> int:
+        """Insert vectors with metadata (IDs are implicit by order)."""
+        if self.index is None:
+            raise RuntimeError("Faiss index is not initialized. Call create_collection first.")
+
+        arr = np.array(vectors, dtype="float32")
+        arr = _normalize(arr)
+        self.index.add(arr)  # type: ignore
+        self.payloads.extend(payloads)
+
+        self._save()
+        logger.info(f"Upserted {len(vectors)} vectors into Faiss")
+        return len(vectors)
+
+    def search(
+        self,
+        query_vector: List[float],
+        limit: int = 5,
+        score_threshold: float = 0.0
+    ) -> List[Dict[str, Any]]:
+        """Search similar vectors via inner product (cosine)."""
+        if self.index is None or self.index.ntotal == 0:  # type: ignore
+            return []
+
+        q = np.array([query_vector], dtype="float32")
+        q = _normalize(q)
+        scores, indices = self.index.search(q, limit)  # type: ignore
+        scores = scores[0].tolist()
+        indices = indices[0].tolist()
+
+        results: List[Dict[str, Any]] = []
+        for score, idx in zip(scores, indices):
+            if idx == -1:
+                continue
+            if score < score_threshold:
+                continue
+            payload = self.payloads[idx] if 0 <= idx < len(self.payloads) else {}
+            results.append({
+                "id": idx,
+                "score": float(score),
+                "payload": payload
+            })
+        return results
+
+    # ---------- Introspection/Access ----------
+
+    def get_collection_info(self) -> Dict[str, Any]:
+        count = int(self.index.ntotal) if self.index is not None else 0  # type: ignore
+        return {
+            "vectors_count": count,
+            "status": "ready" if count >= 0 else "uninitialized"
+        }
+
+    def get_all_payloads(self) -> List[Dict[str, Any]]:
+        """Return all payloads (used by metrics)."""
+        return list(self.payloads)
+
+    def get_payloads_sample(self, limit: int = 100) -> List[Dict[str, Any]]:
+        return self.payloads[:limit]
+
+# Global instance
+vector_store = VectorStoreService()

app/services/vector_store.py.qdrant

@@ -0,0 +1,96 @@
+"""Qdrant vector store service"""
+from qdrant_client import QdrantClient
+from qdrant_client.http import models
+from typing import List, Dict, Any
+from app.config import settings
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+class VectorStoreService:
+    """Manages Qdrant vector database operations"""
+    
+    def __init__(self):
+        """Initialize Qdrant client"""
+        logger.info(f"Connecting to Qdrant at {settings.QDRANT_URL}")
+        self.client = QdrantClient(
+            url=settings.QDRANT_URL,
+            api_key=settings.QDRANT_API_KEY if settings.QDRANT_API_KEY else None
+        )
+        self.collection_name = settings.QDRANT_COLLECTION_NAME
+    
+    def create_collection(self, vector_size: int):
+        """Create or recreate the collection"""
+        try:
+            # Delete if exists
+            self.client.delete_collection(collection_name=self.collection_name)
+            logger.info(f"Deleted existing collection: {self.collection_name}")
+        except:
+            pass
+        
+        # Create new collection
+        self.client.create_collection(
+            collection_name=self.collection_name,
+            vectors_config=models.VectorParams(
+                size=vector_size,
+                distance=models.Distance.COSINE
+            )
+        )
+        logger.info(f"Created collection: {self.collection_name}")
+    
+    def upsert_vectors(
+        self,
+        vectors: List[List[float]],
+        payloads: List[Dict[str, Any]]
+    ) -> int:
+        """Insert vectors with metadata"""
+        points = [
+            models.PointStruct(
+                id=idx,
+                vector=vector,
+                payload=payload
+            )
+            for idx, (vector, payload) in enumerate(zip(vectors, payloads))
+        ]
+        
+        self.client.upsert(
+            collection_name=self.collection_name,
+            points=points
+        )
+        
+        logger.info(f"Upserted {len(points)} vectors")
+        return len(points)
+    
+    def search(
+        self,
+        query_vector: List[float],
+        limit: int = 5,
+        score_threshold: float = 0.5
+    ) -> List[Dict[str, Any]]:
+        """Search for similar vectors"""
+        results = self.client.search(
+            collection_name=self.collection_name,
+            query_vector=query_vector,
+            limit=limit,
+            score_threshold=score_threshold
+        )
+        
+        return [
+            {
+                "id": result.id,
+                "score": result.score,
+                "payload": result.payload
+            }
+            for result in results
+        ]
+    
+    def get_collection_info(self) -> Dict[str, Any]:
+        """Get collection statistics"""
+        info = self.client.get_collection(collection_name=self.collection_name)
+        return {
+            "vectors_count": info.vectors_count,
+            "status": info.status
+        }
+
+# Global instance
+vector_store = VectorStoreService()

app/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules"""

app/utils/logger.py

@@ -0,0 +1,19 @@
+"""Logging configuration"""
+import logging
+import sys
+
+def setup_logger(name: str) -> logging.Logger:
+    """Configure and return a logger instance"""
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setLevel(logging.INFO)
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    
+    return logger

app/utils/response_builder.py

@@ -0,0 +1,35 @@
+"""Helper functions for building API responses"""
+from typing import Optional, List, Dict, Any
+from app.models.jira_schema import QueryResponse, ChartData
+
+def build_query_response(
+    answer: str,
+    chart_type: Optional[str] = None,
+    chart_data: Optional[List[Dict]] = None,
+    sources: Optional[List[str]] = None
+) -> QueryResponse:
+    """Build a structured query response"""
+    chart = None
+    if chart_type and chart_data:
+        chart = ChartData(type=chart_type, data=chart_data)
+    
+    return QueryResponse(
+        answer=answer,
+        chart=chart,
+        sources=sources
+    )
+
+def extract_chart_intent(query: str) -> Optional[str]:
+    """Determine if query requires visualization"""
+    chart_keywords = {
+        "bar": ["compare", "by project", "breakdown", "distribution"],
+        "line": ["trend", "over time", "timeline", "progress"],
+        "pie": ["percentage", "proportion", "share"]
+    }
+    
+    query_lower = query.lower()
+    for chart_type, keywords in chart_keywords.items():
+        if any(keyword in query_lower for keyword in keywords):
+            return chart_type
+    
+    return None

app/utils/vector_store.py

@@ -0,0 +1,96 @@
+"""Qdrant vector store service"""
+from qdrant_client import QdrantClient
+from qdrant_client.http import models
+from typing import List, Dict, Any
+from app.config import settings
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+class VectorStoreService:
+    """Manages Qdrant vector database operations"""
+    
+    def __init__(self):
+        """Initialize Qdrant client"""
+        logger.info(f"Connecting to Qdrant at {settings.QDRANT_URL}")
+        self.client = QdrantClient(
+            url=settings.QDRANT_URL,
+            api_key=settings.QDRANT_API_KEY if settings.QDRANT_API_KEY else None
+        )
+        self.collection_name = settings.QDRANT_COLLECTION_NAME
+    
+    def create_collection(self, vector_size: int):
+        """Create or recreate the collection"""
+        try:
+            # Delete if exists
+            self.client.delete_collection(collection_name=self.collection_name)
+            logger.info(f"Deleted existing collection: {self.collection_name}")
+        except:
+            pass
+        
+        # Create new collection
+        self.client.create_collection(
+            collection_name=self.collection_name,
+            vectors_config=models.VectorParams(
+                size=vector_size,
+                distance=models.Distance.COSINE
+            )
+        )
+        logger.info(f"Created collection: {self.collection_name}")
+    
+    def upsert_vectors(
+        self,
+        vectors: List[List[float]],
+        payloads: List[Dict[str, Any]]
+    ) -> int:
+        """Insert vectors with metadata"""
+        points = [
+            models.PointStruct(
+                id=idx,
+                vector=vector,
+                payload=payload
+            )
+            for idx, (vector, payload) in enumerate(zip(vectors, payloads))
+        ]
+        
+        self.client.upsert(
+            collection_name=self.collection_name,
+            points=points
+        )
+        
+        logger.info(f"Upserted {len(points)} vectors")
+        return len(points)
+    
+    def search(
+        self,
+        query_vector: List[float],
+        limit: int = 5,
+        score_threshold: float = 0.5
+    ) -> List[Dict[str, Any]]:
+        """Search for similar vectors"""
+        results = self.client.search(
+            collection_name=self.collection_name,
+            query_vector=query_vector,
+            limit=limit,
+            score_threshold=score_threshold
+        )
+        
+        return [
+            {
+                "id": result.id,
+                "score": result.score,
+                "payload": result.payload
+            }
+            for result in results
+        ]
+    
+    def get_collection_info(self) -> Dict[str, Any]:
+        """Get collection statistics"""
+        info = self.client.get_collection(collection_name=self.collection_name)
+        return {
+            "vectors_count": info.vectors_count,
+            "status": info.status
+        }
+
+# Global instance
+vector_store = VectorStoreService()

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+python-dotenv==1.0.0
+pandas==2.2.0
+numpy==1.26.3
+sentence-transformers==2.3.1
+faiss-cpu==1.7.4
+qdrant-client==1.7.3
+pydantic==2.5.3
+python-multipart==0.0.6
+requests==2.31.0