fix CI

app.py

@@ -35,14 +35,13 @@ def upload_files(files) -> str:
             path = f if isinstance(f, str) else f.name
             with open(path, "rb") as fp:
                 multipart.append(("files", (os.path.basename(path), fp.read(), "application/octet-stream")))
-        # Large PDFs produce thousands of chunks; embedding them on CPU can take
-        # a few minutes, so allow a generous timeout.
+        # Large PDFs can take minutes to embed on CPU, so allow a generous timeout.
         resp = requests.post(UPLOAD_ENDPOINT, files=multipart, timeout=900)
         resp.raise_for_status()
         return resp.json().get("status", "Files processed.")
     except requests.exceptions.ReadTimeout:
-        return ("Still indexing — this file is large and CPU embedding is slow. "
-                "Wait a moment and try your question; it may already be indexed.")
+        return ("Still indexing. This file is large and CPU embedding is slow; "
+                "wait a moment and try your question, it may already be indexed.")
     except requests.exceptions.RequestException as e:
         return f"Upload failed: {e}"
 
@@ -71,7 +70,7 @@ def _faith_hint(score: float, source: str) -> str:
         return f"Answer is well-grounded in the {what}"
     if score >= 0.50:
         return f"Answer is mostly grounded in the {what}, minor unsupported details possible"
-    return f"Low grounding — answer may contain content not present in the {what}"
+    return f"Low grounding: answer may contain content not present in the {what}"
 
 
 def _relevance_hint(score: float) -> str:
@@ -86,7 +85,7 @@ def _accuracy_hint(score: float) -> str:
     if score >= 0.75:
         return "Strong match with your reference answer"
     if score >= 0.40:
-        return "Partial match — some key points differ from your reference"
+        return "Partial match: some key points differ from your reference"
     return "Low overlap with your reference answer"
 
 
@@ -98,14 +97,14 @@ def _format_metrics(source: str, faithfulness, answer_relevance, accuracy) -> st
     lines = [f"**Answer source: {src_label}**", "---"]
 
     if faithfulness is not None:
-        faith_label = "Faithfulness — grounded in documents" if source != "web" else "Faithfulness — grounded in web results"
+        faith_label = "Faithfulness (grounded in documents)" if source != "web" else "Faithfulness (grounded in web results)"
         lines.append(_fmt(faith_label, faithfulness, _faith_hint(faithfulness, source)))
 
     if answer_relevance is not None:
-        lines.append(_fmt("Answer Relevance — addresses the question", answer_relevance, _relevance_hint(answer_relevance)))
+        lines.append(_fmt("Answer Relevance (addresses the question)", answer_relevance, _relevance_hint(answer_relevance)))
 
     if accuracy is not None:
-        lines.append(_fmt("Accuracy — matches your reference", accuracy, _accuracy_hint(accuracy)))
+        lines.append(_fmt("Accuracy (matches your reference)", accuracy, _accuracy_hint(accuracy)))
     else:
         lines.append("_Accuracy: provide a reference answer above to see this score._")
 
@@ -150,7 +149,7 @@ def process_query(message: str, api_key: str, reference: str, session_id: str, c
             data.get("answer_relevance"),
             data.get("accuracy"),
         )
-        return chat_history, f"Done — answered via {src_label}", metrics_md
+        return chat_history, f"Done. Answered via {src_label}", metrics_md
 
     except requests.exceptions.RequestException as e:
         error = f"Request failed: {e}"
@@ -169,8 +168,7 @@ def clear_chat(session_id: str) -> tuple[list, str, str]:
 
 
 with gr.Blocks(title="Agentic RAG Knowledge Search") as demo:
-    # Per-browser-session id for server-side conversation memory
-    session_id = gr.State()
+    session_id = gr.State()   # per-browser id for server-side memory
 
     gr.Markdown("# Agentic RAG Knowledge Search")
     gr.Markdown(
@@ -183,7 +181,7 @@ with gr.Blocks(title="Agentic RAG Knowledge Search") as demo:
     with gr.Group():
         gr.Markdown(
             "### Your Gemini API Key (required)\n"
-            "This app uses **your own** Google Gemini key — it is sent only with your requests and never stored. "
+            "This app uses **your own** Google Gemini key; it is sent only with your requests and never stored. "
             "Get a free key at [Google AI Studio](https://aistudio.google.com/apikey)."
         )
         api_key_input = gr.Textbox(
@@ -196,8 +194,8 @@ with gr.Blocks(title="Agentic RAG Knowledge Search") as demo:
     with gr.Group():
         gr.Markdown(
             f"### Upload Documents\n"
-            f"Supported: **{', '.join(SUPPORTED_TYPES)}** — multiple files allowed, new uploads add to the index.  \n"
-            "_Large PDFs (100s of pages) can take a few minutes to index on the free CPU — please be patient._"
+            f"Supported: **{', '.join(SUPPORTED_TYPES)}**. Multiple files allowed; new uploads add to the index.  \n"
+            "_Large PDFs (100s of pages) can take a few minutes to index on the free CPU, so please be patient._"
         )
         file_input = gr.File(label="Select Files", file_count="multiple", file_types=SUPPORTED_TYPES)
         with gr.Row():
@@ -239,7 +237,7 @@ with gr.Blocks(title="Agentic RAG Knowledge Search") as demo:
     with gr.Group():
         gr.Markdown(
             "### Evaluation Metrics\n"
-            "Computed automatically after every response — **no extra API calls, no reference needed** for the first two.\n\n"
+            "Computed automatically after every response, with **no extra API calls and no reference needed** for the first two.\n\n"
             "| Metric | Always shown? | What it measures |\n"
             "|---|---|---|\n"
             "| **Faithfulness** | Yes | Is the answer grounded in the source it used? (docs or web results) |\n"
@@ -248,7 +246,6 @@ with gr.Blocks(title="Agentic RAG Knowledge Search") as demo:
         )
         metrics_output = gr.Markdown()
 
-    # Assign a fresh session id when the page loads
     demo.load(fn=lambda: str(uuid.uuid4()), inputs=[], outputs=[session_id])
 
     upload_btn.click(fn=upload_files, inputs=[file_input], outputs=[upload_status])

src/agent.py

@@ -20,8 +20,7 @@ except Exception as e:
 
 _search_tool = DuckDuckGoSearchRun()
 
-# Default to a free-tier model that reliably produces a final answer after tool
-# calls. Override with the GEMINI_MODEL env var if your key supports another model.
+# gemini-2.5-flash reliably answers after tool calls; override per key via env.
 MODEL_NAME = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
 
 SYSTEM_PROMPT = (
@@ -32,7 +31,7 @@ SYSTEM_PROMPT = (
     "knowledge that is unlikely to be in the documents.\n\n"
     "Guidelines:\n"
     "1. Choose the tool that best fits the question; use both if needed.\n"
-    "2. Ground your answer in the retrieved content — do not invent facts. If the documents "
+    "2. Ground your answer in the retrieved content and do not invent facts. If the documents "
     "do not contain the answer, say so and try the web.\n"
     "3. Use the conversation summary and recent turns to resolve follow-up questions "
     "(e.g. pronouns like 'it' or 'that').\n"
@@ -62,7 +61,7 @@ def search_web(query: str) -> str:
 
 @lru_cache(maxsize=32)
 def get_llm(api_key: str) -> ChatGoogleGenerativeAI:
-    """Cached Gemini client for a given key — reused by the agent and the summarizer."""
+    """Cached Gemini client per key, reused by the agent and the summarizer."""
     if not api_key or not api_key.strip():
         raise ValueError("A Google Gemini API key is required.")
     return ChatGoogleGenerativeAI(
@@ -74,11 +73,8 @@ def get_llm(api_key: str) -> ChatGoogleGenerativeAI:
 
 @lru_cache(maxsize=32)
 def get_agent_executor(api_key: str):
-    """Build (and cache) a LangGraph ReAct agent for the given Gemini API key.
-
-    Each visitor supplies their own key (BYOK). The shared tools, embeddings, and
-    RAG index are module-level and reused; only the LLM is per-key. Cached by key
-    so repeat requests from the same user don't rebuild the graph."""
+    """ReAct agent for a given key (BYOK). Tools and the index are shared; only the
+    LLM is per-key, and the graph is cached so repeat calls don't rebuild it."""
     return create_react_agent(
         get_llm(api_key),
         [lookup_documents, search_web],

src/embeddings.py

@@ -1,13 +1,3 @@
-"""
-Shared embedding model — loaded once and reused everywhere.
-
-The same all-MiniLM-L6-v2 model is needed by:
-  - the RAG vector stores (via langchain's HuggingFaceEmbeddings)
-  - the evaluator's cosine-similarity metrics (via the raw SentenceTransformer)
-
-Loading it a single time keeps memory and cold-start cost low on HF Spaces.
-"""
-
 from langchain_huggingface import HuggingFaceEmbeddings
 
 _MODEL_NAME = "all-MiniLM-L6-v2"
@@ -15,7 +5,7 @@ _embeddings = None
 
 
 def get_embeddings() -> HuggingFaceEmbeddings:
-    """Shared langchain embeddings object for FAISS vector stores."""
+    """Shared embeddings instance, loaded once and reused by RAG and the evaluator."""
     global _embeddings
     if _embeddings is None:
         _embeddings = HuggingFaceEmbeddings(model_name=_MODEL_NAME)
@@ -23,10 +13,8 @@ def get_embeddings() -> HuggingFaceEmbeddings:
 
 
 def get_sentence_transformer():
-    """The underlying SentenceTransformer, reused by the evaluator.
-    Falls back to a direct load if langchain's internal attribute changes."""
-    embeddings = get_embeddings()
-    model = getattr(embeddings, "client", None)
+    """The raw SentenceTransformer behind the shared embeddings (used by the evaluator)."""
+    model = getattr(get_embeddings(), "client", None)
     if model is None:
         from sentence_transformers import SentenceTransformer
         model = SentenceTransformer(_MODEL_NAME)

src/evaluator.py

@@ -1,40 +1,29 @@
-"""
-Local evaluation metrics — no LLM API calls, CPU-friendly for HF Spaces.
-
-faithfulness   : NLI entailment of each answer sentence against the best-matching
-                 source passage (docs or web results it actually used).
-                 Detects contradictions / unsupported claims, not just topic overlap.
-                 Falls back to cosine similarity if the NLI model can't load.
-answer_relevance: cosine similarity between question and answer — does the answer
-                 address the question? Needs no reference.
-accuracy       : ROUGE-L F1 vs a user-supplied reference answer. Only when provided.
-"""
+"""Local answer-quality metrics: faithfulness (NLI), relevance (cosine), accuracy (ROUGE).
+No LLM/API calls, so it stays cheap and CPU-friendly. Model libraries are imported lazily
+inside the functions that need them, keeping module import (and CI) fast."""
 
 import re
 import logging
 import numpy as np
 from rouge_score import rouge_scorer
 
-# Heavy model libraries (sentence_transformers, torch) are imported lazily inside
-# the functions that need them, so importing this module — and running the
-# ROUGE/text-helper unit tests — stays fast and dependency-light in CI.
-
 logger = logging.getLogger(__name__)
 
-# FEVER/ANLI-trained NLI model — reliable for fact verification (handles
-# subset/superset and compound claims, which the smaller NLI models miss).
+# FEVER/ANLI-trained NLI model: reliable for fact verification, unlike smaller NLI models
+# that mislabel subset/superset and compound claims.
 _NLI_MODEL_NAME = "MoritzLaurer/DeBERTa-v3-base-mnli-fever-anli"
+_TOP_EVIDENCE = 4
+# Leading proper-noun subject of 2-4 capitalized words, e.g. "Devi Sri Bandaru ".
+_SUBJECT_RE = re.compile(r"^[A-Z][a-z]+(?:\s+[A-Z][a-z]+){1,3}\s+")
 
 _nli_model = None
 _entail_idx = None
 _rouge = rouge_scorer.RougeScorer(["rougeL"], use_stemmer=True)
 
 
-# --- helpers ---------------------------------------------------------------
-
 def _nli():
-    """Lazily load the NLI cross-encoder and resolve its 'entailment' label index
-    (label order varies between models, so we read it from the config)."""
+    """Load the NLI cross-encoder once and resolve its entailment label index
+    (label order differs between models, so read it from the config)."""
     global _nli_model, _entail_idx
     if _nli_model is None:
         from sentence_transformers import CrossEncoder
@@ -63,64 +52,45 @@ def _cosine(text_a: str, text_b: str) -> float:
 
 
 def _is_claim(text: str) -> bool:
-    """Keep verifiable factual statements; drop framing and meta lines."""
-    if len(text) <= 15:
+    """Keep verifiable statements; drop list lead-ins and "(Source: file.pdf)" lines."""
+    if len(text) <= 15 or text.endswith(":"):
         return False
-    if text.endswith(":"):                                  # lead-in to a list
-        return False
-    if re.match(r"^\(?\s*sources?\s*:", text, re.IGNORECASE):  # "(Source: file.pdf)"
-        return False
-    return True
+    return not re.match(r"^\(?\s*sources?\s*:", text, re.IGNORECASE)
 
 
 def _split_sentences(text: str) -> list[str]:
-    # Split on sentence punctuation and newlines so bulleted/list answers
-    # become individual claims; strip leading bullet markers, then drop
-    # framing/meta lines that aren't verifiable factual statements.
+    """Break an answer into individual claims, handling bullet lists and markdown."""
     parts = re.split(r"(?<=[.!?])\s+|\n+", text.strip())
     cleaned = []
     for p in parts:
         p = p.lstrip("*-•· \t")
-        p = re.sub(r"[*_`]+", "", p).strip()   # strip markdown emphasis (**bold**, *italic*, `code`)
+        p = re.sub(r"[*_`]+", "", p).strip()
         cleaned.append(p)
     return [p for p in cleaned if _is_claim(p)]
 
 
 def _split_evidence(context: str) -> list[str]:
-    """Break the retrieved context into individual evidence sentences.
-
-    Source markers like "[File: x]" / "[Source: Page 3]" are stripped, then the
-    text is split on sentence boundaries and newlines. NLI is far more reliable
-    with single-sentence premises than with whole multi-sentence chunks."""
+    """Source text split into single sentences (NLI is far more reliable per-sentence
+    than against a whole multi-sentence chunk). Source markers are stripped first."""
     cleaned = re.sub(r"\[(?:File|Source)[^\]]*\]", " ", context)
     parts = re.split(r"(?<=[.!?])\s+|\n+", cleaned.strip())
     return [p.strip() for p in parts if len(p.strip()) > 15]
 
 
-# --- metrics ---------------------------------------------------------------
-
-_TOP_EVIDENCE = 4   # source sentences considered per claim
-
-# Leading proper-noun subject of 2-4 capitalized words, e.g. "Devi Sri Bandaru ".
-_SUBJECT_RE = re.compile(r"^[A-Z][a-z]+(?:\s+[A-Z][a-z]+){1,3}\s+")
-
-
 def _strip_subject(claim: str) -> str:
-    """Drop a leading proper-noun subject so a subjectless source sentence can
-    still entail the fact. Used only as an extra variant (we keep the max), so a
-    wrong strip never lowers the score."""
+    """Drop a leading proper-noun subject so a subjectless source sentence can still
+    entail the fact. Only ever used as an extra variant (we keep the max), so a wrong
+    strip never lowers the score."""
     return _SUBJECT_RE.sub("", claim)
 
 
 def faithfulness_score(answer: str, source_context: str) -> float:
-    """RAGAS-style faithfulness: is each claim in the answer supported by the source?
-
-    For every answer sentence (claim) we take its most similar source sentences and
-    test entailment against each one *and* their concatenation, keeping the best
-    (max). Single sentences support simple/verbatim claims; the concatenation
-    supports compound claims that combine facts from several source sentences. The
-    score is the mean over claims (0-1) — robust to irrelevant passages (e.g. extra
-    web results), while contradicted or unsupported claims correctly fall toward 0."""
+    """Mean entailment of each answer claim against the source it was drawn from (0-1).
+
+    Each claim is tested against its most similar source sentences and their
+    concatenation, keeping the best match. A claim is faithful if some evidence entails
+    it, so the score is robust to irrelevant passages while contradicted or unsupported
+    claims fall toward 0."""
     if not answer.strip() or not source_context.strip():
         return 0.0
 
@@ -141,13 +111,9 @@ def faithfulness_score(answer: str, source_context: str) -> float:
         pairs, owners = [], []
         for i in range(len(claims)):
             idxs = sims[i].topk(topk).indices.tolist()
-            best = evidence[idxs[0]]                       # supports simple claims
-            concat = " ".join(evidence[j] for j in idxs)   # supports compound claims
+            best = evidence[idxs[0]]
+            concat = " ".join(evidence[j] for j in idxs)
             premises = [best] if best == concat else [best, concat]
-            # Document bullets are often subjectless ("Architected a RAG pipeline"),
-            # while answers prepend the person's name ("Devi Sri Bandaru architected
-            # ..."), which NLI reads as unsupported. Also test a subject-stripped
-            # variant and keep the best.
             variants = [claims[i]]
             stripped = _strip_subject(claims[i])
             if stripped != claims[i] and len(stripped) > 10:
@@ -157,9 +123,7 @@ def faithfulness_score(answer: str, source_context: str) -> float:
                     pairs.append((premise, variant))
                     owners.append(i)
 
-        model_nli = _nli()
-        entail = _softmax(np.asarray(model_nli.predict(pairs)))[:, _entail_idx]
-
+        entail = _softmax(np.asarray(_nli().predict(pairs)))[:, _entail_idx]
         per_claim = [0.0] * len(claims)
         for owner, e in zip(owners, entail):
             per_claim[owner] = max(per_claim[owner], float(e))
@@ -170,12 +134,12 @@ def faithfulness_score(answer: str, source_context: str) -> float:
 
 
 def answer_relevance_score(question: str, answer: str) -> float:
-    """Does the answer address the question? Cosine similarity (0–1)."""
+    """Cosine similarity between the question and the answer (0-1)."""
     return _cosine(question, answer)
 
 
 def accuracy_score(answer: str, reference: str) -> float:
-    """ROUGE-L F1 vs a user-supplied reference answer (0–1)."""
+    """ROUGE-L F1 between the answer and a user-supplied reference (0-1)."""
     if not answer.strip() or not reference.strip():
         return 0.0
     return round(_rouge.score(reference, answer)["rougeL"].fmeasure, 3)

src/main.py

@@ -117,8 +117,7 @@ async def chat(request: QueryRequest):
             result = agent.invoke({"messages": messages})
             answer = extract_content(result["messages"][-1])
 
-            # Some models occasionally emit an empty final turn after a tool call;
-            # retry before giving up so the user never sees a blank reply.
+            # Some models occasionally return an empty turn after a tool call; retry.
             if not answer.strip():
                 logger.warning("Empty answer from model; retrying.")
                 if attempt < 2:
@@ -135,7 +134,6 @@ async def chat(request: QueryRequest):
             relevance = answer_relevance_score(request.query, answer)
             acc = accuracy_score(answer, request.reference) if request.reference else None
 
-            # Update conversation memory, summarizing older turns when it grows
             memory.add_turn(request.query, answer)
             try:
                 memory.summarize_if_needed(_summarizer(api_key))
@@ -163,7 +161,7 @@ async def chat(request: QueryRequest):
                 raise HTTPException(status_code=500, detail=error_str)
             delay = retry_delay(error_str)
             if delay and delay <= 120 and attempt < 2:
-                logger.warning(f"Rate limited — retrying in {delay:.0f}s...")
+                logger.warning(f"Rate limited, retrying in {delay:.0f}s...")
                 time.sleep(delay + 1)
                 continue
             raise HTTPException(

src/memory.py

@@ -1,19 +1,5 @@
-"""
-Conversation memory with rolling summarization.
-
-Long chats are expensive: sending the whole history to the LLM on every turn
-grows token cost without bound and eventually overflows the context window.
-
-Strategy (sliding window + summary):
-  - Keep the most recent `keep_recent` turns verbatim.
-  - When the history grows past `max_turns`, fold the *older* turns into a running
-    natural-language summary (one cheap LLM call) and drop them from the window.
-  - Each request then sends: [summary] + [recent turns] + [new question] — bounded
-    in size no matter how long the conversation runs.
-
-The summarizer is injected (a callable str -> str), so this class is pure and
-unit-testable without any API calls.
-"""
+"""Per-session conversation memory. Recent turns are kept verbatim; older turns are
+folded into a running summary so long chats stay within the model's context window."""
 
 from dataclasses import dataclass, field
 from typing import Callable

src/prefetch_models.py

@@ -1,14 +1,10 @@
-"""
-Download the embedding + NLI models at image-build time so the running
-container starts fast and never needs network access for models at runtime.
-"""
+"""Download the embedding and NLI models at build time so the container runs offline."""
 
 from src.embeddings import get_sentence_transformer
 from src.evaluator import _nli
 
 if __name__ == "__main__":
-    print("Prefetching embedding model (all-MiniLM-L6-v2)...")
+    print("Prefetching embedding and NLI models...")
     get_sentence_transformer()
-    print("Prefetching NLI model (cross-encoder/nli-deberta-v3-small)...")
     _nli()
-    print("Models cached.")
+    print("Done.")

src/rag_engine.py

@@ -4,9 +4,6 @@ from langchain_community.document_loaders import PyPDFLoader
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
 from src.embeddings import get_embeddings
-from dotenv import load_dotenv
-
-load_dotenv()
 
 logger = logging.getLogger(__name__)
 

src/utils.py

@@ -33,7 +33,7 @@ def parse_tool_results(messages: list) -> tuple[str, str]:
     """Return (source_type, combined_tool_output) from the agent message chain.
 
     source_type is 'rag', 'web', 'rag+web', or 'unknown'. The combined output is
-    the actual text the tools returned — what faithfulness is measured against.
+    the actual text the tools returned, which faithfulness is measured against.
     """
     rag_parts, web_parts = [], []
     for msg in messages:

tests/evaluate.py

@@ -1,9 +1,6 @@
-"""
-Evaluation pipeline — two metrics per question:
-  1. Faithfulness  : is the answer grounded in the retrieved context? (hallucination check)
-  2. Accuracy      : does the answer correctly match the ground truth?
-Run from the project root:  python -m tests.evaluate
-"""
+"""Offline LLM-as-a-judge evaluation. Grades the agent on two metrics per question:
+faithfulness (grounded in the retrieved context?) and accuracy (matches ground truth?).
+Run from the project root: python -m tests.evaluate"""
 
 import sys
 import os
@@ -22,10 +19,6 @@ except ImportError:
     sys.exit(1)
 
 
-# ---------------------------------------------------------------------------
-# Judge prompts
-# ---------------------------------------------------------------------------
-
 FAITHFULNESS_PROMPT = """\
 You are evaluating whether an AI answer is grounded in the provided source context.
 
@@ -65,10 +58,6 @@ Score: [1-10]
 Reason: [one sentence]"""
 
 
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
 def extract_content(message) -> str:
     content = message.content
     if isinstance(content, list):
@@ -94,13 +83,8 @@ def get_context(question: str) -> str:
     return _fallback_kb.retrieve(question)
 
 
-# ---------------------------------------------------------------------------
-# Test cases
-# ---------------------------------------------------------------------------
-# Add your own Q&A pairs here. For web-search questions, leave ground_truth
-# as None — only faithfulness will be skipped (no ground truth to compare).
-# ---------------------------------------------------------------------------
-
+# Add your own Q&A pairs here. Leave ground_truth as None for web questions
+# (accuracy is then skipped, since there is nothing to compare against).
 TEST_CASES = [
     {
         "question": "What are the reporting requirements for State Parties?",
@@ -123,13 +107,9 @@ TEST_CASES = [
 ]
 
 
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
 def run_evaluation(test_cases: list = None):
     cases = test_cases or TEST_CASES
-    print(f"Starting evaluation — {len(cases)} test case(s)\n")
+    print(f"Starting evaluation ({len(cases)} test case(s))\n")
 
     api_key = os.getenv("GOOGLE_API_KEY")
     if not api_key:
@@ -153,7 +133,6 @@ def run_evaluation(test_cases: list = None):
 
         print(f"[{i}/{len(cases)}] {question}")
 
-        # 1. Get agent answer
         try:
             result = agent.invoke({"messages": [("user", question)]})
             answer = extract_content(result["messages"][-1])
@@ -167,7 +146,7 @@ def run_evaluation(test_cases: list = None):
 
         print(f"  Answer: {answer[:120]}...")
 
-        # 2. Faithfulness check (hallucination detection) — RAG questions only
+        # Faithfulness only applies to document-grounded answers
         faithfulness_score, faithfulness_reason = "-", "N/A (web search question)"
         if source == "rag":
             try:
@@ -183,7 +162,7 @@ def run_evaluation(test_cases: list = None):
                 faithfulness_reason = str(e)
                 print(f"  Faithfulness check failed: {e}")
 
-        # 3. Accuracy check — only if ground truth is provided
+        # Accuracy only when a ground truth is provided
         accuracy_score, accuracy_reason = "-", "N/A (no ground truth)"
         if ground_truth:
             try:

tests/test_evaluator.py

@@ -1,8 +1,5 @@
-"""
-Unit tests for the lightweight evaluator pieces (ROUGE accuracy + text helpers).
-The embedding/NLI metrics are intentionally not exercised here so CI stays fast
-and offline — they require model downloads and are validated manually.
-"""
+"""Unit tests for the lightweight evaluator pieces (ROUGE accuracy and text helpers).
+The embedding/NLI metrics need model downloads, so they are validated manually, not in CI."""
 
 import numpy as np
 from src.evaluator import accuracy_score, _split_sentences, _softmax