chatrag

.env.example

@@ -1,16 +1,12 @@
 KB_BACKEND=qdrant
-RAG_RETRIEVAL_MODE=semantic
-RAG_LLM_RERANK=true
-RAG_RERANK_CANDIDATES=8
-RAG_RERANK_MAX_TOKENS=280
+RAG_RETRIEVAL_MODE=lexical
 QDRANT_URL=
 QDRANT_API_KEY=
 QDRANT_COLLECTION=doc_kb
 
 HUGGINGFACE_API_TOKEN=
 GROQ_API_KEY=
-RAG_MODEL_ID=llama-3.1-8b-instant
-RAG_MODEL_CANDIDATES=llama-3.1-8b-instant,llama-3.3-70b-versatile,openai/gpt-oss-20b
+RAG_MODEL_ID=openai/gpt-oss-20b
 RAG_TEMPERATURE=0.2
 RAG_MAX_TOKENS=512
 

README.md

@@ -2,7 +2,7 @@
 license: mit
 title: ChatQnA RAG Service
 sdk: docker
-emoji: ⚡
+emoji: 🚀
 colorFrom: red
 colorTo: yellow
 ---

app/main.py

@@ -1,34 +1,33 @@
-from __future__ import annotations
-
-import json
+from __future__ import annotations
+
 import math
 import os
 import re
 import traceback
-from collections import Counter
-from pathlib import Path
-from typing import Any, Optional
-
-from fastapi import FastAPI
-from openai import OpenAI
-from pydantic import BaseModel, Field
-
-from langchain_community.vectorstores import FAISS
-from langchain_qdrant import QdrantVectorStore
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from qdrant_client import QdrantClient
-from qdrant_client.http import models as qmodels
-from qdrant_client.http.models import Distance, VectorParams
-
-
-EMBED_DIM = 384
-FAISS_DIR = Path(os.getenv("FAISS_DIR", "faiss_store"))
-PAGE_RE = re.compile(r"\[PAGE\s+(\d+)\]", re.IGNORECASE)
+from collections import Counter
+from pathlib import Path
+from typing import Any, Optional
+
+from fastapi import FastAPI
+from openai import OpenAI
+from pydantic import BaseModel, Field
+
+from langchain_community.vectorstores import FAISS
+from langchain_qdrant import QdrantVectorStore
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from qdrant_client import QdrantClient
+from qdrant_client.http import models as qmodels
+from qdrant_client.http.models import Distance, VectorParams
+
+
+EMBED_DIM = 384
+FAISS_DIR = Path(os.getenv("FAISS_DIR", "faiss_store"))
+PAGE_RE = re.compile(r"\[PAGE\s+(\d+)\]", re.IGNORECASE)
 FIGURE_REF_RE = re.compile(r"\b(fig(?:ure)?\.?)\s*(\d+)\b", re.IGNORECASE)
 TABLE_REF_RE = re.compile(r"\b(tab(?:le)?\.?)\s*(\d+)\b", re.IGNORECASE)
 CITATION_REF_RE = re.compile(r"\[(S\d+)\]")
 
-VISUAL_TYPES = {
+VISUAL_TYPES = {
     "figure_explain",
     "figure_ocr",
     "figure_caption",
@@ -39,84 +38,73 @@ VISUAL_TYPES = {
     "table_pdfplumber",
     "table_unstructured",
     "tesseract_ocr",
-}
-
-_VECTORSTORE: Optional[Any] = None
-_EMBEDDINGS: Optional[Any] = None
-
-STOPWORDS = {
-    "the",
-    "and",
-    "for",
-    "with",
-    "that",
-    "this",
-    "from",
-    "into",
-    "your",
-    "about",
-    "what",
-    "which",
-    "where",
-    "when",
-    "how",
-    "why",
-    "does",
-    "did",
-    "are",
-    "is",
-    "was",
-    "were",
-    "be",
-    "been",
-    "being",
-    "have",
-    "has",
-    "had",
-    "can",
-    "could",
-    "should",
-    "would",
-    "may",
-    "might",
-    "will",
-    "shall",
-    "a",
-    "an",
-    "of",
-    "to",
-    "in",
-    "on",
-    "at",
-    "by",
-    "as",
-    "it",
-    "its",
-    "or",
-    "if",
-    "but",
-    "not",
-    "we",
-    "our",
-    "you",
-    "they",
-    "their",
-    "them",
 }
 
-DOC_GROUNDED_RE = re.compile(
-    r"\b(document|doc|pdf|page|citation|snippet|source|context|table|figure|selected)\b",
-    flags=re.IGNORECASE,
-)
-DEFAULT_MODEL_ID = "llama-3.1-8b-instant"
-DEFAULT_MODEL_CANDIDATES = [
-    "llama-3.1-8b-instant",
-    "llama-3.3-70b-versatile",
-    "openai/gpt-oss-20b",
-]
-
+_VECTORSTORE: Optional[Any] = None
+_EMBEDDINGS: Optional[Any] = None
 
-class HistoryMessage(BaseModel):
+STOPWORDS = {
+    "the",
+    "and",
+    "for",
+    "with",
+    "that",
+    "this",
+    "from",
+    "into",
+    "your",
+    "about",
+    "what",
+    "which",
+    "where",
+    "when",
+    "how",
+    "why",
+    "does",
+    "did",
+    "are",
+    "is",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "can",
+    "could",
+    "should",
+    "would",
+    "may",
+    "might",
+    "will",
+    "shall",
+    "a",
+    "an",
+    "of",
+    "to",
+    "in",
+    "on",
+    "at",
+    "by",
+    "as",
+    "it",
+    "its",
+    "or",
+    "if",
+    "but",
+    "not",
+    "we",
+    "our",
+    "you",
+    "they",
+    "their",
+    "them",
+}
+
+
+class HistoryMessage(BaseModel):
     role: str
     content: str
 
@@ -166,73 +154,38 @@ class QueryResponse(BaseModel):
 app = FastAPI(title="chatqna-rag-service", version="0.2.0")
 
 
-def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
-    return os.getenv(name, default)
-
-
-def get_bool_secret(name: str, default: bool = False) -> bool:
-    raw = (get_secret(name, str(default)) or "").strip().lower()
-    return raw in {"1", "true", "yes", "on"}
-
-
-def normalize_text(text: str) -> str:
-    return (text or "").strip()
-
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    return os.getenv(name, default)
 
-def get_embeddings() -> Any:
-    """
-    Lazy-load sentence-transformers stack to keep startup memory low.
-    """
-    global _EMBEDDINGS
-    if _EMBEDDINGS is None:
-        from langchain_huggingface import HuggingFaceEmbeddings
 
-        _EMBEDDINGS = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-    return _EMBEDDINGS
-
-
-def get_retrieval_mode() -> str:
-    mode = (get_secret("RAG_RETRIEVAL_MODE", "semantic") or "semantic").strip().lower()
-    return mode if mode in {"lexical", "semantic"} else "semantic"
+def normalize_text(text: str) -> str:
+    return (text or "").strip()
 
 
-def get_rerank_enabled() -> bool:
-    return get_bool_secret("RAG_LLM_RERANK", True)
-
-
-def get_rerank_candidate_k(top_k: int) -> int:
-    cfg = int(get_secret("RAG_RERANK_CANDIDATES", "8") or "8")
-    cfg = max(3, min(cfg, 16))
-    return max(int(top_k), cfg)
-
-
-def hf_routed_model(model_id: str) -> str:
-    return model_id if ":" in model_id else f"{model_id}:groq"
+def get_embeddings() -> Any:
+    """
+    Lazy-load sentence-transformers stack to keep startup memory low.
+    """
+    global _EMBEDDINGS
+    if _EMBEDDINGS is None:
+        from langchain_huggingface import HuggingFaceEmbeddings
 
+        _EMBEDDINGS = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    return _EMBEDDINGS
 
-def get_model_candidates(model_id: str) -> list[str]:
-    preferred = normalize_text(model_id) or DEFAULT_MODEL_ID
-    raw = (get_secret("RAG_MODEL_CANDIDATES", "") or "").strip()
-    if raw:
-        candidates = [normalize_text(part) for part in raw.split(",")]
-        candidates = [c for c in candidates if c]
-    else:
-        candidates = [preferred] + [m for m in DEFAULT_MODEL_CANDIDATES if m != preferred]
 
-    deduped: list[str] = []
-    seen: set[str] = set()
-    for candidate in candidates:
-        key = candidate.lower()
-        if key in seen:
-            continue
-        seen.add(key)
-        deduped.append(candidate)
-    return deduped or [DEFAULT_MODEL_ID]
+def get_retrieval_mode() -> str:
+    mode = (get_secret("RAG_RETRIEVAL_MODE", "lexical") or "lexical").strip().lower()
+    return mode if mode in {"lexical", "semantic"} else "lexical"
 
 
-def openai_chat(
-    client: OpenAI,
-    model: str,
+def hf_routed_model(model_id: str) -> str:
+    return model_id if ":" in model_id else f"{model_id}:groq"
+
+
+def openai_chat(
+    client: OpenAI,
+    model: str,
     messages: list[dict[str, Any]],
     temperature: float,
     max_tokens: int,
@@ -248,74 +201,51 @@ def openai_chat(
     return content or "", resp
 
 
-def llm_chat_with_fallback(
-    model_id: str,
+def llm_chat_with_fallback(
+    model_id: str,
     messages: list[dict[str, Any]],
     temperature: float,
     max_tokens: int,
     hf_token: Optional[str],
     groq_key: Optional[str],
-) -> dict[str, Any]:
-    result: dict[str, Any] = {
-        "content": "",
-        "primary_used": False,
-        "raw": None,
-        "used_model": None,
-        "error_primary": None,
-        "error_fallback": None,
-    }
-    candidate_models = get_model_candidates(model_id)
-
-    if hf_token:
-        primary_errors: list[str] = []
-        try:
-            hf_client = OpenAI(base_url="https://router.huggingface.co/v1", api_key=hf_token)
-            for candidate in candidate_models:
-                try:
-                    routed = hf_routed_model(candidate)
-                    content, raw = openai_chat(hf_client, routed, messages, temperature, max_tokens)
-                    if normalize_text(content):
-                        result.update(
-                            {
-                                "content": content,
-                                "primary_used": True,
-                                "raw": raw,
-                                "used_model": candidate,
-                            }
-                        )
-                        return result
-                    primary_errors.append(f"{candidate}: empty content")
-                except Exception as exc:  # pragma: no cover
-                    primary_errors.append(f"{candidate}: {type(exc).__name__}: {exc}")
-        except Exception as exc:  # pragma: no cover
-            primary_errors.append(f"hf_client_init: {type(exc).__name__}: {exc}")
-        result["error_primary"] = " | ".join(primary_errors[:4]) or "Primary returned empty content."
-    else:
-        result["error_primary"] = "Missing HUGGINGFACE_API_TOKEN"
-
-    if not groq_key:
-        result["error_fallback"] = "Missing GROQ_API_KEY (fallback not available)"
-        return result
-
-    fallback_errors: list[str] = []
-    try:
-        groq_client = OpenAI(base_url="https://api.groq.com/openai/v1", api_key=groq_key)
-        for candidate in candidate_models:
-            try:
-                content, raw = openai_chat(groq_client, candidate, messages, temperature, max_tokens)
-                if normalize_text(content):
-                    result.update({"content": content, "raw": raw, "used_model": candidate})
-                    return result
-                fallback_errors.append(f"{candidate}: empty content")
-            except Exception as exc:  # pragma: no cover
-                fallback_errors.append(f"{candidate}: {type(exc).__name__}: {exc}")
-    except Exception as exc:  # pragma: no cover
-        fallback_errors.append(f"groq_client_init: {type(exc).__name__}: {exc}")
-    result["error_fallback"] = " | ".join(fallback_errors[:4]) or "Fallback returned empty content."
-    return result
-
-
-def load_faiss(embeddings: Any, path: Path = FAISS_DIR) -> Optional[FAISS]:
+) -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "content": "",
+        "primary_used": False,
+        "raw": None,
+        "error_primary": None,
+        "error_fallback": None,
+    }
+
+    if hf_token:
+        try:
+            hf_client = OpenAI(base_url="https://router.huggingface.co/v1", api_key=hf_token)
+            routed = hf_routed_model(model_id)
+            content, raw = openai_chat(hf_client, routed, messages, temperature, max_tokens)
+            if normalize_text(content):
+                result.update({"content": content, "primary_used": True, "raw": raw})
+                return result
+            result["error_primary"] = "Primary returned empty content."
+        except Exception as exc:  # pragma: no cover
+            result["error_primary"] = f"{type(exc).__name__}: {exc}"
+    else:
+        result["error_primary"] = "Missing HUGGINGFACE_API_TOKEN"
+
+    if not groq_key:
+        result["error_fallback"] = "Missing GROQ_API_KEY (fallback not available)"
+        return result
+
+    try:
+        groq_client = OpenAI(base_url="https://api.groq.com/openai/v1", api_key=groq_key)
+        content, raw = openai_chat(groq_client, model_id, messages, temperature, max_tokens)
+        result.update({"content": content, "raw": raw})
+        return result
+    except Exception as exc:  # pragma: no cover
+        result["error_fallback"] = f"{type(exc).__name__}: {exc}"
+        return result
+
+
+def load_faiss(embeddings: Any, path: Path = FAISS_DIR) -> Optional[FAISS]:
     if (path / "index.faiss").exists() and (path / "index.pkl").exists():
         return FAISS.load_local(str(path), embeddings, allow_dangerous_deserialization=True)
     return None
@@ -337,8 +267,8 @@ def init_qdrant_vectorstore() -> tuple[Optional[QdrantVectorStore], Optional[str
                 collection_name=collection_name,
                 vectors_config=VectorParams(size=EMBED_DIM, distance=Distance.COSINE),
             )
-        store = QdrantVectorStore(client=client, collection_name=collection_name, embedding=get_embeddings())
-        return store, None
+        store = QdrantVectorStore(client=client, collection_name=collection_name, embedding=get_embeddings())
+        return store, None
     except Exception as exc:
         return None, f"{type(exc).__name__}: {exc}"
 
@@ -355,8 +285,8 @@ def ensure_vectorstore() -> Optional[Any]:
             _VECTORSTORE = store
             return _VECTORSTORE
 
-    _VECTORSTORE = load_faiss(get_embeddings())
-    return _VECTORSTORE
+    _VECTORSTORE = load_faiss(get_embeddings())
+    return _VECTORSTORE
 
 
 def qdrant_filter_for_chunk_types(types: list[str]) -> qmodels.Filter:
@@ -447,31 +377,31 @@ def dot(a: list[float], b: list[float]) -> float:
     return sum(x * y for x, y in zip(a, b))
 
 
-def cosine_similarity(a: list[float], b: list[float]) -> float:
+def cosine_similarity(a: list[float], b: list[float]) -> float:
     na = math.sqrt(dot(a, a))
     nb = math.sqrt(dot(b, b))
     if na == 0.0 or nb == 0.0:
         return 0.0
-    return dot(a, b) / (na * nb)
-
-
-def tokenize_retrieval(text: str) -> list[str]:
-    toks = re.findall(r"[A-Za-z0-9][A-Za-z0-9\-_]{1,}", text or "")
-    return [t.lower() for t in toks if t.lower() not in STOPWORDS]
-
-
-def lexical_overlap_score(query: str, text: str) -> float:
-    q_tokens = tokenize_retrieval(query)
-    t_tokens = tokenize_retrieval(text)
-    if not q_tokens or not t_tokens:
-        return 0.0
-    q_count = Counter(q_tokens)
-    t_count = Counter(t_tokens)
-    overlap = sum(min(cnt, t_count.get(tok, 0)) for tok, cnt in q_count.items())
-    if overlap <= 0:
-        return 0.0
-    # Lightweight score favoring chunks with better query coverage.
-    return overlap / float(len(q_tokens) + 0.35 * len(t_tokens))
+    return dot(a, b) / (na * nb)
+
+
+def tokenize_retrieval(text: str) -> list[str]:
+    toks = re.findall(r"[A-Za-z0-9][A-Za-z0-9\-_]{1,}", text or "")
+    return [t.lower() for t in toks if t.lower() not in STOPWORDS]
+
+
+def lexical_overlap_score(query: str, text: str) -> float:
+    q_tokens = tokenize_retrieval(query)
+    t_tokens = tokenize_retrieval(text)
+    if not q_tokens or not t_tokens:
+        return 0.0
+    q_count = Counter(q_tokens)
+    t_count = Counter(t_tokens)
+    overlap = sum(min(cnt, t_count.get(tok, 0)) for tok, cnt in q_count.items())
+    if overlap <= 0:
+        return 0.0
+    # Lightweight score favoring chunks with better query coverage.
+    return overlap / float(len(q_tokens) + 0.35 * len(t_tokens))
 
 
 def split_text_with_offsets(text: str, chunk_size: int, chunk_overlap: int) -> list[dict[str, Any]]:
@@ -502,7 +432,7 @@ def split_text_with_offsets(text: str, chunk_size: int, chunk_overlap: int) -> l
     return chunks
 
 
-def retrieve_from_uploaded_document(payload: QueryRequest) -> list[dict[str, Any]]:
+def retrieve_from_uploaded_document(payload: QueryRequest) -> list[dict[str, Any]]:
     document = payload.document
     document_text = (document.documentText if document else "") or ""
     if not document_text.strip():
@@ -514,22 +444,21 @@ def retrieve_from_uploaded_document(payload: QueryRequest) -> list[dict[str, Any
     if not chunks:
         return []
 
-    ranked: list[dict[str, Any]] = []
-    if get_retrieval_mode() == "semantic":
-        embeddings = get_embeddings()
-        query_vec = embeddings.embed_query(payload.message)
-        doc_vecs = embeddings.embed_documents([c["text"] for c in chunks])
-        for chunk, vec in zip(chunks, doc_vecs):
-            score = cosine_similarity(query_vec, vec)
-            ranked.append({**chunk, "score": float(score)})
-    else:
-        for chunk in chunks:
-            score = lexical_overlap_score(payload.message, str(chunk.get("text") or ""))
-            ranked.append({**chunk, "score": float(score)})
+    ranked: list[dict[str, Any]] = []
+    if get_retrieval_mode() == "semantic":
+        embeddings = get_embeddings()
+        query_vec = embeddings.embed_query(payload.message)
+        doc_vecs = embeddings.embed_documents([c["text"] for c in chunks])
+        for chunk, vec in zip(chunks, doc_vecs):
+            score = cosine_similarity(query_vec, vec)
+            ranked.append({**chunk, "score": float(score)})
+    else:
+        for chunk in chunks:
+            score = lexical_overlap_score(payload.message, str(chunk.get("text") or ""))
+            ranked.append({**chunk, "score": float(score)})
 
-    ranked.sort(key=lambda c: c["score"], reverse=True)
-    candidate_k = get_rerank_candidate_k(payload.topK) if get_rerank_enabled() else int(payload.topK)
-    top_k = max(1, min(candidate_k, len(ranked)))
+    ranked.sort(key=lambda c: c["score"], reverse=True)
+    top_k = max(1, min(payload.topK, len(ranked)))
     out: list[dict[str, Any]] = []
     for idx, item in enumerate(ranked[:top_k], start=1):
         out.append(
@@ -559,14 +488,13 @@ def locate_offsets_in_document(text: str, snippet: str) -> tuple[Optional[int],
     return idx, min(len(source), idx + len(needle))
 
 
-def retrieve_from_vectorstore(payload: QueryRequest) -> list[dict[str, Any]]:
+def retrieve_from_vectorstore(payload: QueryRequest) -> list[dict[str, Any]]:
     vectorstore = ensure_vectorstore()
     if vectorstore is None:
         return []
 
-    prefer_visual = is_visual_question(payload.message)
-    requested_k = get_rerank_candidate_k(payload.topK) if get_rerank_enabled() else int(payload.topK)
-    k = max(int(requested_k), 10) if prefer_visual else int(requested_k)
+    prefer_visual = is_visual_question(payload.message)
+    k = max(int(payload.topK), 10) if prefer_visual else int(payload.topK)
     docs = retrieve_docs(vectorstore, payload.message, k=k, prefer_visual=prefer_visual)
     if not docs:
         return []
@@ -602,128 +530,10 @@ def retrieve_from_vectorstore(payload: QueryRequest) -> list[dict[str, Any]]:
                 "score": None,
             }
         )
-    return out
-
-
-def extract_json_object(text: str) -> Optional[dict[str, Any]]:
-    raw = (text or "").strip()
-    if not raw:
-        return None
-
-    try:
-        data = json.loads(raw)
-        return data if isinstance(data, dict) else None
-    except Exception:
-        pass
-
-    fenced = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw, flags=re.IGNORECASE)
-    if fenced:
-        block = fenced.group(1).strip()
-        try:
-            data = json.loads(block)
-            return data if isinstance(data, dict) else None
-        except Exception:
-            pass
-
-    start = raw.find("{")
-    end = raw.rfind("}")
-    if start >= 0 and end > start:
-        try:
-            data = json.loads(raw[start : end + 1])
-            return data if isinstance(data, dict) else None
-        except Exception:
-            return None
-    return None
-
-
-def llm_rerank_chunks(
-    question: str,
-    history: list[dict[str, str]],
-    chunks: list[dict[str, Any]],
-    model_id: str,
-    hf_token: Optional[str],
-    groq_key: Optional[str],
-) -> tuple[list[dict[str, Any]], Optional[str]]:
-    if not get_rerank_enabled() or len(chunks) < 2:
-        return chunks, None
-
-    candidate_limit = min(len(chunks), get_rerank_candidate_k(len(chunks)))
-    candidates = chunks[:candidate_limit]
-    by_id = {str(c.get("id")): c for c in candidates if c.get("id")}
-    if len(by_id) < 2:
-        return chunks, None
-
-    history_tail = history[-4:] if history else []
-    history_text = "\n".join(f"{m.get('role', 'user')}: {(m.get('content') or '')[:240]}" for m in history_tail)
-    candidate_lines: list[str] = []
-    for c in candidates:
-        sid = str(c.get("id") or "")
-        page = c.get("page") or 1
-        ctype = c.get("chunkType") or "main_text"
-        txt = (c.get("text") or "").strip().replace("\n", " ")
-        if len(txt) > 800:
-            txt = txt[:800] + "..."
-        candidate_lines.append(f"[{sid}] page={page} type={ctype} text={txt}")
-
-    rerank_messages: list[dict[str, str]] = [
-        {
-            "role": "system",
-            "content": (
-                "You are a retrieval ranker. Return ONLY JSON with keys: "
-                "ordered_ids (array of snippet IDs sorted by relevance), "
-                "needs_clarification (boolean), clarification_question (string). "
-                "Do not answer the user question directly. "
-                "If the user query is ambiguous relative to snippets, set needs_clarification=true and ask one concise question."
-            ),
-        },
-        {
-            "role": "user",
-            "content": (
-                f"Conversation tail:\n{history_text or '(none)'}\n\n"
-                f"Question:\n{question}\n\n"
-                f"Candidate snippets:\n" + "\n".join(candidate_lines)
-            ),
-        },
-    ]
-
-    rerank_max_tokens = int(get_secret("RAG_RERANK_MAX_TOKENS", "280") or "280")
-    rerank_result = llm_chat_with_fallback(
-        model_id=model_id,
-        messages=rerank_messages,
-        temperature=0.0,
-        max_tokens=max(96, min(rerank_max_tokens, 512)),
-        hf_token=hf_token,
-        groq_key=groq_key,
-    )
-    rerank_content = normalize_text(rerank_result.get("content", ""))
-    parsed = extract_json_object(rerank_content)
-    if not parsed:
-        return chunks, None
-
-    needs_clarification = bool(parsed.get("needs_clarification"))
-    clarification_question = normalize_text(str(parsed.get("clarification_question") or ""))
-    if needs_clarification and clarification_question:
-        return chunks, clarification_question
-
-    ordered_ids_raw = parsed.get("ordered_ids") or []
-    if not isinstance(ordered_ids_raw, list):
-        return chunks, None
-
-    ordered_ids: list[str] = []
-    for item in ordered_ids_raw:
-        sid = str(item or "").strip()
-        if sid and sid in by_id and sid not in ordered_ids:
-            ordered_ids.append(sid)
-
-    if not ordered_ids:
-        return chunks, None
-
-    re_ranked_candidates = [by_id[sid] for sid in ordered_ids]
-    remaining_candidates = [c for c in candidates if str(c.get("id")) not in ordered_ids]
-    return re_ranked_candidates + remaining_candidates + chunks[candidate_limit:], None
+    return out
 
 
-def build_qa_prompt_with_history(
+def build_qa_prompt_with_history(
     history: list[dict[str, str]],
     context_blocks: list[str],
     question: str,
@@ -733,51 +543,26 @@ def build_qa_prompt_with_history(
     if len(msgs) > max_history_turns * 2:
         msgs = msgs[-max_history_turns * 2 :]
 
-    messages: list[dict[str, str]] = [
-        {
-            "role": "system",
-            "content": (
-                "You are a precise assistant. Prefer answers grounded in the provided snippets. "
-                "If the query is ambiguous (for example, 'explain this') and target passage is unclear, "
-                "ask one concise clarifying question instead of guessing. "
-                "If the answer is not present in snippets, say: 'Not found in the knowledge base.' "
-                "When you use snippets, cite snippet IDs like [S1], [S2]. "
-                "For TABLE questions, prioritize [TABLE_EXPLAIN], [TABLE_OCR], [TABLE_CAPTION], "
-                "[TABLE_PDFPLUMBER], [TABLE_UNSTRUCTURED], [PAGE_OCR] snippets. "
-                "For FIGURE questions, prioritize [FIGURE_EXPLAIN], [FIGURE_OCR], [FIGURE_CAPTION], [PAGE_OCR] snippets."
-            ),
-        }
+    messages: list[dict[str, str]] = [
+        {
+            "role": "system",
+            "content": (
+                "You are a precise assistant. Answer using ONLY the provided snippets. "
+                "If the answer is not present in snippets, say: 'Not found in the knowledge base.' "
+                "Cite snippet IDs like [S1], [S2]. Every answer must include citations. "
+                "For TABLE questions, prioritize [TABLE_EXPLAIN], [TABLE_OCR], [TABLE_CAPTION], "
+                "[TABLE_PDFPLUMBER], [TABLE_UNSTRUCTURED], [PAGE_OCR] snippets. "
+                "For FIGURE questions, prioritize [FIGURE_EXPLAIN], [FIGURE_OCR], [FIGURE_CAPTION], [PAGE_OCR] snippets."
+            ),
+        }
     ]
     messages.extend(msgs)
     context_blob = "\n\n".join(context_blocks)
-    messages.append({"role": "user", "content": f"Snippets:\n{context_blob}\n\nQuestion: {question}\nAnswer:"})
-    return messages
-
-
-def build_general_chat_prompt(history: list[dict[str, str]], question: str, max_history_turns: int = 8) -> list[dict[str, str]]:
-    msgs = [m for m in history if m.get("role") in ("user", "assistant")]
-    if len(msgs) > max_history_turns * 2:
-        msgs = msgs[-max_history_turns * 2 :]
-    messages: list[dict[str, str]] = [
-        {
-            "role": "system",
-            "content": (
-                "You are ChatQnA, a concise and helpful assistant. "
-                "Answer naturally. If user asks document-specific questions without available context, "
-                "ask them to upload/select the relevant document section."
-            ),
-        }
-    ]
-    messages.extend(msgs)
-    messages.append({"role": "user", "content": question})
-    return messages
-
-
-def is_doc_grounded_query(question: str) -> bool:
-    return bool(DOC_GROUNDED_RE.search(question or ""))
-
-
-def build_local_fallback_answer(chunks: list[dict[str, Any]]) -> str:
+    messages.append({"role": "user", "content": f"Snippets:\n{context_blob}\n\nQuestion: {question}\nAnswer:"})
+    return messages
+
+
+def build_local_fallback_answer(chunks: list[dict[str, Any]]) -> str:
     if not chunks:
         return "No relevant content found in the knowledge base."
     lines = []
@@ -789,15 +574,15 @@ def build_local_fallback_answer(chunks: list[dict[str, Any]]) -> str:
     return "Based on retrieved context:\n" + "\n".join(lines)
 
 
-def build_citations(answer: str, chunks: list[dict[str, Any]]) -> list[Citation]:
+def build_citations(answer: str, chunks: list[dict[str, Any]]) -> list[Citation]:
     by_id = {str(c["id"]): c for c in chunks}
     ids: list[str] = []
     for sid in CITATION_REF_RE.findall(answer or ""):
         if sid in by_id and sid not in ids:
             ids.append(sid)
 
-    if not ids:
-        return []
+    if not ids:
+        ids = [str(c["id"]) for c in chunks[: min(3, len(chunks))]]
 
     citations: list[Citation] = []
     for sid in ids:
@@ -818,86 +603,43 @@ def build_citations(answer: str, chunks: list[dict[str, Any]]) -> list[Citation]
     return citations
 
 
-@app.get("/health")
-def health() -> dict[str, str]:
-    backend = type(_VECTORSTORE).__name__ if _VECTORSTORE is not None else "lazy_uninitialized"
-    return {"status": "ok", "service": "rag-service", "vectorstore": backend}
+@app.get("/health")
+def health() -> dict[str, str]:
+    backend = type(_VECTORSTORE).__name__ if _VECTORSTORE is not None else "lazy_uninitialized"
+    return {"status": "ok", "service": "rag-service", "vectorstore": backend}
 
 
 @app.post("/query", response_model=QueryResponse)
-def query(payload: QueryRequest) -> QueryResponse:
-    try:
-        model_id = get_secret("RAG_MODEL_ID", DEFAULT_MODEL_ID) or DEFAULT_MODEL_ID
-        temperature = float(get_secret("RAG_TEMPERATURE", "0.2") or "0.2")
-        max_tokens = int(get_secret("RAG_MAX_TOKENS", "512") or "512")
-        hf_token = get_secret("HUGGINGFACE_API_TOKEN")
-        groq_key = get_secret("GROQ_API_KEY")
-        history = [m.model_dump() for m in payload.history]
-
-        retrieved = retrieve_from_uploaded_document(payload)
-        if not retrieved:
-            retrieved = retrieve_from_vectorstore(payload)
-
-        if not retrieved:
-            if not is_doc_grounded_query(payload.message):
-                general_messages = build_general_chat_prompt(history, payload.message, max_history_turns=8)
-                general = llm_chat_with_fallback(
-                    model_id=model_id,
-                    messages=general_messages,
-                    temperature=temperature,
-                    max_tokens=max_tokens,
-                    hf_token=hf_token,
-                    groq_key=groq_key,
-                )
-                general_answer = normalize_text(general.get("content", ""))
-                if general_answer:
-                    return QueryResponse(answer=general_answer, retrievedChunks=[], citations=[])
-                return QueryResponse(
-                    answer=(
-                        "I can answer this, but the answer model is currently unavailable. "
-                        "Please retry shortly."
-                    ),
-                    retrievedChunks=[],
-                    citations=[],
-                )
-            return QueryResponse(answer="No relevant content found in the knowledge base.", retrievedChunks=[], citations=[])
-
-        retrieved, clarifying_question = llm_rerank_chunks(
-            question=payload.message,
-            history=history,
-            chunks=retrieved,
-            model_id=model_id,
-            hf_token=hf_token,
-            groq_key=groq_key,
-        )
-        if clarifying_question:
-            return QueryResponse(answer=clarifying_question, retrievedChunks=[], citations=[])
-
-        retrieved = retrieved[: max(1, int(payload.topK))]
-        context_blocks = [f"[{c['id']}] {c['text']}" for c in retrieved]
-        messages = build_qa_prompt_with_history(history, context_blocks, payload.message, max_history_turns=8)
-
-        result = llm_chat_with_fallback(
-            model_id=model_id,
-            messages=messages,
-            temperature=temperature,
+def query(payload: QueryRequest) -> QueryResponse:
+    try:
+        retrieved = retrieve_from_uploaded_document(payload)
+        if not retrieved:
+            retrieved = retrieve_from_vectorstore(payload)
+
+        if not retrieved:
+            return QueryResponse(answer="No relevant content found in the knowledge base.", retrievedChunks=[], citations=[])
+
+        context_blocks = [f"[{c['id']}] {c['text']}" for c in retrieved]
+        history = [m.model_dump() for m in payload.history]
+        messages = build_qa_prompt_with_history(history, context_blocks, payload.message, max_history_turns=8)
+
+        model_id = get_secret("RAG_MODEL_ID", "openai/gpt-oss-20b") or "openai/gpt-oss-20b"
+        temperature = float(get_secret("RAG_TEMPERATURE", "0.2") or "0.2")
+        max_tokens = int(get_secret("RAG_MAX_TOKENS", "512") or "512")
+        hf_token = get_secret("HUGGINGFACE_API_TOKEN")
+        groq_key = get_secret("GROQ_API_KEY")
+
+        result = llm_chat_with_fallback(
+            model_id=model_id,
+            messages=messages,
+            temperature=temperature,
             max_tokens=max_tokens,
             hf_token=hf_token,
             groq_key=groq_key,
-        )
-        answer = normalize_text(result.get("content", ""))
-        if not answer:
-            answer = build_local_fallback_answer(retrieved)
-            if result.get("error_primary") or result.get("error_fallback"):
-                print(
-                    "llm_unavailable:",
-                    {
-                        "model_candidates": get_model_candidates(model_id),
-                        "error_primary": result.get("error_primary"),
-                        "error_fallback": result.get("error_fallback"),
-                    },
-                )
-                answer += "\n\n(LLM unavailable right now; showing highest-signal retrieved context.)"
+        )
+        answer = normalize_text(result.get("content", ""))
+        if not answer:
+            answer = build_local_fallback_answer(retrieved)
 
         if "not found in the knowledge base" in answer.lower() and context_blocks:
             retry_messages = [
@@ -922,21 +664,21 @@ def query(payload: QueryRequest) -> QueryResponse:
         citations = build_citations(answer, retrieved)
         response_chunks = [RetrievedChunk(**chunk) for chunk in retrieved]
         return QueryResponse(answer=answer, retrievedChunks=response_chunks, citations=citations)
-    except Exception as exc:
-        trace = traceback.format_exc(limit=4)
-        print("query_exception:", trace)
-        fallback = RetrievedChunk(
-            id="S1",
-            page=1,
-            chunkType="main_text",
-            text=f"rag-service exception: {type(exc).__name__}: {exc}",
-        )
-        return QueryResponse(
-            answer=(
-                "RAG query failed and returned a guarded fallback response. "
-                "Check rag-service logs for details."
-            ),
-            retrievedChunks=[fallback],
-            citations=[Citation(id="S1", page=1, chunkType="main_text", text=fallback.text)],
-        )
+    except Exception as exc:
+        trace = traceback.format_exc(limit=4)
+        fallback = RetrievedChunk(
+            id="S1",
+            page=1,
+            chunkType="main_text",
+            text=f"rag-service exception: {type(exc).__name__}: {exc}",
+        )
+        return QueryResponse(
+            answer=(
+                "RAG query failed and returned a guarded fallback response. "
+                "Check rag-service logs for details.\n\n"
+                f"{trace}"
+            ),
+            retrievedChunks=[fallback],
+            citations=[Citation(id="S1", page=1, chunkType="main_text", text=fallback.text)],
+        )
 

requirements.txt

@@ -2,7 +2,6 @@ fastapi==0.115.5
 uvicorn[standard]==0.32.0
 pydantic==2.9.2
 openai==1.54.4
-httpx==0.27.2
 langchain-text-splitters==0.3.2
 langchain-huggingface==0.1.0
 langchain-community==0.3.7