Upload 42 files

proj/.vscode/launch.json

@@ -0,0 +1,33 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug Backend (FastAPI)",
+            "type": "python",
+            "request": "launch",
+            "module": "uvicorn",
+            "cwd": "${workspaceFolder}/backend",
+            "args": [
+                "app.main:app",
+                "--reload",
+                "--port",
+                "8000"
+            ],
+            "jinja": true,
+            "justMyCode": true
+        },
+        {
+            "name": "Debug Frontend (Next.js)",
+            "type": "chrome",
+            "request": "launch",
+            "url": "http://localhost:3000",
+            "webRoot": "${workspaceFolder}/frontend"
+        }
+    ],
+    "compounds": [
+        {
+            "name": "Debug All",
+            "configurations": ["Debug Backend (FastAPI)", "Debug Frontend (Next.js)"]
+        }
+    ]
+}

proj/.vscode/tasks.json

@@ -0,0 +1,26 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Backend",
+      "type": "shell",
+      "command": "cd backend && .venv/Scripts/python -m uvicorn app.main:app --reload",
+      "presentation": {
+        "panel": "dedicated"
+      }
+    },
+    {
+      "label": "Frontend",
+      "type": "shell",
+      "command": "cd frontend && npm run dev",
+      "presentation": {
+        "panel": "dedicated"
+      }
+    },
+   
+    {
+      "label": "Start All",
+      "dependsOn": ["Backend", "Frontend"]
+    }
+  ]
+}

proj/README.md

@@ -0,0 +1,76 @@
+# Full-Stack AI Recruitment Engine
+
+A production-ready candidate ranking platform built with Next.js, FastAPI, and Groq LLMs.
+
+## Features
+- **Multi-Agent Evaluation**: Sequential and parallel agent pipeline (Signal Extraction, Founder Eval, Tech Eval, HR Agent, etc.).
+- **Groq Key Rotation**: Automatic round-robin cycling of multiple API keys to prevent rate limits.
+- **CSV Data Ingestion**: Parse resumes and candidate data directly from CSV files.
+- **Glassmorphic UI**: Modern, high-performance dashboard with animations and progress tracking.
+
+---
+
+## Backend Setup (FastAPI)
+
+1. **Navigate to backend**:
+   ```bash
+   cd backend
+   ```
+
+2. **Create and Activate Virtual Environment**:
+   ```bash
+   python -m venv venv
+   # Windows:
+   venv\Scripts\activate
+   ```
+
+3. **Install Dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Environment Variables**:
+   Create a `.env` file in the `backend/` folder based on `.env.example`:
+   ```env
+   GROQ_API_KEYS=key1,key2,key3
+   GROQ_MODEL=llama3-70b-8192
+   PORT=8000
+   ```
+
+5. **Run Backend**:
+   ```bash
+   uvicorn app.main:app --reload
+   ```
+
+---
+
+## Frontend Setup (Next.js)
+
+1. **Navigate to frontend**:
+   ```bash
+   cd frontend
+   ```
+
+2. **Install Dependencies**:
+   ```bash
+   npm install
+   ```
+
+3. **Environment Variables**:
+   Create a `.env.local` file in the `frontend/` folder:
+   ```env
+   NEXT_PUBLIC_API_URL=http://localhost:8000
+   ```
+
+4. **Run Frontend**:
+   ```bash
+   npm run dev
+   ```
+
+---
+
+## Usage Guide
+1. **Paste Job Description**: Enter the target role details in the textarea.
+2. **Upload CSV**: Upload a CSV containing candidate data (columns: `name`, `email`, `skills`, `experience`, `projects`, `education`, `resume_text`).
+3. **Evaluate**: Click "Run Evaluation" and watch the AI agents process each candidate.
+4. **Deep Dive**: Click on any candidate row to see the full multi-agent breakdown and final synthesis.

proj/backend/.env.example

@@ -0,0 +1,3 @@
+GROQ_API_KEYS=gsk_your_key_1,gsk_your_key_2,gsk_your_key_3
+GROQ_MODEL=llama3-70b-8192
+PORT=8000

proj/backend/app/main.py

@@ -0,0 +1,85 @@
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+import pandas as pd
+import io
+import uuid
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from app.models.schemas import EvaluationRequest, EvaluationResponse, Candidate
+from app.services.evaluation_service import evaluate_candidate
+import asyncio
+
+app = FastAPI(title="AI Recruitment Engine")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# In-memory storage for demonstration (Production should use DB)
+evaluations_cache = {}
+
+@app.post("/upload-csv")
+async def upload_csv(file: UploadFile = File(...)):
+    if not file.filename.endswith('.csv'):
+        raise HTTPException(status_code=400, detail="Invalid file format. Please upload a CSV.")
+    
+    try:
+        content = await file.read()
+        df = pd.read_csv(io.BytesIO(content))
+        df = df.fillna("")
+        
+        candidates = []
+        for _, row in df.iterrows():
+            candidates.append(Candidate(
+                id=str(uuid.uuid4()),
+                name=str(row.get("name", "Unknown")),
+                email=str(row.get("email", "")),
+                skills=str(row.get("skills", "")),
+                experience=str(row.get("experience", "")),
+                projects=str(row.get("projects", "")),
+                education=str(row.get("education", "")),
+                resume_text=str(row.get("resume_text", ""))
+            ))
+        
+        return {"candidates": candidates}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error parsing CSV: {str(e)}")
+
+@app.post("/evaluate", response_model=EvaluationResponse)
+async def evaluate(request: EvaluationRequest):
+    if not request.jd:
+        raise HTTPException(status_code=400, detail="Job Description is required.")
+    
+    if not request.candidates:
+        raise HTTPException(status_code=400, detail="No candidates provided.")
+
+    from app.services.evaluation_service import perform_hybrid_evaluation
+    response = await perform_hybrid_evaluation(request.jd, request.candidates)
+    
+    # Store in cache for detail retrieval
+    for rank in response.shortlist:
+        evaluations_cache[rank.candidate_id] = rank
+    
+    # Also store the deep review details
+    evaluations_cache.update(response.details)
+        
+    return response
+
+@app.get("/results")
+async def get_results():
+    return list(evaluations_cache.values())
+
+@app.get("/candidate/{id}")
+async def get_candidate_report(id: str):
+    if id not in evaluations_cache:
+        raise HTTPException(status_code=404, detail="Candidate report not found.")
+    return evaluations_cache[id]
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

proj/backend/app/models/schemas.py

@@ -0,0 +1,64 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+class Candidate(BaseModel):
+    id: str
+    name: str
+    email: Optional[str] = None
+    skills: Optional[str] = None
+    experience: Optional[str] = None
+    projects: Optional[str] = None
+    education: Optional[str] = None
+    resume_text: Optional[str] = None
+    # Add other fields from the CSV if needed
+    data: Optional[Dict[str, Any]] = None
+
+class NormalizedCandidate(BaseModel):
+    candidate_id: str
+    name: str
+    normalized_title: str
+    experience_years: float
+    primary_skills: List[str]
+    secondary_skills: List[str]
+    backend_score: float
+    frontend_score: float
+    cloud_score: float
+    database_score: float
+    notice_period_days: int
+    location: str
+    employment_status: str
+    salary_expectation: str
+    flags: List[str]
+
+class RerankResult(BaseModel):
+    candidate_id: str
+    scores: Dict[str, float]
+    final_score: float
+    decision: str
+
+class DeepReview(BaseModel):
+    candidate_id: str
+    verdict: str
+    why: str
+    strengths: List[str]
+    risks: List[str]
+    hidden_signal: str
+    confidence: float
+
+class FinalRank(BaseModel):
+    rank: int
+    candidate_id: str
+    name: str
+    decision: str
+    reason: str
+
+class FinalShortlist(BaseModel):
+    final_ranking: List[FinalRank]
+
+class EvaluationRequest(BaseModel):
+    jd: str
+    candidates: List[Candidate]
+
+class EvaluationResponse(BaseModel):
+    shortlist: List[FinalRank]
+    details: Dict[str, Any] # Map candidate_id to their full review for UI

proj/backend/app/prompts/templates.py

@@ -0,0 +1,116 @@
+# STAGE 1 — STRUCTURED PIPELINE EXTRACTION PROMPT
+STAGE1_NORMALIZATION_PROMPT = """
+ROLE: You are a candidate normalization system. You receive already-structured candidate CSV data.
+Your task is to clean, normalize, and prepare candidate features for ranking.
+
+JOB DESCRIPTION:
+{jd}
+
+CANDIDATE DATA:
+{candidate_raw}
+
+TASK: Return normalized structured JSON only.
+RULES: No opinions, No ranking, No explanations, No hallucination, Use only available fields, Standardize values.
+
+OUTPUT JSON FORMAT:
+{{
+  "candidate_id": "",
+  "name": "",
+  "normalized_title": "",
+  "experience_years": 0,
+  "primary_skills": [],
+  "secondary_skills": [],
+  "backend_score": 0,
+  "frontend_score": 0,
+  "cloud_score": 0,
+  "database_score": 0,
+  "notice_period_days": 0,
+  "location": "",
+  "employment_status": "",
+  "salary_expectation": "",
+  "flags": []
+}}
+"""
+
+# STAGE 3 — DETERMINISTIC RERANKING PROMPT
+STAGE3_RERANK_PROMPT = """
+ROLE: You are a candidate scoring engine. Use structured candidate features and JD requirements to assign weighted scores.
+
+JOB DESCRIPTION:
+{jd}
+
+CANDIDATE_FEATURES:
+{normalized_candidate}
+
+TASK: Score candidate using deterministic logic.
+WEIGHTS:
+- Skill Match = 35%
+- Experience Match = 25%
+- Role Relevance = 20%
+- Cloud/Infra Fit = 10%
+- Notice Period = 10%
+
+OUTPUT JSON:
+{{
+  "candidate_id": "",
+  "scores": {{
+    "skill_match": 0,
+    "experience_match": 0,
+    "role_relevance": 0,
+    "infra_fit": 0,
+    "notice_fit": 0
+  }},
+  "final_score": 0,
+  "decision": "pass / reject"
+}}
+"""
+
+# STAGE 4 — LLM DEEP REVIEW PROMPT
+STAGE4_DEEP_REVIEW_PROMPT = """
+ROLE: You are a senior hiring evaluator. You receive only top shortlisted candidates.
+Use nuanced reasoning to identify strongest hires.
+
+JOB DESCRIPTION:
+{jd}
+
+CANDIDATE:
+{candidate_data}
+
+RERANK_SCORE:
+{score}
+
+TASK: Evaluate hidden strengths, practical fit, risks, and hiring recommendation.
+RULES: Use candidate evidence only, No hallucinations, Be concise, Be decisive.
+
+OUTPUT JSON:
+{{
+  "verdict": "strong hire / hire / consider / reject",
+  "why": "",
+  "strengths": [],
+  "risks": [],
+  "hidden_signal": "",
+  "confidence": 0
+}}
+"""
+
+# STAGE 5 — FINAL SELECTION PROMPT
+STAGE5_FINAL_SELECTION_PROMPT = """
+ROLE: You are the final hiring decision engine. Combine rerank scores and LLM evaluations into final shortlist.
+
+TOP_CANDIDATES:
+{all_top_5_results}
+
+TASK: Return final ordered ranking.
+OUTPUT JSON:
+{{
+  "final_ranking": [
+    {{
+      "rank": 1,
+      "candidate_id": "",
+      "name": "",
+      "decision": "",
+      "reason": ""
+    }}
+  ]
+}}
+"""

proj/backend/app/services/evaluation_service.py

@@ -0,0 +1,124 @@
+import asyncio
+import json
+import re
+from typing import List, Dict, Any
+from app.utils.groq_client import get_groq_completion
+from app.models.schemas import (
+    Candidate, NormalizedCandidate, RerankResult, 
+    DeepReview, FinalShortlist, FinalRank, EvaluationResponse
+)
+from app.services.matching_service import match_service
+from app.prompts.templates import (
+    STAGE1_NORMALIZATION_PROMPT,
+    STAGE3_RERANK_PROMPT,
+    STAGE4_DEEP_REVIEW_PROMPT,
+    STAGE5_FINAL_SELECTION_PROMPT
+)
+
+# Concurrency Throttling
+sem = asyncio.Semaphore(3)
+
+async def get_completion_with_sem(messages):
+    async with sem:
+        return await get_groq_completion(messages)
+
+async def normalize_candidate(jd: str, candidate: Candidate) -> NormalizedCandidate:
+    candidate_raw = candidate.model_dump_json()
+    resp = await get_completion_with_sem([
+        {"role": "system", "content": "You are a professional data normalizer. Output JSON ONLY."},
+        {"role": "user", "content": STAGE1_NORMALIZATION_PROMPT.format(jd=jd, candidate_raw=candidate_raw)}
+    ])
+    try:
+        match = re.search(r'\{.*\}', resp, re.DOTALL)
+        data = json.loads(match.group() if match else resp)
+        return NormalizedCandidate(**data)
+    except Exception as e:
+        print(f"Failed to normalize {candidate.name}: {e}")
+        # Return a fallback object
+        return NormalizedCandidate(
+            candidate_id=candidate.id, name=candidate.name, normalized_title="Unknown",
+            experience_years=0, primary_skills=[], secondary_skills=[],
+            backend_score=0, frontend_score=0, cloud_score=0, database_score=0,
+            notice_period_days=0, location="Unknown", employment_status="Unknown",
+            salary_expectation="Unknown", flags=["Parsing Error"]
+        )
+
+async def rerank_candidate(jd: str, normalized: NormalizedCandidate) -> RerankResult:
+    resp = await get_completion_with_sem([
+        {"role": "system", "content": "You are a recruitment scoring engine. Output JSON ONLY."},
+        {"role": "user", "content": STAGE3_RERANK_PROMPT.format(jd=jd, normalized_candidate=normalized.model_dump_json())}
+    ])
+    try:
+        match = re.search(r'\{.*\}', resp, re.DOTALL)
+        data = json.loads(match.group() if match else resp)
+        return RerankResult(**data)
+    except:
+        return RerankResult(candidate_id=normalized.candidate_id, scores={}, final_score=0, decision="reject")
+
+async def review_candidate(jd: str, candidate_data: str, score: float, cand_id: str) -> DeepReview:
+    resp = await get_completion_with_sem([
+        {"role": "system", "content": "You are a senior hiring evaluator. Output JSON ONLY."},
+        {"role": "user", "content": STAGE4_DEEP_REVIEW_PROMPT.format(jd=jd, candidate_data=candidate_data, score=score)}
+    ])
+    try:
+        match = re.search(r'\{.*\}', resp, re.DOTALL)
+        data = json.loads(match.group() if match else resp)
+        data["candidate_id"] = cand_id
+        return DeepReview(**data)
+    except:
+        return DeepReview(candidate_id=cand_id, verdict="reject", why="Error in evaluation", strengths=[], risks=[], hidden_signal="", confidence=0)
+
+async def perform_hybrid_evaluation(jd: str, candidates: List[Candidate]) -> EvaluationResponse:
+    # 1. Normalization (Stage 1) - All candidates
+    normalization_tasks = [normalize_candidate(jd, c) for c in candidates]
+    normalized_candidates = await asyncio.gather(*normalization_tasks)
+    
+    # Map for easy lookup
+    normalized_map = {n.candidate_id: n for n in normalized_candidates}
+    candidate_map = {c.id: c for c in candidates}
+    
+    # 2. Embedding Matching (Stage 2) - Retrieves Top 20
+    # We pass the normalized summary/skills for better matching
+    top_20 = await match_service.get_top_candidates(jd, candidates)
+    
+    # 3. Deterministic Reranking (Stage 3) - Top 20 -> Top 10
+    rerank_tasks = [rerank_candidate(jd, normalized_map[c.id]) for c in top_20]
+    rerank_results = await asyncio.gather(*rerank_tasks)
+    rerank_results.sort(key=lambda x: x.final_score, reverse=True)
+    top_10_results = rerank_results[:10]
+    
+    # 4. LLM Deep Review (Stage 4) - Top 5 Only
+    top_5_for_review = top_10_results[:5]
+    review_tasks = [
+        review_candidate(
+            jd, 
+            candidate_map[r.candidate_id].model_dump_json(), 
+            r.final_score, 
+            r.candidate_id
+        ) for r in top_5_for_review
+    ]
+    review_results = await asyncio.gather(*review_tasks)
+    review_map = {rev.candidate_id: rev for rev in review_results}
+    
+    # 5. Final Selection (Stage 5)
+    reviews_json = json.dumps([r.model_dump() for r in review_results])
+    final_resp = await get_completion_with_sem([
+        {"role": "system", "content": "You are the final hiring decision officer. Output JSON ONLY."},
+        {"role": "user", "content": STAGE5_FINAL_SELECTION_PROMPT.format(all_top_5_results=reviews_json)}
+    ])
+    
+    try:
+        match = re.search(r'\{.*\}', final_resp, re.DOTALL)
+        final_data = json.loads(match.group() if match else final_resp)
+        shortlist = FinalShortlist(**final_data)
+    except:
+        # Fallback ranking if synthesis fails
+        shortlist = FinalShortlist(final_ranking=[
+            FinalRank(rank=i+1, candidate_id=r.candidate_id, name=candidate_map[r.candidate_id].name, decision=r.decision, reason="Automatic ranking")
+            for i, r in enumerate(top_5_for_review)
+        ])
+
+    return EvaluationResponse(
+        shortlist=shortlist.final_ranking,
+        details={rev.candidate_id: rev.model_dump() for rev in review_results}
+    )

proj/backend/app/services/matching_service.py

@@ -0,0 +1,58 @@
+import os
+from pinecone import Pinecone
+from sentence_transformers import SentenceTransformer
+from typing import List
+from app.models.schemas import Candidate
+
+class MatchService:
+    def __init__(self):
+        self.pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))
+        self.index_name = os.getenv("PINECONE_INDEX", "coderound")
+        self.index = self.pc.Index(self.index_name)
+        
+        # Load local embedding model
+        model_name = os.getenv("EMBEDDING_MODEL", "BAAI/bge-m3")
+        self.model = SentenceTransformer(model_name)
+        
+        self.top_k = int(os.getenv("STAGE2_TOP_K", "20"))
+
+    def get_embedding(self, text: str):
+        return self.model.encode(text).tolist()
+
+    async def get_top_candidates(self, jd: str, candidates: List[Candidate]) -> List[Candidate]:
+        # 1. Prepare vectors for batch upload
+        vectors = []
+        candidate_map = {}
+        
+        for c in candidates:
+            # Combine fields for semantic weight
+            search_text = f"{c.name} {c.skills} {c.experience} {c.projects} {c.resume_text}"
+            embedding = self.get_embedding(search_text)
+            
+            vectors.append({
+                "id": c.id,
+                "values": embedding,
+                "metadata": {"name": c.name, "email": c.email}
+            })
+            candidate_map[c.id] = c
+            
+        # 2. Upsert to Pinecone
+        self.index.upsert(vectors=vectors)
+        
+        # 3. Embed JD and Query
+        jd_embedding = self.get_embedding(jd)
+        query_results = self.index.query(
+            vector=jd_embedding,
+            top_k=self.top_k,
+            include_metadata=True
+        )
+        
+        # 4. Map back to Candidate objects
+        top_candidates = []
+        for match in query_results.matches:
+            if match.id in candidate_map:
+                top_candidates.append(candidate_map[match.id])
+                
+        return top_candidates
+
+match_service = MatchService()

proj/backend/app/utils/groq_client.py

@@ -0,0 +1,32 @@
+import os
+import asyncio
+from groq import AsyncGroq
+from app.utils.key_manager import key_manager
+import logging
+
+logger = logging.getLogger(__name__)
+
+async def get_groq_completion(messages: list, model: str = None) -> str:
+    if model is None:
+        model = os.getenv("GROQ_MODEL", "llama3-70b-8192")
+    
+    max_retries = len(key_manager.keys)
+    last_error = None
+
+    for _ in range(max_retries):
+        try:
+            api_key = key_manager.get_next_key()
+            client = AsyncGroq(api_key=api_key)
+            
+            response = await client.chat.completions.create(
+                messages=messages,
+                model=model,
+                temperature=0.7,
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            logger.warning(f"Error using key: {e}. Retrying with next key...")
+            last_error = e
+            continue
+    
+    raise Exception(f"All API keys exhausted or failed. Last error: {last_error}")

proj/backend/app/utils/key_manager.py

@@ -0,0 +1,27 @@
+import os
+import threading
+from typing import List
+
+class KeyRotationManager:
+    def __init__(self):
+        keys_str = os.getenv("GROQ_API_KEYS")
+        if not keys_str:
+            keys_str = os.getenv("GROQ_API_KEY", "")
+        
+        self.keys = [k.strip() for k in keys_str.split(",") if k.strip()]
+        print(f"KeyRotationManager initialized with {len(self.keys)} keys.")
+        if not self.keys:
+            print("WARNING: No GROQ_API_KEYS or GROQ_API_KEY found in environment!")
+        self.current_index = 0
+        self.lock = threading.Lock()
+
+    def get_next_key(self) -> str:
+        with self.lock:
+            if not self.keys:
+                raise ValueError("No GROQ_API_KEYS found in environment variables.")
+            
+            key = self.keys[self.current_index]
+            self.current_index = (self.current_index + 1) % len(self.keys)
+            return key
+
+key_manager = KeyRotationManager()

proj/backend/requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+python-dotenv
+pandas
+groq
+pydantic
+python-multipart
+asyncio
+httpx
+pinecone
+sentence-transformers
+numpy

proj/frontend/.env.local.example

@@ -0,0 +1 @@
+NEXT_PUBLIC_API_URL=http://localhost:8000

proj/frontend/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

proj/frontend/AGENTS.md

@@ -0,0 +1,5 @@
+<!-- BEGIN:nextjs-agent-rules -->
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` before writing any code. Heed deprecation notices.
+<!-- END:nextjs-agent-rules -->

proj/frontend/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

proj/frontend/eslint.config.mjs

@@ -0,0 +1,16 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

proj/frontend/jsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

proj/frontend/next.config.mjs

@@ -0,0 +1,6 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;

proj/frontend/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "next": "16.2.3",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "axios": "^1.6.7",
+    "lucide-react": "latest",
+    "framer-motion": "^11.0.8",
+    "clsx": "^2.1.0",
+    "tailwind-merge": "^2.2.1"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.3",
+    "tailwindcss": "^4"
+  }
+}

proj/frontend/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

proj/frontend/src/app/globals.css

@@ -0,0 +1,62 @@
+@import "tailwindcss";
+
+:root {
+  --background: #f8fafc;
+  --foreground: #0f172a;
+  --primary: #6366f1;
+  --glass: rgba(255, 255, 255, 0.7);
+  --glass-border: rgba(255, 255, 255, 0.3);
+}
+
+.dark {
+  --background: #020617;
+  --foreground: #f8fafc;
+  --primary: #818cf8;
+  --glass: rgba(15, 23, 42, 0.7);
+  --glass-border: rgba(30, 41, 59, 0.5);
+}
+
+body {
+  background-color: var(--background);
+  color: var(--foreground);
+  font-family: 'Inter', system-ui, -apple-system, sans-serif;
+  overflow-x: hidden;
+}
+
+.glass-card {
+  background: var(--glass);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  border: 1px solid var(--glass-border);
+  box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.07);
+}
+
+.gradient-text {
+  background: linear-gradient(135deg, #6366f1 0%, #a855f7 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+}
+
+.animate-in {
+  animation: fadeIn 0.5s ease-out forwards;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; transform: translateY(10px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+/* Custom Scrollbar */
+::-webkit-scrollbar {
+  width: 6px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: #cbd5e1;
+  border-radius: 10px;
+}
+.dark ::-webkit-scrollbar-thumb {
+  background: #334155;
+}

proj/frontend/src/app/layout.jsx

@@ -0,0 +1,36 @@
+import './globals.css';
+import { Inter } from 'next/font/google';
+
+const inter = Inter({ subsets: ['latin'] });
+
+export const metadata = {
+  title: 'AI Recruitment Engine | Elevate Your Hiring',
+  description: 'Production-ready AI candidate ranking platform powered by Groq and multi-agent synergy.',
+};
+
+export default function RootLayout({ children }) {
+  return (
+    <html lang="en">
+      <body className={inter.className}>
+        <div className="fixed inset-0 -z-10 bg-[radial-gradient(ellipse_at_top_right,_var(--tw-gradient-stops))] from-indigo-100 via-slate-50 to-white dark:from-indigo-950 dark:via-slate-950 dark:to-black"></div>
+        <nav className="sticky top-0 z-50 w-full glass-card border-b bg-white/50 dark:bg-black/50 backdrop-blur-md">
+          <div className="container mx-auto px-6 py-4 flex justify-between items-center">
+            <h1 className="text-2xl font-bold gradient-text">RecruitAI</h1>
+            <div className="flex gap-6 items-center">
+              <span className="text-sm font-medium text-slate-500 hover:text-indigo-600 cursor-pointer transition-colors">Dashboard</span>
+              <span className="text-sm font-medium text-slate-500 hover:text-indigo-600 cursor-pointer transition-colors">Analytics</span>
+            </div>
+          </div>
+        </nav>
+        <main className="min-h-screen">
+          {children}
+        </main>
+        <footer className="py-12 border-t border-slate-200 dark:border-slate-800 backdrop-blur-sm">
+          <div className="container mx-auto px-6 text-center text-slate-500 text-sm">
+            © 2024 AI Recruitment Engine. Built for the future of hiring.
+          </div>
+        </footer>
+      </body>
+    </html>
+  );
+}

proj/frontend/src/app/page.jsx

@@ -0,0 +1,171 @@
+'use client';
+
+import React, { useState } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import { Upload, Search, Zap, CheckCircle2, AlertCircle, Loader2, BarChart3, Users } from 'lucide-react';
+import { uploadCSV, runEvaluation } from '@/lib/api';
+import CandidateTable from '@/components/CandidateTable';
+import CandidateDetail from '@/components/CandidateDetail';
+
+export default function Dashboard() {
+  const [jd, setJd] = useState('');
+  const [candidates, setCandidates] = useState([]);
+  const [evaluations, setEvaluations] = useState([]);
+  const [isUploading, setIsUploading] = useState(false);
+  const [isEvaluating, setIsEvaluating] = useState(false);
+  const [selectedCandidate, setSelectedCandidate] = useState(null);
+
+  const handleFileUpload = async (e) => {
+    const file = e.target.files[0];
+    if (!file) return;
+
+    setIsUploading(true);
+    try {
+      const data = await uploadCSV(file);
+      setCandidates(data.candidates);
+    } catch (err) {
+      console.error(err);
+      alert('Failed to upload CSV. Check console for details.');
+    } finally {
+      setIsUploading(false);
+    }
+  };
+
+  const handleEvaluate = async () => {
+    if (!jd || candidates.length === 0) {
+      alert('Please provide a JD and upload candidates.');
+      return;
+    }
+
+    setIsEvaluating(true);
+    try {
+      const data = await runEvaluation(jd, candidates);
+      setEvaluations(data.shortlist);
+      // We can also store data.details if needed for immediate access
+      window.evalDetails = data.details; 
+    } catch (err) {
+      console.error(err);
+      alert('Evaluation failed. Check backend/Groq keys.');
+    } finally {
+      setIsEvaluating(false);
+    }
+  };
+
+  return (
+    <div className="container mx-auto px-6 py-12">
+      <header className="mb-12">
+        <motion.h2 
+          initial={{ opacity: 0, x: -20 }}
+          animate={{ opacity: 1, x: 0 }}
+          className="text-4xl font-extrabold tracking-tight"
+        >
+          Candidate <span className="gradient-text">Ranking Platform</span>
+        </motion.h2>
+        <p className="text-slate-500 mt-2 text-lg">Intelligent multi-agent assessment for your next top hire.</p>
+      </header>
+
+      <div className="grid grid-cols-1 lg:grid-cols-12 gap-8">
+        {/* Left Column: Input */}
+        <div className="lg:col-span-4 space-y-6">
+          <section className="glass-card p-6 rounded-2xl">
+            <h3 className="text-lg font-semibold mb-4 flex items-center gap-2">
+              <Zap className="w-5 h-5 text-indigo-500" /> Job Description
+            </h3>
+            <textarea
+              className="w-full h-64 p-4 bg-white/50 dark:bg-slate-900/50 border border-slate-200 dark:border-slate-800 rounded-xl focus:ring-2 focus:ring-indigo-500 focus:outline-none transition-all resize-none text-sm"
+              placeholder="Paste the job description here..."
+              value={jd}
+              onChange={(e) => setJd(e.target.value)}
+            />
+          </section>
+
+          <section className="glass-card p-6 rounded-2xl">
+            <h3 className="text-lg font-semibold mb-4 flex items-center gap-2 text-indigo-500">
+              <Upload className="w-5 h-5" /> Candidate Data (CSV)
+            </h3>
+            <div className="relative group">
+              <input
+                type="file"
+                className="absolute inset-0 w-full h-full opacity-0 cursor-pointer z-10"
+                onChange={handleFileUpload}
+                accept=".csv"
+              />
+              <div className="border-2 border-dashed border-slate-300 dark:border-slate-700 rounded-xl p-8 text-center group-hover:border-indigo-500 transition-colors">
+                {isUploading ? (
+                  <Loader2 className="w-8 h-8 mx-auto animate-spin text-indigo-500" />
+                ) : (
+                  <>
+                    <Users className="w-8 h-8 mx-auto text-slate-400 group-hover:text-indigo-500 transition-colors mb-2" />
+                    <p className="text-sm font-medium">Click or drag CSV</p>
+                    <p className="text-xs text-slate-500 mt-1">{candidates.length > 0 ? `${candidates.length} candidates loaded` : 'Supports names, skills, email...'}</p>
+                  </>
+                )}
+              </div>
+            </div>
+          </section>
+
+          <button
+            onClick={handleEvaluate}
+            disabled={isEvaluating || !jd || candidates.length === 0}
+            className={`w-full py-4 rounded-xl flex items-center justify-center gap-2 font-bold text-white transition-all shadow-lg ${
+              isEvaluating || !jd || candidates.length === 0 
+                ? 'bg-slate-400 cursor-not-allowed' 
+                : 'bg-indigo-600 hover:bg-indigo-700 hover:scale-[1.02] active:scale-[0.98]'
+            }`}
+          >
+            {isEvaluating ? (
+              <Loader2 className="w-5 h-5 animate-spin" />
+            ) : (
+              <BarChart3 className="w-5 h-5" />
+            )}
+            {isEvaluating ? 'Running AI Agents...' : 'Run Evaluation'}
+          </button>
+        </div>
+
+        {/* Right Column: Results */}
+        <div className="lg:col-span-8">
+          <div className="glass-card rounded-2xl min-h-[600px] relative overflow-hidden">
+            <AnimatePresence mode="wait">
+              {evaluations.length > 0 ? (
+                <motion.div
+                  key="results"
+                  initial={{ opacity: 0 }}
+                  animate={{ opacity: 1 }}
+                  exit={{ opacity: 0 }}
+                  className="p-6"
+                >
+                  <CandidateTable 
+                    evaluations={evaluations} 
+                    onViewDetail={(c) => setSelectedCandidate(c)} 
+                  />
+                </motion.div>
+              ) : (
+                <motion.div
+                  key="empty"
+                  initial={{ opacity: 0 }}
+                  animate={{ opacity: 1 }}
+                  exit={{ opacity: 0 }}
+                  className="absolute inset-0 flex flex-col items-center justify-center text-slate-400 p-12 text-center"
+                >
+                  <Search className="w-16 h-16 mb-4 opacity-20" />
+                  <h3 className="text-xl font-medium">No Evaluations Yet</h3>
+                  <p className="max-w-xs mt-2 text-sm">Upload a CSV, paste a JD, and hit Run to see the magic happen with Groq LLMs.</p>
+                </motion.div>
+              )}
+            </AnimatePresence>
+          </div>
+        </div>
+      </div>
+
+      {/* Detail Modal */}
+      <AnimatePresence>
+        {selectedCandidate && (
+          <CandidateDetail 
+            evaluation={selectedCandidate} 
+            onClose={() => setSelectedCandidate(null)} 
+          />
+        )}
+      </AnimatePresence>
+    </div>
+  );
+}

proj/frontend/src/components/CandidateDetail.jsx

@@ -0,0 +1,154 @@
+'use client';
+
+import React, { useState } from 'react';
+import { motion } from 'framer-motion';
+import { X, ShieldCheck, Zap, Briefcase, Cpu, TrendingUp, Info, Search } from 'lucide-react';
+
+export default function CandidateDetail({ evaluation, onClose }) {
+  const [activeTab, setActiveTab] = useState('Synthesis');
+
+  const agents = [
+    { name: 'Synthesis', icon: ShieldCheck },
+    { name: 'Signal Extraction', icon: Zap },
+    { name: 'Explanation', icon: Info },
+    { name: 'Founder Eval', icon: TrendingUp },
+    { name: 'HR Agent', icon: Search },
+    { name: 'Tech Agent', icon: Cpu },
+    { name: 'Business Agent', icon: Briefcase },
+  ];
+
+  const getAgentContent = (name) => {
+    if (name === 'Synthesis') return evaluation.synthesis;
+    const agent = evaluation.agent_outputs.find(a => a.agent_name === name);
+    return agent ? agent.content : 'No output available for this agent.';
+  };
+
+  return (
+    <motion.div 
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      exit={{ opacity: 0 }}
+      className="fixed inset-0 z-[100] bg-black/40 backdrop-blur-sm flex justify-end"
+      onClick={onClose}
+    >
+      <motion.div 
+        initial={{ x: '100%' }}
+        animate={{ x: 0 }}
+        exit={{ x: '100%' }}
+        transition={{ type: 'spring', damping: 30, stiffness: 300 }}
+        className="w-full max-w-2xl bg-white dark:bg-slate-950 h-full shadow-2xl flex flex-col"
+        onClick={e => e.stopPropagation()}
+      >
+        {/* Header */}
+        <div className="p-8 border-b border-slate-100 dark:border-slate-800 flex justify-between items-start">
+          <div>
+            <span className="text-xs font-bold text-indigo-600 uppercase tracking-widest mb-1 block">Full Report</span>
+            <h2 className="text-3xl font-bold text-slate-900 dark:text-white">{evaluation.name}</h2>
+            <div className="flex items-center gap-4 mt-2">
+               <div className="flex items-center gap-1.5">
+                  <div className="w-2 h-2 rounded-full bg-emerald-500"></div>
+                  <span className="text-sm font-medium text-slate-500">{evaluation.decision}</span>
+               </div>
+               <div className="text-sm text-slate-400">Score: {Math.round(evaluation.final_score)}/100</div>
+            </div>
+          </div>
+          <button 
+            onClick={onClose}
+            className="p-2 hover:bg-slate-100 dark:hover:bg-slate-800 rounded-full transition-colors"
+          >
+            <X className="w-6 h-6 text-slate-400" />
+          </button>
+        </div>
+
+        {/* Content Area */}
+        <div className="flex flex-1 overflow-hidden">
+          {/* Sidebar Tabs */}
+          <div className="w-16 md:w-48 border-r border-slate-100 dark:border-slate-900 bg-slate-50/50 dark:bg-slate-900/20 py-6">
+            {agents.map((agent) => {
+              const Icon = agent.icon;
+              const isActive = activeTab === agent.name;
+              return (
+                <button
+                  key={agent.name}
+                  onClick={() => setActiveTab(agent.name)}
+                  className={`w-full flex items-center gap-3 px-4 py-3 text-sm font-medium transition-all ${
+                    isActive 
+                    ? 'text-indigo-600 bg-white dark:bg-slate-900 shadow-sm border-r-2 border-indigo-600' 
+                    : 'text-slate-400 hover:text-slate-600 dark:hover:text-slate-300'
+                  }`}
+                >
+                  <Icon className="w-5 h-5 flex-shrink-0" />
+                  <span className="hidden md:block truncate">{agent.name}</span>
+                </button>
+              );
+            })}
+          </div>
+
+          {/* Main Content */}
+          <div className="flex-1 overflow-y-auto p-8">
+            <AnimatePresence mode="wait">
+              <motion.div
+                key={activeTab}
+                initial={{ opacity: 0, y: 10 }}
+                animate={{ opacity: 1, y: 0 }}
+                exit={{ opacity: 0, y: -10 }}
+                className="prose dark:prose-invert max-w-none"
+              >
+                <div className="mb-6 flex items-center justify-between">
+                  <h3 className="text-xl font-bold m-0">{activeTab} Output</h3>
+                </div>
+                
+                {activeTab === 'Synthesis' ? (
+                  <div className="space-y-6">
+                    <div className="p-5 bg-indigo-50 dark:bg-indigo-900/20 rounded-2xl border border-indigo-100 dark:border-indigo-800">
+                       <h4 className="text-indigo-900 dark:text-indigo-300 font-bold mb-2">Final Summary</h4>
+                       <p className="text-sm leading-relaxed text-indigo-800 dark:text-indigo-400">{evaluation.synthesis}</p>
+                    </div>
+                    
+                    <div className="grid grid-cols-2 gap-4">
+                      <div className="p-4 bg-emerald-50 dark:bg-emerald-900/10 rounded-xl border border-emerald-100 dark:border-emerald-800/50">
+                        <h4 className="text-emerald-700 dark:text-emerald-400 font-bold text-sm mb-3">Key Strengths</h4>
+                        <ul className="space-y-2">
+                          {evaluation.strengths.map((s, i) => (
+                            <li key={i} className="text-xs flex items-start gap-2 text-emerald-800/70 dark:text-emerald-500/70">
+                              <span className="block w-1 h-1 rounded-full bg-emerald-400 mt-1.5 flex-shrink-0"></span>
+                              {s}
+                            </li>
+                          ))}
+                        </ul>
+                      </div>
+                      <div className="p-4 bg-rose-50 dark:bg-rose-900/10 rounded-xl border border-rose-100 dark:border-rose-800/50">
+                        <h4 className="text-rose-700 dark:text-rose-400 font-bold text-sm mb-3">Potential Risks</h4>
+                        <ul className="space-y-2">
+                          {evaluation.risks.map((r, i) => (
+                            <li key={i} className="text-xs flex items-start gap-2 text-rose-800/70 dark:text-rose-500/70">
+                              <span className="block w-1 h-1 rounded-full bg-rose-400 mt-1.5 flex-shrink-0"></span>
+                              {r}
+                            </li>
+                          ))}
+                        </ul>
+                      </div>
+                    </div>
+
+                    <div className="grid grid-cols-5 gap-2">
+                      {Object.entries(evaluation.scores).map(([key, val]) => (
+                        <div key={key} className="p-3 bg-slate-50 dark:bg-slate-900 rounded-lg text-center">
+                          <div className="text-[10px] uppercase text-slate-400 font-bold mb-1">{key}</div>
+                          <div className="text-sm font-bold text-slate-700 dark:text-slate-300">{val}</div>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                ) : (
+                  <div className="bg-slate-50 dark:bg-slate-900/50 p-6 rounded-2xl whitespace-pre-wrap text-sm leading-relaxed text-slate-600 dark:text-slate-400 border border-slate-100 dark:border-slate-800">
+                    {getAgentContent(activeTab)}
+                  </div>
+                )}
+              </motion.div>
+            </AnimatePresence>
+          </div>
+        </div>
+      </motion.div>
+    </motion.div>
+  );
+}

proj/frontend/src/components/CandidateTable.jsx

@@ -0,0 +1,81 @@
+'use client';
+
+import React from 'react';
+import { ChevronRight, ArrowUpRight, ShieldCheck, AlertTriangle, Target } from 'lucide-react';
+
+export default function CandidateTable({ evaluations, onViewDetail }) {
+  if (!evaluations || evaluations.length === 0) return null;
+
+  return (
+    <div className="overflow-x-auto">
+      <table className="w-full text-left border-separate border-spacing-y-3">
+        <thead>
+          <tr className="text-slate-500 text-sm font-medium">
+            <th className="px-4 pb-2">Rank</th>
+            <th className="px-4 pb-2">Candidate</th>
+            <th className="px-4 pb-2">Score</th>
+            <th className="px-4 pb-2">Decision</th>
+            <th className="px-4 pb-2">Confidence</th>
+            <th className="px-4 pb-2 text-right">Action</th>
+          </tr>
+        </thead>
+        <tbody>
+          {evaluations.map((evalItem, index) => (
+            <tr 
+              key={evalItem.candidate_id} 
+              className="glass-card hover:bg-slate-50/50 dark:hover:bg-slate-800/30 transition-all group cursor-pointer"
+              onClick={() => onViewDetail(evalItem)}
+            >
+              <td className="px-4 py-4 rounded-l-xl">
+                <span className={`flex items-center justify-center w-8 h-8 rounded-full text-xs font-bold ${
+                  index === 0 ? 'bg-amber-100 text-amber-600' : 
+                  index === 1 ? 'bg-slate-100 text-slate-600' : 
+                  index === 2 ? 'bg-orange-100 text-orange-600' : 'bg-slate-50 text-slate-400'
+                }`}>
+                  {index + 1}
+                </span>
+              </td>
+              <td className="px-4 py-4">
+                <div>
+                  <div className="font-semibold text-slate-900 dark:text-white">{evalItem.name}</div>
+                  <div className="text-xs text-slate-500 truncate max-w-[150px]">{evalItem.candidate_id}</div>
+                </div>
+              </td>
+              <td className="px-4 py-4">
+                <div className="flex items-center gap-2">
+                  <div className="w-16 h-2 bg-slate-100 dark:bg-slate-800 rounded-full overflow-hidden">
+                    <div 
+                      className="h-full bg-indigo-500 transition-all duration-1000" 
+                      style={{ width: `${evalItem.final_score}%` }}
+                    />
+                  </div>
+                  <span className="text-sm font-bold text-indigo-600">{Math.round(evalItem.final_score)}</span>
+                </div>
+              </td>
+              <td className="px-4 py-4">
+                <span className={`px-2 py-1 rounded-md text-[10px] uppercase font-bold tracking-wider ${
+                  evalItem.decision === 'Strong Hire' ? 'bg-emerald-100 text-emerald-700' :
+                  evalItem.decision === 'Hire' ? 'bg-blue-100 text-blue-700' :
+                  evalItem.decision === 'Reject' ? 'bg-rose-100 text-rose-700' : 'bg-slate-100 text-slate-700'
+                }`}>
+                  {evalItem.decision}
+                </span>
+              </td>
+              <td className="px-4 py-4">
+                <div className="flex items-center gap-1.6 text-sm">
+                  <Target className="w-4 h-4 text-slate-400" />
+                  <span>{evalItem.confidence}%</span>
+                </div>
+              </td>
+              <td className="px-4 py-4 text-right rounded-r-xl">
+                <button className="p-2 hover:bg-white dark:hover:bg-slate-700 rounded-lg transition-colors">
+                  <ChevronRight className="w-5 h-5 text-slate-400 group-hover:text-indigo-600" />
+                </button>
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}

proj/frontend/src/lib/api.js

@@ -0,0 +1,26 @@
+import axios from 'axios';
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000';
+
+const api = axios.create({
+  baseURL: API_URL,
+});
+
+export const uploadCSV = async (file) => {
+  const formData = new FormData();
+  formData.append('file', file);
+  const response = await api.post('/upload-csv', formData);
+  return response.data;
+};
+
+export const runEvaluation = async (jd, candidates) => {
+  const response = await api.post('/evaluate', { jd, candidates });
+  return response.data;
+};
+
+export const getCandidateDetails = async (id) => {
+  const response = await api.get(`/candidate/${id}`);
+  return response.data;
+};
+
+export default api;

proj/frontend/src/lib/api.ts

@@ -0,0 +1,26 @@
+import axios from 'axios';
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000';
+
+const api = axios.create({
+  baseURL: API_URL,
+});
+
+export const uploadCSV = async (file: File) => {
+  const formData = new FormData();
+  formData.append('file', file);
+  const response = await api.post('/upload-csv', formData);
+  return response.data;
+};
+
+export const runEvaluation = async (jd: string, candidates: any[]) => {
+  const response = await api.post('/evaluate', { jd, candidates });
+  return response.data;
+};
+
+export const getCandidateDetails = async (id: string) => {
+  const response = await api.get(`/candidate/${id}`);
+  return response.data;
+};
+
+export default api;