added

.dockerignore

@@ -0,0 +1,11 @@
+.env
+.git
+.gitignore
+.pytest_cache
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+insurance
+sample_invoice_*.pdf
+complete_claim_package_*.pdf

.env.example

@@ -0,0 +1,5 @@
+CLAIMS_LLM_PROVIDER=groq
+CLAIMS_LLM_MODEL=llama-3.3-70b-versatile
+GROQ_API_KEY=replace_with_your_groq_api_key
+REDIS_URL=redis://localhost:6379/0
+SELF_RAG_CONFIDENCE_THRESHOLD=0.75

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/app/.cache/huggingface \
+    TRANSFORMERS_CACHE=/app/.cache/huggingface
+
+WORKDIR /app
+
+# Tesseract is used when a PDF/image does not contain extractable text.
+# libgomp1 is needed by common ML wheels used by the retrieval stack.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        libgomp1 \
+        tesseract-ocr \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+RUN python -m pip install --upgrade pip \
+    && python -m pip install -r requirements.txt
+
+COPY app ./app
+COPY frontend ./frontend
+COPY data ./data
+COPY README.md .env.example ./
+
+RUN useradd --create-home --shell /usr/sbin/nologin claims \
+    && mkdir -p /app/.cache/huggingface \
+    && chown -R claims:claims /app
+
+USER claims
+
+EXPOSE 8000
+
+CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/__init__.py

@@ -0,0 +1 @@
+

app/main.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Annotated
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from app.services.claims import ClaimDecisionEngine
+from app.services.cache import LRUCache
+from app.services.llm import LLMUnavailableError
+from app.services.ocr import InvoiceExtractor
+from app.services.schemas import ClaimInput
+
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+load_dotenv(BASE_DIR / ".env")
+
+STATIC_DIR = BASE_DIR / "frontend"
+POLICY_PATH = BASE_DIR / "data" / "policies" / "bupa.pdf"
+
+app = FastAPI(title="AI Claims Processing System", version="1.0.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+invoice_extractor = InvoiceExtractor()
+invoice_fields_cache = LRUCache(max_size=128)
+decision_engine: ClaimDecisionEngine | None = None
+
+
+def get_decision_engine() -> ClaimDecisionEngine:
+    global decision_engine
+    if decision_engine is None:
+        try:
+            decision_engine = ClaimDecisionEngine(policy_path=POLICY_PATH)
+        except LLMUnavailableError as exc:
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+    return decision_engine
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(STATIC_DIR / "index.html")
+
+
+@app.get("/api/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.post("/api/extract-invoice")
+async def extract_invoice(invoice: Annotated[UploadFile, File(...)]) -> dict:
+    content = await invoice.read()
+    if not content:
+        raise HTTPException(status_code=400, detail="Invoice file is empty")
+
+    file_hash = hashlib.sha256(content).hexdigest()
+    extracted = invoice_extractor.extract(content, invoice.filename or "invoice.pdf")
+    invoice_fields_cache.set(file_hash, extracted)
+    return {"invoice_hash": file_hash, "fields": extracted.model_dump()}
+
+
+@app.post("/api/process-claim")
+async def process_claim(
+    patient_name: Annotated[str, Form()],
+    patient_address: Annotated[str, Form()],
+    date_of_treatment: Annotated[str, Form()],
+    medical_facility: Annotated[str, Form()],
+    claim_reason: Annotated[str, Form()],
+    claim_amount: Annotated[float, Form()],
+    claim_item: Annotated[str, Form()] = "General Practitioner",
+    invoice_hash: Annotated[str | None, Form()] = None,
+    invoice: Annotated[UploadFile | None, File()] = None,
+) -> dict:
+    upload_hash = invoice_hash
+    extracted_fields = None
+
+    if invoice is not None:
+        content = await invoice.read()
+        if content:
+            upload_hash = hashlib.sha256(content).hexdigest()
+            extracted_fields = invoice_fields_cache.get(upload_hash)
+            if extracted_fields is None:
+                extracted_fields = invoice_extractor.extract(content, invoice.filename or "invoice.pdf")
+                invoice_fields_cache.set(upload_hash, extracted_fields)
+    elif upload_hash:
+        extracted_fields = invoice_fields_cache.get(upload_hash)
+
+    claim = ClaimInput(
+        patient_name=patient_name.strip(),
+        patient_address=patient_address.strip(),
+        claim_item=claim_item.strip(),
+        date_of_treatment=date_of_treatment.strip(),
+        medical_facility=medical_facility.strip(),
+        claim_reason=claim_reason.strip(),
+        claim_amount=claim_amount,
+        invoice_hash=upload_hash,
+        extracted_invoice=extracted_fields,
+    )
+
+    return get_decision_engine().decide(claim).model_dump()

app/services/__init__.py

@@ -0,0 +1 @@
+

app/services/cache.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+
+def stable_hash(payload: Any) -> str:
+    serialized = json.dumps(payload, sort_keys=True, default=str)
+    return hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+
+
+class LRUCache:
+    def __init__(self, max_size: int = 256) -> None:
+        self.max_size = max_size
+        self._items: OrderedDict[str, Any] = OrderedDict()
+
+    def get(self, key: str) -> Any | None:
+        if key not in self._items:
+            return None
+        self._items.move_to_end(key)
+        return self._items[key]
+
+    def set(self, key: str, value: Any) -> None:
+        self._items[key] = value
+        self._items.move_to_end(key)
+        if len(self._items) > self.max_size:
+            self._items.popitem(last=False)
+
+
+@dataclass
+class SemanticCacheEntry:
+    vector: list[float]
+    value: Any
+
+
+class SemanticCache:
+    def __init__(self, threshold: float = 0.92, max_size: int = 128) -> None:
+        self.threshold = threshold
+        self.max_size = max_size
+        self._items: list[SemanticCacheEntry] = []
+
+    def get(self, vector: list[float]) -> Any | None:
+        if not self._items:
+            return None
+        query = np.array(vector, dtype=np.float32)
+        query_norm = np.linalg.norm(query)
+        if query_norm == 0:
+            return None
+
+        best_score = -1.0
+        best_value = None
+        for entry in self._items:
+            candidate = np.array(entry.vector, dtype=np.float32)
+            denom = query_norm * np.linalg.norm(candidate)
+            score = float(np.dot(query, candidate) / denom) if denom else 0.0
+            if score > best_score:
+                best_score = score
+                best_value = entry.value
+
+        return best_value if best_score >= self.threshold else None
+
+    def set(self, vector: list[float], value: Any) -> None:
+        self._items.append(SemanticCacheEntry(vector=vector, value=value))
+        if len(self._items) > self.max_size:
+            self._items.pop(0)
+
+
+class RedisSemanticCache:
+    def __init__(self, namespace: str, threshold: float = 0.92, max_size: int = 256) -> None:
+        self.namespace = namespace
+        self.threshold = threshold
+        self.max_size = max_size
+        self.enabled = False
+        self._redis = None
+
+        redis_url = os.getenv("REDIS_URL")
+        if not redis_url:
+            return
+
+        try:
+            import redis
+
+            self._redis = redis.Redis.from_url(redis_url, decode_responses=True)
+            self._redis.ping()
+            self.enabled = True
+        except Exception:
+            self._redis = None
+            self.enabled = False
+
+    def get(self, vector: list[float]) -> Any | None:
+        if not self.enabled or self._redis is None:
+            return None
+
+        query = np.array(vector, dtype=np.float32)
+        query_norm = np.linalg.norm(query)
+        if query_norm == 0:
+            return None
+
+        best_score = -1.0
+        best_value = None
+        index_key = f"{self.namespace}:index"
+        for item_key in self._redis.lrange(index_key, 0, -1):
+            raw = self._redis.get(item_key)
+            if not raw:
+                continue
+            item = json.loads(raw)
+            candidate = np.array(item["vector"], dtype=np.float32)
+            denom = query_norm * np.linalg.norm(candidate)
+            score = float(np.dot(query, candidate) / denom) if denom else 0.0
+            if score > best_score:
+                best_score = score
+                best_value = item["value"]
+
+        return best_value if best_score >= self.threshold else None
+
+    def set(self, vector: list[float], value: Any) -> None:
+        if not self.enabled or self._redis is None:
+            return
+
+        payload = {"vector": vector, "value": value}
+        item_key = f"{self.namespace}:item:{stable_hash(payload)}"
+        index_key = f"{self.namespace}:index"
+        self._redis.set(item_key, json.dumps(payload, default=str))
+        self._redis.lpush(index_key, item_key)
+        self._redis.ltrim(index_key, 0, self.max_size - 1)

app/services/claims.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import os
+import re
+from datetime import date, datetime
+from pathlib import Path
+
+from app.services.cache import LRUCache, RedisSemanticCache, SemanticCache, stable_hash
+from app.services.llm import ClaimLLMAgent
+from app.services.rag import PolicyRAG
+from app.services.schemas import Citation, ClaimDecision, ClaimInput
+
+
+CACHE_SCHEMA_VERSION = "claims-pipeline-v19-high-confidence-fast-path"
+
+
+class ClaimDecisionEngine:
+    def __init__(self, policy_path: Path) -> None:
+        self.rag = PolicyRAG(policy_path)
+        self.agent = ClaimLLMAgent()
+        self.exact_cache = LRUCache(max_size=256)
+        self.semantic_cache = SemanticCache(threshold=0.94, max_size=128)
+        self.redis_semantic_cache = RedisSemanticCache(
+            namespace=f"claims:{CACHE_SCHEMA_VERSION}:{stable_hash(self.rag.policy_version)}",
+            threshold=0.94,
+            max_size=256,
+        )
+        self.self_rag_confidence_threshold = self._confidence_threshold()
+
+    def decide(self, claim: ClaimInput) -> ClaimDecision:
+        pipeline_trace = {
+            "stage_1_ingestion_ocr": "completed before adjudication endpoint",
+            "stage_2_prefill_form": "completed in browser before submission",
+            "policy_version": self.rag.policy_version,
+            "cache": {"exact": "miss", "semantic_memory": "miss", "semantic_redis": "disabled"},
+        }
+        cache_payload = {
+            "cache_schema_version": CACHE_SCHEMA_VERSION,
+            "policy_version": self.rag.policy_version,
+            "claim": claim.model_dump(exclude={"extracted_invoice"}),
+        }
+        exact_key = stable_hash(cache_payload)
+        exact = self.exact_cache.get(exact_key)
+        if exact:
+            exact.cache_hit = True
+            exact.pipeline_trace["cache"] = {"exact": "hit"}
+            return exact
+
+        semantic_vector = self.rag.embed_query(self._claim_query(claim))
+        semantic_guard = self._semantic_guard(claim)
+        redis_semantic = self.redis_semantic_cache.get(semantic_vector)
+        if redis_semantic and redis_semantic.get("guard") == semantic_guard:
+            decision = ClaimDecision.model_validate(redis_semantic["decision"])
+            decision.cache_hit = True
+            decision.pipeline_trace["cache"] = {"semantic_redis": "hit"}
+            return decision
+
+        semantic = self.semantic_cache.get(semantic_vector)
+        if semantic and semantic.get("guard") == semantic_guard:
+            decision = semantic["decision"]
+            decision.cache_hit = True
+            decision.pipeline_trace["cache"] = {"semantic_memory": "hit"}
+            return decision
+        pipeline_trace["cache"]["semantic_redis"] = "miss" if self.redis_semantic_cache.enabled else "disabled"
+
+        retrieval_plan = self.agent.plan_retrieval(claim)
+        queries = self._build_retrieval_queries(retrieval_plan)
+        pipeline_trace["stage_4_query_rewriting"] = {
+            "route": retrieval_plan.route,
+            "hyde": bool(retrieval_plan.hyde_document),
+            "step_back_question": retrieval_plan.step_back_question,
+            "multi_query_count": len(retrieval_plan.rewritten_queries[:8]),
+            "metadata_filters": retrieval_plan.metadata_filters[:6],
+            "query_count": len(queries),
+        }
+
+        docs = self.rag.retrieve(queries)
+        pipeline_trace["stage_5_hybrid_retrieval"] = self.rag.last_retrieval_trace
+        pipeline_trace["stage_6_cross_encoder_reranking"] = {
+            "reranker": "FlashRank ms-marco-MiniLM-L-12-v2",
+            "top_k": min(len(docs), 12),
+        }
+        flags = self._validate_claim(claim)
+        flags.extend(retrieval_plan.document_checks[:8])
+
+        citations = self._docs_to_citations(docs[:12])
+        decision_draft = self.agent.decide(claim, citations, flags)
+        self_rag_trace = {
+            "threshold": self.self_rag_confidence_threshold,
+            "initial_confidence": decision_draft.confidence,
+            "mode": "skipped",
+            "iterations": [],
+        }
+        if decision_draft.confidence < self.self_rag_confidence_threshold:
+            self_rag_trace["mode"] = "triggered"
+            citations_changed = False
+            for iteration in range(1, 4):
+                evidence_grade = self.agent.grade_evidence(claim, citations)
+                evidence_sufficient = self._as_bool(evidence_grade.sufficient)
+                self_rag_trace["iterations"].append(
+                    {
+                        "iteration": iteration,
+                        "sufficient": evidence_sufficient,
+                        "relevance_check": evidence_grade.relevance_check,
+                        "grounding_check": evidence_grade.grounding_check,
+                        "hallucination_risk": evidence_grade.hallucination_risk,
+                        "contradiction_check": evidence_grade.contradiction_check,
+                        "missing_questions": evidence_grade.missing_questions[:5],
+                        "relevant_citation_indexes": evidence_grade.relevant_citation_indexes[:12],
+                    }
+                )
+                if evidence_sufficient or not evidence_grade.missing_questions:
+                    break
+
+                follow_up_docs = self.rag.retrieve(evidence_grade.missing_questions[:5])
+                follow_up_citations = self._docs_to_citations(follow_up_docs[:6])
+                updated_citations = self._dedupe_citations(citations + follow_up_citations)
+                citations_changed = citations_changed or len(updated_citations) > len(citations)
+                citations = updated_citations
+
+            if citations_changed:
+                decision_draft = self.agent.decide(claim, citations, flags)
+                self_rag_trace["redraft_confidence"] = decision_draft.confidence
+
+        pipeline_trace["stage_7_self_rag_loop"] = self_rag_trace
+
+        selected_citations = self._select_citations(citations, decision_draft.citation_indexes)
+        verification_citations = self._dedupe_citations(selected_citations + citations)[:12]
+        selected_citations = self._select_report_citations(selected_citations, verification_citations)
+        final_status = decision_draft.status
+        final_conclusion = decision_draft.conclusion
+        final_flags = self._dedupe_strings(flags + decision_draft.flags)
+        report = decision_draft
+
+        if self_rag_trace["mode"] == "skipped":
+            pipeline_trace["stage_7_final_grounding_verifier"] = "skipped for high-confidence fast path"
+            pipeline_trace["stage_8_verified_report_writer"] = "skipped; initial decision report reused"
+        else:
+            final_verification = self.agent.verify_decision(claim, verification_citations, decision_draft)
+            pipeline_trace["stage_7_final_grounding_verifier"] = final_verification.model_dump()
+            final_flags = self._dedupe_strings(final_flags + final_verification.verifier_notes)
+            verifier_grounded = self._as_bool(final_verification.grounded)
+            verifier_blocked = (
+                not verifier_grounded
+                or final_verification.hallucination_risk == "high"
+                or self._as_bool(final_verification.contradiction_found)
+            )
+            if verifier_blocked:
+                final_status = final_verification.corrected_status
+                final_conclusion = final_verification.corrected_conclusion
+            elif final_verification.corrected_status != decision_draft.status:
+                final_status = final_verification.corrected_status
+                final_conclusion = self._report_conclusion_from_verifier(
+                    claim=claim,
+                    corrected_status=final_verification.corrected_status,
+                    verifier_conclusion=final_verification.corrected_conclusion,
+                )
+
+            report = self.agent.write_report(
+                claim=claim,
+                citations=verification_citations,
+                status=final_status,
+            )
+            pipeline_trace["stage_8_verified_report_writer"] = "completed"
+
+        decision = ClaimDecision(
+            status=final_status,
+            confidence=decision_draft.confidence,
+            patient_name=claim.patient_name,
+            patient_address=claim.patient_address,
+            claim_item=claim.claim_item,
+            medical_facility=claim.medical_facility,
+            date_of_treatment=claim.date_of_treatment,
+            total_claim_amount=claim.claim_amount,
+            executive_summary=report.executive_summary,
+            introduction=report.introduction,
+            claim_description=(
+                f"{claim.patient_name} visited {claim.medical_facility} for {claim.claim_reason} "
+                f"and the total claim amount is {claim.claim_amount:g}."
+            ),
+            document_verification=report.document_verification,
+            document_summary=report.document_summary,
+            conclusion=report.conclusion,
+            reason_codes=decision_draft.reason_codes,
+            flags=final_flags,
+            citations=selected_citations,
+            pipeline_trace=pipeline_trace,
+        )
+
+        self.exact_cache.set(exact_key, decision)
+        self.semantic_cache.set(semantic_vector, {"guard": semantic_guard, "decision": decision})
+        self.redis_semantic_cache.set(
+            semantic_vector,
+            {"guard": semantic_guard, "decision": decision.model_dump()},
+        )
+        return decision
+
+    def _claim_query(self, claim: ClaimInput) -> str:
+        return " ".join(
+            [
+                claim.patient_address,
+                claim.claim_item,
+                claim.date_of_treatment,
+                claim.medical_facility,
+                claim.claim_reason,
+                str(claim.claim_amount),
+            ]
+        )
+
+    def _semantic_guard(self, claim: ClaimInput) -> str:
+        guard_payload = {
+            "patient_name": claim.patient_name.strip().lower(),
+            "date_of_treatment": claim.date_of_treatment.strip().lower(),
+            "medical_facility": claim.medical_facility.strip().lower(),
+            "claim_amount": round(float(claim.claim_amount), 2),
+            "policy_version": self.rag.policy_version,
+        }
+        return stable_hash(guard_payload)
+
+    def _confidence_threshold(self) -> float:
+        try:
+            threshold = float(os.getenv("SELF_RAG_CONFIDENCE_THRESHOLD", "0.75"))
+        except ValueError:
+            return 0.75
+        return min(max(threshold, 0.0), 1.0)
+
+    def _validate_claim(self, claim: ClaimInput) -> list[str]:
+        flags: list[str] = []
+        parsed_date = self._parse_date(claim.date_of_treatment)
+
+        if parsed_date is None:
+            flags.append("Treatment date could not be parsed.")
+        elif parsed_date > date.today():
+            flags.append("Treatment date is in the future.")
+        elif parsed_date.year < 1900:
+            flags.append("Treatment date is not realistic.")
+
+        if not claim.patient_name:
+            flags.append("Patient name is missing.")
+        if not claim.medical_facility:
+            flags.append("Medical facility is missing.")
+        if claim.claim_amount <= 0:
+            flags.append("Claim amount must be greater than zero.")
+        if not claim.patient_address:
+            flags.append("Patient address is missing.")
+        elif not self._looks_like_uk_address(claim.patient_address):
+            flags.append("Patient address is not clearly within the UK.")
+
+        extracted = claim.extracted_invoice
+        if extracted:
+            dob = self._parse_date(extracted.date_of_birth or "")
+            if dob and dob.year < 1900:
+                flags.append("Invoice date of birth is not realistic.")
+            if extracted.amount_payable is not None and abs(extracted.amount_payable - claim.claim_amount) > 1:
+                flags.append("Entered amount does not match invoice amount.")
+
+        return flags
+
+    def _parse_date(self, value: str) -> date | None:
+        if not value:
+            return None
+        for fmt in ("%Y-%m-%d", "%d/%m/%Y", "%m/%d/%Y", "%d-%m-%Y", "%m-%d-%Y"):
+            try:
+                return datetime.strptime(value.strip(), fmt).date()
+            except ValueError:
+                continue
+        match = re.search(r"(\d{4})-(\d{2})-(\d{2})", value)
+        if match:
+            try:
+                return datetime.strptime(match.group(0), "%Y-%m-%d").date()
+            except ValueError:
+                return None
+        return None
+
+    def _looks_like_uk_address(self, value: str) -> bool:
+        lower = value.lower()
+        uk_terms = ["united kingdom", " uk", "england", "scotland", "wales", "northern ireland", "london"]
+        return any(term in lower for term in uk_terms)
+
+    def _as_bool(self, value) -> bool:
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            return value.strip().lower() in {"true", "yes", "1"}
+        return bool(value)
+
+    def _short_excerpt(self, text: str) -> str:
+        compact = " ".join(text.split())
+        return compact[:320] + ("..." if len(compact) > 320 else "")
+
+    def _build_retrieval_queries(self, retrieval_plan) -> list[str]:
+        queries = [
+            retrieval_plan.hyde_document,
+            retrieval_plan.step_back_question,
+            *retrieval_plan.rewritten_queries[:8],
+            *retrieval_plan.required_policy_topics[:8],
+        ]
+        return [query for query in self._dedupe_strings(queries) if query]
+
+    def _docs_to_citations(self, docs) -> list[Citation]:
+        return [
+            Citation(
+                section=str(doc.metadata.get("section", "Policy")),
+                title=str(doc.metadata.get("title", "Policy clause")),
+                page=str(doc.metadata.get("page", "unknown")),
+                excerpt=self._short_excerpt(doc.page_content),
+            )
+            for doc in docs
+        ]
+
+    def _select_citations(self, citations: list[Citation], indexes: list[int]) -> list[Citation]:
+        selected = [citations[index] for index in indexes[:8] if 0 <= index < len(citations)]
+        return selected[:5] if selected else citations[:5]
+
+    def _select_report_citations(
+        self,
+        selected_citations: list[Citation],
+        verification_citations: list[Citation],
+    ) -> list[Citation]:
+        evidence = self._dedupe_citations(selected_citations + verification_citations)
+        policy_clauses = [
+            citation
+            for citation in evidence
+            if citation.section.lower().startswith(("benefit", "exclusion", "pre-authorisation", "eligibility"))
+        ]
+        return self._dedupe_citations(policy_clauses + evidence)[:5]
+
+    def _dedupe_citations(self, citations: list[Citation]) -> list[Citation]:
+        seen: set[str] = set()
+        deduped: list[Citation] = []
+        for citation in citations:
+            key = f"{citation.section}|{citation.page}|{citation.excerpt[:80]}"
+            if key not in seen:
+                seen.add(key)
+                deduped.append(citation)
+        return deduped
+
+    def _dedupe_strings(self, values: list[str]) -> list[str]:
+        seen: set[str] = set()
+        deduped: list[str] = []
+        for value in values:
+            if value and value not in seen:
+                seen.add(value)
+                deduped.append(value)
+        return deduped
+
+    def _report_conclusion_from_verifier(
+        self,
+        claim: ClaimInput,
+        corrected_status: str,
+        verifier_conclusion: str,
+    ) -> str:
+        if corrected_status == "Approved":
+            return (
+                f"The claim submitted by {claim.patient_name} for {claim.claim_reason} treatment at "
+                f"{claim.medical_facility} has been approved based on the submitted claim documents "
+                "and the retrieved policy evidence."
+            )
+        if corrected_status == "Rejected":
+            return (
+                f"The claim submitted by {claim.patient_name} for {claim.claim_reason} treatment at "
+                f"{claim.medical_facility} has been rejected based on the submitted claim documents "
+                "and the retrieved policy evidence."
+            )
+        return verifier_conclusion

app/services/llm.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import os
+import json
+from typing import Literal
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from pydantic import BaseModel, ConfigDict, Field
+
+from app.services.schemas import Citation, ClaimInput
+
+
+class LLMUnavailableError(RuntimeError):
+    pass
+
+
+class RetrievalPlan(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    route: Literal["health_claim", "cash_benefit", "exclusion_check", "human_review"]
+    hyde_document: str = Field(description="A short hypothetical policy passage that would answer this claim.")
+    step_back_question: str = Field(description="A broader policy question behind the claim.")
+    rewritten_queries: list[str] = Field(default_factory=list)
+    required_policy_topics: list[str] = Field(default_factory=list)
+    metadata_filters: list[str] = Field(default_factory=list)
+    document_checks: list[str] = Field(default_factory=list)
+
+
+class EvidenceGrade(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    sufficient: str = Field(description="Use 'true' or 'false'.")
+    relevance_check: str
+    grounding_check: str
+    hallucination_risk: Literal["low", "medium", "high"]
+    contradiction_check: str
+    missing_questions: list[str] = Field(default_factory=list)
+    relevant_citation_indexes: list[int] = Field(default_factory=list)
+
+
+class DecisionDraft(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    status: Literal["Approved", "Rejected", "Needs Human Review"]
+    confidence: float = Field(ge=0, le=1)
+    executive_summary: str = Field(
+        description="A report-ready paragraph summarizing the claim and decision basis.",
+    )
+    introduction: str = Field(
+        description="A report-ready paragraph introducing the claim analysis and decision.",
+    )
+    document_verification: str = Field(
+        description="A paragraph describing whether the submitted claim documents were verified."
+    )
+    document_summary: str = Field(
+        description="A paragraph summarizing the submitted claim documents and material facts."
+    )
+    conclusion: str = Field(
+        description="A comprehensive report paragraph stating the final status and evidence basis."
+    )
+    reason_codes: list[str] = Field(default_factory=list)
+    flags: list[str] = Field(default_factory=list)
+    citation_indexes: list[int] = Field(default_factory=list)
+
+
+class FinalVerification(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    grounded: str = Field(description="Use 'true' or 'false'.")
+    hallucination_risk: Literal["low", "medium", "high"]
+    contradiction_found: str = Field(description="Use 'true' or 'false'.")
+    corrected_status: Literal["Approved", "Rejected", "Needs Human Review"]
+    corrected_conclusion: str
+    verifier_notes: list[str] = Field(default_factory=list)
+
+
+class ReportDraft(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    executive_summary: str = Field(description="A report-ready executive summary paragraph.")
+    introduction: str = Field(description="A report-ready introduction paragraph.")
+    document_verification: str = Field(description="A report-ready document verification paragraph.")
+    document_summary: str = Field(description="A report-ready document summary paragraph.")
+    conclusion: str = Field(description="A comprehensive final conclusion paragraph.")
+
+
+def get_claims_llm() -> BaseChatModel:
+    provider = os.getenv("CLAIMS_LLM_PROVIDER", "").strip().lower()
+
+    if not provider:
+        if os.getenv("OPENAI_API_KEY"):
+            provider = "openai"
+        elif os.getenv("GROQ_API_KEY"):
+            provider = "groq"
+
+    if provider == "openai":
+        from langchain_openai import ChatOpenAI
+
+        return ChatOpenAI(
+            model=os.getenv("CLAIMS_LLM_MODEL", "gpt-4o-mini"),
+            temperature=0,
+        )
+
+    if provider == "groq":
+        from langchain_groq import ChatGroq
+
+        api_key = os.getenv("GROQ_API_KEY", "")
+        if not api_key or api_key == "replace_with_your_groq_api_key":
+            raise LLMUnavailableError("Set a real GROQ_API_KEY in .env before processing claims.")
+
+        return ChatGroq(
+            model=os.getenv("CLAIMS_LLM_MODEL", "llama-3.3-70b-versatile"),
+            temperature=0,
+        )
+
+    raise LLMUnavailableError(
+        "No claims LLM configured. Set OPENAI_API_KEY or GROQ_API_KEY, or set CLAIMS_LLM_PROVIDER."
+    )
+
+
+class ClaimLLMAgent:
+    def __init__(self) -> None:
+        self.llm = get_claims_llm()
+        self.use_json_mode = "groq" in self.llm.__class__.__module__.lower()
+
+    def plan_retrieval(self, claim: ClaimInput) -> RetrievalPlan:
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "You are an insurance claim retrieval router. Route the claim and rewrite it into precise "
+                    "policy-search questions. Use HyDE, multi-query expansion, and step-back abstraction. "
+                    "Do not decide the claim. Do not invent policy clauses. Ask for the evidence needed "
+                    "to approve, reject, or route to human review. For Bupa health claims, always retrieve "
+                    "evidence for: cover requirements, eligible treatment, outpatient consultations for acute "
+                    "conditions, pre-authorisation, recognised consultants/facilities, outpatient medicines or "
+                    "drug exclusions, and any relevant exclusions/exceptions. If uploaded claim documents "
+                    "include an outpatient prescription or medicine charge, search specifically with the policy "
+                    "terms 'outpatient drugs', 'drugs prescribed for outpatient treatment', and drug exclusions. "
+                    "If the patient address, facility location, claim text, or uploaded documents indicate a "
+                    "country outside the UK, search specifically for UK residency eligibility and overseas "
+                    "treatment exclusions using the policy terms 'resident in the UK throughout the duration "
+                    "of your cover' and 'overseas treatment outside of the UK'. "
+                    "The policy may cover categories "
+                    "such as acute conditions even when the exact diagnosis name is not listed.",
+                ),
+                (
+                    "human",
+                    "Claim:\n{claim}\n\nReturn a retrieval plan for a Bupa health insurance policy guide.\n"
+                    "Return valid JSON matching this schema:\n{schema}",
+                ),
+            ]
+        )
+        chain = self._structured_chain(prompt, RetrievalPlan)
+        return chain.invoke(
+            {
+                "claim": claim.model_dump_json(indent=2),
+                "schema": self._schema_text(RetrievalPlan),
+            }
+        )
+
+    def grade_evidence(self, claim: ClaimInput, citations: list[Citation]) -> EvidenceGrade:
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "You are a Self-RAG evidence grader. Decide whether the retrieved policy evidence is enough "
+                    "to support a claim decision. Perform relevance check, grounding check, contradiction "
+                    "check, and hallucination-risk assessment. Use only the supplied citations. If evidence "
+                    "is missing or weak, write follow-up retrieval questions. For an acute outpatient claim, "
+                    "evidence can be sufficient if the citations establish the general cover class and relevant "
+                    "conditions/exclusions; do not require the policy to name the exact diagnosis if the claim "
+                    "document identifies it as acute. Evidence rules: (1) Treat a claim reason or uploaded "
+                    "document diagnosis that says acute as evidence that the claim is presented as acute. "
+                    "(2) Policy citations do not need to repeat a patient-specific claim amount; invoice text "
+                    "supports claimed amounts. (3) If the claim documents include billed outpatient medicines "
+                    "or a prescription, return sufficient='false' unless the supplied citations include the "
+                    "policy rule that covers or excludes outpatient drugs. A definition of common drugs alone "
+                    "is not that rule. (4) If the claim documents include a billed diagnostic test, return "
+                    "sufficient='false' unless a citation covers or excludes outpatient diagnostic tests. "
+                    "(5) If the patient address, treatment facility, claim text, or uploaded documents show "
+                    "a non-UK country, return sufficient='false' unless the citations include the UK residency "
+                    "eligibility rule or the overseas treatment rule.",
+                ),
+                (
+                    "human",
+                    "Claim:\n{claim}\n\nRetrieved citations:\n{citations}\n\n"
+                    "Return valid JSON matching this schema:\n{schema}",
+                ),
+            ]
+        )
+        chain = self._structured_chain(prompt, EvidenceGrade)
+        return chain.invoke(
+            {
+                "claim": claim.model_dump_json(indent=2),
+                "citations": _format_citations(citations),
+                "schema": self._schema_text(EvidenceGrade),
+            }
+        )
+
+    def decide(self, claim: ClaimInput, citations: list[Citation], validation_flags: list[str]) -> DecisionDraft:
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "You are an insurance claims adjudication assistant. Decide Approved, Rejected, or "
+                    "Needs Human Review using only the provided policy citations and validation flags. "
+                    "Reject only when the citations support rejection. Approve only when the citations support "
+                    "coverage and required claim conditions. If evidence is incomplete or conflicting, choose "
+                    "Needs Human Review. The claim JSON may include uploaded document text; treat invoice, "
+                    "prescription, medical report, payment receipt, and pre-authorisation text as claim-document "
+                    "evidence, while policy citations define the rules. Do not require the policy to name the "
+                    "exact diagnosis when it covers the broader class, such as acute outpatient consultation. "
+                    "Do not require patient-specific amounts to appear in policy citations; amounts come from "
+                    "claim documents. Do not require separate medical-necessity proof unless the cited policy "
+                    "rule requires it and the claim documents do not provide it. "
+                    "Use facts in the claim documents to connect policy rules to the claim. Do not apply an "
+                    "A&E, accident and emergency, urgent-care, or walk-in exclusion unless the claim documents "
+                    "say the treatment followed one of those routes. If the documents show treatment outside "
+                    "the UK and policy evidence excludes overseas treatment, apply that rule unless the "
+                    "supplied evidence supports the stated exception. "
+                    "If part of the amount is excluded, explain the payable/limited portion rather than failing "
+                    "the whole claim automatically. Write report-ready prose for executive_summary, "
+                    "introduction, document_verification, document_summary, and conclusion. The conclusion "
+                    "must be a comprehensive paragraph of two to four sentences that states the claim status, "
+                    "the submitted treatment facts, the document verification result, and the policy-evidence "
+                    "basis. Do not return shorthand conclusions such as 'Claim approved' or 'Claim is valid'. "
+                    "Keep each section suitable for the centered report UI. "
+                    "Do not say a service or medicine is covered unless the supplied policy citations support "
+                    "that statement. A definition of common drugs does not by itself prove an outpatient "
+                    "medicine charge is covered. If a cited exclusion conflicts with a claimed item, state that limitation. "
+                    "The report fields may be shown directly to the claimant on high-confidence decisions. "
+                    "Keep them customer-facing: do not mention Self-RAG, grounding, hallucination checks, "
+                    "internal verification stages, proposed decisions, citation indexes such as [3], or policy "
+                    "chunk numbers. If policy evidence supports one part of a bill but excludes another, "
+                    "name the benefit or exclusion plainly and avoid repeating the same human-review sentence. "
+                    "Do not reveal hidden reasoning.",
+                ),
+                (
+                    "human",
+                    "Claim:\n{claim}\n\nValidation flags:\n{flags}\n\nPolicy citations:\n{citations}\n\n"
+                    "Return valid JSON matching this schema:\n{schema}",
+                ),
+            ]
+        )
+        chain = self._structured_chain(prompt, DecisionDraft)
+        return chain.invoke(
+            {
+                "claim": claim.model_dump_json(indent=2),
+                "flags": "\n".join(f"- {flag}" for flag in validation_flags) or "None",
+                "citations": _format_citations(citations),
+                "schema": self._schema_text(DecisionDraft),
+            }
+        )
+
+    def verify_decision(
+        self,
+        claim: ClaimInput,
+        citations: list[Citation],
+        decision: DecisionDraft,
+    ) -> FinalVerification:
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "You are the final Self-RAG verifier. Check whether the proposed claim decision is grounded "
+                    "in the supplied claim documents and policy citations. Verification rules: "
+                    "(1) Claim-document text proves patient facts such as invoice amount, treatment date, "
+                    "diagnosis, medical report, prescription, payment, and pre-authorisation. Policy citations "
+                    "prove coverage rules. Never require a patient-specific claim amount to appear in policy text. "
+                    "(2) A policy citation for outpatient consultations for acute conditions can ground an "
+                    "acute outpatient consultation even if it does not name the exact diagnosis. "
+                    "(3) Treat a claim reason or uploaded diagnosis that says acute as evidence that the claim "
+                    "is presented as acute. Never say the documents omit acute status when that text is present. "
+                    "(4) Do not require separate medical-necessity proof unless the cited policy rule requires it. "
+                    "(5) A common-drugs definition does not by itself prove an outpatient prescription charge "
+                    "is covered; use a citation that covers or excludes outpatient drugs. Verify against all "
+                    "supplied citations, not only the first broad policy citation. "
+                    "(6) Do not apply A&E, urgent-care, or walk-in exclusions unless claim documents identify "
+                    "that treatment route. If claim documents show treatment outside the UK and policy evidence "
+                    "contains the overseas-treatment exclusion, use that rule unless exception evidence is supplied. "
+                    "If the decision is not grounded, correct it to Needs Human Review. When you write corrected_conclusion, use a "
+                    "report-ready paragraph rather than a one-line status.",
+                ),
+                (
+                    "human",
+                    "Claim:\n{claim}\n\nProposed decision:\n{decision}\n\nPolicy citations:\n{citations}\n\n"
+                    "Return valid JSON matching this schema:\n{schema}",
+                ),
+            ]
+        )
+        chain = self._structured_chain(prompt, FinalVerification)
+        return chain.invoke(
+            {
+                "claim": claim.model_dump_json(indent=2),
+                "decision": decision.model_dump_json(indent=2),
+                "citations": _format_citations(citations),
+                "schema": self._schema_text(FinalVerification),
+            }
+        )
+
+    def write_report(
+        self,
+        claim: ClaimInput,
+        citations: list[Citation],
+        status: str,
+    ) -> ReportDraft:
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "You write the visible insurance claim report after adjudication and Self-RAG "
+                    "verification. The verified status is authoritative. Use the claim-document text for "
+                    "invoice, prescription, report, payment, and pre-authorisation facts. Use the policy "
+                    "evidence for coverage rules. The executive summary, introduction, verification, "
+                    "summary, and conclusion must agree with the verified status. Do not say that an item "
+                    "is covered when the supplied policy citations do not support it. Do not require an exact "
+                    "diagnosis name in policy text when a citation covers the broader treatment class such as "
+                    "acute outpatient consultations. If the claim or uploaded documents state that the "
+                    "condition is acute, do not say that the documents omit that fact. A common-drugs "
+                    "definition does not by itself make an outpatient prescription charge covered. If a cited exclusion affects a billed item, explain that "
+                    "policy limitation clearly. The conclusion must be two to four sentences and be suitable "
+                    "for a formal centered report UI. Policy citations do not need to include the patient "
+                    "specific claim amount; that amount belongs in the claim documents. Keep the report "
+                    "customer-facing: do not mention Self-RAG, grounding, hallucination checks, internal "
+                    "verification stages, proposed decisions, citation indexes such as [3], or policy chunk "
+                    "numbers. If you need to mention evidence, use natural policy names such as outpatient "
+                    "consultation benefit or outpatient drugs exclusion. When policy evidence supports one "
+                    "part of the bill but excludes another billed item, explain the covered and excluded "
+                    "parts plainly and say human review is needed only to determine the payable amount or "
+                    "final handling of the mixed claim. If an outpatient drugs exclusion is supplied and "
+                    "the bill includes prescribed outpatient medicines, say that the medicine charge is "
+                    "excluded or not covered under that exclusion; do not soften it to 'may be limited'. "
+                    "Do not say 'policy citations' in the customer report; say 'policy evidence', 'policy "
+                    "terms', or name the relevant benefit or exclusion. Do not repeat the same human-review "
+                    "sentence within a section. Describe document review as completeness and consistency "
+                    "checking unless the document text itself proves authenticity. Do not mention A&E, "
+                    "urgent-care, or walk-in exclusions unless the claim documents state that treatment route. "
+                    "If the documents show treatment outside the UK and the supplied evidence contains the "
+                    "overseas-treatment exclusion or UK residency eligibility rule, explain that directly. "
+                    "Do not reveal hidden reasoning.",
+                ),
+                (
+                    "human",
+                    "Verified status: {status}\n\nClaim:\n{claim}\n\nPolicy evidence:\n{citations}\n\n"
+                    "Return valid JSON matching this schema:\n{schema}",
+                ),
+            ]
+        )
+        chain = self._structured_chain(prompt, ReportDraft)
+        return chain.invoke(
+            {
+                "status": status,
+                "claim": claim.model_dump_json(indent=2),
+                "citations": _format_citations(citations, include_indexes=False),
+                "schema": self._schema_text(ReportDraft),
+            }
+        )
+
+    def _schema_text(self, schema: type[BaseModel]) -> str:
+        return json.dumps(schema.model_json_schema(), indent=2)
+
+    def _structured_chain(self, prompt: ChatPromptTemplate, schema: type[BaseModel]):
+        if self.use_json_mode:
+            # Groq function-calling can reject a response before Pydantic can ignore
+            # harmless extra keys. JSON mode keeps the schema enforcement local.
+            parser = PydanticOutputParser(pydantic_object=schema)
+            return prompt | self.llm.bind(response_format={"type": "json_object"}) | parser
+        return prompt | self.llm.with_structured_output(schema)
+
+
+def _format_citations(citations: list[Citation], include_indexes: bool = True) -> str:
+    lines: list[str] = []
+    for index, citation in enumerate(citations):
+        prefix = f"[{index}] " if include_indexes else ""
+        lines.append(f"{prefix}{citation.section} - {citation.title}, page {citation.page}\n{citation.excerpt}")
+    return "\n\n".join(lines)

app/services/ocr.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import io
+import re
+import tempfile
+from pathlib import Path
+
+import fitz
+from langchain_core.prompts import ChatPromptTemplate
+from PIL import Image
+
+from app.services.llm import LLMUnavailableError, get_claims_llm
+from app.services.schemas import InvoiceFields
+
+
+class InvoiceExtractor:
+    def extract(self, content: bytes, filename: str) -> InvoiceFields:
+        is_pdf = filename.lower().endswith(".pdf")
+        fast_text = self._extract_pdf_text(content) if is_pdf else ""
+        fast_fields = self._parse_invoice_text(fast_text)
+        if self._has_prefill_fields(fast_fields):
+            return fast_fields
+
+        docling_text = self._extract_docling_text(content, filename)
+        docling_fields = self._parse_invoice_text(docling_text)
+        text = docling_text if len(docling_text.strip()) >= len(fast_text.strip()) else fast_text
+        fallback = self._merge_fields(primary=docling_fields, fallback=fast_fields)
+        if self._has_prefill_fields(fallback):
+            return fallback
+
+        if len(text.strip()) < 30:
+            text = self._ocr_bytes(content, filename)
+            fallback = self._merge_fields(primary=self._parse_invoice_text(text), fallback=fallback)
+            if self._has_prefill_fields(fallback):
+                return fallback
+
+        structured = self._extract_fields_with_langchain(text)
+        return self._merge_fields(primary=structured, fallback=fallback)
+
+    def _extract_docling_text(self, content: bytes, filename: str) -> str:
+        suffix = Path(filename).suffix or ".pdf"
+        try:
+            from docling.datamodel.base_models import InputFormat
+            from docling.datamodel.pipeline_options import PdfPipelineOptions
+            from docling.document_converter import DocumentConverter, PdfFormatOption
+        except Exception:
+            return ""
+
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                tmp.write(content)
+                tmp_path = Path(tmp.name)
+
+            try:
+                if suffix.lower() == ".pdf":
+                    options = PdfPipelineOptions()
+                    options.do_ocr = False
+                    options.do_table_structure = True
+                    converter = DocumentConverter(
+                        format_options={
+                            InputFormat.PDF: PdfFormatOption(pipeline_options=options),
+                        }
+                    )
+                else:
+                    converter = DocumentConverter()
+
+                result = converter.convert(tmp_path)
+                return result.document.export_to_markdown()
+            finally:
+                tmp_path.unlink(missing_ok=True)
+        except Exception:
+            return ""
+
+    def _extract_fields_with_langchain(self, text: str) -> InvoiceFields | None:
+        if len(text.strip()) < 30:
+            return None
+
+        try:
+            llm = get_claims_llm()
+        except LLMUnavailableError:
+            return None
+        except Exception:
+            return None
+
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "Extract hospital invoice and claim-package fields into the provided schema. "
+                    "Use only the document text. If a field is absent, return null. "
+                    "Normalize dates only when clear. Keep raw_text as the original document text.",
+                ),
+                ("human", "Document text:\n{text}"),
+            ]
+        )
+
+        try:
+            chain = prompt | llm.with_structured_output(InvoiceFields)
+            extracted = chain.invoke({"text": text[:12000]})
+            extracted.raw_text = text
+            return extracted
+        except Exception:
+            return None
+
+    def _extract_pdf_text(self, content: bytes) -> str:
+        try:
+            with fitz.open(stream=content, filetype="pdf") as doc:
+                return "\n".join(page.get_text("text") for page in doc)
+        except Exception:
+            return ""
+
+    def _ocr_bytes(self, content: bytes, filename: str) -> str:
+        try:
+            import pytesseract
+        except Exception:
+            return ""
+
+        try:
+            if filename.lower().endswith(".pdf"):
+                with tempfile.TemporaryDirectory() as tmpdir:
+                    pdf = fitz.open(stream=content, filetype="pdf")
+                    parts: list[str] = []
+                    for page in pdf:
+                        pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))
+                        path = Path(tmpdir) / f"page-{page.number}.png"
+                        pix.save(path)
+                        parts.append(pytesseract.image_to_string(Image.open(path)))
+                    return "\n".join(parts)
+
+            return pytesseract.image_to_string(Image.open(io.BytesIO(content)))
+        except Exception:
+            return ""
+
+    def _parse_invoice_text(self, text: str) -> InvoiceFields:
+        clean = re.sub(r"[ \t]+", " ", text)
+
+        def first(patterns: list[str]) -> str | None:
+            for pattern in patterns:
+                match = re.search(pattern, clean, flags=re.IGNORECASE)
+                if match:
+                    return match.group(1).strip(" :-\n\t")
+            return None
+
+        def money(patterns: list[str]) -> float | None:
+            value = first(patterns)
+            if value is None:
+                return None
+            amount_match = re.search(r"[\d,.]+", value)
+            return float(amount_match.group(0).replace(",", "")) if amount_match else None
+
+        facility = first([r"##\s*([A-Z][A-Z ]+HOSPITALS?)", r"^\s*([A-Z][A-Z ]+HOSPITALS?)", r"Medical Facility[:\s]+([^\n]+)"])
+        patient_name = first([r"(?:Patient )?Name[:\s-]+(.+?)(?=\s+-?\s*Date of Birth|\s+DOB|\n|$)"])
+        dob = first([r"Date of Birth[:\s-]+([0-9/\-]+)", r"DOB[:\s-]+([0-9/\-]+)"])
+        address = first([r"Address[:\s-]+(.+?)(?=\s+-?\s*Phone|\n|$)"])
+        phone = first([r"Phone Number[:\s-]+(.+?)(?=\s+-?\s*Policy Number|\s+Service Details|\n|$)", r"Phone[:\s-]+(.+?)(?=\s+-?\s*Policy Number|\s+Service Details|\n|$)"])
+        date_of_service = first([r"Date of Service[:\s-]+([0-9/\-]+)", r"Date of Treatment[:\s-]+([0-9/\-]+)"])
+        diagnosis = first([r"Diagnosis[:\s-]+(.+?)(?=\s+-?\s*Treatment Type|\s+Prescribed Medicines|\s+Details:|\n|$)", r"Claim Reason[:\s-]+([^\n]+)"])
+        total = money([r"Amount payable[:\s=-]+([^\n]+)", r"Total charge[:\s=-]+([^\n]+)", r"Total Claim Amount[:\s=-]+([^\n]+)"])
+        doctor_fee = money([r"Doctor'?s (?:consultation )?fee\s*[-:=]\s*([0-9,.]+)", r"Doctor'?s fee[:\s=-]+(.+?)(?=\s+Medicines?|\n|$)"])
+        medicine_cost = money([r"Prescribed medicines\s*[-:=]\s*([0-9,.]+)", r"Medicines?\s*[-:=]\s*([0-9,.]+)", r"Medicine cost\s*[-:=]\s*([0-9,.]+)"])
+
+        return InvoiceFields(
+            raw_text=text,
+            patient_name=patient_name,
+            date_of_birth=dob,
+            address=address,
+            phone=phone,
+            date_of_treatment=date_of_service,
+            diagnosis=diagnosis,
+            medical_facility=facility,
+            doctor_fee=doctor_fee,
+            medicine_cost=medicine_cost,
+            amount_payable=total,
+        )
+
+    def _merge_fields(self, primary: InvoiceFields | None, fallback: InvoiceFields) -> InvoiceFields:
+        if primary is None:
+            return fallback
+
+        data = primary.model_dump()
+        fallback_data = fallback.model_dump()
+        for key, value in data.items():
+            if value in (None, "") and fallback_data.get(key) not in (None, ""):
+                data[key] = fallback_data[key]
+
+        # Payable amount is the correct claim amount when both total charge and discounted amount exist.
+        if fallback.amount_payable is not None and re.search(r"amount payable", fallback.raw_text, flags=re.IGNORECASE):
+            data["amount_payable"] = fallback.amount_payable
+
+        # Regex fallback is often more precise for flattened Docling invoice lines.
+        for key in ("patient_name", "date_of_birth", "address", "phone", "date_of_treatment", "diagnosis", "medical_facility"):
+            if fallback_data.get(key) not in (None, ""):
+                data[key] = fallback_data[key]
+
+        if not data.get("raw_text"):
+            data["raw_text"] = fallback.raw_text
+        return InvoiceFields(**data)
+
+    def _has_prefill_fields(self, fields: InvoiceFields) -> bool:
+        required = (
+            fields.patient_name,
+            fields.address,
+            fields.date_of_treatment,
+            fields.diagnosis,
+            fields.medical_facility,
+            fields.amount_payable,
+        )
+        return all(value not in (None, "") for value in required)

app/services/rag.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import fitz
+from langchain_core.documents import Document
+from langchain_community.retrievers import BM25Retriever
+from langchain_community.vectorstores import FAISS
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+
+_POLICY_DOCUMENT_CACHE: dict[str, list[Document]] = {}
+
+
+class PolicyRAG:
+    def __init__(self, policy_path: Path) -> None:
+        self.policy_path = policy_path
+        self.policy_version = self._policy_version()
+        self.last_retrieval_trace: list[dict[str, Any]] = []
+        self.documents = self._load_documents()
+        self.embeddings = None
+        self.reranker = None
+        self.bm25_retriever, self.dense_retriever = self._build_retrievers()
+
+    def _policy_version(self) -> str:
+        stat = self.policy_path.stat()
+        return f"{self.policy_path.name}:{stat.st_size}:{int(stat.st_mtime)}"
+
+    def _load_documents(self) -> list[Document]:
+        cache_key = self.policy_version
+        if cache_key in _POLICY_DOCUMENT_CACHE:
+            return _POLICY_DOCUMENT_CACHE[cache_key]
+
+        docs = self._load_pdf_documents() if self.policy_path.suffix.lower() == ".pdf" else self._load_text_documents()
+
+        splitter = RecursiveCharacterTextSplitter(chunk_size=900, chunk_overlap=150)
+        split_docs = splitter.split_documents(docs)
+        _POLICY_DOCUMENT_CACHE[cache_key] = split_docs
+        return split_docs
+
+    def _load_text_documents(self) -> list[Document]:
+        raw = self.policy_path.read_text(encoding="utf-8")
+        docs: list[Document] = []
+        section = "Policy"
+        title = "Bupa Health policy"
+        page = "unknown"
+        buffer: list[str] = []
+
+        def flush() -> None:
+            if buffer:
+                docs.append(
+                    Document(
+                        page_content="\n".join(buffer).strip(),
+                        metadata={"section": section, "title": title, "page": page, "source": str(self.policy_path)},
+                    )
+                )
+
+        for line in raw.splitlines():
+            if line.startswith("## "):
+                flush()
+                buffer = []
+                heading = line[3:].strip()
+                pieces = [part.strip() for part in heading.split("|")]
+                section = pieces[0]
+                title = pieces[1] if len(pieces) > 1 else pieces[0]
+                page = pieces[2].replace("page", "").strip() if len(pieces) > 2 else "unknown"
+            elif line.strip():
+                buffer.append(line.strip())
+        flush()
+        return docs
+
+    def _load_pdf_documents(self) -> list[Document]:
+        docs: list[Document] = []
+        with fitz.open(self.policy_path) as pdf:
+            for page_index, page in enumerate(pdf, start=1):
+                text = page.get_text("text")
+                if not text.strip():
+                    continue
+                for block_index, block in enumerate(self._split_policy_page(text), start=1):
+                    section, title = self._infer_section_title(block, page_index, block_index)
+                    docs.append(
+                        Document(
+                            page_content=block,
+                            metadata={
+                                "section": section,
+                                "title": title,
+                                "page": str(page_index),
+                                "source": str(self.policy_path),
+                            },
+                        )
+                    )
+        if not docs:
+            raise ValueError(f"No text could be extracted from policy PDF: {self.policy_path}")
+        return docs
+
+    def _split_policy_page(self, text: str) -> list[str]:
+        lines = [line.strip() for line in text.splitlines() if line.strip()]
+        blocks: list[list[str]] = []
+        current: list[str] = []
+
+        for line in lines:
+            is_heading = self._looks_like_heading(line)
+            if is_heading and current:
+                blocks.append(current)
+                current = [line]
+            else:
+                current.append(line)
+
+        if current:
+            blocks.append(current)
+
+        merged: list[str] = []
+        buffer = ""
+        for block in blocks:
+            candidate = " ".join(block)
+            if len(buffer) < 260:
+                buffer = f"{buffer} {candidate}".strip()
+            else:
+                merged.append(buffer)
+                buffer = candidate
+        if buffer:
+            merged.append(buffer)
+        return merged
+
+    def _looks_like_heading(self, line: str) -> bool:
+        if len(line) > 90:
+            return False
+        lower = line.lower()
+        heading_terms = [
+            "benefit",
+            "exclusion",
+            "what is covered",
+            "what isn't covered",
+            "what isnt covered",
+            "eligibility",
+            "pre-authorisation",
+            "pre-authorization",
+            "claim",
+            "complain",
+            "definition",
+            "privacy",
+        ]
+        numbered = line[:2].strip(".").isdigit() or line[:3].strip(".").isdigit()
+        title_case = line[:1].isupper() and sum(1 for char in line if char.isalpha()) > 4
+        return numbered or any(term in lower for term in heading_terms) or (title_case and len(line.split()) <= 7)
+
+    def _infer_section_title(self, block: str, page_index: int, block_index: int) -> tuple[str, str]:
+        first = block.split(". ")[0].strip()
+        first = first[:80] if first else f"Policy page {page_index}"
+        lower = block.lower()
+        numbered_exclusion = self._extract_numbered_exclusion(block)
+
+        if numbered_exclusion:
+            section = numbered_exclusion
+        elif "exclusion" in lower:
+            section = self._extract_labeled_section(block, "Exclusion") or f"Exclusion evidence p{page_index}.{block_index}"
+        elif "benefit" in lower:
+            section = self._extract_labeled_section(block, "Benefit") or f"Benefit evidence p{page_index}.{block_index}"
+        elif "pre-authorisation" in lower or "pre-authorization" in lower:
+            section = "Pre-authorisation"
+        elif "eligib" in lower or "resident in the uk" in lower:
+            section = "Eligibility"
+        else:
+            section = f"Policy p{page_index}.{block_index}"
+
+        return section, first
+
+    def _extract_labeled_section(self, block: str, label: str) -> str | None:
+        import re
+
+        match = re.search(rf"\b({label})\s+([A-Z]?[A-Z0-9.]+)?", block, flags=re.IGNORECASE)
+        if not match:
+            return None
+        suffix = (match.group(2) or "").strip()
+        return f"{label} {suffix}".strip()
+
+    def _extract_numbered_exclusion(self, block: str) -> str | None:
+        import re
+
+        lower = block.lower()
+        if "not covered" not in lower and "isn" not in lower and "arent covered" not in lower:
+            return None
+        match = re.match(r"\s*(\d{1,2})\s+[A-Z]", block)
+        return f"Exclusion {match.group(1)}" if match else None
+
+    def _build_retrievers(self):
+        bm25 = BM25Retriever.from_documents(self.documents)
+        bm25.k = 10
+
+        try:
+            from langchain_community.embeddings import HuggingFaceEmbeddings
+
+            self.embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+            vector_store = FAISS.from_documents(self.documents, self.embeddings)
+            dense = vector_store.as_retriever(search_kwargs={"k": 10})
+            return bm25, dense
+        except Exception:
+            return bm25, None
+
+    def retrieve(self, queries: list[str]) -> list[Document]:
+        self.last_retrieval_trace = []
+        seen: set[str] = set()
+        candidates: list[Document] = []
+        anchors: list[Document] = []
+        for query in queries:
+            query_docs = self._hybrid_search(query)
+            for doc in query_docs[:2]:
+                key = f"{doc.metadata.get('section')}::{doc.page_content[:120]}"
+                if key not in seen:
+                    seen.add(key)
+                    anchors.append(doc)
+                    candidates.append(doc)
+            for doc in query_docs:
+                key = f"{doc.metadata.get('section')}::{doc.page_content[:120]}"
+                if key not in seen:
+                    seen.add(key)
+                    candidates.append(doc)
+
+        reranked = self._dedupe_documents(anchors + self._rerank(" ".join(queries), candidates))[:12]
+        self.last_retrieval_trace.append(
+            {
+                "stage": "reranking",
+                "reranker": "flashrank/ms-marco-MiniLM-L-12-v2",
+                "candidate_count": len(candidates),
+                "per_query_anchor_count": len(anchors),
+                "selected_count": len(reranked),
+            }
+        )
+        return reranked
+
+    def _hybrid_search(self, query: str) -> list[Document]:
+        bm25_ranked = self.bm25_retriever.invoke(query)
+        ranked_lists = [bm25_ranked]
+        dense_ranked = []
+        if self.dense_retriever is not None:
+            dense_ranked = self.dense_retriever.invoke(query)
+            ranked_lists.append(dense_ranked)
+
+        scores: dict[str, float] = {}
+        docs_by_key: dict[str, Document] = {}
+        for ranked in ranked_lists:
+            for rank, doc in enumerate(ranked, start=1):
+                key = f"{doc.metadata.get('section')}::{doc.page_content[:120]}"
+                docs_by_key[key] = doc
+                scores[key] = scores.get(key, 0.0) + 1.0 / (60 + rank)
+
+        fused = [docs_by_key[key] for key, _ in sorted(scores.items(), key=lambda item: item[1], reverse=True)]
+        self.last_retrieval_trace.append(
+            {
+                "stage": "hybrid_retrieval",
+                "query": query,
+                "dense_results": len(dense_ranked),
+                "sparse_results": len(bm25_ranked),
+                "fusion": "reciprocal_rank_fusion",
+                "fused_results": len(fused),
+            }
+        )
+        return fused
+
+    def embed_query(self, query: str) -> list[float]:
+        if self.embeddings is not None:
+            return self.embeddings.embed_query(query)
+        import hashlib
+
+        vector = [0.0] * 384
+        for word in query.lower().split():
+            slot = int(hashlib.sha256(word.encode("utf-8")).hexdigest()[:8], 16) % len(vector)
+            vector[slot] += 1.0
+        return vector
+
+    def _rerank(self, query: str, docs: list[Document]) -> list[Document]:
+        if not docs:
+            return []
+
+        try:
+            from flashrank import Ranker, RerankRequest
+
+            if self.reranker is None:
+                self.reranker = Ranker(model_name="ms-marco-MiniLM-L-12-v2")
+            passages = [
+                {"id": str(index), "text": doc.page_content, "meta": doc.metadata}
+                for index, doc in enumerate(docs)
+            ]
+            results = self.reranker.rerank(RerankRequest(query=query, passages=passages))
+            ordered = [docs[int(result["id"])] for result in results]
+            return ordered
+        except Exception:
+            keywords = {word.lower() for word in query.split() if len(word) > 3}
+
+            def score(doc: Document) -> int:
+                text = doc.page_content.lower()
+                metadata = " ".join(str(v).lower() for v in doc.metadata.values())
+                return sum(1 for word in keywords if word in text or word in metadata)
+
+            return sorted(docs, key=score, reverse=True)
+
+    def _dedupe_documents(self, docs: list[Document]) -> list[Document]:
+        seen: set[str] = set()
+        deduped: list[Document] = []
+        for doc in docs:
+            key = f"{doc.metadata.get('section')}::{doc.page_content[:120]}"
+            if key not in seen:
+                seen.add(key)
+                deduped.append(doc)
+        return deduped

app/services/schemas.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class InvoiceFields(BaseModel):
+    raw_text: str = ""
+    patient_name: str | None = None
+    date_of_birth: str | None = None
+    address: str | None = None
+    phone: str | None = None
+    date_of_treatment: str | None = None
+    diagnosis: str | None = None
+    medical_facility: str | None = None
+    doctor_fee: float | None = None
+    medicine_cost: float | None = None
+    amount_payable: float | None = None
+
+
+class ClaimInput(BaseModel):
+    patient_name: str
+    patient_address: str
+    claim_item: str = "General Practitioner"
+    date_of_treatment: str
+    medical_facility: str
+    claim_reason: str
+    claim_amount: float
+    invoice_hash: str | None = None
+    extracted_invoice: InvoiceFields | None = None
+
+
+class Citation(BaseModel):
+    section: str
+    title: str
+    page: str
+    excerpt: str
+
+
+class ClaimDecision(BaseModel):
+    status: str
+    confidence: float = Field(ge=0, le=1)
+    patient_name: str
+    patient_address: str
+    claim_item: str
+    medical_facility: str
+    date_of_treatment: str
+    total_claim_amount: float
+    executive_summary: str
+    introduction: str
+    claim_description: str
+    document_verification: str
+    document_summary: str
+    conclusion: str
+    reason_codes: list[str]
+    flags: list[str]
+    citations: list[Citation]
+    cache_hit: bool = False
+    pipeline_trace: dict = Field(default_factory=dict)

frontend/app.js

@@ -0,0 +1,169 @@
+const form = document.querySelector("#claim-form");
+const invoiceInput = document.querySelector("#invoice");
+const uploadStatus = document.querySelector("#upload-status");
+const submitBtn = document.querySelector("#submit-btn");
+const backBtn = document.querySelector("#back-btn");
+let invoiceHash = "";
+
+const fields = {
+  patient_name: document.querySelector("#patient_name"),
+  patient_address: document.querySelector("#patient_address"),
+  claim_item: document.querySelector("#claim_item"),
+  date_of_treatment: document.querySelector("#date_of_treatment"),
+  medical_facility: document.querySelector("#medical_facility"),
+  claim_reason: document.querySelector("#claim_reason"),
+  claim_amount: document.querySelector("#claim_amount"),
+};
+
+window.addEventListener("pageshow", () => {
+  form.reset();
+  invoiceHash = "";
+  uploadStatus.textContent = "";
+});
+
+invoiceInput.addEventListener("change", async () => {
+  const file = invoiceInput.files[0];
+  if (!file) return;
+
+  uploadStatus.textContent = "Extracting invoice fields...";
+  const data = new FormData();
+  data.append("invoice", file);
+
+  try {
+    const response = await fetch("/api/extract-invoice", {
+      method: "POST",
+      body: data,
+    });
+    if (!response.ok) throw new Error("Invoice extraction failed");
+    const payload = await response.json();
+    invoiceHash = payload.invoice_hash;
+    const extracted = payload.fields;
+
+    if (extracted.patient_name) fields.patient_name.value = extracted.patient_name;
+    if (extracted.address) fields.patient_address.value = extracted.address;
+    if (extracted.date_of_treatment) fields.date_of_treatment.value = normalizeDate(extracted.date_of_treatment);
+    if (extracted.medical_facility) fields.medical_facility.value = extracted.medical_facility;
+    if (extracted.diagnosis) fields.claim_reason.value = extracted.diagnosis;
+    if (extracted.amount_payable) fields.claim_amount.value = extracted.amount_payable;
+
+    uploadStatus.textContent = "Invoice extracted. Please review the fields before submitting.";
+  } catch (error) {
+    uploadStatus.textContent = "Could not extract invoice automatically. Please enter the details manually.";
+  }
+});
+
+form.addEventListener("submit", async (event) => {
+  event.preventDefault();
+  document.querySelector("#result").hidden = true;
+  submitBtn.disabled = true;
+  submitBtn.textContent = "Processing...";
+
+  const data = new FormData();
+  data.append("patient_name", fields.patient_name.value);
+  data.append("patient_address", fields.patient_address.value);
+  data.append("claim_item", fields.claim_item.value);
+  data.append("date_of_treatment", fields.date_of_treatment.value);
+  data.append("medical_facility", fields.medical_facility.value);
+  data.append("claim_reason", fields.claim_reason.value);
+  data.append("claim_amount", fields.claim_amount.value);
+  data.append("invoice_hash", invoiceHash);
+
+  if (invoiceInput.files[0]) {
+    data.append("invoice", invoiceInput.files[0]);
+  }
+
+  try {
+    const response = await fetch("/api/process-claim", {
+      method: "POST",
+      body: data,
+    });
+    if (!response.ok) {
+      const errorPayload = await response.json().catch(() => ({}));
+      throw new Error(errorPayload.detail || "Claim processing failed");
+    }
+    const result = await response.json();
+    if (!matchesSubmittedClaim(result)) {
+      throw new Error("The server returned a stale or mismatched claim result. Please refresh and try again.");
+    }
+    renderResult(result);
+  } catch (error) {
+    alert(error.message || "Claim processing failed. Please check the backend logs.");
+  } finally {
+    submitBtn.disabled = false;
+    submitBtn.textContent = "Process Claim";
+  }
+});
+
+function matchesSubmittedClaim(result) {
+  const expectedName = normalizeText(fields.patient_name.value);
+  const expectedFacility = normalizeText(fields.medical_facility.value);
+  const expectedAmount = Number(fields.claim_amount.value);
+  return (
+    normalizeText(result.patient_name) === expectedName &&
+    normalizeText(result.medical_facility) === expectedFacility &&
+    Number(result.total_claim_amount) === expectedAmount
+  );
+}
+
+backBtn.addEventListener("click", () => {
+  document.querySelector("#result").hidden = true;
+  form.hidden = false;
+  form.scrollIntoView({ behavior: "smooth", block: "start" });
+});
+
+function renderResult(result) {
+  const panel = document.querySelector("#result");
+
+  document.querySelector("#r-name").textContent = result.patient_name;
+  document.querySelector("#r-address").textContent = result.patient_address;
+  document.querySelector("#r-claim-item").textContent = result.claim_item;
+  document.querySelector("#r-facility").textContent = result.medical_facility;
+  document.querySelector("#r-date").textContent = result.date_of_treatment;
+  document.querySelector("#r-amount").textContent = result.total_claim_amount;
+  document.querySelector("#r-executive-summary").textContent = result.executive_summary;
+  document.querySelector("#r-introduction").textContent = result.introduction;
+  document.querySelector("#r-description").textContent = result.claim_description;
+  document.querySelector("#r-verification").textContent = result.document_verification;
+  document.querySelector("#r-summary").textContent = result.document_summary;
+  document.querySelector("#r-conclusion").textContent = result.conclusion;
+
+  const citations = document.querySelector("#r-citations");
+  citations.innerHTML = "";
+  result.citations.forEach((citation) => {
+    const node = document.createElement("div");
+    node.className = "citation";
+    node.innerHTML = `
+      <strong>${escapeHtml(citation.section)} - ${escapeHtml(citation.title)} · page ${escapeHtml(citation.page)}</strong>
+      <span>${escapeHtml(citation.excerpt)}</span>
+    `;
+    citations.appendChild(node);
+  });
+
+  panel.hidden = false;
+  form.hidden = true;
+  panel.scrollIntoView({ behavior: "smooth", block: "start" });
+}
+
+function normalizeDate(value) {
+  const trimmed = value.trim();
+  const iso = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (iso) return trimmed;
+  const slash = trimmed.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+  if (!slash) return trimmed;
+  const day = slash[1].padStart(2, "0");
+  const month = slash[2].padStart(2, "0");
+  return `${slash[3]}-${month}-${day}`;
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#039;");
+}
+
+function normalizeText(value) {
+  return String(value || "").trim().toLowerCase();
+}

frontend/index.html

@@ -0,0 +1,133 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Insurance Claims</title>
+    <link rel="stylesheet" href="/static/styles.css?v=blank-claim-form-v1" />
+  </head>
+  <body>
+    <main class="app-shell">
+      <section class="intro-pane">
+        <div class="intro-content">
+          <h1>Insurance Claims</h1>
+          <p>Please provide accurate information to verify your claim.</p>
+          <div class="shield-art" aria-hidden="true">
+            <div class="shield">
+              <div class="key-ring"></div>
+              <div class="key-stem"></div>
+              <div class="key-bit"></div>
+            </div>
+            <div class="check-bubble">✓</div>
+          </div>
+        </div>
+      </section>
+
+      <section class="claim-pane">
+        <form id="claim-form" class="claim-form">
+          <label class="full">
+            <span>Submit claim for</span>
+            <input id="patient_name" name="patient_name" type="text" placeholder="Patient name" required />
+          </label>
+
+          <label>
+            <span>Claim item</span>
+            <select id="claim_item" name="claim_item" required>
+              <option value="" selected disabled>Select claim item</option>
+              <option>General Practitioner</option>
+              <option>Outpatient Consultation</option>
+              <option>Medicine</option>
+              <option>Diagnostic Test</option>
+              <option>Hospital Treatment</option>
+            </select>
+          </label>
+
+          <label>
+            <span>Claim Reason</span>
+            <input id="claim_reason" name="claim_reason" type="text" placeholder="Claim reason" required />
+          </label>
+
+          <label class="full">
+            <span>Patient Address</span>
+            <input id="patient_address" name="patient_address" type="text" placeholder="Patient address" required />
+          </label>
+
+          <label>
+            <span>Date of treatment</span>
+            <input id="date_of_treatment" name="date_of_treatment" type="date" required />
+          </label>
+
+          <span></span>
+
+          <label>
+            <span>Medical Facility</span>
+            <input id="medical_facility" name="medical_facility" type="text" placeholder="Medical facility" required />
+          </label>
+
+          <label>
+            <span>Claim Amount</span>
+            <input id="claim_amount" name="claim_amount" type="number" min="0" step="0.01" placeholder="Claim amount" required />
+          </label>
+
+          <div class="upload-box full">
+            <div>
+              <strong>Make sure your payment receipt includes:</strong>
+              <ul>
+                <li>The patient's name</li>
+                <li>Treatment date</li>
+                <li>Medical facility</li>
+                <li>Total amount charged</li>
+              </ul>
+            </div>
+            <label class="file-control">
+              <input id="invoice" name="invoice" type="file" accept=".pdf,.png,.jpg,.jpeg" />
+              <span>Upload invoice PDF</span>
+            </label>
+            <p id="upload-status" class="upload-status"></p>
+          </div>
+
+          <button id="submit-btn" class="submit-btn" type="submit">Process Claim</button>
+        </form>
+
+        <section id="result" class="result-panel" hidden>
+          <div class="report">
+            <h2>Executive Summary</h2>
+            <p id="r-executive-summary"></p>
+
+            <h2>Introduction</h2>
+            <p id="r-introduction"></p>
+
+            <h2>Claim Details</h2>
+            <p><strong>Patient Name:</strong> <span id="r-name"></span></p>
+            <p><strong>Address:</strong> <span id="r-address"></span></p>
+            <p><strong>Claim Type:</strong> <span id="r-claim-item"></span></p>
+            <p><strong>Medical Facility:</strong> <span id="r-facility"></span></p>
+            <p><strong>Date:</strong> <span id="r-date"></span></p>
+            <p><strong>Total Claim Amount:</strong> <span id="r-amount"></span></p>
+
+            <h2>Claim Description</h2>
+            <p id="r-description"></p>
+
+            <h2>Document Verification</h2>
+            <p id="r-verification"></p>
+
+            <h2>Document Summary</h2>
+            <p id="r-summary"></p>
+
+            <h2>Conclusion</h2>
+            <p id="r-conclusion"></p>
+
+            <details class="policy-evidence">
+              <summary>Policy Evidence</summary>
+              <div id="r-citations" class="citations"></div>
+            </details>
+          </div>
+
+          <button id="back-btn" class="back-btn" type="button">Back</button>
+        </section>
+      </section>
+    </main>
+
+    <script src="/static/app.js?v=blank-claim-form-v1"></script>
+  </body>
+</html>

frontend/styles.css

@@ -0,0 +1,301 @@
+:root {
+  --text: #1f2937;
+  --muted: #667085;
+  --line: #d9e0ea;
+  --panel: #ffffff;
+  --blue: #b9dbff;
+  --blue-strong: #386ccf;
+  --danger: #b42318;
+  --warning: #b54708;
+  --success: #067647;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  font-family: Arial, Helvetica, sans-serif;
+  color: var(--text);
+  background: linear-gradient(90deg, #f7fbff 0%, #eef5ff 34%, #ffffff 34%);
+}
+
+.app-shell {
+  width: min(1160px, calc(100vw - 32px));
+  margin: 70px auto 36px;
+  display: grid;
+  grid-template-columns: 340px minmax(0, 1fr);
+  gap: 28px;
+}
+
+.intro-pane {
+  min-height: 560px;
+  display: flex;
+  justify-content: center;
+}
+
+.intro-content {
+  width: 260px;
+}
+
+h1 {
+  margin: 0;
+  font-size: 24px;
+  line-height: 1.2;
+}
+
+.intro-content p {
+  margin: 8px 0 36px;
+  color: var(--muted);
+  font-size: 13px;
+}
+
+.shield-art {
+  position: relative;
+  width: 220px;
+  height: 220px;
+  margin: 0 auto;
+}
+
+.shield {
+  position: absolute;
+  inset: 34px 44px 22px 18px;
+  background: linear-gradient(135deg, #dce8ff, #f9fbff);
+  border: 12px solid #567bd7;
+  border-right-color: #e9f0ff;
+  border-radius: 34px 34px 68px 68px;
+  transform: rotate(-24deg);
+  box-shadow: 0 20px 40px rgba(56, 108, 207, 0.18);
+}
+
+.key-ring {
+  position: absolute;
+  width: 50px;
+  height: 50px;
+  border: 14px solid #6a82df;
+  border-radius: 50%;
+  top: 60px;
+  left: 52px;
+}
+
+.key-stem {
+  position: absolute;
+  width: 78px;
+  height: 12px;
+  background: #6a82df;
+  top: 82px;
+  left: 96px;
+}
+
+.key-bit {
+  position: absolute;
+  width: 30px;
+  height: 34px;
+  border: 10px solid #6a82df;
+  border-left: 0;
+  top: 71px;
+  left: 158px;
+  border-radius: 0 18px 18px 0;
+}
+
+.check-bubble {
+  position: absolute;
+  right: 28px;
+  top: 0;
+  width: 68px;
+  height: 54px;
+  border-radius: 50%;
+  background: #dfe8ff;
+  color: #4876d8;
+  font-size: 42px;
+  font-weight: 700;
+  text-align: center;
+  line-height: 54px;
+  box-shadow: 0 10px 28px rgba(70, 118, 216, 0.2);
+}
+
+.claim-pane {
+  background: var(--panel);
+  border: 1px solid #e5e9f0;
+  padding: 34px 34px 42px;
+}
+
+.claim-form {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 22px 24px;
+}
+
+label {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.full {
+  grid-column: 1 / -1;
+}
+
+input,
+select {
+  width: 100%;
+  height: 34px;
+  border: 1px solid #cfd7e3;
+  border-radius: 4px;
+  padding: 7px 9px;
+  font: inherit;
+  font-weight: 400;
+  color: var(--text);
+  background: #fff;
+}
+
+input:focus,
+select:focus {
+  outline: 2px solid rgba(56, 108, 207, 0.25);
+  border-color: #587fd7;
+}
+
+.upload-box {
+  background: var(--blue);
+  border-radius: 8px;
+  padding: 16px 18px;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 210px;
+  gap: 16px;
+  align-items: center;
+  font-size: 13px;
+}
+
+.upload-box ul {
+  margin: 8px 0 0;
+  padding-left: 20px;
+}
+
+.file-control input {
+  display: none;
+}
+
+.file-control span,
+.submit-btn {
+  min-height: 38px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border: 0;
+  border-radius: 4px;
+  background: var(--blue-strong);
+  color: #fff;
+  font-weight: 700;
+  cursor: pointer;
+}
+
+.upload-status {
+  grid-column: 1 / -1;
+  min-height: 18px;
+  margin: 0;
+  color: #31527f;
+}
+
+.submit-btn {
+  width: 180px;
+  padding: 0 18px;
+  font-size: 14px;
+}
+
+.result-panel {
+  margin: 34px auto 0;
+  border: 1px solid #cfd7e3;
+  padding: 20px 34px 30px;
+}
+
+.report {
+  max-width: 560px;
+  margin: 0 auto;
+  text-align: center;
+  color: #555f6d;
+  line-height: 1.45;
+}
+
+.report p {
+  margin: 4px 0;
+}
+
+.report h2 {
+  margin: 28px 0 8px;
+  color: #667085;
+  font-size: 16px;
+  font-weight: 500;
+}
+
+.policy-evidence {
+  margin-top: 26px;
+  text-align: left;
+  font-size: 12px;
+}
+
+.policy-evidence summary {
+  width: max-content;
+  margin: 0 auto 10px;
+  color: #667085;
+  cursor: pointer;
+}
+
+.citations {
+  display: grid;
+  gap: 8px;
+  text-align: left;
+}
+
+.citation {
+  border: 1px solid #e1e6ee;
+  border-radius: 6px;
+  padding: 10px;
+  background: #fbfcff;
+  font-size: 12px;
+}
+
+.citation strong {
+  display: block;
+  color: #364152;
+  margin-bottom: 4px;
+}
+
+.back-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 54px;
+  height: 34px;
+  margin: 38px auto 0;
+  padding: 0 16px;
+  border: 0;
+  border-radius: 4px;
+  background: var(--blue-strong);
+  color: #fff;
+  font-weight: 700;
+  cursor: pointer;
+}
+
+@media (max-width: 860px) {
+  body {
+    background: #fff;
+  }
+
+  .app-shell {
+    grid-template-columns: 1fr;
+    margin-top: 28px;
+  }
+
+  .intro-pane {
+    min-height: auto;
+  }
+
+  .claim-form,
+  .upload-box {
+    grid-template-columns: 1fr;
+  }
+}

scripts/create_bangladesh_invoice.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+
+import fitz
+
+
+def main() -> None:
+    output = Path("sample_invoice_bangladesh.pdf")
+    doc = fitz.open()
+    page = doc.new_page(width=595, height=842)
+
+    y = 78
+    page.insert_text((190, y), "DHAKA CENTRAL HOSPITAL", fontsize=16, fontname="helv")
+    y += 20
+    page.insert_text((205, y), "Original Hospital Invoice", fontsize=11, fontname="helv")
+    page.draw_line((72, 115), (523, 115), color=(0.55, 0.62, 0.72))
+
+    y = 145
+    lines = [
+        "Invoice Number: DCH-INV-2024-0718-204",
+        "Invoice Date: 18/07/2024",
+        "",
+        "Patient Information:",
+        "- Patient Name: Arafat Rahman",
+        "- Date of Birth: 14/03/1995",
+        "- Address: House 22, Road 7, Dhanmondi, Dhaka 1205, Bangladesh",
+        "- Phone Number: +8801712345678",
+        "",
+        "Service Details:",
+        "- Date of Treatment: 18/07/2024",
+        "- Medical Facility: DHAKA CENTRAL HOSPITAL",
+        "- Consultant: Dr Nusrat Jahan, General Physician",
+        "- Diagnosis: Acute viral fever",
+        "- Treatment Type: Outpatient consultation, CBC test, and short-term prescribed medicine",
+        "",
+        "Service Charges:",
+        "- Doctor's consultation fee: 1200",
+        "- CBC diagnostic test: 800",
+        "- Prescribed medicines: 1500",
+        "- Total charge: 3500",
+        "- Membership Discount: 5%",
+        "- Amount payable: 3325",
+        "",
+        "Payment Status: Paid by patient",
+        "Payment Method: Card",
+        "Receipt Status: Original unaltered invoice issued by DHAKA CENTRAL HOSPITAL.",
+    ]
+
+    for line in lines:
+        if line.endswith(":"):
+            y += 14
+            page.insert_text((72, y), line, fontsize=12, fontname="helv")
+            page.draw_line((72, y + 3), (72 + min(190, len(line) * 7), y + 3))
+            y += 24
+            continue
+        if not line:
+            y += 10
+            continue
+        page.insert_text((72, y), line, fontsize=10.5, fontname="helv")
+        y += 20
+
+    page.draw_line((72, 775), (523, 775), color=(0.75, 0.78, 0.82))
+    page.insert_text(
+        (72, 792),
+        "Sample Bangladesh invoice for AI Claims Processing System testing only.",
+        fontsize=8,
+        fontname="helv",
+        color=(0.35, 0.35, 0.35),
+    )
+
+    doc.save(output)
+    doc.close()
+    print(output.resolve())
+
+
+if __name__ == "__main__":
+    main()

scripts/create_complete_claim_pdf.py

@@ -0,0 +1,198 @@
+from pathlib import Path
+
+import fitz
+
+
+OUTPUT = Path("complete_claim_package_surbhit.pdf")
+
+
+def add_heading(page: fitz.Page, title: str) -> int:
+    page.insert_text((72, 58), title, fontsize=17, fontname="helv")
+    page.draw_line((72, 82), (523, 82), color=(0.55, 0.62, 0.72))
+    return 112
+
+
+def add_lines(page: fitz.Page, lines: list[str], y: int, size: int = 10) -> int:
+    for line in lines:
+        if not line:
+            y += 14
+            continue
+        page.insert_text((72, y), line, fontsize=size, fontname="helv")
+        y += 18
+    return y
+
+
+def add_footer(page: fitz.Page, page_no: int) -> None:
+    page.draw_line((72, 775), (523, 775), color=(0.75, 0.78, 0.82))
+    page.insert_text(
+        (72, 792),
+        f"Sample document for AI Claims Processing System testing only | Page {page_no}",
+        fontsize=8,
+        fontname="helv",
+        color=(0.35, 0.35, 0.35),
+    )
+
+
+def main() -> None:
+    doc = fitz.open()
+
+    page = doc.new_page(width=595, height=842)
+    y = add_heading(page, "APOLLO HOSPITALS - ORIGINAL TAX INVOICE")
+    y = add_lines(
+        page,
+        [
+            "Invoice Number: AH-INV-2024-0202-115",
+            "Pre-authorisation Number: BUPA-PA-240202-7718",
+            "Invoice Date: 02/02/2024",
+            "",
+            "Patient Information:",
+            "- Patient Name: Surbhit",
+            "- Date of Birth: 01/01/1998",
+            "- Address: 22 Baker Street, London, United Kingdom",
+            "- Phone Number: +44 7700 900123",
+            "- Policy Number: BUPA-HLT-204455",
+            "",
+            "Service Details:",
+            "- Date of Treatment: 02/02/2024",
+            "- Medical Facility: APOLLO HOSPITALS",
+            "- Consultant: Dr Amelia Wright, General Practitioner",
+            "- Diagnosis: Acute tension headache",
+            "- Treatment Type: Outpatient consultation and short-term prescribed medicine",
+            "",
+            "Service Charges:",
+            "- Doctor's consultation fee: 1500",
+            "- Diagnostic observation and clinical assessment: 500",
+            "- Prescribed medicines: 1500",
+            "- Total charge: 3500",
+            "- Membership Discount: 10%",
+            "- Amount payable: 3150",
+            "",
+            "Payment Status: Paid by patient",
+            "Receipt Status: Original unaltered invoice issued by APOLLO HOSPITALS.",
+        ],
+        y,
+    )
+    add_footer(page, 1)
+
+    page = doc.new_page(width=595, height=842)
+    y = add_heading(page, "PRESCRIPTION")
+    y = add_lines(
+        page,
+        [
+            "Prescription ID: RX-2024-0202-883",
+            "Date: 02/02/2024",
+            "Patient Name: Surbhit",
+            "Diagnosis: Acute tension headache",
+            "",
+            "Prescribed Medicines:",
+            "1. Paracetamol 500mg - Take one tablet every 6 hours if required for pain, maximum 3 days.",
+            "2. Ibuprofen 200mg - Take one tablet after food if required, maximum 2 days.",
+            "3. Oral rehydration solution - As required.",
+            "",
+            "Clinical Note:",
+            "Medication was prescribed for short-term symptom relief linked to the acute outpatient visit.",
+            "No long-term medicine, chronic disease management, or preventive screening was prescribed.",
+            "",
+            "Prescriber:",
+            "Dr Amelia Wright",
+            "GMC Number: 7123456",
+            "Signature: Dr Amelia Wright",
+        ],
+        y,
+    )
+    add_footer(page, 2)
+
+    page = doc.new_page(width=595, height=842)
+    y = add_heading(page, "MEDICAL REPORT")
+    y = add_lines(
+        page,
+        [
+            "Report Number: MR-2024-0202-491",
+            "Date of Report: 02/02/2024",
+            "Patient Name: Surbhit",
+            "Date of Treatment: 02/02/2024",
+            "Treating Clinician: Dr Amelia Wright",
+            "",
+            "Presenting Complaint:",
+            "The patient attended outpatient consultation with headache symptoms that started the same day.",
+            "",
+            "Clinical Findings:",
+            "- No loss of consciousness reported.",
+            "- No neurological deficit observed during examination.",
+            "- Blood pressure and temperature were within normal limits.",
+            "- No evidence of chronic headache disorder was recorded.",
+            "",
+            "Diagnosis:",
+            "Acute tension headache.",
+            "",
+            "Treatment Provided:",
+            "Outpatient consultation, clinical assessment, advice on hydration/rest, and short-term medication.",
+            "",
+            "Medical Necessity Statement:",
+            "The consultation was medically necessary to assess acute symptoms and rule out urgent warning signs.",
+            "The treatment was short-term and intended to return the patient to their prior state of health.",
+        ],
+        y,
+    )
+    add_footer(page, 3)
+
+    page = doc.new_page(width=595, height=842)
+    y = add_heading(page, "BUPA PRE-AUTHORISATION CONFIRMATION")
+    y = add_lines(
+        page,
+        [
+            "Pre-authorisation Number: BUPA-PA-240202-7718",
+            "Date Issued: 02/02/2024",
+            "Policy Number: BUPA-HLT-204455",
+            "Patient Name: Surbhit",
+            "",
+            "Authorised Service:",
+            "- Outpatient consultation for acute symptoms",
+            "- Consultant/GP assessment",
+            "- Clinically necessary short-term treatment linked to the consultation",
+            "",
+            "Facility and Clinician:",
+            "- Medical Facility: APOLLO HOSPITALS",
+            "- Clinician: Dr Amelia Wright",
+            "",
+            "Important Note:",
+            "This sample confirmation is provided for testing the AI workflow only.",
+            "Final payment remains subject to policy terms, membership certificate benefits, excess, allowances,",
+            "recognised provider status, and review of original documents.",
+        ],
+        y,
+    )
+    add_footer(page, 4)
+
+    page = doc.new_page(width=595, height=842)
+    y = add_heading(page, "PAYMENT RECEIPT")
+    y = add_lines(
+        page,
+        [
+            "Receipt Number: PAY-2024-0202-3150",
+            "Invoice Number: AH-INV-2024-0202-115",
+            "Payment Date: 02/02/2024",
+            "Patient Name: Surbhit",
+            "Medical Facility: APOLLO HOSPITALS",
+            "",
+            "Payment Breakdown:",
+            "- Total charge: 3500",
+            "- Membership discount: 350",
+            "- Amount payable: 3150",
+            "- Amount paid: 3150",
+            "",
+            "Payment Method: Card",
+            "Payment Status: Paid in full",
+            "Issued by: APOLLO HOSPITALS Billing Department",
+        ],
+        y,
+    )
+    add_footer(page, 5)
+
+    doc.save(OUTPUT)
+    doc.close()
+    print(OUTPUT.resolve())
+
+
+if __name__ == "__main__":
+    main()

scripts/create_sample_invoice.py

@@ -0,0 +1,65 @@
+from pathlib import Path
+
+import fitz
+
+
+def main() -> None:
+    output = Path("sample_invoice_apollo.pdf")
+    doc = fitz.open()
+    page = doc.new_page(width=595, height=842)
+
+    y = 90
+    page.insert_text((230, y), "APOLLO HOSPITALS", fontsize=16, fontname="helv")
+
+    y += 45
+    page.insert_text((80, y), "Patient Information:", fontsize=12, fontname="helv")
+    page.draw_line((80, y + 3), (200, y + 3))
+
+    y += 35
+    lines = [
+        "- Name: Surbhit",
+        "- Date of Birth: 01/01/1998",
+        "- Address: India",
+        "- Phone Number: 1239874653",
+        "",
+        "Service Details:",
+        "Date of Service: 02/02/2024",
+        "Diagnosis: Headache",
+        "",
+        "Details: Consultation and medicines as mentioned in the prescription",
+        "",
+        "Service charges:",
+        "Doctor's fee - 1500",
+        "Medicines - 2000",
+        "",
+        "Total charge - 3500",
+        "Membership Discount - 10%",
+        "Amount payable - 3150",
+    ]
+
+    for line in lines:
+        if line == "Service Details:":
+            y += 18
+            page.insert_text((80, y), line, fontsize=12, fontname="helv")
+            page.draw_line((80, y + 3), (170, y + 3))
+            y += 24
+            continue
+
+        page.insert_text((80, y), line, fontsize=11, fontname="helv")
+        y += 22
+
+    page.insert_text(
+        (80, 760),
+        "This is a sample invoice for testing the AI Claims Processing System.",
+        fontsize=9,
+        fontname="helv",
+        color=(0.35, 0.35, 0.35),
+    )
+
+    doc.save(output)
+    doc.close()
+    print(output.resolve())
+
+
+if __name__ == "__main__":
+    main()