test: add client tests for ReflectResponse parsing

Added comprehensive tests in hindsight-clients/python/tests to verify:
- v0.4.0+ format with empty based_on object
- v0.4.0+ format with null based_on
- v0.4.0+ format with populated facts
- v0.3.0 format (list) correctly fails validation
- Missing based_on field handling

These tests document the v0.3.0 -> v0.4.0 breaking change where
based_on changed from list to object.

.env.example

@@ -31,12 +31,6 @@ HINDSIGHT_API_HOST=0.0.0.0
 HINDSIGHT_API_PORT=8888
 HINDSIGHT_API_LOG_LEVEL=info
 
-# Base Path / Reverse Proxy Support (Optional)
-# Set these when deploying behind a reverse proxy with path-based routing
-# Example: To deploy at example.com/hindsight/, set both to "/hindsight"
-# HINDSIGHT_API_BASE_PATH=/hindsight
-# NEXT_PUBLIC_BASE_PATH=/hindsight
-
 # Database (Optional - uses embedded pg0 by default)
 # HINDSIGHT_API_DATABASE_URL=postgresql://user:pass@host:5432/db
 # HINDSIGHT_API_DATABASE_SCHEMA=public  # PostgreSQL schema name (default: public)

.github/workflows/test.yml

@@ -941,11 +941,30 @@ jobs:
           sleep 1
         done
 
+    - name: Run Python doc examples
+      working-directory: ./hindsight-clients/python
+      run: |
+        for f in ../../hindsight-docs/examples/api/*.py; do
+          echo "Running $f..."
+          uv run python "$f"
+        done
+
+    - name: Run Node.js doc examples
+      run: |
+        for f in hindsight-docs/examples/api/*.mjs; do
+          echo "Running $f..."
+          node "$f"
+        done
+
     - name: Configure CLI
       run: hindsight configure --api-url http://localhost:8888
 
-    - name: Run all doc examples
-      run: ./scripts/test-doc-examples.sh
+    - name: Run CLI doc examples
+      run: |
+        for f in hindsight-docs/examples/api/*.sh; do
+          echo "Running $f..."
+          bash "$f"
+        done
 
     - name: Show API server logs
       if: always()

.gitignore

@@ -46,7 +46,6 @@ hindsight-docs/static/llms-full.txt
 hindsight-dev/benchmarks/locomo/results/
 hindsight-dev/benchmarks/longmemeval/results/
 hindsight-dev/benchmarks/consolidation/results/
-hindsight-dev/benchmarks/perf/results/
 benchmarks/results/
 hindsight-cli/target
 hindsight-clients/rust/target

CLAUDE.md

@@ -57,15 +57,8 @@ cd hindsight-control-plane && npm run dev
 
 ### Benchmarks
 ```bash
-# Accuracy benchmarks
 ./scripts/benchmarks/run-longmemeval.sh
 ./scripts/benchmarks/run-locomo.sh
-
-# Performance benchmarks
-./scripts/benchmarks/run-consolidation.sh
-./scripts/benchmarks/run-retain-perf.sh --document <path>  # Requires API server running
-
-# Results viewer
 ./scripts/benchmarks/start-visualizer.sh  # View results at localhost:8001
 ```
 
@@ -245,61 +238,26 @@ def process(data: UserData) -> str:
 
 ### Adding New API Configuration Flags
 
-Configuration follows a hierarchical system: **Global (env vars) → Tenant (via extension) → Bank (database)**.
-
-Fields must be categorized as either **hierarchical** (can be overridden per-tenant/bank) or **static** (server-level only).
-
-#### Adding a New Configuration Field
+When adding a new environment variable configuration:
 
 1. **config.py** (`hindsight-api/hindsight_api/config.py`):
-   - Add `ENV_*` constant for the environment variable name (e.g., `ENV_MY_SETTING = "HINDSIGHT_API_MY_SETTING"`)
+   - Add `ENV_*` constant for the environment variable name
    - Add `DEFAULT_*` constant for the default value
-   - Add field to `HindsightConfig` dataclass with type annotation
-   - **Mark as hierarchical or static** by adding to `_HIERARCHICAL_FIELDS` set (hierarchical) or leaving it out (static)
+   - Add field to `HindsightConfig` dataclass
    - Add initialization in `from_env()` method
 
-   ```python
-   # Hierarchical field (can be overridden per-bank)
-   _HIERARCHICAL_FIELDS = {
-       ...,
-       "my_setting",  # Add here for hierarchical
-   }
-
-   # Static field - just don't add to _HIERARCHICAL_FIELDS
-   ```
-
 2. **main.py** (`hindsight-api/hindsight_api/main.py`):
    - Add field to the manual `HindsightConfig()` constructor call (search for "CLI override")
 
-3. **Use hierarchical config in MemoryEngine**:
-   ```python
-   # Config is resolved automatically per bank via ConfigResolver
-   config_dict = await self._config_resolver.get_bank_config(bank_id, context)
-   value = config_dict["my_setting"]
-   ```
-
-4. **Use static config** (non-hierarchical):
+3. **Use the config** in code:
    ```python
    from ...config import get_config
    config = get_config()
-   value = config.my_static_field
+   value = config.your_new_field
    ```
 
-5. **Documentation** (`hindsight-docs/docs/developer/configuration.md`):
+4. **Documentation** (`hindsight-docs/docs/developer/configuration.md`):
    - Add to appropriate section table with Variable, Description, Default
-   - Mark if it's hierarchical (can be overridden per-bank)
-
-#### Hierarchical vs Static Guidelines
-
-**Hierarchical** (per-bank overridable):
-- LLM settings (provider, model, API key, base URL)
-- Operation-specific settings (retain mode, chunk size, etc.)
-- Feature flags that vary by customer/bank
-
-**Static** (server-level only):
-- Infrastructure settings (database URL, port, host)
-- Global limits (max concurrent operations)
-- System-wide feature flags
 
 ## Environment Setup
 
@@ -323,4 +281,3 @@ Optional (uses local models by default):
 - `HINDSIGHT_API_EMBEDDINGS_PROVIDER`: local (default) or tei
 - `HINDSIGHT_API_RERANKER_PROVIDER`: local (default) or tei
 - `HINDSIGHT_API_DATABASE_URL`: External PostgreSQL (uses embedded pg0 by default)
-- `HINDSIGHT_API_ENABLE_BANK_CONFIG_API`: Enable per-bank config API (default: false, disabled for security)

README.md

@@ -2,7 +2,7 @@
 
 ![Hindsight Banner](./hindsight-docs/static/img/hindsight-github-banner.png)
 
-[Documentation](https://hindsight.vectorize.io) • [Paper](https://arxiv.org/abs/2512.12818) • [Cookbook](https://hindsight.vectorize.io/cookbook) • [Hindsight Cloud](https://ui.hindsight.vectorize.io/signup)
+[Documentation](https://hindsight.vectorize.io) • [Paper](https://arxiv.org/abs/2512.12818) • [Cookbook](https://hindsight.vectorize.io/cookbook) • [Hindsight Cloud](https://vectorize.io/hindsight/cloud)
 
 [![CI](https://github.com/vectorize-io/hindsight/actions/workflows/release.yml/badge.svg)](https://github.com/vectorize-io/hindsight/actions/workflows/release.yml)
 [![Slack Community](https://img.shields.io/badge/Slack-Join%20Community-4A154B?logo=slack)](https://join.slack.com/t/hindsight-space/shared_invite/zt-3nhbm4w29-LeSJ5Ixi6j8PdiYOCPlOgg)

docker/docker-compose/nginx/README.md

@@ -1,96 +0,0 @@
-# Nginx Reverse Proxy with Custom Base Path
-
-Deploy Hindsight API under `/hindsight` (or any custom path) using Nginx reverse proxy.
-
-## Quick Start (Published Image - API Only)
-
-```bash
-docker-compose up
-```
-
-- **API:** http://localhost:8080/hindsight/docs
-- **Control Plane:** http://localhost:9999 (direct access, not proxied)
-
-## Full Stack with Custom Base Path (Requires Build)
-
-**Important:** You cannot rebuild from the published image with build args. You must build from source.
-
-### Build from Source with Custom Base Path
-
-1. **Clone the repository** (if you haven't):
-```bash
-git clone https://github.com/vectorize-io/hindsight.git
-cd hindsight
-```
-
-2. **Build with base path**:
-```bash
-docker build \
-  --build-arg NEXT_PUBLIC_BASE_PATH=/hindsight \
-  -f docker/standalone/Dockerfile \
-  -t hindsight:custom \
-  .
-```
-
-3. **Update docker-compose.yml** to use your built image:
-```yaml
-services:
-  hindsight:
-    image: hindsight:custom  # ← Change this
-    environment:
-      HINDSIGHT_API_BASE_PATH: /hindsight
-      NEXT_PUBLIC_BASE_PATH: /hindsight
-```
-
-4. **Update nginx.conf** to handle Control Plane routes (see below)
-
-5. **Run**:
-```bash
-docker-compose up
-```
-
-### Required nginx.conf for Full Stack
-
-Replace the current `nginx.conf` with this to proxy both API and Control Plane:
-
-```nginx
-events { worker_connections 1024; }
-
-http {
-    include /etc/nginx/mime.types;
-    default_type application/octet-stream;
-
-    upstream hindsight_api { server hindsight:8888; }
-    upstream hindsight_cp { server hindsight:9999; }
-
-    server {
-        listen 80;
-
-        # API
-        location ~ ^/hindsight/(docs|openapi\.json|health|metrics|v1|mcp) {
-            proxy_pass http://hindsight_api;
-            proxy_set_header Host $http_host;
-        }
-
-        # Control Plane static files
-        location ~ ^/hindsight/_next/ {
-            proxy_pass http://hindsight_cp;
-            proxy_set_header Host $http_host;
-        }
-
-        # Control Plane UI
-        location /hindsight {
-            proxy_pass http://hindsight_cp;
-            proxy_set_header Host $http_host;
-        }
-
-        location = / { return 301 /hindsight; }
-    }
-}
-```
-
-### Why Build is Required
-
-Next.js requires `basePath` at **build time**. The published image was built without a custom base path, so you must rebuild from source with the `NEXT_PUBLIC_BASE_PATH` build arg to deploy the Control Plane under a subpath.
-
-The API works without rebuild because `HINDSIGHT_API_BASE_PATH` is a runtime environment variable.

docker/docker-compose/nginx/docker-compose.yml

@@ -1,88 +0,0 @@
-# Hindsight API deployment with Nginx reverse proxy (API-only)
-#
-# This example deploys Hindsight API under the path /hindsight with:
-# - Hindsight standalone image (API + Control Plane + embedded pg0)
-# - Nginx reverse proxy (API only)
-#
-# Quick Start:
-#   docker-compose -f docker/docker-compose/nginx/docker-compose.yml up
-#
-# Access:
-#   API (via nginx):         http://localhost:8080/hindsight/docs
-#   Control Plane (direct):  http://localhost:9999
-#
-# For full stack deployment (API + Control Plane both under /hindsight):
-#   See README.md in this directory for instructions on building with basePath.
-#
-# Note: This configuration uses the published image (no build required).
-#       Control Plane is served directly because Next.js basePath requires
-#       build-time configuration. See README.md for the full stack option.
-
-services:
-  # Hindsight (API + Control Plane + embedded pg0)
-  hindsight:
-    image: ghcr.io/vectorize-io/hindsight:latest
-    ports:
-      - "9999:9999"  # Control Plane (direct access, not proxied)
-    environment:
-      # API base path for reverse proxy
-      HINDSIGHT_API_BASE_PATH: /hindsight
-
-      # LLM configuration
-      # Using mock provider for testing (no API key needed)
-      # For production, set OPENAI_API_KEY or ANTHROPIC_API_KEY and use a real provider
-      HINDSIGHT_API_LLM_PROVIDER: ${HINDSIGHT_API_LLM_PROVIDER:-mock}
-      HINDSIGHT_API_LLM_API_KEY: ${OPENAI_API_KEY:-not-needed-for-mock}
-      HINDSIGHT_API_LLM_MODEL: ${HINDSIGHT_API_LLM_MODEL:-mock-model}
-
-      # Production examples (uncomment and set appropriate API key):
-      # HINDSIGHT_API_LLM_PROVIDER: openai
-      # HINDSIGHT_API_LLM_API_KEY: ${OPENAI_API_KEY}
-      # HINDSIGHT_API_LLM_MODEL: gpt-4o-mini
-
-      # HINDSIGHT_API_LLM_PROVIDER: anthropic
-      # HINDSIGHT_API_LLM_API_KEY: ${ANTHROPIC_API_KEY}
-      # HINDSIGHT_API_LLM_MODEL: claude-sonnet-4-20250514
-
-      # Server config
-      HINDSIGHT_API_HOST: 0.0.0.0
-      HINDSIGHT_API_PORT: 8888
-      HINDSIGHT_API_LOG_LEVEL: info
-
-      # Control Plane config
-      HINDSIGHT_CP_DATAPLANE_API_URL: http://localhost:8888
-    volumes:
-      # Persist embedded pg0 database
-      - hindsight_data:/app/data
-    # Note: Ports not exposed - access via Nginx at localhost:8080/hindsight/
-    # To debug directly, uncomment these ports:
-    # ports:
-    #   - "8888:8888"  # API
-    #   - "9999:9999"  # Control Plane
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:8888/hindsight/health"]
-      interval: 10s
-      timeout: 5s
-      retries: 3
-      start_period: 30s
-    networks:
-      - hindsight
-
-  # Nginx reverse proxy
-  nginx:
-    image: nginx:alpine
-    ports:
-      - "8080:80"
-    volumes:
-      - ./nginx.conf:/etc/nginx/nginx.conf:ro
-    depends_on:
-      hindsight:
-        condition: service_healthy
-    networks:
-      - hindsight
-
-volumes:
-  hindsight_data:
-
-networks:
-  hindsight:

docker/docker-compose/nginx/nginx.conf

@@ -1,40 +0,0 @@
-# Nginx configuration for API-only reverse proxy
-# Control Plane accessed directly (not through nginx)
-
-events {
-    worker_connections 1024;
-}
-
-http {
-    include /etc/nginx/mime.types;
-    default_type application/octet-stream;
-
-    # Logging
-    access_log /var/log/nginx/access.log;
-    error_log /var/log/nginx/error.log;
-
-    # Upstream - Hindsight API
-    upstream hindsight_api {
-        server hindsight:8888;
-    }
-
-    server {
-        listen 80;
-        server_name _;
-
-        # API endpoints - forward with /hindsight prefix
-        location /hindsight/ {
-            proxy_pass http://hindsight_api;
-
-            proxy_set_header Host $http_host;
-            proxy_set_header X-Real-IP $remote_addr;
-            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-            proxy_set_header X-Forwarded-Proto $scheme;
-        }
-
-        # Redirect root to API docs
-        location = / {
-            return 301 /hindsight/docs;
-        }
-    }
-}

docker/docker-compose/pg_textsearch/Dockerfile

@@ -1,32 +0,0 @@
-# PostgreSQL with pgvector and pg_textsearch extensions
-# Note: pg_textsearch requires PostgreSQL 17+
-FROM postgres:17
-
-# Install build dependencies
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    git \
-    postgresql-server-dev-17 \
-    libpq-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install pgvector
-RUN cd /tmp && \
-    git clone --branch v0.8.0 https://github.com/pgvector/pgvector.git && \
-    cd pgvector && \
-    make && \
-    make install
-
-# Install pg_textsearch
-RUN cd /tmp && \
-    git clone https://github.com/timescale/pg_textsearch.git && \
-    cd pg_textsearch && \
-    make && \
-    make install
-
-# Clean up source files and build dependencies
-RUN rm -rf /tmp/pgvector /tmp/pg_textsearch && \
-    apt-get purge -y --auto-remove build-essential git postgresql-server-dev-17
-
-# Ensure extensions are preloaded
-RUN echo "shared_preload_libraries = 'pg_textsearch'" >> /usr/share/postgresql/postgresql.conf.sample

docker/docker-compose/pg_textsearch/docker-compose.yaml

@@ -1,91 +0,0 @@
-name: hindsight
-# Docker Compose file for Hindsight with PostgreSQL and Timescale pg_textsearch
-# docker compose -f docker/docker-compose/pg_textsearch/docker-compose.yaml down && sleep 2 && docker compose -f docker/docker-compose/pg_textsearch/docker-compose.yaml up -d
-# Make sure to set the required environment variables before running:
-# - HINDSIGHT_DB_PASSWORD: Password for the PostgreSQL user
-# - Configure LLM provider variables as needed (see below in the hindsight service)
-#
-# Usage:
-# docker compose up -d
-#
-# Optional environment variables with defaults:
-# - HINDSIGHT_VERSION: Hindsight application version (default: latest)
-# - HINDSIGHT_DB_USER: PostgreSQL user (default: hindsight_user)
-# - HINDSIGHT_DB_NAME: PostgreSQL database name (default: hindsight_db)
-
-services:
-  db:
-    # Use custom PostgreSQL image with pgvector and pg_textsearch extensions
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: hindsight-db
-    restart: always
-    # Expose PostgreSQL port
-    ports:
-      - "5437:5432"
-    environment:
-      POSTGRES_USER: ${HINDSIGHT_DB_USER:-hindsight_user}
-      POSTGRES_PASSWORD: ${HINDSIGHT_DB_PASSWORD:-hindsight_password}
-      POSTGRES_DB: ${HINDSIGHT_DB_NAME:-hindsight_db}
-    volumes:
-      - pg_data:/var/lib/postgresql/data
-    networks:
-      - hindsight-net
-
-  pg-textsearch-init:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    depends_on:
-      - db
-    environment:
-      - PGPASSWORD=${HINDSIGHT_DB_PASSWORD:-hindsight_password}
-    command: >
-      bash -c "
-        echo 'Waiting for PostgreSQL to be ready...';
-        until pg_isready -h hindsight-db -p 5432 -U hindsight_user; do
-          echo 'PostgreSQL is unavailable - sleeping';
-          sleep 2;
-        done;
-        echo 'PostgreSQL is ready - creating hindsight_db database';
-        psql -h hindsight-db -p 5432 -U hindsight_user -c 'CREATE DATABASE hindsight_db;' 2>/dev/null || echo 'Database already exists';
-        echo 'Creating extensions in hindsight_db database';
-        psql -h hindsight-db -p 5432 -U hindsight_user -d hindsight_db -c 'CREATE EXTENSION IF NOT EXISTS vector CASCADE;';
-        psql -h hindsight-db -p 5432 -U hindsight_user -d hindsight_db -c 'CREATE EXTENSION IF NOT EXISTS pg_textsearch CASCADE;';
-        echo 'Database and extensions created successfully';
-      "
-    restart: "no"
-    networks:
-      - hindsight-net
-
-  hindsight:
-    image: ghcr.io/vectorize-io/hindsight:${HINDSIGHT_VERSION:-latest}
-    container_name: hindsight-app
-    ports:
-      - "8888:8888"
-      - "9999:9999"
-    environment:
-      # LLM Configuration
-      HINDSIGHT_API_LLM_PROVIDER: ${HINDSIGHT_API_LLM_PROVIDER:-openai}
-      HINDSIGHT_API_LLM_API_KEY: ${OPENAI_API_KEY:-your-api-key}
-
-      # Database Configuration
-      HINDSIGHT_API_DATABASE_URL: postgresql://${HINDSIGHT_DB_USER:-hindsight_user}:${HINDSIGHT_DB_PASSWORD:-hindsight_password}@db:5432/${HINDSIGHT_DB_NAME:-hindsight_db}
-
-      # Vector and Text Search Extensions
-      HINDSIGHT_API_VECTOR_EXTENSION: pgvector
-      HINDSIGHT_API_TEXT_SEARCH_EXTENSION: pg_textsearch
-
-    depends_on:
-      - db
-    networks:
-      - hindsight-net
-
-
-networks:
-  hindsight-net:
-    driver: bridge
-
-volumes:
-  pg_data:

docker/docker-compose/vchord/docker-compose.yaml

@@ -1,93 +0,0 @@
-name: hindsight
-# Docker Compose file for Hindsight with PostgreSQL and vectorchord
-# docker compose -f docker/docker-compose/docker-compose.yaml down && sleep 2 && docker compose -f docker/docker-compose/docker-compose.yaml up -d
-# Make sure to set the required environment variables before running:
-# - HINDSIGHT_DB_PASSWORD: Password for the PostgreSQL user
-# - Configure LLM provider variables as needed (see below in the hindsight service)
-#
-# Usage:
-# docker compose up -d
-#
-# Optional environment variables with defaults:
-# - HINDSIGHT_VERSION: Hindsight application version (default: latest)
-# - HINDSIGHT_DB_USER: PostgreSQL user (default: hindsight_user)
-# - HINDSIGHT_DB_NAME: PostgreSQL database name (default: hindsight_db)
-# - HINDSIGHT_DB_VERSION: PostgreSQL version (default: 18)
-
-services:
-  db:
-    # Use a PostgreSQL-Image with vectorchord extension pre-installed
-    image: tensorchord/vchord-suite:pg${HINDSIGHT_DB_VERSION:-18-latest}
-    container_name: hindsight-db
-    restart: always
-    # Expose PostgreSQL port
-    ports:
-      - "5436:5432"
-    environment:
-      POSTGRES_USER: ${HINDSIGHT_DB_USER:-hindsight_user}
-      POSTGRES_PASSWORD: ${HINDSIGHT_DB_PASSWORD:-hindsight_password}
-      POSTGRES_DB: ${HINDSIGHT_DB_NAME:-hindsight_db}
-    volumes:
-      - pg_data:/var/lib/postgresql/${HINDSIGHT_DB_VERSION:-18}/docker
-    networks:
-      - hindsight-net
-
-  vectorchord-init:
-    image: tensorchord/vchord-suite:pg18-latest
-    #container_name: vectorchord-init
-    depends_on:
-      - db
-    environment:
-      - PGPASSWORD=${HINDSIGHT_DB_PASSWORD:-hindsight_password}
-    command: >
-      bash -c "
-        echo 'Waiting for PostgreSQL to be ready...';
-        until pg_isready -h hindsight-db -p 5432 -U hindsight_user; do
-          echo 'PostgreSQL is unavailable - sleeping';
-          sleep 2;
-        done;
-        echo 'PostgreSQL is ready - creating hindsight_db database';
-        psql -h hindsight-db -p 5432 -U hindsight_user -c 'CREATE DATABASE hindsight_db;' 2>/dev/null || echo 'Database already exists';
-        echo 'Creating extensions in hindsight_db database';
-        psql -h hindsight-db -p 5432 -U hindsight_user -d hindsight_db -c 'CREATE EXTENSION IF NOT EXISTS vchord CASCADE;';
-        psql -h hindsight-db -p 5432 -U hindsight_user -d hindsight_db -c 'CREATE EXTENSION IF NOT EXISTS pg_tokenizer CASCADE;';
-        psql -h hindsight-db -p 5432 -U hindsight_user -d hindsight_db -c 'CREATE EXTENSION IF NOT EXISTS vchord_bm25 CASCADE;';
-        echo 'Creating llmlingua2 tokenizer';
-        psql -h hindsight-db -p 5432 -U hindsight_user -d hindsight_db -c \"SELECT create_tokenizer('llmlingua2', \\$\\$ model = \\\"llmlingua2\\\" \\$\\$);\" 2>/dev/null || echo 'Tokenizer already exists or creation skipped';
-        echo 'Database and extensions created successfully';
-      "
-    restart: "no"
-    networks:
-      - hindsight-net
-
-  hindsight:
-    image: ghcr.io/vectorize-io/hindsight:${HINDSIGHT_VERSION:-latest}
-    container_name: hindsight-app
-    ports:
-      - "8888:8888"
-      - "9999:9999"
-    environment:
-      # LLM Configuration (uses OpenAI for testing vchord)
-      # LLM configuration
-      HINDSIGHT_API_LLM_PROVIDER: ${HINDSIGHT_API_LLM_PROVIDER:-openai}
-      HINDSIGHT_API_LLM_API_KEY: ${OPENAI_API_KEY:-your-api-key}
-
-      # Database Configuration
-      HINDSIGHT_API_DATABASE_URL: postgresql://${HINDSIGHT_DB_USER:-hindsight_user}:${HINDSIGHT_DB_PASSWORD:-hindsight_password}@db:5432/${HINDSIGHT_DB_NAME:-hindsight_db}
-
-      # Vector and Text Search Extensions
-      HINDSIGHT_API_VECTOR_EXTENSION: vchord
-      HINDSIGHT_API_TEXT_SEARCH_EXTENSION: vchord
-
-    depends_on:
-      - db
-    networks:
-      - hindsight-net
-
-
-networks:
-  hindsight-net:
-    driver: bridge
-
-volumes:
-  pg_data:

docker/standalone/Dockerfile

@@ -112,10 +112,6 @@ RUN rm -f package-lock.json && sed -i '/"@vectorize-io\/hindsight-client":/d' pa
 # Copy built SDK directly into node_modules (more reliable than npm link in Docker)
 COPY --from=sdk-builder /app/hindsight-clients/typescript ./node_modules/@vectorize-io/hindsight-client
 
-# Accept base path as build argument for reverse proxy deployments
-# Usage: docker build --build-arg NEXT_PUBLIC_BASE_PATH=/hindsight ...
-ARG NEXT_PUBLIC_BASE_PATH=""
-
 # Build Control Plane - run next build first, then custom standalone copy
 # (The build:standalone script expects a specific path structure that differs in Docker)
 RUN npm exec -- next build

helm/hindsight/Chart.yaml

@@ -2,8 +2,8 @@ apiVersion: v2
 name: hindsight
 description: Hindsight helm chart
 type: application
-version: 0.4.11
-appVersion: "0.4.11"
+version: 0.4.10
+appVersion: "0.4.10"
 keywords:
   - ai
   - memory

hindsight-api/hindsight_api/__init__.py

@@ -46,4 +46,4 @@ __all__ = [
     "RemoteTEICrossEncoder",
     "LLMConfig",
 ]
-__version__ = "0.4.11"
+__version__ = "0.4.10"

hindsight-api/hindsight_api/alembic/versions/5a366d414dce_initial_schema.py

@@ -6,7 +6,6 @@ Create Date: 2025-11-27 11:54:19.228030
 
 """
 
-import os
 from collections.abc import Sequence
 
 import sqlalchemy as sa
@@ -22,73 +21,6 @@ branch_labels: str | Sequence[str] | None = None
 depends_on: str | Sequence[str] | None = None
 
 
-def _detect_vector_extension() -> str:
-    """
-    Detect or validate vector extension: 'vchord' or 'pgvector'.
-    Respects HINDSIGHT_API_VECTOR_EXTENSION env var if set.
-    """
-    conn = op.get_bind()
-    vector_extension = os.getenv("HINDSIGHT_API_VECTOR_EXTENSION", "pgvector").lower()
-
-    # Validate configured extension is installed
-    if vector_extension == "vchord":
-        vchord_check = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vchord'")).scalar()
-        if not vchord_check:
-            raise RuntimeError(
-                "Configured vector extension 'vchord' not found. Install it with: CREATE EXTENSION vchord CASCADE;"
-            )
-        return "vchord"
-    elif vector_extension == "pgvector":
-        pgvector_check = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vector'")).scalar()
-        if not pgvector_check:
-            raise RuntimeError(
-                "Configured vector extension 'pgvector' not found. Install it with: CREATE EXTENSION vector;"
-            )
-        return "pgvector"
-    else:
-        raise ValueError(f"Invalid HINDSIGHT_API_VECTOR_EXTENSION: {vector_extension}. Must be 'pgvector' or 'vchord'")
-
-
-def _detect_text_search_extension() -> str:
-    """
-    Detect or validate text search extension: 'native', 'vchord', or 'pg_textsearch'.
-    Respects HINDSIGHT_API_TEXT_SEARCH_EXTENSION env var.
-    Creates the extension if needed.
-    """
-    text_search_extension = os.getenv("HINDSIGHT_API_TEXT_SEARCH_EXTENSION", "native").lower()
-
-    if text_search_extension == "vchord":
-        # Create vchord_bm25 extension if not exists
-        try:
-            op.execute("CREATE EXTENSION IF NOT EXISTS vchord_bm25 CASCADE")
-        except Exception:
-            # Extension might already exist or user lacks permissions - verify it exists
-            conn = op.get_bind()
-            result = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vchord_bm25'")).fetchone()
-            if not result:
-                # Extension truly doesn't exist - re-raise the error
-                raise
-        return "vchord"
-    elif text_search_extension == "pg_textsearch":
-        # Create pg_textsearch extension if not exists
-        try:
-            op.execute("CREATE EXTENSION IF NOT EXISTS pg_textsearch CASCADE")
-        except Exception:
-            # Extension might already exist or user lacks permissions - verify it exists
-            conn = op.get_bind()
-            result = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'pg_textsearch'")).fetchone()
-            if not result:
-                # Extension truly doesn't exist - re-raise the error
-                raise
-        return "pg_textsearch"
-    elif text_search_extension == "native":
-        return "native"
-    else:
-        raise ValueError(
-            f"Invalid HINDSIGHT_API_TEXT_SEARCH_EXTENSION: {text_search_extension}. Must be 'native', 'vchord', or 'pg_textsearch'"
-        )
-
-
 def upgrade() -> None:
     """Upgrade schema - create all tables from scratch."""
 
@@ -234,29 +166,11 @@ def upgrade() -> None:
     )
 
     # Add search_vector column for full-text search
-    # Type depends on configured text search backend
-    text_search_ext = _detect_text_search_extension()
-
-    if text_search_ext == "vchord":
-        # VectorChord BM25: bm25vector type (no GENERATED - tokenization happens on INSERT)
-        # Note: vchord_bm25 extension creates types in bm25_catalog schema
-        op.execute("""
-            ALTER TABLE memory_units
-            ADD COLUMN search_vector bm25_catalog.bm25vector
-        """)
-    elif text_search_ext == "pg_textsearch":
-        # Timescale pg_textsearch: dummy TEXT column for consistency (indexes operate on base columns directly)
-        op.execute("""
-            ALTER TABLE memory_units
-            ADD COLUMN search_vector TEXT
-        """)
-    else:  # native
-        # Native PostgreSQL: tsvector with automatic generation
-        op.execute("""
-            ALTER TABLE memory_units
-            ADD COLUMN search_vector tsvector
-            GENERATED ALWAYS AS (to_tsvector('english', COALESCE(text, '') || ' ' || COALESCE(context, ''))) STORED
-        """)
+    op.execute("""
+        ALTER TABLE memory_units
+        ADD COLUMN search_vector tsvector
+        GENERATED ALWAYS AS (to_tsvector('english', COALESCE(text, '') || ' ' || COALESCE(context, ''))) STORED
+    """)
 
     op.create_index("idx_memory_units_bank_id", "memory_units", ["bank_id"])
     op.create_index("idx_memory_units_document_id", "memory_units", ["document_id"])
@@ -286,47 +200,19 @@ def upgrade() -> None:
         ["bank_id", sa.text("event_date DESC")],
         postgresql_where=sa.text("fact_type = 'observation'"),
     )
-    # Create vector index - conditional based on available extension
-    vector_ext = _detect_vector_extension()
+    op.create_index(
+        "idx_memory_units_embedding",
+        "memory_units",
+        ["embedding"],
+        postgresql_using="hnsw",
+        postgresql_ops={"embedding": "vector_cosine_ops"},
+    )
 
-    if vector_ext == "vchord":
-        # Use vchordrq index for vchord (supports high-dimensional embeddings)
-        op.execute("""
-            CREATE INDEX idx_memory_units_embedding ON memory_units
-            USING vchordrq (embedding vector_l2_ops)
-        """)
-    else:  # pgvector
-        # Use HNSW index for pgvector
-        op.create_index(
-            "idx_memory_units_embedding",
-            "memory_units",
-            ["embedding"],
-            postgresql_using="hnsw",
-            postgresql_ops={"embedding": "vector_cosine_ops"},
-        )
-
-    # Create full-text search index on search_vector
-    # Index type depends on text search backend
-    if text_search_ext == "vchord":
-        # VectorChord BM25 index
-        op.execute("""
-            CREATE INDEX idx_memory_units_text_search ON memory_units
-            USING bm25 (search_vector bm25_catalog.bm25_ops)
-        """)
-    elif text_search_ext == "pg_textsearch":
-        # Timescale pg_textsearch BM25 index on text column
-        # Note: pg_textsearch doesn't support expressions, so we index the main text column
-        op.execute("""
-            CREATE INDEX idx_memory_units_text_search ON memory_units
-            USING bm25(text)
-            WITH (text_config='english')
-        """)
-    else:  # native
-        # Native PostgreSQL GIN index
-        op.execute("""
-            CREATE INDEX idx_memory_units_text_search ON memory_units
-            USING gin(search_vector)
-        """)
+    # Create BM25 full-text search index on search_vector
+    op.execute("""
+        CREATE INDEX idx_memory_units_text_search ON memory_units
+        USING gin(search_vector)
+    """)
 
     op.execute("""
         CREATE MATERIALIZED VIEW memory_units_bm25 AS

hindsight-api/hindsight_api/alembic/versions/n9i0j1k2l3m4_learnings_and_pinned_reflections.py

@@ -10,11 +10,9 @@ This migration:
 3. Adds consolidation tracking columns to the 'banks' table
 """
 
-import os
 from collections.abc import Sequence
 
 from alembic import context, op
-from sqlalchemy import text
 
 # revision identifiers, used by Alembic.
 revision: str = "n9i0j1k2l3m4"
@@ -29,83 +27,10 @@ def _get_schema_prefix() -> str:
     return f'"{schema}".' if schema else ""
 
 
-def _detect_vector_extension() -> str:
-    """
-    Detect or validate vector extension: 'vchord' or 'pgvector'.
-    Respects HINDSIGHT_API_VECTOR_EXTENSION env var if set.
-    """
-    conn = op.get_bind()
-    vector_extension = os.getenv("HINDSIGHT_API_VECTOR_EXTENSION", "pgvector").lower()
-
-    # Validate configured extension is installed
-    if vector_extension == "vchord":
-        vchord_check = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vchord'")).scalar()
-        if not vchord_check:
-            raise RuntimeError(
-                "Configured vector extension 'vchord' not found. Install it with: CREATE EXTENSION vchord CASCADE;"
-            )
-        return "vchord"
-    elif vector_extension == "pgvector":
-        pgvector_check = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vector'")).scalar()
-        if not pgvector_check:
-            raise RuntimeError(
-                "Configured vector extension 'pgvector' not found. Install it with: CREATE EXTENSION vector;"
-            )
-        return "pgvector"
-    else:
-        raise ValueError(f"Invalid HINDSIGHT_API_VECTOR_EXTENSION: {vector_extension}. Must be 'pgvector' or 'vchord'")
-
-
-def _detect_text_search_extension() -> str:
-    """
-    Detect or validate text search extension: 'native', 'vchord', or 'pg_textsearch'.
-    Respects HINDSIGHT_API_TEXT_SEARCH_EXTENSION env var.
-    Creates the extension if needed.
-    """
-    text_search_extension = os.getenv("HINDSIGHT_API_TEXT_SEARCH_EXTENSION", "native").lower()
-
-    if text_search_extension == "vchord":
-        # Create vchord_bm25 extension if not exists
-        try:
-            op.execute("CREATE EXTENSION IF NOT EXISTS vchord_bm25 CASCADE")
-        except Exception:
-            # Extension might already exist or user lacks permissions - verify it exists
-            conn = op.get_bind()
-            result = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vchord_bm25'")).fetchone()
-            if not result:
-                # Extension truly doesn't exist - re-raise the error
-                raise
-        return "vchord"
-    elif text_search_extension == "pg_textsearch":
-        # Create pg_textsearch extension if not exists
-        try:
-            op.execute("CREATE EXTENSION IF NOT EXISTS pg_textsearch CASCADE")
-        except Exception:
-            # Extension might already exist or user lacks permissions - verify it exists
-            conn = op.get_bind()
-            result = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'pg_textsearch'")).fetchone()
-            if not result:
-                # Extension truly doesn't exist - re-raise the error
-                raise
-        return "pg_textsearch"
-    elif text_search_extension == "native":
-        return "native"
-    else:
-        raise ValueError(
-            f"Invalid HINDSIGHT_API_TEXT_SEARCH_EXTENSION: {text_search_extension}. Must be 'native', 'vchord', or 'pg_textsearch'"
-        )
-
-
 def upgrade() -> None:
     """Create learnings and pinned_reflections tables."""
     schema = _get_schema_prefix()
 
-    # Detect which vector extension is available
-    vector_ext = _detect_vector_extension()
-
-    # Detect which text search extension to use
-    text_search_ext = _detect_text_search_extension()
-
     # 1. Create learnings table
     op.execute(f"""
         CREATE TABLE {schema}learnings (
@@ -132,48 +57,18 @@ def upgrade() -> None:
 
     # Indexes for learnings
     op.execute(f"CREATE INDEX idx_learnings_bank_id ON {schema}learnings(bank_id)")
-
-    # Create vector index based on detected extension
-    if vector_ext == "vchord":
-        op.execute(f"""
-            CREATE INDEX idx_learnings_embedding ON {schema}learnings
-            USING vchordrq (embedding vector_l2_ops)
-        """)
-    else:  # pgvector
-        op.execute(f"""
-            CREATE INDEX idx_learnings_embedding ON {schema}learnings
-            USING hnsw (embedding vector_cosine_ops)
-        """)
-
+    op.execute(f"""
+        CREATE INDEX idx_learnings_embedding ON {schema}learnings
+        USING hnsw (embedding vector_cosine_ops)
+    """)
     op.execute(f"CREATE INDEX idx_learnings_tags ON {schema}learnings USING GIN(tags)")
 
     # Full-text search for learnings
-    if text_search_ext == "vchord":
-        # VectorChord BM25: bm25vector type (no GENERATED - tokenization happens on INSERT)
-        # Note: vchord_bm25 extension creates types in bm25_catalog schema
-        op.execute(f"""
-            ALTER TABLE {schema}learnings ADD COLUMN search_vector bm25_catalog.bm25vector
-        """)
-        op.execute(f"""
-            CREATE INDEX idx_learnings_text_search ON {schema}learnings
-            USING bm25 (search_vector bm25_catalog.bm25_ops)
-        """)
-    elif text_search_ext == "pg_textsearch":
-        # Timescale pg_textsearch: dummy TEXT column for consistency (indexes operate on base columns directly)
-        op.execute(f"""
-            ALTER TABLE {schema}learnings ADD COLUMN search_vector TEXT
-        """)
-        op.execute(f"""
-            CREATE INDEX idx_learnings_text_search ON {schema}learnings
-            USING bm25(text) WITH (text_config='english')
-        """)
-    else:  # native
-        # Native PostgreSQL: tsvector with automatic generation
-        op.execute(f"""
-            ALTER TABLE {schema}learnings ADD COLUMN search_vector tsvector
-            GENERATED ALWAYS AS (to_tsvector('english', text)) STORED
-        """)
-        op.execute(f"CREATE INDEX idx_learnings_text_search ON {schema}learnings USING gin(search_vector)")
+    op.execute(f"""
+        ALTER TABLE {schema}learnings ADD COLUMN search_vector tsvector
+        GENERATED ALWAYS AS (to_tsvector('english', text)) STORED
+    """)
+    op.execute(f"CREATE INDEX idx_learnings_text_search ON {schema}learnings USING gin(search_vector)")
 
     # 2. Create pinned_reflections table
     op.execute(f"""
@@ -199,52 +94,21 @@ def upgrade() -> None:
 
     # Indexes for pinned_reflections
     op.execute(f"CREATE INDEX idx_pinned_reflections_bank_id ON {schema}pinned_reflections(bank_id)")
-
-    # Create vector index based on detected extension
-    if vector_ext == "vchord":
-        op.execute(f"""
-            CREATE INDEX idx_pinned_reflections_embedding ON {schema}pinned_reflections
-            USING vchordrq (embedding vector_l2_ops)
-        """)
-    else:  # pgvector
-        op.execute(f"""
-            CREATE INDEX idx_pinned_reflections_embedding ON {schema}pinned_reflections
-            USING hnsw (embedding vector_cosine_ops)
-        """)
-
+    op.execute(f"""
+        CREATE INDEX idx_pinned_reflections_embedding ON {schema}pinned_reflections
+        USING hnsw (embedding vector_cosine_ops)
+    """)
     op.execute(f"CREATE INDEX idx_pinned_reflections_tags ON {schema}pinned_reflections USING GIN(tags)")
 
     # Full-text search for pinned_reflections
-    if text_search_ext == "vchord":
-        # VectorChord BM25: bm25vector type (no GENERATED - tokenization happens on INSERT/UPDATE)
-        # Note: vchord_bm25 extension creates types in bm25_catalog schema
-        op.execute(f"""
-            ALTER TABLE {schema}pinned_reflections ADD COLUMN search_vector bm25_catalog.bm25vector
-        """)
-        op.execute(f"""
-            CREATE INDEX idx_pinned_reflections_text_search ON {schema}pinned_reflections
-            USING bm25 (search_vector bm25_catalog.bm25_ops)
-        """)
-    elif text_search_ext == "pg_textsearch":
-        # Timescale pg_textsearch: dummy TEXT column for consistency (indexes operate on base columns directly)
-        op.execute(f"""
-            ALTER TABLE {schema}pinned_reflections ADD COLUMN search_vector TEXT
-        """)
-        op.execute(f"""
-            CREATE INDEX idx_pinned_reflections_text_search ON {schema}pinned_reflections
-            USING bm25(content)
-            WITH (text_config='english')
-        """)
-    else:  # native
-        # Native PostgreSQL: tsvector with automatic generation
-        op.execute(f"""
-            ALTER TABLE {schema}pinned_reflections ADD COLUMN search_vector tsvector
-            GENERATED ALWAYS AS (to_tsvector('english', COALESCE(name, '') || ' ' || content)) STORED
-        """)
-        op.execute(f"""
-            CREATE INDEX idx_pinned_reflections_text_search ON {schema}pinned_reflections
-            USING gin(search_vector)
-        """)
+    op.execute(f"""
+        ALTER TABLE {schema}pinned_reflections ADD COLUMN search_vector tsvector
+        GENERATED ALWAYS AS (to_tsvector('english', COALESCE(name, '') || ' ' || content)) STORED
+    """)
+    op.execute(f"""
+        CREATE INDEX idx_pinned_reflections_text_search ON {schema}pinned_reflections
+        USING gin(search_vector)
+    """)
 
     # 3. Add consolidation tracking columns to banks table
     op.execute(f"""

hindsight-api/hindsight_api/alembic/versions/x9s0t1u2v3w4_add_bank_config_column.py

@@ -1,64 +0,0 @@
-"""Add config JSONB column to banks table for hierarchical configuration
-
-Revision ID: x9s0t1u2v3w4
-Revises: w8r9s0t1u2v3
-Create Date: 2026-02-09
-
-This migration adds a `config` JSONB column to the banks table to support
-per-bank configuration overrides. This enables hierarchical configuration where:
-- Global config is loaded from environment variables
-- Tenant config is provided via TenantExtension
-- Bank config overrides are stored in banks.config JSONB column
-
-The config column stores overrides for hierarchical fields (LLM settings,
-retention parameters, retrieval settings, etc.) in Python field name format.
-"""
-
-from collections.abc import Sequence
-
-import sqlalchemy as sa
-from alembic import context, op
-from sqlalchemy.dialects.postgresql import JSONB
-
-revision: str = "x9s0t1u2v3w4"
-down_revision: str | Sequence[str] | None = "w8r9s0t1u2v3"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-
-def _get_schema_prefix() -> str:
-    """Get schema prefix for table names (required for multi-tenant support)."""
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
-def upgrade() -> None:
-    """Add config JSONB column to banks table with GIN index."""
-    schema = _get_schema_prefix()
-
-    # Add config column to banks table
-    op.execute(f"""
-        ALTER TABLE {schema}banks
-        ADD COLUMN config JSONB NOT NULL DEFAULT '{{}}'::jsonb
-    """)
-
-    # Add GIN index for efficient JSONB queries
-    op.execute(f"""
-        CREATE INDEX idx_banks_config
-        ON {schema}banks
-        USING gin(config)
-    """)
-
-
-def downgrade() -> None:
-    """Remove config column and index from banks table."""
-    schema = _get_schema_prefix()
-
-    # Drop index first
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_banks_config")
-
-    # Drop column
-    op.execute(f"""
-        ALTER TABLE {schema}banks
-        DROP COLUMN IF EXISTS config
-    """)

hindsight-api/hindsight_api/alembic/versions/y0t1u2v3w4x5_add_result_metadata_gin_index.py

@@ -1,49 +0,0 @@
-"""Add GIN index on async_operations.result_metadata for parent_operation_id queries
-
-Revision ID: y0t1u2v3w4x5
-Revises: x9s0t1u2v3w4
-Create Date: 2026-02-13
-
-This migration adds a GIN index on the result_metadata JSONB column in the
-async_operations table to support efficient queries for child operations by
-parent_operation_id.
-
-The index enables fast lookups when querying for child operations:
-  SELECT * FROM async_operations
-  WHERE result_metadata::jsonb @> '{"parent_operation_id": "uuid"}'::jsonb
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "y0t1u2v3w4x5"
-down_revision: str | Sequence[str] | None = "x9s0t1u2v3w4"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-
-def _get_schema_prefix() -> str:
-    """Get schema prefix for table names (required for multi-tenant support)."""
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
-def upgrade() -> None:
-    """Add GIN index on result_metadata for efficient parent_operation_id queries."""
-    schema = _get_schema_prefix()
-
-    # Add GIN index for JSONB containment queries (@> operator)
-    op.execute(f"""
-        CREATE INDEX idx_async_operations_result_metadata
-        ON {schema}async_operations
-        USING gin(result_metadata)
-    """)
-
-
-def downgrade() -> None:
-    """Remove GIN index on result_metadata."""
-    schema = _get_schema_prefix()
-
-    # Drop index
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_async_operations_result_metadata")

hindsight-api/hindsight_api/api/http.py

@@ -70,7 +70,6 @@ def FieldWithDefault(default_factory: Callable, **kwargs) -> Any:
     return Field(default_factory=default_factory, json_schema_extra=json_extra, **kwargs)
 
 
-from hindsight_api.config import get_config
 from hindsight_api.engine.db_utils import acquire_with_retry
 from hindsight_api.engine.memory_engine import Budget, _get_tiktoken_encoding, fq_table
 from hindsight_api.engine.reflect.observations import Observation
@@ -827,55 +826,6 @@ class CreateBankRequest(BaseModel):
     background: str | None = Field(default=None, description="Deprecated: use mission instead")
 
 
-class BankConfigUpdate(BaseModel):
-    """Request model for updating bank configuration."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "example": {
-                "updates": {
-                    "llm_model": "claude-sonnet-4-5",
-                    "retain_extraction_mode": "verbose",
-                    "retain_custom_instructions": "Extract technical details carefully",
-                }
-            }
-        }
-    )
-
-    updates: dict[str, Any] = Field(
-        description="Configuration overrides. Keys can be in Python field format (llm_provider) "
-        "or environment variable format (HINDSIGHT_API_LLM_PROVIDER). "
-        "Only hierarchical fields can be overridden per-bank."
-    )
-
-
-class BankConfigResponse(BaseModel):
-    """Response model for bank configuration."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "example": {
-                "bank_id": "my-bank",
-                "config": {
-                    "llm_provider": "openai",
-                    "llm_model": "gpt-4",
-                    "retain_extraction_mode": "verbose",
-                },
-                "overrides": {
-                    "llm_model": "gpt-4",
-                    "retain_extraction_mode": "verbose",
-                },
-            }
-        }
-    )
-
-    bank_id: str = Field(description="Bank identifier")
-    config: dict[str, Any] = Field(
-        description="Fully resolved configuration with all hierarchical overrides applied (Python field names)"
-    )
-    overrides: dict[str, Any] = Field(description="Bank-specific configuration overrides only (Python field names)")
-
-
 class GraphDataResponse(BaseModel):
     """Response model for graph data endpoint."""
 
@@ -1357,16 +1307,6 @@ class CancelOperationResponse(BaseModel):
     operation_id: str
 
 
-class ChildOperationStatus(BaseModel):
-    """Status of a child operation (for batch operations)."""
-
-    operation_id: str
-    status: str
-    sub_batch_index: int | None = None
-    items_count: int | None = None
-    error_message: str | None = None
-
-
 class OperationStatusResponse(BaseModel):
     """Response model for getting a single operation status."""
 
@@ -1391,13 +1331,6 @@ class OperationStatusResponse(BaseModel):
     updated_at: str | None = None
     completed_at: str | None = None
     error_message: str | None = None
-    result_metadata: dict[str, Any] | None = Field(
-        default=None,
-        description="Internal metadata for debugging. Structure may change without notice. Not for production use.",
-    )
-    child_operations: list[ChildOperationStatus] | None = Field(
-        default=None, description="Child operations for batch operations (if applicable)"
-    )
 
 
 class AsyncOperationSubmitResponse(BaseModel):
@@ -1422,7 +1355,6 @@ class FeaturesInfo(BaseModel):
     observations: bool = Field(description="Whether observations (auto-consolidation) are enabled")
     mcp: bool = Field(description="Whether MCP (Model Context Protocol) server is enabled")
     worker: bool = Field(description="Whether the background worker is enabled")
-    bank_config_api: bool = Field(description="Whether per-bank configuration API is enabled")
 
 
 class VersionResponse(BaseModel):
@@ -1436,7 +1368,6 @@ class VersionResponse(BaseModel):
                     "observations": False,
                     "mcp": True,
                     "worker": True,
-                    "bank_config_api": False,
                 },
             }
         }
@@ -1593,9 +1524,6 @@ def create_app(
         logging.info("Memory system closed")
 
     from hindsight_api import __version__
-    from hindsight_api.config import get_config
-
-    config = get_config()
 
     app = FastAPI(
         title="Hindsight HTTP API",
@@ -1609,7 +1537,6 @@ def create_app(
             "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
         },
         lifespan=lifespan,
-        root_path=config.base_path,
     )
 
     # IMPORTANT: Set memory on app.state immediately, don't wait for lifespan
@@ -1716,21 +1643,17 @@ def _register_routes(app: FastAPI):
 
         Returns version info and feature flags that can be used by clients
         to determine which capabilities are available.
-
-        Note: observations flag shows the global default. Individual banks
-        may override this setting via bank-specific configuration.
         """
         from hindsight_api import __version__
-        from hindsight_api.config import _get_raw_config
+        from hindsight_api.config import get_config
 
-        config = _get_raw_config()
+        config = get_config()
         return VersionResponse(
             api_version=__version__,
             features=FeaturesInfo(
                 observations=config.enable_observations,
                 mcp=config.mcp_enabled,
                 worker=config.worker_enabled,
-                bank_config_api=config.enable_bank_config_api,
             ),
         )
 
@@ -3384,112 +3307,6 @@ def _register_routes(app: FastAPI):
             logger.error(f"Error in DELETE /v1/default/banks/{bank_id}/observations: {error_detail}")
             raise HTTPException(status_code=500, detail=str(e))
 
-    @app.get(
-        "/v1/default/banks/{bank_id}/config",
-        response_model=BankConfigResponse,
-        summary="Get bank configuration",
-        description="Get fully resolved configuration for a bank including all hierarchical overrides (global → tenant → bank). "
-        "The 'config' field contains all resolved config values. The 'overrides' field shows only bank-specific overrides.",
-        operation_id="get_bank_config",
-        tags=["Banks"],
-    )
-    async def api_get_bank_config(bank_id: str, request_context: RequestContext = Depends(get_request_context)):
-        """Get configuration for a bank with all hierarchical overrides applied."""
-        if not get_config().enable_bank_config_api:
-            raise HTTPException(
-                status_code=404,
-                detail="Bank configuration API is disabled. Set HINDSIGHT_API_ENABLE_BANK_CONFIG_API=true to enable.",
-            )
-        try:
-            # Get resolved config from config resolver
-            config_dict = await app.state.memory._config_resolver.get_bank_config(bank_id, request_context)
-
-            # Get bank-specific overrides only
-            bank_overrides = await app.state.memory._config_resolver._load_bank_config(bank_id)
-
-            return BankConfigResponse(bank_id=bank_id, config=config_dict, overrides=bank_overrides)
-        except (AuthenticationError, HTTPException):
-            raise
-        except Exception as e:
-            import traceback
-
-            error_detail = f"{str(e)}\n\nTraceback:\n{traceback.format_exc()}"
-            logger.error(f"Error in GET /v1/default/banks/{bank_id}/config: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @app.patch(
-        "/v1/default/banks/{bank_id}/config",
-        response_model=BankConfigResponse,
-        summary="Update bank configuration",
-        description="Update configuration overrides for a bank. Only hierarchical fields can be overridden (LLM settings, retention parameters, etc.). "
-        "Keys can be provided in Python field format (llm_provider) or environment variable format (HINDSIGHT_API_LLM_PROVIDER).",
-        operation_id="update_bank_config",
-        tags=["Banks"],
-    )
-    async def api_update_bank_config(
-        bank_id: str, request: BankConfigUpdate, request_context: RequestContext = Depends(get_request_context)
-    ):
-        """Update configuration overrides for a bank."""
-        if not get_config().enable_bank_config_api:
-            raise HTTPException(
-                status_code=404,
-                detail="Bank configuration API is disabled. Set HINDSIGHT_API_ENABLE_BANK_CONFIG_API=true to enable.",
-            )
-        try:
-            # Update config via config resolver (validates configurable fields and permissions)
-            await app.state.memory._config_resolver.update_bank_config(bank_id, request.updates, request_context)
-
-            # Return updated config
-            config_dict = await app.state.memory._config_resolver.get_bank_config(bank_id, request_context)
-            bank_overrides = await app.state.memory._config_resolver._load_bank_config(bank_id)
-
-            return BankConfigResponse(bank_id=bank_id, config=config_dict, overrides=bank_overrides)
-        except ValueError as e:
-            # Validation error (e.g., trying to override static field)
-            raise HTTPException(status_code=400, detail=str(e))
-        except (AuthenticationError, HTTPException):
-            raise
-        except Exception as e:
-            import traceback
-
-            error_detail = f"{str(e)}\n\nTraceback:\n{traceback.format_exc()}"
-            logger.error(f"Error in PATCH /v1/default/banks/{bank_id}/config: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @app.delete(
-        "/v1/default/banks/{bank_id}/config",
-        response_model=BankConfigResponse,
-        summary="Reset bank configuration",
-        description="Reset bank configuration to defaults by removing all bank-specific overrides. "
-        "The bank will then use global and tenant-level configuration only.",
-        operation_id="reset_bank_config",
-        tags=["Banks"],
-    )
-    async def api_reset_bank_config(bank_id: str, request_context: RequestContext = Depends(get_request_context)):
-        """Reset bank configuration to defaults (remove all overrides)."""
-        if not get_config().enable_bank_config_api:
-            raise HTTPException(
-                status_code=404,
-                detail="Bank configuration API is disabled. Set HINDSIGHT_API_ENABLE_BANK_CONFIG_API=true to enable.",
-            )
-        try:
-            # Reset config via config resolver
-            await app.state.memory._config_resolver.reset_bank_config(bank_id)
-
-            # Return updated config (should match defaults now)
-            config_dict = await app.state.memory._config_resolver.get_bank_config(bank_id, request_context)
-            bank_overrides = await app.state.memory._config_resolver._load_bank_config(bank_id)
-
-            return BankConfigResponse(bank_id=bank_id, config=config_dict, overrides=bank_overrides)
-        except (AuthenticationError, HTTPException):
-            raise
-        except Exception as e:
-            import traceback
-
-            error_detail = f"{str(e)}\n\nTraceback:\n{traceback.format_exc()}"
-            logger.error(f"Error in DELETE /v1/default/banks/{bank_id}/config: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
     @app.post(
         "/v1/default/banks/{bank_id}/consolidate",
         response_model=ConsolidationResponse,

hindsight-api/hindsight_api/api/mcp.py

@@ -114,39 +114,9 @@ def create_mcp_server(memory: MemoryEngine, multi_bank: bool = True) -> FastMCP:
         logger.info(f"Loading MCP extension: {mcp_extension.__class__.__name__}")
         mcp_extension.register_tools(mcp, memory)
 
-    # Make all tools tolerant of extra arguments from LLMs (e.g., "explanation")
-    _make_tools_tolerant(mcp)
-
     return mcp
 
 
-def _make_tools_tolerant(mcp: FastMCP) -> None:
-    """Wrap all tool run methods to strip unknown arguments before validation.
-
-    LLMs frequently add extra fields like "explanation" or "reasoning" to tool calls.
-    FastMCP's Pydantic TypeAdapter rejects these with "Unexpected keyword argument".
-    This wraps each tool's run() to filter arguments to only known parameters.
-    """
-    try:
-        for name, tool in mcp._tool_manager._tools.items():
-            if hasattr(tool, "parameters") and tool.parameters:
-                allowed = set(tool.parameters.get("properties", {}).keys())
-                original_run = tool.run
-
-                async def _tolerant_run(arguments, _allowed=allowed, _orig=original_run):
-                    extra_keys = set(arguments.keys()) - _allowed
-                    if extra_keys:
-                        logger.debug(f"Stripping unknown arguments from tool call: {extra_keys}")
-                        arguments = {k: v for k, v in arguments.items() if k in _allowed}
-                    return await _orig(arguments)
-
-                # FunctionTool is a Pydantic model with extra='forbid', so use
-                # object.__setattr__ to bypass Pydantic's setter validation.
-                object.__setattr__(tool, "run", _tolerant_run)
-    except (AttributeError, KeyError) as e:
-        logger.warning(f"Could not make tools tolerant of extra arguments: {e}")
-
-
 class MCPMiddleware:
     """ASGI middleware that intercepts MCP requests and routes to appropriate MCP server.
 
@@ -172,11 +142,6 @@ class MCPMiddleware:
        - No bank management tools (list_banks, create_bank)
        - Recommended for agent isolation
 
-    Bank ID resolution priority:
-        1. URL path (e.g., /mcp/{bank_id}/) → single-bank mode
-        2. X-Bank-Id header → multi-bank mode
-        3. HINDSIGHT_MCP_BANK_ID env var → multi-bank mode (default: "default")
-
     Examples:
         # Single-bank mode (recommended for agent isolation)
         claude mcp add --transport http my-agent http://localhost:8888/mcp/my-agent-bank/ \\
@@ -277,25 +242,20 @@ class MCPMiddleware:
             _current_schema.set(tenant_context.schema_name) if tenant_context and tenant_context.schema_name else None
         )
 
-        # Resolve bank_id: path takes priority over header.
-        # Path = user's explicit connection endpoint (e.g., /mcp/my-bank/).
-        # X-Bank-Id header = per-request override for multi-bank mode only.
-        bank_id = None
+        # Try to get bank_id from header first (for Claude Code compatibility)
+        bank_id = self._get_header(scope, "X-Bank-Id")
         bank_id_from_path = False
-        new_path = path
 
-        # First, try to extract from path: /{bank_id}/...
-        if path.startswith("/") and len(path) > 1:
+        # If no header, try to extract from path: /{bank_id}/...
+        new_path = path
+        if not bank_id and path.startswith("/") and len(path) > 1:
             parts = path[1:].split("/", 1)
             if parts[0]:
+                # First segment looks like a bank_id
                 bank_id = parts[0]
                 bank_id_from_path = True
                 new_path = "/" + parts[1] if len(parts) > 1 else "/"
 
-        # If no path-based bank_id, try X-Bank-Id header (multi-bank mode)
-        if not bank_id:
-            bank_id = self._get_header(scope, "X-Bank-Id")
-
         # Fall back to default bank_id
         if not bank_id:
             bank_id = DEFAULT_BANK_ID

hindsight-api/hindsight_api/config.py

@@ -8,9 +8,8 @@ import json
 import logging
 import os
 import sys
-from dataclasses import dataclass, field, fields
+from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any
 
 from dotenv import find_dotenv, load_dotenv
 
@@ -19,103 +18,6 @@ load_dotenv(find_dotenv(usecwd=True), override=True)
 
 logger = logging.getLogger(__name__)
 
-
-class ConfigFieldAccessError(AttributeError):
-    """Raised when trying to access a bank-configurable field from global config."""
-
-    pass
-
-
-class StaticConfigProxy:
-    """
-    Proxy that wraps HindsightConfig and only allows access to static (non-configurable) fields.
-
-    Raises ConfigFieldAccessError when trying to access configurable fields that vary per-bank.
-    Forces developers to use get_resolved_config(bank_id, context) for bank-specific settings.
-    """
-
-    def __init__(self, config: "HindsightConfig"):
-        object.__setattr__(self, "_config", config)
-        object.__setattr__(self, "_configurable_fields", HindsightConfig.get_configurable_fields())
-
-    def __getattribute__(self, name: str):
-        if name.startswith("_"):
-            return object.__getattribute__(self, name)
-
-        configurable_fields = object.__getattribute__(self, "_configurable_fields")
-        if name in configurable_fields:
-            raise ConfigFieldAccessError(
-                f"Field '{name}' is bank-configurable and cannot be accessed from global config. "
-                f"Use ConfigResolver.resolve_full_config(bank_id, context) to get bank-specific config. "
-                f"This prevents accidentally using global defaults when bank-specific overrides exist."
-            )
-
-        config = object.__getattribute__(self, "_config")
-        return getattr(config, name)
-
-    def __setattr__(self, name: str, value):
-        raise AttributeError("Config is read-only. Modifications must go through ConfigResolver.")
-
-
-# Configuration field markers for hierarchical configuration
-def hierarchical(default_value):
-    """
-    Mark a config field as hierarchical (can be overridden per-tenant/bank).
-
-    Hierarchical fields can be customized at the tenant or bank level via database
-    configuration. Examples: LLM settings, retention parameters, retrieval settings.
-    """
-    return field(default=default_value, metadata={"hierarchical": True})
-
-
-def static(default_value):
-    """
-    Mark a config field as static (server-level only, cannot be overridden).
-
-    Static fields are infrastructure-level settings that affect the entire server
-    and cannot vary per tenant or bank. Examples: database URL, API port, worker settings.
-    """
-    return field(default=default_value, metadata={"hierarchical": False})
-
-
-# Configuration key normalization utilities
-def normalize_config_key(key: str) -> str:
-    """
-    Convert environment variable format to Python field name format.
-
-    Examples:
-        HINDSIGHT_API_LLM_PROVIDER -> llm_provider
-        LLM_MODEL -> llm_model
-        llm_model -> llm_model (already normalized)
-
-    Args:
-        key: Environment variable name or Python field name
-
-    Returns:
-        Normalized Python field name (lowercase snake_case)
-    """
-    if key.startswith("HINDSIGHT_API_"):
-        key = key[len("HINDSIGHT_API_") :]
-    return key.lower()
-
-
-def normalize_config_dict(config: dict[str, Any]) -> dict[str, Any]:
-    """
-    Normalize all keys in a config dict to Python field names.
-
-    Allows users to provide config overrides in either format:
-    - Python field format: {"llm_provider": "openai"}
-    - Env var format: {"HINDSIGHT_API_LLM_PROVIDER": "openai"}
-
-    Args:
-        config: Dict with env var or Python field names as keys
-
-    Returns:
-        Dict with all keys normalized to Python field names
-    """
-    return {normalize_config_key(k): v for k, v in config.items()}
-
-
 # Environment variable names
 ENV_DATABASE_URL = "HINDSIGHT_API_DATABASE_URL"
 ENV_DATABASE_SCHEMA = "HINDSIGHT_API_DATABASE_SCHEMA"
@@ -189,14 +91,6 @@ ENV_RERANKER_LITELLM_API_BASE = "HINDSIGHT_API_RERANKER_LITELLM_API_BASE"
 ENV_RERANKER_LITELLM_API_KEY = "HINDSIGHT_API_RERANKER_LITELLM_API_KEY"
 ENV_RERANKER_LITELLM_MODEL = "HINDSIGHT_API_RERANKER_LITELLM_MODEL"
 
-# LiteLLM SDK configuration (direct API access, no proxy needed)
-ENV_EMBEDDINGS_LITELLM_SDK_API_KEY = "HINDSIGHT_API_EMBEDDINGS_LITELLM_SDK_API_KEY"
-ENV_EMBEDDINGS_LITELLM_SDK_MODEL = "HINDSIGHT_API_EMBEDDINGS_LITELLM_SDK_MODEL"
-ENV_EMBEDDINGS_LITELLM_SDK_API_BASE = "HINDSIGHT_API_EMBEDDINGS_LITELLM_SDK_API_BASE"
-ENV_RERANKER_LITELLM_SDK_API_KEY = "HINDSIGHT_API_RERANKER_LITELLM_SDK_API_KEY"
-ENV_RERANKER_LITELLM_SDK_MODEL = "HINDSIGHT_API_RERANKER_LITELLM_SDK_MODEL"
-ENV_RERANKER_LITELLM_SDK_API_BASE = "HINDSIGHT_API_RERANKER_LITELLM_SDK_API_BASE"
-
 # Deprecated: Legacy shared LiteLLM config (for backward compatibility)
 ENV_LITELLM_API_BASE = "HINDSIGHT_API_LITELLM_API_BASE"
 ENV_LITELLM_API_KEY = "HINDSIGHT_API_LITELLM_API_KEY"
@@ -213,17 +107,12 @@ ENV_RERANKER_MAX_CANDIDATES = "HINDSIGHT_API_RERANKER_MAX_CANDIDATES"
 ENV_RERANKER_FLASHRANK_MODEL = "HINDSIGHT_API_RERANKER_FLASHRANK_MODEL"
 ENV_RERANKER_FLASHRANK_CACHE_DIR = "HINDSIGHT_API_RERANKER_FLASHRANK_CACHE_DIR"
 
-ENV_VECTOR_EXTENSION = "HINDSIGHT_API_VECTOR_EXTENSION"
-ENV_TEXT_SEARCH_EXTENSION = "HINDSIGHT_API_TEXT_SEARCH_EXTENSION"
-
 ENV_HOST = "HINDSIGHT_API_HOST"
 ENV_PORT = "HINDSIGHT_API_PORT"
-ENV_BASE_PATH = "HINDSIGHT_API_BASE_PATH"
 ENV_LOG_LEVEL = "HINDSIGHT_API_LOG_LEVEL"
 ENV_LOG_FORMAT = "HINDSIGHT_API_LOG_FORMAT"
 ENV_WORKERS = "HINDSIGHT_API_WORKERS"
 ENV_MCP_ENABLED = "HINDSIGHT_API_MCP_ENABLED"
-ENV_ENABLE_BANK_CONFIG_API = "HINDSIGHT_API_ENABLE_BANK_CONFIG_API"
 ENV_GRAPH_RETRIEVER = "HINDSIGHT_API_GRAPH_RETRIEVER"
 ENV_MPFP_TOP_K_NEIGHBORS = "HINDSIGHT_API_MPFP_TOP_K_NEIGHBORS"
 ENV_RECALL_MAX_CONCURRENT = "HINDSIGHT_API_RECALL_MAX_CONCURRENT"
@@ -250,7 +139,6 @@ ENV_RETAIN_CHUNK_SIZE = "HINDSIGHT_API_RETAIN_CHUNK_SIZE"
 ENV_RETAIN_EXTRACT_CAUSAL_LINKS = "HINDSIGHT_API_RETAIN_EXTRACT_CAUSAL_LINKS"
 ENV_RETAIN_EXTRACTION_MODE = "HINDSIGHT_API_RETAIN_EXTRACTION_MODE"
 ENV_RETAIN_CUSTOM_INSTRUCTIONS = "HINDSIGHT_API_RETAIN_CUSTOM_INSTRUCTIONS"
-ENV_RETAIN_BATCH_TOKENS = "HINDSIGHT_API_RETAIN_BATCH_TOKENS"
 
 # Observations settings (consolidated knowledge from facts)
 ENV_ENABLE_OBSERVATIONS = "HINDSIGHT_API_ENABLE_OBSERVATIONS"
@@ -335,29 +223,17 @@ DEFAULT_RERANKER_FLASHRANK_CACHE_DIR = None  # Use default cache directory
 DEFAULT_EMBEDDINGS_COHERE_MODEL = "embed-english-v3.0"
 DEFAULT_RERANKER_COHERE_MODEL = "rerank-english-v3.0"
 
-# Vector extension (pgvector vs vchord)
-DEFAULT_VECTOR_EXTENSION = "pgvector"  # Options: "pgvector", "vchord"
-
-# Text search extension (native PostgreSQL, vchord BM25, or Timescale pg_textsearch)
-DEFAULT_TEXT_SEARCH_EXTENSION = "native"  # Options: "native", "vchord", "pg_textsearch"
-
 # LiteLLM defaults
 DEFAULT_LITELLM_API_BASE = "http://localhost:4000"
 DEFAULT_EMBEDDINGS_LITELLM_MODEL = "text-embedding-3-small"
 DEFAULT_RERANKER_LITELLM_MODEL = "cohere/rerank-english-v3.0"
 
-# LiteLLM SDK defaults
-DEFAULT_EMBEDDINGS_LITELLM_SDK_MODEL = "cohere/embed-english-v3.0"
-DEFAULT_RERANKER_LITELLM_SDK_MODEL = "cohere/rerank-english-v3.0"
-
 DEFAULT_HOST = "0.0.0.0"
 DEFAULT_PORT = 8888
-DEFAULT_BASE_PATH = ""  # Empty string = root path
 DEFAULT_LOG_LEVEL = "info"
 DEFAULT_LOG_FORMAT = "text"  # Options: "text", "json"
 DEFAULT_WORKERS = 1
 DEFAULT_MCP_ENABLED = True
-DEFAULT_ENABLE_BANK_CONFIG_API = False  # Disabled by default for security
 DEFAULT_GRAPH_RETRIEVER = "link_expansion"  # Options: "link_expansion", "mpfp", "bfs"
 DEFAULT_MPFP_TOP_K_NEIGHBORS = 20  # Fan-out limit per node in MPFP graph traversal
 DEFAULT_RECALL_MAX_CONCURRENT = 32  # Max concurrent recall operations per worker
@@ -372,7 +248,6 @@ DEFAULT_RETAIN_EXTRACT_CAUSAL_LINKS = True  # Extract causal links between facts
 DEFAULT_RETAIN_EXTRACTION_MODE = "concise"  # Extraction mode: "concise", "verbose", or "custom"
 RETAIN_EXTRACTION_MODES = ("concise", "verbose", "custom")  # Allowed extraction modes
 DEFAULT_RETAIN_CUSTOM_INSTRUCTIONS = None  # Custom extraction guidelines (only used when mode="custom")
-DEFAULT_RETAIN_BATCH_TOKENS = 10_000  # ~40KB of text  # Max chars per sub-batch for async retain auto-splitting
 
 # Observations defaults (consolidated knowledge from facts)
 DEFAULT_ENABLE_OBSERVATIONS = True  # Observations enabled by default
@@ -483,8 +358,6 @@ class HindsightConfig:
     # Database
     database_url: str
     database_schema: str
-    vector_extension: str  # "pgvector" or "vchord"
-    text_search_extension: str  # "native" or "vchord"
 
     # LLM (default, used as fallback for per-operation config)
     llm_provider: str
@@ -546,9 +419,6 @@ class HindsightConfig:
     embeddings_litellm_api_base: str
     embeddings_litellm_api_key: str | None
     embeddings_litellm_model: str
-    embeddings_litellm_sdk_api_key: str | None
-    embeddings_litellm_sdk_model: str
-    embeddings_litellm_sdk_api_base: str | None
 
     # Reranker
     reranker_provider: str
@@ -566,18 +436,13 @@ class HindsightConfig:
     reranker_litellm_api_base: str
     reranker_litellm_api_key: str | None
     reranker_litellm_model: str
-    reranker_litellm_sdk_api_key: str | None
-    reranker_litellm_sdk_model: str
-    reranker_litellm_sdk_api_base: str | None
 
     # Server
     host: str
     port: int
-    base_path: str
     log_level: str
     log_format: str
     mcp_enabled: bool
-    enable_bank_config_api: bool
 
     # Recall
     graph_retriever: str
@@ -592,7 +457,6 @@ class HindsightConfig:
     retain_extract_causal_links: bool
     retain_extraction_mode: str
     retain_custom_instructions: str | None
-    retain_batch_tokens: int
 
     # Observations settings (consolidated knowledge from facts)
     enable_observations: bool
@@ -631,108 +495,8 @@ class HindsightConfig:
     otel_service_name: str
     otel_deployment_environment: str
 
-    # Class-level sets for configuration categorization
-
-    # CREDENTIAL_FIELDS: Never exposed via API, never configurable per-tenant/bank
-    _CREDENTIAL_FIELDS = {
-        # API Keys
-        "llm_api_key",
-        "retain_llm_api_key",
-        "reflect_llm_api_key",
-        "consolidation_llm_api_key",
-        # Base URLs (could expose infrastructure)
-        "llm_base_url",
-        "retain_llm_base_url",
-        "reflect_llm_base_url",
-        "consolidation_llm_base_url",
-        "embeddings_tei_base_url",
-        "reranker_tei_base_url",
-        "reranker_cohere_base_url",
-        # Service Account Keys
-        "llm_vertexai_service_account_key",
-    }
-
-    # CONFIGURABLE_FIELDS: Safe behavioral settings that can be customized per-tenant/bank
-    # These fields are manually tagged as safe to expose and modify.
-    # Excludes credentials, infrastructure config, provider/model selection, and performance tuning.
-    _CONFIGURABLE_FIELDS = {
-        # Retention settings (behavioral)
-        "retain_chunk_size",
-        "retain_extraction_mode",
-        "retain_custom_instructions",
-        # Consolidation settings
-        "enable_observations",
-    }
-
-    @classmethod
-    def get_configurable_fields(cls) -> set[str]:
-        """
-        Get set of field names that are configurable per-tenant/bank via API.
-
-        Configurable fields are manually tagged behavioral settings that are safe
-        to expose and modify (e.g., retain_chunk_size, custom_instructions).
-        Excludes credentials, infrastructure config, and provider/model selection.
-
-        Returns:
-            Set of configurable field names
-        """
-        return cls._CONFIGURABLE_FIELDS.copy()
-
-    @classmethod
-    def get_credential_fields(cls) -> set[str]:
-        """
-        Get set of field names that are credentials (NEVER exposed via API).
-
-        Credential fields include API keys, base URLs, and service account keys.
-        These must never be returned in API responses or accepted in updates.
-
-        Returns:
-            Set of credential field names
-        """
-        return cls._CREDENTIAL_FIELDS.copy()
-
-    @classmethod
-    def get_hierarchical_fields(cls) -> set[str]:
-        """
-        DEPRECATED: Use get_configurable_fields() instead.
-
-        Kept for backward compatibility during migration.
-        """
-        return cls.get_configurable_fields()
-
-    @classmethod
-    def get_static_fields(cls) -> set[str]:
-        """
-        Get set of field names that are static (server-level only).
-
-        Static fields are infrastructure-level settings that cannot vary
-        per tenant or bank. These include database config, API port, worker settings, etc.
-        Also includes credential fields which are never configurable.
-
-        Returns:
-            Set of static field names
-        """
-        # Get all field names from dataclass
-        all_fields = {f.name for f in fields(cls)}
-        # Static fields = all fields - configurable fields
-        return all_fields - cls._CONFIGURABLE_FIELDS
-
     def validate(self) -> None:
         """Validate configuration values and raise errors for invalid combinations."""
-        # Validate vector_extension
-        valid_extensions = ("pgvector", "vchord")
-        if self.vector_extension not in valid_extensions:
-            raise ValueError(
-                f"Invalid vector_extension: {self.vector_extension}. Must be one of: {', '.join(valid_extensions)}"
-            )
-
-        # Validate text_search_extension
-        valid_text_search = ("native", "vchord", "pg_textsearch")
-        if self.text_search_extension not in valid_text_search:
-            raise ValueError(
-                f"Invalid text_search_extension: {self.text_search_extension}. Must be one of: {', '.join(valid_text_search)}"
-            )
-
         # RETAIN_MAX_COMPLETION_TOKENS must be greater than RETAIN_CHUNK_SIZE
         # to ensure the LLM has enough output capacity to extract facts from chunks
         if self.retain_max_completion_tokens <= self.retain_chunk_size:
@@ -758,8 +522,6 @@ class HindsightConfig:
             # Database
             database_url=os.getenv(ENV_DATABASE_URL, DEFAULT_DATABASE_URL),
             database_schema=os.getenv(ENV_DATABASE_SCHEMA, DEFAULT_DATABASE_SCHEMA),
-            vector_extension=os.getenv(ENV_VECTOR_EXTENSION, DEFAULT_VECTOR_EXTENSION).lower(),
-            text_search_extension=os.getenv(ENV_TEXT_SEARCH_EXTENSION, DEFAULT_TEXT_SEARCH_EXTENSION).lower(),
             # LLM
             llm_provider=llm_provider,
             llm_api_key=os.getenv(ENV_LLM_API_KEY),
@@ -868,12 +630,6 @@ class HindsightConfig:
             or os.getenv(ENV_LITELLM_API_BASE, DEFAULT_LITELLM_API_BASE),
             embeddings_litellm_api_key=os.getenv(ENV_EMBEDDINGS_LITELLM_API_KEY) or os.getenv(ENV_LITELLM_API_KEY),
             embeddings_litellm_model=os.getenv(ENV_EMBEDDINGS_LITELLM_MODEL, DEFAULT_EMBEDDINGS_LITELLM_MODEL),
-            # LiteLLM SDK embeddings (direct API access)
-            embeddings_litellm_sdk_api_key=os.getenv(ENV_EMBEDDINGS_LITELLM_SDK_API_KEY),
-            embeddings_litellm_sdk_model=os.getenv(
-                ENV_EMBEDDINGS_LITELLM_SDK_MODEL, DEFAULT_EMBEDDINGS_LITELLM_SDK_MODEL
-            ),
-            embeddings_litellm_sdk_api_base=os.getenv(ENV_EMBEDDINGS_LITELLM_SDK_API_BASE) or None,
             # Reranker
             reranker_provider=os.getenv(ENV_RERANKER_PROVIDER, DEFAULT_RERANKER_PROVIDER),
             reranker_local_model=os.getenv(ENV_RERANKER_LOCAL_MODEL, DEFAULT_RERANKER_LOCAL_MODEL),
@@ -903,19 +659,12 @@ class HindsightConfig:
             or os.getenv(ENV_LITELLM_API_BASE, DEFAULT_LITELLM_API_BASE),
             reranker_litellm_api_key=os.getenv(ENV_RERANKER_LITELLM_API_KEY) or os.getenv(ENV_LITELLM_API_KEY),
             reranker_litellm_model=os.getenv(ENV_RERANKER_LITELLM_MODEL, DEFAULT_RERANKER_LITELLM_MODEL),
-            # LiteLLM SDK reranker (direct API access)
-            reranker_litellm_sdk_api_key=os.getenv(ENV_RERANKER_LITELLM_SDK_API_KEY),
-            reranker_litellm_sdk_model=os.getenv(ENV_RERANKER_LITELLM_SDK_MODEL, DEFAULT_RERANKER_LITELLM_SDK_MODEL),
-            reranker_litellm_sdk_api_base=os.getenv(ENV_RERANKER_LITELLM_SDK_API_BASE) or None,
             # Server
             host=os.getenv(ENV_HOST, DEFAULT_HOST),
             port=int(os.getenv(ENV_PORT, DEFAULT_PORT)),
-            base_path=os.getenv(ENV_BASE_PATH, DEFAULT_BASE_PATH),
             log_level=os.getenv(ENV_LOG_LEVEL, DEFAULT_LOG_LEVEL),
             log_format=os.getenv(ENV_LOG_FORMAT, DEFAULT_LOG_FORMAT).lower(),
             mcp_enabled=os.getenv(ENV_MCP_ENABLED, str(DEFAULT_MCP_ENABLED)).lower() == "true",
-            enable_bank_config_api=os.getenv(ENV_ENABLE_BANK_CONFIG_API, str(DEFAULT_ENABLE_BANK_CONFIG_API)).lower()
-            == "true",
             # Recall
             graph_retriever=os.getenv(ENV_GRAPH_RETRIEVER, DEFAULT_GRAPH_RETRIEVER),
             mpfp_top_k_neighbors=int(os.getenv(ENV_MPFP_TOP_K_NEIGHBORS, str(DEFAULT_MPFP_TOP_K_NEIGHBORS))),
@@ -942,7 +691,6 @@ class HindsightConfig:
                 os.getenv(ENV_RETAIN_EXTRACTION_MODE, DEFAULT_RETAIN_EXTRACTION_MODE)
             ),
             retain_custom_instructions=os.getenv(ENV_RETAIN_CUSTOM_INSTRUCTIONS) or DEFAULT_RETAIN_CUSTOM_INSTRUCTIONS,
-            retain_batch_tokens=int(os.getenv(ENV_RETAIN_BATCH_TOKENS, str(DEFAULT_RETAIN_BATCH_TOKENS))),
             # Observations settings (consolidated knowledge from facts)
             enable_observations=os.getenv(ENV_ENABLE_OBSERVATIONS, str(DEFAULT_ENABLE_OBSERVATIONS)).lower() == "true",
             consolidation_batch_size=int(
@@ -1057,35 +805,8 @@ class HindsightConfig:
 _config_cache: HindsightConfig | None = None
 
 
-def get_config() -> StaticConfigProxy:
-    """
-    Get global configuration with ONLY static (non-configurable) fields accessible.
-
-    This returns a proxy that prevents access to bank-configurable fields
-    (like enable_observations, retain_chunk_size, etc.).
-
-    For bank-specific configuration, use:
-        config_resolver.resolve_full_config(bank_id, context)
-
-    This design prevents accidentally using global defaults when bank-specific
-    overrides exist.
-
-    Returns:
-        StaticConfigProxy that only exposes static infrastructure fields
-
-    Raises:
-        ConfigFieldAccessError: If you try to access a bank-configurable field
-    """
-    return StaticConfigProxy(_get_raw_config())
-
-
-def _get_raw_config() -> HindsightConfig:
-    """
-    Get raw config (internal use only).
-
-    INTERNAL USE ONLY. Do not use this directly in application code.
-    Use get_config() for static fields or ConfigResolver.resolve_full_config() for bank-specific config.
-    """
+def get_config() -> HindsightConfig:
+    """Get the cached configuration, loading from environment on first call."""
     global _config_cache
     if _config_cache is None:
         _config_cache = HindsightConfig.from_env()

hindsight-api/hindsight_api/config_resolver.py

@@ -1,274 +0,0 @@
-"""
-Configuration resolution with hierarchical overrides.
-
-Resolves config values through the hierarchy:
-  Global (env vars) → Tenant config (via extension) → Bank config (database)
-
-Config values are resolved on every request to ensure consistency across
-multiple API servers.
-"""
-
-import json
-import logging
-from dataclasses import asdict
-from typing import Any
-
-import asyncpg
-
-from hindsight_api.config import HindsightConfig, _get_raw_config, normalize_config_dict
-from hindsight_api.extensions.tenant import TenantExtension
-from hindsight_api.models import RequestContext
-
-logger = logging.getLogger(__name__)
-
-
-class ConfigResolver:
-    """Resolves hierarchical configuration with tenant/bank overrides."""
-
-    def __init__(self, pool: asyncpg.Pool, tenant_extension: TenantExtension | None = None):
-        """
-        Initialize config resolver.
-
-        Args:
-            pool: Database connection pool
-            tenant_extension: Optional tenant extension for tenant-level config and permissions
-        """
-        self.pool = pool
-        self.tenant_extension = tenant_extension
-        self._global_config = _get_raw_config()
-        self._configurable_fields = HindsightConfig.get_configurable_fields()
-        self._credential_fields = HindsightConfig.get_credential_fields()
-
-    async def resolve_full_config(self, bank_id: str, context: RequestContext | None = None) -> HindsightConfig:
-        """
-        Resolve full HindsightConfig for a bank with hierarchical overrides applied.
-
-        This is for INTERNAL USE ONLY. Returns the complete config object with all fields
-        including credentials and static fields. Use get_bank_config() for API responses.
-
-        Resolution order:
-        1. Global config (from environment variables)
-        2. Tenant config overrides (from TenantExtension.get_tenant_config())
-        3. Bank config overrides (from banks.config JSONB)
-
-        Args:
-            bank_id: Bank identifier
-            context: Request context for tenant config resolution
-
-        Returns:
-            Complete HindsightConfig with hierarchical overrides applied
-        """
-        # Start with global config (all fields)
-        config_dict = asdict(self._global_config)
-
-        # Load tenant config overrides (if tenant extension available)
-        if self.tenant_extension and context:
-            try:
-                tenant_overrides = await self.tenant_extension.get_tenant_config(context)
-                if tenant_overrides:
-                    # Normalize keys and filter to configurable fields only
-                    normalized_tenant = normalize_config_dict(tenant_overrides)
-                    configurable_tenant = {k: v for k, v in normalized_tenant.items() if k in self._configurable_fields}
-                    config_dict.update(configurable_tenant)
-                    logger.debug(
-                        f"Applied tenant config overrides for bank {bank_id}: {list(configurable_tenant.keys())}"
-                    )
-            except Exception as e:
-                logger.warning(f"Failed to load tenant config for bank {bank_id}: {e}")
-
-        # Load bank config overrides
-        bank_overrides = await self._load_bank_config(bank_id)
-        if bank_overrides:
-            config_dict.update(bank_overrides)
-            logger.debug(f"Applied bank config overrides for bank {bank_id}: {list(bank_overrides.keys())}")
-
-        # Return full config object (dataclass doesn't have __init__ that accepts kwargs, so we update the object)
-        # Create a new config instance by copying the global config and updating fields
-        resolved_config = HindsightConfig(**config_dict)
-        return resolved_config
-
-    async def get_bank_config(self, bank_id: str, context: RequestContext | None = None) -> dict[str, Any]:
-        """
-        Get fully resolved config for a bank (filtered by permissions).
-
-        Resolution order:
-        1. Global config (from environment variables)
-        2. Tenant config overrides (from TenantExtension.get_tenant_config())
-        3. Bank config overrides (from banks.config JSONB)
-
-        Note: Config is resolved on every call (not cached) to ensure consistency
-        across multiple API servers.
-
-        SECURITY:
-        - Only returns configurable fields (excludes static/infrastructure fields)
-        - Filters out ALL credential fields (API keys, base URLs, etc.)
-        - Further filtered by tenant/bank permissions if extension provides them
-
-        Args:
-            bank_id: Bank identifier
-            context: Request context for tenant config resolution and permissions
-
-        Returns:
-            Dict of allowed configurable fields only (never includes credentials or static fields)
-        """
-        # Resolve full config with all hierarchical overrides
-        resolved_config = await self.resolve_full_config(bank_id, context)
-        config_dict = asdict(resolved_config)
-
-        # SECURITY: Filter to only configurable fields (exclude static/infrastructure)
-        filtered = {k: v for k, v in config_dict.items() if k in self._configurable_fields}
-
-        # SECURITY: Remove ALL credential fields (API keys, base URLs, etc.)
-        filtered = {k: v for k, v in filtered.items() if k not in self._credential_fields}
-
-        # PERMISSIONS: Further filter based on tenant/bank permissions
-        if self.tenant_extension and context:
-            try:
-                allowed_fields = await self.tenant_extension.get_allowed_config_fields(context, bank_id)
-                if allowed_fields is not None:  # None means "allow all"
-                    filtered = {k: v for k, v in filtered.items() if k in allowed_fields}
-                    logger.debug(
-                        f"Applied permission filter for bank {bank_id}: allowed={len(allowed_fields)} fields, "
-                        f"returned={len(filtered)} fields"
-                    )
-            except Exception as e:
-                logger.warning(f"Failed to load permissions for bank {bank_id}: {e}")
-
-        return filtered
-
-    async def _load_bank_config(self, bank_id: str) -> dict[str, Any]:
-        """
-        Load bank config overrides from banks.config JSONB column.
-
-        Args:
-            bank_id: Bank identifier
-
-        Returns:
-            Dict of config overrides (only configurable fields, normalized keys)
-        """
-        try:
-            async with self.pool.acquire() as conn:
-                row = await conn.fetchrow(
-                    """
-                    SELECT config FROM banks WHERE bank_id = $1
-                    """,
-                    bank_id,
-                )
-
-                if row and row["config"]:
-                    config_data = row["config"]
-
-                    # Handle case where JSONB is returned as JSON string
-                    if isinstance(config_data, str):
-                        config_data = json.loads(config_data)
-
-                    # Normalize keys (handle both env var format and Python field format)
-                    normalized = normalize_config_dict(config_data)
-
-                    # Only return overrides for configurable fields
-                    return {k: v for k, v in normalized.items() if k in self._configurable_fields}
-        except Exception as e:
-            logger.error(f"Failed to load bank config for {bank_id}: {e}")
-
-        return {}
-
-    async def update_bank_config(
-        self, bank_id: str, updates: dict[str, Any], context: RequestContext | None = None
-    ) -> None:
-        """
-        Update bank configuration overrides (with permission checking).
-
-        Args:
-            bank_id: Bank identifier
-            updates: Dict of config field names to new values.
-                    Keys can be in env var format (HINDSIGHT_API_LLM_PROVIDER)
-                    or Python field format (llm_provider).
-                    Only configurable fields are allowed.
-            context: Request context for permission checking
-
-        Raises:
-            ValueError: If attempting to override invalid/disallowed fields
-        """
-        # Normalize keys
-        normalized_updates = normalize_config_dict(updates)
-
-        # SECURITY: Reject credential fields explicitly
-        credential_attempts = set(normalized_updates.keys()) & self._credential_fields
-        if credential_attempts:
-            raise ValueError(
-                f"Cannot set credential fields via API: {sorted(credential_attempts)}. "
-                f"Credentials (API keys, base URLs) must be set at server level only."
-            )
-
-        # Validate all fields are configurable
-        invalid_fields = set(normalized_updates.keys()) - self._configurable_fields
-        if invalid_fields:
-            static_fields = HindsightConfig.get_static_fields()
-            invalid_static = invalid_fields & static_fields
-            if invalid_static:
-                raise ValueError(
-                    f"Cannot override static (server-level) fields: {sorted(invalid_static)}. "
-                    f"Only configurable fields can be overridden per-bank. "
-                    f"Configurable fields include: {sorted(list(self._configurable_fields)[:10])}... "
-                    f"(total: {len(self._configurable_fields)} fields)"
-                )
-            else:
-                raise ValueError(
-                    f"Unknown configuration fields: {sorted(invalid_fields)}. "
-                    f"Valid configurable fields: {sorted(list(self._configurable_fields)[:10])}..."
-                )
-
-        # PERMISSIONS: Check tenant/bank permissions
-        if self.tenant_extension and context:
-            try:
-                allowed_fields = await self.tenant_extension.get_allowed_config_fields(context, bank_id)
-                if allowed_fields is not None:  # None means "allow all"
-                    disallowed = set(normalized_updates.keys()) - allowed_fields
-                    if disallowed:
-                        raise ValueError(
-                            f"Not allowed to modify fields: {sorted(disallowed)}. "
-                            f"Your permissions allow: {sorted(list(allowed_fields)[:10])}..."
-                            if allowed_fields
-                            else "Not allowed to modify fields: {sorted(disallowed)}. "
-                            "Your permissions do not allow any config modifications."
-                        )
-            except ValueError:
-                raise  # Re-raise permission errors
-            except Exception as e:
-                logger.warning(f"Failed to check permissions for bank {bank_id}: {e}")
-                # Continue without permission check (fail open for backward compatibility)
-
-        # Merge with existing config (JSONB || operator)
-        async with self.pool.acquire() as conn:
-            await conn.execute(
-                """
-                UPDATE banks
-                SET config = config || $1::jsonb,
-                    updated_at = now()
-                WHERE bank_id = $2
-                """,
-                json.dumps(normalized_updates),
-                bank_id,
-            )
-
-        logger.info(f"Updated bank config for {bank_id}: {list(normalized_updates.keys())}")
-
-    async def reset_bank_config(self, bank_id: str) -> None:
-        """
-        Reset bank configuration to defaults (remove all overrides).
-
-        Args:
-            bank_id: Bank identifier
-        """
-        async with self.pool.acquire() as conn:
-            await conn.execute(
-                """
-                UPDATE banks
-                SET config = '{}'::jsonb,
-                    updated_at = now()
-                WHERE bank_id = $1
-                """,
-                bank_id,
-            )
-
-        logger.info(f"Reset bank config for {bank_id} to defaults")

hindsight-api/hindsight_api/engine/consolidation/consolidator.py

@@ -18,7 +18,6 @@ import uuid
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
-from ...config import get_config
 from ..memory_engine import fq_table
 from ..retain import embedding_utils
 from .prompts import (
@@ -83,8 +82,9 @@ async def run_consolidation_job(
     Returns:
         Dict with consolidation results
     """
-    # Resolve bank-specific config with hierarchical overrides
-    config = await memory_engine._config_resolver.resolve_full_config(bank_id, request_context)
+    from ...config import get_config
+
+    config = get_config()
     perf = ConsolidationPerfLog(bank_id)
     max_memories_per_batch = config.consolidation_batch_size
 
@@ -1016,34 +1016,15 @@ async def _create_observation_directly(
 
     t0 = time.time()
     observation_id = uuid.uuid4()
-
-    # Query varies based on text search backend
-    config = get_config()
-    if config.text_search_extension == "vchord":
-        # VectorChord: manually tokenize and insert search_vector
-        query = f"""
-            INSERT INTO {fq_table("memory_units")} (
-                id, bank_id, text, fact_type, embedding, proof_count, source_memory_ids, history,
-                tags, event_date, occurred_start, occurred_end, mentioned_at, search_vector
-            )
-            VALUES ($1, $2, $3, 'observation', $4::vector, 1, $5, '[]'::jsonb, $6, $7, $8, $9, $10,
-                    tokenize($3, 'llmlingua2')::bm25_catalog.bm25vector)
-            RETURNING id
-        """
-    else:  # native or pg_textsearch
-        # Native PostgreSQL: search_vector is GENERATED ALWAYS, don't include it
-        # pg_textsearch: indexes operate on base columns directly, don't populate search_vector
-        query = f"""
-            INSERT INTO {fq_table("memory_units")} (
-                id, bank_id, text, fact_type, embedding, proof_count, source_memory_ids, history,
-                tags, event_date, occurred_start, occurred_end, mentioned_at
-            )
-            VALUES ($1, $2, $3, 'observation', $4::vector, 1, $5, '[]'::jsonb, $6, $7, $8, $9, $10)
-            RETURNING id
-        """
-
     row = await conn.fetchrow(
-        query,
+        f"""
+        INSERT INTO {fq_table("memory_units")} (
+            id, bank_id, text, fact_type, embedding, proof_count, source_memory_ids, history,
+            tags, event_date, occurred_start, occurred_end, mentioned_at
+        )
+        VALUES ($1, $2, $3, 'observation', $4::vector, 1, $5, '[]'::jsonb, $6, $7, $8, $9, $10)
+        RETURNING id
+        """,
         observation_id,
         bank_id,
         observation_text,

hindsight-api/hindsight_api/engine/cross_encoder.py

@@ -21,7 +21,6 @@ from ..config import (
     DEFAULT_RERANKER_FLASHRANK_CACHE_DIR,
     DEFAULT_RERANKER_FLASHRANK_MODEL,
     DEFAULT_RERANKER_LITELLM_MODEL,
-    DEFAULT_RERANKER_LITELLM_SDK_MODEL,
     DEFAULT_RERANKER_LOCAL_FORCE_CPU,
     DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT,
     DEFAULT_RERANKER_LOCAL_MODEL,
@@ -33,7 +32,6 @@ from ..config import (
     ENV_RERANKER_COHERE_MODEL,
     ENV_RERANKER_FLASHRANK_CACHE_DIR,
     ENV_RERANKER_FLASHRANK_MODEL,
-    ENV_RERANKER_LITELLM_SDK_API_KEY,
     ENV_RERANKER_LOCAL_FORCE_CPU,
     ENV_RERANKER_LOCAL_MAX_CONCURRENT,
     ENV_RERANKER_LOCAL_MODEL,
@@ -830,126 +828,6 @@ class LiteLLMCrossEncoder(CrossEncoderModel):
         return all_scores
 
 
-class LiteLLMSDKCrossEncoder(CrossEncoderModel):
-    """
-    LiteLLM SDK cross-encoder for direct API integration.
-
-    Supports reranking via LiteLLM SDK without requiring a proxy server.
-    Supported providers: Cohere, DeepInfra, Together AI, HuggingFace, Jina AI, Voyage AI, AWS Bedrock.
-
-    Example model names:
-    - cohere/rerank-english-v3.0
-    - deepinfra/Qwen3-reranker-8B
-    - together_ai/Salesforce/Llama-Rank-V1
-    - huggingface/BAAI/bge-reranker-v2-m3
-    """
-
-    def __init__(
-        self,
-        api_key: str,
-        model: str = DEFAULT_RERANKER_LITELLM_SDK_MODEL,
-        api_base: str | None = None,
-        timeout: float = 60.0,
-    ):
-        """
-        Initialize LiteLLM SDK cross-encoder client.
-
-        Args:
-            api_key: API key for the reranking provider
-            model: Model name with provider prefix (e.g., "deepinfra/Qwen3-reranker-8B")
-            api_base: Custom base URL for API (optional)
-            timeout: Request timeout in seconds (default: 60.0)
-        """
-        self.api_key = api_key
-        self.model = model
-        self.api_base = api_base
-        self.timeout = timeout
-        self._initialized = False
-        self._litellm = None  # Will be set during initialization
-
-    @property
-    def provider_name(self) -> str:
-        return "litellm-sdk"
-
-    async def initialize(self) -> None:
-        """Initialize the LiteLLM SDK client."""
-        if self._initialized:
-            return
-
-        try:
-            import litellm
-
-            self._litellm = litellm  # Store reference
-        except ImportError:
-            raise ImportError("litellm is required for LiteLLMSDKCrossEncoder. Install it with: pip install litellm")
-
-        api_base_msg = f" at {self.api_base}" if self.api_base else ""
-        logger.info(f"Reranker: initializing LiteLLM SDK provider with model {self.model}{api_base_msg}")
-
-        self._initialized = True
-        logger.info("Reranker: LiteLLM SDK provider initialized")
-
-    async def predict(self, pairs: list[tuple[str, str]]) -> list[float]:
-        """
-        Score query-document pairs using the LiteLLM SDK.
-
-        Args:
-            pairs: List of (query, document) tuples to score
-
-        Returns:
-            List of relevance scores
-        """
-        if not self._initialized:
-            raise RuntimeError("Reranker not initialized. Call initialize() first.")
-
-        if not pairs:
-            return []
-
-        # Group pairs by query for efficient batching
-        # LiteLLM rerank expects one query with multiple documents
-        query_groups: dict[str, list[tuple[int, str]]] = {}
-        for idx, (query, text) in enumerate(pairs):
-            if query not in query_groups:
-                query_groups[query] = []
-            query_groups[query].append((idx, text))
-
-        all_scores = [0.0] * len(pairs)
-
-        for query, indexed_texts in query_groups.items():
-            texts = [text for _, text in indexed_texts]
-            indices = [idx for idx, _ in indexed_texts]
-
-            # Build kwargs for rerank call
-            rerank_kwargs = {
-                "model": self.model,
-                "query": query,
-                "documents": texts,
-                "api_key": self.api_key,
-            }
-            if self.api_base:
-                rerank_kwargs["api_base"] = self.api_base
-
-            response = await self._litellm.arerank(**rerank_kwargs)
-
-            # Map scores back to original positions
-            # Response format: RerankResponse with results list
-            # Each result is a TypedDict with "index" and "relevance_score"
-            if hasattr(response, "results") and response.results:
-                for result in response.results:
-                    # Results are TypedDicts, use dict-style access
-                    original_idx = result["index"]
-                    score = result.get("relevance_score", result.get("score", 0.0))
-                    all_scores[indices[original_idx]] = score
-            elif isinstance(response, list):
-                # Direct list of scores (unlikely but defensive)
-                for i, score in enumerate(response):
-                    all_scores[indices[i]] = score
-            else:
-                logger.warning(f"Unexpected response format from LiteLLM rerank: {type(response)}")
-
-        return all_scores
-
-
 def create_cross_encoder_from_env() -> CrossEncoderModel:
     """
     Create a CrossEncoderModel instance based on configuration.
@@ -999,20 +877,9 @@ def create_cross_encoder_from_env() -> CrossEncoderModel:
             api_key=config.reranker_litellm_api_key,
             model=config.reranker_litellm_model,
         )
-    elif provider == "litellm-sdk":
-        api_key = config.reranker_litellm_sdk_api_key
-        if not api_key:
-            raise ValueError(
-                f"{ENV_RERANKER_LITELLM_SDK_API_KEY} is required when {ENV_RERANKER_PROVIDER} is 'litellm-sdk'"
-            )
-        return LiteLLMSDKCrossEncoder(
-            api_key=api_key,
-            model=config.reranker_litellm_sdk_model,
-            api_base=config.reranker_litellm_sdk_api_base,
-        )
     elif provider == "rrf":
         return RRFPassthroughCrossEncoder()
     else:
         raise ValueError(
-            f"Unknown reranker provider: {provider}. Supported: 'local', 'tei', 'cohere', 'flashrank', 'litellm', 'litellm-sdk', 'rrf'"
+            f"Unknown reranker provider: {provider}. Supported: 'local', 'tei', 'cohere', 'flashrank', 'litellm', 'rrf'"
         )

hindsight-api/hindsight_api/engine/embeddings.py

@@ -19,7 +19,6 @@ import httpx
 from ..config import (
     DEFAULT_EMBEDDINGS_COHERE_MODEL,
     DEFAULT_EMBEDDINGS_LITELLM_MODEL,
-    DEFAULT_EMBEDDINGS_LITELLM_SDK_MODEL,
     DEFAULT_EMBEDDINGS_LOCAL_FORCE_CPU,
     DEFAULT_EMBEDDINGS_LOCAL_MODEL,
     DEFAULT_EMBEDDINGS_LOCAL_TRUST_REMOTE_CODE,
@@ -27,7 +26,6 @@ from ..config import (
     DEFAULT_EMBEDDINGS_PROVIDER,
     DEFAULT_LITELLM_API_BASE,
     ENV_EMBEDDINGS_COHERE_API_KEY,
-    ENV_EMBEDDINGS_LITELLM_SDK_API_KEY,
     ENV_EMBEDDINGS_LOCAL_FORCE_CPU,
     ENV_EMBEDDINGS_LOCAL_MODEL,
     ENV_EMBEDDINGS_LOCAL_TRUST_REMOTE_CODE,
@@ -722,148 +720,6 @@ class LiteLLMEmbeddings(Embeddings):
         return all_embeddings
 
 
-class LiteLLMSDKEmbeddings(Embeddings):
-    """
-    LiteLLM SDK embeddings for direct API integration.
-
-    Supports embeddings via LiteLLM SDK without requiring a proxy server.
-    Supported providers: Cohere, OpenAI, Azure OpenAI, HuggingFace, Voyage AI, Together AI, etc.
-
-    Example model names:
-    - cohere/embed-english-v3.0
-    - openai/text-embedding-3-small
-    - together_ai/togethercomputer/m2-bert-80M-8k-retrieval
-    - voyage/voyage-2
-    """
-
-    def __init__(
-        self,
-        api_key: str,
-        model: str = DEFAULT_EMBEDDINGS_LITELLM_SDK_MODEL,
-        api_base: str | None = None,
-        batch_size: int = 100,
-        timeout: float = 60.0,
-    ):
-        """
-        Initialize LiteLLM SDK embeddings client.
-
-        Args:
-            api_key: API key for the embedding provider
-            model: Model name with provider prefix (e.g., "cohere/embed-english-v3.0")
-            api_base: Custom base URL for API (optional)
-            batch_size: Maximum batch size for embedding requests (default: 100)
-            timeout: Request timeout in seconds (default: 60.0)
-        """
-        self.api_key = api_key
-        self.model = model
-        self.api_base = api_base
-        self.batch_size = batch_size
-        self.timeout = timeout
-        self._litellm = None  # Will be set during initialization
-        self._dimension: int | None = None
-
-    @property
-    def provider_name(self) -> str:
-        return "litellm-sdk"
-
-    @property
-    def dimension(self) -> int:
-        if self._dimension is None:
-            raise RuntimeError("Embeddings not initialized. Call initialize() first.")
-        return self._dimension
-
-    async def initialize(self) -> None:
-        """Initialize the LiteLLM SDK client and detect dimension."""
-        if self._litellm is not None:
-            return
-
-        try:
-            import litellm
-
-            self._litellm = litellm  # Store reference
-        except ImportError:
-            raise ImportError("litellm is required for LiteLLMSDKEmbeddings. Install it with: pip install litellm")
-
-        api_base_msg = f" at {self.api_base}" if self.api_base else ""
-        logger.info(f"Embeddings: initializing LiteLLM SDK provider with model {self.model}{api_base_msg}")
-
-        # Do a test embedding to detect dimension
-        try:
-            # Build kwargs for embedding call
-            embed_kwargs = {
-                "model": self.model,
-                "input": ["test"],
-                "api_key": self.api_key,
-            }
-            if self.api_base:
-                embed_kwargs["api_base"] = self.api_base
-
-            # Use async embedding method (standard in litellm)
-            response = await self._litellm.aembedding(**embed_kwargs)
-
-            # Extract dimension from response
-            if response.data and len(response.data) > 0:
-                self._dimension = len(response.data[0]["embedding"])
-            else:
-                raise RuntimeError(f"Unable to detect embedding dimension for model {self.model}")
-
-        except Exception as e:
-            raise RuntimeError(f"Failed to initialize LiteLLM SDK embeddings: {e}")
-
-        logger.info(f"Embeddings: LiteLLM SDK provider initialized (model: {self.model}, dim: {self._dimension})")
-
-    def encode(self, texts: list[str]) -> list[list[float]]:
-        """
-        Generate embeddings using the LiteLLM SDK.
-
-        Args:
-            texts: List of text strings to encode
-
-        Returns:
-            List of embedding vectors (one per input text)
-        """
-        if self._litellm is None:
-            raise RuntimeError("Embeddings not initialized. Call initialize() first.")
-
-        if not texts:
-            return []
-
-        all_embeddings = []
-
-        # Process in batches
-        for i in range(0, len(texts), self.batch_size):
-            batch = texts[i : i + self.batch_size]
-
-            try:
-                # Build kwargs for embedding call
-                embed_kwargs = {
-                    "model": self.model,
-                    "input": batch,
-                    "api_key": self.api_key,
-                }
-                if self.api_base:
-                    embed_kwargs["api_base"] = self.api_base
-
-                # Use sync embedding (litellm doesn't have async in thread-safe way)
-                response = self._litellm.embedding(**embed_kwargs)
-
-                # Extract embeddings from response
-                # Sort by index to ensure correct order
-                batch_embeddings = sorted(response.data, key=lambda x: x.get("index", 0))
-                all_embeddings.extend([e["embedding"] for e in batch_embeddings])
-
-            except Exception as e:
-                import traceback
-
-                logger.error(
-                    f"Error in LiteLLM embedding for batch starting at index {i}: {e}\n"
-                    f"Traceback: {traceback.format_exc()}"
-                )
-                raise
-
-        return all_embeddings
-
-
 def create_embeddings_from_env() -> Embeddings:
     """
     Create an Embeddings instance based on configuration.
@@ -915,19 +771,7 @@ def create_embeddings_from_env() -> Embeddings:
             api_key=config.embeddings_litellm_api_key,
             model=config.embeddings_litellm_model,
         )
-    elif provider == "litellm-sdk":
-        api_key = config.embeddings_litellm_sdk_api_key
-        if not api_key:
-            raise ValueError(
-                f"{ENV_EMBEDDINGS_LITELLM_SDK_API_KEY} is required when {ENV_EMBEDDINGS_PROVIDER} is 'litellm-sdk'"
-            )
-        return LiteLLMSDKEmbeddings(
-            api_key=api_key,
-            model=config.embeddings_litellm_sdk_model,
-            api_base=config.embeddings_litellm_sdk_api_base,
-        )
     else:
         raise ValueError(
-            f"Unknown embeddings provider: {provider}. "
-            f"Supported: 'local', 'tei', 'openai', 'cohere', 'litellm', 'litellm-sdk'"
+            f"Unknown embeddings provider: {provider}. Supported: 'local', 'tei', 'openai', 'cohere', 'litellm'"
         )

hindsight-api/hindsight_api/engine/interface.py

@@ -48,7 +48,6 @@ class MemoryEngineInterface(ABC):
         contents: list[dict[str, Any]],
         *,
         request_context: "RequestContext",
-        document_tags: list[str] | None = None,
     ) -> dict[str, Any]:
         """
         Retain a batch of memory items.
@@ -56,9 +55,8 @@ class MemoryEngineInterface(ABC):
         Args:
             bank_id: The memory bank ID.
             contents: List of content dicts with 'content', optional 'event_date',
-                     'context', 'metadata', 'document_id', and per-item 'tags'.
+                     'context', 'metadata', 'document_id'.
             request_context: Request context for authentication.
-            document_tags: Optional tags applied to all items in the batch.
 
         Returns:
             Dict with processing results.
@@ -563,7 +561,6 @@ class MemoryEngineInterface(ABC):
         contents: list[dict[str, Any]],
         *,
         request_context: "RequestContext",
-        document_tags: list[str] | None = None,
     ) -> dict[str, Any]:
         """
         Submit a batch retain operation to run asynchronously.
@@ -572,7 +569,6 @@ class MemoryEngineInterface(ABC):
             bank_id: The memory bank ID.
             contents: List of content dicts to retain.
             request_context: Request context for authentication.
-            document_tags: Optional tags applied to all items in the async batch.
 
         Returns:
             Dict with operation_id and items_count.

hindsight-api/hindsight_api/engine/memory_engine.py

@@ -18,20 +18,11 @@ import uuid
 from datetime import UTC, datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
-import tiktoken
-
 from ..config import get_config
 from ..metrics import get_metrics_collector
 from ..tracing import create_operation_span
 from ..utils import mask_network_location
 from .db_budget import budgeted_operation
-from .operation_metadata import (
-    BatchRetainChildMetadata,
-    BatchRetainParentMetadata,
-    ConsolidationMetadata,
-    RefreshMentalModelMetadata,
-    RetainMetadata,
-)
 
 # Context variable for current schema (async-safe, per-task isolation)
 # Note: default is None, actual default comes from config via get_current_schema()
@@ -47,15 +38,6 @@ def get_current_schema() -> str:
     return schema
 
 
-# Initialize tiktoken encoder once at module level for efficiency
-_tiktoken_encoder = tiktoken.get_encoding("cl100k_base")  # GPT-4/GPT-3.5-turbo encoding
-
-
-def count_tokens(text: str) -> int:
-    """Count tokens in text using tiktoken (cl100k_base encoding for GPT-4/3.5)."""
-    return len(_tiktoken_encoder.encode(text))
-
-
 def fq_table(table_name: str) -> str:
     """
     Get fully-qualified table name with current schema.
@@ -558,7 +540,6 @@ class MemoryEngine(MemoryEngineInterface):
         if not bank_id:
             raise ValueError("bank_id is required for batch retain task")
         contents = task_dict.get("contents", [])
-        document_tags = task_dict.get("document_tags")
 
         logger.info(
             f"[BATCH_RETAIN_TASK] Starting background batch retain for bank_id={bank_id}, {len(contents)} items"
@@ -576,12 +557,7 @@ class MemoryEngine(MemoryEngineInterface):
             tenant_id=task_dict.get("_tenant_id"),
             api_key_id=task_dict.get("_api_key_id"),
         )
-        await self.retain_batch_async(
-            bank_id=bank_id,
-            contents=contents,
-            document_tags=document_tags,
-            request_context=context,
-        )
+        await self.retain_batch_async(bank_id=bank_id, contents=contents, request_context=context)
 
         logger.info(f"[BATCH_RETAIN_TASK] Completed background batch retain for bank_id={bank_id}")
 
@@ -844,11 +820,7 @@ class MemoryEngine(MemoryEngineInterface):
             logger.error(f"Failed to delete async operation record {operation_id}: {e}")
 
     async def _mark_operation_failed(self, operation_id: str, error_message: str, error_traceback: str):
-        """Helper to mark an operation as failed in the database.
-
-        Also checks if this is a child operation and updates the parent if all siblings are done.
-        Uses a single transaction to avoid race conditions when multiple children fail simultaneously.
-        """
+        """Helper to mark an operation as failed in the database."""
         try:
             pool = await self._get_pool()
             # Truncate error message to avoid extremely long strings
@@ -856,160 +828,36 @@ class MemoryEngine(MemoryEngineInterface):
             truncated_error = full_error[:5000] if len(full_error) > 5000 else full_error
 
             async with acquire_with_retry(pool) as conn:
-                async with conn.transaction():
-                    # Mark this operation as failed
-                    await conn.execute(
-                        f"""
-                        UPDATE {fq_table("async_operations")}
-                        SET status = 'failed', error_message = $2, updated_at = NOW()
-                        WHERE operation_id = $1
-                        """,
-                        uuid.UUID(operation_id),
-                        truncated_error,
-                    )
-                    logger.info(f"Marked async operation as failed: {operation_id}")
-
-                    # Check if this is a child operation and update parent if all siblings are done
-                    # This happens in the same transaction after the child status is updated
-                    await self._maybe_update_parent_operation(operation_id, conn)
+                await conn.execute(
+                    f"""
+                    UPDATE {fq_table("async_operations")}
+                    SET status = 'failed', error_message = $2, updated_at = NOW()
+                    WHERE operation_id = $1
+                    """,
+                    uuid.UUID(operation_id),
+                    truncated_error,
+                )
+            logger.info(f"Marked async operation as failed: {operation_id}")
         except Exception as e:
             logger.error(f"Failed to mark operation as failed {operation_id}: {e}")
 
     async def _mark_operation_completed(self, operation_id: str):
-        """Helper to mark an operation as completed in the database.
-
-        Also checks if this is a child operation and updates the parent if all siblings are done.
-        Uses a single transaction to avoid race conditions when multiple children complete simultaneously.
-        """
+        """Helper to mark an operation as completed in the database."""
         try:
             pool = await self._get_pool()
             async with acquire_with_retry(pool) as conn:
-                async with conn.transaction():
-                    # Mark this operation as completed
-                    await conn.execute(
-                        f"""
-                        UPDATE {fq_table("async_operations")}
-                        SET status = 'completed', updated_at = NOW(), completed_at = NOW()
-                        WHERE operation_id = $1
-                        """,
-                        uuid.UUID(operation_id),
-                    )
-                    logger.info(f"Marked async operation as completed: {operation_id}")
-
-                    # Check if this is a child operation and update parent if all siblings are done
-                    # This happens in the same transaction after the child status is updated
-                    await self._maybe_update_parent_operation(operation_id, conn)
+                await conn.execute(
+                    f"""
+                    UPDATE {fq_table("async_operations")}
+                    SET status = 'completed', updated_at = NOW(), completed_at = NOW()
+                    WHERE operation_id = $1
+                    """,
+                    uuid.UUID(operation_id),
+                )
+            logger.info(f"Marked async operation as completed: {operation_id}")
         except Exception as e:
             logger.error(f"Failed to mark operation as completed {operation_id}: {e}")
 
-    async def _maybe_update_parent_operation(self, child_operation_id: str, conn):
-        """Check if this is a child operation and update parent status if all siblings are done.
-
-        Must be called within an active transaction that has already updated the child's status.
-        Uses SELECT FOR UPDATE to lock the parent and prevent race conditions.
-
-        Args:
-            child_operation_id: The operation ID that just completed or failed
-            conn: Database connection with an active transaction
-        """
-        try:
-            # Get this operation's metadata to check if it has a parent
-            row = await conn.fetchrow(
-                f"""
-                SELECT result_metadata, bank_id
-                FROM {fq_table("async_operations")}
-                WHERE operation_id = $1
-                """,
-                uuid.UUID(child_operation_id),
-            )
-
-            if not row:
-                return
-
-            result_metadata = json.loads(row["result_metadata"]) if row["result_metadata"] else {}
-            parent_operation_id = result_metadata.get("parent_operation_id")
-
-            if not parent_operation_id:
-                # Not a child operation
-                return
-
-            bank_id = row["bank_id"]
-
-            # Lock the parent operation to prevent concurrent updates from other children
-            # Use FOR UPDATE to ensure only one child can update the parent at a time
-            parent_row = await conn.fetchrow(
-                f"""
-                SELECT operation_id
-                FROM {fq_table("async_operations")}
-                WHERE operation_id = $1 AND bank_id = $2
-                FOR UPDATE
-                """,
-                uuid.UUID(parent_operation_id),
-                bank_id,
-            )
-
-            if not parent_row:
-                # Parent doesn't exist (shouldn't happen)
-                return
-
-            # Get all sibling operations (including this one)
-            # This query runs in the same transaction, so it sees the current child's updated status
-            siblings = await conn.fetch(
-                f"""
-                SELECT status
-                FROM {fq_table("async_operations")}
-                WHERE bank_id = $1
-                AND result_metadata::jsonb @> $2::jsonb
-                """,
-                bank_id,
-                json.dumps({"parent_operation_id": parent_operation_id}),
-            )
-
-            if not siblings:
-                return
-
-            # Check if all siblings are done (completed or failed)
-            all_completed = all(sib["status"] == "completed" for sib in siblings)
-            any_failed = any(sib["status"] == "failed" for sib in siblings)
-            all_done = all(sib["status"] in ("completed", "failed") for sib in siblings)
-
-            if not all_done:
-                # Some siblings still pending/processing
-                return
-
-            # All siblings are done - update parent status
-            if any_failed:
-                new_status = "failed"
-                # Set parent error message to indicate child failure
-                await conn.execute(
-                    f"""
-                    UPDATE {fq_table("async_operations")}
-                    SET status = $2, error_message = $3, updated_at = NOW()
-                    WHERE operation_id = $1
-                    """,
-                    uuid.UUID(parent_operation_id),
-                    new_status,
-                    "One or more sub-batches failed",
-                )
-            elif all_completed:
-                new_status = "completed"
-                await conn.execute(
-                    f"""
-                    UPDATE {fq_table("async_operations")}
-                    SET status = $2, updated_at = NOW(), completed_at = NOW()
-                    WHERE operation_id = $1
-                    """,
-                    uuid.UUID(parent_operation_id),
-                    new_status,
-                )
-
-            logger.info(f"Updated parent operation {parent_operation_id} to status '{new_status}' (all children done)")
-
-        except Exception as e:
-            logger.error(f"Failed to update parent operation for child {child_operation_id}: {e}")
-            # Re-raise to rollback the transaction
-            raise
-
     async def initialize(self):
         """Initialize the connection pool, models, and background workers.
 
@@ -1120,12 +968,7 @@ class MemoryEngine(MemoryEngineInterface):
 
         # Run database migrations if enabled
         if self._run_migrations:
-            from ..migrations import (
-                ensure_embedding_dimension,
-                ensure_text_search_extension,
-                ensure_vector_extension,
-                run_migrations,
-            )
+            from ..migrations import ensure_embedding_dimension, run_migrations
 
             if not self.db_url:
                 raise ValueError("Database URL is required for migrations")
@@ -1133,43 +976,30 @@ class MemoryEngine(MemoryEngineInterface):
             # Migrate all schemas from the tenant extension
             # The tenant extension is the single source of truth for which schemas exist
             logger.info("Running database migrations...")
-            tenants = await self._tenant_extension.list_tenants()
-            if tenants:
-                logger.info(f"Running migrations on {len(tenants)} schema(s)...")
-                for tenant in tenants:
-                    schema = tenant.schema
-                    if schema:
-                        run_migrations(self.db_url, schema=schema)
-                logger.info("Schema migrations completed")
+            try:
+                tenants = await self._tenant_extension.list_tenants()
+                if tenants:
+                    logger.info(f"Running migrations on {len(tenants)} schema(s)...")
+                    for tenant in tenants:
+                        schema = tenant.schema
+                        if schema:
+                            try:
+                                run_migrations(self.db_url, schema=schema)
+                            except Exception as e:
+                                logger.warning(f"Failed to migrate schema {schema}: {e}")
+                    logger.info("Schema migrations completed")
 
-                # Get config for vector extension setting
-                config = get_config()
-
-                # Ensure embedding column dimension matches the model's dimension
-                # This is done after migrations and after embeddings.initialize()
-                for tenant in tenants:
-                    schema = tenant.schema
-                    if schema:
-                        ensure_embedding_dimension(
-                            self.db_url,
-                            self.embeddings.dimension,
-                            schema=schema,
-                            vector_extension=config.vector_extension,
-                        )
-
-                # Ensure vector indexes match the configured extension
-                for tenant in tenants:
-                    schema = tenant.schema
-                    if schema:
-                        ensure_vector_extension(self.db_url, vector_extension=config.vector_extension, schema=schema)
-
-                # Ensure text search columns/indexes match the configured extension
-                for tenant in tenants:
-                    schema = tenant.schema
-                    if schema:
-                        ensure_text_search_extension(
-                            self.db_url, text_search_extension=config.text_search_extension, schema=schema
-                        )
+                    # Ensure embedding column dimension matches the model's dimension
+                    # This is done after migrations and after embeddings.initialize()
+                    for tenant in tenants:
+                        schema = tenant.schema
+                        if schema:
+                            try:
+                                ensure_embedding_dimension(self.db_url, self.embeddings.dimension, schema=schema)
+                            except Exception as e:
+                                logger.warning(f"Failed to ensure embedding dimension for schema {schema}: {e}")
+            except Exception as e:
+                logger.warning(f"Failed to run schema migrations: {e}")
 
         logger.info(f"Connecting to PostgreSQL at {mask_network_location(self.db_url)}")
 
@@ -1188,12 +1018,6 @@ class MemoryEngine(MemoryEngineInterface):
         # Initialize entity resolver with pool
         self.entity_resolver = EntityResolver(self._pool)
 
-        # Initialize config resolver for hierarchical configuration
-        from ..config_resolver import ConfigResolver
-
-        self._config_resolver = ConfigResolver(pool=self._pool, tenant_extension=self._tenant_extension)
-        logger.debug("Config resolver initialized for hierarchical configuration")
-
         # Set executor for task backend and initialize
         self._task_backend.set_executor(self.execute_task)
         await self._task_backend.initialize()
@@ -1576,49 +1400,35 @@ class MemoryEngine(MemoryEngineInterface):
                 if "document_id" not in item:
                     item["document_id"] = document_id
 
-        # Validate no duplicate document_ids in the batch
-        # Having duplicate document_ids causes race conditions in document upserts during parallel processing
-        doc_ids = [item.get("document_id") for item in contents if item.get("document_id")]
-        if len(doc_ids) != len(set(doc_ids)):
-            from collections import Counter
-
-            duplicates = [doc_id for doc_id, count in Counter(doc_ids).items() if count > 1]
-            raise ValueError(
-                f"Batch contains duplicate document_ids: {duplicates}. "
-                f"Each content item in a batch must have a unique document_id to avoid race conditions."
-            )
-
-        # Auto-chunk large batches by token count to avoid timeouts and memory issues
-        # Calculate total token count
-        total_tokens = sum(count_tokens(item.get("content", "")) for item in contents)
+        # Auto-chunk large batches by character count to avoid timeouts and memory issues
+        # Calculate total character count
+        total_chars = sum(len(item.get("content", "")) for item in contents)
         total_usage = TokenUsage()
 
-        # Get batch size threshold from config
-        config = get_config()
-        tokens_per_batch = config.retain_batch_tokens
+        CHARS_PER_BATCH = 600_000
 
-        if total_tokens > tokens_per_batch:
-            # Split into smaller batches based on token count
+        if total_chars > CHARS_PER_BATCH:
+            # Split into smaller batches based on character count
             logger.info(
-                f"Large batch detected ({total_tokens:,} tokens from {len(contents)} items). Splitting into sub-batches of ~{tokens_per_batch:,} tokens each..."
+                f"Large batch detected ({total_chars:,} chars from {len(contents)} items). Splitting into sub-batches of ~{CHARS_PER_BATCH:,} chars each..."
             )
 
             sub_batches = []
             current_batch = []
-            current_batch_tokens = 0
+            current_batch_chars = 0
 
             for item in contents:
-                item_tokens = count_tokens(item.get("content", ""))
+                item_chars = len(item.get("content", ""))
 
                 # If adding this item would exceed the limit, start a new batch
                 # (unless current batch is empty - then we must include it even if it's large)
-                if current_batch and current_batch_tokens + item_tokens > tokens_per_batch:
+                if current_batch and current_batch_chars + item_chars > CHARS_PER_BATCH:
                     sub_batches.append(current_batch)
                     current_batch = [item]
-                    current_batch_tokens = item_tokens
+                    current_batch_chars = item_chars
                 else:
                     current_batch.append(item)
-                    current_batch_tokens += item_tokens
+                    current_batch_chars += item_chars
 
             # Add the last batch
             if current_batch:
@@ -1629,15 +1439,14 @@ class MemoryEngine(MemoryEngineInterface):
             # Process each sub-batch
             all_results = []
             for i, sub_batch in enumerate(sub_batches, 1):
-                sub_batch_tokens = sum(count_tokens(item.get("content", "")) for item in sub_batch)
+                sub_batch_chars = sum(len(item.get("content", "")) for item in sub_batch)
                 logger.info(
-                    f"Processing sub-batch {i}/{len(sub_batches)}: {len(sub_batch)} items, {sub_batch_tokens:,} tokens"
+                    f"Processing sub-batch {i}/{len(sub_batches)}: {len(sub_batch)} items, {sub_batch_chars:,} chars"
                 )
 
                 sub_results, sub_usage = await self._retain_batch_async_internal(
                     bank_id=bank_id,
                     contents=sub_batch,
-                    request_context=request_context,
                     document_id=document_id,
                     is_first_batch=i == 1,  # Only upsert on first batch
                     fact_type_override=fact_type_override,
@@ -1657,7 +1466,6 @@ class MemoryEngine(MemoryEngineInterface):
             result, total_usage = await self._retain_batch_async_internal(
                 bank_id=bank_id,
                 contents=contents,
-                request_context=request_context,
                 document_id=document_id,
                 is_first_batch=True,
                 fact_type_override=fact_type_override,
@@ -1689,8 +1497,9 @@ class MemoryEngine(MemoryEngineInterface):
                 logger.warning(f"Post-retain hook error (non-fatal): {e}")
 
         # Trigger consolidation as a tracked async operation if enabled
-        # Resolve bank-specific config to check if observations are enabled for this bank
-        config = await self._config_resolver.resolve_full_config(bank_id, request_context)
+        from ..config import get_config
+
+        config = get_config()
         if config.enable_observations:
             try:
                 await self.submit_async_consolidation(bank_id=bank_id, request_context=request_context)
@@ -1706,7 +1515,6 @@ class MemoryEngine(MemoryEngineInterface):
         self,
         bank_id: str,
         contents: list[RetainContentDict],
-        request_context: "RequestContext",
         document_id: str | None = None,
         is_first_batch: bool = True,
         fact_type_override: str | None = None,
@@ -1724,7 +1532,6 @@ class MemoryEngine(MemoryEngineInterface):
         Args:
             bank_id: Unique identifier for the bank
             contents: List of dicts with content, context, event_date
-            request_context: Request context for config resolution
             document_id: Optional document ID (always upserts if exists)
             is_first_batch: Whether this is the first batch (for chunked operations, only delete on first batch)
             fact_type_override: Override fact type for all facts
@@ -1741,9 +1548,6 @@ class MemoryEngine(MemoryEngineInterface):
 
             pool = await self._get_pool()
 
-            # Resolve bank-specific config for this operation
-            resolved_config = await self._config_resolver.resolve_full_config(bank_id, request_context)
-
             # Create parent span for retain operation
             with create_operation_span("retain", bank_id):
                 return await orchestrator.retain_batch(
@@ -1760,7 +1564,6 @@ class MemoryEngine(MemoryEngineInterface):
                     fact_type_override=fact_type_override,
                     confidence_score=confidence_score,
                     document_tags=document_tags,
-                    config=resolved_config,
                 )
 
     def recall(
@@ -1848,21 +1651,15 @@ class MemoryEngine(MemoryEngineInterface):
             max_entity_tokens: Maximum tokens for entity observations (default 500)
             include_chunks: Whether to include raw chunks in the response
             max_chunk_tokens: Maximum tokens for chunks (default 8192)
-                             NOTE: Chunks are fetched independently of max_tokens filtering.
-                             This means setting max_tokens=0 will return 0 facts but can still
-                             return chunks from the top-scored (reranked) results.
-                             Chunks are fetched in batches (estimated as (max_chunk_tokens // retain_chunk_size) * 2)
-                             until the token budget is exhausted or all chunks are fetched.
-                             This handles varying chunk sizes across documents.
             tags: Optional list of tags for visibility filtering (OR matching - returns
                   memories that have at least one matching tag)
 
         Returns:
             RecallResultModel containing:
-            - results: List of MemoryFact objects (filtered by max_tokens)
+            - results: List of MemoryFact objects
             - trace: Optional trace information for debugging
             - entities: Optional dict of entity states (if include_entities=True)
-            - chunks: Optional dict of chunks (if include_chunks=True, independent of max_tokens)
+            - chunks: Optional dict of chunks (if include_chunks=True)
         """
         # Authenticate tenant and set schema in context (for fq_table())
         await self._authenticate_tenant(request_context)
@@ -2090,8 +1887,7 @@ class MemoryEngine(MemoryEngineInterface):
         2. Merge: RRF to combine ranked lists
         3. Reranking: Pluggable strategy (heuristic or cross-encoder)
         4. Diversity: MMR with λ=0.5
-        5. Chunks: Fetch chunks from top-scored results (BEFORE token filtering)
-        6. Token Filter: Limit facts to max_tokens budget
+        5. Token Filter: Limit results to max_tokens budget
 
         Args:
             bank_id: bank IDentifier
@@ -2102,7 +1898,7 @@ class MemoryEngine(MemoryEngineInterface):
             enable_trace: Whether to return search trace (deprecated)
             include_entities: Whether to include entity observations
             max_entity_tokens: Maximum tokens for entity observations
-            include_chunks: Whether to include raw chunks (fetched before max_tokens filtering)
+            include_chunks: Whether to include raw chunks
             max_chunk_tokens: Maximum tokens for chunks
 
         Returns:
@@ -2525,85 +2321,6 @@ class MemoryEngine(MemoryEngineInterface):
             top_scored = scored_results[:rerank_limit]
             log_buffer.append(f"  [5] Truncated to top {len(top_scored)} results")
 
-            # Step 5.5: Fetch chunks from top-scored results (before token filtering)
-            # Chunks are fetched independently of max_tokens filtering
-            chunks_dict = None
-            total_chunk_tokens = 0
-            if include_chunks and top_scored:
-                from .response_models import ChunkInfo
-
-                # Collect chunk_ids in order of fact relevance (preserving order from top_scored)
-                # Use a list to maintain order, but track seen chunks to avoid duplicates
-                chunk_ids_ordered = []
-                seen_chunk_ids = set()
-                for sr in top_scored:
-                    chunk_id = sr.retrieval.chunk_id
-                    if chunk_id and chunk_id not in seen_chunk_ids:
-                        chunk_ids_ordered.append(chunk_id)
-                        seen_chunk_ids.add(chunk_id)
-
-                if chunk_ids_ordered:
-                    # Estimate batch size based on retain_chunk_size * 2 (rough estimate)
-                    # Chunk sizes vary per document, so we fetch in batches until budget is exhausted
-                    bank_config = await self._config_resolver.resolve_full_config(bank_id, request_context)
-                    estimated_batch_size = max(1, (max_chunk_tokens // bank_config.retain_chunk_size) * 2)
-
-                    chunks_dict = {}
-                    encoding = _get_tiktoken_encoding()
-                    chunk_offset = 0
-
-                    # Fetch chunks in batches until we run out of budget or chunks
-                    while chunk_offset < len(chunk_ids_ordered) and total_chunk_tokens < max_chunk_tokens:
-                        # Get next batch of chunk IDs
-                        batch_chunk_ids = chunk_ids_ordered[chunk_offset : chunk_offset + estimated_batch_size]
-                        chunk_offset += estimated_batch_size
-
-                        # Fetch chunk data from database
-                        async with acquire_with_retry(pool) as conn:
-                            chunks_rows = await conn.fetch(
-                                f"""
-                                SELECT chunk_id, chunk_text, chunk_index
-                                FROM {fq_table("chunks")}
-                                WHERE chunk_id = ANY($1::text[])
-                                """,
-                                batch_chunk_ids,
-                            )
-
-                        # Create a lookup dict for fast access (preserves order from batch_chunk_ids)
-                        chunks_lookup = {row["chunk_id"]: row for row in chunks_rows}
-
-                        # Process chunks in order, respecting token budget
-                        for chunk_id in batch_chunk_ids:
-                            if chunk_id not in chunks_lookup:
-                                continue
-
-                            row = chunks_lookup[chunk_id]
-                            chunk_text = row["chunk_text"]
-                            chunk_tokens = len(encoding.encode(chunk_text))
-
-                            # Check if adding this chunk would exceed the limit
-                            if total_chunk_tokens + chunk_tokens > max_chunk_tokens:
-                                # Truncate the chunk to fit within the remaining budget
-                                remaining_tokens = max_chunk_tokens - total_chunk_tokens
-                                if remaining_tokens > 0:
-                                    # Truncate to remaining tokens
-                                    truncated_text = encoding.decode(encoding.encode(chunk_text)[:remaining_tokens])
-                                    chunks_dict[chunk_id] = ChunkInfo(
-                                        chunk_text=truncated_text, chunk_index=row["chunk_index"], truncated=True
-                                    )
-                                    total_chunk_tokens = max_chunk_tokens
-                                # Budget exhausted - stop fetching more batches
-                                break
-                            else:
-                                chunks_dict[chunk_id] = ChunkInfo(
-                                    chunk_text=chunk_text, chunk_index=row["chunk_index"], truncated=False
-                                )
-                                total_chunk_tokens += chunk_tokens
-
-                        # If we hit the budget limit in this batch, stop fetching more batches
-                        if total_chunk_tokens >= max_chunk_tokens:
-                            break
-
             # Step 6: Token budget filtering
             step_start = time.time()
 
@@ -2698,6 +2415,68 @@ class MemoryEngine(MemoryEngineInterface):
             # Entity observations removed - always set to None
             entities_dict = None
 
+            # Fetch chunks if requested
+            chunks_dict = None
+            total_chunk_tokens = 0
+            if include_chunks and top_scored:
+                from .response_models import ChunkInfo
+
+                # Collect chunk_ids in order of fact relevance (preserving order from top_scored)
+                # Use a list to maintain order, but track seen chunks to avoid duplicates
+                chunk_ids_ordered = []
+                seen_chunk_ids = set()
+                for sr in top_scored:
+                    chunk_id = sr.retrieval.chunk_id
+                    if chunk_id and chunk_id not in seen_chunk_ids:
+                        chunk_ids_ordered.append(chunk_id)
+                        seen_chunk_ids.add(chunk_id)
+
+                if chunk_ids_ordered:
+                    # Fetch chunk data from database using chunk_ids (no ORDER BY to preserve input order)
+                    async with acquire_with_retry(pool) as conn:
+                        chunks_rows = await conn.fetch(
+                            f"""
+                            SELECT chunk_id, chunk_text, chunk_index
+                            FROM {fq_table("chunks")}
+                            WHERE chunk_id = ANY($1::text[])
+                            """,
+                            chunk_ids_ordered,
+                        )
+
+                    # Create a lookup dict for fast access
+                    chunks_lookup = {row["chunk_id"]: row for row in chunks_rows}
+
+                    # Apply token limit and build chunks_dict in the order of chunk_ids_ordered
+                    chunks_dict = {}
+                    encoding = _get_tiktoken_encoding()
+
+                    for chunk_id in chunk_ids_ordered:
+                        if chunk_id not in chunks_lookup:
+                            continue
+
+                        row = chunks_lookup[chunk_id]
+                        chunk_text = row["chunk_text"]
+                        chunk_tokens = len(encoding.encode(chunk_text))
+
+                        # Check if adding this chunk would exceed the limit
+                        if total_chunk_tokens + chunk_tokens > max_chunk_tokens:
+                            # Truncate the chunk to fit within the remaining budget
+                            remaining_tokens = max_chunk_tokens - total_chunk_tokens
+                            if remaining_tokens > 0:
+                                # Truncate to remaining tokens
+                                truncated_text = encoding.decode(encoding.encode(chunk_text)[:remaining_tokens])
+                                chunks_dict[chunk_id] = ChunkInfo(
+                                    chunk_text=truncated_text, chunk_index=row["chunk_index"], truncated=True
+                                )
+                                total_chunk_tokens = max_chunk_tokens
+                            # Stop adding more chunks once we hit the limit
+                            break
+                        else:
+                            chunks_dict[chunk_id] = ChunkInfo(
+                                chunk_text=chunk_text, chunk_index=row["chunk_index"], truncated=False
+                            )
+                            total_chunk_tokens += chunk_tokens
+
             # Finalize trace if enabled
             trace_dict = None
             if tracer:
@@ -5623,10 +5402,10 @@ class MemoryEngine(MemoryEngineInterface):
             )
             total = total_row["total"] if total_row else 0
 
-            # Get operations with pagination (include result_metadata to check for parent operations)
+            # Get operations with pagination
             operations = await conn.fetch(
                 f"""
-                SELECT operation_id, operation_type, created_at, status, error_message, result_metadata
+                SELECT operation_id, operation_type, created_at, status, error_message
                 FROM {fq_table("async_operations")}
                 WHERE {where_clause}
                 ORDER BY created_at DESC
@@ -5637,29 +5416,21 @@ class MemoryEngine(MemoryEngineInterface):
                 offset,
             )
 
-            # Build operation list using status from database
-            # Parent operations have their status updated when all children complete/fail
-            operation_list = []
-            for row in operations:
-                # Map DB status to API status (pending includes processing)
-                db_status = row["status"]
-                api_status = "pending" if db_status in ("pending", "processing") else db_status
-
-                operation_list.append(
+            return {
+                "total": total,
+                "operations": [
                     {
                         "id": str(row["operation_id"]),
                         "task_type": row["operation_type"],
                         "items_count": 0,
                         "document_id": None,
                         "created_at": row["created_at"].isoformat(),
-                        "status": api_status,
+                        # Map DB status to API status (processing -> pending for simplicity)
+                        "status": "pending" if row["status"] in ("pending", "processing") else row["status"],
                         "error_message": row["error_message"],
                     }
-                )
-
-            return {
-                "total": total,
-                "operations": operation_list,
+                    for row in operations
+                ],
             }
 
     async def get_operation_status(
@@ -5671,13 +5442,10 @@ class MemoryEngine(MemoryEngineInterface):
     ) -> dict[str, Any]:
         """Get the status of a specific async operation.
 
-        For parent operations, the status is automatically updated in the database when all children complete/fail.
-
         Returns:
-            - status: "pending", "completed", or "failed" (from database)
+            - status: "pending", "completed", or "failed"
             - updated_at: last update timestamp
             - completed_at: completion timestamp (if completed)
-            - child_operations: (for parent operations) list of child operation statuses
         """
         await self._authenticate_tenant(request_context)
         pool = await self._get_pool()
@@ -5687,7 +5455,7 @@ class MemoryEngine(MemoryEngineInterface):
         async with acquire_with_retry(pool) as conn:
             row = await conn.fetchrow(
                 f"""
-                SELECT operation_id, operation_type, created_at, updated_at, completed_at, status, error_message, result_metadata
+                SELECT operation_id, operation_type, created_at, updated_at, completed_at, status, error_message
                 FROM {fq_table("async_operations")}
                 WHERE operation_id = $1 AND bank_id = $2
                 """,
@@ -5696,98 +5464,18 @@ class MemoryEngine(MemoryEngineInterface):
             )
 
             if row:
-                # Check if this is a parent operation
-                result_metadata = json.loads(row["result_metadata"]) if row["result_metadata"] else {}
-                is_parent = result_metadata.get("is_parent", False)
-
-                # Use status from database (parent status is updated when all children complete/fail)
+                # Map DB status to API status (processing -> pending for simplicity)
                 db_status = row["status"]
                 api_status = "pending" if db_status in ("pending", "processing") else db_status
-
-                # For parent operations, include child operations list
-                if is_parent:
-                    # Query child operations
-                    child_rows = await conn.fetch(
-                        f"""
-                        SELECT operation_id, status, error_message, result_metadata
-                        FROM {fq_table("async_operations")}
-                        WHERE bank_id = $1
-                        AND result_metadata::jsonb @> $2::jsonb
-                        ORDER BY (result_metadata->>'sub_batch_index')::int
-                        """,
-                        bank_id,
-                        json.dumps({"parent_operation_id": operation_id}),
-                    )
-
-                    # Build child operations list and check if parent status needs updating
-                    child_statuses = []
-                    all_done = True
-                    any_failed = False
-                    all_completed = True
-
-                    for child_row in child_rows:
-                        child_metadata = (
-                            json.loads(child_row["result_metadata"]) if child_row["result_metadata"] else {}
-                        )
-                        child_status = child_row["status"]
-
-                        child_statuses.append(
-                            {
-                                "operation_id": str(child_row["operation_id"]),
-                                "status": child_status,
-                                "sub_batch_index": child_metadata.get("sub_batch_index"),
-                                "items_count": child_metadata.get("items_count"),
-                                "error_message": child_row["error_message"],
-                            }
-                        )
-
-                        if child_status not in ("completed", "failed"):
-                            all_done = False
-                        if child_status == "failed":
-                            any_failed = True
-                        if child_status != "completed":
-                            all_completed = False
-
-                    # Self-healing: if parent status is out of sync with children, update it
-                    if all_done and api_status == "pending":
-                        correct_status = "failed" if any_failed else "completed"
-                        logger.warning(
-                            f"Parent operation {operation_id} status out of sync (DB: pending, should be: {correct_status}). Fixing."
-                        )
-                        await conn.execute(
-                            f"""
-                            UPDATE {fq_table("async_operations")}
-                            SET status = $2, updated_at = NOW(), completed_at = NOW()
-                            WHERE operation_id = $1
-                            """,
-                            op_uuid,
-                            correct_status,
-                        )
-                        api_status = correct_status
-
-                    return {
-                        "operation_id": operation_id,
-                        "status": api_status,
-                        "operation_type": row["operation_type"],
-                        "created_at": row["created_at"].isoformat() if row["created_at"] else None,
-                        "updated_at": row["updated_at"].isoformat() if row["updated_at"] else None,
-                        "completed_at": row["completed_at"].isoformat() if row["completed_at"] else None,
-                        "error_message": row["error_message"],
-                        "result_metadata": result_metadata,
-                        "child_operations": child_statuses,
-                    }
-                else:
-                    # Regular operation (not a parent)
-                    return {
-                        "operation_id": operation_id,
-                        "status": api_status,
-                        "operation_type": row["operation_type"],
-                        "created_at": row["created_at"].isoformat() if row["created_at"] else None,
-                        "updated_at": row["updated_at"].isoformat() if row["updated_at"] else None,
-                        "completed_at": row["completed_at"].isoformat() if row["completed_at"] else None,
-                        "error_message": row["error_message"],
-                        "result_metadata": result_metadata,
-                    }
+                return {
+                    "operation_id": operation_id,
+                    "status": api_status,
+                    "operation_type": row["operation_type"],
+                    "created_at": row["created_at"].isoformat() if row["created_at"] else None,
+                    "updated_at": row["updated_at"].isoformat() if row["updated_at"] else None,
+                    "completed_at": row["completed_at"].isoformat() if row["completed_at"] else None,
+                    "error_message": row["error_message"],
+                }
             else:
                 # Operation not found
                 return {
@@ -5963,126 +5651,31 @@ class MemoryEngine(MemoryEngineInterface):
         request_context: "RequestContext",
         document_tags: list[str] | None = None,
     ) -> dict[str, Any]:
-        """Submit a batch retain operation to run asynchronously.
-
-        For large batches (exceeding retain_batch_chars threshold), automatically splits
-        into smaller sub-batches and creates a parent operation that tracks all children.
-        """
+        """Submit a batch retain operation to run asynchronously."""
         await self._authenticate_tenant(request_context)
 
-        # Validate no duplicate document_ids in the batch
-        # Having duplicate document_ids causes race conditions in document upserts during parallel processing
-        doc_ids = [item.get("document_id") for item in contents if item.get("document_id")]
-        if len(doc_ids) != len(set(doc_ids)):
-            from collections import Counter
+        task_payload: dict[str, Any] = {"contents": contents}
+        if document_tags:
+            task_payload["document_tags"] = document_tags
+        # Pass tenant_id and api_key_id through task payload so the worker
+        # can propagate request context to downstream operations (e.g.,
+        # consolidation and mental model refreshes triggered after retain).
+        if request_context.tenant_id:
+            task_payload["_tenant_id"] = request_context.tenant_id
+        if request_context.api_key_id:
+            task_payload["_api_key_id"] = request_context.api_key_id
 
-            duplicates = [doc_id for doc_id, count in Counter(doc_ids).items() if count > 1]
-            raise ValueError(
-                f"Batch contains duplicate document_ids: {duplicates}. "
-                f"Each content item in a batch must have a unique document_id to avoid race conditions."
-            )
-
-        # Calculate total token count and determine if we need to split
-        total_tokens = sum(count_tokens(item.get("content", "")) for item in contents)
-        config = get_config()
-        tokens_per_batch = config.retain_batch_tokens
-
-        # Split into sub-batches based on token count
-        sub_batches = []
-        current_batch = []
-        current_batch_tokens = 0
-
-        for item in contents:
-            item_tokens = count_tokens(item.get("content", ""))
-
-            # If adding this item would exceed the limit, start a new batch
-            # (unless current batch is empty - then we must include it even if it's large)
-            if current_batch and current_batch_tokens + item_tokens > tokens_per_batch:
-                sub_batches.append(current_batch)
-                current_batch = [item]
-                current_batch_tokens = item_tokens
-            else:
-                current_batch.append(item)
-                current_batch_tokens += item_tokens
-
-        # Add the last batch
-        if current_batch:
-            sub_batches.append(current_batch)
-
-        # Log splitting info if we actually split
-        if len(sub_batches) > 1:
-            logger.info(
-                f"Large async retain batch ({total_tokens:,} tokens from {len(contents)} items). "
-                f"Split into {len(sub_batches)} sub-batches: {[len(b) for b in sub_batches]} items each"
-            )
-
-        # Always create parent operation (even for single batch - simpler, more reliable code path)
-        import uuid
-
-        parent_operation_id = uuid.uuid4()
-        pool = await self._get_pool()
-
-        # Create typed metadata for parent operation
-        parent_metadata = BatchRetainParentMetadata(
-            items_count=len(contents),
-            total_tokens=total_tokens,
-            num_sub_batches=len(sub_batches),
+        result = await self._submit_async_operation(
+            bank_id=bank_id,
+            operation_type="retain",
+            task_type="batch_retain",
+            task_payload=task_payload,
+            result_metadata={"items_count": len(contents)},
+            dedupe_by_bank=False,
         )
 
-        async with acquire_with_retry(pool) as conn:
-            await conn.execute(
-                f"""
-                INSERT INTO {fq_table("async_operations")} (operation_id, bank_id, operation_type, result_metadata, status)
-                VALUES ($1, $2, $3, $4, $5)
-                """,
-                parent_operation_id,
-                bank_id,
-                "batch_retain",
-                json.dumps(parent_metadata.to_dict()),
-                "pending",  # Will be updated by status aggregation
-            )
-
-        logger.info(f"Created parent operation {parent_operation_id} for {len(sub_batches)} sub-batch(es)")
-
-        # Submit child operations for each sub-batch
-        for i, sub_batch in enumerate(sub_batches, 1):
-            if len(sub_batches) > 1:
-                sub_batch_tokens = sum(count_tokens(item.get("content", "")) for item in sub_batch)
-                logger.info(
-                    f"Submitting sub-batch {i}/{len(sub_batches)}: {len(sub_batch)} items, {sub_batch_tokens:,} tokens"
-                )
-
-            task_payload: dict[str, Any] = {"contents": sub_batch}
-            if document_tags:
-                task_payload["document_tags"] = document_tags
-            # Pass tenant_id and api_key_id through task payload
-            if request_context.tenant_id:
-                task_payload["_tenant_id"] = request_context.tenant_id
-            if request_context.api_key_id:
-                task_payload["_api_key_id"] = request_context.api_key_id
-
-            # Create typed metadata for child operation
-            child_metadata = BatchRetainChildMetadata(
-                items_count=len(sub_batch),
-                parent_operation_id=str(parent_operation_id),
-                sub_batch_index=i,
-                total_sub_batches=len(sub_batches),
-            )
-
-            # Create child operation with reference to parent
-            await self._submit_async_operation(
-                bank_id=bank_id,
-                operation_type="retain",
-                task_type="batch_retain",
-                task_payload=task_payload,
-                result_metadata=child_metadata.to_dict(),
-                dedupe_by_bank=False,
-            )
-
-        return {
-            "operation_id": str(parent_operation_id),
-            "items_count": len(contents),
-        }
+        result["items_count"] = len(contents)
+        return result
 
     async def submit_async_consolidation(
         self,

hindsight-api/hindsight_api/engine/operation_metadata.py

@@ -1,69 +0,0 @@
-"""
-Typed metadata models for async operations.
-
-These dataclasses define the structure of result_metadata for different operation types.
-The metadata is exposed in the API for debugging purposes and may change without notice.
-"""
-
-from dataclasses import asdict, dataclass
-from typing import Any
-
-
-@dataclass
-class BatchRetainParentMetadata:
-    """Metadata for parent batch_retain operations (when split into sub-batches)."""
-
-    items_count: int
-    total_tokens: int
-    num_sub_batches: int
-    is_parent: bool = True
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dict for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class BatchRetainChildMetadata:
-    """Metadata for child batch_retain operations (individual sub-batches)."""
-
-    items_count: int
-    parent_operation_id: str
-    sub_batch_index: int
-    total_sub_batches: int
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dict for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class RetainMetadata:
-    """Metadata for regular retain operations (non-batched, deprecated async path)."""
-
-    items_count: int
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dict for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class ConsolidationMetadata:
-    """Metadata for consolidation operations."""
-
-    # Currently empty, but structure for future fields
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dict for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class RefreshMentalModelMetadata:
-    """Metadata for mental model refresh operations."""
-
-    mental_model_id: str
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dict for JSON serialization."""
-        return asdict(self)

hindsight-api/hindsight_api/engine/retain/fact_extraction.py

@@ -702,7 +702,6 @@ async def _extract_facts_from_chunk(
     event_date: datetime,
     context: str,
     llm_config: "LLMConfig",
-    config,
     agent_name: str = None,
 ) -> tuple[list[dict[str, str]], TokenUsage]:
     """
@@ -722,6 +721,7 @@ async def _extract_facts_from_chunk(
     fact_types_instruction = "Extract ONLY 'world' and 'assistant' type facts."
 
     # Check config for extraction mode and causal link extraction
+    config = get_config()
     extraction_mode = config.retain_extraction_mode
     extract_causal_links = config.retain_extract_causal_links
 
@@ -1055,7 +1055,6 @@ async def _extract_facts_with_auto_split(
     event_date: datetime,
     context: str,
     llm_config: LLMConfig,
-    config,
     agent_name: str = None,
 ) -> tuple[list[dict[str, str]], TokenUsage]:
     """
@@ -1071,7 +1070,6 @@ async def _extract_facts_with_auto_split(
         event_date: Reference date for temporal information
         context: Context about the conversation/document
         llm_config: LLM configuration to use
-        config: Resolved HindsightConfig for this bank
         agent_name: Optional agent name (memory owner)
 
     Returns:
@@ -1090,7 +1088,6 @@ async def _extract_facts_with_auto_split(
             event_date=event_date,
             context=context,
             llm_config=llm_config,
-            config=config,
             agent_name=agent_name,
         )
     except OutputTooLongError:
@@ -1135,7 +1132,6 @@ async def _extract_facts_with_auto_split(
                 event_date=event_date,
                 context=context,
                 llm_config=llm_config,
-                config=config,
                 agent_name=agent_name,
             ),
             _extract_facts_with_auto_split(
@@ -1145,7 +1141,6 @@ async def _extract_facts_with_auto_split(
                 event_date=event_date,
                 context=context,
                 llm_config=llm_config,
-                config=config,
                 agent_name=agent_name,
             ),
         ]
@@ -1169,7 +1164,6 @@ async def extract_facts_from_text(
     event_date: datetime,
     llm_config: LLMConfig,
     agent_name: str,
-    config,
     context: str = "",
 ) -> tuple[list[Fact], list[tuple[str, int]], TokenUsage]:
     """
@@ -1184,10 +1178,9 @@ async def extract_facts_from_text(
     Args:
         text: Input text (conversation, article, etc.)
         event_date: Reference date for resolving relative times
+        context: Context about the conversation/document
         llm_config: LLM configuration to use
         agent_name: Agent name (memory owner)
-        config: Resolved HindsightConfig for this bank
-        context: Context about the conversation/document
 
     Returns:
         Tuple of (facts, chunks, usage) where:
@@ -1195,6 +1188,7 @@ async def extract_facts_from_text(
         - chunks: List of tuples (chunk_text, fact_count) for each chunk
         - usage: Aggregated token usage across all LLM calls
     """
+    config = get_config()
     chunks = chunk_text(text, max_chars=config.retain_chunk_size)
 
     # Log chunk count before starting LLM requests
@@ -1213,7 +1207,6 @@ async def extract_facts_from_text(
             event_date=event_date,
             context=context,
             llm_config=llm_config,
-            config=config,
             agent_name=agent_name,
         )
         for i, chunk in enumerate(chunks)
@@ -1246,7 +1239,7 @@ SECONDS_PER_FACT = 10
 
 
 async def extract_facts_from_contents(
-    contents: list[RetainContent], llm_config, agent_name: str, config
+    contents: list[RetainContent], llm_config, agent_name: str
 ) -> tuple[list[ExtractedFactType], list[ChunkMetadata], TokenUsage]:
     """
     Extract facts from multiple content items in parallel.
@@ -1261,7 +1254,6 @@ async def extract_facts_from_contents(
         contents: List of RetainContent objects to process
         llm_config: LLM configuration for fact extraction
         agent_name: Name of the agent (for agent-related fact detection)
-        config: Resolved HindsightConfig for this bank
 
     Returns:
         Tuple of (extracted_facts, chunks_metadata, usage)
@@ -1280,7 +1272,6 @@ async def extract_facts_from_contents(
             context=item.context,
             llm_config=llm_config,
             agent_name=agent_name,
-            config=config,
         )
         fact_extraction_tasks.append(task)
 

hindsight-api/hindsight_api/engine/retain/fact_storage.py

@@ -7,7 +7,6 @@ Handles insertion of facts into the database.
 import json
 import logging
 
-from ...config import get_config
 from ..memory_engine import fq_table
 from .fact_extraction import _sanitize_text
 from .types import ProcessedFact
@@ -71,59 +70,28 @@ async def insert_facts_batch(
 
     # Batch insert all facts
     # Note: tags are passed as JSON strings and converted back to varchar[] via jsonb_array_elements_text + array_agg
-    # Query varies based on text search backend
-    config = get_config()
-    if config.text_search_extension == "vchord":
-        # VectorChord: manually tokenize and insert search_vector
-        query = f"""
-            WITH input_data AS (
-                SELECT * FROM unnest(
-                    $2::text[], $3::vector[], $4::timestamptz[], $5::timestamptz[], $6::timestamptz[], $7::timestamptz[],
-                    $8::text[], $9::text[], $10::float[], $11::jsonb[], $12::text[], $13::text[], $14::jsonb[]
-                ) AS t(text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
-                       context, fact_type, confidence_score, metadata, chunk_id, document_id, tags_json)
-            )
-            INSERT INTO {fq_table("memory_units")} (bank_id, text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
-                                     context, fact_type, confidence_score, metadata, chunk_id, document_id, tags, search_vector)
-            SELECT
-                $1,
-                text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
-                context, fact_type, confidence_score, metadata, chunk_id, document_id,
-                COALESCE(
-                    (SELECT array_agg(elem) FROM jsonb_array_elements_text(tags_json) AS elem),
-                    '{{}}'::varchar[]
-                ),
-                tokenize(COALESCE(text, '') || ' ' || COALESCE(context, ''), 'llmlingua2')::bm25_catalog.bm25vector
-            FROM input_data
-            RETURNING id
-        """
-    else:  # native or pg_textsearch
-        # Native PostgreSQL: search_vector is GENERATED ALWAYS, don't include it
-        # pg_textsearch: indexes operate on base columns directly, don't populate search_vector
-        query = f"""
-            WITH input_data AS (
-                SELECT * FROM unnest(
-                    $2::text[], $3::vector[], $4::timestamptz[], $5::timestamptz[], $6::timestamptz[], $7::timestamptz[],
-                    $8::text[], $9::text[], $10::float[], $11::jsonb[], $12::text[], $13::text[], $14::jsonb[]
-                ) AS t(text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
-                       context, fact_type, confidence_score, metadata, chunk_id, document_id, tags_json)
-            )
-            INSERT INTO {fq_table("memory_units")} (bank_id, text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
-                                     context, fact_type, confidence_score, metadata, chunk_id, document_id, tags)
-            SELECT
-                $1,
-                text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
-                context, fact_type, confidence_score, metadata, chunk_id, document_id,
-                COALESCE(
-                    (SELECT array_agg(elem) FROM jsonb_array_elements_text(tags_json) AS elem),
-                    '{{}}'::varchar[]
-                )
-            FROM input_data
-            RETURNING id
-        """
-
     results = await conn.fetch(
-        query,
+        f"""
+        WITH input_data AS (
+            SELECT * FROM unnest(
+                $2::text[], $3::vector[], $4::timestamptz[], $5::timestamptz[], $6::timestamptz[], $7::timestamptz[],
+                $8::text[], $9::text[], $10::float[], $11::jsonb[], $12::text[], $13::text[], $14::jsonb[]
+            ) AS t(text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
+                   context, fact_type, confidence_score, metadata, chunk_id, document_id, tags_json)
+        )
+        INSERT INTO {fq_table("memory_units")} (bank_id, text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
+                                 context, fact_type, confidence_score, metadata, chunk_id, document_id, tags)
+        SELECT
+            $1,
+            text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
+            context, fact_type, confidence_score, metadata, chunk_id, document_id,
+            COALESCE(
+                (SELECT array_agg(elem) FROM jsonb_array_elements_text(tags_json) AS elem),
+                '{{}}'::varchar[]
+            )
+        FROM input_data
+        RETURNING id
+        """,
         bank_id,
         fact_texts,
         embeddings,

hindsight-api/hindsight_api/engine/retain/orchestrator.py

@@ -76,7 +76,6 @@ async def retain_batch(
     duplicate_checker_fn,
     bank_id: str,
     contents_dicts: list[RetainContentDict],
-    config,
     document_id: str | None = None,
     is_first_batch: bool = True,
     fact_type_override: str | None = None,
@@ -95,7 +94,6 @@ async def retain_batch(
         duplicate_checker_fn: Function to check for duplicate facts
         bank_id: Bank identifier
         contents_dicts: List of content dictionaries
-        config: Resolved HindsightConfig for this bank
         document_id: Optional document ID
         is_first_batch: Whether this is the first batch
         fact_type_override: Override fact type for all facts
@@ -146,9 +144,7 @@ async def retain_batch(
     # Step 1: Extract facts from all contents
     step_start = time.time()
 
-    extracted_facts, chunks, usage = await fact_extraction.extract_facts_from_contents(
-        contents, llm_config, agent_name, config
-    )
+    extracted_facts, chunks, usage = await fact_extraction.extract_facts_from_contents(contents, llm_config, agent_name)
     log_buffer.append(
         f"[1] Extract facts: {len(extracted_facts)} facts, {len(chunks)} chunks from {len(contents)} contents in {time.time() - step_start:.3f}s"
     )

hindsight-api/hindsight_api/engine/search/__init__.py

@@ -13,10 +13,12 @@ from .reranking import CrossEncoderReranker
 from .retrieval import (
     ParallelRetrievalResult,
     get_default_graph_retriever,
+    retrieve_parallel,
     set_default_graph_retriever,
 )
 
 __all__ = [
+    "retrieve_parallel",
     "get_default_graph_retriever",
     "set_default_graph_retriever",
     "ParallelRetrievalResult",

hindsight-api/hindsight_api/engine/search/retrieval.py

@@ -85,6 +85,116 @@ def set_default_graph_retriever(retriever: GraphRetriever) -> None:
     _default_graph_retriever = retriever
 
 
+async def retrieve_semantic(
+    conn,
+    query_emb_str: str,
+    bank_id: str,
+    fact_type: str,
+    limit: int,
+    tags: list[str] | None = None,
+) -> list[RetrievalResult]:
+    """
+    Semantic retrieval via vector similarity.
+
+    Args:
+        conn: Database connection
+        query_emb_str: Query embedding as string
+        agent_id: bank ID
+        fact_type: Fact type to filter
+        limit: Maximum results to return
+        tags: Optional list of tags for visibility filtering (OR matching)
+
+    Returns:
+        List of RetrievalResult objects
+    """
+    from .tags import TagsMatch, build_tags_where_clause_simple
+
+    tags_clause = build_tags_where_clause_simple(tags, 5)
+    params = [query_emb_str, bank_id, fact_type, limit]
+    if tags:
+        params.append(tags)
+
+    results = await conn.fetch(
+        f"""
+        SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, embedding, fact_type, document_id, chunk_id, tags,
+               1 - (embedding <=> $1::vector) AS similarity
+        FROM {fq_table("memory_units")}
+        WHERE bank_id = $2
+          AND embedding IS NOT NULL
+          AND fact_type = $3
+          AND (1 - (embedding <=> $1::vector)) >= 0.3
+          {tags_clause}
+        ORDER BY embedding <=> $1::vector
+        LIMIT $4
+        """,
+        *params,
+    )
+    return [RetrievalResult.from_db_row(dict(r)) for r in results]
+
+
+async def retrieve_bm25(
+    conn,
+    query_text: str,
+    bank_id: str,
+    fact_type: str,
+    limit: int,
+    tags: list[str] | None = None,
+) -> list[RetrievalResult]:
+    """
+    BM25 keyword retrieval via full-text search.
+
+    Args:
+        conn: Database connection
+        query_text: Query text
+        agent_id: bank ID
+        fact_type: Fact type to filter
+        limit: Maximum results to return
+        tags: Optional list of tags for visibility filtering (OR matching)
+
+    Returns:
+        List of RetrievalResult objects
+    """
+    import re
+
+    from .tags import TagsMatch, build_tags_where_clause_simple
+
+    # Sanitize query text: remove special characters that have meaning in tsquery
+    # Keep only alphanumeric characters and spaces
+    sanitized_text = re.sub(r"[^\w\s]", " ", query_text.lower())
+
+    # Split and filter empty strings
+    tokens = [token for token in sanitized_text.split() if token]
+
+    if not tokens:
+        # If no valid tokens, return empty results
+        return []
+
+    # Convert query to tsquery using OR for more flexible matching
+    # This prevents empty results when some terms are missing
+    query_tsquery = " | ".join(tokens)
+
+    tags_clause = build_tags_where_clause_simple(tags, 5)
+    params = [query_tsquery, bank_id, fact_type, limit]
+    if tags:
+        params.append(tags)
+
+    results = await conn.fetch(
+        f"""
+        SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, embedding, fact_type, document_id, chunk_id, tags,
+               ts_rank_cd(search_vector, to_tsquery('english', $1)) AS bm25_score
+        FROM {fq_table("memory_units")}
+        WHERE bank_id = $2
+          AND fact_type = $3
+          AND search_vector @@ to_tsquery('english', $1)
+          {tags_clause}
+        ORDER BY bm25_score DESC
+        LIMIT $4
+        """,
+        *params,
+    )
+    return [RetrievalResult.from_db_row(dict(r)) for r in results]
+
+
 async def retrieve_semantic_bm25_combined(
     conn,
     query_emb_str: str,
@@ -158,41 +268,18 @@ async def retrieve_semantic_bm25_combined(
                 result_dict[ft][0].append(RetrievalResult.from_db_row(row))
         return result_dict
 
-    # Build BM25 query based on text search backend
-    config = get_config()
+    query_tsquery = " | ".join(tokens)
 
     # Build tags clause - param 6 if tags provided
     tags_clause = build_tags_where_clause_simple(tags, 6, match=tags_match)
-
-    # Build backend-specific BM25 parts
-    if config.text_search_extension == "vchord":
-        # VectorChord BM25: use <&> operator with to_bm25query and tokenize
-        # Note: VectorChord scores are negative (higher = better, so -1 > -10)
-        bm25_score_expr = "search_vector <&> to_bm25query('idx_memory_units_text_search', tokenize($5, 'llmlingua2'))"
-        bm25_order_by = f"{bm25_score_expr} DESC"
-        bm25_where_filter = ""  # No additional WHERE filter for vchord
-        params = [query_emb_str, bank_id, fact_types, limit, query_text]  # Pass raw query_text for tokenization
-    elif config.text_search_extension == "pg_textsearch":
-        # Timescale pg_textsearch: use <@> operator with to_bm25query
-        # Note: pg_textsearch scores are negative (lower/more negative = better, so -10 > -1)
-        # We negate the score to maintain API consistency (higher = better)
-        bm25_score_expr = "-(text <@> to_bm25query($5, 'idx_memory_units_text_search'))"
-        bm25_order_by = "text <@> to_bm25query($5, 'idx_memory_units_text_search') ASC"
-        bm25_where_filter = ""  # No additional WHERE filter for pg_textsearch
-        params = [query_emb_str, bank_id, fact_types, limit, query_text]
-    else:  # native
-        # Native PostgreSQL: use ts_rank_cd with to_tsquery
-        query_tsquery = " | ".join(tokens)
-        bm25_score_expr = "ts_rank_cd(search_vector, to_tsquery('english', $5))"
-        bm25_order_by = f"{bm25_score_expr} DESC"
-        bm25_where_filter = "AND search_vector @@ to_tsquery('english', $5)"
-        params = [query_emb_str, bank_id, fact_types, limit, query_tsquery]
-
+    params = [query_emb_str, bank_id, fact_types, limit, query_tsquery]
     if tags:
         params.append(tags)
 
-    # Single query template with backend-specific parts injected
-    query = f"""
+    # Combined CTE query for both semantic and BM25 across all fact types
+    # Uses window functions to limit per fact_type per method
+    results = await conn.fetch(
+        f"""
         WITH semantic_ranked AS (
             SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, embedding, fact_type, document_id, chunk_id, tags,
                    1 - (embedding <=> $1::vector) AS similarity,
@@ -209,13 +296,13 @@ async def retrieve_semantic_bm25_combined(
         bm25_ranked AS (
             SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, embedding, fact_type, document_id, chunk_id, tags,
                    NULL::float AS similarity,
-                   {bm25_score_expr} AS bm25_score,
+                   ts_rank_cd(search_vector, to_tsquery('english', $5)) AS bm25_score,
                    'bm25' AS source,
-                   ROW_NUMBER() OVER (PARTITION BY fact_type ORDER BY {bm25_order_by}) AS rn
+                   ROW_NUMBER() OVER (PARTITION BY fact_type ORDER BY ts_rank_cd(search_vector, to_tsquery('english', $5)) DESC) AS rn
             FROM {fq_table("memory_units")}
             WHERE bank_id = $2
               AND fact_type = ANY($3)
-              {bm25_where_filter}
+              AND search_vector @@ to_tsquery('english', $5)
               {tags_clause}
         ),
         semantic AS (
@@ -231,11 +318,9 @@ async def retrieve_semantic_bm25_combined(
         SELECT * FROM semantic
         UNION ALL
         SELECT * FROM bm25
-    """
-
-    # Combined CTE query for both semantic and BM25 across all fact types
-    # Uses window functions to limit per fact_type per method
-    results = await conn.fetch(query, *params)
+        """,
+        *params,
+    )
 
     # Group results by fact_type and source
     result_dict: dict[str, tuple[list[RetrievalResult], list[RetrievalResult]]] = {ft: ([], []) for ft in fact_types}
@@ -476,6 +561,623 @@ async def retrieve_temporal_combined(
     return results_by_ft
 
 
+async def retrieve_temporal(
+    conn,
+    query_emb_str: str,
+    bank_id: str,
+    fact_type: str,
+    start_date: datetime,
+    end_date: datetime,
+    budget: int,
+    semantic_threshold: float = 0.1,
+    tags: list[str] | None = None,
+) -> list[RetrievalResult]:
+    """
+    Temporal retrieval with spreading activation.
+
+    Strategy:
+    1. Find entry points (facts in date range with semantic relevance)
+    2. Spread through temporal links to related facts
+    3. Score by temporal proximity + semantic similarity + link weight
+
+    Args:
+        conn: Database connection
+        query_emb_str: Query embedding as string
+        agent_id: bank ID
+        fact_type: Fact type to filter
+        start_date: Start of time range
+        end_date: End of time range
+        budget: Node budget for spreading
+        semantic_threshold: Minimum semantic similarity to include
+        tags: Optional list of tags for visibility filtering (OR matching)
+
+    Returns:
+        List of RetrievalResult objects with temporal scores
+    """
+
+    # Ensure start_date and end_date are timezone-aware (UTC) to match database datetimes
+    if start_date.tzinfo is None:
+        start_date = start_date.replace(tzinfo=UTC)
+    if end_date.tzinfo is None:
+        end_date = end_date.replace(tzinfo=UTC)
+
+    from .tags import TagsMatch, build_tags_where_clause_simple
+
+    tags_clause = build_tags_where_clause_simple(tags, 7)
+    params = [query_emb_str, bank_id, fact_type, start_date, end_date, semantic_threshold]
+    if tags:
+        params.append(tags)
+
+    entry_points = await conn.fetch(
+        f"""
+        SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, embedding, fact_type, document_id, chunk_id, tags,
+               1 - (embedding <=> $1::vector) AS similarity
+        FROM {fq_table("memory_units")}
+        WHERE bank_id = $2
+          AND fact_type = $3
+          AND embedding IS NOT NULL
+          AND (
+              -- Match if occurred range overlaps with query range
+              (occurred_start IS NOT NULL AND occurred_end IS NOT NULL
+               AND occurred_start <= $5 AND occurred_end >= $4)
+              OR
+              -- Match if mentioned_at falls within query range
+              (mentioned_at IS NOT NULL AND mentioned_at BETWEEN $4 AND $5)
+              OR
+              -- Match if any occurred date is set and overlaps (even if only start or end is set)
+              (occurred_start IS NOT NULL AND occurred_start BETWEEN $4 AND $5)
+              OR
+              (occurred_end IS NOT NULL AND occurred_end BETWEEN $4 AND $5)
+          )
+          AND (1 - (embedding <=> $1::vector)) >= $6
+          {tags_clause}
+        ORDER BY COALESCE(occurred_start, mentioned_at, occurred_end) DESC, (embedding <=> $1::vector) ASC
+        LIMIT 10
+        """,
+        *params,
+    )
+
+    if not entry_points:
+        return []
+
+    # Calculate temporal scores for entry points
+    total_days = (end_date - start_date).total_seconds() / 86400
+    mid_date = start_date + (end_date - start_date) / 2  # Calculate once for all comparisons
+    results = []
+    visited = set()
+
+    for ep in entry_points:
+        unit_id = str(ep["id"])
+        visited.add(unit_id)
+
+        # Calculate temporal proximity using the most relevant date
+        # Priority: occurred_start/end (event time) > mentioned_at (mention time)
+        best_date = None
+        if ep["occurred_start"] is not None and ep["occurred_end"] is not None:
+            # Use midpoint of occurred range
+            best_date = ep["occurred_start"] + (ep["occurred_end"] - ep["occurred_start"]) / 2
+        elif ep["occurred_start"] is not None:
+            best_date = ep["occurred_start"]
+        elif ep["occurred_end"] is not None:
+            best_date = ep["occurred_end"]
+        elif ep["mentioned_at"] is not None:
+            best_date = ep["mentioned_at"]
+
+        # Temporal proximity score (closer to range center = higher score)
+        if best_date:
+            days_from_mid = abs((best_date - mid_date).total_seconds() / 86400)
+            temporal_proximity = 1.0 - min(days_from_mid / (total_days / 2), 1.0) if total_days > 0 else 1.0
+        else:
+            temporal_proximity = 0.5  # Fallback if no dates (shouldn't happen due to WHERE clause)
+
+        # Create RetrievalResult with temporal scores
+        ep_result = RetrievalResult.from_db_row(dict(ep))
+        ep_result.temporal_score = temporal_proximity
+        ep_result.temporal_proximity = temporal_proximity
+        results.append(ep_result)
+
+    # Spread through temporal links using BATCHED neighbor fetching
+    # Map node_id -> (semantic_sim, temporal_score) for propagation
+    node_scores = {str(ep["id"]): (ep["similarity"], 1.0) for ep in entry_points}
+    frontier = list(node_scores.keys())  # Current batch of nodes to expand
+    budget_remaining = budget - len(entry_points)
+    batch_size = 20  # Process this many nodes per DB query
+
+    while frontier and budget_remaining > 0:
+        # Take a batch from frontier
+        batch_ids = frontier[:batch_size]
+        frontier = frontier[batch_size:]
+
+        # Batch fetch all neighbors for this batch of nodes
+        neighbors = await conn.fetch(
+            f"""
+            SELECT mu.id, mu.text, mu.context, mu.event_date, mu.occurred_start, mu.occurred_end, mu.mentioned_at, mu.embedding, mu.fact_type, mu.document_id, mu.chunk_id,
+                   ml.weight, ml.link_type, ml.from_unit_id,
+                   1 - (mu.embedding <=> $1::vector) AS similarity
+            FROM {fq_table("memory_links")} ml
+            JOIN {fq_table("memory_units")} mu ON ml.to_unit_id = mu.id
+            WHERE ml.from_unit_id = ANY($2::uuid[])
+              AND ml.link_type IN ('temporal', 'causes', 'caused_by', 'enables', 'prevents')
+              AND ml.weight >= 0.1
+              AND mu.fact_type = $3
+              AND mu.embedding IS NOT NULL
+              AND (1 - (mu.embedding <=> $1::vector)) >= $4
+            ORDER BY ml.weight DESC
+            LIMIT $5
+            """,
+            query_emb_str,
+            batch_ids,
+            fact_type,
+            semantic_threshold,
+            batch_size * 10,  # Allow up to 10 neighbors per node in batch
+        )
+
+        for n in neighbors:
+            neighbor_id = str(n["id"])
+            if neighbor_id in visited:
+                continue
+
+            visited.add(neighbor_id)
+            budget_remaining -= 1
+
+            # Get parent's scores for propagation
+            parent_id = str(n["from_unit_id"])
+            _, parent_temporal_score = node_scores.get(parent_id, (0.5, 0.5))
+
+            # Calculate temporal score for neighbor using best available date
+            neighbor_best_date = None
+            if n["occurred_start"] is not None and n["occurred_end"] is not None:
+                neighbor_best_date = n["occurred_start"] + (n["occurred_end"] - n["occurred_start"]) / 2
+            elif n["occurred_start"] is not None:
+                neighbor_best_date = n["occurred_start"]
+            elif n["occurred_end"] is not None:
+                neighbor_best_date = n["occurred_end"]
+            elif n["mentioned_at"] is not None:
+                neighbor_best_date = n["mentioned_at"]
+
+            if neighbor_best_date:
+                days_from_mid = abs((neighbor_best_date - mid_date).total_seconds() / 86400)
+                neighbor_temporal_proximity = (
+                    1.0 - min(days_from_mid / (total_days / 2), 1.0) if total_days > 0 else 1.0
+                )
+            else:
+                neighbor_temporal_proximity = 0.3  # Lower score if no temporal data
+
+            # Boost causal links (same as graph retrieval)
+            link_type = n["link_type"]
+            if link_type in ("causes", "caused_by"):
+                causal_boost = 2.0
+            elif link_type in ("enables", "prevents"):
+                causal_boost = 1.5
+            else:
+                causal_boost = 1.0
+
+            # Propagate temporal score through links (decay, with causal boost)
+            propagated_temporal = parent_temporal_score * n["weight"] * causal_boost * 0.7
+
+            # Combined temporal score
+            combined_temporal = max(neighbor_temporal_proximity, propagated_temporal)
+
+            # Create RetrievalResult with temporal scores
+            neighbor_result = RetrievalResult.from_db_row(dict(n))
+            neighbor_result.temporal_score = combined_temporal
+            neighbor_result.temporal_proximity = neighbor_temporal_proximity
+            results.append(neighbor_result)
+
+            # Track scores for propagation and add to frontier
+            if budget_remaining > 0 and combined_temporal > 0.2:
+                node_scores[neighbor_id] = (n["similarity"], combined_temporal)
+                frontier.append(neighbor_id)
+
+            if budget_remaining <= 0:
+                break
+
+    return results
+
+
+async def retrieve_parallel(
+    pool,
+    query_text: str,
+    query_embedding_str: str,
+    bank_id: str,
+    fact_type: str,
+    thinking_budget: int,
+    question_date: datetime | None = None,
+    query_analyzer: Optional["QueryAnalyzer"] = None,
+    graph_retriever: GraphRetriever | None = None,
+    temporal_constraint: tuple | None = None,  # Pre-extracted temporal constraint
+    tags: list[str] | None = None,  # Visibility scope tags for filtering
+) -> ParallelRetrievalResult:
+    """
+    Run 3-way or 4-way parallel retrieval (adds temporal if detected).
+
+    Args:
+        pool: Database connection pool
+        query_text: Query text
+        query_embedding_str: Query embedding as string
+        bank_id: Bank ID
+        fact_type: Fact type to filter
+        thinking_budget: Budget for graph traversal and retrieval limits
+        question_date: Optional date when question was asked (for temporal filtering)
+        query_analyzer: Query analyzer to use (defaults to TransformerQueryAnalyzer)
+        graph_retriever: Graph retrieval strategy (defaults to configured retriever)
+        temporal_constraint: Pre-extracted temporal constraint (optional)
+        tags: Optional list of tags for visibility filtering (OR matching)
+
+    Returns:
+        ParallelRetrievalResult with semantic, bm25, graph, temporal results and timings
+    """
+    retriever = graph_retriever or get_default_graph_retriever()
+
+    # Use optimized parallel path for MPFP and LinkExpansion (runs all methods truly in parallel)
+    # BFS uses legacy path that extracts temporal constraint upfront
+    if retriever.name in ("mpfp", "link_expansion"):
+        return await _retrieve_parallel_mpfp(
+            pool,
+            query_text,
+            query_embedding_str,
+            bank_id,
+            fact_type,
+            thinking_budget,
+            temporal_constraint,
+            retriever,
+            question_date,
+            query_analyzer,
+            tags=tags,
+        )
+    else:
+        # For BFS, extract temporal constraint upfront (legacy path)
+        if temporal_constraint is None:
+            from .temporal_extraction import extract_temporal_constraint
+
+            temporal_constraint = extract_temporal_constraint(
+                query_text, reference_date=question_date, analyzer=query_analyzer
+            )
+        return await _retrieve_parallel_bfs(
+            pool,
+            query_text,
+            query_embedding_str,
+            bank_id,
+            fact_type,
+            thinking_budget,
+            temporal_constraint,
+            retriever,
+            tags=tags,
+        )
+
+
+@dataclass
+class _TimedResult:
+    """Internal result with timing."""
+
+    results: list[RetrievalResult]
+    time: float
+    conn_wait: float = 0.0  # Connection acquisition wait time
+
+
+async def _retrieve_parallel_mpfp(
+    pool,
+    query_text: str,
+    query_embedding_str: str,
+    bank_id: str,
+    fact_type: str,
+    thinking_budget: int,
+    temporal_constraint: tuple | None,
+    retriever: GraphRetriever,
+    question_date: datetime | None = None,
+    query_analyzer=None,
+    tags: list[str] | None = None,
+) -> ParallelRetrievalResult:
+    """
+    MPFP retrieval with true parallelization.
+
+    All methods run independently in parallel:
+    - Semantic: vector similarity search
+    - BM25: keyword search
+    - Graph: MPFP traversal (does its own semantic seeds internally)
+    - Temporal: date extraction (if needed) + date-range search
+
+    Temporal extraction runs IN PARALLEL with other retrievals, so even if
+    dateparser is slow, it doesn't block semantic/BM25/graph.
+    """
+    import time
+
+    async def run_semantic() -> _TimedResult:
+        """Independent semantic retrieval."""
+        start = time.time()
+        acquire_start = time.time()
+        async with acquire_with_retry(pool) as conn:
+            conn_wait = time.time() - acquire_start
+            results = await retrieve_semantic(
+                conn, query_embedding_str, bank_id, fact_type, limit=thinking_budget, tags=tags
+            )
+        return _TimedResult(results, time.time() - start, conn_wait)
+
+    async def run_bm25() -> _TimedResult:
+        """Independent BM25 retrieval."""
+        start = time.time()
+        acquire_start = time.time()
+        async with acquire_with_retry(pool) as conn:
+            conn_wait = time.time() - acquire_start
+            results = await retrieve_bm25(conn, query_text, bank_id, fact_type, limit=thinking_budget, tags=tags)
+        return _TimedResult(results, time.time() - start, conn_wait)
+
+    async def run_graph() -> tuple[list[RetrievalResult], float, MPFPTimings | None]:
+        """Independent graph retrieval - does its own semantic seeds."""
+        start = time.time()
+
+        # MPFP does its own semantic seeds via _find_semantic_seeds
+        # Note: temporal_seeds not used here to avoid dependency on temporal extraction
+        results, mpfp_timing = await retriever.retrieve(
+            pool=pool,
+            query_embedding_str=query_embedding_str,
+            bank_id=bank_id,
+            fact_type=fact_type,
+            budget=thinking_budget,
+            query_text=query_text,
+            semantic_seeds=None,  # Let MPFP find its own seeds
+            temporal_seeds=None,  # Don't wait for temporal extraction
+            tags=tags,
+        )
+        return results, time.time() - start, mpfp_timing
+
+    @dataclass
+    class _TemporalWithConstraint:
+        """Temporal results with the extracted constraint."""
+
+        results: list[RetrievalResult]
+        time: float
+        constraint: tuple | None
+        extraction_time: float  # Time spent in query analyzer (dateparser)
+        conn_wait: float = 0.0  # Connection acquisition wait time
+
+    async def run_temporal_with_extraction() -> _TemporalWithConstraint:
+        """
+        Extract temporal constraint AND run temporal retrieval.
+
+        This runs in parallel with semantic/BM25/graph, so dateparser
+        latency doesn't block other retrievals.
+        """
+        start = time.time()
+
+        # Use pre-provided constraint if available
+        tc = temporal_constraint
+        extraction_time = 0.0
+
+        # Otherwise extract from query (this is the potentially slow dateparser call)
+        if tc is None:
+            from .temporal_extraction import extract_temporal_constraint
+
+            extraction_start = time.time()
+            tc = extract_temporal_constraint(query_text, reference_date=question_date, analyzer=query_analyzer)
+            extraction_time = time.time() - extraction_start
+
+        # If no temporal constraint found, return empty (but still report extraction time)
+        if tc is None:
+            return _TemporalWithConstraint([], time.time() - start, None, extraction_time, 0.0)
+
+        # Run temporal retrieval with the extracted constraint
+        tc_start, tc_end = tc
+        acquire_start = time.time()
+        async with acquire_with_retry(pool) as conn:
+            conn_wait = time.time() - acquire_start
+            results = await retrieve_temporal(
+                conn,
+                query_embedding_str,
+                bank_id,
+                fact_type,
+                tc_start,
+                tc_end,
+                budget=thinking_budget,
+                semantic_threshold=0.1,
+            )
+        return _TemporalWithConstraint(results, time.time() - start, tc, extraction_time, conn_wait)
+
+    # Run ALL methods in parallel (including temporal extraction!)
+    semantic_result, bm25_result, graph_result, temporal_result = await asyncio.gather(
+        run_semantic(),
+        run_bm25(),
+        run_graph(),
+        run_temporal_with_extraction(),
+    )
+    graph_results, graph_time, mpfp_timing = graph_result
+
+    # Compute max connection wait across all methods (graph handles its own connections)
+    max_conn_wait = max(semantic_result.conn_wait, bm25_result.conn_wait, temporal_result.conn_wait)
+
+    return ParallelRetrievalResult(
+        semantic=semantic_result.results,
+        bm25=bm25_result.results,
+        graph=graph_results,
+        temporal=temporal_result.results if temporal_result.results else None,
+        timings={
+            "semantic": semantic_result.time,
+            "bm25": bm25_result.time,
+            "graph": graph_time,
+            "temporal": temporal_result.time,
+            "temporal_extraction": temporal_result.extraction_time,
+        },
+        temporal_constraint=temporal_result.constraint,
+        mpfp_timings=[mpfp_timing] if mpfp_timing else [],
+        max_conn_wait=max_conn_wait,
+    )
+
+
+async def _get_temporal_entry_points(
+    conn,
+    query_embedding_str: str,
+    bank_id: str,
+    fact_type: str,
+    start_date: datetime,
+    end_date: datetime,
+    limit: int = 20,
+    semantic_threshold: float = 0.1,
+) -> list[RetrievalResult]:
+    """Get temporal entry points (facts in date range with semantic relevance)."""
+
+    if start_date.tzinfo is None:
+        start_date = start_date.replace(tzinfo=UTC)
+    if end_date.tzinfo is None:
+        end_date = end_date.replace(tzinfo=UTC)
+
+    rows = await conn.fetch(
+        f"""
+        SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at,
+               embedding, fact_type, document_id, chunk_id,
+               1 - (embedding <=> $1::vector) AS similarity
+        FROM {fq_table("memory_units")}
+        WHERE bank_id = $2
+          AND fact_type = $3
+          AND embedding IS NOT NULL
+          AND (
+              (occurred_start IS NOT NULL AND occurred_end IS NOT NULL
+               AND occurred_start <= $5 AND occurred_end >= $4)
+              OR (mentioned_at IS NOT NULL AND mentioned_at BETWEEN $4 AND $5)
+              OR (occurred_start IS NOT NULL AND occurred_start BETWEEN $4 AND $5)
+              OR (occurred_end IS NOT NULL AND occurred_end BETWEEN $4 AND $5)
+          )
+          AND (1 - (embedding <=> $1::vector)) >= $6
+        ORDER BY COALESCE(occurred_start, mentioned_at, occurred_end) DESC,
+                 (embedding <=> $1::vector) ASC
+        LIMIT $7
+        """,
+        query_embedding_str,
+        bank_id,
+        fact_type,
+        start_date,
+        end_date,
+        semantic_threshold,
+        limit,
+    )
+
+    results = []
+    total_days = max((end_date - start_date).total_seconds() / 86400, 1)
+    mid_date = start_date + (end_date - start_date) / 2
+
+    for row in rows:
+        result = RetrievalResult.from_db_row(dict(row))
+
+        # Calculate temporal proximity score
+        best_date = None
+        if row["occurred_start"] and row["occurred_end"]:
+            best_date = row["occurred_start"] + (row["occurred_end"] - row["occurred_start"]) / 2
+        elif row["occurred_start"]:
+            best_date = row["occurred_start"]
+        elif row["occurred_end"]:
+            best_date = row["occurred_end"]
+        elif row["mentioned_at"]:
+            best_date = row["mentioned_at"]
+
+        if best_date:
+            days_from_mid = abs((best_date - mid_date).total_seconds() / 86400)
+            result.temporal_proximity = 1.0 - min(days_from_mid / (total_days / 2), 1.0)
+        else:
+            result.temporal_proximity = 0.5
+
+        result.temporal_score = result.temporal_proximity
+        results.append(result)
+
+    return results
+
+
+async def _retrieve_parallel_bfs(
+    pool,
+    query_text: str,
+    query_embedding_str: str,
+    bank_id: str,
+    fact_type: str,
+    thinking_budget: int,
+    temporal_constraint: tuple | None,
+    retriever: GraphRetriever,
+    tags: list[str] | None = None,
+) -> ParallelRetrievalResult:
+    """BFS retrieval: all methods run in parallel (original behavior)."""
+    import time
+
+    async def run_semantic() -> _TimedResult:
+        start = time.time()
+        async with acquire_with_retry(pool) as conn:
+            results = await retrieve_semantic(
+                conn, query_embedding_str, bank_id, fact_type, limit=thinking_budget, tags=tags
+            )
+        return _TimedResult(results, time.time() - start)
+
+    async def run_bm25() -> _TimedResult:
+        start = time.time()
+        async with acquire_with_retry(pool) as conn:
+            results = await retrieve_bm25(conn, query_text, bank_id, fact_type, limit=thinking_budget, tags=tags)
+        return _TimedResult(results, time.time() - start)
+
+    async def run_graph() -> _TimedResult:
+        start = time.time()
+        results, _ = await retriever.retrieve(
+            pool=pool,
+            query_embedding_str=query_embedding_str,
+            bank_id=bank_id,
+            fact_type=fact_type,
+            budget=thinking_budget,
+            query_text=query_text,
+            tags=tags,
+        )
+        return _TimedResult(results, time.time() - start)
+
+    async def run_temporal(tc_start, tc_end) -> _TimedResult:
+        start = time.time()
+        async with acquire_with_retry(pool) as conn:
+            results = await retrieve_temporal(
+                conn,
+                query_embedding_str,
+                bank_id,
+                fact_type,
+                tc_start,
+                tc_end,
+                budget=thinking_budget,
+                semantic_threshold=0.1,
+                tags=tags,
+            )
+        return _TimedResult(results, time.time() - start)
+
+    if temporal_constraint:
+        tc_start, tc_end = temporal_constraint
+        semantic_r, bm25_r, graph_r, temporal_r = await asyncio.gather(
+            run_semantic(),
+            run_bm25(),
+            run_graph(),
+            run_temporal(tc_start, tc_end),
+        )
+        return ParallelRetrievalResult(
+            semantic=semantic_r.results,
+            bm25=bm25_r.results,
+            graph=graph_r.results,
+            temporal=temporal_r.results,
+            timings={
+                "semantic": semantic_r.time,
+                "bm25": bm25_r.time,
+                "graph": graph_r.time,
+                "temporal": temporal_r.time,
+            },
+            temporal_constraint=temporal_constraint,
+        )
+    else:
+        semantic_r, bm25_r, graph_r = await asyncio.gather(
+            run_semantic(),
+            run_bm25(),
+            run_graph(),
+        )
+        return ParallelRetrievalResult(
+            semantic=semantic_r.results,
+            bm25=bm25_r.results,
+            graph=graph_r.results,
+            temporal=None,
+            timings={
+                "semantic": semantic_r.time,
+                "bm25": bm25_r.time,
+                "graph": graph_r.time,
+            },
+            temporal_constraint=None,
+        )
+
+
 async def retrieve_all_fact_types_parallel(
     pool,
     query_text: str,

hindsight-api/hindsight_api/engine/utils.py

@@ -19,7 +19,6 @@ async def extract_facts(
     context: str = "",
     llm_config: "LLMConfig" = None,
     agent_name: str = None,
-    config=None,
 ) -> tuple[list["Fact"], list[tuple[str, int]]]:
     """
     Extract semantic facts from text using LLM.
@@ -36,7 +35,6 @@ async def extract_facts(
         context: Context about the conversation/document
         llm_config: LLM configuration to use
         agent_name: Optional agent name to help identify agent-related facts
-        config: HindsightConfig to use (defaults to global config if not provided)
 
     Returns:
         Tuple of (facts, chunks) where:
@@ -49,19 +47,12 @@ async def extract_facts(
     if not text or not text.strip():
         return [], []
 
-    # Use provided config or fall back to global config
-    if config is None:
-        from ..config import _get_raw_config
-
-        config = _get_raw_config()
-
     facts, chunks, _ = await extract_facts_from_text(
         text,
         event_date,
+        context=context,
         llm_config=llm_config,
         agent_name=agent_name,
-        config=config,
-        context=context,
     )
 
     if not facts:

hindsight-api/hindsight_api/extensions/context.py

@@ -96,13 +96,7 @@ class DefaultExtensionContext(ExtensionContext):
 
     async def run_migration(self, schema: str) -> None:
         """Run migrations for a specific schema."""
-        from hindsight_api.config import get_config
-        from hindsight_api.migrations import (
-            ensure_embedding_dimension,
-            ensure_text_search_extension,
-            ensure_vector_extension,
-            run_migrations,
-        )
+        from hindsight_api.migrations import ensure_embedding_dimension, run_migrations
 
         # Prefer getting URL from memory engine (handles pg0 case where URL is set after init)
         db_url = self._database_url
@@ -113,9 +107,6 @@ class DefaultExtensionContext(ExtensionContext):
 
         run_migrations(db_url, schema=schema)
 
-        # Get config for vector extension setting
-        config = get_config()
-
         # Ensure embedding column dimension matches the model's dimension
         # This is needed because migrations create columns with default dimension
         if self._memory_engine is not None:
@@ -123,15 +114,7 @@ class DefaultExtensionContext(ExtensionContext):
             if embeddings is not None:
                 dimension = getattr(embeddings, "dimension", None)
                 if dimension is not None:
-                    ensure_embedding_dimension(
-                        db_url, dimension, schema=schema, vector_extension=config.vector_extension
-                    )
-
-        # Ensure vector indexes match the configured extension
-        ensure_vector_extension(db_url, vector_extension=config.vector_extension, schema=schema)
-
-        # Ensure text search columns/indexes match the configured extension
-        ensure_text_search_extension(db_url, text_search_extension=config.text_search_extension, schema=schema)
+                    ensure_embedding_dimension(db_url, dimension, schema=schema)
 
     def get_memory_engine(self) -> "MemoryEngineInterface":
         """Get the memory engine interface."""

hindsight-api/hindsight_api/extensions/tenant.py

@@ -2,7 +2,6 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any
 
 from hindsight_api.extensions.base import Extension
 from hindsight_api.models import RequestContext
@@ -89,54 +88,6 @@ class TenantExtension(Extension, ABC):
         """
         ...
 
-    async def get_tenant_config(self, context: RequestContext) -> dict[str, Any]:
-        """
-        Get tenant-specific configuration overrides.
-
-        This method is called during hierarchical configuration resolution to get
-        tenant-level config overrides. The returned dict should contain Python field
-        names (lowercase snake_case) as keys, not environment variable names.
-
-        Example:
-            {"llm_model": "gpt-4", "retain_extraction_mode": "verbose"}
-
-        The default implementation returns an empty dict (no tenant-specific config).
-        Override this method in custom extensions to provide tenant-specific configuration.
-
-        Args:
-            context: The request context containing tenant information.
-
-        Returns:
-            Dict of config field names to values (only configurable fields).
-            Empty dict if no tenant-specific config.
-        """
-        return {}
-
-    async def get_allowed_config_fields(self, context: RequestContext, bank_id: str) -> set[str] | None:
-        """
-        Get set of config fields that this tenant/bank is allowed to modify.
-
-        This method controls which configurable fields can be modified via the bank config API.
-        It enables fine-grained permission control per tenant or per bank.
-
-        Examples:
-            - Return None: Allow all configurable fields (default)
-            - Return {"retain_chunk_size", "retain_custom_instructions"}: Allow only these fields
-            - Return set(): Allow no modifications (read-only)
-
-        The default implementation returns None (all configurable fields allowed).
-        Override this method in custom extensions to implement custom permission logic.
-
-        Args:
-            context: The request context containing tenant information.
-            bank_id: The bank identifier for per-bank permissions.
-
-        Returns:
-            Set of allowed field names, or None to allow all configurable fields.
-            Returned fields must be a subset of HindsightConfig.get_configurable_fields().
-        """
-        return None
-
     async def authenticate_mcp(self, context: RequestContext) -> TenantContext:
         """
         Authenticate MCP requests.

hindsight-api/hindsight_api/main.py

@@ -23,7 +23,7 @@ import uvicorn
 from . import MemoryEngine, __version__
 from .api import create_app
 from .banner import print_banner
-from .config import DEFAULT_WORKERS, ENV_WORKERS, HindsightConfig, _get_raw_config
+from .config import DEFAULT_WORKERS, ENV_WORKERS, HindsightConfig, get_config
 from .daemon import (
     DEFAULT_DAEMON_PORT,
     DEFAULT_IDLE_TIMEOUT,
@@ -68,7 +68,7 @@ def main():
     global _memory
 
     # Load configuration from environment (for CLI args defaults)
-    config = _get_raw_config()
+    config = get_config()
 
     parser = argparse.ArgumentParser(
         prog="hindsight-api",
@@ -155,8 +155,6 @@ def main():
         config = HindsightConfig(
             database_url=config.database_url,
             database_schema=config.database_schema,
-            vector_extension=config.vector_extension,
-            text_search_extension=config.text_search_extension,
             llm_provider=config.llm_provider,
             llm_api_key=config.llm_api_key,
             llm_model=config.llm_model,
@@ -208,9 +206,6 @@ def main():
             embeddings_litellm_api_base=config.embeddings_litellm_api_base,
             embeddings_litellm_api_key=config.embeddings_litellm_api_key,
             embeddings_litellm_model=config.embeddings_litellm_model,
-            embeddings_litellm_sdk_api_key=config.embeddings_litellm_sdk_api_key,
-            embeddings_litellm_sdk_model=config.embeddings_litellm_sdk_model,
-            embeddings_litellm_sdk_api_base=config.embeddings_litellm_sdk_api_base,
             reranker_provider=config.reranker_provider,
             reranker_local_model=config.reranker_local_model,
             reranker_local_force_cpu=config.reranker_local_force_cpu,
@@ -226,16 +221,11 @@ def main():
             reranker_litellm_api_base=config.reranker_litellm_api_base,
             reranker_litellm_api_key=config.reranker_litellm_api_key,
             reranker_litellm_model=config.reranker_litellm_model,
-            reranker_litellm_sdk_api_key=config.reranker_litellm_sdk_api_key,
-            reranker_litellm_sdk_model=config.reranker_litellm_sdk_model,
-            reranker_litellm_sdk_api_base=config.reranker_litellm_sdk_api_base,
             host=args.host,
             port=args.port,
-            base_path=config.base_path,
             log_level=args.log_level,
             log_format=config.log_format,
             mcp_enabled=config.mcp_enabled,
-            enable_bank_config_api=config.enable_bank_config_api,
             graph_retriever=config.graph_retriever,
             mpfp_top_k_neighbors=config.mpfp_top_k_neighbors,
             recall_max_concurrent=config.recall_max_concurrent,
@@ -245,7 +235,6 @@ def main():
             retain_extract_causal_links=config.retain_extract_causal_links,
             retain_extraction_mode=config.retain_extraction_mode,
             retain_custom_instructions=config.retain_custom_instructions,
-            retain_batch_tokens=config.retain_batch_tokens,
             enable_observations=config.enable_observations,
             consolidation_batch_size=config.consolidation_batch_size,
             consolidation_max_tokens=config.consolidation_max_tokens,

hindsight-api/hindsight_api/migrations.py

@@ -33,41 +33,6 @@ logger = logging.getLogger(__name__)
 MIGRATION_LOCK_ID = 123456789
 
 
-def _detect_vector_extension(conn, vector_extension: str = "pgvector") -> str:
-    """
-    Validate vector extension: 'vchord' or 'pgvector'.
-
-    Args:
-        conn: SQLAlchemy connection object
-        vector_extension: Configured extension ("pgvector" or "vchord")
-
-    Returns:
-        "vchord" or "pgvector"
-
-    Raises:
-        RuntimeError: If configured extension is not installed
-    """
-    # Verify the configured extension is installed
-    if vector_extension == "vchord":
-        vchord_check = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vchord'")).scalar()
-        if not vchord_check:
-            raise RuntimeError(
-                "Configured vector extension 'vchord' not found. Install it with: CREATE EXTENSION vchord CASCADE;"
-            )
-        logger.debug("Using configured vector extension: vchord")
-        return "vchord"
-    elif vector_extension == "pgvector":
-        pgvector_check = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vector'")).scalar()
-        if not pgvector_check:
-            raise RuntimeError(
-                "Configured vector extension 'pgvector' not found. Install it with: CREATE EXTENSION vector;"
-            )
-        logger.debug("Using configured vector extension: pgvector")
-        return "pgvector"
-    else:
-        raise ValueError(f"Invalid vector_extension: {vector_extension}. Must be 'pgvector' or 'vchord'")
-
-
 def _get_schema_lock_id(schema: str) -> int:
     """
     Generate a unique advisory lock ID for a schema.
@@ -359,7 +324,6 @@ def ensure_embedding_dimension(
     database_url: str,
     required_dimension: int,
     schema: str | None = None,
-    vector_extension: str = "pgvector",
 ) -> None:
     """
     Ensure the embedding column dimension matches the model's dimension.
@@ -374,7 +338,6 @@ def ensure_embedding_dimension(
         database_url: SQLAlchemy database URL
         required_dimension: The embedding dimension required by the model
         schema: Target PostgreSQL schema name (None for public)
-        vector_extension: Configured vector extension ("pgvector" or "vchord")
 
     Raises:
         RuntimeError: If dimension mismatch with existing data
@@ -398,10 +361,6 @@ def ensure_embedding_dimension(
             logger.debug(f"memory_units table does not exist in schema '{schema_name}', skipping dimension check")
             return
 
-        # Detect which vector extension is available
-        vector_ext = _detect_vector_extension(conn, vector_extension)
-        logger.info(f"Using vector extension: {vector_ext}")
-
         # Get current column dimension from pg_attribute
         # pgvector stores dimension in atttypmod
         current_dim = conn.execute(
@@ -449,7 +408,8 @@ def ensure_embedding_dimension(
         # Table is empty, safe to alter column
         logger.info(f"Altering embedding column dimension from {current_dimension} to {required_dimension}")
 
-        # Drop existing vector index (works for both HNSW and vchordrq)
+        # Drop the HNSW index on embedding column if it exists
+        # Only drop indexes that use 'hnsw' and reference the 'embedding' column
         conn.execute(
             text(f"""
                 DO $$
@@ -459,7 +419,7 @@ def ensure_embedding_dimension(
                         SELECT indexname FROM pg_indexes
                         WHERE schemaname = '{schema_name}'
                           AND tablename = 'memory_units'
-                          AND (indexdef LIKE '%hnsw%' OR indexdef LIKE '%vchordrq%')
+                          AND indexdef LIKE '%hnsw%'
                           AND indexdef LIKE '%embedding%'
                     LOOP
                         EXECUTE 'DROP INDEX IF EXISTS {schema_name}.' || idx_name;
@@ -474,410 +434,15 @@ def ensure_embedding_dimension(
         )
         conn.commit()
 
-        # Recreate index with appropriate type based on detected extension
-        if vector_ext == "vchord":
-            conn.execute(
-                text(f"""
-                    CREATE INDEX IF NOT EXISTS idx_memory_units_embedding_vchordrq
-                    ON {schema_name}.memory_units
-                    USING vchordrq (embedding vector_l2_ops)
-                """)
-            )
-            logger.info(f"Created vchordrq index for {required_dimension}-dimensional embeddings")
-        else:  # pgvector
-            conn.execute(
-                text(f"""
-                    CREATE INDEX IF NOT EXISTS idx_memory_units_embedding_hnsw
-                    ON {schema_name}.memory_units
-                    USING hnsw (embedding vector_cosine_ops)
-                    WITH (m = 16, ef_construction = 64)
-                """)
-            )
-            logger.info(f"Created HNSW index for {required_dimension}-dimensional embeddings")
+        # Recreate the HNSW index
+        conn.execute(
+            text(f"""
+                CREATE INDEX IF NOT EXISTS idx_memory_units_embedding_hnsw
+                ON {schema_name}.memory_units
+                USING hnsw (embedding vector_cosine_ops)
+                WITH (m = 16, ef_construction = 64)
+            """)
+        )
         conn.commit()
 
         logger.info(f"Successfully changed embedding dimension to {required_dimension}")
-
-
-def ensure_vector_extension(
-    database_url: str,
-    vector_extension: str = "pgvector",
-    schema: str | None = None,
-) -> None:
-    """
-    Ensure the vector indexes match the configured vector extension.
-
-    This function checks the current vector index type in the database
-    and adjusts it if necessary:
-    - If index type matches configured extension: no action needed
-    - If they differ and tables are empty: drop old indexes, recreate with new type
-    - If they differ and tables have data: raise error with migration guidance
-
-    Args:
-        database_url: SQLAlchemy database URL
-        vector_extension: Configured vector extension ("pgvector" or "vchord")
-        schema: Target PostgreSQL schema name (None for public)
-
-    Raises:
-        RuntimeError: If extension mismatch with existing data
-    """
-    schema_name = schema or "public"
-
-    engine = create_engine(database_url)
-    with engine.connect() as conn:
-        # Detect which vector extension should be used
-        target_ext = _detect_vector_extension(conn, vector_extension)
-        logger.info(f"Target vector extension: {target_ext}")
-
-        # Tables with vector indexes to check
-        tables_to_check = [
-            ("memory_units", "idx_memory_units_embedding"),
-            ("learnings", "idx_learnings_embedding"),
-            ("pinned_reflections", "idx_pinned_reflections_embedding"),
-        ]
-
-        # Determine target index type
-        target_index_type = "vchordrq" if target_ext == "vchord" else "hnsw"
-
-        mismatched_tables = []
-        tables_with_data = []
-
-        for table_name, index_name in tables_to_check:
-            # Check if table exists
-            table_exists = conn.execute(
-                text("""
-                    SELECT EXISTS (
-                        SELECT 1 FROM information_schema.tables
-                        WHERE table_schema = :schema AND table_name = :table_name
-                    )
-                """),
-                {"schema": schema_name, "table_name": table_name},
-            ).scalar()
-
-            if not table_exists:
-                logger.debug(f"Table {table_name} does not exist in schema '{schema_name}', skipping")
-                continue
-
-            # Check current index type by querying pg_indexes
-            current_index_info = conn.execute(
-                text("""
-                    SELECT indexdef
-                    FROM pg_indexes
-                    WHERE schemaname = :schema
-                      AND tablename = :table_name
-                      AND indexname LIKE :index_pattern
-                """),
-                {"schema": schema_name, "table_name": table_name, "index_pattern": "%embedding%"},
-            ).fetchone()
-
-            if not current_index_info:
-                logger.warning(f"No embedding index found for {table_name}, will create it")
-                mismatched_tables.append((table_name, index_name, None))
-                continue
-
-            indexdef = current_index_info[0].lower()
-            if "vchordrq" in indexdef:
-                current_index_type = "vchordrq"
-            elif "hnsw" in indexdef:
-                current_index_type = "hnsw"
-            else:
-                logger.warning(f"Unknown index type for {table_name}: {indexdef}")
-                continue
-
-            # Check if index type matches target
-            if current_index_type != target_index_type:
-                logger.info(
-                    f"Index type mismatch on {table_name}: current={current_index_type}, target={target_index_type}"
-                )
-                mismatched_tables.append((table_name, index_name, current_index_type))
-
-                # Check if table has data
-                row_count = conn.execute(
-                    text(f"SELECT COUNT(*) FROM {schema_name}.{table_name} WHERE embedding IS NOT NULL")
-                ).scalar()
-
-                if row_count > 0:
-                    tables_with_data.append((table_name, row_count))
-            else:
-                logger.debug(f"Index type OK for {table_name}: {current_index_type}")
-
-        # If no mismatches, we're done
-        if not mismatched_tables:
-            logger.debug(f"All vector indexes match configured extension: {target_ext}")
-            return
-
-        # If there's data in any mismatched table, raise error
-        if tables_with_data:
-            table_list = ", ".join([f"{table}({count} rows)" for table, count in tables_with_data])
-            raise RuntimeError(
-                f"Cannot change vector extension from {current_index_type} to {target_index_type}: "
-                f"the following tables contain data: {table_list}. "
-                f"To change vector extension, you must either:\n"
-                f"  1. Re-embed all data: DELETE FROM {schema_name}.memory_units; "
-                f"DELETE FROM {schema_name}.learnings; DELETE FROM {schema_name}.pinned_reflections; then restart\n"
-                f"  2. Use the current vector extension (set HINDSIGHT_API_VECTOR_EXTENSION='{current_index_type.replace('vchordrq', 'vchord').replace('hnsw', 'pgvector')}')"
-            )
-
-        # Tables are empty, safe to recreate indexes
-        logger.info(f"Recreating vector indexes for {target_ext}")
-
-        for table_name, index_name, current_type in mismatched_tables:
-            # Drop existing index if it exists
-            if current_type:
-                logger.info(f"Dropping {current_type} index on {table_name}")
-                conn.execute(text(f"DROP INDEX IF EXISTS {schema_name}.{index_name}"))
-
-            # Create new index with appropriate type
-            if target_ext == "vchord":
-                logger.info(f"Creating vchordrq index on {table_name}")
-                conn.execute(
-                    text(f"""
-                        CREATE INDEX IF NOT EXISTS {index_name}
-                        ON {schema_name}.{table_name}
-                        USING vchordrq (embedding vector_l2_ops)
-                    """)
-                )
-            else:  # pgvector
-                logger.info(f"Creating HNSW index on {table_name}")
-                conn.execute(
-                    text(f"""
-                        CREATE INDEX IF NOT EXISTS {index_name}
-                        ON {schema_name}.{table_name}
-                        USING hnsw (embedding vector_cosine_ops)
-                        WITH (m = 16, ef_construction = 64)
-                    """)
-                )
-
-        conn.commit()
-        logger.info(f"Successfully migrated vector indexes to {target_ext}")
-
-
-def ensure_text_search_extension(
-    database_url: str,
-    text_search_extension: str = "native",
-    schema: str | None = None,
-) -> None:
-    """
-    Ensure the text search columns and indexes match the configured extension.
-
-    This function checks the current search_vector column type and index type
-    in the database and adjusts them if necessary:
-    - If they match configured extension: no action needed
-    - If they differ and tables are empty: drop old column/index, recreate with new type
-    - If they differ and tables have data: raise error with migration guidance
-
-    Args:
-        database_url: SQLAlchemy database URL
-        text_search_extension: Configured text search extension ("native" or "vchord")
-        schema: Target PostgreSQL schema name (None for public)
-
-    Raises:
-        RuntimeError: If extension mismatch with existing data
-    """
-    schema_name = schema or "public"
-
-    engine = create_engine(database_url)
-    with engine.connect() as conn:
-        # Tables with search_vector columns to check
-        tables_to_check = [
-            "memory_units",
-            "reflections",  # Renamed from pinned_reflections in p1k2l3m4n5o6 migration
-        ]
-
-        # Determine target column type and index type
-        if text_search_extension == "vchord":
-            target_column_type = "bm25vector"
-            target_index_type = "bm25"
-        elif text_search_extension == "pg_textsearch":
-            target_column_type = "text"
-            target_index_type = "bm25"
-        else:  # native
-            target_column_type = "tsvector"
-            target_index_type = "gin"
-
-        mismatched_tables = []
-        tables_with_data = []
-
-        for table_name in tables_to_check:
-            # Check if table exists
-            table_exists = conn.execute(
-                text("""
-                    SELECT EXISTS (
-                        SELECT 1 FROM information_schema.tables
-                        WHERE table_schema = :schema AND table_name = :table_name
-                    )
-                """),
-                {"schema": schema_name, "table_name": table_name},
-            ).scalar()
-
-            if not table_exists:
-                logger.debug(f"Table {table_name} does not exist in schema '{schema_name}', skipping")
-                continue
-
-            # Get current column type from information_schema
-            current_column_info = conn.execute(
-                text("""
-                    SELECT data_type, udt_name
-                    FROM information_schema.columns
-                    WHERE table_schema = :schema
-                      AND table_name = :table_name
-                      AND column_name = 'search_vector'
-                """),
-                {"schema": schema_name, "table_name": table_name},
-            ).fetchone()
-
-            if not current_column_info:
-                logger.warning(f"No search_vector column found for {table_name}, will create it")
-                mismatched_tables.append((table_name, None, None))
-                continue
-
-            # Check column type (udt_name contains the actual type: tsvector, bm25vector, etc.)
-            current_column_type = current_column_info[1]  # udt_name
-
-            # Get current index type
-            current_index_info = conn.execute(
-                text("""
-                    SELECT am.amname
-                    FROM pg_indexes pi
-                    JOIN pg_class c ON c.relname = pi.indexname
-                    JOIN pg_am am ON am.oid = c.relam
-                    WHERE pi.schemaname = :schema
-                      AND pi.tablename = :table_name
-                      AND pi.indexname LIKE '%text_search%'
-                """),
-                {"schema": schema_name, "table_name": table_name},
-            ).fetchone()
-
-            current_index_type = current_index_info[0] if current_index_info else None
-
-            # Check if column and index types match target
-            column_matches = current_column_type == target_column_type
-            index_matches = current_index_type == target_index_type if current_index_type else False
-
-            if not (column_matches and index_matches):
-                logger.info(
-                    f"Text search mismatch on {table_name}: "
-                    f"column={current_column_type} (want {target_column_type}), "
-                    f"index={current_index_type} (want {target_index_type})"
-                )
-                mismatched_tables.append((table_name, current_column_type, current_index_type))
-
-                # Check if table has data
-                row_count = conn.execute(text(f"SELECT COUNT(*) FROM {schema_name}.{table_name}")).scalar()
-
-                if row_count > 0:
-                    tables_with_data.append((table_name, row_count))
-            else:
-                logger.debug(f"Text search OK for {table_name}: {current_column_type}/{current_index_type}")
-
-        # If no mismatches, we're done
-        if not mismatched_tables:
-            logger.debug(f"All text search columns/indexes match configured extension: {text_search_extension}")
-            return
-
-        # If there's data in any mismatched table, raise error
-        if tables_with_data:
-            table_list = ", ".join([f"{table}({count} rows)" for table, count in tables_with_data])
-            # Detect current extension from column type
-            current_col_type = mismatched_tables[0][1]
-            if current_col_type == "tsvector":
-                current_ext = "native"
-            elif current_col_type == "bm25vector":
-                current_ext = "vchord"
-            elif current_col_type == "text":
-                current_ext = "pg_textsearch"
-            else:
-                current_ext = "unknown"
-            raise RuntimeError(
-                f"Cannot change text search extension from {current_ext} to {text_search_extension}: "
-                f"the following tables contain data: {table_list}. "
-                f"To change text search extension, you must either:\n"
-                f"  1. Clear all data: DELETE FROM {schema_name}.memory_units; "
-                f"DELETE FROM {schema_name}.reflections; then restart\n"
-                f"  2. Use the current text search extension (set HINDSIGHT_API_TEXT_SEARCH_EXTENSION='{current_ext}')"
-            )
-
-        # Tables are empty, safe to recreate columns/indexes
-        logger.info(f"Recreating text search columns/indexes for {text_search_extension}")
-
-        for table_name, current_col_type, current_idx_type in mismatched_tables:
-            # Drop existing index if it exists
-            if current_idx_type:
-                logger.info(f"Dropping {current_idx_type} index on {table_name}")
-                conn.execute(
-                    text(f"""
-                        DROP INDEX IF EXISTS {schema_name}.idx_{table_name.replace(".", "_")}_text_search
-                    """)
-                )
-
-            # Drop existing column if it exists
-            if current_col_type:
-                logger.info(f"Dropping {current_col_type} column on {table_name}")
-                conn.execute(text(f"ALTER TABLE {schema_name}.{table_name} DROP COLUMN IF EXISTS search_vector"))
-
-            # Create new column with appropriate type
-            if text_search_extension == "vchord":
-                logger.info(f"Creating bm25vector column on {table_name}")
-                # Note: vchord_bm25 extension creates types in bm25_catalog schema
-                conn.execute(
-                    text(f"ALTER TABLE {schema_name}.{table_name} ADD COLUMN search_vector bm25_catalog.bm25vector")
-                )
-
-                # Create BM25 index
-                logger.info(f"Creating BM25 index on {table_name}")
-                conn.execute(
-                    text(f"""
-                        CREATE INDEX idx_{table_name.replace(".", "_")}_text_search
-                        ON {schema_name}.{table_name}
-                        USING bm25 (search_vector bm25_catalog.bm25_ops)
-                    """)
-                )
-            elif text_search_extension == "pg_textsearch":
-                logger.info(f"Creating TEXT column on {table_name}")
-                # Dummy TEXT column for consistency (indexes operate on base columns)
-                conn.execute(text(f"ALTER TABLE {schema_name}.{table_name} ADD COLUMN search_vector TEXT"))
-
-                # Create BM25 index on expression
-                logger.info(f"Creating BM25 index on {table_name}")
-                # Different expression for each table
-                if table_name == "memory_units":
-                    index_expr = "(COALESCE(text, '') || ' ' || COALESCE(context, ''))"
-                else:  # reflections
-                    index_expr = "(COALESCE(name, '') || ' ' || content)"
-
-                conn.execute(
-                    text(f"""
-                        CREATE INDEX idx_{table_name.replace(".", "_")}_text_search
-                        ON {schema_name}.{table_name}
-                        USING bm25({index_expr})
-                        WITH (text_config='english')
-                    """)
-                )
-            else:  # native
-                logger.info(f"Creating tsvector column on {table_name}")
-                # Different GENERATED expression for each table
-                if table_name == "memory_units":
-                    generated_expr = "to_tsvector('english', COALESCE(text, '') || ' ' || COALESCE(context, ''))"
-                else:  # reflections
-                    generated_expr = "to_tsvector('english', COALESCE(name, '') || ' ' || content)"
-
-                conn.execute(
-                    text(f"""
-                        ALTER TABLE {schema_name}.{table_name}
-                        ADD COLUMN search_vector tsvector
-                        GENERATED ALWAYS AS ({generated_expr}) STORED
-                    """)
-                )
-
-                # Create GIN index
-                logger.info(f"Creating GIN index on {table_name}")
-                conn.execute(
-                    text(f"""
-                        CREATE INDEX idx_{table_name.replace(".", "_")}_text_search
-                        ON {schema_name}.{table_name}
-                        USING gin(search_vector)
-                    """)
-                )
-
-        conn.commit()
-        logger.info(f"Successfully migrated text search to {text_search_extension}")

hindsight-api/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hindsight-api"
-version = "0.4.11"
+version = "0.4.10"
 description = "Hindsight: Agent Memory That Works Like Human Memory"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -42,7 +42,6 @@ dependencies = [
     "typer>=0.9.0",
     "cohere>=5.0.0",
     "flashrank>=0.2.0",
-    "litellm>=1.0.0",
     # Local ML models for embeddings/reranking - can be excluded in Docker with INCLUDE_LOCAL_MODELS=false
     "sentence-transformers>=3.3.0",
     "transformers>=4.53.0", # Security fixes for ReDoS vulnerabilities

hindsight-api/tests/test_async_batch_retain.py

@@ -1,423 +0,0 @@
-"""Test async batch retain with smart batching and parent-child operations."""
-
-import asyncio
-import json
-import uuid
-
-import pytest
-
-from hindsight_api.extensions import RequestContext
-
-
-@pytest.mark.asyncio
-async def test_duplicate_document_ids_rejected_async(memory, request_context):
-    """Test that async retain rejects batches with duplicate document_ids."""
-    bank_id = "test_duplicate_async"
-    contents = [
-        {"content": "First item", "document_id": "doc1"},
-        {"content": "Second item", "document_id": "doc2"},
-        {"content": "Third item", "document_id": "doc1"},  # Duplicate!
-    ]
-
-    # Should raise ValueError due to duplicate document_ids
-    with pytest.raises(ValueError, match="duplicate document_ids.*doc1"):
-        await memory.submit_async_retain(
-            bank_id=bank_id,
-            contents=contents,
-            request_context=request_context,
-        )
-
-
-@pytest.mark.asyncio
-async def test_duplicate_document_ids_rejected_sync(memory, request_context):
-    """Test that sync retain also rejects batches with duplicate document_ids."""
-    bank_id = "test_duplicate_sync"
-    contents = [
-        {"content": "First item", "document_id": "doc1"},
-        {"content": "Second item", "document_id": "doc1"},  # Duplicate!
-    ]
-
-    # Should raise ValueError due to duplicate document_ids
-    with pytest.raises(ValueError, match="duplicate document_ids.*doc1"):
-        await memory.retain_batch_async(
-            bank_id=bank_id,
-            contents=contents,
-            request_context=request_context,
-        )
-
-
-@pytest.mark.asyncio
-async def test_small_async_batch_no_splitting(memory, request_context):
-    """Test that small async batches create parent with single child (simplified code path)."""
-    bank_id = "test_small_async"
-    contents = [{"content": "Alice works at Google", "document_id": f"doc{i}"} for i in range(5)]
-
-    # Calculate total chars (should be well under threshold)
-    total_chars = sum(len(item["content"]) for item in contents)
-    assert total_chars < 10_000, "Test batch should be small"
-
-    # Submit async retain
-    result = await memory.submit_async_retain(
-        bank_id=bank_id,
-        contents=contents,
-        request_context=request_context,
-    )
-
-    # Verify we got an operation_id back
-    assert "operation_id" in result
-    assert "items_count" in result
-    assert result["items_count"] == 5
-
-    operation_id = result["operation_id"]
-
-    # Wait for task to complete (SyncTaskBackend executes immediately)
-    await asyncio.sleep(0.1)
-
-    # Check operation status
-    status = await memory.get_operation_status(
-        bank_id=bank_id,
-        operation_id=operation_id,
-        request_context=request_context,
-    )
-
-    # Should be a parent operation with single child (simplified code path)
-    assert status["status"] == "completed"
-    assert status["operation_type"] == "batch_retain"
-    assert "child_operations" in status
-    assert status["result_metadata"]["num_sub_batches"] == 1  # Single sub-batch
-    assert len(status["child_operations"]) == 1
-    assert status["child_operations"][0]["status"] == "completed"
-
-
-@pytest.mark.asyncio
-async def test_large_async_batch_auto_splits(memory, request_context):
-    """Test that large async batches automatically split into sub-batches with parent operation."""
-    from hindsight_api.engine.memory_engine import count_tokens
-
-    bank_id = "test_large_async"
-
-    # Create a large batch that exceeds the threshold (10k tokens default)
-    # Repeating "A"s gets heavily compressed by tokenizer, use varied content
-    # Use ~22k chars per item = ~5.5k tokens per item, 2 items = ~11k tokens total (exceeds 10k)
-    large_content = "The quick brown fox jumps over the lazy dog. " * 500  # ~22k chars = ~5.5k tokens
-    contents = [{"content": large_content + f" item {i}", "document_id": f"doc{i}"} for i in range(2)]
-
-    # Calculate total tokens (should exceed threshold)
-    total_tokens = sum(count_tokens(item["content"]) for item in contents)
-    assert total_tokens > 10_000, "Test batch should exceed threshold"
-
-    # Submit async retain
-    result = await memory.submit_async_retain(
-        bank_id=bank_id,
-        contents=contents,
-        request_context=request_context,
-    )
-
-    # Verify we got an operation_id back
-    assert "operation_id" in result
-    assert "items_count" in result
-    assert result["items_count"] == 2
-
-    parent_operation_id = result["operation_id"]
-
-    # Wait for tasks to complete
-    await asyncio.sleep(0.5)
-
-    # Check parent operation status
-    parent_status = await memory.get_operation_status(
-        bank_id=bank_id,
-        operation_id=parent_operation_id,
-        request_context=request_context,
-    )
-
-    # Should be a parent operation with children
-    assert parent_status["operation_type"] == "batch_retain"
-    assert "child_operations" in parent_status
-    assert "num_sub_batches" in parent_status["result_metadata"]
-    assert parent_status["result_metadata"]["num_sub_batches"] >= 2  # Should split into at least 2 batches
-    assert parent_status["result_metadata"]["items_count"] == 2
-
-    # Verify child operations
-    child_ops = parent_status["child_operations"]
-    assert len(child_ops) >= 2, "Should have at least 2 child operations"
-
-    # All children should be completed (SyncTaskBackend executes immediately)
-    for child in child_ops:
-        assert child["status"] == "completed"
-        assert child["sub_batch_index"] is not None
-        assert child["items_count"] > 0
-
-    # Parent status should be aggregated as "completed"
-    assert parent_status["status"] == "completed"
-
-
-@pytest.mark.asyncio
-async def test_parent_operation_status_aggregation_pending(memory, request_context):
-    """Test that parent operation shows 'pending' when children are pending."""
-    bank_id = "test_parent_pending"
-    pool = await memory._get_pool()
-
-    # Manually create a parent operation
-    parent_id = uuid.uuid4()
-    async with pool.acquire() as conn:
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            parent_id,
-            bank_id,
-            "batch_retain",
-            json.dumps({"items_count": 20, "num_sub_batches": 2, "is_parent": True}),
-            "pending",
-        )
-
-        # Create 2 child operations - one completed, one pending
-        child1_id = uuid.uuid4()
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            child1_id,
-            bank_id,
-            "retain",
-            json.dumps(
-                {
-                    "items_count": 10,
-                    "parent_operation_id": str(parent_id),
-                    "sub_batch_index": 1,
-                    "total_sub_batches": 2,
-                }
-            ),
-            "completed",
-        )
-
-        child2_id = uuid.uuid4()
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            child2_id,
-            bank_id,
-            "retain",
-            json.dumps(
-                {
-                    "items_count": 10,
-                    "parent_operation_id": str(parent_id),
-                    "sub_batch_index": 2,
-                    "total_sub_batches": 2,
-                }
-            ),
-            "pending",
-        )
-
-    # Check parent status
-    parent_status = await memory.get_operation_status(
-        bank_id=bank_id,
-        operation_id=str(parent_id),
-        request_context=request_context,
-    )
-
-    # Parent should aggregate as "pending" since one child is still pending
-    assert parent_status["status"] == "pending"
-    assert len(parent_status["child_operations"]) == 2
-
-
-@pytest.mark.asyncio
-async def test_parent_operation_status_aggregation_failed(memory, request_context):
-    """Test that parent operation shows 'failed' when any child fails."""
-    bank_id = "test_parent_failed"
-    pool = await memory._get_pool()
-
-    # Manually create a parent operation
-    parent_id = uuid.uuid4()
-    async with pool.acquire() as conn:
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            parent_id,
-            bank_id,
-            "batch_retain",
-            json.dumps({"items_count": 20, "num_sub_batches": 2, "is_parent": True}),
-            "pending",
-        )
-
-        # Create 2 child operations - one completed, one failed
-        child1_id = uuid.uuid4()
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            child1_id,
-            bank_id,
-            "retain",
-            json.dumps(
-                {
-                    "items_count": 10,
-                    "parent_operation_id": str(parent_id),
-                    "sub_batch_index": 1,
-                    "total_sub_batches": 2,
-                }
-            ),
-            "completed",
-        )
-
-        child2_id = uuid.uuid4()
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status, error_message)
-            VALUES ($1, $2, $3, $4, $5, $6)
-            """,
-            child2_id,
-            bank_id,
-            "retain",
-            json.dumps(
-                {
-                    "items_count": 10,
-                    "parent_operation_id": str(parent_id),
-                    "sub_batch_index": 2,
-                    "total_sub_batches": 2,
-                }
-            ),
-            "failed",
-            "Test error",
-        )
-
-    # Check parent status
-    parent_status = await memory.get_operation_status(
-        bank_id=bank_id,
-        operation_id=str(parent_id),
-        request_context=request_context,
-    )
-
-    # Parent should aggregate as "failed" since one child failed
-    assert parent_status["status"] == "failed"
-    assert len(parent_status["child_operations"]) == 2
-
-    # Verify child with error is included
-    failed_child = [c for c in parent_status["child_operations"] if c["status"] == "failed"][0]
-    assert failed_child["error_message"] == "Test error"
-
-
-@pytest.mark.asyncio
-async def test_parent_operation_status_aggregation_completed(memory, request_context):
-    """Test that parent operation shows 'completed' when all children are completed."""
-    bank_id = "test_parent_completed"
-    pool = await memory._get_pool()
-
-    # Manually create a parent operation
-    parent_id = uuid.uuid4()
-    async with pool.acquire() as conn:
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            parent_id,
-            bank_id,
-            "batch_retain",
-            json.dumps({"items_count": 20, "num_sub_batches": 2, "is_parent": True}),
-            "pending",
-        )
-
-        # Create 2 child operations - both completed
-        child1_id = uuid.uuid4()
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            child1_id,
-            bank_id,
-            "retain",
-            json.dumps(
-                {
-                    "items_count": 10,
-                    "parent_operation_id": str(parent_id),
-                    "sub_batch_index": 1,
-                    "total_sub_batches": 2,
-                }
-            ),
-            "completed",
-        )
-
-        child2_id = uuid.uuid4()
-        await conn.execute(
-            """
-            INSERT INTO async_operations (operation_id, bank_id, operation_type, result_metadata, status)
-            VALUES ($1, $2, $3, $4, $5)
-            """,
-            child2_id,
-            bank_id,
-            "retain",
-            json.dumps(
-                {
-                    "items_count": 10,
-                    "parent_operation_id": str(parent_id),
-                    "sub_batch_index": 2,
-                    "total_sub_batches": 2,
-                }
-            ),
-            "completed",
-        )
-
-    # Check parent status
-    parent_status = await memory.get_operation_status(
-        bank_id=bank_id,
-        operation_id=str(parent_id),
-        request_context=request_context,
-    )
-
-    # Parent should aggregate as "completed" since all children are completed
-    assert parent_status["status"] == "completed"
-    assert len(parent_status["child_operations"]) == 2
-    assert all(c["status"] == "completed" for c in parent_status["child_operations"])
-
-
-@pytest.mark.asyncio
-async def test_config_retain_batch_tokens_respected(memory, request_context):
-    """Test that the retain_batch_tokens config setting is respected."""
-    from hindsight_api.config import get_config
-    from hindsight_api.engine.memory_engine import count_tokens
-
-    bank_id = "test_config_batch_tokens"
-    config = get_config()
-
-    # Check that config has the retain_batch_tokens setting
-    assert hasattr(config, "retain_batch_tokens")
-    assert config.retain_batch_tokens > 0
-
-    # Create a batch that's just under the threshold
-    # Use content that produces roughly half the token limit per item
-    content_size = config.retain_batch_tokens * 2  # chars (rough estimate: 1 token ~= 4 chars)
-    contents = [{"content": "A" * content_size, "document_id": f"doc{i}"} for i in range(2)]
-
-    total_tokens = sum(count_tokens(item["content"]) for item in contents)
-    # Should be equal to threshold (boundary case, no splitting since we use > not >=)
-    assert total_tokens <= config.retain_batch_tokens
-
-    # Submit - should NOT split
-    result = await memory.submit_async_retain(
-        bank_id=bank_id,
-        contents=contents,
-        request_context=request_context,
-    )
-
-    # Wait for completion
-    await asyncio.sleep(0.1)
-
-    # Check status - should be a parent with single child (even for small batches)
-    status = await memory.get_operation_status(
-        bank_id=bank_id,
-        operation_id=result["operation_id"],
-        request_context=request_context,
-    )
-
-    # Even small batches use parent-child pattern now (simpler code path)
-    assert "child_operations" in status
-    assert status["result_metadata"]["num_sub_batches"] == 1

hindsight-api/tests/test_async_retain_tags.py

@@ -1,93 +0,0 @@
-"""Unit tests for async retain tag propagation."""
-
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from hindsight_api.engine.memory_engine import MemoryEngine
-from hindsight_api.models import RequestContext
-
-
-@pytest.mark.asyncio
-async def test_submit_async_retain_includes_document_tags_in_task_payload():
-    """submit_async_retain should include document_tags in queued task payload."""
-    engine = MemoryEngine.__new__(MemoryEngine)
-    engine._initialized = True
-    engine._authenticate_tenant = AsyncMock()
-    engine._submit_async_operation = AsyncMock(return_value={"operation_id": "op-1"})
-
-    # Mock the pool and connection for parent operation creation
-    mock_conn = AsyncMock()
-    mock_conn.execute = AsyncMock()
-    mock_conn.transaction = MagicMock()
-    mock_conn.transaction.return_value.__aenter__ = AsyncMock()
-    mock_conn.transaction.return_value.__aexit__ = AsyncMock()
-
-    mock_pool = AsyncMock()
-    mock_pool.acquire = AsyncMock(return_value=mock_conn)
-    mock_pool.release = AsyncMock()
-
-    engine._get_pool = AsyncMock(return_value=mock_pool)
-
-    request_context = RequestContext(tenant_id="tenant-a", api_key_id="key-a")
-    contents = [{"content": "Async retain payload test."}]
-    document_tags = ["scope:tools", "user:alice"]
-
-    result = await MemoryEngine.submit_async_retain(
-        engine,
-        bank_id="bank-1",
-        contents=contents,
-        document_tags=document_tags,
-        request_context=request_context,
-    )
-
-    # Check result structure
-    assert "operation_id" in result
-    assert "items_count" in result
-    assert result["items_count"] == 1
-
-    # Verify authentication was called
-    engine._authenticate_tenant.assert_awaited_once_with(request_context)
-
-    # Verify child operation was submitted
-    engine._submit_async_operation.assert_awaited_once()
-
-    # Verify child operation payload contains document_tags
-    kwargs = engine._submit_async_operation.await_args.kwargs
-    assert kwargs["bank_id"] == "bank-1"
-    assert kwargs["operation_type"] == "retain"
-    assert kwargs["task_type"] == "batch_retain"
-    assert kwargs["task_payload"]["contents"] == contents
-    assert kwargs["task_payload"]["document_tags"] == document_tags
-    assert kwargs["task_payload"]["_tenant_id"] == "tenant-a"
-    assert kwargs["task_payload"]["_api_key_id"] == "key-a"
-
-
-@pytest.mark.asyncio
-async def test_handle_batch_retain_forwards_document_tags_to_retain_batch_async():
-    """Worker handler should forward document_tags from task payload."""
-    engine = MemoryEngine.__new__(MemoryEngine)
-    engine._initialized = True
-    engine.retain_batch_async = AsyncMock(return_value={"items_count": 1})
-
-    task_dict = {
-        "bank_id": "bank-1",
-        "contents": [{"content": "Forward tags test."}],
-        "document_tags": ["scope:client"],
-        "_tenant_id": "tenant-a",
-        "_api_key_id": "key-a",
-    }
-
-    await MemoryEngine._handle_batch_retain(engine, task_dict)
-
-    engine.retain_batch_async.assert_awaited_once()
-    kwargs = engine.retain_batch_async.await_args.kwargs
-    assert kwargs["bank_id"] == "bank-1"
-    assert kwargs["contents"] == task_dict["contents"]
-    assert kwargs["document_tags"] == ["scope:client"]
-
-    request_context = kwargs["request_context"]
-    assert request_context.internal is True
-    assert request_context.user_initiated is True
-    assert request_context.tenant_id == "tenant-a"
-    assert request_context.api_key_id == "key-a"

hindsight-api/tests/test_base_path.py

@@ -1,189 +0,0 @@
-"""
-Integration test for API base path support.
-
-Tests that the API works correctly when deployed with a base path (e.g., /hindsight)
-for reverse proxy deployments.
-"""
-import os
-import pytest
-import pytest_asyncio
-import httpx
-from hindsight_api.api import create_app
-from hindsight_api.config import clear_config_cache
-
-
-@pytest_asyncio.fixture
-async def api_client_with_base_path(memory):
-    """Create an async test client for the FastAPI app with a base path."""
-    # Set base path in environment
-    base_path = "/hindsight"
-    os.environ["HINDSIGHT_API_BASE_PATH"] = base_path
-
-    # Clear config cache to force reload with new base_path
-    clear_config_cache()
-
-    # Memory is already initialized by the conftest fixture (with migrations)
-    app = create_app(memory, initialize_memory=False)
-
-    # Use base_url with base path
-    transport = httpx.ASGITransport(app=app)
-    async with httpx.AsyncClient(
-        transport=transport,
-        base_url=f"http://test{base_path}"
-    ) as client:
-        yield client
-
-    # Cleanup: unset base path
-    os.environ.pop("HINDSIGHT_API_BASE_PATH", None)
-    clear_config_cache()
-
-
-@pytest_asyncio.fixture
-async def api_client_without_base_path(memory):
-    """Create an async test client for the FastAPI app without a base path (root)."""
-    # Ensure no base path is set
-    os.environ.pop("HINDSIGHT_API_BASE_PATH", None)
-    clear_config_cache()
-
-    app = create_app(memory, initialize_memory=False)
-    transport = httpx.ASGITransport(app=app)
-    async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_base_path_health_endpoint(api_client_with_base_path):
-    """Test that health endpoint works with base path."""
-    # With base path set to /hindsight, health should be at /hindsight/health
-    # But since our client base_url is already http://test/hindsight, we request /health
-    response = await api_client_with_base_path.get("/health")
-    assert response.status_code == 200
-    data = response.json()
-    assert "status" in data
-    assert data["status"] in ["ok", "healthy"]  # Accept both formats
-
-
-@pytest.mark.asyncio
-async def test_base_path_banks_endpoint(api_client_with_base_path):
-    """Test that banks endpoint works with base path."""
-    response = await api_client_with_base_path.get("/v1/default/banks")
-    assert response.status_code == 200
-    data = response.json()
-    assert "banks" in data
-
-
-@pytest.mark.asyncio
-async def test_base_path_openapi_schema(api_client_with_base_path):
-    """Test that OpenAPI schema includes correct base path in servers."""
-    response = await api_client_with_base_path.get("/openapi.json")
-    assert response.status_code == 200
-    openapi_schema = response.json()
-
-    # Check that servers array includes base path
-    assert "servers" in openapi_schema
-    servers = openapi_schema["servers"]
-    assert len(servers) > 0
-    # FastAPI should set server URL to the root_path
-    assert servers[0]["url"] == "/hindsight"
-
-
-@pytest.mark.asyncio
-async def test_base_path_docs_redirect(api_client_with_base_path):
-    """Test that /docs redirects correctly with base path."""
-    # FastAPI docs endpoint should work
-    response = await api_client_with_base_path.get("/docs", follow_redirects=False)
-    # Should either return 200 (direct) or 307 (redirect to trailing slash)
-    assert response.status_code in [200, 307]
-
-
-@pytest.mark.asyncio
-async def test_base_path_metrics(api_client_with_base_path):
-    """Test that metrics endpoint works with base path."""
-    response = await api_client_with_base_path.get("/metrics")
-    assert response.status_code == 200
-    # Metrics should be in Prometheus format
-    assert "# HELP" in response.text or "# TYPE" in response.text
-
-
-@pytest.mark.asyncio
-async def test_base_path_full_workflow(api_client_with_base_path):
-    """
-    Test a full retain/recall workflow with base path.
-
-    This ensures that all memory operations work correctly when the API
-    is deployed with a base path.
-    """
-    bank_id = "test_base_path_bank"
-
-    # 1. Create/get bank
-    response = await api_client_with_base_path.get(f"/v1/default/banks/{bank_id}/profile")
-    assert response.status_code == 200
-
-    # 2. Store a memory
-    response = await api_client_with_base_path.post(
-        f"/v1/default/banks/{bank_id}/memories",
-        json={
-            "items": [
-                {
-                    "content": "The API supports base path deployment for reverse proxy use cases.",
-                    "context": "testing base path feature"
-                }
-            ]
-        }
-    )
-    assert response.status_code == 200
-    result = response.json()
-    assert result["success"] is True
-
-    # 3. Recall the memory
-    response = await api_client_with_base_path.post(
-        f"/v1/default/banks/{bank_id}/memories/recall",
-        json={
-            "query": "base path support"
-        }
-    )
-    assert response.status_code == 200
-    recall_result = response.json()
-    # API returns "results" not "memories"
-    assert "results" in recall_result
-    assert len(recall_result["results"]) > 0
-
-
-@pytest.mark.asyncio
-async def test_without_base_path_still_works(api_client_without_base_path):
-    """
-    Regression test: ensure default behavior (no base path) still works.
-
-    This test verifies that when HINDSIGHT_API_BASE_PATH is not set,
-    the API works at the root path as before.
-    """
-    # Health check at root
-    response = await api_client_without_base_path.get("/health")
-    assert response.status_code == 200
-
-    # Banks endpoint at root
-    response = await api_client_without_base_path.get("/v1/default/banks")
-    assert response.status_code == 200
-
-    # OpenAPI schema should have empty or "/" server path
-    response = await api_client_without_base_path.get("/openapi.json")
-    assert response.status_code == 200
-    openapi_schema = response.json()
-    servers = openapi_schema.get("servers", [])
-    if servers:
-        # Server URL should be empty string (root) or "/"
-        assert servers[0]["url"] in ["", "/"]
-
-
-@pytest.mark.skip(reason="MCP endpoint routing with base path needs investigation")
-@pytest.mark.asyncio
-async def test_base_path_mcp_endpoint(api_client_with_base_path):
-    """Test that MCP endpoint is accessible with base path."""
-    bank_id = "test_mcp_bank"
-
-    # MCP endpoint should be mounted at /mcp/{bank_id}/
-    # The MCP server uses a different protocol, so just check the root exists
-    response = await api_client_with_base_path.get(f"/mcp/{bank_id}/")
-    # MCP may return various status codes, but should not be 404 (not found)
-    # Accept 405 (method not allowed), 400 (bad request), etc.
-    assert response.status_code != 404, "MCP endpoint should exist"

hindsight-api/tests/test_causal_relations.py

@@ -12,7 +12,6 @@ from datetime import datetime
 import pytest
 
 from hindsight_api import LLMConfig
-from hindsight_api.config import _get_raw_config
 from hindsight_api.engine.retain.fact_extraction import extract_facts_from_text
 
 
@@ -45,7 +44,6 @@ class TestCausalRelationsValidation:
             context=context,
             llm_config=llm_config,
             agent_name="TestUser",
-            config=_get_raw_config(),
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -90,7 +88,6 @@ class TestCausalRelationsValidation:
             context=context,
             llm_config=llm_config,
             agent_name="TestUser",
-            config=_get_raw_config(),
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -127,7 +124,6 @@ class TestCausalRelationsValidation:
             context=context,
             llm_config=llm_config,
             agent_name="TestUser",
-            config=_get_raw_config(),
         )
 
         assert len(facts) > 0, "Should extract facts about the causal chain"
@@ -177,7 +173,6 @@ class TestCausalRelationsValidation:
             context=context,
             llm_config=llm_config,
             agent_name="TestUser",
-            config=_get_raw_config(),
         )
 
         assert len(facts) > 0, "Should extract facts"
@@ -214,7 +209,6 @@ class TestCausalRelationsValidation:
             context=context,
             llm_config=llm_config,
             agent_name="TestUser",
-            config=_get_raw_config(),
         )
 
         # Verify relation types are all backward-looking

hindsight-api/tests/test_causal_relationships.py

@@ -10,7 +10,6 @@ from datetime import datetime
 import pytest
 
 from hindsight_api import LLMConfig
-from hindsight_api.config import _get_raw_config
 from hindsight_api.engine.retain.fact_extraction import extract_facts_from_text
 
 
@@ -38,8 +37,7 @@ After searching for weeks, I finally found a cheaper apartment in Brooklyn.
         llm_config = LLMConfig.for_memory()
 
         facts, _, _ = await extract_facts_from_text(
-            text=text, event_date=datetime(2024, 3, 15), context=context, llm_config=llm_config, agent_name="TestUser",
-            config=_get_raw_config(),
+            text=text, event_date=datetime(2024, 3, 15), context=context, llm_config=llm_config, agent_name="TestUser"
         )
 
         assert len(facts) >= 3, f"Should extract at least 3 facts from the causal chain. Got {len(facts)}"
@@ -108,8 +106,7 @@ The renovation took three months and cost $15,000.
         llm_config = LLMConfig.for_memory()
 
         facts, _, _ = await extract_facts_from_text(
-            text=text, event_date=datetime(2024, 6, 1), context=context, llm_config=llm_config, agent_name="TestUser",
-            config=_get_raw_config(),
+            text=text, event_date=datetime(2024, 6, 1), context=context, llm_config=llm_config, agent_name="TestUser"
         )
 
         assert len(facts) >= 4, f"Should extract at least 4 facts. Got {len(facts)}"
@@ -139,8 +136,7 @@ Machine learning fascinated me so much that I changed my career to data science.
         llm_config = LLMConfig.for_memory()
 
         facts, _, _ = await extract_facts_from_text(
-            text=text, event_date=datetime(2024, 1, 1), context=context, llm_config=llm_config, agent_name="TestUser",
-            config=_get_raw_config(),
+            text=text, event_date=datetime(2024, 1, 1), context=context, llm_config=llm_config, agent_name="TestUser"
         )
 
         # Check no fact references itself
@@ -167,8 +163,7 @@ The new role enabled me to lead a team of engineers.
         llm_config = LLMConfig.for_memory()
 
         facts, _, _ = await extract_facts_from_text(
-            text=text, event_date=datetime(2024, 2, 15), context=context, llm_config=llm_config, agent_name="TestUser",
-            config=_get_raw_config(),
+            text=text, event_date=datetime(2024, 2, 15), context=context, llm_config=llm_config, agent_name="TestUser"
         )
 
         # Validate all indices (must reference PREVIOUS facts only)
@@ -195,8 +190,7 @@ Reduced spending somewhat affected local businesses.
         llm_config = LLMConfig.for_memory()
 
         facts, _, _ = await extract_facts_from_text(
-            text=text, event_date=datetime(2024, 4, 1), context=context, llm_config=llm_config, agent_name="TestUser",
-            config=_get_raw_config(),
+            text=text, event_date=datetime(2024, 4, 1), context=context, llm_config=llm_config, agent_name="TestUser"
         )
 
         for i, fact in enumerate(facts):

hindsight-api/tests/test_consolidation.py

@@ -21,9 +21,9 @@ from hindsight_api.engine.reflect.tools import (
 @pytest.fixture(autouse=True)
 def enable_observations():
     """Enable observations for all tests in this module."""
-    from hindsight_api.config import _get_raw_config
+    from hindsight_api.config import get_config
 
-    config = _get_raw_config()
+    config = get_config()
     original_value = config.enable_observations
     config.enable_observations = True
     yield
@@ -563,26 +563,25 @@ class TestConsolidationDisabled:
         self, memory: MemoryEngine, request_context
     ):
         """Test that consolidation returns disabled status when enable_observations is False."""
+        from unittest.mock import patch
+
         bank_id = f"test-consolidation-disabled-{uuid.uuid4().hex[:8]}"
 
         # Create the bank
         await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
 
-        # Disable observations for this bank via bank config
-        await memory._config_resolver.update_bank_config(
-            bank_id=bank_id,
-            updates={"enable_observations": False},
-            context=request_context,
-        )
+        # Disable observations via config
+        with patch("hindsight_api.config.get_config") as mock_config:
+            mock_config.return_value.enable_observations = False
 
-        result = await run_consolidation_job(
-            memory_engine=memory,
-            bank_id=bank_id,
-            request_context=request_context,
-        )
+            result = await run_consolidation_job(
+                memory_engine=memory,
+                bank_id=bank_id,
+                request_context=request_context,
+            )
 
-        assert result["status"] == "disabled"
-        assert result["bank_id"] == bank_id
+            assert result["status"] == "disabled"
+            assert result["bank_id"] == bank_id
 
         # Cleanup
         await memory.delete_bank(bank_id, request_context=request_context)

hindsight-api/tests/test_fact_extraction_analysis.py

@@ -8,7 +8,7 @@ from datetime import datetime
 
 import pytest
 
-from hindsight_api.config import get_config, clear_config_cache, _get_raw_config
+from hindsight_api.config import get_config, clear_config_cache
 from hindsight_api.engine.llm_wrapper import LLMConfig
 from hindsight_api.engine.retain.fact_extraction import extract_facts_from_text
 
@@ -58,7 +58,6 @@ async def test_fact_extraction_basic_analysis(llm_config):
         llm_config=llm_config,
         agent_name="test-agent",
         context="Friday Standup meeting",
-        config=_get_raw_config(),
     )
 
     duration = time.time() - start_time

hindsight-api/tests/test_fact_extraction_output_ratio.py

@@ -11,7 +11,6 @@ from datetime import datetime
 import pytest
 
 from hindsight_api import LLMConfig
-from hindsight_api.config import _get_raw_config
 from hindsight_api.engine.retain.fact_extraction import extract_facts_from_text
 
 
@@ -45,8 +44,7 @@ I ran into my neighbor Sarah who mentioned she's planning a trip to Italy next m
             event_date=datetime(2024, 6, 15),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         input_length = len(text)
@@ -90,8 +88,7 @@ User: Perfect, I'll make a reservation for Saturday at 7pm.
             event_date=datetime(2024, 6, 15),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         input_length = len(text)
@@ -147,8 +144,7 @@ I edited about 20 photos from my recent trip to the mountains.
             event_date=datetime(2024, 4, 15),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         input_length = len(text)
@@ -212,8 +208,7 @@ I edited about 20 photos from my recent trip to the mountains.
             event_date=datetime(2023, 5, 8),  # Date from locomo dataset
             context=context,
             llm_config=llm_config,
-            agent_name=data["conversation"]["speaker_a"],
-            config=_get_raw_config(),
+            agent_name=data["conversation"]["speaker_a"]
         )
 
         # Calculate ratios
@@ -274,8 +269,7 @@ I'm planning to visit Japan next year.
             event_date=datetime(2024, 6, 15),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         # Count approximate number of statements (sentences)

hindsight-api/tests/test_fact_extraction_quality.py

@@ -17,7 +17,6 @@ from datetime import UTC, datetime
 import pytest
 
 from hindsight_api import LLMConfig
-from hindsight_api.config import _get_raw_config
 from hindsight_api.engine.retain.fact_extraction import extract_facts_from_text
 
 # =============================================================================
@@ -49,8 +48,7 @@ Marcus felt anxious about the upcoming interview.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -82,8 +80,7 @@ The music was so loud I could barely hear myself think.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -116,8 +113,7 @@ Maybe we should reconsider the timeline.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -150,8 +146,7 @@ I'm unable to attend the conference due to scheduling conflicts.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -183,8 +178,7 @@ Unlike last year, we're ahead of schedule.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -217,8 +211,7 @@ She's enthusiastic about the opportunity.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -251,8 +244,7 @@ I'm planning to switch careers because I'm not fulfilled in my current role.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -289,8 +281,7 @@ Family is the most important thing to her.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -324,8 +315,7 @@ I prefer presenting in person rather than virtually because I can read the room
             event_date=event_date,
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -382,8 +372,7 @@ I'm planning to visit Tokyo next month.
             event_date=event_date,
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -434,8 +423,7 @@ with a concert surrounded by music, joy and the warm summer breeze.
                     event_date=event_date,
                     context=context,
                     llm_config=llm_config,
-                    agent_name="Melanie",
-                    config=_get_raw_config(),
+                    agent_name="Melanie"
                 )
 
                 assert len(facts) > 0, "Should extract at least one fact"
@@ -505,8 +493,7 @@ It was a beautiful day and I plan to make this a regular habit.
             event_date=event_date,
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -560,8 +547,7 @@ It was a beautiful day and I plan to make this a regular habit.
             event_date=reference_date,
             llm_config=llm_config,
             agent_name="TestUser",
-            context="Personal diary",
-            config=_get_raw_config(),
+            context="Personal diary"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -591,8 +577,7 @@ It was a beautiful day and I plan to make this a regular habit.
             event_date=reference_date,
             llm_config=llm_config,
             agent_name="TestUser",
-            context="General info",
-            config=_get_raw_config(),
+            context="General info"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -619,8 +604,7 @@ It was a beautiful day and I plan to make this a regular habit.
             event_date=reference_date,
             llm_config=llm_config,
             agent_name="TestUser",
-            context="Calendar events",
-            config=_get_raw_config(),
+            context="Calendar events"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -671,8 +655,7 @@ great time! Every time I see it, I can't help but smile.
             event_date=event_date,
             context=context,
             llm_config=llm_config,
-            agent_name="Deborah",
-            config=_get_raw_config(),
+            agent_name="Deborah"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -722,8 +705,7 @@ I've learned so much from it.
             event_date=datetime(2024, 11, 13),
             context=context,
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -792,8 +774,7 @@ Jamie: Congratulations! I'd love to read it.
             event_date=datetime(2024, 11, 13),
             llm_config=llm_config,
             agent_name="Marcus",
-            context=context,
-            config=_get_raw_config(),
+            context=context
         )
 
         assert len(facts) > 0, "Should extract at least one fact from the transcript"
@@ -838,8 +819,7 @@ We presented our findings to the team yesterday.
             event_date=datetime(2024, 11, 13),
             llm_config=llm_config,
             agent_name="TestUser",
-            context=context,
-            config=_get_raw_config(),
+            context=context
         )
 
         assert len(facts) > 0, "Should extract facts"
@@ -874,8 +854,7 @@ Jamie: [teasing] We'll see who's right, my Niners pick is solid.
             event_date=datetime(2024, 11, 14),
             context=context,
             llm_config=llm_config,
-            agent_name=agent_name,
-            config=_get_raw_config(),
+            agent_name=agent_name
         )
 
         assert len(facts) > 0, "Should extract at least one fact"
@@ -941,8 +920,7 @@ so the algorithm learns to box out. See you next week!
                     event_date=datetime(2024, 11, 13),
                     llm_config=llm_config,
                     agent_name="Marcus",
-                    context=context,
-                    config=_get_raw_config(),
+                    context=context
                 )
 
                 assert len(facts) > 0, "Should extract at least one fact"

hindsight-api/tests/test_hierarchical_config.py

@@ -1,491 +0,0 @@
-"""
-Tests for hierarchical configuration system.
-
-Tests config resolution hierarchy (global → tenant → bank),
-key normalization, API endpoints, validation, and caching.
-"""
-
-import os
-
-import pytest
-
-from hindsight_api import MemoryEngine
-from hindsight_api.config import HindsightConfig, normalize_config_dict, normalize_config_key
-from hindsight_api.config_resolver import ConfigResolver
-from hindsight_api.extensions.tenant import TenantExtension
-from hindsight_api.models import RequestContext
-
-# Enable bank config API for all tests in this module
-os.environ["HINDSIGHT_API_ENABLE_BANK_CONFIG_API"] = "true"
-
-
-class MockTenantExtension(TenantExtension):
-    """Mock tenant extension for testing tenant-level config."""
-
-    def __init__(self, tenant_config: dict):
-        self.tenant_config = tenant_config
-
-    async def authenticate(self, context):
-        from hindsight_api.extensions.tenant import TenantContext
-
-        return TenantContext(schema_name="public")
-
-    async def list_tenants(self):
-        from hindsight_api.extensions.tenant import Tenant
-
-        return [Tenant(schema="public")]
-
-    async def get_tenant_config(self, context):
-        """Return mock tenant config."""
-        return self.tenant_config
-
-
-@pytest.mark.asyncio
-async def test_config_key_normalization():
-    """Test that env var keys are normalized to Python field names."""
-    # Test basic normalization
-    assert normalize_config_key("HINDSIGHT_API_LLM_PROVIDER") == "llm_provider"
-    assert normalize_config_key("HINDSIGHT_API_LLM_MODEL") == "llm_model"
-    assert normalize_config_key("HINDSIGHT_API_RETAIN_LLM_PROVIDER") == "retain_llm_provider"
-
-    # Test already normalized keys
-    assert normalize_config_key("llm_provider") == "llm_provider"
-    assert normalize_config_key("llm_model") == "llm_model"
-
-    # Test dict normalization
-    input_dict = {
-        "HINDSIGHT_API_LLM_PROVIDER": "openai",
-        "HINDSIGHT_API_LLM_MODEL": "gpt-4",
-        "llm_base_url": "https://api.openai.com",
-    }
-    expected = {"llm_provider": "openai", "llm_model": "gpt-4", "llm_base_url": "https://api.openai.com"}
-    assert normalize_config_dict(input_dict) == expected
-
-
-@pytest.mark.asyncio
-async def test_hierarchical_fields_categorization():
-    """Test that fields are correctly categorized as configurable, credentials, or static."""
-    configurable = HindsightConfig.get_configurable_fields()
-    credentials = HindsightConfig.get_credential_fields()
-    static = HindsightConfig.get_static_fields()
-
-    # Verify no overlap between configurable and credentials
-    assert len(configurable & credentials) == 0, "Configurable fields should not include credentials"
-
-    # Verify configurable fields include behavioral settings (safe to modify)
-    assert "retain_extraction_mode" in configurable
-    assert "enable_observations" in configurable
-    assert "retain_chunk_size" in configurable
-    assert "retain_custom_instructions" in configurable
-
-    # Verify count is correct (only 4 fields)
-    assert len(configurable) == 4
-
-    # Verify credential fields (NEVER exposed)
-    assert "llm_api_key" in credentials
-    assert "llm_base_url" in credentials
-    assert "retain_llm_api_key" in credentials
-    assert "reflect_llm_api_key" in credentials
-
-    # Verify static fields include server settings AND non-configurable LLM fields
-    assert "database_url" in static
-    assert "port" in static
-    assert "host" in static
-    assert "embeddings_provider" in static
-    assert "reranker_provider" in static
-    assert "worker_enabled" in static
-    assert "llm_provider" in static  # Not configurable (needs presets)
-    assert "llm_model" in static  # Not configurable (needs presets)
-    assert "graph_retriever" in static  # Performance tuning, not configurable
-    assert "llm_max_concurrent" in static  # Performance tuning, not configurable
-
-
-@pytest.mark.asyncio
-async def test_config_hierarchy_resolution(memory, request_context):
-    """Test that config resolution follows global → tenant → bank hierarchy."""
-    bank_id = "test-hierarchy-bank"
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank_id, request_context=request_context)
-
-        # Set up mock tenant extension with tenant-level config (use configurable fields only)
-        tenant_config = {"retain_chunk_size": 5000, "retain_extraction_mode": "tenant-mode"}
-        mock_tenant = MockTenantExtension(tenant_config)
-
-        # Create config resolver with mock tenant extension
-        resolver = ConfigResolver(pool=memory._pool, tenant_extension=mock_tenant)
-
-        # Test 1: Global config only (no overrides)
-        context = RequestContext(api_key=None, api_key_id=None, tenant_id=None, internal=False)
-        config = await resolver.get_bank_config(bank_id, context)
-
-        # Should have configurable fields from global config (NOT credentials or llm_provider/model)
-        assert "retain_chunk_size" in config  # Configurable field
-        assert "llm_api_key" not in config  # Credential - never exposed
-        assert "llm_provider" not in config  # Not configurable (needs presets)
-
-        # Test 2: Add tenant-level overrides
-        config = await resolver.get_bank_config(bank_id, context)
-
-        # Should apply tenant overrides (only configurable fields)
-        assert config["retain_chunk_size"] == 5000  # Tenant override
-        assert config["retain_extraction_mode"] == "tenant-mode"  # Tenant override
-
-        # Test 3: Add bank-level overrides (should take precedence)
-        await resolver.update_bank_config(
-            bank_id,
-            {"retain_chunk_size": 2000, "retain_extraction_mode": "bank-mode"},  # Override tenant settings
-            context,
-        )
-
-        # Config should reflect changes immediately (no caching)
-        config = await resolver.get_bank_config(bank_id, context)
-
-        # Bank overrides should take precedence over tenant
-        assert config["retain_chunk_size"] == 2000  # Bank override wins
-        assert config["retain_extraction_mode"] == "bank-mode"  # Bank override wins
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_config_validation_rejects_static_fields(memory, request_context):
-    """Test that attempting to override static fields raises ValueError."""
-    bank_id = "test-validation-bank"
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank_id, request_context=request_context)
-
-        resolver = ConfigResolver(pool=memory._pool)
-
-        # Test 1: Configurable fields should work
-        await resolver.update_bank_config(bank_id, {"retain_chunk_size": 4000, "retain_extraction_mode": "verbose"})
-
-        # Test 2: Static fields should raise ValueError
-        with pytest.raises(ValueError, match="Cannot override static"):
-            await resolver.update_bank_config(bank_id, {"port": 9000})
-
-        with pytest.raises(ValueError, match="Cannot override static"):
-            await resolver.update_bank_config(bank_id, {"database_url": "postgresql://fake"})
-
-        with pytest.raises(ValueError, match="Cannot override static"):
-            await resolver.update_bank_config(bank_id, {"embeddings_provider": "openai"})
-
-        # Test 3: Credential fields should raise ValueError
-        with pytest.raises(ValueError, match="Cannot set credential fields"):
-            await resolver.update_bank_config(bank_id, {"llm_api_key": "sk-fake"})
-
-        # Test 4: Non-configurable LLM fields should raise ValueError (need presets)
-        with pytest.raises(ValueError, match="Cannot override static"):
-            await resolver.update_bank_config(bank_id, {"llm_model": "gpt-4"})
-
-        # Test 5: Mix of configurable and static should fail
-        with pytest.raises(ValueError, match="Cannot override static"):
-            await resolver.update_bank_config(bank_id, {"retain_chunk_size": 4000, "port": 9000})
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_config_freshness_across_updates(memory, request_context):
-    """Test that config changes are immediately visible (no stale cache)."""
-    bank1 = "freshness-test-1"
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank1, request_context=request_context)
-
-        resolver = ConfigResolver(pool=memory._pool)
-
-        # Test 1: Initial config reflects global defaults
-        config1 = await resolver.get_bank_config(bank1, None)
-        initial_chunk_size = config1["retain_chunk_size"]
-
-        # Test 2: Update config
-        await resolver.update_bank_config(bank1, {"retain_chunk_size": 4000})
-
-        # Test 3: Next call should see updated value immediately (no stale cache)
-        config2 = await resolver.get_bank_config(bank1, None)
-        assert config2["retain_chunk_size"] == 4000
-
-        # Test 4: Multiple updates are all immediately visible
-        await resolver.update_bank_config(bank1, {"retain_chunk_size": 4500})
-        config3 = await resolver.get_bank_config(bank1, None)
-        assert config3["retain_chunk_size"] == 4500
-
-        # Test 5: Reset restores global defaults immediately
-        await resolver.reset_bank_config(bank1)
-        config4 = await resolver.get_bank_config(bank1, None)
-        assert config4["retain_chunk_size"] == initial_chunk_size  # Back to global default
-
-        # Test 6: Each call returns a fresh config dict (not a cached reference)
-        config5 = await resolver.get_bank_config(bank1, None)
-        config6 = await resolver.get_bank_config(bank1, None)
-        assert config5 is not config6  # Different object instances
-
-    finally:
-        await memory.delete_bank(bank1, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_config_reset_to_defaults(memory, request_context):
-    """Test that resetting config removes all bank-specific overrides."""
-    bank_id = "test-reset-bank"
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank_id, request_context=request_context)
-
-        resolver = ConfigResolver(pool=memory._pool)
-
-        # Add bank-specific overrides
-        await resolver.update_bank_config(
-            bank_id,
-            {
-                "retain_chunk_size": 5500,
-                "retain_extraction_mode": "custom",
-                "retain_custom_instructions": "Custom instructions",
-            },
-        )
-
-        # Verify overrides applied
-        config = await resolver.get_bank_config(bank_id, None)
-        assert config["retain_chunk_size"] == 5500
-        assert config["retain_extraction_mode"] == "custom"
-        assert config["retain_custom_instructions"] == "Custom instructions"
-
-        # Reset to defaults
-        await resolver.reset_bank_config(bank_id)
-
-        # Verify overrides removed (back to global defaults)
-        config_reset = await resolver.get_bank_config(bank_id, None)
-        assert config_reset["retain_chunk_size"] != 5500  # Should be global default
-        assert config_reset["retain_extraction_mode"] != "custom"  # Should be global default
-
-        # Verify bank_config is empty
-        bank_overrides = await resolver._load_bank_config(bank_id)
-        assert bank_overrides == {}
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_config_supports_both_key_formats(memory, request_context):
-    """Test that API accepts both env var and Python field formats."""
-    bank_id = "test-key-format-bank"
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank_id, request_context=request_context)
-
-        resolver = ConfigResolver(pool=memory._pool)
-
-        # Test 1: Python field format
-        await resolver.update_bank_config(bank_id, {"retain_chunk_size": 7000})
-
-        config = await resolver.get_bank_config(bank_id, None)
-        assert config["retain_chunk_size"] == 7000
-
-        # Test 2: Env var format (should be normalized)
-        await resolver.update_bank_config(bank_id, {"HINDSIGHT_API_RETAIN_CHUNK_SIZE": 8000})
-
-        config = await resolver.get_bank_config(bank_id, None)
-        assert config["retain_chunk_size"] == 8000
-
-        # Test 3: Mixed format in same request
-        await resolver.update_bank_config(
-            bank_id,
-            {
-                "retain_chunk_size": 9000,  # Python format
-                "HINDSIGHT_API_RETAIN_EXTRACTION_MODE": "verbose",  # Env format
-            },
-        )
-
-        config = await resolver.get_bank_config(bank_id, None)
-        assert config["retain_chunk_size"] == 9000
-        assert config["retain_extraction_mode"] == "verbose"
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_config_only_configurable_fields_stored(memory, request_context):
-    """Test that only configurable fields are stored in bank config."""
-    bank_id = "test-filter-bank"
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank_id, request_context=request_context)
-
-        resolver = ConfigResolver(pool=memory._pool)
-
-        # Add valid configurable field
-        await resolver.update_bank_config(bank_id, {"retain_chunk_size": 3500})
-
-        # Load bank config and verify only configurable fields present
-        bank_overrides = await resolver._load_bank_config(bank_id)
-
-        for key in bank_overrides.keys():
-            assert key in HindsightConfig.get_configurable_fields(), f"Non-configurable field {key} in bank config"
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_config_get_bank_config_no_static_or_credential_fields_leak(memory, request_context):
-    """
-    SECURITY TEST: Verify get_bank_config() only returns configurable fields (no static/credentials).
-
-    This prevents leaking sensitive system configuration like database URLs,
-    API keys, LLM providers/models, worker counts, etc. when retrieving bank configuration.
-    """
-    bank_id = "test-security-bank"
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank_id, request_context=request_context)
-
-        resolver = ConfigResolver(pool=memory._pool)
-
-        # Get bank config
-        config = await resolver.get_bank_config(bank_id, None)
-
-        # Get field categorizations
-        configurable_fields = HindsightConfig.get_configurable_fields()
-        credential_fields = HindsightConfig.get_credential_fields()
-        static_fields = HindsightConfig.get_static_fields()
-
-        # SECURITY: Verify ONLY configurable fields are returned (NO static, NO credentials)
-        for key in config.keys():
-            assert key in configurable_fields, (
-                f"SECURITY VIOLATION: Non-configurable field '{key}' returned by get_bank_config(). "
-                f"Only configurable fields should be returned to prevent leaking system config."
-            )
-            assert key not in credential_fields, (
-                f"SECURITY VIOLATION: Credential field '{key}' returned by get_bank_config(). "
-                f"Credentials must NEVER be exposed via API."
-            )
-
-        # SECURITY: Verify specific sensitive fields are NOT present
-        sensitive_fields = [
-            "database_url", "api_port", "host", "worker_count",  # Infrastructure
-            "llm_api_key", "llm_base_url",  # Credentials
-            "retain_llm_api_key", "reflect_llm_api_key",  # More credentials
-            "llm_provider", "llm_model",  # Not configurable (need presets)
-        ]
-        for field in sensitive_fields:
-            assert field not in config, (
-                f"SECURITY VIOLATION: Sensitive field '{field}' returned by get_bank_config(). "
-                f"Must not be exposed via bank config API."
-            )
-
-        # Verify we have the expected configurable fields (small set)
-        expected_configurable = ["retain_chunk_size", "retain_extraction_mode", "enable_observations"]
-        for field in expected_configurable:
-            assert field in config, f"Expected configurable field '{field}' missing from config"
-
-        # Should have a small number of configurable fields (not hundreds)
-        assert len(config) < 20, f"Too many fields returned: {len(config)}"
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_config_permissions_system(memory, request_context):
-    """
-    Test that tenant extension can control which fields banks are allowed to modify.
-
-    Tests get_allowed_config_fields() permission system.
-    """
-    bank_id = "test-permissions-bank"
-
-    class PermissionTenantExtension(TenantExtension):
-        """Mock tenant extension with configurable permissions."""
-
-        def __init__(self, allowed_fields: set[str] | None):
-            self.allowed_fields = allowed_fields
-
-        async def authenticate(self, context):
-            from hindsight_api.extensions.tenant import TenantContext
-
-            return TenantContext(schema_name="public")
-
-        async def list_tenants(self):
-            from hindsight_api.extensions.tenant import Tenant
-
-            return [Tenant(schema="public")]
-
-        async def get_allowed_config_fields(self, context, bank_id):
-            """Return configured allowed fields."""
-            return self.allowed_fields
-
-    try:
-        # Ensure bank exists in database
-        await memory.get_bank_profile(bank_id, request_context=request_context)
-
-        # Test 1: None = allow all configurable fields
-        extension = PermissionTenantExtension(allowed_fields=None)
-        resolver = ConfigResolver(pool=memory._pool, tenant_extension=extension)
-
-        await resolver.update_bank_config(
-            bank_id, {"retain_chunk_size": 4000, "retain_extraction_mode": "verbose"}, request_context
-        )
-        config = await resolver.get_bank_config(bank_id, request_context)
-        assert config["retain_chunk_size"] == 4000
-        assert config["retain_extraction_mode"] == "verbose"
-
-        # Reset for next test
-        await resolver.reset_bank_config(bank_id)
-
-        # Test 2: Specific set = only those fields allowed
-        extension = PermissionTenantExtension(allowed_fields={"retain_chunk_size"})
-        resolver = ConfigResolver(pool=memory._pool, tenant_extension=extension)
-
-        # Should allow retain_chunk_size
-        await resolver.update_bank_config(bank_id, {"retain_chunk_size": 5000}, request_context)
-        config = await resolver.get_bank_config(bank_id, request_context)
-        assert config["retain_chunk_size"] == 5000
-
-        # Should reject retain_extraction_mode (not in allowed list)
-        with pytest.raises(ValueError, match="Not allowed to modify fields"):
-            await resolver.update_bank_config(bank_id, {"retain_extraction_mode": "verbose"}, request_context)
-
-        # Should reject mix of allowed and disallowed
-        with pytest.raises(ValueError, match="Not allowed to modify fields"):
-            await resolver.update_bank_config(
-                bank_id, {"retain_chunk_size": 6000, "retain_extraction_mode": "verbose"}, request_context
-            )
-
-        # Reset for next test
-        await resolver.reset_bank_config(bank_id)
-
-        # Test 3: Empty set = no modifications allowed (read-only)
-        extension = PermissionTenantExtension(allowed_fields=set())
-        resolver = ConfigResolver(pool=memory._pool, tenant_extension=extension)
-
-        with pytest.raises(ValueError, match="Not allowed to modify fields"):
-            await resolver.update_bank_config(bank_id, {"retain_chunk_size": 7000}, request_context)
-
-        # Test 4: get_bank_config should filter response based on permissions
-        extension = PermissionTenantExtension(allowed_fields={"retain_chunk_size", "enable_observations"})
-        resolver = ConfigResolver(pool=memory._pool, tenant_extension=extension)
-
-        config = await resolver.get_bank_config(bank_id, request_context)
-
-        # Should only return allowed fields
-        assert "retain_chunk_size" in config
-        assert "enable_observations" in config
-        # Other configurable fields should be filtered out
-        assert "retain_extraction_mode" not in config
-        assert "retain_custom_instructions" not in config
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)

hindsight-api/tests/test_http_api_integration.py

@@ -528,7 +528,7 @@ async def test_delete_bank(api_client):
                 {
                     "content": "Bob is the CTO and leads the engineering team.",
                     "context": "team info",
-                    "document_id": "team-doc-2",
+                    "document_id": "team-doc-1",
                 },
             ]
         },

hindsight-api/tests/test_link_expansion_retrieval.py

@@ -12,9 +12,9 @@ import pytest
 @pytest.fixture(autouse=True)
 def enable_observations():
     """Enable observations for all tests in this module."""
-    from hindsight_api.config import _get_raw_config
+    from hindsight_api.config import get_config
 
-    config = _get_raw_config()
+    config = get_config()
     original_value = config.enable_observations
     config.enable_observations = True
     yield

hindsight-api/tests/test_litellm_sdk_cross_encoder.py

@@ -1,392 +0,0 @@
-"""
-Tests for LiteLLMSDKCrossEncoder.
-
-Tests the LiteLLM SDK-based cross-encoder implementation for reranking.
-"""
-
-import os
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from hindsight_api.engine.cross_encoder import LiteLLMSDKCrossEncoder, create_cross_encoder_from_env
-
-
-class TestLiteLLMSDKCrossEncoder:
-    """Test suite for LiteLLMSDKCrossEncoder class."""
-
-    @pytest.mark.asyncio
-    async def test_initialization_success(self):
-        """Test successful initialization with valid config."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="deepinfra/Qwen3-reranker-8B",
-        )
-
-        assert encoder.provider_name == "litellm-sdk"
-        assert encoder.api_key == "test_key"
-        assert encoder.model == "deepinfra/Qwen3-reranker-8B"
-        assert encoder._initialized is False
-
-        # Mock the litellm import
-        mock_litellm = MagicMock()
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-            assert encoder._initialized is True
-
-    @pytest.mark.asyncio
-    async def test_initialization_missing_package(self):
-        """Test initialization fails when litellm package is missing."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="cohere/rerank-english-v3.0",
-        )
-
-        with patch.dict("sys.modules", {"litellm": None}):
-            with pytest.raises(ImportError, match="litellm is required"):
-                await encoder.initialize()
-
-    @pytest.mark.asyncio
-    async def test_initialization_idempotent(self):
-        """Test that calling initialize() multiple times is safe."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="cohere/rerank-english-v3.0",
-        )
-
-        mock_litellm = MagicMock()
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-            assert encoder._initialized is True
-
-            # Second call should be no-op
-            await encoder.initialize()
-            assert encoder._initialized is True
-
-    @pytest.mark.asyncio
-    async def test_predict_single_query(self):
-        """Test prediction with a single query and multiple documents."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="deepinfra/Qwen3-reranker-8B",
-        )
-
-        # Create mock response with results as TypedDicts
-        mock_response = MagicMock()
-        mock_response.results = [
-            {"index": 0, "relevance_score": 0.9},
-            {"index": 1, "relevance_score": 0.7},
-            {"index": 2, "relevance_score": 0.5},
-        ]
-
-        mock_litellm = MagicMock()
-        mock_litellm.arerank = AsyncMock(return_value=mock_response)
-
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-
-            pairs = [
-                ("What is Python?", "Python is a programming language"),
-                ("What is Python?", "Python is a snake"),
-                ("What is Python?", "Python is a British comedy group"),
-            ]
-
-            scores = await encoder.predict(pairs)
-
-            assert len(scores) == 3
-            assert scores == [0.9, 0.7, 0.5]
-
-            # Verify arerank was called correctly
-            mock_litellm.arerank.assert_called_once()
-            call_args = mock_litellm.arerank.call_args
-            assert call_args.kwargs["model"] == "deepinfra/Qwen3-reranker-8B"
-            assert call_args.kwargs["query"] == "What is Python?"
-            assert len(call_args.kwargs["documents"]) == 3
-            assert call_args.kwargs["api_key"] == "test_key"
-
-    @pytest.mark.asyncio
-    async def test_predict_multiple_queries(self):
-        """Test prediction with multiple different queries (grouped efficiently)."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="cohere/rerank-english-v3.0",
-        )
-
-        # First query response
-        mock_response1 = MagicMock()
-        mock_response1.results = [
-            {"index": 0, "relevance_score": 0.9},
-            {"index": 1, "relevance_score": 0.7},
-        ]
-
-        # Second query response
-        mock_response2 = MagicMock()
-        mock_response2.results = [
-            {"index": 0, "relevance_score": 0.8},
-        ]
-
-        mock_litellm = MagicMock()
-        mock_litellm.arerank = AsyncMock(side_effect=[mock_response1, mock_response2])
-
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-
-            pairs = [
-                ("What is Python?", "Python is a programming language"),
-                ("What is Python?", "Python is a snake"),
-                ("What is Java?", "Java is a programming language"),
-            ]
-
-            scores = await encoder.predict(pairs)
-
-            assert len(scores) == 3
-            assert scores[0] == 0.9  # First query, first doc
-            assert scores[1] == 0.7  # First query, second doc
-            assert scores[2] == 0.8  # Second query, first doc
-
-            # Verify arerank was called twice (once per unique query)
-            assert mock_litellm.arerank.call_count == 2
-
-    @pytest.mark.asyncio
-    async def test_predict_empty_pairs(self):
-        """Test prediction with empty input."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="cohere/rerank-english-v3.0",
-        )
-
-        mock_litellm = MagicMock()
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-            scores = await encoder.predict([])
-            assert scores == []
-
-    @pytest.mark.asyncio
-    async def test_predict_not_initialized(self):
-        """Test that predict fails if encoder not initialized."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="cohere/rerank-english-v3.0",
-        )
-
-        pairs = [("query", "document")]
-
-        with pytest.raises(RuntimeError, match="not initialized"):
-            await encoder.predict(pairs)
-
-    @pytest.mark.asyncio
-    async def test_predict_error_handling(self):
-        """Test that errors during prediction are raised."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="cohere/rerank-english-v3.0",
-        )
-
-        # Mock litellm to raise an error
-        mock_litellm = MagicMock()
-        mock_litellm.arerank = AsyncMock(side_effect=Exception("API Error"))
-
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-
-            pairs = [
-                ("What is Python?", "Python is a programming language"),
-            ]
-
-            # Should raise the exception
-            with pytest.raises(Exception, match="API Error"):
-                await encoder.predict(pairs)
-
-    @pytest.mark.asyncio
-    async def test_custom_api_base(self):
-        """Test that custom API base URL is passed to rerank calls."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="cohere/rerank-english-v3.0",
-            api_base="https://custom.api.example.com",
-        )
-
-        mock_response = MagicMock()
-        mock_response.results = [
-            {"index": 0, "relevance_score": 0.9},
-        ]
-
-        mock_litellm = MagicMock()
-        mock_litellm.arerank = AsyncMock(return_value=mock_response)
-
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-
-            # Test that api_base is passed to arerank
-            pairs = [("query", "document")]
-            scores = await encoder.predict(pairs)
-
-            assert scores == [0.9]
-            mock_litellm.arerank.assert_called_once()
-            call_args = mock_litellm.arerank.call_args
-            assert call_args.kwargs["api_base"] == "https://custom.api.example.com"
-
-    @pytest.mark.asyncio
-    async def test_response_with_direct_score_list(self):
-        """Test handling of response format with direct score list."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key="test_key",
-            model="some-provider/model",
-        )
-
-        # Mock litellm to return direct list of scores
-        mock_litellm = MagicMock()
-        mock_litellm.arerank = AsyncMock(return_value=[0.9, 0.7, 0.5])
-
-        with patch.dict("sys.modules", {"litellm": mock_litellm}):
-            await encoder.initialize()
-
-            pairs = [
-                ("query", "doc1"),
-                ("query", "doc2"),
-                ("query", "doc3"),
-            ]
-
-            scores = await encoder.predict(pairs)
-
-            assert scores == [0.9, 0.7, 0.5]
-
-
-class TestFactoryFunction:
-    """Test suite for create_cross_encoder_from_env factory function."""
-
-    @pytest.mark.asyncio
-    async def test_create_litellm_sdk_from_env(self):
-        """Test creating LiteLLM SDK cross-encoder from environment variables."""
-        env_vars = {
-            "HINDSIGHT_API_RERANKER_PROVIDER": "litellm-sdk",
-            "HINDSIGHT_API_RERANKER_LITELLM_SDK_API_KEY": "test_key",
-            "HINDSIGHT_API_RERANKER_LITELLM_SDK_MODEL": "deepinfra/Qwen3-reranker-8B",
-        }
-
-        with patch.dict(os.environ, env_vars, clear=False):
-            # Need to reload config to pick up env vars
-            from hindsight_api.config import HindsightConfig
-
-            config = HindsightConfig.from_env()
-
-            with patch("hindsight_api.config.get_config", return_value=config):
-                encoder = create_cross_encoder_from_env()
-
-                assert isinstance(encoder, LiteLLMSDKCrossEncoder)
-                assert encoder.api_key == "test_key"
-                assert encoder.model == "deepinfra/Qwen3-reranker-8B"
-
-    @pytest.mark.asyncio
-    async def test_create_litellm_sdk_missing_api_key(self):
-        """Test that factory raises error when API key is missing."""
-        env_vars = {
-            "HINDSIGHT_API_RERANKER_PROVIDER": "litellm-sdk",
-            "HINDSIGHT_API_RERANKER_LITELLM_SDK_MODEL": "deepinfra/Qwen3-reranker-8B",
-        }
-
-        with patch.dict(os.environ, env_vars, clear=False):
-            # Remove API key if set
-            if "HINDSIGHT_API_RERANKER_LITELLM_SDK_API_KEY" in os.environ:
-                del os.environ["HINDSIGHT_API_RERANKER_LITELLM_SDK_API_KEY"]
-
-            from hindsight_api.config import HindsightConfig
-
-            config = HindsightConfig.from_env()
-
-            with patch("hindsight_api.config.get_config", return_value=config):
-                with pytest.raises(ValueError, match="HINDSIGHT_API_RERANKER_LITELLM_SDK_API_KEY is required"):
-                    create_cross_encoder_from_env()
-
-    @pytest.mark.asyncio
-    async def test_create_litellm_sdk_with_custom_api_base(self):
-        """Test creating LiteLLM SDK cross-encoder with custom API base."""
-        env_vars = {
-            "HINDSIGHT_API_RERANKER_PROVIDER": "litellm-sdk",
-            "HINDSIGHT_API_RERANKER_LITELLM_SDK_API_KEY": "test_key",
-            "HINDSIGHT_API_RERANKER_LITELLM_SDK_MODEL": "cohere/rerank-english-v3.0",
-            "HINDSIGHT_API_RERANKER_LITELLM_SDK_API_BASE": "https://custom.api.example.com",
-        }
-
-        with patch.dict(os.environ, env_vars, clear=False):
-            from hindsight_api.config import HindsightConfig
-
-            config = HindsightConfig.from_env()
-
-            with patch("hindsight_api.config.get_config", return_value=config):
-                encoder = create_cross_encoder_from_env()
-
-                assert isinstance(encoder, LiteLLMSDKCrossEncoder)
-                assert encoder.api_base == "https://custom.api.example.com"
-
-
-class TestLiteLLMSDKCohereCrossEncoder:
-    """Tests for LiteLLM SDK calling Cohere (runs in CI with COHERE_API_KEY)."""
-
-    @pytest.fixture
-    async def litellm_cohere_cross_encoder(self):
-        """Create LiteLLM SDK cross-encoder instance for Cohere."""
-        if not os.environ.get("COHERE_API_KEY"):
-            pytest.skip("Cohere API key not available (set COHERE_API_KEY)")
-
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key=os.environ["COHERE_API_KEY"],
-            model="cohere/rerank-english-v3.0",
-        )
-        await encoder.initialize()
-        return encoder
-
-    @pytest.mark.asyncio
-    async def test_litellm_sdk_cohere_initialization(self, litellm_cohere_cross_encoder):
-        """Test that LiteLLM SDK Cohere cross-encoder initializes correctly."""
-        assert litellm_cohere_cross_encoder.provider_name == "litellm-sdk"
-        assert litellm_cohere_cross_encoder.model == "cohere/rerank-english-v3.0"
-
-    @pytest.mark.asyncio
-    async def test_litellm_sdk_cohere_predict(self, litellm_cohere_cross_encoder):
-        """Test that LiteLLM SDK can call Cohere rerank API."""
-        pairs = [
-            ("What is the capital of France?", "Paris is the capital of France."),
-            ("What is the capital of France?", "The Eiffel Tower is in Paris."),
-            ("What is the capital of France?", "Python is a programming language."),
-        ]
-        scores = await litellm_cohere_cross_encoder.predict(pairs)
-
-        assert len(scores) == 3
-        assert all(isinstance(s, float) for s in scores)
-        # The first result should be most relevant
-        assert scores[0] > scores[2], "Direct answer should score higher than unrelated text"
-        # All scores should be in valid range
-        assert all(0.0 <= score <= 1.0 for score in scores)
-
-
-class TestIntegration:
-    """Integration tests with real API (optional - requires API keys)."""
-
-    @pytest.mark.skipif(
-        not os.environ.get("DEEPINFRA_API_KEY"),
-        reason="DEEPINFRA_API_KEY not set - skipping integration test",
-    )
-    @pytest.mark.asyncio
-    async def test_real_deepinfra_api(self):
-        """Test with real DeepInfra API (requires DEEPINFRA_API_KEY env var)."""
-        encoder = LiteLLMSDKCrossEncoder(
-            api_key=os.environ["DEEPINFRA_API_KEY"],
-            model="deepinfra/Qwen3-reranker-8B",
-        )
-
-        await encoder.initialize()
-
-        pairs = [
-            ("What is Python?", "Python is a high-level programming language"),
-            ("What is Python?", "Python is a species of snake"),
-            ("What is Python?", "Python is unrelated text about cars"),
-        ]
-
-        scores = await encoder.predict(pairs)
-
-        # First doc should have highest score (most relevant)
-        assert len(scores) == 3
-        assert scores[0] > scores[1]
-        assert scores[1] > scores[2]
-        assert all(0.0 <= score <= 1.0 for score in scores)

hindsight-api/tests/test_litellm_sdk_embeddings.py

@@ -1,387 +0,0 @@
-"""
-Tests for LiteLLM SDK embeddings implementation.
-
-These tests cover:
-1. Initialization (success, missing package, missing API key, idempotent)
-2. Encode (single text, multiple texts, batching, error handling)
-3. Provider-specific configuration (Cohere, OpenAI, etc.)
-4. Factory function (create from env, validation errors)
-5. Dimension detection
-"""
-
-import os
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from hindsight_api.config import (
-    ENV_EMBEDDINGS_LITELLM_SDK_API_KEY,
-    ENV_EMBEDDINGS_LITELLM_SDK_MODEL,
-    ENV_EMBEDDINGS_PROVIDER,
-    HindsightConfig,
-)
-from hindsight_api.engine.embeddings import LiteLLMSDKEmbeddings, create_embeddings_from_env
-
-
-class TestLiteLLMSDKEmbeddings:
-    """Unit tests for LiteLLMSDKEmbeddings with mocked litellm responses."""
-
-    @pytest.fixture
-    def mock_litellm(self):
-        """Mock litellm module."""
-        mock = MagicMock()
-
-        # Mock aembedding (async) for initialization
-        mock_response = MagicMock()
-        mock_response.data = [{"embedding": [0.1] * 768, "index": 0}]
-        mock.aembedding = AsyncMock(return_value=mock_response)
-
-        # Mock embedding (sync) for encode
-        mock_sync_response = MagicMock()
-        mock_sync_response.data = [
-            {"embedding": [0.1] * 768, "index": 0},
-            {"embedding": [0.2] * 768, "index": 1},
-        ]
-        mock.embedding = MagicMock(return_value=mock_sync_response)
-
-        return mock
-
-    @pytest.fixture
-    async def embeddings(self, mock_litellm):
-        """Create initialized LiteLLMSDKEmbeddings instance."""
-        emb = LiteLLMSDKEmbeddings(
-            api_key="test_key",
-            model="cohere/embed-english-v3.0",
-            api_base=None,
-            batch_size=100,
-            timeout=60.0,
-        )
-        # Manually set the mock (simulating successful initialization)
-        emb._litellm = mock_litellm
-        emb._dimension = 768
-        return emb
-
-    async def test_initialization_success(self, mock_litellm):
-        """Test successful initialization."""
-        with patch("builtins.__import__", side_effect=lambda name, *args: mock_litellm if name == "litellm" else __import__(name, *args)):
-            emb = LiteLLMSDKEmbeddings(
-                api_key="test_key",
-                model="cohere/embed-english-v3.0",
-                api_base=None,
-                batch_size=100,
-                timeout=60.0,
-            )
-
-            assert emb._litellm is None
-            assert emb._dimension is None
-
-            await emb.initialize()
-
-            assert emb._litellm is not None
-            assert emb._dimension == 768
-
-            # Verify test embedding was called
-            mock_litellm.aembedding.assert_called_once_with(
-                model="cohere/embed-english-v3.0",
-                input=["test"],
-                api_key="test_key",
-            )
-
-    async def test_initialization_missing_package(self):
-        """Test initialization fails gracefully when litellm is not installed."""
-        def mock_import(name, *args):
-            if name == "litellm":
-                raise ImportError("No module named 'litellm'")
-            return __import__(name, *args)
-
-        with patch("builtins.__import__", side_effect=mock_import):
-            emb = LiteLLMSDKEmbeddings(
-                api_key="test_key",
-                model="cohere/embed-english-v3.0",
-                api_base=None,
-                batch_size=100,
-                timeout=60.0,
-            )
-
-            with pytest.raises(ImportError, match="litellm is required"):
-                await emb.initialize()
-
-    async def test_initialization_idempotent(self, embeddings, mock_litellm):
-        """Test that calling initialize() multiple times is safe."""
-        # embeddings._litellm is already set in fixture
-        assert embeddings._litellm is not None
-
-        # Call again
-        await embeddings.initialize()
-
-        # Should still have same litellm instance
-        assert embeddings._litellm is not None
-
-    async def test_encode_single_text(self, embeddings, mock_litellm):
-        """Test encoding a single text."""
-        # Set up mock response
-        mock_litellm.embedding.return_value.data = [
-            {"embedding": [0.5] * 768, "index": 0},
-        ]
-
-        result = embeddings.encode(["Hello world"])
-
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert len(result[0]) == 768
-        assert all(isinstance(x, float) for x in result[0])
-        assert all(abs(x - 0.5) < 0.001 for x in result[0])
-
-        # Verify call
-        mock_litellm.embedding.assert_called_once_with(
-            model="cohere/embed-english-v3.0",
-            input=["Hello world"],
-            api_key="test_key",
-        )
-
-    async def test_encode_multiple_texts(self, embeddings, mock_litellm):
-        """Test encoding multiple texts."""
-        # Set up mock response
-        mock_litellm.embedding.return_value.data = [
-            {"embedding": [0.1] * 768, "index": 0},
-            {"embedding": [0.2] * 768, "index": 1},
-            {"embedding": [0.3] * 768, "index": 2},
-        ]
-
-        texts = ["First text", "Second text", "Third text"]
-        result = embeddings.encode(texts)
-
-        assert isinstance(result, list)
-        assert len(result) == 3
-        assert len(result[0]) == 768
-        assert len(result[1]) == 768
-        assert len(result[2]) == 768
-        assert all(abs(x - 0.1) < 0.001 for x in result[0])
-        assert all(abs(x - 0.2) < 0.001 for x in result[1])
-        assert all(abs(x - 0.3) < 0.001 for x in result[2])
-
-    async def test_encode_batching(self, embeddings, mock_litellm):
-        """Test that large inputs are batched correctly."""
-        # Create embeddings with small batch size
-        emb = LiteLLMSDKEmbeddings(
-            api_key="test_key",
-            model="cohere/embed-english-v3.0",
-            api_base=None,
-            batch_size=2,  # Small batch for testing
-            timeout=60.0,
-        )
-        emb._litellm = mock_litellm
-        emb._initialized = True
-        emb._dimension = 768
-
-        # Mock responses for each batch
-        def mock_embedding_side_effect(model, input, **kwargs):
-            mock_response = MagicMock()
-            mock_response.data = [
-                {"embedding": [float(i)] * 768, "index": i} for i in range(len(input))
-            ]
-            return mock_response
-
-        mock_litellm.embedding.side_effect = mock_embedding_side_effect
-
-        # Encode 5 texts (should create 3 batches: 2, 2, 1)
-        texts = [f"Text {i}" for i in range(5)]
-        result = emb.encode(texts)
-
-        assert isinstance(result, list)
-        assert len(result) == 5
-        assert all(len(embedding) == 768 for embedding in result)
-
-        # Verify batching: should be called 3 times
-        assert mock_litellm.embedding.call_count == 3
-
-        # Verify batch sizes
-        calls = mock_litellm.embedding.call_args_list
-        assert len(calls[0][1]["input"]) == 2  # First batch
-        assert len(calls[1][1]["input"]) == 2  # Second batch
-        assert len(calls[2][1]["input"]) == 1  # Third batch
-
-    async def test_encode_empty_list(self, embeddings):
-        """Test encoding empty list returns empty list."""
-        result = embeddings.encode([])
-
-        assert isinstance(result, list)
-        assert len(result) == 0
-
-    async def test_encode_before_initialization(self, mock_litellm):
-        """Test that encode raises error if not initialized."""
-        emb = LiteLLMSDKEmbeddings(
-            api_key="test_key",
-            model="cohere/embed-english-v3.0",
-            api_base=None,
-            batch_size=100,
-            timeout=60.0,
-        )
-
-        with pytest.raises(RuntimeError, match="not initialized"):
-            emb.encode(["test"])
-
-    async def test_encode_error_handling(self, embeddings, mock_litellm):
-        """Test error handling during encoding."""
-        # Make embedding raise an error
-        mock_litellm.embedding.side_effect = Exception("API Error")
-
-        with pytest.raises(Exception, match="API Error"):
-            embeddings.encode(["test"])
-
-    async def test_dimension_property(self, embeddings):
-        """Test dimension property."""
-        assert embeddings.dimension == 768
-
-    async def test_dimension_before_initialization(self, mock_litellm):
-        """Test dimension raises error if not initialized."""
-        emb = LiteLLMSDKEmbeddings(
-            api_key="test_key",
-            model="cohere/embed-english-v3.0",
-            api_base=None,
-            batch_size=100,
-            timeout=60.0,
-        )
-
-        with pytest.raises(RuntimeError, match="not initialized"):
-            _ = emb.dimension
-
-    async def test_custom_api_base(self, mock_litellm):
-        """Test custom API base URL is passed to embedding calls."""
-        with patch("builtins.__import__", side_effect=lambda name, *args: mock_litellm if name == "litellm" else __import__(name, *args)):
-            emb = LiteLLMSDKEmbeddings(
-                api_key="test_key",
-                model="cohere/embed-english-v3.0",
-                api_base="https://custom.api.com",
-                batch_size=100,
-                timeout=60.0,
-            )
-
-            await emb.initialize()
-
-            # Verify api_base is set
-            assert emb.api_base == "https://custom.api.com"
-
-            # Verify api_base is passed to aembedding
-            mock_litellm.aembedding.assert_called_once()
-            call_args = mock_litellm.aembedding.call_args
-            assert call_args.kwargs["api_base"] == "https://custom.api.com"
-
-            # Test encode also passes api_base
-            mock_litellm.embedding.return_value.data = [{"embedding": [0.1] * 768, "index": 0}]
-            emb.encode(["test"])
-
-            mock_litellm.embedding.assert_called_once()
-            call_args = mock_litellm.embedding.call_args
-            assert call_args.kwargs["api_base"] == "https://custom.api.com"
-
-
-class TestLiteLLMSDKEmbeddingsFactory:
-    """Test the factory function for creating LiteLLM SDK embeddings."""
-
-    def test_create_from_env_success(self, monkeypatch):
-        """Test creating embeddings from environment variables."""
-        # Mock get_config() to return configured HindsightConfig
-        mock_config = MagicMock()
-        mock_config.embeddings_provider = "litellm-sdk"
-        mock_config.embeddings_litellm_sdk_api_key = "test_key"
-        mock_config.embeddings_litellm_sdk_model = "cohere/embed-english-v3.0"
-        mock_config.embeddings_litellm_sdk_api_base = None
-
-        with patch("hindsight_api.config.get_config", return_value=mock_config):
-            embeddings = create_embeddings_from_env()
-
-            assert isinstance(embeddings, LiteLLMSDKEmbeddings)
-            assert embeddings.api_key == "test_key"
-            assert embeddings.model == "cohere/embed-english-v3.0"
-
-    def test_create_from_env_missing_api_key(self, monkeypatch):
-        """Test that missing API key raises error."""
-        # Mock get_config() with missing API key
-        mock_config = MagicMock()
-        mock_config.embeddings_provider = "litellm-sdk"
-        mock_config.embeddings_litellm_sdk_api_key = None  # Missing key
-        mock_config.embeddings_litellm_sdk_model = "cohere/embed-english-v3.0"
-
-        with patch("hindsight_api.config.get_config", return_value=mock_config):
-            with pytest.raises(ValueError, match=ENV_EMBEDDINGS_LITELLM_SDK_API_KEY):
-                create_embeddings_from_env()
-
-    def test_create_from_env_with_api_base(self, monkeypatch):
-        """Test creating embeddings with custom API base."""
-        # Mock get_config() with custom API base
-        mock_config = MagicMock()
-        mock_config.embeddings_provider = "litellm-sdk"
-        mock_config.embeddings_litellm_sdk_api_key = "test_key"
-        mock_config.embeddings_litellm_sdk_model = "cohere/embed-english-v3.0"
-        mock_config.embeddings_litellm_sdk_api_base = "https://custom.api.com"
-
-        with patch("hindsight_api.config.get_config", return_value=mock_config):
-            embeddings = create_embeddings_from_env()
-
-            assert isinstance(embeddings, LiteLLMSDKEmbeddings)
-            assert embeddings.api_base == "https://custom.api.com"
-
-
-class TestLiteLLMSDKCohereEmbeddings:
-    """Integration tests calling real Cohere API (matches CI pattern)."""
-
-    @pytest.fixture
-    async def litellm_cohere_embeddings(self):
-        """Create embeddings instance with real Cohere API key."""
-        if not os.environ.get("COHERE_API_KEY"):
-            pytest.skip("Cohere API key not available")
-
-        emb = LiteLLMSDKEmbeddings(
-            api_key=os.environ["COHERE_API_KEY"],
-            model="cohere/embed-english-v3.0",
-            api_base=None,
-            batch_size=100,
-            timeout=60.0,
-        )
-        await emb.initialize()
-        return emb
-
-    @pytest.mark.asyncio
-    async def test_litellm_sdk_cohere_encode(self, litellm_cohere_embeddings):
-        """Test real Cohere API call for embeddings."""
-        texts = [
-            "The quick brown fox jumps over the lazy dog",
-            "Machine learning is a subset of artificial intelligence",
-            "Python is a popular programming language",
-        ]
-
-        result = litellm_cohere_embeddings.encode(texts)
-
-        # Verify result type and shape
-        assert isinstance(result, list)
-        assert len(result) == 3
-        assert all(len(embedding) > 0 for embedding in result)
-        assert all(isinstance(x, float) for x in result[0])
-
-        # Verify embeddings are not zeros (common API failure mode)
-        for i, embedding in enumerate(result):
-            assert not all(abs(x) < 0.0001 for x in embedding), f"Embedding {i} is all zeros"
-
-        # Verify embeddings are normalized (Cohere returns normalized vectors)
-        for i, embedding in enumerate(result):
-            norm = sum(x * x for x in embedding) ** 0.5
-            assert 0.9 < norm < 1.1, f"Embedding {i} norm {norm} is not close to 1.0"
-
-    @pytest.mark.asyncio
-    async def test_litellm_sdk_cohere_dimension(self, litellm_cohere_embeddings):
-        """Test dimension detection with real Cohere API."""
-        dimension = litellm_cohere_embeddings.dimension
-
-        # Cohere embed-english-v3.0 has 1024 dimensions
-        assert dimension == 1024
-
-    @pytest.mark.asyncio
-    async def test_litellm_sdk_cohere_single_text(self, litellm_cohere_embeddings):
-        """Test encoding single text with real Cohere API."""
-        result = litellm_cohere_embeddings.encode(["Hello world"])
-
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert len(result[0]) == 1024
-        assert not all(abs(x) < 0.0001 for x in result[0])

hindsight-api/tests/test_load_large_batch.py

@@ -209,7 +209,7 @@ class TestLargeBatchRetain:
                 raise
 
     @pytest.mark.asyncio
-    @pytest.mark.timeout(240)  # Increased timeout for VectorChord BM25 tokenization
+    @pytest.mark.timeout(120)
     async def test_batch_chunking_behavior(self, memory_with_mock_llm, request_context):
         """
         Test that large batches are properly chunked into sub-batches.

hindsight-api/tests/test_main_module.py

@@ -45,7 +45,7 @@ class TestMainModuleExtensionLoading:
 
         with patch("hindsight_api.main.MemoryEngine") as mock_engine, \
              patch("hindsight_api.main.create_app") as mock_create_app, \
-             patch("hindsight_api.main._get_raw_config") as mock_get_config, \
+             patch("hindsight_api.main.get_config") as mock_get_config, \
              patch("hindsight_api.main.load_extension", side_effect=tracking_load_extension), \
              patch("hindsight_api.main.DefaultExtensionContext"), \
              patch("hindsight_api.main.print_banner"), \
@@ -96,7 +96,7 @@ class TestMainModuleExtensionLoading:
 
         with patch("hindsight_api.main.MemoryEngine") as mock_engine, \
              patch("hindsight_api.main.create_app") as mock_create_app, \
-             patch("hindsight_api.main._get_raw_config") as mock_get_config, \
+             patch("hindsight_api.main.get_config") as mock_get_config, \
              patch("hindsight_api.main.load_extension", side_effect=tracking_load_extension), \
              patch("hindsight_api.main.DefaultExtensionContext"), \
              patch("hindsight_api.main.print_banner"), \
@@ -143,7 +143,7 @@ class TestMainModuleExtensionLoading:
 
         with patch("hindsight_api.main.MemoryEngine", side_effect=capture_memory_engine), \
              patch("hindsight_api.main.create_app") as mock_create_app, \
-             patch("hindsight_api.main._get_raw_config") as mock_get_config, \
+             patch("hindsight_api.main.get_config") as mock_get_config, \
              patch("hindsight_api.main.DefaultExtensionContext"), \
              patch("hindsight_api.main.print_banner"), \
              patch("uvicorn.run"):
@@ -200,7 +200,7 @@ class TestMainModuleExtensionLoading:
 
         with patch("hindsight_api.main.MemoryEngine", side_effect=capture_memory_engine), \
              patch("hindsight_api.main.create_app") as mock_create_app, \
-             patch("hindsight_api.main._get_raw_config") as mock_get_config, \
+             patch("hindsight_api.main.get_config") as mock_get_config, \
              patch("hindsight_api.main.DefaultExtensionContext", side_effect=capture_context), \
              patch("hindsight_api.main.print_banner"), \
              patch("uvicorn.run"):
@@ -242,7 +242,7 @@ class TestMainModuleExtensionLoading:
 
         with patch("hindsight_api.main.MemoryEngine", side_effect=capture_memory_engine), \
              patch("hindsight_api.main.create_app") as mock_create_app, \
-             patch("hindsight_api.main._get_raw_config") as mock_get_config, \
+             patch("hindsight_api.main.get_config") as mock_get_config, \
              patch("hindsight_api.main.print_banner"), \
              patch("uvicorn.run"):
 
@@ -287,7 +287,7 @@ class TestMainModuleExtensionLoading:
 
         with patch("hindsight_api.main.MemoryEngine") as mock_engine, \
              patch("hindsight_api.main.create_app", return_value=mock_app), \
-             patch("hindsight_api.main._get_raw_config") as mock_get_config, \
+             patch("hindsight_api.main.get_config") as mock_get_config, \
              patch("hindsight_api.main.print_banner"), \
              patch("uvicorn.run", side_effect=capture_uvicorn_run):
 
@@ -327,7 +327,7 @@ class TestMainModuleExtensionLoading:
 
         with patch("hindsight_api.main.MemoryEngine") as mock_engine, \
              patch("hindsight_api.main.create_app") as mock_create_app, \
-             patch("hindsight_api.main._get_raw_config") as mock_get_config, \
+             patch("hindsight_api.main.get_config") as mock_get_config, \
              patch("hindsight_api.main.print_banner"), \
              patch("uvicorn.run", side_effect=capture_uvicorn_run):
 

hindsight-api/tests/test_observations.py

@@ -8,14 +8,14 @@ populated from the summary for backwards compatibility.
 import pytest
 from hindsight_api.engine.memory_engine import Budget
 from hindsight_api import RequestContext
-from hindsight_api.config import _get_raw_config
+from hindsight_api.config import get_config
 from datetime import datetime, timezone
 
 
 @pytest.fixture
 def disable_observations():
     """Disable observations for a specific test."""
-    config = _get_raw_config()
+    config = get_config()
     original_value = config.enable_observations
     config.enable_observations = False
     yield

hindsight-api/tests/test_recall_chunks_independence.py

@@ -1,274 +0,0 @@
-"""
-Test that recall chunks are fetched independently of max_tokens filtering.
-
-This test verifies the new behavior where:
-1. Chunks are fetched BEFORE max_tokens filtering
-2. max_tokens=0 returns 0 facts but can still return chunks
-3. Chunks are fetched in batches to handle varying chunk sizes
-"""
-
-import pytest
-import pytest_asyncio
-
-from hindsight_api.engine.memory_engine import Budget
-
-
-@pytest.mark.asyncio
-async def test_recall_chunks_independent_of_max_tokens(memory, request_context):
-    """
-    Test that chunks are fetched independently of max_tokens.
-
-    When max_tokens=0, recall should:
-    - Return 0 memory facts
-    - Still return chunks (up to max_chunk_tokens)
-    - Chunks should come from top-scored results before token filtering
-    """
-    bank_id = "test-chunks-independence"
-
-    try:
-
-        # Retain some test content with substantial size to generate chunks
-        test_content = """
-        The quantum computing research team at MIT has made significant breakthroughs.
-        Dr. Sarah Chen leads the team and focuses on quantum error correction.
-        The team published three papers in Nature Physics this year.
-        Their work on topological qubits shows promise for scalable quantum computers.
-        Collaborators include IBM Research and Google Quantum AI.
-        The research is funded by a $5M NSF grant running through 2026.
-        """ * 10  # Repeat to ensure we get multiple chunks
-
-        await memory.retain_async(
-            bank_id=bank_id,
-            content=test_content,
-            context="research notes",
-            request_context=request_context,
-        )
-
-        # Test 1: Normal recall with both facts and chunks
-        result_normal = await memory.recall_async(
-            bank_id=bank_id,
-            query="quantum computing",
-            max_tokens=4096,  # Normal token budget
-            include_chunks=True,
-            max_chunk_tokens=2000,
-            budget=Budget.MID,
-            request_context=request_context,
-        )
-
-        assert len(result_normal.results) > 0, "Should return memory facts with normal max_tokens"
-        assert result_normal.chunks is not None, "Should include chunks when requested"
-        assert len(result_normal.chunks) > 0, "Should return at least one chunk"
-
-        # Test 2: Recall with max_tokens=0 but chunks enabled
-        result_chunks_only = await memory.recall_async(
-            bank_id=bank_id,
-            query="quantum computing",
-            max_tokens=0,  # Zero token budget for facts
-            include_chunks=True,
-            max_chunk_tokens=2000,  # But allow chunks
-            budget=Budget.MID,
-            request_context=request_context,
-        )
-
-        # Key assertions for new behavior
-        assert len(result_chunks_only.results) == 0, "max_tokens=0 should return 0 facts"
-        assert result_chunks_only.chunks is not None, "Should still include chunks dict"
-        assert len(result_chunks_only.chunks) > 0, "Should return chunks even with max_tokens=0"
-
-        # Verify chunks are from the same content (non-empty text)
-        for chunk_id, chunk_info in result_chunks_only.chunks.items():
-            assert len(chunk_info.chunk_text) > 0, "Chunks should contain text"
-            assert chunk_info.chunk_index >= 0, "Chunk should have valid index"
-
-    finally:
-        # Cleanup
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_recall_chunks_batching_with_varying_sizes(memory, request_context):
-    """
-    Test that chunk batching works correctly with varying chunk sizes.
-
-    This verifies that:
-    1. Chunks are fetched in batches until token budget is exhausted
-    2. The system handles varying chunk sizes across documents
-    3. Token budget is respected across multiple batch fetches
-    """
-    bank_id = "test-chunks-batching"
-
-    try:
-
-        # Retain multiple documents with different content sizes
-        # Document 1: Short content (small chunks)
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Alice is a software engineer who specializes in Python programming and machine learning.",
-            context="doc1",
-            request_context=request_context,
-        )
-
-        # Document 2: Medium content
-        content_bob = """
-        Bob works as a data scientist at a tech startup in San Francisco.
-        He has expertise in natural language processing and computer vision.
-        Bob completed his PhD at Stanford University in 2020.
-        He leads a team of five engineers working on AI-powered recommendation systems.
-        """ * 5
-        await memory.retain_async(
-            bank_id=bank_id,
-            content=content_bob,
-            context="doc2",
-            request_context=request_context,
-        )
-
-        # Document 3: Long content (large chunks)
-        content_charlie = """
-        Charlie is the CTO of a growing AI company focused on healthcare applications.
-        He has over 15 years of experience in software architecture and distributed systems.
-        Charlie's team builds machine learning models for medical image analysis and diagnosis.
-        The company recently raised $50 million in Series B funding.
-        They have partnerships with major hospitals in the United States and Europe.
-        Charlie holds several patents in medical imaging and deep learning.
-        """ * 20
-        await memory.retain_async(
-            bank_id=bank_id,
-            content=content_charlie,
-            context="doc3",
-            request_context=request_context,
-        )
-
-        # Recall with modest chunk token budget
-        result = await memory.recall_async(
-            bank_id=bank_id,
-            query="Alice Bob Charlie",
-            max_tokens=0,  # No facts, only chunks
-            include_chunks=True,
-            max_chunk_tokens=1000,  # Limited chunk budget
-            budget=Budget.MID,
-            request_context=request_context,
-        )
-
-        assert len(result.results) == 0, "Should return 0 facts with max_tokens=0"
-        assert result.chunks is not None, "Should include chunks"
-
-        # Verify we got chunks and respected the token budget
-        if len(result.chunks) > 0:
-            # Count total tokens (approximate)
-            total_chunk_chars = sum(len(chunk.chunk_text) for chunk in result.chunks.values())
-            # Very rough estimate: 1 token ≈ 4 characters
-            estimated_tokens = total_chunk_chars // 4
-
-            # Should be reasonably close to budget (within 2x due to estimation and batching)
-            assert estimated_tokens <= 1000 * 2, f"Should respect chunk token budget (got ~{estimated_tokens} tokens)"
-
-    finally:
-        # Cleanup
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_recall_chunks_ordering_by_relevance(memory, request_context):
-    """
-    Test that chunks are returned in order of fact relevance.
-
-    Chunks should be ordered based on the top-scored (reranked) results,
-    not in document order or random order.
-    """
-    bank_id = "test-chunks-ordering"
-
-    try:
-
-        # Retain content with different relevance to query
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="The Python programming language is widely used for machine learning and data science applications.",
-            context="topic: Python",
-            request_context=request_context,
-        )
-
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="JavaScript is commonly used for web development and frontend applications.",
-            context="topic: JavaScript",
-            request_context=request_context,
-        )
-
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Python's scikit-learn library is excellent for traditional machine learning tasks and model training.",
-            context="topic: Python ML",
-            request_context=request_context,
-        )
-
-        # Query specifically about Python - should rank Python facts higher
-        result = await memory.recall_async(
-            bank_id=bank_id,
-            query="Python machine learning",
-            max_tokens=0,  # No facts
-            include_chunks=True,
-            max_chunk_tokens=5000,  # Enough for all chunks
-            budget=Budget.HIGH,  # Use high budget for better recall
-            request_context=request_context,
-        )
-
-        assert len(result.results) == 0, "Should return 0 facts with max_tokens=0"
-        assert result.chunks is not None, "Should include chunks"
-
-        # We should get chunks, and they should be ordered by relevance
-        # The exact ordering depends on the reranker, but we should have chunks
-        assert len(result.chunks) > 0, "Should return chunks from relevant facts"
-
-        # Verify chunks contain relevant content
-        all_chunk_text = " ".join(chunk.chunk_text for chunk in result.chunks.values())
-        # At least some chunks should mention Python (higher relevance)
-        # This is a soft check since exact ordering depends on scoring
-        assert "Python" in all_chunk_text or "python" in all_chunk_text.lower(), \
-            "Chunks should include content about Python (relevant to query)"
-
-    finally:
-        # Cleanup
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_recall_chunks_without_include_flag(memory, request_context):
-    """
-    Test that chunks are NOT returned when include_chunks=False (default).
-
-    This ensures backward compatibility - chunks are only fetched when explicitly requested.
-    """
-    bank_id = "test-chunks-no-include"
-
-    try:
-
-        # Retain content
-        test_content = """
-        Sarah is a product manager at a fintech company in New York.
-        She specializes in user experience design and agile methodologies.
-        Sarah graduated from MIT with a degree in computer science.
-        She has led the development of three successful mobile banking applications.
-        """
-        await memory.retain_async(
-            bank_id=bank_id,
-            content=test_content,
-            request_context=request_context,
-        )
-
-        # Recall without include_chunks flag (default is False)
-        result = await memory.recall_async(
-            bank_id=bank_id,
-            query="Sarah product manager",
-            max_tokens=4096,
-            request_context=request_context,
-            # include_chunks=False is the default
-        )
-
-        # Should have facts but no chunks
-        assert len(result.results) > 0, "Should return facts"
-        assert result.chunks is None or len(result.chunks) == 0, \
-            "Should NOT return chunks when include_chunks=False"
-
-    finally:
-        # Cleanup
-        await memory.delete_bank(bank_id, request_context=request_context)

hindsight-api/tests/test_retain.py

@@ -2093,7 +2093,7 @@ async def test_custom_extraction_mode():
     import os
     from hindsight_api import LLMConfig
     from hindsight_api.engine.retain.fact_extraction import extract_facts_from_text
-    from hindsight_api.config import clear_config_cache, _get_raw_config
+    from hindsight_api.config import clear_config_cache
 
     # Save original env vars
     original_mode = os.getenv("HINDSIGHT_API_RETAIN_EXTRACTION_MODE")
@@ -2135,8 +2135,7 @@ If the text contains both Italian and English content, extract ONLY the Italian
             event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
             context="team meeting notes",
             llm_config=llm_config,
-            agent_name="TestUser",
-            config=_get_raw_config(),
+            agent_name="TestUser"
         )
 
         logger.info(f"\nExtracted {len(facts)} facts with custom mode (Italian only):")

hindsight-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hindsight-cli"
-version = "0.4.11"
+version = "0.4.10"
 edition = "2021"
 authors = ["Hindsight Team"]
 description = "A beautiful CLI for Hindsight - semantic memory system"

hindsight-cli/src/api.rs

@@ -387,43 +387,6 @@ impl ApiClient {
         })
     }
 
-    pub fn get_bank_config(
-        &self,
-        bank_id: &str,
-        _verbose: bool,
-    ) -> Result<types::BankConfigResponse> {
-        self.runtime.block_on(async {
-            let response = self.client.get_bank_config(bank_id, None).await?;
-            Ok(response.into_inner())
-        })
-    }
-
-    pub fn update_bank_config(
-        &self,
-        bank_id: &str,
-        updates: std::collections::HashMap<String, serde_json::Value>,
-        _verbose: bool,
-    ) -> Result<types::BankConfigResponse> {
-        self.runtime.block_on(async {
-            // Convert HashMap to serde_json::Map
-            let updates_map: serde_json::Map<String, serde_json::Value> = updates.into_iter().collect();
-            let request = types::BankConfigUpdate { updates: updates_map };
-            let response = self.client.update_bank_config(bank_id, None, &request).await?;
-            Ok(response.into_inner())
-        })
-    }
-
-    pub fn reset_bank_config(
-        &self,
-        bank_id: &str,
-        _verbose: bool,
-    ) -> Result<types::BankConfigResponse> {
-        self.runtime.block_on(async {
-            let response = self.client.reset_bank_config(bank_id, None).await?;
-            Ok(response.into_inner())
-        })
-    }
-
     // --- Tag Methods ---
 
     pub fn list_tags(

hindsight-cli/src/commands/bank.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use crate::api::ApiClient;
 use crate::output::{self, OutputFormat};
 use crate::ui;
@@ -655,159 +655,3 @@ pub fn clear_observations(
         Err(e) => Err(e),
     }
 }
-
-pub fn config(
-    client: &ApiClient,
-    bank_id: &str,
-    overrides_only: bool,
-    verbose: bool,
-    output_format: OutputFormat,
-) -> Result<()> {
-    let spinner = if output_format == OutputFormat::Pretty {
-        Some(ui::create_spinner("Fetching bank configuration..."))
-    } else {
-        None
-    };
-
-    let response = client.get_bank_config(bank_id, verbose);
-
-    if let Some(mut sp) = spinner {
-        sp.finish();
-    }
-
-    match response {
-        Ok(result) => {
-            if output_format == OutputFormat::Pretty {
-                ui::print_success(&format!("Configuration for bank '{}'", bank_id));
-                println!();
-                if overrides_only {
-                    println!("Bank-specific overrides:");
-                    if result.overrides.is_empty() {
-                        println!("  (none - using defaults)");
-                    } else {
-                        for (key, value) in result.overrides.iter() {
-                            println!("  {}: {:?}", key, value);
-                        }
-                    }
-                } else {
-                    println!("Resolved configuration (with all overrides applied):");
-                    for (key, value) in result.config.iter() {
-                        println!("  {}: {:?}", key, value);
-                    }
-                }
-            } else {
-                if overrides_only {
-                    output::print_output(&result.overrides, output_format)?;
-                } else {
-                    output::print_output(&result, output_format)?;
-                }
-            }
-            Ok(())
-        }
-        Err(e) => Err(e),
-    }
-}
-
-pub fn set_config(
-    client: &ApiClient,
-    bank_id: &str,
-    llm_provider: Option<String>,
-    llm_model: Option<String>,
-    llm_api_key: Option<String>,
-    llm_base_url: Option<String>,
-    verbose: bool,
-    output_format: OutputFormat,
-) -> Result<()> {
-    use std::collections::HashMap;
-
-    let mut updates: HashMap<String, serde_json::Value> = HashMap::new();
-
-    if let Some(provider) = llm_provider {
-        updates.insert("llm_provider".to_string(), serde_json::Value::String(provider));
-    }
-    if let Some(model) = llm_model {
-        updates.insert("llm_model".to_string(), serde_json::Value::String(model));
-    }
-    if let Some(api_key) = llm_api_key {
-        updates.insert("llm_api_key".to_string(), serde_json::Value::String(api_key));
-    }
-    if let Some(base_url) = llm_base_url {
-        updates.insert("llm_base_url".to_string(), serde_json::Value::String(base_url));
-    }
-
-    if updates.is_empty() {
-        return Err(anyhow!("No config updates provided. Use --llm-provider, --llm-model, --llm-api-key, or --llm-base-url".to_string()));
-    }
-
-    let spinner = if output_format == OutputFormat::Pretty {
-        Some(ui::create_spinner("Updating bank configuration..."))
-    } else {
-        None
-    };
-
-    let response = client.update_bank_config(bank_id, updates, verbose);
-
-    if let Some(mut sp) = spinner {
-        sp.finish();
-    }
-
-    match response {
-        Ok(result) => {
-            if output_format == OutputFormat::Pretty {
-                ui::print_success(&format!("Configuration updated for bank '{}'", bank_id));
-                println!("\nUpdated overrides:");
-                for (key, value) in result.overrides.iter() {
-                    println!("  {}: {:?}", key, value);
-                }
-            } else {
-                output::print_output(&result, output_format)?;
-            }
-            Ok(())
-        }
-        Err(e) => Err(e),
-    }
-}
-
-pub fn reset_config(
-    client: &ApiClient,
-    bank_id: &str,
-    yes: bool,
-    verbose: bool,
-    output_format: OutputFormat,
-) -> Result<()> {
-    if !yes && output_format == OutputFormat::Pretty {
-        let confirmed = ui::prompt_confirmation(&format!(
-            "Reset all configuration overrides for bank '{}'?",
-            bank_id
-        ))?;
-
-        if !confirmed {
-            ui::print_info("Operation cancelled");
-            return Ok(());
-        }
-    }
-
-    let spinner = if output_format == OutputFormat::Pretty {
-        Some(ui::create_spinner("Resetting bank configuration..."))
-    } else {
-        None
-    };
-
-    let response = client.reset_bank_config(bank_id, verbose);
-
-    if let Some(mut sp) = spinner {
-        sp.finish();
-    }
-
-    match response {
-        Ok(result) => {
-            if output_format == OutputFormat::Pretty {
-                ui::print_success(&format!("Configuration reset to defaults for bank '{}'", bank_id));
-            } else {
-                output::print_output(&result, output_format)?;
-            }
-            Ok(())
-        }
-        Err(e) => Err(e),
-    }
-}

hindsight-cli/src/errors.rs

@@ -58,22 +58,8 @@ fn format_error_message(err: &anyhow::Error, api_url: &str) -> String {
         );
     }
 
-    // 404 Not Found - check for disabled features first
+    // 404 Not Found
     if err_str.contains("404") {
-        if err_str.contains("Bank configuration API is disabled") {
-            return format!(
-                "{} {}\n\n{}\n  {}\n\n{}\n  {}\n\n{}\n  {}",
-                "✗".bright_red().bold(),
-                "Bank configuration API is disabled".bright_red().bold(),
-                "API URL:".bright_yellow(),
-                api_url.bright_white(),
-                "This feature is disabled by default for security.".bright_yellow(),
-                "To enable, set HINDSIGHT_API_ENABLE_BANK_CONFIG_API=true on the API server".bright_white(),
-                "Note:".bright_cyan(),
-                "This allows per-bank LLM configuration overrides via API".bright_white()
-            );
-        }
-
         return format!(
             "{} {}\n\n{}\n  {}\n\n{}\n  • {}\n  • {}\n\n{}\n  {}",
             "✗".bright_red().bold(),
@@ -88,8 +74,8 @@ fn format_error_message(err: &anyhow::Error, api_url: &str) -> String {
         );
     }
 
-    // 401 Authentication failed
-    if err_str.contains("401") {
+    // 401/403 Authentication
+    if err_str.contains("401") || err_str.contains("403") {
         return format!(
             "{} {}\n\n{}\n  {}\n\n{}\n  • {}\n  • {}\n\n{}\n  {}",
             "✗".bright_red().bold(),
@@ -104,22 +90,6 @@ fn format_error_message(err: &anyhow::Error, api_url: &str) -> String {
         );
     }
 
-    // 403 Forbidden
-    if err_str.contains("403") {
-        return format!(
-            "{} {}\n\n{}\n  {}\n\n{}\n  • {}\n  • {}\n\n{}\n  {}",
-            "✗".bright_red().bold(),
-            "Permission denied (403)".bright_red().bold(),
-            "API URL:".bright_yellow(),
-            api_url.bright_white(),
-            "Possible causes:".bright_yellow(),
-            "This operation is not allowed".bright_white(),
-            "The feature may be disabled on the server".bright_white(),
-            "Try:".bright_green(),
-            "Check server configuration or contact your administrator".bright_white()
-        );
-    }
-
     // 500 Server Error
     if err_str.contains("500") || err_str.contains("502") || err_str.contains("503") {
         return format!(

hindsight-cli/src/main.rs

@@ -279,48 +279,6 @@ enum BankCommands {
         #[arg(short = 'y', long)]
         yes: bool,
     },
-
-    /// Get bank configuration (hierarchical overrides)
-    Config {
-        /// Bank ID
-        bank_id: String,
-
-        /// Show only bank-specific overrides (not full resolved config)
-        #[arg(long)]
-        overrides_only: bool,
-    },
-
-    /// Update bank configuration (set hierarchical overrides)
-    SetConfig {
-        /// Bank ID
-        bank_id: String,
-
-        /// LLM provider override
-        #[arg(long)]
-        llm_provider: Option<String>,
-
-        /// LLM model override
-        #[arg(long)]
-        llm_model: Option<String>,
-
-        /// LLM API key override
-        #[arg(long)]
-        llm_api_key: Option<String>,
-
-        /// LLM base URL override
-        #[arg(long)]
-        llm_base_url: Option<String>,
-    },
-
-    /// Reset bank configuration to defaults (remove all overrides)
-    ResetConfig {
-        /// Bank ID
-        bank_id: String,
-
-        /// Skip confirmation prompt
-        #[arg(short = 'y', long)]
-        yes: bool,
-    },
 }
 
 #[derive(Subcommand)]
@@ -818,15 +776,6 @@ fn run() -> Result<()> {
             BankCommands::ClearObservations { bank_id, yes } => {
                 commands::bank::clear_observations(&client, &bank_id, yes, verbose, output_format)
             }
-            BankCommands::Config { bank_id, overrides_only } => {
-                commands::bank::config(&client, &bank_id, overrides_only, verbose, output_format)
-            }
-            BankCommands::SetConfig { bank_id, llm_provider, llm_model, llm_api_key, llm_base_url } => {
-                commands::bank::set_config(&client, &bank_id, llm_provider, llm_model, llm_api_key, llm_base_url, verbose, output_format)
-            }
-            BankCommands::ResetConfig { bank_id, yes } => {
-                commands::bank::reset_config(&client, &bank_id, yes, verbose, output_format)
-            }
         },
 
         // Memory commands

hindsight-clients/python/.openapi-generator/FILES

@@ -16,15 +16,12 @@ hindsight_client_api/models/__init__.py
 hindsight_client_api/models/add_background_request.py
 hindsight_client_api/models/async_operation_submit_response.py
 hindsight_client_api/models/background_response.py
-hindsight_client_api/models/bank_config_response.py
-hindsight_client_api/models/bank_config_update.py
 hindsight_client_api/models/bank_list_item.py
 hindsight_client_api/models/bank_list_response.py
 hindsight_client_api/models/bank_profile_response.py
 hindsight_client_api/models/bank_stats_response.py
 hindsight_client_api/models/budget.py
 hindsight_client_api/models/cancel_operation_response.py
-hindsight_client_api/models/child_operation_status.py
 hindsight_client_api/models/chunk_data.py
 hindsight_client_api/models/chunk_include_options.py
 hindsight_client_api/models/chunk_response.py

hindsight-clients/python/hindsight_client_api/__init__.py

@@ -7,7 +7,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -41,15 +41,12 @@ from hindsight_client_api.exceptions import ApiException
 from hindsight_client_api.models.add_background_request import AddBackgroundRequest
 from hindsight_client_api.models.async_operation_submit_response import AsyncOperationSubmitResponse
 from hindsight_client_api.models.background_response import BackgroundResponse
-from hindsight_client_api.models.bank_config_response import BankConfigResponse
-from hindsight_client_api.models.bank_config_update import BankConfigUpdate
 from hindsight_client_api.models.bank_list_item import BankListItem
 from hindsight_client_api.models.bank_list_response import BankListResponse
 from hindsight_client_api.models.bank_profile_response import BankProfileResponse
 from hindsight_client_api.models.bank_stats_response import BankStatsResponse
 from hindsight_client_api.models.budget import Budget
 from hindsight_client_api.models.cancel_operation_response import CancelOperationResponse
-from hindsight_client_api.models.child_operation_status import ChildOperationStatus
 from hindsight_client_api.models.chunk_data import ChunkData
 from hindsight_client_api.models.chunk_include_options import ChunkIncludeOptions
 from hindsight_client_api.models.chunk_response import ChunkResponse

hindsight-clients/python/hindsight_client_api/api/banks_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -20,8 +20,6 @@ from pydantic import StrictStr
 from typing import Optional
 from hindsight_client_api.models.add_background_request import AddBackgroundRequest
 from hindsight_client_api.models.background_response import BackgroundResponse
-from hindsight_client_api.models.bank_config_response import BankConfigResponse
-from hindsight_client_api.models.bank_config_update import BankConfigUpdate
 from hindsight_client_api.models.bank_list_response import BankListResponse
 from hindsight_client_api.models.bank_profile_response import BankProfileResponse
 from hindsight_client_api.models.bank_stats_response import BankStatsResponse
@@ -1497,284 +1495,6 @@ class BanksApi:
 
 
 
-    @validate_call
-    async def get_bank_config(
-        self,
-        bank_id: StrictStr,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> BankConfigResponse:
-        """Get bank configuration
-
-        Get fully resolved configuration for a bank including all hierarchical overrides (global → tenant → bank). The 'config' field contains all resolved config values. The 'overrides' field shows only bank-specific overrides.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._get_bank_config_serialize(
-            bank_id=bank_id,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        await response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    async def get_bank_config_with_http_info(
-        self,
-        bank_id: StrictStr,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[BankConfigResponse]:
-        """Get bank configuration
-
-        Get fully resolved configuration for a bank including all hierarchical overrides (global → tenant → bank). The 'config' field contains all resolved config values. The 'overrides' field shows only bank-specific overrides.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._get_bank_config_serialize(
-            bank_id=bank_id,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        await response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    async def get_bank_config_without_preload_content(
-        self,
-        bank_id: StrictStr,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Get bank configuration
-
-        Get fully resolved configuration for a bank including all hierarchical overrides (global → tenant → bank). The 'config' field contains all resolved config values. The 'overrides' field shows only bank-specific overrides.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._get_bank_config_serialize(
-            bank_id=bank_id,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _get_bank_config_serialize(
-        self,
-        bank_id,
-        authorization,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if bank_id is not None:
-            _path_params['bank_id'] = bank_id
-        # process the query parameters
-        # process the header parameters
-        if authorization is not None:
-            _header_params['authorization'] = authorization
-        # process the form parameters
-        # process the body parameter
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'application/json'
-                ]
-            )
-
-
-        # authentication setting
-        _auth_settings: List[str] = [
-        ]
-
-        return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/v1/default/banks/{bank_id}/config',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
     @validate_call
     async def get_bank_profile(
         self,
@@ -2316,284 +2036,6 @@ class BanksApi:
 
 
 
-    @validate_call
-    async def reset_bank_config(
-        self,
-        bank_id: StrictStr,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> BankConfigResponse:
-        """Reset bank configuration
-
-        Reset bank configuration to defaults by removing all bank-specific overrides. The bank will then use global and tenant-level configuration only.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._reset_bank_config_serialize(
-            bank_id=bank_id,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        await response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    async def reset_bank_config_with_http_info(
-        self,
-        bank_id: StrictStr,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[BankConfigResponse]:
-        """Reset bank configuration
-
-        Reset bank configuration to defaults by removing all bank-specific overrides. The bank will then use global and tenant-level configuration only.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._reset_bank_config_serialize(
-            bank_id=bank_id,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        await response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    async def reset_bank_config_without_preload_content(
-        self,
-        bank_id: StrictStr,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Reset bank configuration
-
-        Reset bank configuration to defaults by removing all bank-specific overrides. The bank will then use global and tenant-level configuration only.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._reset_bank_config_serialize(
-            bank_id=bank_id,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _reset_bank_config_serialize(
-        self,
-        bank_id,
-        authorization,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if bank_id is not None:
-            _path_params['bank_id'] = bank_id
-        # process the query parameters
-        # process the header parameters
-        if authorization is not None:
-            _header_params['authorization'] = authorization
-        # process the form parameters
-        # process the body parameter
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'application/json'
-                ]
-            )
-
-
-        # authentication setting
-        _auth_settings: List[str] = [
-        ]
-
-        return self.api_client.param_serialize(
-            method='DELETE',
-            resource_path='/v1/default/banks/{bank_id}/config',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
     @validate_call
     async def trigger_consolidation(
         self,
@@ -3178,312 +2620,6 @@ class BanksApi:
 
 
 
-    @validate_call
-    async def update_bank_config(
-        self,
-        bank_id: StrictStr,
-        bank_config_update: BankConfigUpdate,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> BankConfigResponse:
-        """Update bank configuration
-
-        Update configuration overrides for a bank. Only hierarchical fields can be overridden (LLM settings, retention parameters, etc.). Keys can be provided in Python field format (llm_provider) or environment variable format (HINDSIGHT_API_LLM_PROVIDER).
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param bank_config_update: (required)
-        :type bank_config_update: BankConfigUpdate
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._update_bank_config_serialize(
-            bank_id=bank_id,
-            bank_config_update=bank_config_update,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        await response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    async def update_bank_config_with_http_info(
-        self,
-        bank_id: StrictStr,
-        bank_config_update: BankConfigUpdate,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[BankConfigResponse]:
-        """Update bank configuration
-
-        Update configuration overrides for a bank. Only hierarchical fields can be overridden (LLM settings, retention parameters, etc.). Keys can be provided in Python field format (llm_provider) or environment variable format (HINDSIGHT_API_LLM_PROVIDER).
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param bank_config_update: (required)
-        :type bank_config_update: BankConfigUpdate
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._update_bank_config_serialize(
-            bank_id=bank_id,
-            bank_config_update=bank_config_update,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        await response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    async def update_bank_config_without_preload_content(
-        self,
-        bank_id: StrictStr,
-        bank_config_update: BankConfigUpdate,
-        authorization: Optional[StrictStr] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Update bank configuration
-
-        Update configuration overrides for a bank. Only hierarchical fields can be overridden (LLM settings, retention parameters, etc.). Keys can be provided in Python field format (llm_provider) or environment variable format (HINDSIGHT_API_LLM_PROVIDER).
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param bank_config_update: (required)
-        :type bank_config_update: BankConfigUpdate
-        :param authorization:
-        :type authorization: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._update_bank_config_serialize(
-            bank_id=bank_id,
-            bank_config_update=bank_config_update,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "BankConfigResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _update_bank_config_serialize(
-        self,
-        bank_id,
-        bank_config_update,
-        authorization,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if bank_id is not None:
-            _path_params['bank_id'] = bank_id
-        # process the query parameters
-        # process the header parameters
-        if authorization is not None:
-            _header_params['authorization'] = authorization
-        # process the form parameters
-        # process the body parameter
-        if bank_config_update is not None:
-            _body_params = bank_config_update
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'application/json'
-                ]
-            )
-
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'application/json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-        ]
-
-        return self.api_client.param_serialize(
-            method='PATCH',
-            resource_path='/v1/default/banks/{bank_id}/config',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
     @validate_call
     async def update_bank_disposition(
         self,

hindsight-clients/python/hindsight_client_api/api/directives_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/documents_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/entities_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/memory_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/mental_models_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/monitoring_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/operations_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api_client.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/configuration.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -489,7 +489,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.4.11\n"\
+               "Version of the API: 0.4.10\n"\
                "SDK Package Version: 0.0.7".\
                format(env=sys.platform, pyversion=sys.version)
 

hindsight-clients/python/hindsight_client_api/exceptions.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/__init__.py

@@ -6,7 +6,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -17,15 +17,12 @@
 from hindsight_client_api.models.add_background_request import AddBackgroundRequest
 from hindsight_client_api.models.async_operation_submit_response import AsyncOperationSubmitResponse
 from hindsight_client_api.models.background_response import BackgroundResponse
-from hindsight_client_api.models.bank_config_response import BankConfigResponse
-from hindsight_client_api.models.bank_config_update import BankConfigUpdate
 from hindsight_client_api.models.bank_list_item import BankListItem
 from hindsight_client_api.models.bank_list_response import BankListResponse
 from hindsight_client_api.models.bank_profile_response import BankProfileResponse
 from hindsight_client_api.models.bank_stats_response import BankStatsResponse
 from hindsight_client_api.models.budget import Budget
 from hindsight_client_api.models.cancel_operation_response import CancelOperationResponse
-from hindsight_client_api.models.child_operation_status import ChildOperationStatus
 from hindsight_client_api.models.chunk_data import ChunkData
 from hindsight_client_api.models.chunk_include_options import ChunkIncludeOptions
 from hindsight_client_api.models.chunk_response import ChunkResponse

hindsight-clients/python/hindsight_client_api/models/add_background_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/async_operation_submit_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/background_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_config_response.py

@@ -1,91 +0,0 @@
-# coding: utf-8
-
-"""
-    Hindsight HTTP API
-
-    HTTP API for Hindsight
-
-    The version of the OpenAPI document: 0.4.11
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
-from typing import Any, ClassVar, Dict, List
-from typing import Optional, Set
-from typing_extensions import Self
-
-class BankConfigResponse(BaseModel):
-    """
-    Response model for bank configuration.
-    """ # noqa: E501
-    bank_id: StrictStr = Field(description="Bank identifier")
-    config: Dict[str, Any] = Field(description="Fully resolved configuration with all hierarchical overrides applied (Python field names)")
-    overrides: Dict[str, Any] = Field(description="Bank-specific configuration overrides only (Python field names)")
-    __properties: ClassVar[List[str]] = ["bank_id", "config", "overrides"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of BankConfigResponse from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of BankConfigResponse from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "bank_id": obj.get("bank_id"),
-            "config": obj.get("config"),
-            "overrides": obj.get("overrides")
-        })
-        return _obj
-
-

hindsight-clients/python/hindsight_client_api/models/bank_config_update.py

@@ -1,87 +0,0 @@
-# coding: utf-8
-
-"""
-    Hindsight HTTP API
-
-    HTTP API for Hindsight
-
-    The version of the OpenAPI document: 0.4.11
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, Field
-from typing import Any, ClassVar, Dict, List
-from typing import Optional, Set
-from typing_extensions import Self
-
-class BankConfigUpdate(BaseModel):
-    """
-    Request model for updating bank configuration.
-    """ # noqa: E501
-    updates: Dict[str, Any] = Field(description="Configuration overrides. Keys can be in Python field format (llm_provider) or environment variable format (HINDSIGHT_API_LLM_PROVIDER). Only hierarchical fields can be overridden per-bank.")
-    __properties: ClassVar[List[str]] = ["updates"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of BankConfigUpdate from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of BankConfigUpdate from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "updates": obj.get("updates")
-        })
-        return _obj
-
-

hindsight-clients/python/hindsight_client_api/models/bank_list_item.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_list_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_profile_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_stats_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/budget.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/cancel_operation_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/child_operation_status.py

@@ -1,110 +0,0 @@
-# coding: utf-8
-
-"""
-    Hindsight HTTP API
-
-    HTTP API for Hindsight
-
-    The version of the OpenAPI document: 0.4.11
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional
-from typing import Optional, Set
-from typing_extensions import Self
-
-class ChildOperationStatus(BaseModel):
-    """
-    Status of a child operation (for batch operations).
-    """ # noqa: E501
-    operation_id: StrictStr
-    status: StrictStr
-    sub_batch_index: Optional[StrictInt] = None
-    items_count: Optional[StrictInt] = None
-    error_message: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["operation_id", "status", "sub_batch_index", "items_count", "error_message"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ChildOperationStatus from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # set to None if sub_batch_index (nullable) is None
-        # and model_fields_set contains the field
-        if self.sub_batch_index is None and "sub_batch_index" in self.model_fields_set:
-            _dict['sub_batch_index'] = None
-
-        # set to None if items_count (nullable) is None
-        # and model_fields_set contains the field
-        if self.items_count is None and "items_count" in self.model_fields_set:
-            _dict['items_count'] = None
-
-        # set to None if error_message (nullable) is None
-        # and model_fields_set contains the field
-        if self.error_message is None and "error_message" in self.model_fields_set:
-            _dict['error_message'] = None
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ChildOperationStatus from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "operation_id": obj.get("operation_id"),
-            "status": obj.get("status"),
-            "sub_batch_index": obj.get("sub_batch_index"),
-            "items_count": obj.get("items_count"),
-            "error_message": obj.get("error_message")
-        })
-        return _obj
-
-

hindsight-clients/python/hindsight_client_api/models/chunk_data.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/chunk_include_options.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/chunk_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/consolidation_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/create_bank_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/create_directive_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/create_mental_model_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/create_mental_model_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/delete_document_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/delete_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.11
+    The version of the OpenAPI document: 0.4.10
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.