remdb 0.3.141__py3-none-any.whl → 0.3.146__py3-none-any.whl

rem/auth/middleware.py

@@ -6,6 +6,7 @@ Supports anonymous access with rate limiting when allow_anonymous=True.
 MCP endpoints are always protected unless explicitly disabled.
 
 Design Pattern:
+- Check X-API-Key header first (if API key auth enabled)
 - Check session for user on protected paths
 - Check Bearer token for dev token (non-production only)
 - MCP paths always require authentication (protected service)
@@ -20,6 +21,12 @@ Access Modes (configured in settings.auth):
 - mcp_requires_auth=true (default): MCP always requires login regardless of allow_anonymous
 - mcp_requires_auth=false: MCP follows normal allow_anonymous rules (dev only)
 
+API Key Authentication (configured in settings.api):
+- api_key_enabled=true: Require X-API-Key header for protected endpoints
+- api_key: The secret key to validate against
+- Provides simple programmatic access without OAuth flow
+- X-API-Key header takes precedence over session auth
+
 Dev Token Support (non-production only):
 - GET /api/auth/dev/token returns a Bearer token for test-user
 - Include as: Authorization: Bearer dev_<signature>
@@ -82,6 +89,39 @@ class AuthMiddleware(BaseHTTPMiddleware):
         self.mcp_requires_auth = mcp_requires_auth
         self.mcp_path = mcp_path
 
+    def _check_api_key(self, request: Request) -> dict | None:
+        """
+        Check for valid X-API-Key header.
+
+        Returns:
+            API key user dict if valid, None otherwise
+        """
+        # Only check if API key auth is enabled
+        if not settings.api.api_key_enabled:
+            return None
+
+        # Check for X-API-Key header
+        api_key = request.headers.get("x-api-key")
+        if not api_key:
+            return None
+
+        # Validate against configured API key
+        if settings.api.api_key and api_key == settings.api.api_key:
+            logger.debug("X-API-Key authenticated")
+            return {
+                "id": "api-key-user",
+                "email": "api@rem.local",
+                "name": "API Key User",
+                "provider": "api-key",
+                "tenant_id": "default",
+                "tier": "pro",  # API key users get full access
+                "roles": ["user"],
+            }
+
+        # Invalid API key
+        logger.warning("Invalid X-API-Key provided")
+        return None
+
     def _check_dev_token(self, request: Request) -> dict | None:
         """
         Check for valid dev token in Authorization header (non-production only).
@@ -105,7 +145,7 @@ class AuthMiddleware(BaseHTTPMiddleware):
         # Verify dev token
         from ..api.routers.dev import verify_dev_token
         if verify_dev_token(token):
-            logger.debug(f"Dev token authenticated as test-user")
+            logger.debug("Dev token authenticated as test-user")
             return {
                 "id": "test-user",
                 "email": "test@rem.local",
@@ -142,6 +182,31 @@ class AuthMiddleware(BaseHTTPMiddleware):
         if not is_protected or is_excluded:
             return await call_next(request)
 
+        # Check for X-API-Key header first (if enabled)
+        api_key_user = self._check_api_key(request)
+        if api_key_user:
+            request.state.user = api_key_user
+            request.state.is_anonymous = False
+            return await call_next(request)
+
+        # If API key auth is enabled but no valid key provided, reject immediately
+        if settings.api.api_key_enabled:
+            # Check if X-API-Key header was provided but invalid
+            if request.headers.get("x-api-key"):
+                logger.warning(f"Invalid X-API-Key for: {path}")
+                return JSONResponse(
+                    status_code=401,
+                    content={"detail": "Invalid API key"},
+                    headers={"WWW-Authenticate": 'ApiKey realm="REM API"'},
+                )
+            # No API key provided when required
+            logger.debug(f"Missing X-API-Key for: {path}")
+            return JSONResponse(
+                status_code=401,
+                content={"detail": "API key required. Include X-API-Key header."},
+                headers={"WWW-Authenticate": 'ApiKey realm="REM API"'},
+            )
+
         # Check for dev token (non-production only)
         dev_user = self._check_dev_token(request)
         if dev_user:

rem/cli/commands/experiments.py

@@ -125,19 +125,17 @@ def create(
         # Resolve base path: CLI arg > EXPERIMENTS_HOME env var > default "experiments"
         if base_path is None:
             base_path = os.getenv("EXPERIMENTS_HOME", "experiments")
-        # Build dataset reference
+        # Build dataset reference (format auto-detected from file extension)
         if dataset_location == "git":
             dataset_ref = DatasetReference(
                 location=DatasetLocation.GIT,
                 path="ground-truth/dataset.csv",
-                format="csv",
                 description="Ground truth Q&A dataset for evaluation"
             )
         else:  # s3 or hybrid
             dataset_ref = DatasetReference(
                 location=DatasetLocation(dataset_location),
                 path=f"s3://rem-experiments/{name}/datasets/ground_truth.parquet",
-                format="parquet",
                 schema_path="datasets/schema.yaml" if dataset_location == "hybrid" else None,
                 description="Ground truth dataset for evaluation"
             )
@@ -930,58 +928,46 @@ def run(
                 raise click.Abort()
             click.echo("✓ Evaluator credentials validated")
 
-        # Load dataset using Polars
-        import polars as pl
+        # Load dataset using read_dataframe utility (auto-detects format from extension)
+        from rem.utils.files import read_dataframe
 
         click.echo(f"Loading dataset: {list(config.datasets.keys())[0]}")
         dataset_ref = list(config.datasets.values())[0]
 
-        if dataset_ref.location.value == "git":
-            # Load from Git (local filesystem)
-            dataset_path = Path(base_path) / name / dataset_ref.path
-            if not dataset_path.exists():
-                click.echo(f"Error: Dataset not found: {dataset_path}")
-                raise click.Abort()
-
-            if dataset_ref.format == "csv":
-                dataset_df = pl.read_csv(dataset_path)
-            elif dataset_ref.format == "parquet":
-                dataset_df = pl.read_parquet(dataset_path)
-            elif dataset_ref.format == "jsonl":
-                dataset_df = pl.read_ndjson(dataset_path)
-            else:
-                click.echo(f"Error: Format '{dataset_ref.format}' not yet supported")
-                raise click.Abort()
-        elif dataset_ref.location.value in ["s3", "hybrid"]:
-            # Load from S3 using FS provider
-            from rem.services.fs import FS
-            from io import BytesIO
+        try:
+            if dataset_ref.location.value == "git":
+                # Load from Git (local filesystem)
+                dataset_path = Path(base_path) / name / dataset_ref.path
+                if not dataset_path.exists():
+                    click.echo(f"Error: Dataset not found: {dataset_path}")
+                    raise click.Abort()
 
-            fs = FS()
+                dataset_df = read_dataframe(dataset_path)
 
-            try:
-                if dataset_ref.format == "csv":
-                    content = fs.read(dataset_ref.path)
-                    dataset_df = pl.read_csv(BytesIO(content.encode() if isinstance(content, str) else content))
-                elif dataset_ref.format == "parquet":
-                    content_bytes = fs.read(dataset_ref.path)
-                    dataset_df = pl.read_parquet(BytesIO(content_bytes if isinstance(content_bytes, bytes) else content_bytes.encode()))
-                elif dataset_ref.format == "jsonl":
-                    content = fs.read(dataset_ref.path)
-                    dataset_df = pl.read_ndjson(BytesIO(content.encode() if isinstance(content, str) else content))
-                else:
-                    click.echo(f"Error: Format '{dataset_ref.format}' not yet supported")
-                    raise click.Abort()
+            elif dataset_ref.location.value in ["s3", "hybrid"]:
+                # Load from S3 using FS provider
+                from rem.services.fs import FS
 
+                fs = FS()
+                content = fs.read(dataset_ref.path)
+                # Ensure we have bytes
+                if isinstance(content, str):
+                    content = content.encode()
+                dataset_df = read_dataframe(content, filename=dataset_ref.path)
                 click.echo(f"✓ Loaded dataset from S3")
-            except Exception as e:
-                logger.error(f"Failed to load dataset from S3: {e}")
-                click.echo(f"Error: Could not load dataset from S3")
-                click.echo(f"  Path: {dataset_ref.path}")
-                click.echo(f"  Format: {dataset_ref.format}")
+
+            else:
+                click.echo(f"Error: Unknown dataset location: {dataset_ref.location.value}")
                 raise click.Abort()
-        else:
-            click.echo(f"Error: Unknown dataset location: {dataset_ref.location.value}")
+
+        except ValueError as e:
+            # Unsupported format error from read_dataframe
+            click.echo(f"Error: {e}")
+            raise click.Abort()
+        except Exception as e:
+            logger.error(f"Failed to load dataset: {e}")
+            click.echo(f"Error: Could not load dataset")
+            click.echo(f"  Path: {dataset_ref.path}")
             raise click.Abort()
 
         click.echo(f"✓ Loaded dataset: {len(dataset_df)} examples")

rem/models/core/experiment.py

@@ -138,18 +138,14 @@ class DatasetReference(BaseModel):
 
     path: str = Field(
         description=(
-            "Path to dataset:\n"
+            "Path to dataset. Format is inferred from file extension.\n"
+            "Supported: .csv, .tsv, .parquet, .json, .jsonl, .xlsx, .ods, .avro, .ipc\n"
             "- Git: Relative path from experiment root (e.g., 'datasets/ground_truth.csv')\n"
-            "- S3: Full S3 URI (e.g., 's3://bucket/experiments/my-exp/datasets/ground_truth.csv')\n"
+            "- S3: Full S3 URI (e.g., 's3://bucket/experiments/my-exp/datasets/data.parquet')\n"
             "- Hybrid: S3 URI for data, Git path for schema"
         )
     )
 
-    format: Literal["csv", "jsonl", "parquet", "json"] = Field(
-        default="csv",
-        description="Dataset file format"
-    )
-
     schema_path: str | None = Field(
         default=None,
         description=(
@@ -262,8 +258,7 @@ class ExperimentConfig(BaseModel):
     datasets:
       ground_truth:
         location: git
-        path: datasets/ground_truth.csv
-        format: csv
+        path: datasets/ground_truth.csv  # format inferred from extension
     results:
       location: git
       base_path: results/
@@ -288,12 +283,10 @@ class ExperimentConfig(BaseModel):
       ground_truth:
         location: s3
         path: s3://rem-prod/experiments/cv-parser-production/datasets/ground_truth.parquet
-        format: parquet
         schema_path: datasets/schema.yaml  # Schema in Git for documentation
       test_cases:
         location: s3
         path: s3://rem-prod/experiments/cv-parser-production/datasets/test_cases.jsonl
-        format: jsonl
     results:
       location: hybrid
       base_path: s3://rem-prod/experiments/cv-parser-production/results/
@@ -558,7 +551,6 @@ class ExperimentConfig(BaseModel):
 
 - **Location**: `{dataset.location.value}`
 - **Path**: `{dataset.path}`
-- **Format**: `{dataset.format}`
 """
             if dataset.description:
                 readme += f"- **Description**: {dataset.description}\n"
@@ -629,7 +621,6 @@ EXAMPLE_SMALL_EXPERIMENT = ExperimentConfig(
         "ground_truth": DatasetReference(
             location=DatasetLocation.GIT,
             path="datasets/ground_truth.csv",
-            format="csv",
             description="10 manually curated test cases"
         )
     },
@@ -659,7 +650,6 @@ EXAMPLE_LARGE_EXPERIMENT = ExperimentConfig(
         "ground_truth": DatasetReference(
             location=DatasetLocation.S3,
             path="s3://rem-prod/experiments/cv-parser-production/datasets/ground_truth.parquet",
-            format="parquet",
             schema_path="datasets/schema.yaml",
             description="10,000 CV/resume pairs with ground truth extractions"
         )

rem/services/postgres/pydantic_to_sqlalchemy.py

@@ -513,18 +513,15 @@ def get_target_metadata() -> MetaData:
     """
     Get SQLAlchemy metadata for Alembic autogenerate.
 
-    This is the main entry point used by alembic/env.py.
+    This is the main entry point used by alembic/env.py and rem db diff.
+
+    Uses the model registry as the source of truth, which includes:
+    - Core REM models (Resource, Message, User, etc.)
+    - User-registered models via @rem.register_model decorator
 
     Returns:
-        SQLAlchemy MetaData object representing current Pydantic models
+        SQLAlchemy MetaData object representing all registered Pydantic models
     """
-    import rem
-
-    package_root = Path(rem.__file__).parent.parent.parent
-    models_dir = package_root / "src" / "rem" / "models" / "entities"
-
-    if not models_dir.exists():
-        logger.error(f"Models directory not found: {models_dir}")
-        return MetaData()
-
-    return build_sqlalchemy_metadata_from_pydantic(models_dir)
+    # build_sqlalchemy_metadata_from_pydantic uses the registry internally,
+    # so no directory path is needed (the parameter is kept for backwards compat)
+    return build_sqlalchemy_metadata_from_pydantic()

rem/settings.py

@@ -21,8 +21,8 @@ Example .env file:
     LLM__OPENAI_API_KEY=sk-...
     LLM__ANTHROPIC_API_KEY=sk-ant-...
 
-    # Database (port 5050 for Docker Compose)
-    POSTGRES__CONNECTION_STRING=postgresql://rem:rem@localhost:5050/rem
+    # Database (port 5051 for Docker Compose prebuilt, 5050 for local dev)
+    POSTGRES__CONNECTION_STRING=postgresql://rem:rem@localhost:5051/rem
     POSTGRES__POOL_MIN_SIZE=5
     POSTGRES__POOL_MAX_SIZE=20
     POSTGRES__STATEMENT_TIMEOUT=30000
@@ -464,10 +464,11 @@ class PostgresSettings(BaseSettings):
     )
 
     connection_string: str = Field(
-        default="postgresql://rem:rem@localhost:5050/rem",
-        description="PostgreSQL connection string (default uses Docker Compose port 5050)",
+        default="postgresql://rem:rem@localhost:5051/rem",
+        description="PostgreSQL connection string (default uses Docker Compose prebuilt port 5051)",
     )
 
+
     pool_size: int = Field(
         default=10,
         description="Connection pool size (deprecated, use pool_min_size/pool_max_size)",
@@ -1060,6 +1061,8 @@ class APISettings(BaseSettings):
         API__RELOAD - Enable auto-reload for development
         API__WORKERS - Number of worker processes (production)
         API__LOG_LEVEL - Logging level (debug, info, warning, error)
+        API__API_KEY_ENABLED - Enable X-API-Key header authentication
+        API__API_KEY - API key for X-API-Key authentication
     """
 
     model_config = SettingsConfigDict(
@@ -1094,6 +1097,23 @@ class APISettings(BaseSettings):
         description="Logging level (debug, info, warning, error, critical)",
     )
 
+    api_key_enabled: bool = Field(
+        default=False,
+        description=(
+            "Enable X-API-Key header authentication for API endpoints. "
+            "When enabled, requests must include X-API-Key header with valid key. "
+            "This provides simple API key auth independent of OAuth."
+        ),
+    )
+
+    api_key: str | None = Field(
+        default=None,
+        description=(
+            "API key for X-API-Key authentication. Required when api_key_enabled=true. "
+            "Generate with: python -c \"import secrets; print(secrets.token_urlsafe(32))\""
+        ),
+    )
+
 
 class ModelsSettings(BaseSettings):
     """

rem/utils/README.md

@@ -4,6 +4,7 @@
 
 1. [SQL Types](#sql-types-sql_typespy) - Pydantic to PostgreSQL type mapping
 2. [Embeddings](#embeddings-embeddingspy) - Vector embeddings generation
+3. [Files](#files-filespy) - File utilities and DataFrame I/O
 
 ## SQL Types (`sql_types.py`)
 
@@ -581,3 +582,47 @@ This will demonstrate:
 - `sql_types.py` - Use `embedding_provider` in json_schema_extra for TEXT fields
 - OpenAI Embeddings API: https://platform.openai.com/docs/api-reference/embeddings
 - pgvector Documentation: https://github.com/pgvector/pgvector
+
+---
+
+## Files (`files.py`)
+
+File utilities including temporary file handling and DataFrame I/O with automatic format detection.
+
+### DataFrame I/O
+
+Read and write DataFrames with format auto-detected from file extension:
+
+```python
+from rem.utils.files import read_dataframe, write_dataframe
+
+# Read - format inferred from extension
+df = read_dataframe("data.csv")
+df = read_dataframe("data.parquet")
+df = read_dataframe("data.xlsx")
+
+# Read from bytes (e.g., from S3)
+df = read_dataframe(content_bytes, filename="data.csv")
+
+# Write - format inferred from extension
+write_dataframe(df, "output.parquet")
+```
+
+**Supported formats**: `.csv`, `.tsv`, `.parquet`, `.json`, `.jsonl`, `.avro`, `.xlsx`, `.xls`, `.ods`, `.ipc`, `.arrow`, `.feather`
+
+Note: Some formats require optional dependencies (e.g., `fastexcel` for Excel).
+
+### Temporary File Utilities
+
+```python
+from rem.utils.files import temp_file_from_bytes, temp_directory
+
+# Create temp file from bytes, auto-cleanup
+with temp_file_from_bytes(pdf_bytes, suffix=".pdf") as tmp_path:
+    result = process_pdf(tmp_path)
+
+# Create temp directory, auto-cleanup
+with temp_directory() as tmp_dir:
+    # Work with files in tmp_dir
+    pass
+```

rem/utils/files.py

@@ -3,13 +3,18 @@ File utilities for consistent file handling throughout REM.
 
 Provides context managers and helpers for temporary file operations,
 ensuring proper cleanup and consistent patterns.
+
+Also provides DataFrame I/O utilities using Polars with automatic
+format detection based on file extension.
 """
 
 import tempfile
 from contextlib import contextmanager
+from io import BytesIO
 from pathlib import Path
-from typing import Generator, Optional
+from typing import Generator, Optional, Union
 
+import polars as pl
 from loguru import logger
 
 
@@ -165,3 +170,154 @@ def safe_delete(path: Path) -> bool:
     except Exception as e:
         logger.warning(f"Failed to delete {path}: {e}")
         return False
+
+
+# Extension to Polars reader mapping
+_EXTENSION_READERS = {
+    ".csv": pl.read_csv,
+    ".tsv": lambda p, **kw: pl.read_csv(p, separator="\t", **kw),
+    ".parquet": pl.read_parquet,
+    ".pq": pl.read_parquet,
+    ".json": pl.read_json,
+    ".jsonl": pl.read_ndjson,
+    ".ndjson": pl.read_ndjson,
+    ".avro": pl.read_avro,
+    ".xlsx": pl.read_excel,
+    ".xls": pl.read_excel,
+    ".ods": pl.read_ods,
+    ".ipc": pl.read_ipc,
+    ".arrow": pl.read_ipc,
+    ".feather": pl.read_ipc,
+}
+
+# Extension to Polars writer mapping
+_EXTENSION_WRITERS = {
+    ".csv": "write_csv",
+    ".tsv": "write_csv",  # with separator="\t"
+    ".parquet": "write_parquet",
+    ".pq": "write_parquet",
+    ".json": "write_json",
+    ".jsonl": "write_ndjson",
+    ".ndjson": "write_ndjson",
+    ".avro": "write_avro",
+    ".xlsx": "write_excel",
+    ".ipc": "write_ipc",
+    ".arrow": "write_ipc",
+    ".feather": "write_ipc",
+}
+
+
+def read_dataframe(
+    source: Union[str, Path, bytes],
+    filename: Optional[str] = None,
+    **kwargs,
+) -> pl.DataFrame:
+    """
+    Read a DataFrame from a file, inferring format from extension.
+
+    Supports all Polars-compatible formats:
+    - CSV (.csv), TSV (.tsv)
+    - Parquet (.parquet, .pq)
+    - JSON (.json), JSONL/NDJSON (.jsonl, .ndjson)
+    - Avro (.avro)
+    - Excel (.xlsx, .xls)
+    - OpenDocument (.ods)
+    - Arrow IPC (.ipc, .arrow, .feather)
+
+    Args:
+        source: File path (str/Path) or bytes content
+        filename: Required when source is bytes, to determine format
+        **kwargs: Additional arguments passed to the Polars reader
+
+    Returns:
+        Polars DataFrame
+
+    Raises:
+        ValueError: If format cannot be determined or is unsupported
+
+    Examples:
+        >>> df = read_dataframe("data.csv")
+        >>> df = read_dataframe("data.parquet")
+        >>> df = read_dataframe(csv_bytes, filename="data.csv")
+    """
+    # Determine the file extension
+    if isinstance(source, bytes):
+        if not filename:
+            raise ValueError("filename is required when source is bytes")
+        ext = Path(filename).suffix.lower()
+        # For bytes, we need to wrap in BytesIO
+        file_like = BytesIO(source)
+    else:
+        path = Path(source)
+        ext = path.suffix.lower()
+        file_like = path
+
+    # Get the appropriate reader
+    reader = _EXTENSION_READERS.get(ext)
+    if reader is None:
+        supported = ", ".join(sorted(_EXTENSION_READERS.keys()))
+        raise ValueError(
+            f"Unsupported file format: {ext}. "
+            f"Supported formats: {supported}"
+        )
+
+    try:
+        return reader(file_like, **kwargs)
+    except Exception as e:
+        logger.error(f"Failed to read DataFrame from {ext} format: {e}")
+        raise
+
+
+def write_dataframe(
+    df: pl.DataFrame,
+    dest: Union[str, Path],
+    **kwargs,
+) -> None:
+    """
+    Write a DataFrame to a file, inferring format from extension.
+
+    Supports most Polars-writable formats:
+    - CSV (.csv), TSV (.tsv)
+    - Parquet (.parquet, .pq)
+    - JSON (.json), JSONL/NDJSON (.jsonl, .ndjson)
+    - Avro (.avro)
+    - Excel (.xlsx)
+    - Arrow IPC (.ipc, .arrow, .feather)
+
+    Args:
+        df: Polars DataFrame to write
+        dest: Destination file path
+        **kwargs: Additional arguments passed to the Polars writer
+
+    Raises:
+        ValueError: If format cannot be determined or is unsupported
+
+    Examples:
+        >>> write_dataframe(df, "output.csv")
+        >>> write_dataframe(df, "output.parquet")
+        >>> write_dataframe(df, "output.jsonl")
+    """
+    path = Path(dest)
+    ext = path.suffix.lower()
+
+    writer_method = _EXTENSION_WRITERS.get(ext)
+    if writer_method is None:
+        supported = ", ".join(sorted(_EXTENSION_WRITERS.keys()))
+        raise ValueError(
+            f"Unsupported file format for writing: {ext}. "
+            f"Supported formats: {supported}"
+        )
+
+    # Ensure parent directory exists
+    ensure_parent_exists(path)
+
+    # Handle TSV special case
+    if ext == ".tsv":
+        kwargs.setdefault("separator", "\t")
+
+    try:
+        writer = getattr(df, writer_method)
+        writer(path, **kwargs)
+    except Exception as e:
+        logger.error(f"Failed to write DataFrame to {ext} format: {e}")
+        raise

{remdb-0.3.141.dist-info → remdb-0.3.146.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remdb
-Version: 0.3.141
+Version: 0.3.146
 Summary: Resources Entities Moments - Bio-inspired memory system for agentic AI workloads
 Project-URL: Homepage, https://github.com/Percolation-Labs/reminiscent
 Project-URL: Documentation, https://github.com/Percolation-Labs/reminiscent/blob/main/README.md
@@ -12,9 +12,11 @@ Keywords: agents,ai,mcp,memory,postgresql,vector-search
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: <3.13,>=3.12
+Requires-Python: <3.14,>=3.11
 Requires-Dist: aioboto3>=13.0.0
 Requires-Dist: arize-phoenix>=5.0.0
 Requires-Dist: asyncpg>=0.30.0
@@ -143,9 +145,9 @@ pip install "remdb[all]"
 git clone https://github.com/Percolation-Labs/remstack-lab.git
 cd remstack-lab
 
-# Start PostgreSQL with docker-compose
+# Start services (PostgreSQL, Phoenix observability)
 curl -O https://gist.githubusercontent.com/percolating-sirsh/d117b673bc0edfdef1a5068ccd3cf3e5/raw/docker-compose.prebuilt.yml
-docker compose -f docker-compose.prebuilt.yml up -d postgres
+docker compose -f docker-compose.prebuilt.yml up -d
 
 # Configure REM (creates ~/.rem/config.yaml and installs database schema)
 # Add --claude-desktop to register with Claude Desktop app
@@ -177,7 +179,7 @@ rem ask "What is the Bitcoin whitepaper about?"
 Once configured, you can also use the OpenAI-compatible chat completions API:
 
 ```bash
-# Start the API server (if not using docker-compose for API)
+# Start all services (PostgreSQL, Phoenix, API)
 docker compose -f docker-compose.prebuilt.yml up -d
 
 # Test the API

{remdb-0.3.141.dist-info → remdb-0.3.146.dist-info}/RECORD

@@ -3,7 +3,7 @@ rem/config.py,sha256=cyXFpqgTvHeYeIriiQHGC1jSokp55BkJtMS1cVu-C1M,6769
 rem/mcp_server.py,sha256=OK0XaO2k_7BnVRozOfH_xRL51SkRN9kLoNNp_zrrGeA,1383
 rem/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rem/registry.py,sha256=AAGcr7oRHiHsX2mu7TL4EgKw39IFea8F-YIgbX58CUM,10545
-rem/settings.py,sha256=BSV06mmQZxefSG2J8Uxwhe6VJsl7FsFhOODXdiVyj6k,53591
+rem/settings.py,sha256=fB9_J6S8XYXTWC4qlkhVDBsnmJc-VCedd-jVQ8ceajE,54361
 rem/agentic/README.md,sha256=brF1Z1V6s8z5TLoyNPQ3BC5mqDy648QRPOQmGu6Jkzw,21815
 rem/agentic/__init__.py,sha256=-UZiEYpodfD5xDns6L0nYSqK9owr3NxiWsq6vmK1tGk,1268
 rem/agentic/context.py,sha256=EBw2rQ85mygJZHaHfO2A59cu3rgI2vfy1A0Qhri99DE,6282
@@ -49,7 +49,7 @@ rem/api/routers/chat/sse_events.py,sha256=CS1yuor09Qq48bpJBODu7INS94S4GjS8YsPZkI
 rem/api/routers/chat/streaming.py,sha256=bHSDfTjpMS7wMjF1ovKWoH7mPngh7O5EHMzadOLBxKg,37287
 rem/auth/README.md,sha256=BpZUqEVYMUpQG4guykyuvmtzlH3_LsGzspuRZS20i8k,8631
 rem/auth/__init__.py,sha256=NuOzrlipfiRUM7lwuEJTzc-b8lYWCxDl_7V82FxElJA,700
-rem/auth/middleware.py,sha256=_55Va07HElp_fhB9ROyI8bhRXCSCVZ7bROw2vXCer1Y,7381
+rem/auth/middleware.py,sha256=3RaMTFTtu8o3VXfXGazFHSUlDG-wDJNi4msE83w_RwM,9923
 rem/auth/providers/__init__.py,sha256=NMdH84_UC2_9zX7yv-u26FxdGuDipz42S-YO1vc8w1M,318
 rem/auth/providers/base.py,sha256=wa7lrgM0AetZnITc45QFyiNHXgVVoWmZgW9tBpInDLw,11831
 rem/auth/providers/google.py,sha256=p3JAYOtyWwiN6T05rZI6sQJqrXhHaunaNOucHTBzWWc,5346
@@ -65,7 +65,7 @@ rem/cli/commands/cluster.py,sha256=MQThC3Da73ixVQ75UYxleQlB8AqPQLzEK73eaB8pNFI,6
 rem/cli/commands/configure.py,sha256=GQzlER8PkUCTaeYuLbXUYoeqlmEDafcjAcPJrDchC1I,16595
 rem/cli/commands/db.py,sha256=5Enkq7CG7fOpIwMGQ_yF4mTEP3wmoZK3ic3jxERi7Fk,24953
 rem/cli/commands/dreaming.py,sha256=2P8nyX9gnRgyCJZrDuyJt5_YAsFmjUGa6dg7OvoLA8k,13292
-rem/cli/commands/experiments.py,sha256=wAYyh3ti8QJkSS79mXkQ8zOAQQh3vNOwOc3g9xFlE4I,63319
+rem/cli/commands/experiments.py,sha256=dRJKtvrGQu0a9bQZaLnVfdWhaur2bKYviixqOnYQC-k,62472
 rem/cli/commands/mcp.py,sha256=PiP_zXflZ2lPVgmH3N8EGOWXDSfvNTQJD-MMW3ym3xo,1666
 rem/cli/commands/process.py,sha256=DCV7KuS3idRkJ7hsl4uxFqdt67RbxuCP3DL9VeqQuFQ,8630
 rem/cli/commands/scaffold.py,sha256=hv2-ozD1bbD8FEky7OdIDzcgu-KISs5ek6APqykdZ6I,1618
@@ -75,7 +75,7 @@ rem/cli/commands/session.py,sha256=rUDeLnBNwc6A1zSOOs-uHyfixDmBYlVtLToJpbPxo7I,9
 rem/models/core/__init__.py,sha256=BBbARx5_7uVz5FuuoPdFm3tbiWZWubs97i3smU0UxXg,1449
 rem/models/core/core_model.py,sha256=aYVx2905n0b6TGLnIiV5YMWO2O8pxHVtLEWljWvURxU,2617
 rem/models/core/engram.py,sha256=CuoilA74hmlgMT2mZCoEEh0jFsMrKUw9wdyFOygBa8E,10135
-rem/models/core/experiment.py,sha256=F3MEJSFnkZYSUDTIg2W1SYFP1D2cCnWED99CJZN_i7g,20909
+rem/models/core/experiment.py,sha256=Zc5kVtUa05mxEzvJHuXGvGMffa0Uk9Lo16XNsbIDfHw,20777
 rem/models/core/inline_edge.py,sha256=BVOYchWzb5vYRPTBJEKh06YDwzL_NKdvCRg4BtXRn7g,5059
 rem/models/core/rem_query.py,sha256=EpD1NdhxgptW81ID1_q2pnYhioM8J4Efx-JFJsNW_i0,8108
 rem/models/entities/__init__.py,sha256=p3eOFNZdlQ_dF0ZdXR9sHPHu_btMd5mZmw0v5iL8uik,1878
@@ -160,7 +160,7 @@ rem/services/postgres/README.md,sha256=qPimP6367CvfcuF1DjC0VSL0uoc_ThOVeZ0ioJy_z
 rem/services/postgres/__init__.py,sha256=hPOVs7Gi42qjz9ySu1y1Fmxcyo21UrhVycw_y4YAF-0,563
 rem/services/postgres/diff_service.py,sha256=vffYq6e5Ce_b8yuS01u9r27SYCUnmODa5mH8eeZpInM,19402
 rem/services/postgres/migration_service.py,sha256=2irsWfzczZ0_-wge6ReyCrFrE3HxvnlwKAEp8mWqtQo,14897
-rem/services/postgres/pydantic_to_sqlalchemy.py,sha256=Ao1Qh5epVetw8BfEiBmd-xSfUiBOzcROgrfq5BM_hTM,15950
+rem/services/postgres/pydantic_to_sqlalchemy.py,sha256=Gnphk41CPfgYNgEYlnGV1bkz7o56n8PQe1v47mWks-E,16036
 rem/services/postgres/register_type.py,sha256=KwttMTvCdtLvSyW2YICmZ71BBB4oomIoX9IJT-qyEn8,11169
 rem/services/postgres/repository.py,sha256=CYbAozL7iAjVnpV8HbQ1HNu8UUlgHzvyBds1qTICfQE,15788
 rem/services/postgres/schema_generator.py,sha256=TpINJtEPcrbISbz3HUo7zEI1C-542HEAsf2m5kOuGM8,23906
@@ -184,7 +184,7 @@ rem/sql/migrations/002_install_models.sql,sha256=SMhvFKp70ctaln63ghZq9ED34LWR0__
 rem/sql/migrations/003_optional_extensions.sql,sha256=QACy3J50ZgV_4BHNkkT3iswkE1ijc0oCAOgavv6KC5g,12443
 rem/sql/migrations/004_cache_system.sql,sha256=KBpU3hQY08So_MkMfcOwTZDngTMqa_3kA0ujQ98K33k,19672
 rem/utils/AGENTIC_CHUNKING.md,sha256=Z9IyL5yoFTlvamPE5KA7cs0Btoc_6bq8hh7Q_WARlw8,17230
-rem/utils/README.md,sha256=KMgT5nZT023nFWLZz_f3nHSZZkHmmoS7iTLIVRStk3Y,16830
+rem/utils/README.md,sha256=Osix2SVYAECMFTFnLhn8D8rsPrtNaCBWfkZfkn5RS60,18087
 rem/utils/__init__.py,sha256=ZGMTgR7g-V3fhfgKo791wGBhdxy72xTJSo7Q_xwkQRI,1417
 rem/utils/agentic_chunking.py,sha256=B7TIggqOSeHJ5clPPY7O712Wb1xz52Y_2gCPiEZlWqY,21841
 rem/utils/batch_ops.py,sha256=LgzttGV0O_a8Y70fnsX3XwlSZWZKRTnwBBwxP09BOvw,11689
@@ -194,7 +194,7 @@ rem/utils/constants.py,sha256=aX2GwgtaZx3wztsGNa8HFyKxAWNoZlZv9k45gQ7K3Qs,3283
 rem/utils/date_utils.py,sha256=LiqyiYcvfw8I-zvfDzPEs1PnwHOEXfmqn_6BDqefEBo,5542
 rem/utils/dict_utils.py,sha256=qp5myXSgGV2Daz9X-9SKzQDu2WeQeIBBcgFnqd8VhqY,2905
 rem/utils/embeddings.py,sha256=FnjZFHXgxf__dbubY2HknhDAngizr8j7P28-Sug4-f0,13150
-rem/utils/files.py,sha256=8vMiVljs7kDLfGMvcRtJFUH7_F_z4XYGd9cP0h1G78c,4353
+rem/utils/files.py,sha256=6ax-5vmk_4cI-IG55PT9sKj_DqXBl32RkTRSsxqvgGY,8759
 rem/utils/markdown.py,sha256=zhfSiSRX36vky1b2UOGKsuSr11L2l6Kl_O7iSfwQXBY,401
 rem/utils/mime_types.py,sha256=8KGEuPWVdQ8r1DFLsgiaAgEYqMaaQIk-6lCVOBB1z_A,5346
 rem/utils/model_helpers.py,sha256=Cvqeof9KlhkkBmAFxRLtfsh4m_MQ0N8WukI3IDJcTtw,11743
@@ -213,7 +213,7 @@ rem/workers/dreaming.py,sha256=UqCf-iBUhzBVBRFj7_DtR6q27oRo7EUoal9qqHLzlo4,17823
 rem/workers/engram_processor.py,sha256=Ws92kAILMLK_np3F1HRmhKKXiruLIvFn3o9MY3V2W8g,10779
 rem/workers/sqs_file_processor.py,sha256=tX8S0yo2n1XGvaZ7JUqeGmtTwxybQqz3wkHT2j6Ak7Y,6597
 rem/workers/unlogged_maintainer.py,sha256=KhebhXl3s6DwvHnXXEJ45r5tLK9PNj-0KclNIQVQ68s,15817
-remdb-0.3.141.dist-info/METADATA,sha256=DSHGsUASGuvaGKIViTYvA2fqPs9LmiIXYJa1ZDMd2NU,53247
-remdb-0.3.141.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-remdb-0.3.141.dist-info/entry_points.txt,sha256=gmmrz7tRC1WGUrCMJMg6p5pEP5h5mPYRvWIxp1FYdr0,42
-remdb-0.3.141.dist-info/RECORD,,
+remdb-0.3.146.dist-info/METADATA,sha256=5EN8fzDT5MKmkGWP4W6-bZSPQ6uG9j0rcsUsZdpK-_c,53341
+remdb-0.3.146.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+remdb-0.3.146.dist-info/entry_points.txt,sha256=gmmrz7tRC1WGUrCMJMg6p5pEP5h5mPYRvWIxp1FYdr0,42
+remdb-0.3.146.dist-info/RECORD,,