Update services/kb_creation.py

services/kb_creation.py

@@ -1,16 +1,13 @@
+
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
 services/kb_creation.py
 
-Single-file replacement to make NOVA's KB search and intent logic generic and
-meaning-aware. Intent is classified semantically (not via brittle keywords).
-Ranking combines semantic similarity, BM25 lexical signals, and semantic meta
-overlap with SOP filename/title/section.
-
-If EXACT context is found → return full steps from that topic/section.
-If only PARTIAL context is found → return concise response clipped to partial
-matches.
+Generic, meaning-aware intent & ranking:
+- Semantic intent classification (no keyword rules).
+- Hybrid score = semantic similarity + BM25 + lexical meta overlap + semantic meta overlap.
+- Chroma 'include' excludes 'ids'; IDs synthesized from metadata.
 """
 
 import os
@@ -22,15 +19,15 @@ from docx import Document
 from sentence_transformers import SentenceTransformer
 import chromadb
 
-# --------------------------- ChromaDB setup ---------------------------
+# -------- ChromaDB --------
 CHROMA_PATH = os.path.join(os.getcwd(), "chroma_db")
 client = chromadb.PersistentClient(path=CHROMA_PATH)
 collection = client.get_or_create_collection(name="knowledge_base")
 
-# --------------------------- Embedding model --------------------------
+# -------- Embeddings --------
 model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
 
-# --------------------------- BM25 (lightweight) -----------------------
+# -------- BM25 (lightweight) --------
 BM25_INDEX_FILE = os.path.join(CHROMA_PATH, "bm25_index.pkl")
 bm25_docs: List[Dict[str, Any]] = []
 bm25_inverted: Dict[str, List[int]] = {}
@@ -40,36 +37,26 @@ bm25_ready: bool = False
 BM25_K1 = 1.5
 BM25_B = 0.75
 
-# --------------------------- Utilities --------------------------------
+# -------- Utilities --------
 def _tokenize(text: str) -> List[str]:
-    if not text:
-        return []
+    if not text: return []
     text = text.lower()
     return re.findall(r"[a-z0-9]+", text)
 
-
 def _normalize_query(q: str) -> str:
     q = (q or "").strip().lower()
     q = re.sub(r"[^\w\s]", " ", q)
-    # remove filler issue words
-    q = re.sub(
-        r"\b(facing|get|getting|got|seeing|receiving|encountered|having|observing|issue|problem)\b",
-        " ",
-        q,
-    )
+    q = re.sub(r"\b(facing|get|getting|got|seeing|receiving|encountered|having|observing|issue|problem)\b", " ", q)
     q = re.sub(r"\s+", " ", q).strip()
     return q
 
-
 def _tokenize_meta_value(val: Optional[str]) -> List[str]:
     return _tokenize(val or "")
 
-# ---------------------- DOCX parsing & chunking -----------------------
-
+# -------- DOCX parsing & chunking --------
 def _split_by_sections(doc: Document) -> List[Tuple[str, List[str]]]:
     sections: List[Tuple[str, List[str]]] = []
-    current_title = None
-    current_paras: List[str] = []
+    current_title, current_paras = None, []
     for para in doc.paragraphs:
         text = (para.text or "").strip()
         style_name = (para.style.name if para.style else "") or ""
@@ -77,8 +64,7 @@ def _split_by_sections(doc: Document) -> List[Tuple[str, List[str]]]:
         if is_heading and text:
             if current_title or current_paras:
                 sections.append((current_title or "Untitled Section", current_paras))
-            current_title = text
-            current_paras = []
+            current_title, current_paras = text, []
         else:
             if text:
                 current_paras.append(text)
@@ -89,44 +75,31 @@ def _split_by_sections(doc: Document) -> List[Tuple[str, List[str]]]:
         sections = [("Document", all_text)]
     return sections
 
-
 def _chunk_text_with_context(doc_title: str, section_title: str, paragraphs: List[str], max_words: int = 900) -> List[str]:
     body = "\n".join(paragraphs).strip()
-    if not body:
-        return []
+    if not body: return []
     words = body.split()
     chunks: List[str] = []
     for i in range(0, len(words), max_words):
         chunk_body = ' '.join(words[i:i + max_words]).strip()
         if chunk_body:
             chunks.append(chunk_body)
-    if not chunks:
-        chunks = [body]
+    if not chunks: chunks = [body]
     return chunks
 
-# ---------------------- Intent tagging (section-based) ----------------
-
+# -------- Intent tag from section (for metadata only) --------
 def _infer_intent_tag(section_title: str) -> str:
     st = (section_title or "").lower()
-    if any(k in st for k in ["process steps", "procedure", "how to", "workflow", "instructions"]):
-        return "steps"
-    if any(k in st for k in ["common errors", "resolution", "troubleshooting"]):
-        return "errors"
-    if any(k in st for k in ["pre-requisites", "prerequisites"]):
-        return "prereqs"
-    if any(k in st for k in ["purpose", "overview", "introduction"]):
-        return "purpose"
+    if any(k in st for k in ["process steps", "procedure", "how to", "workflow", "instructions"]): return "steps"
+    if any(k in st for k in ["common errors", "resolution", "troubleshooting"]): return "errors"
+    if any(k in st for k in ["pre-requisites", "prerequisites"]): return "prereqs"
+    if any(k in st for k in ["purpose", "overview", "introduction"]): return "purpose"
     return "neutral"
 
-# ---------------------- Ingestion ------------------------------------
-
+# -------- Ingestion --------
 def ingest_documents(folder_path: str) -> None:
-    print(f"📂 Checking folder: {folder_path}")
     files = [f for f in os.listdir(folder_path) if f.lower().endswith('.docx')]
-    print(f"Found {len(files)} Word files: {files}")
-    if not files:
-        print("⚠️ No .docx files found. Please check the folder path.")
-        return
+    if not files: return
 
     global bm25_docs, bm25_inverted, bm25_df, bm25_avgdl, bm25_ready
     bm25_docs, bm25_inverted, bm25_df = [], {}, {}
@@ -137,10 +110,8 @@ def ingest_documents(folder_path: str) -> None:
         doc_title = os.path.splitext(file)[0]
         doc = Document(file_path)
         sections = _split_by_sections(doc)
-        total_chunks = 0
         for s_idx, (section_title, paras) in enumerate(sections):
             chunks = _chunk_text_with_context(doc_title, section_title, paras, max_words=900)
-            total_chunks += len(chunks)
             intent_tag = _infer_intent_tag(section_title)
             for c_idx, chunk in enumerate(chunks):
                 embedding = model.encode(chunk).tolist()
@@ -159,13 +130,12 @@ def ingest_documents(folder_path: str) -> None:
                     try:
                         collection.delete(ids=[doc_id])
                         collection.add(ids=[doc_id], embeddings=[embedding], documents=[chunk], metadatas=[meta])
-                    except Exception as e2:
-                        print(f"❌ Upsert failed for {doc_id}: {e2}")
+                    except Exception:
+                        pass
 
                 tokens = _tokenize(chunk)
                 tf: Dict[str, int] = {}
-                for t in tokens:
-                    tf[t] = tf.get(t, 0) + 1
+                for t in tokens: tf[t] = tf.get(t, 0) + 1
                 idx = len(bm25_docs)
                 bm25_docs.append({"id": doc_id, "text": chunk, "tokens": tokens, "tf": tf, "length": len(tokens), "meta": meta})
                 seen = set()
@@ -174,31 +144,21 @@ def ingest_documents(folder_path: str) -> None:
                     if term not in seen:
                         bm25_df[term] = bm25_df.get(term, 0) + 1
                         seen.add(term)
-        print(f"📄 Ingested {file} → {total_chunks} chunks")
 
     N = len(bm25_docs)
     if N > 0:
         bm25_avgdl = sum(d["length"] for d in bm25_docs) / float(N)
         bm25_ready = True
-    payload = {
-        "bm25_docs": bm25_docs,
-        "bm25_inverted": bm25_inverted,
-        "bm25_df": bm25_df,
-        "bm25_avgdl": bm25_avgdl,
-        "BM25_K1": BM25_K1,
-        "BM25_B": BM25_B,
-    }
+
+    payload = {"bm25_docs": bm25_docs, "bm25_inverted": bm25_inverted, "bm25_df": bm25_df,
+               "bm25_avgdl": bm25_avgdl, "BM25_K1": BM25_K1, "BM25_B": BM25_B}
     os.makedirs(CHROMA_PATH, exist_ok=True)
     with open(BM25_INDEX_FILE, "wb") as f:
         pickle.dump(payload, f)
-    print(f"✅ BM25 index saved: {BM25_INDEX_FILE}")
-    print(f"✅ Documents ingested. Total entries in Chroma: {collection.count()}")
-
 
 def _load_bm25_index() -> None:
     global bm25_docs, bm25_inverted, bm25_df, bm25_avgdl, bm25_ready
-    if not os.path.exists(BM25_INDEX_FILE):
-        return
+    if not os.path.exists(BM25_INDEX_FILE): return
     try:
         with open(BM25_INDEX_FILE, "rb") as f:
             payload = pickle.load(f)
@@ -207,122 +167,88 @@ def _load_bm25_index() -> None:
         bm25_df = payload.get("bm25_df", {})
         bm25_avgdl = payload.get("bm25_avgdl", 0.0)
         bm25_ready = len(bm25_docs) > 0
-        if bm25_ready:
-            print(f"✅ BM25 index loaded: {BM25_INDEX_FILE} (docs={len(bm25_docs)})")
-    except Exception as e:
-        print(f"⚠️ Could not load BM25 index: {e}")
-
+    except Exception:
+        pass
 
 _load_bm25_index()
 
-# ---------------------- BM25 search ----------------------------------
-
+# -------- BM25 search --------
 def _bm25_score_for_doc(query_terms: List[str], doc_idx: int) -> float:
-    if not bm25_ready or doc_idx < 0 or doc_idx >= len(bm25_docs):
-        return 0.0
+    if not bm25_ready or doc_idx < 0 or doc_idx >= len(bm25_docs): return 0.0
     doc = bm25_docs[doc_idx]
-    score = 0.0
-    dl = doc["length"] or 1
+    score, dl = 0.0, (doc["length"] or 1)
     for term in query_terms:
         df = bm25_df.get(term, 0)
-        if df == 0:
-            continue
+        if df == 0: continue
         tf = doc["tf"].get(term, 0)
-        if tf == 0:
-            continue
+        if tf == 0: continue
         N = len(bm25_docs)
         idf_ratio = ((N - df + 0.5) / (df + 0.5))
-        try:
-            idf = math.log(idf_ratio + 1.0)
-        except Exception:
-            idf = 1.0
+        try: idf = math.log(idf_ratio + 1.0)
+        except Exception: idf = 1.0
         denom = tf + BM25_K1 * (1 - BM25_B + BM25_B * (dl / (bm25_avgdl or 1.0)))
         score += idf * ((tf * (BM25_K1 + 1)) / (denom or 1.0))
     return score
 
-
 def bm25_search(query: str, top_k: int = 50) -> List[Tuple[int, float]]:
-    if not bm25_ready:
-        return []
+    if not bm25_ready: return []
     norm = _normalize_query(query)
     q_terms = _tokenize(norm)
-    if not q_terms:
-        return []
+    if not q_terms: return []
     candidates = set()
     for t in q_terms:
-        for idx in bm25_inverted.get(t, []):
-            candidates.add(idx)
-    if not candidates:
-        candidates = set(range(len(bm25_docs)))
+        for idx in bm25_inverted.get(t, []): candidates.add(idx)
+    if not candidates: candidates = set(range(len(bm25_docs)))
     scored = []
     for idx in candidates:
         s = _bm25_score_for_doc(q_terms, idx)
-        if s > 0:
-            scored.append((idx, s))
+        if s > 0: scored.append((idx, s))
     scored.sort(key=lambda x: x[1], reverse=True)
     return scored[:top_k]
 
-# ---------------------- Semantic-only --------------------------------
+# -------- SAFE Chroma query and semantic-only --------
+def _safe_collection_query(query_embedding, top_k: int):
+    base_include = ['documents', 'metadatas', 'distances']  # supported
+    return collection.query(query_embeddings=[query_embedding], n_results=top_k, include=base_include)
 
 def search_knowledge_base(query: str, top_k: int = 10) -> dict:
     query_embedding = model.encode(query).tolist()
-    res = collection.query(
-        query_embeddings=[query_embedding],
-        n_results=top_k,
-        include=['documents', 'metadatas', 'distances', 'ids']
-    )
+    res = _safe_collection_query(query_embedding, top_k)
     documents = (res.get("documents", [[]]) or [[]])[0]
     metadatas = (res.get("metadatas", [[]]) or [[]])[0]
     distances = (res.get("distances", [[]]) or [[]])[0]
-    ids = (res.get("ids", [[]]) or [[]])[0]
-    return {
-        "documents": documents,
-        "metadatas": metadatas,
-        "distances": distances,
-        "ids": ids,
-    }
-
-# ---------------------- Semantic intent + Hybrid ranking --------------
-
-# Semantic intent prototypes (generic, wording-agnostic)
+    # synthesize ids
+    ids = []
+    for i, m in enumerate(metadatas):
+        fn = (m or {}).get("filename", "unknown")
+        sec = (m or {}).get("section", "section")
+        idx = (m or {}).get("chunk_index", i)
+        ids.append(f"{fn}:{sec}:{idx}")
+    return {"documents": documents, "metadatas": metadatas, "distances": distances, "ids": ids}
+
+# -------- Semantic intent + Hybrid ranking --------
 INTENT_PROTOTYPES = {
-    "steps": [
-        "how to perform", "procedure", "workflow", "instructions",
-        "steps to accomplish", "operate", "process to follow"
-    ],
-    "errors": [
-        "error condition", "issue troubleshooting", "resolution steps",
-        "fix failure", "diagnose problem"
-    ],
-    "prereqs": [
-        "pre-requisites", "requirements before starting", "setup needed"
-    ],
-    "purpose": [
-        "overview", "purpose", "introduction", "what is this about"
-    ],
+    "steps": ["how to perform", "procedure", "workflow", "instructions", "steps to accomplish", "operate", "process to follow"],
+    "errors": ["error condition", "issue troubleshooting", "resolution steps", "fix failure", "diagnose problem"],
+    "prereqs": ["pre-requisites", "requirements before starting", "setup needed"],
+    "purpose": ["overview", "purpose", "introduction", "what is this about"],
     "neutral": ["general information", "context", "details"],
 }
-
 INTENT_PROTO_VECS = {name: model.encode(" ; ".join(phrases)).tolist() for name, phrases in INTENT_PROTOTYPES.items()}
 
-
 def _cosine(a: list, b: list) -> float:
-    if not a or not b or len(a) != len(b):
-        return 0.0
-    dot = sum(x * y for x, y in zip(a, b))
-    na = math.sqrt(sum(x * x for x in a)) or 1.0
-    nb = math.sqrt(sum(y * y for y in b)) or 1.0
+    if not a or not b or len(a) != len(b): return 0.0
+    dot = sum(x*y for x, y in zip(a, b))
+    na = math.sqrt(sum(x*x for x in a)) or 1.0
+    nb = math.sqrt(sum(y*y for y in b)) or 1.0
     return dot / (na * nb)
 
-
 def classify_intent_semantic(query: str, min_margin: float = 0.08) -> str:
-    """Meaning-based intent classification using sentence embeddings."""
     qv = model.encode((query or "").strip()).tolist()
     scores = {name: _cosine(qv, vec) for name, vec in INTENT_PROTO_VECS.items()}
     best = max(scores.items(), key=lambda kv: kv[1])
     second = sorted(scores.values(), reverse=True)[1] if len(scores) > 1 else 0.0
-    if best[1] - second >= min_margin:
-        return best[0] if best[0] != "neutral" else "neutral"
+    if best[1] - second >= min_margin: return best[0] if best[0] != "neutral" else "neutral"
     return "neutral"
 
 ACTION_SYNONYMS = {
@@ -332,80 +258,58 @@ ACTION_SYNONYMS = {
     "navigate": ["navigate", "go to", "open"],
 }
 
-
 def _extract_actions(query: str) -> List[str]:
     q = (query or "").lower()
     found = []
     for act, syns in ACTION_SYNONYMS.items():
-        if any(s in q for s in syns):
-            found.append(act)
+        if any(s in q for s in syns): found.append(act)
     return found or []
 
-
 def _intent_weight(meta: dict, user_intent: str) -> float:
     tag = (meta or {}).get("intent_tag", "neutral")
-    if user_intent == "neutral":
-        return 0.0
-    if tag == user_intent:
-        return 1.0
-    if tag in ["purpose", "prereqs"] and user_intent in ["steps", "errors"]:
-        return -0.6
+    if user_intent == "neutral": return 0.0
+    if tag == user_intent: return 1.0
+    if tag in ["purpose", "prereqs"] and user_intent in ["steps", "errors"]: return -0.6
     return -0.2
 
-
 def _meta_overlap(meta: Dict[str, Any], q_terms: List[str]) -> float:
     fn_tokens = _tokenize_meta_value(meta.get("filename"))
     title_tokens = _tokenize_meta_value(meta.get("title"))
     section_tokens = _tokenize_meta_value(meta.get("section"))
     meta_tokens = set(fn_tokens + title_tokens + section_tokens)
-    if not meta_tokens or not q_terms:
-        return 0.0
+    if not meta_tokens or not q_terms: return 0.0
     qset = set(q_terms)
     inter = len(meta_tokens & qset)
     return inter / max(1, len(qset))
 
-
 def _semantic_meta_overlap(meta: Dict[str, Any], query_vec: List[float]) -> float:
-    """Compare query vector to semantic vector of filename/title/section."""
-    if not meta:
-        return 0.0
     s = " ".join([str(meta.get("filename", "")), str(meta.get("title", "")), str(meta.get("section", ""))]).strip()
-    if not s:
-        return 0.0
+    if not s: return 0.0
     mv = model.encode(s).tolist()
     return max(0.0, _cosine(query_vec, mv))
 
-
 def _action_weight(text: str, actions: List[str]) -> float:
-    if not actions:
-        return 0.0
+    if not actions: return 0.0
     t = (text or "").lower()
     score = 0.0
     for act in actions:
         for syn in ACTION_SYNONYMS.get(act, [act]):
-            if syn in t:
-                score += 1.0
+            if syn in t: score += 1.0
     conflicts = {"create": ["delete"], "delete": ["create"], "update": ["delete"], "navigate": []}
     for act in actions:
         for bad in conflicts.get(act, []):
             for syn in ACTION_SYNONYMS.get(bad, [bad]):
-                if syn in t:
-                    score -= 0.8
+                if syn in t: score -= 0.8
     return score
 
-
 def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6, beta: float = 0.4) -> dict:
     norm_query = _normalize_query(query)
     q_terms = _tokenize(norm_query)
 
-    # semantic intent
-    user_intent = classify_intent_semantic(query)
+    user_intent = classify_intent_semantic(query)            # semantic intent
     actions = _extract_actions(query)
-
-    # query vector
     query_vec = model.encode(norm_query).tolist()
 
-    # semantic results
     sem_res = search_knowledge_base(norm_query, top_k=max(top_k, 30))
     sem_docs = sem_res.get("documents", [])
     sem_metas = sem_res.get("metadatas", [])
@@ -413,16 +317,12 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
     sem_ids = sem_res.get("ids", [])
 
     def dist_to_sim(d: Optional[float]) -> float:
-        if d is None:
-            return 0.0
-        try:
-            return 1.0 / (1.0 + float(d))
-        except Exception:
-            return 0.0
+        if d is None: return 0.0
+        try: return 1.0 / (1.0 + float(d))
+        except Exception: return 0.0
 
     sem_sims = [dist_to_sim(d) for d in sem_dists]
 
-    # bm25 results
     bm25_hits = bm25_search(norm_query, top_k=max(50, top_k * 5))
     bm25_max = max([s for _, s in bm25_hits], default=1.0)
     bm25_norm_pairs = [(idx, (score / bm25_max) if bm25_max > 0 else 0.0) for idx, score in bm25_hits]
@@ -436,13 +336,12 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
     union_ids = set(sem_ids) | set(bm25_id_to_norm.keys())
 
     # weights
-    gamma = 0.25  # lexical meta overlap
-    delta = 0.35  # intent boost
-    epsilon = 0.25  # action weight
-    zeta = 0.35    # semantic meta similarity
+    gamma = 0.25      # lexical meta overlap
+    delta = 0.35      # intent tag vs user intent
+    epsilon = 0.25    # action weight
+    zeta = 0.35       # semantic meta similarity (NEW)
 
     combined_records_ext: List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float]] = []
-
     for cid in union_ids:
         if cid in sem_ids:
             pos = sem_ids.index(cid)
@@ -460,22 +359,13 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
         text = sem_text if sem_text else bm25_text
         meta = sem_meta if sem_meta else bm25_meta
 
-        m_overlap = _meta_overlap(meta, q_terms)             # lexical overlap
-        m_sem = _semantic_meta_overlap(meta, query_vec)      # semantic overlap
+        m_overlap = _meta_overlap(meta, q_terms)
+        m_sem = _semantic_meta_overlap(meta, query_vec)     # NEW semantic meta
         intent_boost = _intent_weight(meta, user_intent)
         act_wt = _action_weight(text, actions)
 
-        final_score = (
-            alpha * sem_sim +
-            beta * bm25_sim +
-            gamma * m_overlap +
-            zeta * m_sem +
-            delta * intent_boost +
-            epsilon * act_wt
-        )
-        combined_records_ext.append(
-            (cid, final_score, (sem_dist if sem_dist is not None else 999.0), text, meta, m_overlap, intent_boost, act_wt, m_sem)
-        )
+        final_score = alpha * sem_sim + beta * bm25_sim + gamma * m_overlap + zeta * m_sem + delta * intent_boost + epsilon * act_wt
+        combined_records_ext.append((cid, final_score, (sem_dist if sem_dist is not None else 999.0), text, meta, m_overlap, intent_boost, act_wt, m_sem))
 
     from collections import defaultdict
     doc_groups: Dict[str, List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float]]] = defaultdict(list)
@@ -502,8 +392,7 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
     best_recs = sorted(doc_groups.get(best_doc, []), key=lambda x: x[1], reverse=True)
     other_recs = []
     for fn, recs in doc_groups.items():
-        if fn == best_doc:
-            continue
+        if fn == best_doc: continue
         other_recs.extend(recs)
     other_recs.sort(key=lambda x: x[1], reverse=True)
     reordered = best_recs + other_recs
@@ -526,33 +415,26 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
         "actions": actions,
     }
 
-# ---------------------- Section fetch helpers -------------------------
-
+# -------- Section helpers --------
 def get_section_text(filename: str, section: str) -> str:
-    """Concatenate all chunk texts for a given filename+section."""
     texts: List[str] = []
     for d in bm25_docs:
         m = d.get("meta", {})
         if m.get("filename") == filename and m.get("section") == section:
             t = (d.get("text") or "").strip()
-            if t:
-                texts.append(t)
+            if t: texts.append(t)
     return "\n\n".join(texts).strip()
 
-
 def get_best_steps_section_text(filename: str) -> str:
-    """Return combined text of all 'steps' sections in the given SOP (filename)."""
     texts: List[str] = []
     for d in bm25_docs:
         m = d.get("meta", {})
         if m.get("filename") == filename and (m.get("intent_tag") == "steps"):
             t = (d.get("text") or "").strip()
-            if t:
-                texts.append(t)
+            if t: texts.append(t)
     return "\n\n".join(texts).strip()
 
-# ---------------------- Admin helpers --------------------------------
-
+# -------- Admin --------
 def get_kb_runtime_info() -> Dict[str, Any]:
     return {
         "chroma_path": CHROMA_PATH,
@@ -563,19 +445,15 @@ def get_kb_runtime_info() -> Dict[str, Any]:
         "bm25_ready": bm25_ready,
     }
 
-
 def reset_kb(folder_path: str) -> Dict[str, Any]:
     result = {"status": "OK", "message": "KB reset and re-ingested"}
     try:
-        try:
-            client.delete_collection(name="knowledge_base")
-        except Exception:
-            pass
+        try: client.delete_collection(name="knowledge_base")
+        except Exception: pass
         global collection
         collection = client.get_or_create_collection(name="knowledge_base")
         try:
-            if os.path.isfile(BM25_INDEX_FILE):
-                os.remove(BM25_INDEX_FILE)
+            if os.path.isfile(BM25_INDEX_FILE): os.remove(BM25_INDEX_FILE)
         except Exception as e:
             result.setdefault("warnings", []).append(f"bm25 index delete: {e}")
         os.makedirs(CHROMA_PATH, exist_ok=True)