own-rag-cli 0.0.8-snapshot → 0.0.9-snapshot

package/README.md

@@ -1,4 +1,4 @@
-# MCP binary checksum (SHA-256, payload without shebang): `1413af4d4c7d01d57ec5195ea0c5f704f9fefabeb641d2f216a042ec638c2b59`
+# MCP binary checksum (SHA-256, payload without shebang): `80e56de30d6296582df5b6b09ab182df9879dc16603fe48604206d94264e8673`
 
 # own-rag
 

package/bin/indexer_full.py

@@ -1176,6 +1176,7 @@ def index_file(
     splitter: RecursiveCharacterTextSplitter,
     root_path: Path,
     embedding_batch_size: int,
+    raise_on_stop_iteration: bool = False,
 ) -> int:
     """
     Indexa um único arquivo: lê, divide em chunks, gera embeddings e faz upsert.
@@ -1320,6 +1321,10 @@ def index_file(
         _warn_stop_iteration(
             f"  [AVISO] {filepath.name}: {skipped_chunks} chunk(s) vazio(s)/inválido(s) foram ignorados."
         )
+    if raise_on_stop_iteration and inserted_chunks == 0 and stop_iteration_warnings > 0:
+        raise RuntimeError(
+            f"stop_iteration_all_chunks:{filepath.name}:{stop_iteration_warnings}"
+        )
     return inserted_chunks
 
 
@@ -1532,8 +1537,8 @@ def main():
                 if target is None:
                     continue
 
+                target_quantization = jina_quantization if target.model_choice == "jina" else "default"
                 if target.model_choice not in loaded_models:
-                    target_quantization = jina_quantization if target.model_choice == "jina" else "default"
                     try:
                         loaded_models[target.model_choice] = load_embedding_model(
                             target.model_choice,
@@ -1568,6 +1573,7 @@ def main():
                             splitter,
                             root_path,
                             embedding_batch_size=effective_batch_size,
+                            raise_on_stop_iteration=(target.model_choice == "bge"),
                         )
                         total_chunks += n_chunks
                         files_processed_total += 1
@@ -1591,6 +1597,45 @@ def main():
                                 gc.collect()
                                 continue
 
+                        if target.model_choice == "bge":
+                            fallback_target = target_by_model.get("jina-v2") or target_by_model.get("jina")
+                            if fallback_target is not None:
+                                fallback_quantization = (
+                                    jina_quantization if fallback_target.model_choice == "jina" else "default"
+                                )
+                                try:
+                                    if fallback_target.model_choice not in loaded_models:
+                                        loaded_models[fallback_target.model_choice] = load_embedding_model(
+                                            fallback_target.model_choice,
+                                            fallback_quantization,
+                                        )
+                                    fallback_model = loaded_models[fallback_target.model_choice]
+                                    fallback_collection = collections[fallback_target.collection_name]
+                                    tqdm.write(
+                                        f"  [FALLBACK] {filepath.name}: BGE falhou; "
+                                        f"reindexando com {fallback_target.label}."
+                                    )
+                                    fallback_chunks = index_file(
+                                        filepath,
+                                        fallback_collection,
+                                        fallback_model,
+                                        splitter,
+                                        root_path,
+                                        embedding_batch_size=effective_batch_size,
+                                        raise_on_stop_iteration=False,
+                                    )
+                                    total_chunks += fallback_chunks
+                                    files_processed_total += 1
+                                    files_eligible_by_collection[fallback_target.collection_name] += 1
+                                    chunks_by_collection[fallback_target.collection_name] += fallback_chunks
+                                    files_by_collection[fallback_target.collection_name] += 1
+                                    break
+                                except Exception as fallback_error:
+                                    tqdm.write(
+                                        f"  [ERRO] {filepath} [fallback {fallback_target.label}]: "
+                                        f"{_format_exception(fallback_error)}"
+                                    )
+
                         if (
                             _is_dimension_mismatch_error(e)
                             and not collection_dimension_reset_done[target.collection_name]

package/bin/mcp_server.py

@@ -1021,6 +1021,10 @@ def _index_single_file_for_branch(
         _warn_stop_iteration(
             f"{filepath.name} [{branch.key}] ignorou {skipped_chunks} chunk(s) vazio(s)/inválido(s)."
         )
+    if branch.key == "bge_doc" and inserted_chunks == 0 and stop_iteration_warnings > 0:
+        raise RuntimeError(
+            f"stop_iteration_all_chunks:{filepath.name}:{stop_iteration_warnings}"
+        )
     return inserted_chunks
 
 
@@ -1139,6 +1143,7 @@ def _rrf_fuse(hits_by_branch: dict[str, list[RetrievedHit]], top_limit: int) ->
 
 
 def _apply_rerank(query: str, fused_hits: list[FusedHit], top_k: int) -> tuple[list[FusedHit], bool, str | None]:
+    global _reranker, _reranker_error
     if not fused_hits:
         return [], False, None
 
@@ -1163,7 +1168,9 @@ def _apply_rerank(query: str, fused_hits: list[FusedHit], top_k: int) -> tuple[l
         )
         return fused_hits[:top_k], True, None
     except Exception as e:
-        return fused_hits[:top_k], False, str(e)
+        _reranker = None
+        _reranker_error = f"runtime_error:{e}"
+        return fused_hits[:top_k], False, f"fallback_sem_rerank:{e}"
 
 
 def _format_similarity(similarity: float | None) -> str:
@@ -1483,6 +1490,23 @@ def update_file_index(file_path: str) -> str:
             )
             inserted_per_branch[branch.key] = inserted
         except Exception as e:
+            if branch.key == "bge_doc" and "jina_code" not in inserted_per_branch:
+                fallback_branch = BRANCH_SPECS["jina_code"]
+                try:
+                    inserted = _index_single_file_for_branch(
+                        filepath,
+                        fallback_branch,
+                        splitter,
+                        delete_existing=False,
+                    )
+                    inserted_per_branch[fallback_branch.key] = inserted
+                    index_errors.append(f"{branch.key}: {e} (fallback para {fallback_branch.key} aplicado)")
+                    continue
+                except Exception as fallback_error:
+                    index_errors.append(
+                        f"{branch.key}: {e} | fallback {fallback_branch.key}: {fallback_error}"
+                    )
+                    continue
             index_errors.append(f"{branch.key}: {e}")
 
     success_branches = [k for k, v in inserted_per_branch.items() if v > 0]
@@ -1611,13 +1635,31 @@ def index_specific_folder(folder_path: str) -> str:
     for filepath in _scan_folder(folder):
         processed_files += 1
         targets = _classify_file_targets(filepath)
+        indexed_branches_for_file: set[str] = set()
 
         for branch in targets:
             try:
                 n_chunks = _index_single_file_for_branch(filepath, branch, splitter)
                 branch_file_counts[branch.key] += 1
                 branch_chunk_counts[branch.key] += n_chunks
+                indexed_branches_for_file.add(branch.key)
             except Exception as e:
+                if branch.key == "bge_doc" and "jina_code" not in indexed_branches_for_file:
+                    fallback_branch = BRANCH_SPECS["jina_code"]
+                    try:
+                        n_chunks = _index_single_file_for_branch(filepath, fallback_branch, splitter)
+                        branch_file_counts[fallback_branch.key] += 1
+                        branch_chunk_counts[fallback_branch.key] += n_chunks
+                        indexed_branches_for_file.add(fallback_branch.key)
+                        error_count += 1
+                        if len(error_samples) < 10:
+                            error_samples.append(
+                                f"{filepath.name} [{branch.key}]: {e} "
+                                f"(fallback para {fallback_branch.key} aplicado)"
+                            )
+                        continue
+                    except Exception as fallback_error:
+                        e = RuntimeError(f"{e} | fallback {fallback_branch.key}: {fallback_error}")
                 error_count += 1
                 if len(error_samples) < 10:
                     error_samples.append(f"{filepath.name} [{branch.key}]: {e}")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "own-rag-cli",
-  "version": "0.0.8-snapshot",
+  "version": "0.0.9-snapshot",
   "description": "Local RAG setup with ChromaDB + MCP server (Jina/BGE hybrid support).",
   "license": "MIT",
   "private": false,