feat!: remove set-store config command (#130)

Blocked by #129.

Author: ilbertt

context_use/cli/app.py

@@ -59,8 +59,6 @@
     "Show current settings\n"
     "  context-use config set-key                   "
     "Change OpenAI API key\n"
-    "  context-use config set-store <backend>       "
-    "Switch store (sqlite)\n"
     "  context-use config path                      "
     "Print config file location\n"
 )

context_use/cli/base.py

@@ -351,7 +351,6 @@ class EphemeralApiCommand(ContextCommand, ABC):
     llm_mode: ClassVar[str] = "sync"
 
     def _prepare(self, cfg: Config, args: argparse.Namespace) -> Config:
-        cfg.store_provider = "sqlite"
         cfg.ensure_dirs()
         ensure_api_key(cfg)
         return cfg

context_use/cli/commands/config.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
 
 import argparse
-import subprocess
-import sys
 
 from context_use.cli import output as out
 from context_use.cli.base import BaseCommand, CommandGroup
 from context_use.config import (
     Config,
-    build_ctx,
     config_path,
     load_config,
     load_config_with_sources,
@@ -46,13 +43,7 @@ def badge(attr: str) -> str:
             f"{cfg.openai_embedding_model} {badge('openai_embedding_model')}",
         )
 
-        if cfg.store_provider == "postgres":
-            store_val = f"postgres ({cfg.db_host}:{cfg.db_port}/{cfg.db_name})"
-        elif cfg.store_provider == "sqlite":
-            store_val = f"sqlite ({cfg.db_path})"
-        else:
-            store_val = cfg.store_provider
-        out.kv("Store", f"{store_val} {badge('store_provider')}")
+        out.kv("Store", f"sqlite ({cfg.db_path})")
 
         if cfg.agent_backend:
             out.kv("Agent backend", f"{cfg.agent_backend} {badge('agent_backend')}")
@@ -72,7 +63,6 @@ def badge(attr: str) -> str:
         print()
         out.info("To change settings:")
         out.next_step("context-use config set-key", "change OpenAI API key")
-        out.next_step("context-use config set-store sqlite", "use SQLite (default)")
         out.next_step("context-use config set-agent adk", "configure agent backend")
         print()
 
@@ -101,136 +91,6 @@ async def execute(self, args: argparse.Namespace) -> None:
         out.success(f"API key saved to {path}")
 
 
-def _start_docker_postgres(cfg: Config) -> None:
-    """Start a pgvector/pgvector Postgres container via ``docker run``."""
-    probe = subprocess.run(["docker", "info"], capture_output=True, text=True)
-    if probe.returncode != 0:
-        out.error("Docker daemon is not running.")
-        out.info("Start Docker Desktop (or the docker service) and try again:")
-        out.next_step("context-use config set-store postgres")
-        sys.exit(1)
-
-    container_name = "context-use-postgres"
-
-    result = subprocess.run(
-        ["docker", "inspect", "-f", "{{.State.Running}}", container_name],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode == 0 and "true" in result.stdout:
-        out.success("Postgres container already running")
-        return
-
-    subprocess.run(["docker", "rm", "-f", container_name], capture_output=True)
-
-    out.info("Starting Postgres container...")
-    result = subprocess.run(
-        [
-            "docker",
-            "run",
-            "-d",
-            "--name",
-            container_name,
-            "-p",
-            f"{cfg.db_port}:5432",
-            "-e",
-            f"POSTGRES_USER={cfg.db_user}",
-            "-e",
-            f"POSTGRES_PASSWORD={cfg.db_password}",
-            "-e",
-            f"POSTGRES_DB={cfg.db_name}",
-            "-v",
-            "context-use-pgdata:/var/lib/postgresql/data",
-            "pgvector/pgvector:pg17",
-        ],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode == 0:
-        import time
-
-        out.success(f"Postgres running on localhost:{cfg.db_port}")
-        out.info("Waiting for Postgres to be ready...")
-        time.sleep(3)
-    else:
-        out.error(f"Failed to start Postgres: {result.stderr.strip()}")
-        sys.exit(1)
-
-
-class ConfigSetStoreCommand(BaseCommand):
-    name = "set-store"
-    help = "Configure the store backend"
-
-    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
-        parser.add_argument(
-            "backend",
-            choices=["postgres", "memory"],
-            help="Store backend to use",
-        )
-
-    async def execute(self, args: argparse.Namespace) -> None:
-        import shutil
-
-        cfg = load_config() if config_path().exists() else Config()
-        backend = args.backend
-
-        if backend == "memory":
-            cfg.store_provider = "memory"
-            path = save_config(cfg)
-            out.success(f"Store set to in-memory. Config written to {path}")
-            out.info("Data will only persist for the duration of a single command.")
-            out.info(
-                "Use 'context-use quickstart' to ingest + generate in one session."
-            )
-            return
-
-        # postgres
-        cfg.store_provider = "postgres"
-        out.info("Setting up PostgreSQL for persistent storage across sessions.")
-        out.info("For trying it out without PostgreSQL, run 'context-use quickstart'\n")
-
-        if shutil.which("docker") is not None:
-            prompt_text = "  Start a local Postgres container with Docker? [Y/n] "
-            start_db = input(prompt_text).strip().lower()
-            if start_db in ("", "y", "yes"):
-                _start_docker_postgres(cfg)
-
-        host = input(f"  Database host [{cfg.db_host}]: ").strip() or cfg.db_host
-        port = input(f"  Database port [{cfg.db_port}]: ").strip() or str(cfg.db_port)
-        name = input(f"  Database name [{cfg.db_name}]: ").strip() or cfg.db_name
-        user = input(f"  Database user [{cfg.db_user}]: ").strip() or cfg.db_user
-        pw_prompt = f"  Database password [{cfg.db_password}]: "
-        password = input(pw_prompt).strip() or cfg.db_password
-        cfg.db_host = host
-        cfg.db_port = int(port)
-        cfg.db_name = name
-        cfg.db_user = user
-        cfg.db_password = password
-
-        path = save_config(cfg)
-        out.success(f"PostgreSQL configured. Config written to {path}")
-
-        try:
-            ctx = build_ctx(cfg)
-            await ctx.init()
-            out.success("Database initialised")
-        except Exception as exc:
-            out.warn(f"Could not initialise database: {exc}")
-            out.info("You can retry later with: context-use config set-store postgres")
-
-        print()
-        out.header("You're all set! Next steps:")
-        print()
-        out.info("Run the full pipeline:")
-        out.next_step("context-use pipeline")
-        out.info("Or step by step:")
-        out.next_step("context-use ingest")
-        out.next_step("context-use memories generate")
-        out.info("Start the MCP server:")
-        out.next_step("python -m context_use.ext.mcp_use.run")
-        print()
-
-
 class ConfigSetAgentCommand(BaseCommand):
     name = "set-agent"
     help = "Configure the agent backend"
@@ -253,12 +113,6 @@ async def execute(self, args: argparse.Namespace) -> None:
         if backend == "adk":
             out.info("Requires the adk extra: uv sync --extra adk")
 
-        if cfg.store_provider not in ("sqlite", "postgres"):
-            out.warn("The agent requires a persistent store (sqlite or postgres).")
-            out.info("Set it up first with:")
-            out.next_step("context-use config set-store sqlite")
-            print()
-
         print()
         out.header("Next steps:")
         out.next_step(
@@ -282,7 +136,6 @@ class ConfigGroup(CommandGroup):
     subcommands = [
         ConfigShowCommand,
         ConfigSetKeyCommand,
-        ConfigSetStoreCommand,
         ConfigSetAgentCommand,
         ConfigPathCommand,
     ]

context_use/config.py

@@ -38,12 +38,6 @@ class _FieldSpec(NamedTuple):
     _FieldSpec(
         "openai_embedding_model", "openai", "embedding_model", "OPENAI_EMBEDDING_MODEL"
     ),
-    _FieldSpec("store_provider", "store", "provider", "CONTEXT_USE_STORE"),
-    _FieldSpec("db_host", "database", "host", "POSTGRES_HOST"),
-    _FieldSpec("db_port", "database", "port", "POSTGRES_PORT", int),
-    _FieldSpec("db_name", "database", "name", "POSTGRES_DB"),
-    _FieldSpec("db_user", "database", "user", "POSTGRES_USER"),
-    _FieldSpec("db_password", "database", "password", "POSTGRES_PASSWORD"),
     _FieldSpec("agent_backend", "agent", "backend", "CONTEXT_USE_AGENT_BACKEND"),
     _FieldSpec("data_dir", "data", "dir", None, Path),
 ]
@@ -57,16 +51,6 @@ class Config:
     openai_model: str = _DEFAULT_MODEL
     openai_embedding_model: str = _DEFAULT_EMBEDDING_MODEL
 
-    # Store backend: "sqlite" (default), "memory", or "postgres"
-    store_provider: str = "sqlite"
-
-    # Postgres settings (only used when store_provider == "postgres")
-    db_host: str = "localhost"
-    db_port: int = 5432
-    db_name: str = "context_use"
-    db_user: str = "postgres"
-    db_password: str = "postgres"
-
     # Agent backend: "" (not configured), "adk", …
     agent_backend: str = ""
 
@@ -92,10 +76,6 @@ def storage_path(self) -> str:
     def db_path(self) -> str:
         return str(self.data_dir / "context_use.db")
 
-    @property
-    def uses_postgres(self) -> bool:
-        return self.store_provider == "postgres"
-
     def ensure_dirs(self) -> None:
         """Create the data directory structure if it doesn't exist."""
         self.input_dir.mkdir(parents=True, exist_ok=True)
@@ -152,25 +132,6 @@ def save_config(cfg: Config) -> Path:
         lines.append(f'embedding_model = "{cfg.openai_embedding_model}"')
     lines.append("")
 
-    lines += [
-        "[store]",
-        f'provider = "{cfg.store_provider}"',
-        "",
-    ]
-
-    if cfg.uses_postgres:
-        lines.extend(
-            [
-                "[database]",
-                f'host = "{cfg.db_host}"',
-                f"port = {cfg.db_port}",
-                f'name = "{cfg.db_name}"',
-                f'user = "{cfg.db_user}"',
-                f'password = "{cfg.db_password}"',
-                "",
-            ]
-        )
-
     if cfg.agent_backend:
         lines.extend(
             [
@@ -195,27 +156,10 @@ def save_config(cfg: Config) -> Path:
 def build_ctx(cfg: Config, *, llm_mode: str = "batch") -> ContextUse:
     """Construct a :class:`ContextUse` from a :class:`Config`."""
 
-    storage = DiskStorage(cfg.storage_path)
+    from context_use.store.sqlite import SqliteStore
 
-    if cfg.store_provider == "postgres":
-        from context_use.store.postgres import PostgresStore
-
-        store = PostgresStore(
-            host=cfg.db_host,
-            port=cfg.db_port,
-            database=cfg.db_name,
-            user=cfg.db_user,
-            password=cfg.db_password,
-        )
-    elif cfg.store_provider == "sqlite":
-        from context_use.store.sqlite import SqliteStore
-
-        store = SqliteStore(path=cfg.db_path)
-    else:
-        raise ValueError(
-            f"Unknown store provider {cfg.store_provider!r}. "
-            "Supported: 'sqlite', 'postgres'."
-        )
+    storage = DiskStorage(cfg.storage_path)
+    store = SqliteStore(path=cfg.db_path)
 
     api_key = cfg.openai_api_key or ""
     model = OpenAIModel(cfg.openai_model)

context_use/ext/mcp_use/run.py

@@ -13,7 +13,6 @@
 from __future__ import annotations
 
 import argparse
-import sys
 
 from context_use.config import build_ctx, load_config
 
@@ -33,11 +32,6 @@ def main() -> None:
     args = parser.parse_args()
 
     cfg = load_config()
-    if cfg.store_provider not in ("sqlite"):
-        sys.exit(
-            "error: MCP server requires a persistent store (sqlite).\n"
-            "  Run: context-use config set-store sqlite"
-        )
 
     from context_use.ext.mcp_use.server import create_server