own-rag-cli 0.0.1-snapshot → 0.0.2-snapshot

package/README.md

@@ -1,4 +1,4 @@
-# MCP binary checksum (SHA-256, payload without shebang): `3246eeb57f901742d915e0bce37fa96f059e149a57bbce73095ff4e5ea51d8d4`
+# MCP binary checksum (SHA-256, payload without shebang): `74bb1de161e5ebeef6691397fc1403bc58c221b9302f67fd770b1097f8ff76d8`
 
 # own-rag
 
@@ -63,7 +63,43 @@ rag remove
 4. Optionally updates MCP config files (`.claude.json`, Cursor config).
 5. Indexes the project.
 
-## ChromaDB Port Behavior
+## Permissions and Tuning Config
+
+- Autotune/indexer tuning is persisted by default in:
+  - `~/.cache/own-rag-cli/indexer_tuning.json`
+- This avoids permission issues when `~/.rag_db` is owned by `root`.
+- If you want to store tuning inside `~/.rag_db`, grant permissions and set:
+
+```bash
+sudo chown -R "$USER":"$USER" ~/.rag_db
+export MCP_INDEXER_CONFIG_FILE="$HOME/.rag_db/indexer_tuning.json"
+```
+
+## Chroma Endpoint Config
+
+- Runtime config file: `~/.own-rag-cli.json`
+- Default generated content:
+
+```json
+{
+  "chroma": {
+    "scheme": "http",
+    "host": "localhost",
+    "port": 8000
+  },
+  "indexing": {
+    "embedding_batch_size": 4,
+    "batch_count": 4
+  }
+}
+```
+
+- You can point to remote ChromaDB by changing `scheme`, `host`, and `port`.
+- `indexing.embedding_batch_size` / `indexing.batch_count` are updated after indexing/autotune.
+- `rag-setup.run` / `rag-setup-macos.run` persist chosen values into this file.
+- If `host` is not local (`localhost`, `127.0.0.1`, `::1`), setup skips local Docker startup.
+
+## ChromaDB Port Behavior (Local)
 
 - Default host port is `8000`.
 - During ChromaDB install/reinstall, setup asks for the port.
@@ -75,7 +111,7 @@ rag remove
 - Selected port is propagated to:
   - Docker Compose mapping
   - health checks
-  - MCP config (`CHROMA_PORT`)
+  - `~/.own-rag-cli.json`
   - indexer runtime (`MCP_CHROMA_PORT`)
 
 ## Performance Profiles
@@ -95,6 +131,9 @@ Este modo pode elevar consideravelmente o consumo de memória e causar encerrame
 - `MCP_EMBEDDING_MODEL=jina|bge|hybrid`
 - `MCP_JINA_QUANTIZATION=default|dynamic-int8`
 - `MCP_PERF_PROFILE=autotune|max-performance`
+- `OWN_RAG_CLI_CONFIG_FILE=~/.own-rag-cli.json`
+- `MCP_CHROMA_SCHEME=http|https`
+- `MCP_CHROMA_HOST=localhost|<host>`
 - `MCP_CHROMA_PORT=8000`
 - `MCP_CHUNK_SIZE`
 - `MCP_CHUNK_OVERLAP`

package/bin/indexer_full.py

@@ -22,6 +22,7 @@ from collections.abc import Iterator
 from pathlib import Path
 from dataclasses import dataclass
 from datetime import datetime
+from urllib.parse import urlparse
 
 # Evita avisos "advisory" ruidosos do transformers no fluxo interativo.
 os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
@@ -55,8 +56,126 @@ def _env_int(name: str, default: int, *, min_value: int = 1) -> int:
     except ValueError:
         return max(min_value, default)
 
-CHROMA_HOST = "localhost"
-CHROMA_PORT = _env_int("MCP_CHROMA_PORT", 8000, min_value=1)
+
+def _env_str(name: str, default: str) -> str:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    stripped = raw.strip()
+    return stripped if stripped else default
+
+
+def _parse_positive_int(raw: object, *, min_value: int = 1) -> int | None:
+    try:
+        parsed = int(str(raw).strip())
+    except Exception:
+        return None
+    if parsed < min_value:
+        return None
+    return parsed
+
+
+OWN_RAG_CLI_CONFIG_PATH = Path(
+    os.environ.get("OWN_RAG_CLI_CONFIG_FILE", str(Path.home() / ".own-rag-cli.json"))
+).expanduser()
+
+
+def _load_own_rag_cli_config_payload() -> dict[str, object]:
+    try:
+        if not OWN_RAG_CLI_CONFIG_PATH.exists():
+            return {}
+        payload = json.loads(OWN_RAG_CLI_CONFIG_PATH.read_text(encoding="utf-8"))
+        return payload if isinstance(payload, dict) else {}
+    except Exception:
+        return {}
+
+
+def _extract_chroma_endpoint_from_config(config_payload: object) -> tuple[str, str, int]:
+    scheme = "http"
+    host = "localhost"
+    port = 8000
+
+    def _read_scheme(raw: object) -> None:
+        nonlocal scheme
+        if not isinstance(raw, str):
+            return
+        lowered = raw.strip().lower()
+        if lowered in {"http", "https"}:
+            scheme = lowered
+
+    def _read_host(raw: object) -> None:
+        nonlocal scheme, host, port
+        if not isinstance(raw, str):
+            return
+        candidate = raw.strip()
+        if not candidate:
+            return
+        parsed = urlparse(candidate if "://" in candidate else f"//{candidate}")
+        if parsed.scheme in {"http", "https"}:
+            scheme = parsed.scheme
+        if parsed.hostname:
+            host = parsed.hostname
+        elif "://" not in candidate:
+            host = candidate.strip().strip("/")
+        if parsed.port and 1 <= parsed.port <= 65535:
+            port = parsed.port
+
+    def _read_port(raw: object) -> None:
+        nonlocal port
+        try:
+            parsed = int(str(raw).strip())
+        except Exception:
+            return
+        if 1 <= parsed <= 65535:
+            port = parsed
+
+    if isinstance(config_payload, dict):
+        chroma_obj = config_payload.get("chroma")
+        if isinstance(chroma_obj, dict):
+            _read_scheme(chroma_obj.get("scheme"))
+            _read_host(chroma_obj.get("host"))
+            _read_port(chroma_obj.get("port"))
+
+        # Compatibilidade com formatos flat antigos.
+        _read_scheme(config_payload.get("CHROMA_SCHEME"))
+        _read_host(config_payload.get("CHROMA_HOST"))
+        _read_port(config_payload.get("CHROMA_PORT"))
+
+    return scheme, host, port
+
+
+def _extract_embedding_batch_from_config(config_payload: object) -> int | None:
+    if not isinstance(config_payload, dict):
+        return None
+
+    indexing = config_payload.get("indexing")
+    if isinstance(indexing, dict):
+        for key in ("embedding_batch_size", "batch_count"):
+            parsed = _parse_positive_int(indexing.get(key), min_value=1)
+            if parsed is not None:
+                return parsed
+
+    for key in ("MCP_EMBEDDING_BATCH_SIZE", "embedding_batch_size", "batch_count"):
+        parsed = _parse_positive_int(config_payload.get(key), min_value=1)
+        if parsed is not None:
+            return parsed
+    return None
+
+
+def _load_cli_chroma_defaults() -> tuple[str, str, int]:
+    payload = _load_own_rag_cli_config_payload()
+    if not payload:
+        return ("http", "localhost", 8000)
+    return _extract_chroma_endpoint_from_config(payload)
+
+_DEFAULT_CHROMA_SCHEME, _DEFAULT_CHROMA_HOST, _DEFAULT_CHROMA_PORT = _load_cli_chroma_defaults()
+_DEFAULT_EMBEDDING_BATCH_SIZE = _extract_embedding_batch_from_config(_load_own_rag_cli_config_payload()) or 4
+CHROMA_SCHEME = _env_str("MCP_CHROMA_SCHEME", _DEFAULT_CHROMA_SCHEME).lower()
+if CHROMA_SCHEME not in {"http", "https"}:
+    CHROMA_SCHEME = _DEFAULT_CHROMA_SCHEME
+CHROMA_HOST = _env_str("MCP_CHROMA_HOST", _DEFAULT_CHROMA_HOST)
+CHROMA_PORT = _env_int("MCP_CHROMA_PORT", _DEFAULT_CHROMA_PORT, min_value=1)
+CHROMA_SSL = CHROMA_SCHEME == "https"
 COLLECTION_CODE_JINA = "code_vectors_jina"
 COLLECTION_DOC_BGE = "doc_vectors_bge"
 
@@ -104,12 +223,18 @@ MAX_FILE_SIZE_BYTES = 500 * 1024  # 500 KB
 # Parâmetros do splitter e batch (perfil low-memory por padrão).
 CHUNK_SIZE = _env_int("MCP_CHUNK_SIZE", 3000, min_value=256)
 CHUNK_OVERLAP = min(CHUNK_SIZE - 1, _env_int("MCP_CHUNK_OVERLAP", 400, min_value=0))
-EMBEDDING_BATCH_SIZE = _env_int("MCP_EMBEDDING_BATCH_SIZE", 4, min_value=1)
+EMBEDDING_BATCH_SIZE = _env_int(
+    "MCP_EMBEDDING_BATCH_SIZE",
+    _DEFAULT_EMBEDDING_BATCH_SIZE,
+    min_value=1,
+)
 DEFAULT_PERF_PROFILE = "autotune"
 INDEXER_CONFIG_PATH = Path(
-    os.environ.get("MCP_INDEXER_CONFIG_FILE", str(Path.home() / ".rag_db" / "indexer_tuning.json"))
+    os.environ.get(
+        "MCP_INDEXER_CONFIG_FILE",
+        str(Path.home() / ".cache" / "own-rag-cli" / "indexer_tuning.json"),
+    )
 ).expanduser()
-INDEXER_CONFIG_FALLBACK_PATH = Path.home() / ".cache" / "my-custom-rag-python" / "indexer_tuning.json"
 
 # Modelo de embeddings (roda na CPU)
 JINA_V3_EMBEDDING_MODEL = "jinaai/jina-embeddings-v3"
@@ -118,7 +243,7 @@ BGE_EMBEDDING_MODEL = "BAAI/bge-m3"
 DEFAULT_EMBEDDING_MODEL_CHOICE = "jina"
 DEFAULT_JINA_QUANTIZATION = "dynamic-int8"
 MODEL_CACHE_BASE_DIR = Path(
-    os.environ.get("MCP_MODEL_DIR", str(Path.home() / ".cache" / "my-custom-rag-python" / "models"))
+    os.environ.get("MCP_MODEL_DIR", str(Path.home() / ".cache" / "own-rag-cli" / "models"))
 ).expanduser()
 JINA_RECOMMENDED_RAM_GB_DEFAULT = 64
 JINA_RECOMMENDED_RAM_GB_DYNAMIC_INT8 = 48
@@ -349,52 +474,72 @@ def resolve_embedding_config(
     return model_choice, jina_quantization
 
 
-def _indexer_config_candidates() -> list[Path]:
-    candidates = [INDEXER_CONFIG_PATH]
-    if INDEXER_CONFIG_FALLBACK_PATH not in candidates:
-        candidates.append(INDEXER_CONFIG_FALLBACK_PATH)
-    return candidates
-
-
 def load_indexer_tuning_config(force_reconfigure: bool) -> dict[str, object]:
     if force_reconfigure:
         return {}
-    for candidate in _indexer_config_candidates():
-        try:
-            if not candidate.exists():
-                continue
-            data = json.loads(candidate.read_text(encoding="utf-8"))
-            if isinstance(data, dict):
-                return data
-        except Exception:
-            continue
+    try:
+        if not INDEXER_CONFIG_PATH.exists():
+            return {}
+        data = json.loads(INDEXER_CONFIG_PATH.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        return {}
     return {}
 
 
+def _persist_batch_to_cli_config(batch_size: int) -> None:
+    payload = _load_own_rag_cli_config_payload()
+    chroma = payload.get("chroma")
+    if not isinstance(chroma, dict):
+        chroma = {
+            "scheme": CHROMA_SCHEME,
+            "host": CHROMA_HOST,
+            "port": CHROMA_PORT,
+        }
+        payload["chroma"] = chroma
+
+    indexing = payload.get("indexing")
+    if not isinstance(indexing, dict):
+        indexing = {}
+    indexing["embedding_batch_size"] = batch_size
+    indexing["batch_count"] = batch_size
+    payload["indexing"] = indexing
+
+    try:
+        OWN_RAG_CLI_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        OWN_RAG_CLI_CONFIG_PATH.write_text(
+            json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+    except Exception as e:
+        print(
+            f"[AVISO] Não foi possível atualizar batch em "
+            f"{OWN_RAG_CLI_CONFIG_PATH}: {_format_exception(e)}"
+        )
+
+
 def save_indexer_tuning_config(config: dict[str, object]) -> None:
+    batch_size = _parse_positive_int(config.get("embedding_batch_size"), min_value=1)
     payload = {
         **config,
         "updated_at": int(time()),
     }
-    write_errors: list[tuple[Path, Exception]] = []
+    if batch_size is not None:
+        payload["batch_count"] = batch_size
 
-    for candidate in _indexer_config_candidates():
-        try:
-            candidate.parent.mkdir(parents=True, exist_ok=True)
-            candidate.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-            if candidate == INDEXER_CONFIG_PATH:
-                print(f"[CONFIG] Configuração persistida em: {candidate}")
-            else:
-                print(
-                    f"[CONFIG] Configuração persistida em fallback: {candidate} "
-                    f"(destino primário sem permissão: {INDEXER_CONFIG_PATH})"
-                )
-            return
-        except Exception as e:
-            write_errors.append((candidate, e))
+    try:
+        INDEXER_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        INDEXER_CONFIG_PATH.write_text(
+            json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+        print(f"[CONFIG] Configuração persistida em: {INDEXER_CONFIG_PATH}")
+    except Exception as e:
+        print(f"[AVISO] Não foi possível persistir configuração em {INDEXER_CONFIG_PATH}: {_format_exception(e)}")
 
-    details = " | ".join(f"{path}: {_format_exception(err)}" for path, err in write_errors)
-    print(f"[AVISO] Não foi possível persistir configuração: {details}")
+    if batch_size is not None:
+        _persist_batch_to_cli_config(batch_size)
 
 
 def resolve_perf_profile(perf_profile_arg: str | None, persisted_config: dict[str, object]) -> str:
@@ -921,15 +1066,14 @@ def load_embedding_model(model_choice: str, jina_quantization: str) -> SentenceT
 def connect_to_chroma() -> chromadb.HttpClient:
     """Conecta ao ChromaDB via HTTP e valida a conexão."""
     try:
-        client = chromadb.HttpClient(host=CHROMA_HOST, port=CHROMA_PORT)
+        client = chromadb.HttpClient(host=CHROMA_HOST, port=CHROMA_PORT, ssl=CHROMA_SSL)
         # Faz um heartbeat para confirmar que o servidor está no ar
         client.heartbeat()
-        print(f"[+] Conectado ao ChromaDB em {CHROMA_HOST}:{CHROMA_PORT}")
+        print(f"[+] Conectado ao ChromaDB em {CHROMA_SCHEME}://{CHROMA_HOST}:{CHROMA_PORT}")
         return client
     except Exception as e:
         print(f"[ERRO] Não foi possível conectar ao ChromaDB: {e}")
-        print("       Verifique se o container Docker está rodando:")
-        print("       docker compose up -d")
+        print(f"       Endpoint configurado: {CHROMA_SCHEME}://{CHROMA_HOST}:{CHROMA_PORT}")
         sys.exit(1)
 
 
@@ -1141,6 +1285,8 @@ def main():
     persisted_chunk_size = _parse_config_int(persisted_config, "chunk_size")
     persisted_chunk_overlap = _parse_config_int(persisted_config, "chunk_overlap")
     persisted_batch_size = _parse_config_int(persisted_config, "embedding_batch_size")
+    if persisted_batch_size is None:
+        persisted_batch_size = _parse_config_int(persisted_config, "batch_count")
 
     effective_chunk_size = CHUNK_SIZE
     if not chunk_size_locked and persisted_chunk_size is not None:

package/bin/mcp_server.py

@@ -21,6 +21,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
+from urllib.parse import urlparse
 
 # Evita mensagens advisory do transformers em stderr durante a carga do modelo.
 os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
@@ -118,7 +119,13 @@ def _log_tool_usage(event: str, tool_name: str, details: dict[str, object] | Non
 
 
 INDEXER_CONFIG_PATH = Path(
-    os.environ.get("MCP_INDEXER_CONFIG_FILE", str(Path.home() / ".rag_db" / "indexer_tuning.json"))
+    os.environ.get(
+        "MCP_INDEXER_CONFIG_FILE",
+        str(Path.home() / ".cache" / "own-rag-cli" / "indexer_tuning.json"),
+    )
+).expanduser()
+OWN_RAG_CLI_CONFIG_PATH = Path(
+    os.environ.get("OWN_RAG_CLI_CONFIG_FILE", str(Path.home() / ".own-rag-cli.json"))
 ).expanduser()
 
 
@@ -135,6 +142,16 @@ def _load_indexer_tuning_config() -> dict[str, object]:
 INDEXER_TUNING_CONFIG = _load_indexer_tuning_config()
 
 
+def _load_own_rag_cli_config_payload() -> dict[str, object]:
+    try:
+        if not OWN_RAG_CLI_CONFIG_PATH.exists():
+            return {}
+        payload = json.loads(OWN_RAG_CLI_CONFIG_PATH.read_text(encoding="utf-8"))
+        return payload if isinstance(payload, dict) else {}
+    except Exception:
+        return {}
+
+
 def _config_str(env_name: str, config_key: str, default: str) -> str:
     env_raw = os.environ.get(env_name)
     if env_raw is not None and env_raw.strip():
@@ -145,7 +162,108 @@ def _config_str(env_name: str, config_key: str, default: str) -> str:
     return default
 
 
-def _config_int(env_name: str, config_key: str, default: int, *, min_value: int = 1) -> int:
+def _parse_int(raw: object, default: int, *, min_value: int = 1) -> int:
+    try:
+        parsed = int(str(raw).strip())
+    except Exception:
+        return max(min_value, default)
+    return max(min_value, parsed)
+
+
+def _extract_chroma_endpoint_from_config(config_payload: object) -> tuple[str, str, int]:
+    scheme = "http"
+    host = "localhost"
+    port = 8000
+
+    def _read_scheme(raw: object) -> None:
+        nonlocal scheme
+        if not isinstance(raw, str):
+            return
+        lowered = raw.strip().lower()
+        if lowered in {"http", "https"}:
+            scheme = lowered
+
+    def _read_host(raw: object) -> None:
+        nonlocal scheme, host, port
+        if not isinstance(raw, str):
+            return
+        candidate = raw.strip()
+        if not candidate:
+            return
+        parsed = urlparse(candidate if "://" in candidate else f"//{candidate}")
+        if parsed.scheme in {"http", "https"}:
+            scheme = parsed.scheme
+        if parsed.hostname:
+            host = parsed.hostname
+        elif "://" not in candidate:
+            host = candidate.strip().strip("/")
+        if parsed.port and 1 <= parsed.port <= 65535:
+            port = parsed.port
+
+    def _read_port(raw: object) -> None:
+        nonlocal port
+        try:
+            parsed = int(str(raw).strip())
+        except Exception:
+            return
+        if 1 <= parsed <= 65535:
+            port = parsed
+
+    if isinstance(config_payload, dict):
+        chroma_obj = config_payload.get("chroma")
+        if isinstance(chroma_obj, dict):
+            _read_scheme(chroma_obj.get("scheme"))
+            _read_host(chroma_obj.get("host"))
+            _read_port(chroma_obj.get("port"))
+
+        # Compatibilidade com formatos flat antigos.
+        _read_scheme(config_payload.get("CHROMA_SCHEME"))
+        _read_host(config_payload.get("CHROMA_HOST"))
+        _read_port(config_payload.get("CHROMA_PORT"))
+
+    return scheme, host, port
+
+
+def _extract_embedding_batch_from_config(config_payload: object) -> int | None:
+    if not isinstance(config_payload, dict):
+        return None
+
+    def _read(raw: object) -> int | None:
+        try:
+            parsed = int(str(raw).strip())
+        except Exception:
+            return None
+        return parsed if parsed >= 1 else None
+
+    indexing = config_payload.get("indexing")
+    if isinstance(indexing, dict):
+        for key in ("embedding_batch_size", "batch_count"):
+            parsed = _read(indexing.get(key))
+            if parsed is not None:
+                return parsed
+
+    for key in ("MCP_EMBEDDING_BATCH_SIZE", "embedding_batch_size", "batch_count"):
+        parsed = _read(config_payload.get(key))
+        if parsed is not None:
+            return parsed
+    return None
+
+
+def _load_cli_chroma_defaults() -> tuple[str, str, int]:
+    payload = _load_own_rag_cli_config_payload()
+    if not payload:
+        return ("http", "localhost", 8000)
+    return _extract_chroma_endpoint_from_config(payload)
+
+
+def _config_int(
+    env_name: str,
+    config_key: str,
+    default: int,
+    *,
+    min_value: int = 1,
+    fallback_config_keys: tuple[str, ...] = (),
+) -> int:
     env_raw = os.environ.get(env_name)
     if env_raw is not None and env_raw.strip():
         try:
@@ -153,20 +271,41 @@ def _config_int(env_name: str, config_key: str, default: int, *, min_value: int
         except ValueError:
             pass
 
-    cfg_raw = INDEXER_TUNING_CONFIG.get(config_key)
-    if isinstance(cfg_raw, int):
-        return max(min_value, cfg_raw)
-    if isinstance(cfg_raw, str):
-        try:
-            return max(min_value, int(cfg_raw))
-        except ValueError:
-            pass
+    for key in (config_key, *fallback_config_keys):
+        cfg_raw = INDEXER_TUNING_CONFIG.get(key)
+        if isinstance(cfg_raw, int):
+            return max(min_value, cfg_raw)
+        if isinstance(cfg_raw, str):
+            try:
+                return max(min_value, int(cfg_raw))
+            except ValueError:
+                pass
 
     return max(min_value, default)
 
 
-CHROMA_HOST = os.environ.get("CHROMA_HOST", "localhost")
-CHROMA_PORT = int(os.environ.get("CHROMA_PORT", "8000"))
+_DEFAULT_CHROMA_SCHEME, _DEFAULT_CHROMA_HOST, _DEFAULT_CHROMA_PORT = _load_cli_chroma_defaults()
+_DEFAULT_EMBEDDING_BATCH_SIZE = _extract_embedding_batch_from_config(_load_own_rag_cli_config_payload()) or 4
+CHROMA_SCHEME = (
+    os.environ.get("CHROMA_SCHEME")
+    or os.environ.get("MCP_CHROMA_SCHEME")
+    or _DEFAULT_CHROMA_SCHEME
+).strip().lower()
+if CHROMA_SCHEME not in {"http", "https"}:
+    CHROMA_SCHEME = _DEFAULT_CHROMA_SCHEME
+CHROMA_HOST = (
+    os.environ.get("CHROMA_HOST")
+    or os.environ.get("MCP_CHROMA_HOST")
+    or _DEFAULT_CHROMA_HOST
+).strip() or _DEFAULT_CHROMA_HOST
+CHROMA_PORT = _parse_int(
+    os.environ.get("CHROMA_PORT")
+    or os.environ.get("MCP_CHROMA_PORT")
+    or _DEFAULT_CHROMA_PORT,
+    _DEFAULT_CHROMA_PORT,
+    min_value=1,
+)
+CHROMA_SSL = CHROMA_SCHEME == "https"
 
 # Coleções separadas por especialização de embedding
 COLLECTION_CODE_JINA = "code_vectors_jina"
@@ -225,13 +364,19 @@ if RERANKER_QUANTIZATION not in {"default", "dynamic-int8"}:
     RERANKER_QUANTIZATION = "dynamic-int8"
 
 RRF_K = int(os.environ.get("MCP_RRF_K", "60"))
-EMBEDDING_BATCH_SIZE = _config_int("MCP_EMBEDDING_BATCH_SIZE", "embedding_batch_size", 4, min_value=1)
+EMBEDDING_BATCH_SIZE = _config_int(
+    "MCP_EMBEDDING_BATCH_SIZE",
+    "embedding_batch_size",
+    _DEFAULT_EMBEDDING_BATCH_SIZE,
+    min_value=1,
+    fallback_config_keys=("batch_count",),
+)
 
 _env_model_dir = os.environ.get("MCP_MODEL_DIR")
 MODEL_DIR = (
     Path(_env_model_dir).expanduser()
     if _env_model_dir
-    else Path.home() / ".cache" / "my-custom-rag-python" / "models"
+    else Path.home() / ".cache" / "own-rag-cli" / "models"
 )
 
 # Parâmetros do splitter (alinhados com indexer_full.py, perfil low-memory)
@@ -355,9 +500,9 @@ def _model_cache_dir(base_dir: Path, model_id: str) -> Path:
 def _get_chroma_client() -> chromadb.HttpClient:
     global _chroma_client
     if _chroma_client is None:
-        _chroma_client = chromadb.HttpClient(host=CHROMA_HOST, port=CHROMA_PORT)
+        _chroma_client = chromadb.HttpClient(host=CHROMA_HOST, port=CHROMA_PORT, ssl=CHROMA_SSL)
         _chroma_client.heartbeat()
-        log.info("Conectado ao ChromaDB em %s:%s", CHROMA_HOST, CHROMA_PORT)
+        log.info("Conectado ao ChromaDB em %s://%s:%s", CHROMA_SCHEME, CHROMA_HOST, CHROMA_PORT)
     return _chroma_client
 
 
@@ -376,7 +521,7 @@ def get_chroma_collection(collection_name: str) -> chromadb.Collection:
     except Exception as e:
         raise RuntimeError(
             f"Não foi possível acessar a coleção '{collection_name}' no ChromaDB "
-            f"({CHROMA_HOST}:{CHROMA_PORT}). Erro: {e}"
+            f"({CHROMA_SCHEME}://{CHROMA_HOST}:{CHROMA_PORT}). Erro: {e}"
         )
 
 
@@ -1402,7 +1547,7 @@ def index_specific_folder(folder_path: str) -> str:
 
 if __name__ == "__main__":
     log.info("Iniciando servidor MCP RAG (stdio)...")
-    log.info("ChromaDB: %s:%s", CHROMA_HOST, CHROMA_PORT)
+    log.info("ChromaDB: %s://%s:%s", CHROMA_SCHEME, CHROMA_HOST, CHROMA_PORT)
     log.info(
         "Coleções: %s (%s), %s (%s)",
         COLLECTION_CODE_JINA,

package/bin/postinstall.sh

@@ -16,6 +16,7 @@ MONITOR_SRC="${PACKAGE_ROOT}/chroma_monitor.sh"
 MONITOR_DEST="${LOCAL_BIN_DIR}/chroma_monitor.sh"
 REMOVE_SRC="${PACKAGE_ROOT}/bin/rag-remove.sh"
 REMOVE_DEST="${LOCAL_BIN_DIR}/rag-remove.sh"
+OWN_RAG_CONFIG_FILE="${HOME}/.own-rag-cli.json"
 
 COMPOSE_SOURCE="${PACKAGE_ROOT}/bin/docker-compose.yml"
 COMPOSE_DIR="${HOME}/docker-chromadb"
@@ -26,7 +27,34 @@ ALIAS_LINE="alias rag='~/.local/bin/rag-wrapper.sh'"
 log_info() { printf "[+] %s\n" "$*"; }
 log_warn() { printf "[!] %s\n" "$*" >&2; }
 
+ensure_own_rag_cli_config() {
+    python3 - "${OWN_RAG_CONFIG_FILE}" <<'PYEOF'
+import json
+import sys
+from pathlib import Path
+
+cfg = Path(sys.argv[1]).expanduser()
+if cfg.exists():
+    raise SystemExit(0)
+cfg.parent.mkdir(parents=True, exist_ok=True)
+payload = {
+    "chroma": {
+        "scheme": "http",
+        "host": "localhost",
+        "port": 8000,
+    },
+    "indexing": {
+        "embedding_batch_size": 4,
+        "batch_count": 4,
+    },
+}
+cfg.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+PYEOF
+}
+
 mkdir -p "${LOCAL_BIN_DIR}"
+ensure_own_rag_cli_config
+log_info "Config criada/ok: ${OWN_RAG_CONFIG_FILE}"
 
 if [[ -f "${WRAPPER_SRC}" ]]; then
     cp "${WRAPPER_SRC}" "${WRAPPER_DEST}"

package/bin/rag-remove.sh

@@ -96,8 +96,10 @@ declare -a REMOVE_PATHS=(
     "${HOME}/.rag_venv"
     "${HOME}/.rag_db"
     "${HOME}/docker-chromadb"
+    "${HOME}/.cache/own-rag-cli"
     "${HOME}/.cache/my-custom-rag-python"
     "${HOME}/.cache/ny-custom-rag-python"
+    "${HOME}/.own-rag-cli.json"
     "${HOME}/.local/bin/mcp-rag-server"
     "${HOME}/.local/bin/download_model_from_hugginface.py"
     "${HOME}/.local/bin/download_model_from_modelscope.py"
@@ -183,6 +185,7 @@ PY
 
 if command -v npm >/dev/null 2>&1; then
     npm uninstall -g own-rag >/dev/null 2>&1 || true
+    npm uninstall -g own-rag-cli >/dev/null 2>&1 || true
 fi
 
 if [[ ${#FAILED_PATHS[@]} -gt 0 ]]; then