Redeploy latest local changes

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+sample_docs/Amar_Agnihotri_Resume.pdf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -37,7 +37,7 @@ ENV APP_ENV=production \
     CELERY_CONCURRENCY=1 \
     HF_INFERENCE_PROVIDER=auto \
     OPENAI_BASE_URL=https://router.huggingface.co/v1 \
-    OPENAI_MODEL=deepseek-ai/DeepSeek-R1 \
+    OPENAI_MODEL=openai/gpt-oss-20b \
     HF_EMBEDDING_MODEL=Qwen/Qwen3-Embedding-8B \
     EMBEDDING_MODEL=infgrad/Jasper-Token-Compression-600M \
     EMBEDDING_DEVICE=cpu \

README.md

@@ -39,7 +39,7 @@ Required Space secrets:
 Recommended Space variables:
 
 - `OPENAI_BASE_URL=https://router.huggingface.co/v1`
-- `OPENAI_MODEL=deepseek-ai/DeepSeek-R1`
+- `OPENAI_MODEL=openai/gpt-oss-20b`
 - `HF_INFERENCE_PROVIDER=auto`
 - `HF_EMBEDDING_MODEL=Qwen/Qwen3-Embedding-8B`
 - `EMBEDDING_MODEL=infgrad/Jasper-Token-Compression-600M`

app/core/config.py

@@ -27,9 +27,9 @@ class Settings(BaseSettings):
     openai_api_key: str | None = None
     openai_model: str | None = None
     openai_timeout_seconds: int = 60
-    local_llm_base_url: str = "http://host.docker.internal:11434/v1"
+    local_llm_base_url: str = "http://host.docker.internal:8000/v1"
     local_llm_api_key: str = "local-dev"
-    local_llm_model: str = "qwen3:0.6b"
+    local_llm_model: str = "Qwen/Qwen3-0.6B"
     local_llm_model_placeholder: str = "local-model"
     default_openai_model: str = "gpt-4.1-mini"
 
@@ -121,6 +121,21 @@ class Settings(BaseSettings):
             )
         return "OpenAI unavailable. Check OPENAI_API_KEY, OPENAI_BASE_URL, and network access."
 
+    @property
+    def local_llm_unavailable_message(self) -> str:
+        return (
+            "Local LLM unavailable. "
+            f"Check {self.local_llm_base_url} and model {self.local_llm_model}."
+        )
+
+    @property
+    def hosted_then_local_llm_unavailable_message(self) -> str:
+        return (
+            "Hosted LLM failed and local fallback is unavailable. "
+            f"Check OPENAI_BASE_URL/OPENAI_API_KEY plus local fallback {self.local_llm_base_url} "
+            f"with model {self.local_llm_model}."
+        )
+
     @property
     def use_hf_inference_embeddings(self) -> bool:
         return self._clean_optional(self.hf_token) is not None

app/rag/chunk_verification.py

@@ -14,19 +14,6 @@ from app.services.llm_client import LLMUnavailableError, OpenAICompatibleClient
 THINK_BLOCK_RE = re.compile(r"<think>.*?</think>", re.IGNORECASE | re.DOTALL)
 JSON_BLOCK_RE = re.compile(r"\{.*\}", re.DOTALL)
 FENCED_BLOCK_RE = re.compile(r"```(?:json)?\s*(.*?)```", re.IGNORECASE | re.DOTALL)
-CONTINUATION_PREFIXES = (
-    "also ",
-    "another ",
-    "additionally ",
-    "further ",
-    "furthermore ",
-    "the system ",
-    "the platform ",
-    "this solution ",
-    "this system ",
-    "built on ",
-    "it ",
-)
 
 
 def verify_semantic_chunks(
@@ -41,44 +28,44 @@ def verify_semantic_chunks(
     if len(chunks) < 2:
         return annotate_chunks(chunks, verification_status="skipped_too_short")
 
-    candidate_windows = build_candidate_windows(chunks)
-    if not candidate_windows:
-        return annotate_chunks(chunks, verification_status="skipped_no_candidates")
-
+    boundary_windows = build_boundary_windows(chunks)
     llm = llm or OpenAICompatibleClient()
-    try:
-        raw_response = llm.complete(
-            build_chunk_verification_prompt(
-                document_title=document_title,
-                chunks=chunks,
-                candidate_windows=candidate_windows,
-                chunk_max_chars=settings.chunk_max_chars,
-            )
-        )
-    except LLMUnavailableError:
-        return annotate_chunks(chunks, verification_status="skipped_llm_unavailable")
-    except Exception:
-        return annotate_chunks(chunks, verification_status="skipped_llm_error")
-
-    decisions = parse_chunk_verification_response(raw_response)
-    if decisions is None:
-        return annotate_chunks(chunks, verification_status="skipped_invalid_response")
-
     merge_boundaries: set[int] = set()
     decision_notes: dict[int, str] = {}
-    for decision in decisions:
-        left_index = decision.get("left_chunk_index")
-        right_index = decision.get("right_chunk_index")
-        action = str(decision.get("action", "")).strip().lower()
-        if not isinstance(left_index, int) or not isinstance(right_index, int):
-            continue
-        if right_index != left_index + 1:
-            continue
-        if action not in {"merge", "keep"}:
-            continue
-        decision_notes[left_index] = str(decision.get("reason", "")).strip()
-        if action == "merge":
-            merge_boundaries.add(left_index)
+    batch_size = max(1, settings.chunk_verification_max_windows)
+
+    for boundary_batch in batch_boundary_windows(boundary_windows, batch_size):
+        try:
+            raw_response = llm.complete(
+                build_chunk_verification_prompt(
+                    document_title=document_title,
+                    chunks=chunks,
+                    boundary_windows=boundary_batch,
+                    chunk_max_chars=settings.chunk_max_chars,
+                )
+            )
+        except LLMUnavailableError:
+            return annotate_chunks(chunks, verification_status="skipped_llm_unavailable")
+        except Exception:
+            return annotate_chunks(chunks, verification_status="skipped_llm_error")
+
+        decisions = parse_chunk_verification_response(raw_response)
+        if decisions is None:
+            return annotate_chunks(chunks, verification_status="skipped_invalid_response")
+
+        for decision in decisions:
+            left_index = decision.get("left_chunk_index")
+            right_index = decision.get("right_chunk_index")
+            action = str(decision.get("action", "")).strip().lower()
+            if not isinstance(left_index, int) or not isinstance(right_index, int):
+                continue
+            if right_index != left_index + 1:
+                continue
+            if action not in {"merge", "keep"}:
+                continue
+            decision_notes[left_index] = str(decision.get("reason", "")).strip()
+            if action == "merge":
+                merge_boundaries.add(left_index)
 
     return apply_merge_decisions(
         document_title=document_title,
@@ -88,42 +75,23 @@ def verify_semantic_chunks(
     )
 
 
-def build_candidate_windows(chunks: list[ChunkDraft]) -> list[dict[str, int]]:
-    settings = get_settings()
-    candidate_windows: list[dict[str, int]] = []
+def build_boundary_windows(chunks: list[ChunkDraft]) -> list[dict[str, int]]:
+    boundary_windows: list[dict[str, int]] = []
     for left_index in range(len(chunks) - 1):
-        if is_verification_candidate(chunks[left_index], chunks[left_index + 1], settings.chunk_max_chars):
-            candidate_windows.append(
-                {
-                    "left_index": left_index,
-                    "right_index": left_index + 1,
-                }
-            )
-        if len(candidate_windows) >= settings.chunk_verification_max_windows:
-            break
-    return candidate_windows
-
-
-def is_verification_candidate(left: ChunkDraft, right: ChunkDraft, chunk_max_chars: int) -> bool:
-    if left.section_title != right.section_title and left.heading_path != right.heading_path:
-        return False
-
-    combined_length = len(left.raw_text) + len(right.raw_text) + 2
-    if combined_length > chunk_max_chars + 180:
-        return False
-
-    shorter_chunk = min(len(left.raw_text), len(right.raw_text))
-    if shorter_chunk <= max(180, chunk_max_chars // 4):
-        return True
-
-    if left.raw_text.count("•") and right.raw_text.count("•"):
-        return True
+        boundary_windows.append(
+            {
+                "left_index": left_index,
+                "right_index": left_index + 1,
+            }
+        )
+    return boundary_windows
 
-    right_lower = right.raw_text.strip().lower()
-    if any(right_lower.startswith(prefix) for prefix in CONTINUATION_PREFIXES):
-        return True
 
-    return left.section_title == right.section_title
+def batch_boundary_windows(boundary_windows: list[dict[str, int]], batch_size: int) -> list[list[dict[str, int]]]:
+    return [
+        boundary_windows[index : index + batch_size]
+        for index in range(0, len(boundary_windows), batch_size)
+    ]
 
 
 def parse_chunk_verification_response(raw_response: str) -> list[dict[str, object]] | None:

app/rag/prompts.py

@@ -187,11 +187,11 @@ def build_chunk_verification_prompt(
     *,
     document_title: str,
     chunks: list[ChunkDraft],
-    candidate_windows: list[dict[str, int]],
+    boundary_windows: list[dict[str, int]],
     chunk_max_chars: int,
 ) -> str:
     windows: list[str] = []
-    for window in candidate_windows:
+    for window in boundary_windows:
         left_index = window["left_index"]
         right_index = window["right_index"]
         previous_chunk = chunks[left_index - 1] if left_index > 0 else None
@@ -215,7 +215,7 @@ def build_chunk_verification_prompt(
     window_text = "\n\n---\n\n".join(windows)
     return (
         "You are verifying document chunk boundaries after deterministic chunking.\n"
-        "For each candidate boundary, decide whether the right chunk should stay separate or merge with the left chunk.\n"
+        "For each chunk boundary, decide whether the right chunk should stay separate or merge with the left chunk.\n"
         "Choose merge only when the right chunk is a continuation of the same semantic unit, list item group, or subtopic.\n"
         "Choose keep when the right chunk starts a different role, project, section, or independently meaningful unit.\n"
         "Do not rewrite or add facts. Do not use outside knowledge.\n"
@@ -223,7 +223,7 @@ def build_chunk_verification_prompt(
         '{"decisions":[{"left_chunk_index":0,"right_chunk_index":1,"action":"keep","reason":"..."},{"left_chunk_index":1,"right_chunk_index":2,"action":"merge","reason":"..."}]}\n\n'
         f"Document Title: {document_title}\n"
         f"Chunk Max Chars: {chunk_max_chars}\n\n"
-        f"Candidate Boundaries:\n{window_text}\n"
+        f"Chunk Boundaries:\n{window_text}\n"
     )
 
 

app/services/llm_client.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+import logging
+
 from openai import OpenAI, OpenAIError
 
 from app.core.config import get_settings
 
+logger = logging.getLogger(__name__)
+
 
 class LLMUnavailableError(RuntimeError):
     """Raised when the configured OpenAI-compatible endpoint cannot complete a request."""
@@ -13,13 +17,16 @@ class OpenAICompatibleClient:
     def __init__(self) -> None:
         settings = get_settings()
         self.settings = settings
-        client_kwargs = {
-            "api_key": settings.effective_openai_api_key,
-            "timeout": settings.openai_timeout_seconds,
-        }
-        if settings.effective_openai_base_url:
-            client_kwargs["base_url"] = settings.effective_openai_base_url
-        self.client = OpenAI(**client_kwargs)
+        self.client = self._build_client(
+            api_key=settings.effective_openai_api_key,
+            base_url=settings.effective_openai_base_url,
+        )
+        self.fallback_client = None
+        if settings.has_openai_api_key:
+            self.fallback_client = self._build_client(
+                api_key=settings.local_llm_api_key,
+                base_url=settings.local_llm_base_url,
+            )
 
     def complete(self, prompt: str, *, system_prompt: str | None = None) -> str:
         messages = []
@@ -28,11 +35,43 @@ class OpenAICompatibleClient:
         messages.append({"role": "user", "content": prompt})
 
         try:
-            response = self.client.chat.completions.create(
+            response = self._complete_with_client(
+                self.client,
                 model=self.settings.effective_openai_model,
-                temperature=0.1,
                 messages=messages,
             )
         except OpenAIError as exc:
-            raise LLMUnavailableError(self.settings.llm_unavailable_message) from exc
+            if self.fallback_client is not None:
+                logger.warning(
+                    "Hosted LLM request failed for model %s; falling back to local model %s: %s",
+                    self.settings.effective_openai_model,
+                    self.settings.local_llm_model,
+                    exc,
+                )
+                try:
+                    response = self._complete_with_client(
+                        self.fallback_client,
+                        model=self.settings.local_llm_model,
+                        messages=messages,
+                    )
+                except OpenAIError as fallback_exc:
+                    raise LLMUnavailableError(self.settings.hosted_then_local_llm_unavailable_message) from fallback_exc
+            else:
+                raise LLMUnavailableError(self.settings.llm_unavailable_message) from exc
         return response.choices[0].message.content or ""
+
+    def _build_client(self, *, api_key: str, base_url: str | None) -> OpenAI:
+        client_kwargs = {
+            "api_key": api_key,
+            "timeout": self.settings.openai_timeout_seconds,
+        }
+        if base_url:
+            client_kwargs["base_url"] = base_url
+        return OpenAI(**client_kwargs)
+
+    def _complete_with_client(self, client: OpenAI, *, model: str, messages: list[dict[str, str]]):
+        return client.chat.completions.create(
+            model=model,
+            temperature=0.1,
+            messages=messages,
+        )

sample_docs/Amar_Agnihotri_Resume.pdf

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

sample_docs/candidate_profiles_packet.pdf

@@ -1,95 +0,0 @@
-%PDF-1.4
-1 0 obj
-<< /Type /Catalog /Pages 2 0 R >>
-endobj
-2 0 obj
-<< /Type /Pages /Kids [3 0 R] /Count 1 >>
-endobj
-3 0 obj
-<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>
-endobj
-4 0 obj
-<< /Length 1306 >>
-stream
-BT
-/F1 11 Tf
-14 TL
-50 760 Td
-(Candidate Profiles Packet) Tj
-T*
-() Tj
-T*
-(Priya Nair) Tj
-T*
-() Tj
-T*
-(6 years experience. Built Python microservices with FastAPI, Celery, Redis, PostgreSQL, and) Tj
-T*
-(Docker. Led an incident reduction effort for asynchronous workflows.) Tj
-T*
-() Tj
-T*
-(Strengths: backend platform ownership, queue design, API reliability, production debugging.) Tj
-T*
-() Tj
-T*
-(Raghav Menon) Tj
-T*
-() Tj
-T*
-(5 years experience. Built semantic search and document question-answering systems using) Tj
-T*
-(sentence transformers, FAISS, reranking, and evaluation tooling.) Tj
-T*
-() Tj
-T*
-(Strengths: LLM products, retrieval quality tuning, prompt controls, source attribution.) Tj
-T*
-() Tj
-T*
-(Asha Kulkarni) Tj
-T*
-() Tj
-T*
-(7 years experience. Strong in Kubernetes, AWS, Terraform, CI/CD, and observability. Limited) Tj
-T*
-(recent Python API work and no direct Celery ownership.) Tj
-T*
-() Tj
-T*
-(Strengths: DevOps depth, platform automation. Risks: weaker application-layer backend fit.) Tj
-T*
-() Tj
-T*
-(Neel Shah) Tj
-T*
-() Tj
-T*
-(2 years experience. Built internal dashboards and simple Flask APIs. Good communication but) Tj
-T*
-(below the target experience band.) Tj
-T*
-() Tj
-T*
-(Strengths: learning speed. Risks: limited scale and insufficient backend depth for the role.) Tj
-T*
-() Tj
-ET
-endstream
-endobj
-5 0 obj
-<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
-endobj
-xref
-0 6
-0000000000 65535 f 
-0000000009 00000 n 
-0000000058 00000 n 
-0000000115 00000 n 
-0000000241 00000 n 
-0000001599 00000 n 
-trailer
-<< /Size 6 /Root 1 0 R >>
-startxref
-1669
-%%EOF