kbase-cli 0.1.0__py3-none-any.whl

kbase/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

kbase/cli.py

@@ -0,0 +1,31 @@
+import typer
+
+from kbase import __version__
+from kbase.commands import add_cmd
+from kbase.commands import config_cmd
+from kbase.commands.ask_cmd import ask_command
+from kbase.commands.doctor_cmd import doctor_command
+from kbase.commands import kb_cmd
+from kbase.commands.init_cmd import init
+from kbase.commands.status_cmd import status_command
+
+app = typer.Typer(help="KBase CLI")
+app.command("init")(init)
+app.add_typer(kb_cmd.app, name="kb")
+app.add_typer(add_cmd.app, name="add")
+app.add_typer(config_cmd.app, name="config")
+app.command("ask")(ask_command)
+app.command("status")(status_command)
+app.command("doctor")(doctor_command)
+
+
+@app.callback()
+def main() -> None:
+    """kbase root command group."""
+
+
+@app.command()
+def version() -> None:
+    """Print kbase version."""
+    typer.echo(f"kbase-cli {__version__}")
+

kbase/commands/__init__.py

@@ -0,0 +1,4 @@
+from . import kb_cmd
+from .init_cmd import init
+
+__all__ = ["kb_cmd", "init"]

kbase/commands/add_cmd.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import asyncio
+import time
+
+import typer
+
+from kbase.config import load_config
+from kbase.domain.ingest_service import IngestService
+from kbase.domain.kb_validator import ensure_kb_exists, validate_kb_name
+
+
+app = typer.Typer(help="Add files into a knowledge base.")
+_ingest_service = IngestService()
+
+
+def get_ingest_service() -> IngestService:
+    return _ingest_service
+
+
+def _resolve_kb_name(kb: str | None) -> str:
+    if kb is not None and kb.strip():
+        return validate_kb_name(kb)
+    return validate_kb_name(load_config().active_kb)
+
+
+def _resolve_target_kb(kb: str | None) -> str:
+    try:
+        return ensure_kb_exists(_resolve_kb_name(kb))
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc), param_hint="--kb") from exc
+
+
+@app.command("file")
+def add_file_command(
+    path: str,
+    kb: str | None = typer.Option(None, "--kb", help="Target knowledge base."),
+    mineru_online: bool = typer.Option(
+        False,
+        "--mineru-online/--mineru-local",
+        help="Use MinerU online API mode (token/url from env).",
+    ),
+) -> None:
+    """Add a single file to knowledge base."""
+    start = time.perf_counter()
+    kb_name = _resolve_target_kb(kb)
+    typer.echo(f"开始入库文件（知识库：{kb_name}）...")
+    service = get_ingest_service()
+    try:
+        asyncio.run(service.add_file(kb_name, path, mineru_online=mineru_online))
+    except Exception as exc:
+        elapsed = time.perf_counter() - start
+        typer.echo(f"文件入库失败，耗时: {elapsed:.2f}s")
+        typer.echo(f"Failed to add file: {exc}")
+        raise typer.Exit(code=1) from exc
+    elapsed = time.perf_counter() - start
+    typer.echo("入库完成。")
+    typer.echo(f"文件入库耗时: {elapsed:.2f}s")
+    typer.echo(f'Added file "{path}" to kb "{kb_name}".')
+
+
+@app.command("dir")
+def add_dir_command(
+    path: str,
+    recursive: bool = typer.Option(True, "--recursive/--no-recursive", help="Scan sub-directories."),
+    kb: str | None = typer.Option(None, "--kb", help="Target knowledge base."),
+    glob: list[str] | None = typer.Option(None, "--glob", help="Glob pattern, can be provided multiple times."),
+    mineru_online: bool = typer.Option(
+        False,
+        "--mineru-online/--mineru-local",
+        help="Use MinerU online API mode (token/url from env).",
+    ),
+) -> None:
+    """Add all files under a directory to knowledge base."""
+    start = time.perf_counter()
+    kb_name = _resolve_target_kb(kb)
+    typer.echo(f"开始入库目录（知识库：{kb_name}）...")
+    service = get_ingest_service()
+    try:
+        result = asyncio.run(service.add_dir(kb_name, path, recursive, glob, mineru_online=mineru_online))
+    except Exception as exc:
+        elapsed = time.perf_counter() - start
+        typer.echo(f"目录入库失败，耗时: {elapsed:.2f}s")
+        typer.echo(f"Failed to add directory: {exc}")
+        raise typer.Exit(code=1) from exc
+
+    total = int(result.get("total", 0))
+    succeeded = int(result.get("succeeded", 0))
+    skipped = int(result.get("skipped", 0))
+    failed = result.get("failed", [])
+    elapsed = time.perf_counter() - start
+    typer.echo("目录入库完成。")
+    typer.echo(f"目录入库耗时: {elapsed:.2f}s")
+    typer.echo(f'Add summary for kb "{kb_name}": success={succeeded}, failed={len(failed)}, skipped={skipped}, total={total}')
+    for item in failed:
+        item_path = item.get("path", "<unknown>")
+        item_error = item.get("error", "unknown error")
+        typer.echo(f"- FAILED {item_path}: {item_error}")

kbase/commands/ask_cmd.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import asyncio
+import time
+
+import typer
+
+from kbase.config import load_config
+from kbase.domain.kb_validator import ensure_kb_exists, validate_kb_name
+from kbase.domain.query_service import QueryService
+
+
+app = typer.Typer(help="Ask questions against a knowledge base.")
+_query_service = QueryService()
+
+
+def get_query_service() -> QueryService:
+    return _query_service
+
+
+def _resolve_kb_name(kb: str | None) -> str:
+    if kb is not None and kb.strip():
+        return validate_kb_name(kb)
+    return validate_kb_name(load_config().active_kb)
+
+
+def _resolve_target_kb(kb: str | None) -> str:
+    try:
+        return ensure_kb_exists(_resolve_kb_name(kb))
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc), param_hint="--kb") from exc
+
+
+def _resolve_query_mode(mode: str | None) -> str:
+    if mode is not None and mode.strip():
+        return mode
+    return load_config().default_query_mode
+
+
+@app.command("ask")
+def ask_command(
+    question: str,
+    kb: str | None = typer.Option(None, "--kb", help="Target knowledge base."),
+    mode: str | None = typer.Option(None, "--mode", help="Query mode, e.g. hybrid/local/global."),
+) -> None:
+    """Ask a question and print the answer."""
+    start = time.perf_counter()
+    kb_name = _resolve_target_kb(kb)
+    query_mode = _resolve_query_mode(mode)
+    typer.echo(f"开始检索并生成回答（知识库：{kb_name}，模式：{query_mode}）...")
+    service = get_query_service()
+    try:
+        answer = asyncio.run(service.ask(kb_name=kb_name, question=question, mode=query_mode))
+    except Exception as exc:
+        elapsed = time.perf_counter() - start
+        typer.echo(f"问答失败，耗时: {elapsed:.2f}s")
+        typer.echo(f"Failed to ask question: {exc}")
+        raise typer.Exit(code=1) from exc
+    elapsed = time.perf_counter() - start
+    typer.echo("问答完成。")
+    typer.echo(f"问答耗时: {elapsed:.2f}s")
+    typer.echo(answer)

kbase/commands/config_cmd.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import typer
+
+from kbase.config import load_config
+
+
+app = typer.Typer(help="Show effective configuration.")
+
+
+def _mask_secret(value: str) -> str:
+    if not value:
+        return "<empty>"
+    if len(value) <= 6:
+        return "*" * len(value)
+    return f"{value[:3]}...{value[-3:]}"
+
+
+def _resolve_env(name: str, fallback: str | None = None) -> str:
+    value = os.getenv(name)
+    if value is not None and value.strip():
+        return value.strip()
+    return (fallback or "").strip()
+
+
+def _build_effective_config() -> dict[str, Any]:
+    cfg = load_config()
+    llm_api_key = _resolve_env("LLM_API_KEY", _resolve_env("OPENAI_API_KEY"))
+    llm_base_url = _resolve_env("LLM_BASE_URL", _resolve_env("OPENAI_BASE_URL"))
+    embed_provider = _resolve_env("EMBED_PROVIDER", "online").lower()
+    embed_model = _resolve_env("EMBED_MODEL", "text-embedding-3-large" if embed_provider == "online" else "bge-m3")
+    embed_dim = _resolve_env("EMBED_DIM", "3072" if embed_provider == "online" else "1024")
+    embed_base_url = _resolve_env("EMBED_BASE_URL", llm_base_url)
+    embed_api_key = _resolve_env("EMBED_API_KEY", llm_api_key if embed_provider == "online" else "ollama")
+    mineru_token = _resolve_env("KBASE_MINERU_API_TOKEN", _resolve_env("MINERU_API_TOKEN"))
+
+    return {
+        "active_kb": cfg.active_kb,
+        "parser": cfg.parser,
+        "default_query_mode": cfg.default_query_mode,
+        "llm_api_key": _mask_secret(llm_api_key),
+        "llm_base_url": llm_base_url or "<missing>",
+        "llm_model": _resolve_env("LLM_MODEL", _resolve_env("KBASE_LLM_MODEL", "gpt-4o-mini")),
+        "vision_model": _resolve_env("VISION_MODEL", _resolve_env("KBASE_VISION_MODEL", "gpt-4o-mini")),
+        "mineru_api_token": _mask_secret(mineru_token),
+        "embed_provider": embed_provider,
+        "embed_model": embed_model,
+        "embed_dim": embed_dim,
+        "embed_base_url": embed_base_url or "<missing>",
+        "embed_api_key": _mask_secret(embed_api_key),
+    }
+
+
+@app.command("show")
+def show_command() -> None:
+    """Show effective configuration with masked secrets."""
+    values = _build_effective_config()
+    for key, value in values.items():
+        typer.echo(f"{key}: {value}")
+

kbase/commands/doctor_cmd.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+import os
+from typing import Callable
+
+import typer
+
+from kbase.config import load_config
+from kbase.domain.kb_validator import ensure_kb_exists
+from kbase.infra.storage import kbase_home
+
+
+@dataclass
+class CheckResult:
+    status: str  # PASS | WARN | FAIL
+    name: str
+    detail: str
+
+
+def _run_check(name: str, fn: Callable[[], tuple[bool, str]], warn: bool = False) -> CheckResult:
+    try:
+        ok, detail = fn()
+    except Exception as exc:  # pragma: no cover
+        return CheckResult("FAIL", name, str(exc))
+    if ok:
+        return CheckResult("PASS", name, detail)
+    return CheckResult("WARN" if warn else "FAIL", name, detail)
+
+
+def doctor_command() -> None:
+    """Run preflight diagnostics for environment and runtime dependencies."""
+    results: list[CheckResult] = []
+
+    cfg_box: dict[str, object] = {}
+
+    def check_config() -> tuple[bool, str]:
+        cfg = load_config()
+        cfg_box["cfg"] = cfg
+        return True, f"active_kb={cfg.active_kb}, parser={cfg.parser}, default_query_mode={cfg.default_query_mode}"
+
+    results.append(_run_check("config", check_config))
+
+    def check_kbase_home() -> tuple[bool, str]:
+        home = kbase_home()
+        exists = home.exists()
+        return (exists, f"KBASE_HOME={home} {'exists' if exists else 'not exists yet'}")
+
+    results.append(_run_check("kbase_home", check_kbase_home, warn=True))
+
+    def check_active_kb() -> tuple[bool, str]:
+        cfg = cfg_box.get("cfg")
+        if cfg is None:
+            return False, "config unavailable"
+        kb_name = getattr(cfg, "active_kb", "default")
+        ensure_kb_exists(str(kb_name))
+        return True, f'knowledge base "{kb_name}" exists'
+
+    results.append(_run_check("active_kb", check_active_kb))
+
+    def check_llm_key() -> tuple[bool, str]:
+        api_key = os.getenv("LLM_API_KEY") or os.getenv("OPENAI_API_KEY", "")
+        if not api_key:
+            return False, "LLM_API_KEY missing (or OPENAI_API_KEY)"
+        return True, f"LLM API key present (length={len(api_key)})"
+
+    results.append(_run_check("llm_api_key", check_llm_key))
+
+    def check_llm_base_url() -> tuple[bool, str]:
+        base_url = os.getenv("LLM_BASE_URL") or os.getenv("OPENAI_BASE_URL", "")
+        if not base_url:
+            return False, "LLM_BASE_URL missing (or OPENAI_BASE_URL)"
+        return True, f"LLM_BASE_URL={base_url}"
+
+    results.append(_run_check("llm_base_url", check_llm_base_url))
+
+    def check_mineru_token() -> tuple[bool, str]:
+        token = os.getenv("KBASE_MINERU_API_TOKEN") or os.getenv("MINERU_API_TOKEN", "")
+        if not token:
+            return False, "MINERU_API_TOKEN missing (or KBASE_MINERU_API_TOKEN)"
+        return True, f"MinerU token present (length={len(token)})"
+
+    results.append(_run_check("mineru_api_token", check_mineru_token))
+
+    rag_box: dict[str, object] = {}
+
+    def check_raganything_import() -> tuple[bool, str]:
+        try:
+            from raganything import RAGAnything, RAGAnythingConfig  # type: ignore
+        except Exception:
+            from raganything.raganything import RAGAnything  # type: ignore
+            from raganything.config import RAGAnythingConfig  # type: ignore
+        rag_box["RAGAnything"] = RAGAnything
+        rag_box["RAGAnythingConfig"] = RAGAnythingConfig
+        return True, "raganything import ok"
+
+    results.append(_run_check("raganything_import", check_raganything_import))
+
+    def check_parser_installation() -> tuple[bool, str]:
+        cfg = cfg_box.get("cfg")
+        if cfg is None:
+            return False, "config unavailable"
+        parser = getattr(cfg, "parser", "mineru-cloud")
+        RAGAnything = rag_box.get("RAGAnything")
+        RAGAnythingConfig = rag_box.get("RAGAnythingConfig")
+        if RAGAnything is None or RAGAnythingConfig is None:
+            return False, "raganything unavailable"
+        with tempfile.TemporaryDirectory(prefix="kbase-doctor-") as temp_dir:
+            try:
+                config = RAGAnythingConfig(working_dir=temp_dir, parser=parser, parse_method="auto")
+                rag = RAGAnything(
+                    config=config,
+                    lightrag_kwargs={"working_dir": temp_dir},
+                )
+            except Exception as exc:
+                message = str(exc)
+                if "Unsupported parser type" in message and "mineru-cloud" in message:
+                    return (
+                        False,
+                        'Current raganything package does not support "mineru-cloud". '
+                        "Please install your patched raganything build.",
+                    )
+                raise
+            checker = getattr(rag, "check_parser_installation", None)
+            if checker is None:
+                return True, f'parser "{parser}" configured (no explicit checker method)'
+            try:
+                ok = bool(checker())
+            except TypeError:
+                ok = bool(checker(parser))
+            return ok, f'parser "{parser}" installation {"verified" if ok else "not available"}'
+
+    results.append(_run_check("parser_installation", check_parser_installation))
+
+    for item in results:
+        typer.echo(f"[{item.status}] {item.name}: {item.detail}")
+
+    fail_count = sum(1 for i in results if i.status == "FAIL")
+    warn_count = sum(1 for i in results if i.status == "WARN")
+    typer.echo(f"\nDoctor summary: fail={fail_count}, warn={warn_count}, total={len(results)}")
+    if fail_count > 0:
+        typer.echo(
+            "Suggested fixes: set MINERU_API_TOKEN, LLM_API_KEY, LLM_BASE_URL, "
+            "ensure active kb exists, run `uv run kbase init`."
+        )
+        raise typer.Exit(code=1)

kbase/commands/init_cmd.py

@@ -0,0 +1,13 @@
+import typer
+
+from kbase.domain.kb_manager import init_workspace
+
+
+def init() -> None:
+    """Initialize kbase workspace with default knowledge base."""
+    try:
+        init_workspace()
+    except ValueError as exc:
+        typer.echo(f"Init failed: {exc}")
+        raise typer.Exit(code=1) from exc
+    typer.echo("Workspace initialized with default knowledge base.")

kbase/commands/kb_cmd.py

@@ -0,0 +1,60 @@
+import typer
+import time
+
+from kbase.domain.kb_manager import create_kb, list_kbs, use_kb
+
+
+app = typer.Typer(help="Manage knowledge bases.")
+
+
+@app.command("list")
+def list_command() -> None:
+    """List all knowledge bases."""
+    start = time.perf_counter()
+    typer.echo("开始列出知识库...")
+    kbs = list_kbs()
+    if not kbs:
+        elapsed = time.perf_counter() - start
+        typer.echo("No knowledge bases found.")
+        typer.echo(f"耗时: {elapsed:.2f}s")
+        return
+    for name, active in kbs:
+        marker = " (active)" if active else ""
+        typer.echo(f"- {name}{marker}")
+    elapsed = time.perf_counter() - start
+    typer.echo(f"列出知识库完成，耗时: {elapsed:.2f}s")
+
+
+@app.command("create")
+def create_command(name: str, use: bool = typer.Option(False, "--use", help="Switch to the kb after creation.")) -> None:
+    """Create a knowledge base."""
+    start = time.perf_counter()
+    typer.echo(f'开始创建知识库 "{name}"...')
+    try:
+        create_kb(name, use=use)
+    except ValueError as exc:
+        elapsed = time.perf_counter() - start
+        typer.echo(f"创建知识库失败，耗时: {elapsed:.2f}s")
+        raise typer.BadParameter(str(exc)) from exc
+    elapsed = time.perf_counter() - start
+    if use:
+        typer.echo(f'Created knowledge base "{name}" and set active.')
+    else:
+        typer.echo(f'Created knowledge base "{name}".')
+    typer.echo(f"创建知识库完成，耗时: {elapsed:.2f}s")
+
+
+@app.command("use")
+def use_command(name: str) -> None:
+    """Switch active knowledge base."""
+    start = time.perf_counter()
+    typer.echo(f'开始切换知识库到 "{name}"...')
+    try:
+        use_kb(name)
+    except ValueError as exc:
+        elapsed = time.perf_counter() - start
+        typer.echo(f"切换知识库失败，耗时: {elapsed:.2f}s")
+        raise typer.BadParameter(str(exc)) from exc
+    elapsed = time.perf_counter() - start
+    typer.echo(f'Active knowledge base set to "{name}".')
+    typer.echo(f"切换知识库完成，耗时: {elapsed:.2f}s")

kbase/commands/status_cmd.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from kbase.config import load_config
+from kbase.domain.kb_validator import ensure_kb_exists, validate_kb_name
+from kbase.infra.storage import kb_dir
+
+
+def _resolve_kb_name(kb: str | None) -> str:
+    if kb is not None and kb.strip():
+        return validate_kb_name(kb)
+    return validate_kb_name(load_config().active_kb)
+
+
+def _resolve_target_kb(kb: str | None) -> str:
+    return ensure_kb_exists(_resolve_kb_name(kb))
+
+
+def _load_json_file(path: Path) -> dict[str, Any]:
+    if not path.exists() or not path.is_file():
+        return {}
+    with path.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data if isinstance(data, dict) else {}
+
+
+def _kv_count(data: dict[str, Any]) -> int:
+    return sum(1 for k in data.keys() if not str(k).startswith("_"))
+
+
+def _status_counts(doc_status: dict[str, Any]) -> tuple[int, int, int]:
+    success = 0
+    failed = 0
+    pending = 0
+    for value in doc_status.values():
+        if not isinstance(value, dict):
+            continue
+        state = str(value.get("status", "")).lower()
+        if state in {"processed", "success", "done"}:
+            success += 1
+        elif state in {"failed", "error"}:
+            failed += 1
+        else:
+            pending += 1
+    return success, failed, pending
+
+
+def _sum_chunks(doc_status: dict[str, Any]) -> int:
+    total = 0
+    for value in doc_status.values():
+        if not isinstance(value, dict):
+            continue
+        try:
+            total += int(value.get("chunks_count", 0))
+        except (TypeError, ValueError):
+            continue
+    return total
+
+
+def _latest_update(doc_status: dict[str, Any]) -> str:
+    latest = ""
+    for value in doc_status.values():
+        if not isinstance(value, dict):
+            continue
+        updated = str(value.get("updated_at", ""))
+        if updated and updated > latest:
+            latest = updated
+    return latest or "n/a"
+
+
+def status_command(kb: str | None = typer.Option(None, "--kb", help="Target knowledge base.")) -> None:
+    """Show active knowledge base and storage/index statistics."""
+    try:
+        active_kb = validate_kb_name(load_config().active_kb)
+        kb_name = _resolve_target_kb(kb)
+        target_path = kb_dir(kb_name)
+        full_docs = _load_json_file(target_path / "kv_store_full_docs.json")
+        doc_status = _load_json_file(target_path / "kv_store_doc_status.json")
+        parse_cache = _load_json_file(target_path / "kv_store_parse_cache.json")
+        docs = max(_kv_count(full_docs), _kv_count(doc_status))
+        chunks = _sum_chunks(doc_status)
+        success, failed, pending = _status_counts(doc_status)
+        cache_entries = _kv_count(parse_cache)
+        file_count = len([p for p in target_path.rglob("*") if p.is_file()]) if target_path.exists() else 0
+
+        typer.echo(f"active_kb: {active_kb}")
+        typer.echo(f"kb: {kb_name}")
+        typer.echo(f"kb_path: {target_path}")
+        typer.echo("stats:")
+        typer.echo(f"  docs: {docs}")
+        typer.echo(f"  chunks: {chunks}")
+        typer.echo(f"  doc_status_success: {success}")
+        typer.echo(f"  doc_status_failed: {failed}")
+        typer.echo(f"  doc_status_pending: {pending}")
+        typer.echo(f"  parse_cache_entries: {cache_entries}")
+        typer.echo(f"  storage_files: {file_count}")
+        typer.echo(f"  last_updated: {_latest_update(doc_status)}")
+    except Exception as exc:
+        typer.echo(f"Failed to get status: {exc}")
+        raise typer.Exit(code=1) from exc

kbase/config/__init__.py

@@ -0,0 +1,4 @@
+from kbase.config.loader import load_config
+from kbase.config.model import AppConfig
+
+__all__ = ["AppConfig", "load_config"]

kbase/config/loader.py

@@ -0,0 +1,42 @@
+import os
+from typing import Any
+
+from kbase.config.model import AppConfig
+from kbase.infra.storage import config_path
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib
+
+
+def _load_file_values() -> dict[str, Any]:
+    path = config_path()
+    if not path.exists():
+        return {}
+    raw = path.read_text(encoding="utf-8")
+    try:
+        values = tomllib.loads(raw)
+    except tomllib.TOMLDecodeError as exc:
+        raise ValueError(f"Failed to parse config file at {path}: {exc}") from exc
+    if not isinstance(values, dict):
+        raise ValueError(f"Invalid config format at {path}: root must be a table")
+    return values
+
+
+def _load_env_values() -> dict[str, str]:
+    mapping = {
+        "active_kb": os.getenv("KBASE_ACTIVE_KB"),
+        "parser": os.getenv("KBASE_PARSER"),
+        "default_query_mode": os.getenv("KBASE_DEFAULT_QUERY_MODE"),
+    }
+    return {key: value for key, value in mapping.items() if value not in (None, "")}
+
+
+def load_config() -> AppConfig:
+    file_values = _load_file_values()
+    env_values = _load_env_values()
+    merged = {**file_values, **env_values}
+    if "parser" not in merged:
+        merged["parser"] = "mineru-cloud"
+    return AppConfig.model_validate(merged)

kbase/config/model.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+from typing import Literal
+
+
+class AppConfig(BaseModel):
+    active_kb: str = "default"
+    parser: Literal["mineru-cloud", "mineru", "docling", "paddleocr"] = "mineru-cloud"
+    default_query_mode: Literal["hybrid", "local", "global", "naive", "mix", "bypass"] = "hybrid"

kbase/domain/__init__.py

@@ -0,0 +1,3 @@
+from .kb_manager import create_kb, init_workspace, list_kbs, use_kb
+
+__all__ = ["init_workspace", "create_kb", "list_kbs", "use_kb"]