fix: resolve asyncpg ssl connection errors and Qdrant strict payload filtering

backend/alembic/env.py

@@ -12,8 +12,12 @@ if config.config_file_name is not None:
 import sys, os
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
+# Load .env before importing settings
+from dotenv import load_dotenv
+load_dotenv(os.path.join(os.path.dirname(__file__), "..", ".env"))
+
 from src.database import Base
-from src.models import JobDescription, Candidate, MatchResult
+from src.models import JobDescription, Candidate, MatchResult, Session
 from src.config import get_settings
 
 target_metadata = Base.metadata
@@ -22,6 +26,10 @@ target_metadata = Base.metadata
 def _make_async_url(url: str) -> str:
     url = re.sub(r"^postgresql:", "postgresql+asyncpg:", url)
     url = re.sub(r"[?&]channel_binding=require", "", url)
+    url = re.sub(r"[?&]sslmode=[^&]*", "", url)
+    url = re.sub(r"[?&]connect_timeout=[^&]*", "", url)
+    # clean trailing ? or &
+    url = re.sub(r"[?&]$", "", url)
     return url
 
 
@@ -45,7 +53,9 @@ def do_run_migrations(connection):
 
 async def run_async_migrations() -> None:
     settings = get_settings()
-    connectable = create_async_engine(_make_async_url(settings.database_url), poolclass=pool.NullPool)
+    from src.database import _make_async_url
+    db_url, connect_args = _make_async_url(settings.database_url)
+    connectable = create_async_engine(db_url, poolclass=pool.NullPool, connect_args=connect_args)
     async with connectable.connect() as connection:
         await connection.run_sync(do_run_migrations)
     await connectable.dispose()

backend/main.py

@@ -1,18 +1,21 @@
 import os
+import logging
 from contextlib import asynccontextmanager
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 from qdrant_client import QdrantClient
-from qdrant_client.models import Distance, VectorParams
+from qdrant_client.models import Distance, VectorParams, PayloadSchemaType
 
 from src.config import get_settings
-from src.database import engine
-from src.models import JobDescription, Candidate, MatchResult
-from src.routers import jds, candidates, matching
+from src.models import JobDescription, Candidate, MatchResult, Session
+from src.routers import jds, candidates, matching, sessions
 
+logger = logging.getLogger(__name__)
 settings = get_settings()
 
 _qdrant_client: QdrantClient | None = None
+_qdrant_ready: bool = False
 
 
 def get_qdrant() -> QdrantClient:
@@ -21,24 +24,47 @@ def get_qdrant() -> QdrantClient:
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    global _qdrant_client
+    global _qdrant_client, _qdrant_ready
     _qdrant_client = QdrantClient(url=settings.qdrant_url, api_key=settings.qdrant_api_key)
 
-    existing = [c.name for c in _qdrant_client.get_collections().collections]
-    if settings.collection_name not in existing:
-        _qdrant_client.create_collection(
-            collection_name=settings.collection_name,
-            vectors_config=VectorParams(size=settings.vector_size, distance=Distance.COSINE),
+    try:
+        existing = [c.name for c in _qdrant_client.get_collections().collections]
+        if settings.collection_name not in existing:
+            _qdrant_client.create_collection(
+                collection_name=settings.collection_name,
+                vectors_config=VectorParams(size=settings.vector_size, distance=Distance.COSINE),
+            )
+            # Create indexing for the session_id to allow fast filtering
+            _qdrant_client.create_payload_index(
+                collection_name=settings.collection_name,
+                field_name="session_id",
+                field_schema=PayloadSchemaType.UUID,
+            )
+            # Create indexing for years_of_experience for range filtering
+            _qdrant_client.create_payload_index(
+                collection_name=settings.collection_name,
+                field_name="years_of_experience",
+                field_schema=PayloadSchemaType.FLOAT,
+            )
+        _qdrant_ready = True
+        logger.info("Qdrant connected — collection '%s' ready", settings.collection_name)
+    except Exception as exc:
+        _qdrant_ready = False
+        logger.warning(
+            "Qdrant unavailable at startup (%s). "
+            "The API will start but vector search will fail until Qdrant is reachable.",
+            exc,
         )
 
     app.state.qdrant = _qdrant_client
+    app.state.qdrant_ready = _qdrant_ready
     yield
     _qdrant_client.close()
 
 
 app = FastAPI(
     title="TalentPulse — AI Candidate Matching",
-    description="Two-stage retrieval + reranking pipeline for matching JDs against 100K+ candidates",
+    description="Two-stage retrieval + reranking pipeline for matching JDs against candidate sessions",
     version="1.0.0",
     lifespan=lifespan,
 )
@@ -51,11 +77,22 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+app.include_router(sessions.router, prefix="/api/sessions", tags=["Sessions"])
 app.include_router(jds.router, prefix="/api/jds", tags=["Job Descriptions"])
 app.include_router(candidates.router, prefix="/api/candidates", tags=["Candidates"])
 app.include_router(matching.router, prefix="/api/match", tags=["Matching"])
 
 
 @app.get("/health")
-async def health():
-    return {"status": "ok", "version": "1.0.0"}
+async def health(request: "Request"):
+    qdrant_ok = getattr(request.app.state, "qdrant_ready", False)
+    return {
+        "status": "ok",
+        "version": "1.0.0",
+        "qdrant": "connected" if qdrant_ok else "unavailable",
+    }
+
+
+static_dir = os.path.join(os.path.dirname(__file__), "static")
+if os.path.isdir(static_dir):
+    app.mount("/", StaticFiles(directory=static_dir, html=True), name="static")

backend/src/database.py

@@ -5,14 +5,39 @@ from sqlalchemy.orm import DeclarativeBase
 from .config import get_settings
 
 
-def _make_async_url(url: str) -> str:
-    url = re.sub(r"^postgresql:", "postgresql+asyncpg:", url)
-    url = re.sub(r"[?&]channel_binding=require", "", url)
-    return url
+def _make_async_url(url: str) -> tuple[str, dict]:
+    """Convert a standard postgres:// URL to asyncpg-compatible form.
+
+    asyncpg does NOT accept sslmode or channel_binding as URL query params.
+    Strip them and return connect_args with ssl=True when sslmode was present.
+    """
+    needs_ssl = bool(re.search(r"[?&]sslmode=", url))
+    # Switch scheme
+    url = re.sub(r"^postgresql(\+[^:]+)?:", "postgresql+asyncpg:", url)
+    # Remove unsupported query params
+    for param in ("sslmode", "channel_binding"):
+        url = re.sub(rf"[?&]{param}=[^&]*", "", url)
+    # Clean up trailing ? or & left behind
+    url = re.sub(r"\?$", "", url)
+    url = re.sub(r"&$", "", url)
+    connect_args: dict = {}
+    if needs_ssl:
+        import ssl as _ssl
+        ctx = _ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = _ssl.CERT_NONE
+        connect_args["ssl"] = ctx
+    return url, connect_args
 
 
 settings = get_settings()
-engine = create_async_engine(_make_async_url(settings.database_url), echo=False, pool_pre_ping=True)
+_db_url, _connect_args = _make_async_url(settings.database_url)
+engine = create_async_engine(
+    _db_url,
+    echo=False,
+    pool_pre_ping=True,
+    connect_args=_connect_args,
+)
 AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)
 
 
@@ -23,3 +48,4 @@ class Base(DeclarativeBase):
 async def get_db() -> AsyncGenerator[AsyncSession, None]:
     async with AsyncSessionLocal() as session:
         yield session
+

backend/src/matching/stage1.py

@@ -2,39 +2,26 @@ from typing import Any
 from qdrant_client import QdrantClient
 from qdrant_client.models import Filter, FieldCondition, MatchValue, Range
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, or_
+from sqlalchemy import select
 
 from ..config import get_settings
 from ..models.candidate import Candidate
 from ..ml.embedder import embed_query
-from ..ml.feature_builder import (
-    skill_jaccard,
-    yoe_match,
-    company_quality_signal,
-    education_match,
-)
+from ..ml.feature_builder import skill_jaccard, yoe_match, company_quality_signal, education_match
 
 
 DEFAULT_WEIGHTS = {
-    "semantic": 0.20,
-    "skill": 0.35,
-    "yoe": 0.15,
-    "company": 0.10,
-    "growth": 0.10,
-    "education": 0.10,
+    "semantic": 0.20, "skill": 0.35, "yoe": 0.15,
+    "company": 0.10, "growth": 0.10, "education": 0.10,
 }
 
 
-def _build_qdrant_filter(jd: dict) -> Filter | None:
+def _build_qdrant_filter(jd: dict, session_id: str | None) -> Filter | None:
     conditions = []
-    if jd.get("role_type"):
-        conditions.append(
-            FieldCondition(key="role_type", match=MatchValue(value=jd["role_type"]))
-        )
+    if session_id:
+        conditions.append(FieldCondition(key="session_id", match=MatchValue(value=session_id)))
     if jd.get("min_yoe") is not None:
-        conditions.append(
-            FieldCondition(key="years_of_experience", range=Range(gte=max(0, jd["min_yoe"] - 2)))
-        )
+        conditions.append(FieldCondition(key="years_of_experience", range=Range(gte=max(0, jd["min_yoe"] - 2))))
     if not conditions:
         return None
     return Filter(must=conditions)
@@ -44,6 +31,7 @@ async def stage1_retrieve(
     jd: dict,
     db: AsyncSession,
     qdrant: QdrantClient,
+    session_id: str | None = None,
     top_k: int = 200,
     weights: dict | None = None,
 ) -> list[dict[str, Any]]:
@@ -53,7 +41,7 @@ async def stage1_retrieve(
     jd_text = f"{jd.get('title', '')} {jd.get('raw_text', '')}"
     query_vector = embed_query(jd_text)
 
-    qdrant_filter = _build_qdrant_filter(jd)
+    qdrant_filter = _build_qdrant_filter(jd, session_id)
     search_results = qdrant.search(
         collection_name=settings.collection_name,
         query_vector=query_vector.tolist(),
@@ -68,9 +56,7 @@ async def stage1_retrieve(
     qdrant_ids = [r.id for r in search_results]
     score_by_qdrant_id = {r.id: float(r.score) for r in search_results}
 
-    result = await db.execute(
-        select(Candidate).where(Candidate.qdrant_id.in_(qdrant_ids))
-    )
+    result = await db.execute(select(Candidate).where(Candidate.qdrant_id.in_(qdrant_ids)))
     candidates = {c.qdrant_id: c for c in result.scalars().all()}
 
     jd_skills = jd.get("required_skills") or []
@@ -84,11 +70,8 @@ async def stage1_retrieve(
             continue
 
         cosine_sim = score_by_qdrant_id[qid]
-
         all_cand_skills = (
-            (cand.programming_languages or [])
-            + (cand.backend_frameworks or [])
-            + (cand.frontend_technologies or [])
+            (cand.programming_languages or []) + (cand.backend_frameworks or []) + (cand.frontend_technologies or [])
         )
         if cand.parsed_skills:
             all_cand_skills.extend([s.strip() for s in cand.parsed_skills.split(",") if s.strip()])
@@ -97,45 +80,35 @@ async def stage1_retrieve(
             "semantic": cosine_sim,
             "skill": skill_jaccard(jd_skills, all_cand_skills),
             "yoe": yoe_match(min_yoe, max_yoe, cand.years_of_experience),
-            "company": company_quality_signal(
-                {
-                    "most_recent_company_is_funded": cand.most_recent_company_is_funded,
-                    "most_recent_company_is_product_company": cand.most_recent_company_is_product_company,
-                    "most_recent_company_total_funding": cand.most_recent_company_total_funding,
-                }
-            ),
+            "company": company_quality_signal({
+                "most_recent_company_is_funded": cand.most_recent_company_is_funded,
+                "most_recent_company_is_product_company": cand.most_recent_company_is_product_company,
+                "most_recent_company_total_funding": cand.most_recent_company_total_funding,
+            }),
             "growth": float(cand.growth_velocity or 0.5),
-            "education": education_match(
-                {
-                    "degree": cand.degree,
-                    "education_status": cand.education_status,
-                }
-            ),
+            "education": education_match({"degree": cand.degree, "education_status": cand.education_status}),
         }
 
         total = sum(w.get(k, 0) * v for k, v in components.items())
-
-        scored.append(
-            {
-                "candidate_id": str(cand.id),
-                "qdrant_id": qid,
-                "name": cand.name,
-                "email": cand.email,
-                "role_type": cand.role_type,
-                "engineer_type": cand.engineer_type,
-                "years_of_experience": cand.years_of_experience,
-                "most_recent_company": cand.most_recent_company,
-                "parsed_summary": cand.parsed_summary,
-                "parsed_skills": cand.parsed_skills,
-                "parsed_work_experience": cand.parsed_work_experience or [],
-                "programming_languages": cand.programming_languages or [],
-                "backend_frameworks": cand.backend_frameworks or [],
-                "frontend_technologies": cand.frontend_technologies or [],
-                "growth_velocity": cand.growth_velocity,
-                "stage1_score": round(total, 4),
-                "component_scores": {k: round(v, 4) for k, v in components.items()},
-            }
-        )
+        scored.append({
+            "candidate_id": str(cand.id),
+            "qdrant_id": qid,
+            "name": cand.name,
+            "email": cand.email,
+            "role_type": cand.role_type,
+            "engineer_type": cand.engineer_type,
+            "years_of_experience": cand.years_of_experience,
+            "most_recent_company": cand.most_recent_company,
+            "parsed_summary": cand.parsed_summary,
+            "parsed_skills": cand.parsed_skills,
+            "parsed_work_experience": cand.parsed_work_experience or [],
+            "programming_languages": cand.programming_languages or [],
+            "backend_frameworks": cand.backend_frameworks or [],
+            "frontend_technologies": cand.frontend_technologies or [],
+            "growth_velocity": cand.growth_velocity,
+            "stage1_score": round(total, 4),
+            "component_scores": {k: round(v, 4) for k, v in components.items()},
+        })
 
     scored.sort(key=lambda x: x["stage1_score"], reverse=True)
     return scored[:50]

backend/src/routers/matching.py

@@ -1,6 +1,6 @@
 import uuid
 from datetime import datetime, timezone
-from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi import APIRouter, Depends, HTTPException, Request, Query
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, delete
 
@@ -8,7 +8,10 @@ from ..database import get_db
 from ..models.jd import JobDescription
 from ..models.candidate import Candidate
 from ..models.match_result import MatchResult
-from ..schemas.match import MatchResponse, MatchedCandidate, ComponentScores, GapItem, CandidateDetailResponse, ReRankRequest
+from ..schemas.match import (
+    MatchResponse, MatchedCandidate, ComponentScores, GapItem,
+    CandidateDetailResponse, ReRankRequest,
+)
 from ..matching.stage1 import stage1_retrieve
 from ..matching.stage2 import stage2_rerank
 from ..matching.llm_explainer import generate_explanation
@@ -31,39 +34,64 @@ async def _load_jd(jd_id: uuid.UUID, db: AsyncSession) -> JobDescription:
     return jd
 
 
+def _build_jd_dict(jd: JobDescription) -> dict:
+    return {
+        "id": str(jd.id), "title": jd.title, "raw_text": jd.raw_text,
+        "required_skills": jd.required_skills or [], "min_yoe": jd.min_yoe,
+        "max_yoe": jd.max_yoe, "role_type": jd.role_type,
+        "engineer_type": jd.engineer_type, "location": jd.location,
+        "remote_allowed": jd.remote_allowed,
+    }
+
+
+def _to_matched_candidate(item: dict, rank: int) -> MatchedCandidate:
+    return MatchedCandidate(
+        candidate_id=uuid.UUID(item["candidate_id"]),
+        rank=rank,
+        name=item.get("name"),
+        email=item.get("email"),
+        role_type=item.get("role_type"),
+        engineer_type=item.get("engineer_type"),
+        years_of_experience=item.get("years_of_experience"),
+        most_recent_company=item.get("most_recent_company"),
+        parsed_summary=item.get("parsed_summary"),
+        programming_languages=item.get("programming_languages") or [],
+        growth_velocity=item.get("growth_velocity", 0.5),
+        stage1_score=item.get("stage1_score", 0),
+        stage2_score=item.get("stage2_score"),
+        final_score=item.get("final_score", 0),
+        component_scores=ComponentScores(**(item.get("component_scores") or {})),
+        gaps=[GapItem(**g) for g in item.get("gaps", [])],
+    )
+
+
 @router.post("/{jd_id}", response_model=MatchResponse)
 async def trigger_match(
     jd_id: uuid.UUID,
     request: Request,
+    session_id: uuid.UUID | None = Query(None, description="Candidate session to match against"),
     db: AsyncSession = Depends(get_db),
 ):
     jd = await _load_jd(jd_id, db)
     qdrant = _get_qdrant(request)
+    jd_dict = _build_jd_dict(jd)
+    sid_str = str(session_id) if session_id else None
 
-    jd_dict = {
-        "id": str(jd.id),
-        "title": jd.title,
-        "raw_text": jd.raw_text,
-        "required_skills": jd.required_skills or [],
-        "min_yoe": jd.min_yoe,
-        "max_yoe": jd.max_yoe,
-        "role_type": jd.role_type,
-        "engineer_type": jd.engineer_type,
-        "location": jd.location,
-        "remote_allowed": jd.remote_allowed,
-    }
-
-    shortlist = await stage1_retrieve(jd_dict, db, qdrant)
+    shortlist = await stage1_retrieve(jd_dict, db, qdrant, session_id=sid_str)
     final_ranked = await stage2_rerank(jd_dict, shortlist)
 
-    await db.execute(delete(MatchResult).where(MatchResult.jd_id == jd_id))
+    await db.execute(
+        delete(MatchResult).where(
+            MatchResult.jd_id == jd_id,
+            MatchResult.session_id == session_id if session_id else MatchResult.session_id.is_(None),
+        )
+    )
 
-    match_records = []
     for i, item in enumerate(final_ranked):
         mr = MatchResult(
-            id=uuid.uuid4(),
-            jd_id=jd_id,
+            id=uuid.uuid4(), jd_id=jd_id,
             candidate_id=uuid.UUID(item["candidate_id"]),
+            session_id=session_id,
             rank=i + 1,
             stage1_score=item.get("stage1_score", 0),
             stage2_score=item.get("stage2_score"),
@@ -71,54 +99,40 @@ async def trigger_match(
             component_scores=item.get("component_scores", {}),
             gaps=item.get("gaps", []),
         )
-        match_records.append(mr)
         db.add(mr)
 
     await db.commit()
 
-    results = []
-    for i, item in enumerate(final_ranked):
-        results.append(
-            MatchedCandidate(
-                candidate_id=uuid.UUID(item["candidate_id"]),
-                rank=i + 1,
-                name=item.get("name"),
-                email=item.get("email"),
-                role_type=item.get("role_type"),
-                engineer_type=item.get("engineer_type"),
-                years_of_experience=item.get("years_of_experience"),
-                most_recent_company=item.get("most_recent_company"),
-                parsed_summary=item.get("parsed_summary"),
-                programming_languages=item.get("programming_languages") or [],
-                growth_velocity=item.get("growth_velocity", 0.5),
-                stage1_score=item.get("stage1_score", 0),
-                stage2_score=item.get("stage2_score"),
-                final_score=item.get("final_score", 0),
-                component_scores=ComponentScores(**item.get("component_scores", {})),
-                gaps=[GapItem(**g) for g in item.get("gaps", [])],
-            )
-        )
-
+    results = [_to_matched_candidate(item, i + 1) for i, item in enumerate(final_ranked)]
     return MatchResponse(
-        jd_id=jd_id,
-        jd_title=jd.title,
+        jd_id=jd_id, jd_title=jd.title,
         jd_quality=jd.jd_quality or {},
-        total_matched=len(results),
-        results=results,
+        total_matched=len(results), results=results,
         weights_used={"semantic": 0.20, "skill": 0.35, "yoe": 0.15, "company": 0.10, "growth": 0.10, "education": 0.10},
+        session_id=session_id,
     )
 
 
 @router.get("/{jd_id}", response_model=MatchResponse)
-async def get_match_results(jd_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+async def get_match_results(
+    jd_id: uuid.UUID,
+    session_id: uuid.UUID | None = Query(None),
+    db: AsyncSession = Depends(get_db),
+):
     jd = await _load_jd(jd_id, db)
 
-    result = await db.execute(
+    q = (
         select(MatchResult, Candidate)
         .join(Candidate, MatchResult.candidate_id == Candidate.id)
         .where(MatchResult.jd_id == jd_id)
-        .order_by(MatchResult.rank)
     )
+    if session_id:
+        q = q.where(MatchResult.session_id == session_id)
+    else:
+        q = q.where(MatchResult.session_id.is_(None))
+    q = q.order_by(MatchResult.rank)
+
+    result = await db.execute(q)
     rows = result.all()
 
     if not rows:
@@ -126,33 +140,73 @@ async def get_match_results(jd_id: uuid.UUID, db: AsyncSession = Depends(get_db)
 
     results = []
     for mr, cand in rows:
-        results.append(
-            MatchedCandidate(
-                candidate_id=cand.id,
-                rank=mr.rank or 0,
-                name=cand.name,
-                email=cand.email,
-                role_type=cand.role_type,
-                engineer_type=cand.engineer_type,
-                years_of_experience=cand.years_of_experience,
-                most_recent_company=cand.most_recent_company,
-                parsed_summary=cand.parsed_summary,
-                programming_languages=cand.programming_languages or [],
-                growth_velocity=cand.growth_velocity,
-                stage1_score=mr.stage1_score,
-                stage2_score=mr.stage2_score,
-                final_score=mr.final_score,
-                component_scores=ComponentScores(**(mr.component_scores or {})),
-                gaps=[GapItem(**g) for g in (mr.gaps or [])],
-            )
-        )
+        item = {
+            "candidate_id": str(cand.id), "name": cand.name, "email": cand.email,
+            "role_type": cand.role_type, "engineer_type": cand.engineer_type,
+            "years_of_experience": cand.years_of_experience,
+            "most_recent_company": cand.most_recent_company,
+            "parsed_summary": cand.parsed_summary,
+            "programming_languages": cand.programming_languages or [],
+            "growth_velocity": cand.growth_velocity,
+            "stage1_score": mr.stage1_score, "stage2_score": mr.stage2_score,
+            "final_score": mr.final_score,
+            "component_scores": mr.component_scores or {}, "gaps": mr.gaps or [],
+        }
+        results.append(_to_matched_candidate(item, mr.rank or 0))
 
     return MatchResponse(
-        jd_id=jd_id,
-        jd_title=jd.title,
-        jd_quality=jd.jd_quality or {},
-        total_matched=len(results),
-        results=results,
+        jd_id=jd_id, jd_title=jd.title, jd_quality=jd.jd_quality or {},
+        total_matched=len(results), results=results, session_id=session_id,
+    )
+
+
+@router.post("/{jd_id}/rerank", response_model=MatchResponse)
+async def rerank_results(
+    jd_id: uuid.UUID,
+    payload: ReRankRequest,
+    session_id: uuid.UUID | None = Query(None),
+    db: AsyncSession = Depends(get_db),
+):
+    jd = await _load_jd(jd_id, db)
+
+    q = (
+        select(MatchResult, Candidate)
+        .join(Candidate, MatchResult.candidate_id == Candidate.id)
+        .where(MatchResult.jd_id == jd_id)
+    )
+    if session_id:
+        q = q.where(MatchResult.session_id == session_id)
+    else:
+        q = q.where(MatchResult.session_id.is_(None))
+    q = q.order_by(MatchResult.rank)
+
+    result = await db.execute(q)
+    rows = result.all()
+    if not rows:
+        raise HTTPException(status_code=404, detail="No match results found.")
+
+    items = [
+        {
+            "candidate_id": str(cand.id), "name": cand.name, "email": cand.email,
+            "role_type": cand.role_type, "engineer_type": cand.engineer_type,
+            "years_of_experience": cand.years_of_experience,
+            "most_recent_company": cand.most_recent_company,
+            "parsed_summary": cand.parsed_summary,
+            "programming_languages": cand.programming_languages or [],
+            "growth_velocity": cand.growth_velocity,
+            "stage1_score": mr.stage1_score, "stage2_score": mr.stage2_score,
+            "final_score": mr.final_score,
+            "component_scores": mr.component_scores or {}, "gaps": mr.gaps or [],
+        }
+        for mr, cand in rows
+    ]
+
+    reranked = rerank_with_weights(items, payload.weights)
+    results = [_to_matched_candidate(item, item["rank"]) for item in reranked]
+    return MatchResponse(
+        jd_id=jd_id, jd_title=jd.title, jd_quality=jd.jd_quality or {},
+        total_matched=len(results), results=results,
+        weights_used=payload.weights, session_id=session_id,
     )
 
 
@@ -160,19 +214,18 @@ async def get_match_results(jd_id: uuid.UUID, db: AsyncSession = Depends(get_db)
 async def get_candidate_detail(
     jd_id: uuid.UUID,
     candidate_id: uuid.UUID,
+    session_id: uuid.UUID | None = Query(None),
     db: AsyncSession = Depends(get_db),
 ):
     jd = await _load_jd(jd_id, db)
 
-    mr_result = await db.execute(
-        select(MatchResult).where(
-            MatchResult.jd_id == jd_id,
-            MatchResult.candidate_id == candidate_id,
-        )
-    )
+    q = select(MatchResult).where(MatchResult.jd_id == jd_id, MatchResult.candidate_id == candidate_id)
+    if session_id:
+        q = q.where(MatchResult.session_id == session_id)
+    mr_result = await db.execute(q)
     mr = mr_result.scalar_one_or_none()
     if not mr:
-        raise HTTPException(status_code=404, detail="Match result not found for this JD/candidate pair")
+        raise HTTPException(status_code=404, detail="Match result not found")
 
     cand_result = await db.execute(select(Candidate).where(Candidate.id == candidate_id))
     cand = cand_result.scalar_one_or_none()
@@ -180,19 +233,9 @@ async def get_candidate_detail(
         raise HTTPException(status_code=404, detail="Candidate not found")
 
     if not mr.explanation:
-        jd_dict = {
-            "id": str(jd.id),
-            "title": jd.title,
-            "raw_text": jd.raw_text,
-            "required_skills": jd.required_skills or [],
-            "min_yoe": jd.min_yoe,
-            "engineer_type": jd.engineer_type,
-            "location": jd.location,
-            "remote_allowed": jd.remote_allowed,
-        }
+        jd_dict = _build_jd_dict(jd)
         cand_dict = {
-            "parsed_summary": cand.parsed_summary,
-            "parsed_skills": cand.parsed_skills,
+            "parsed_summary": cand.parsed_summary, "parsed_skills": cand.parsed_skills,
             "years_of_experience": cand.years_of_experience,
             "programming_languages": cand.programming_languages or [],
             "backend_frameworks": cand.backend_frameworks or [],
@@ -206,113 +249,28 @@ async def get_candidate_detail(
         await db.commit()
 
     return CandidateDetailResponse(
-        jd_id=jd_id,
-        candidate_id=candidate_id,
-        rank=mr.rank,
+        jd_id=jd_id, candidate_id=candidate_id, rank=mr.rank,
         final_score=mr.final_score,
         component_scores=ComponentScores(**(mr.component_scores or {})),
         gaps=[GapItem(**g) for g in (mr.gaps or [])],
         explanation=mr.explanation,
         candidate={
-            "name": cand.name,
-            "email": cand.email,
-            "role_type": cand.role_type,
-            "engineer_type": cand.engineer_type,
-            "years_of_experience": cand.years_of_experience,
-            "most_recent_company": cand.most_recent_company,
-            "parsed_summary": cand.parsed_summary,
-            "parsed_skills": cand.parsed_skills,
-            "parsed_work_experience": cand.parsed_work_experience or [],
+            "name": cand.name, "email": cand.email, "role_type": cand.role_type,
+            "engineer_type": cand.engineer_type, "years_of_experience": cand.years_of_experience,
+            "most_recent_company": cand.most_recent_company, "parsed_summary": cand.parsed_summary,
+            "parsed_skills": cand.parsed_skills, "parsed_work_experience": cand.parsed_work_experience or [],
             "programming_languages": cand.programming_languages or [],
             "backend_frameworks": cand.backend_frameworks or [],
-            "gen_ai_experience": cand.gen_ai_experience,
-            "growth_velocity": cand.growth_velocity,
-            "looking_for": cand.looking_for,
-            "open_to_working_at": cand.open_to_working_at,
+            "gen_ai_experience": cand.gen_ai_experience, "growth_velocity": cand.growth_velocity,
+            "looking_for": cand.looking_for, "open_to_working_at": cand.open_to_working_at,
             "is_actively_or_passively_looking": cand.is_actively_or_passively_looking,
             "most_recent_company_is_funded": cand.most_recent_company_is_funded,
             "most_recent_company_is_product_company": cand.most_recent_company_is_product_company,
             "most_recent_company_total_funding": cand.most_recent_company_total_funding,
         },
         jd={
-            "title": jd.title,
-            "required_skills": jd.required_skills or [],
-            "min_yoe": jd.min_yoe,
-            "role_type": jd.role_type,
-            "engineer_type": jd.engineer_type,
-            "location": jd.location,
+            "title": jd.title, "required_skills": jd.required_skills or [],
+            "min_yoe": jd.min_yoe, "role_type": jd.role_type,
+            "engineer_type": jd.engineer_type, "location": jd.location,
         },
     )
-
-
-@router.post("/{jd_id}/rerank", response_model=MatchResponse)
-async def rerank_results(
-    jd_id: uuid.UUID,
-    payload: ReRankRequest,
-    db: AsyncSession = Depends(get_db),
-):
-    jd = await _load_jd(jd_id, db)
-
-    result = await db.execute(
-        select(MatchResult, Candidate)
-        .join(Candidate, MatchResult.candidate_id == Candidate.id)
-        .where(MatchResult.jd_id == jd_id)
-        .order_by(MatchResult.rank)
-    )
-    rows = result.all()
-
-    if not rows:
-        raise HTTPException(status_code=404, detail="No match results found.")
-
-    items = []
-    for mr, cand in rows:
-        items.append({
-            "candidate_id": str(cand.id),
-            "name": cand.name,
-            "email": cand.email,
-            "role_type": cand.role_type,
-            "engineer_type": cand.engineer_type,
-            "years_of_experience": cand.years_of_experience,
-            "most_recent_company": cand.most_recent_company,
-            "parsed_summary": cand.parsed_summary,
-            "programming_languages": cand.programming_languages or [],
-            "growth_velocity": cand.growth_velocity,
-            "stage1_score": mr.stage1_score,
-            "stage2_score": mr.stage2_score,
-            "final_score": mr.final_score,
-            "component_scores": mr.component_scores or {},
-            "gaps": mr.gaps or [],
-        })
-
-    reranked = rerank_with_weights(items, payload.weights)
-
-    results = [
-        MatchedCandidate(
-            candidate_id=uuid.UUID(item["candidate_id"]),
-            rank=item["rank"],
-            name=item.get("name"),
-            email=item.get("email"),
-            role_type=item.get("role_type"),
-            engineer_type=item.get("engineer_type"),
-            years_of_experience=item.get("years_of_experience"),
-            most_recent_company=item.get("most_recent_company"),
-            parsed_summary=item.get("parsed_summary"),
-            programming_languages=item.get("programming_languages") or [],
-            growth_velocity=item.get("growth_velocity", 0.5),
-            stage1_score=item.get("stage1_score", 0),
-            stage2_score=item.get("stage2_score"),
-            final_score=item.get("final_score", 0),
-            component_scores=ComponentScores(**(item.get("component_scores") or {})),
-            gaps=[GapItem(**g) for g in item.get("gaps", [])],
-        )
-        for item in reranked
-    ]
-
-    return MatchResponse(
-        jd_id=jd_id,
-        jd_title=jd.title,
-        jd_quality=jd.jd_quality or {},
-        total_matched=len(results),
-        results=results,
-        weights_used=payload.weights,
-    )

backend/test_db.py

@@ -0,0 +1,8 @@
+import asyncio
+from src.database import engine
+
+async def test():
+    async with engine.begin() as conn:
+        await conn.run_sync(lambda *args: print('DB Connection OK'))
+
+asyncio.run(test())