fix: set max_completion_tokens to 100 in llm validation

.github/workflows/release.yml

@@ -42,10 +42,6 @@ jobs:
       working-directory: ./hindsight-integrations/litellm
       run: uv build --out-dir dist
 
-    - name: Build hindsight-embed
-      working-directory: ./hindsight-embed
-      run: uv build --out-dir dist
-
     # Publish in order (client and api first, then hindsight-all which depends on them)
     - name: Publish hindsight-client to PyPI
       uses: pypa/gh-action-pypi-publish@release/v1
@@ -71,12 +67,6 @@ jobs:
         packages-dir: ./hindsight-integrations/litellm/dist
         skip-existing: true
 
-    - name: Publish hindsight-embed to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        packages-dir: ./hindsight-embed/dist
-        skip-existing: true
-
     # Upload artifacts for GitHub release
     - name: Upload artifacts
       uses: actions/upload-artifact@v4
@@ -87,7 +77,6 @@ jobs:
           hindsight-api/dist/*
           hindsight/dist/*
           hindsight-integrations/litellm/dist/*
-          hindsight-embed/dist/*
         retention-days: 1
 
   release-typescript-client:
@@ -427,7 +416,6 @@ jobs:
         cp artifacts/python-packages/hindsight-api/dist/* release-assets/ || true
         cp artifacts/python-packages/hindsight/dist/* release-assets/ || true
         cp artifacts/python-packages/hindsight-integrations/litellm/dist/* release-assets/ || true
-        cp artifacts/python-packages/hindsight-embed/dist/* release-assets/ || true
         # TypeScript client
         cp artifacts/typescript-client/*.tgz release-assets/ || true
         # Control Plane

.github/workflows/test.yml

@@ -20,8 +20,6 @@ jobs:
             path: hindsight-api
           - name: hindsight-client
             path: hindsight-clients/python
-          - name: hindsight-embed
-            path: hindsight-embed
 
     steps:
     - uses: actions/checkout@v4
@@ -175,90 +173,6 @@ jobs:
       working-directory: hindsight-cli
       run: cargo build --release
 
-    - name: Upload CLI artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: hindsight-cli
-        path: hindsight-cli/target/release/hindsight
-        retention-days: 1
-
-  test-rust-cli:
-    runs-on: ubuntu-latest
-    needs: build-rust-cli
-    env:
-      HINDSIGHT_API_LLM_PROVIDER: groq
-      HINDSIGHT_API_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
-      HINDSIGHT_API_LLM_MODEL: openai/gpt-oss-20b
-      HINDSIGHT_API_URL: http://localhost:8888
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      UV_INDEX: pytorch=https://download.pytorch.org/whl/cpu
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Download CLI artifact
-      uses: actions/download-artifact@v4
-      with:
-        name: hindsight-cli
-        path: /tmp/cli
-
-    - name: Make CLI executable
-      run: chmod +x /tmp/cli/hindsight
-
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-      with:
-        enable-cache: true
-        prune-cache: false
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version-file: ".python-version"
-
-    - name: Build API
-      working-directory: ./hindsight-api
-      run: uv build
-
-    - name: Install API dependencies
-      working-directory: ./hindsight-api
-      run: uv sync --no-install-project --index-strategy unsafe-best-match
-
-    - name: Create .env file
-      run: |
-        cat > .env << EOF
-        HINDSIGHT_API_LLM_PROVIDER=${{ env.HINDSIGHT_API_LLM_PROVIDER }}
-        HINDSIGHT_API_LLM_API_KEY=${{ env.HINDSIGHT_API_LLM_API_KEY }}
-        HINDSIGHT_API_LLM_MODEL=${{ env.HINDSIGHT_API_LLM_MODEL }}
-        EOF
-
-    - name: Start API server
-      run: |
-        ./scripts/dev/start-api.sh > /tmp/api-server.log 2>&1 &
-        echo "Waiting for API server to be ready..."
-        for i in {1..60}; do
-          if curl -sf http://localhost:8888/health > /dev/null 2>&1; then
-            echo "API server is ready after ${i}s"
-            break
-          fi
-          if [ $i -eq 60 ]; then
-            echo "API server failed to start after 60s"
-            cat /tmp/api-server.log
-            exit 1
-          fi
-          sleep 1
-        done
-
-    - name: Run CLI smoke test
-      run: |
-        HINDSIGHT_CLI=/tmp/cli/hindsight ./hindsight-cli/smoke-test.sh
-
-    - name: Show API server logs
-      if: always()
-      run: |
-        echo "=== API Server Logs ==="
-        cat /tmp/api-server.log || echo "No API server log found"
-
   lint-helm-chart:
     runs-on: ubuntu-latest
 
@@ -642,49 +556,8 @@ jobs:
       working-directory: ./hindsight-integrations/litellm
       run: uv run pytest tests -v
 
-  test-embed:
-    runs-on: ubuntu-latest
-    env:
-      HINDSIGHT_EMBED_LLM_PROVIDER: groq
-      HINDSIGHT_EMBED_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
-      HINDSIGHT_EMBED_LLM_MODEL: openai/gpt-oss-20b
-      # Prefer CPU-only PyTorch in CI
-      UV_INDEX: pytorch=https://download.pytorch.org/whl/cpu
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-      with:
-        enable-cache: true
-        prune-cache: false
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version-file: ".python-version"
-
-    - name: Install dependencies
-      working-directory: ./hindsight-embed
-      run: uv sync --index-strategy unsafe-best-match
-
-    - name: Cache HuggingFace models
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/huggingface
-        key: ${{ runner.os }}-huggingface-embed-${{ hashFiles('hindsight-embed/pyproject.toml') }}
-        restore-keys: |
-          ${{ runner.os }}-huggingface-embed-
-          ${{ runner.os }}-huggingface-
-
-    - name: Run smoke test
-      working-directory: ./hindsight-embed
-      run: ./test.sh
-
   test-doc-examples:
     runs-on: ubuntu-latest
-    needs: build-rust-cli
     env:
       HINDSIGHT_API_LLM_PROVIDER: groq
       HINDSIGHT_API_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
@@ -696,15 +569,6 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
-    - name: Download CLI artifact
-      uses: actions/download-artifact@v4
-      with:
-        name: hindsight-cli
-        path: /usr/local/bin
-
-    - name: Make CLI executable
-      run: chmod +x /usr/local/bin/hindsight
-
     - name: Install uv
       uses: astral-sh/setup-uv@v5
       with:
@@ -778,16 +642,6 @@ jobs:
           node "$f"
         done
 
-    - name: Configure CLI
-      run: hindsight configure --api-url http://localhost:8888
-
-    - 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()
       run: |

AGENTS.md

@@ -14,7 +14,6 @@ This document captures architectural decisions and coding conventions for the Hi
 hindsight/              # Python package for embedded usage
 hindsight-api/          # FastAPI server (core memory engine)
 hindsight-cli/          # Rust CLI client
-hindsight-embed/        # Embedded CLI (no server needed)
 hindsight-control-plane/ # Next.js admin UI
 hindsight-docs/         # Docusaurus documentation site
 hindsight-dev/          # Development tools and benchmarks
@@ -149,5 +148,4 @@ Note: The maintained wrapper `hindsight_client.py` and `README.md` are preserved
 
 # Branding
 ## Colors
-- Primary: gradient from #0074d9 to #009296
-
+- Primary: gradient from #0074d9 to #009296  

docker/standalone/Dockerfile

@@ -2,19 +2,16 @@
 # Supports building API-only, Control Plane-only, or both
 #
 # Build args:
-#   INCLUDE_API=true/false       - Include API (default: true)
-#   INCLUDE_CP=true/false        - Include Control Plane (default: true)
-#   PRELOAD_ML_MODELS=true/false - Pre-download ML models during build (default: true)
+#   INCLUDE_API=true/false  - Include API (default: true)
+#   INCLUDE_CP=true/false   - Include Control Plane (default: true)
 #
 # Examples:
-#   docker build -t hindsight .                                          # Both (standalone)
-#   docker build -t hindsight-api --build-arg INCLUDE_CP=false .         # API only
-#   docker build -t hindsight-cp --build-arg INCLUDE_API=false .         # Control Plane only
-#   docker build -t hindsight --build-arg PRELOAD_ML_MODELS=false .      # Skip ML model preload
+#   docker build -t hindsight .                                    # Both (standalone)
+#   docker build -t hindsight-api --build-arg INCLUDE_CP=false .   # API only
+#   docker build -t hindsight-cp --build-arg INCLUDE_API=false .   # Control Plane only
 
 ARG INCLUDE_API=true
 ARG INCLUDE_CP=true
-ARG PRELOAD_ML_MODELS=true
 
 # =============================================================================
 # Stage: API Builder
@@ -162,17 +159,14 @@ ENV PG0_HOME=/home/hindsight/.pg0-cache
 
 ENV PG0_HOME=/home/hindsight/.pg0
 
-# Pre-download ML models to avoid runtime download (conditional)
-ARG PRELOAD_ML_MODELS
-RUN if [ "$PRELOAD_ML_MODELS" = "true" ]; then \
-    /app/api/.venv/bin/python -c "\
+# Pre-download ML models to avoid runtime download
+RUN /app/api/.venv/bin/python -c "\
 from sentence_transformers import SentenceTransformer, CrossEncoder; \
 print('Downloading embedding model...'); \
 SentenceTransformer('BAAI/bge-small-en-v1.5'); \
 print('Downloading cross-encoder model...'); \
 CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2'); \
-print('Models cached successfully')"; \
-    else echo "Skipping ML model preload"; fi
+print('Models cached successfully')"
 
 EXPOSE 8888
 
@@ -283,17 +277,14 @@ print('PostgreSQL pre-cached to PG0_HOME')" || echo "Pre-download skipped"
 
 ENV PG0_HOME=/home/hindsight/.pg0
 
-# Pre-download ML models to avoid runtime download (conditional)
-ARG PRELOAD_ML_MODELS
-RUN if [ "$PRELOAD_ML_MODELS" = "true" ]; then \
-    /app/api/.venv/bin/python -c "\
+# Pre-download ML models to avoid runtime download
+RUN /app/api/.venv/bin/python -c "\
 from sentence_transformers import SentenceTransformer, CrossEncoder; \
 print('Downloading embedding model...'); \
 SentenceTransformer('BAAI/bge-small-en-v1.5'); \
 print('Downloading cross-encoder model...'); \
 CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2'); \
-print('Models cached successfully')"; \
-    else echo "Skipping ML model preload"; fi
+print('Models cached successfully')"
 
 EXPOSE 8888 9999
 

helm/hindsight/Chart.yaml

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

hindsight-api/hindsight_api/__init__.py

@@ -21,11 +21,9 @@ from .engine.search.trace import (
     WeightComponents,
 )
 from .engine.search.tracer import SearchTracer
-from .models import RequestContext
 
 __all__ = [
     "MemoryEngine",
-    "RequestContext",
     "HindsightConfig",
     "get_config",
     "SearchTrace",

hindsight-api/hindsight_api/alembic/env.py

@@ -109,9 +109,6 @@ def run_migrations_online() -> None:
 
     get_database_url()  # Process and set the database URL in config
 
-    # Check if we're targeting a specific schema (for multi-tenant isolation)
-    target_schema = config.get_main_option("target_schema")
-
     connectable = engine_from_config(
         config.get_section(config.config_ini_section, {}),
         prefix="sqlalchemy.",
@@ -124,34 +121,14 @@ def run_migrations_online() -> None:
     def set_read_write_mode(dbapi_connection, connection_record):
         cursor = dbapi_connection.cursor()
         cursor.execute("SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE")
-        # If targeting a specific schema, set search_path
-        # Include public in search_path for access to shared extensions (pgvector)
-        if target_schema:
-            cursor.execute(f'CREATE SCHEMA IF NOT EXISTS "{target_schema}"')
-            cursor.execute(f'SET search_path TO "{target_schema}", public')
         cursor.close()
 
     with connectable.connect() as connection:
         # Also explicitly set read-write mode on this connection
         connection.execute(text("SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE"))
-
-        # If targeting a specific schema, set search_path
-        # Include public in search_path for access to shared extensions (pgvector)
-        if target_schema:
-            connection.execute(text(f'CREATE SCHEMA IF NOT EXISTS "{target_schema}"'))
-            connection.execute(text(f'SET search_path TO "{target_schema}", public'))
-
         connection.commit()  # Commit the SET command
 
-        # Configure context with version_table_schema if using a specific schema
-        context_opts = {
-            "connection": connection,
-            "target_metadata": target_metadata,
-        }
-        if target_schema:
-            context_opts["version_table_schema"] = target_schema
-
-        context.configure(**context_opts)
+        context.configure(connection=connection, target_metadata=target_metadata)
 
         with context.begin_transaction():
             context.run_migrations()

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

@@ -6,7 +6,7 @@ Create Date: 2024-12-04 15:00:00.000000
 
 """
 
-from alembic import context, op
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision = "d9f6a3b4c5e2"
@@ -15,22 +15,14 @@ branch_labels = None
 depends_on = None
 
 
-def _get_schema_prefix() -> str:
-    """Get schema prefix for table names (e.g., 'tenant_x.' or '' for public)."""
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
 def upgrade():
-    schema = _get_schema_prefix()
-
     # Drop old check constraint FIRST (before updating data)
     op.drop_constraint("memory_units_fact_type_check", "memory_units", type_="check")
 
     # Update existing 'bank' values to 'experience'
-    op.execute(f"UPDATE {schema}memory_units SET fact_type = 'experience' WHERE fact_type = 'bank'")
+    op.execute("UPDATE memory_units SET fact_type = 'experience' WHERE fact_type = 'bank'")
     # Also update any 'interactions' values (in case of partial migration)
-    op.execute(f"UPDATE {schema}memory_units SET fact_type = 'experience' WHERE fact_type = 'interactions'")
+    op.execute("UPDATE memory_units SET fact_type = 'experience' WHERE fact_type = 'interactions'")
 
     # Create new check constraint with 'experience' instead of 'bank'
     op.create_check_constraint(
@@ -39,13 +31,11 @@ def upgrade():
 
 
 def downgrade():
-    schema = _get_schema_prefix()
-
     # Drop new check constraint FIRST
     op.drop_constraint("memory_units_fact_type_check", "memory_units", type_="check")
 
     # Update 'experience' back to 'bank'
-    op.execute(f"UPDATE {schema}memory_units SET fact_type = 'bank' WHERE fact_type = 'experience'")
+    op.execute("UPDATE memory_units SET fact_type = 'bank' WHERE fact_type = 'experience'")
 
     # Recreate old check constraint
     op.create_check_constraint(

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

@@ -12,7 +12,7 @@ system (skepticism, literalism, empathy with 1-5 integer values).
 from collections.abc import Sequence
 
 import sqlalchemy as sa
-from alembic import context, op
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "e0a1b2c3d4e5"
@@ -21,36 +21,9 @@ 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 (e.g., 'tenant_x.' or '' for public)."""
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
-def _get_target_schema() -> str:
-    """Get the target schema name (tenant schema or 'public')."""
-    schema = context.config.get_main_option("target_schema")
-    return schema if schema else "public"
-
-
 def upgrade() -> None:
     """Convert Big Five disposition to 3-trait disposition."""
     conn = op.get_bind()
-    schema = _get_schema_prefix()
-    target_schema = _get_target_schema()
-
-    # Check if disposition column exists (should have been created by previous migration)
-    result = conn.execute(
-        sa.text("""
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = :schema AND table_name = 'banks' AND column_name = 'disposition'
-    """),
-        {"schema": target_schema},
-    )
-    if not result.fetchone():
-        # Column doesn't exist yet (shouldn't happen but be safe)
-        return
 
     # Update all existing banks to use the new disposition format
     # Convert from old format to new format with reasonable mappings:
@@ -59,18 +32,18 @@ def upgrade() -> None:
     # - empathy: derived from agreeableness + inverse of neuroticism
     # Default all to 3 (neutral) for simplicity
     conn.execute(
-        sa.text(f"""
-        UPDATE {schema}banks
-        SET disposition = '{{"skepticism": 3, "literalism": 3, "empathy": 3}}'::jsonb
+        sa.text("""
+        UPDATE banks
+        SET disposition = '{"skepticism": 3, "literalism": 3, "empathy": 3}'::jsonb
         WHERE disposition IS NOT NULL
     """)
     )
 
     # Update the default for new banks
     conn.execute(
-        sa.text(f"""
-        ALTER TABLE {schema}banks
-        ALTER COLUMN disposition SET DEFAULT '{{"skepticism": 3, "literalism": 3, "empathy": 3}}'::jsonb
+        sa.text("""
+        ALTER TABLE banks
+        ALTER COLUMN disposition SET DEFAULT '{"skepticism": 3, "literalism": 3, "empathy": 3}'::jsonb
     """)
     )
 
@@ -78,34 +51,20 @@ def upgrade() -> None:
 def downgrade() -> None:
     """Convert back to Big Five disposition."""
     conn = op.get_bind()
-    schema = _get_schema_prefix()
-    target_schema = _get_target_schema()
-
-    # Check if disposition column exists
-    result = conn.execute(
-        sa.text("""
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = :schema AND table_name = 'banks' AND column_name = 'disposition'
-    """),
-        {"schema": target_schema},
-    )
-    if not result.fetchone():
-        return
 
     # Revert to Big Five format with default values
     conn.execute(
-        sa.text(f"""
-        UPDATE {schema}banks
-        SET disposition = '{{"openness": 0.5, "conscientiousness": 0.5, "extraversion": 0.5, "agreeableness": 0.5, "neuroticism": 0.5, "bias_strength": 0.5}}'::jsonb
+        sa.text("""
+        UPDATE banks
+        SET disposition = '{"openness": 0.5, "conscientiousness": 0.5, "extraversion": 0.5, "agreeableness": 0.5, "neuroticism": 0.5, "bias_strength": 0.5}'::jsonb
         WHERE disposition IS NOT NULL
     """)
     )
 
     # Update the default for new banks
     conn.execute(
-        sa.text(f"""
-        ALTER TABLE {schema}banks
-        ALTER COLUMN disposition SET DEFAULT '{{"openness": 0.5, "conscientiousness": 0.5, "extraversion": 0.5, "agreeableness": 0.5, "neuroticism": 0.5, "bias_strength": 0.5}}'::jsonb
+        sa.text("""
+        ALTER TABLE banks
+        ALTER COLUMN disposition SET DEFAULT '{"openness": 0.5, "conscientiousness": 0.5, "extraversion": 0.5, "agreeableness": 0.5, "neuroticism": 0.5, "bias_strength": 0.5}'::jsonb
     """)
     )

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

@@ -9,7 +9,7 @@ Create Date: 2024-12-04
 from collections.abc import Sequence
 
 import sqlalchemy as sa
-from alembic import context, op
+from alembic import op
 from sqlalchemy.dialects import postgresql
 
 # revision identifiers, used by Alembic.
@@ -19,25 +19,17 @@ branch_labels: str | Sequence[str] | None = None
 depends_on: str | Sequence[str] | None = None
 
 
-def _get_target_schema() -> str:
-    """Get the target schema name (tenant schema or 'public')."""
-    schema = context.config.get_main_option("target_schema")
-    return schema if schema else "public"
-
-
 def upgrade() -> None:
     """Rename personality column to disposition in banks table (if it exists)."""
     conn = op.get_bind()
-    target_schema = _get_target_schema()
 
     # Check if 'personality' column exists (old database)
     result = conn.execute(
         sa.text("""
         SELECT column_name
         FROM information_schema.columns
-        WHERE table_schema = :schema AND table_name = 'banks' AND column_name = 'personality'
-    """),
-        {"schema": target_schema},
+        WHERE table_name = 'banks' AND column_name = 'personality'
+    """)
     )
     has_personality = result.fetchone() is not None
 
@@ -46,9 +38,8 @@ def upgrade() -> None:
         sa.text("""
         SELECT column_name
         FROM information_schema.columns
-        WHERE table_schema = :schema AND table_name = 'banks' AND column_name = 'disposition'
-    """),
-        {"schema": target_schema},
+        WHERE table_name = 'banks' AND column_name = 'disposition'
+    """)
     )
     has_disposition = result.fetchone() is not None
 
@@ -72,14 +63,12 @@ def upgrade() -> None:
 def downgrade() -> None:
     """Revert disposition column back to personality."""
     conn = op.get_bind()
-    target_schema = _get_target_schema()
     result = conn.execute(
         sa.text("""
         SELECT column_name
         FROM information_schema.columns
-        WHERE table_schema = :schema AND table_name = 'banks' AND column_name = 'disposition'
-    """),
-        {"schema": target_schema},
+        WHERE table_name = 'banks' AND column_name = 'disposition'
+    """)
     )
     if result.fetchone():
         op.alter_column("banks", "disposition", new_column_name="personality")

hindsight-api/hindsight_api/api/mcp.py

@@ -9,7 +9,6 @@ from fastmcp import FastMCP
 
 from hindsight_api import MemoryEngine
 from hindsight_api.engine.response_models import VALID_RECALL_FACT_TYPES
-from hindsight_api.models import RequestContext
 
 # Configure logging from HINDSIGHT_API_LOG_LEVEL environment variable
 _log_level_str = os.environ.get("HINDSIGHT_API_LOG_LEVEL", "info").lower()
@@ -68,11 +67,7 @@ def create_mcp_server(memory: MemoryEngine) -> FastMCP:
         """
         try:
             bank_id = get_current_bank_id()
-            if bank_id is None:
-                return "Error: No bank_id configured"
-            await memory.retain_batch_async(
-                bank_id=bank_id, contents=[{"content": content, "context": context}], request_context=RequestContext()
-            )
+            await memory.retain_batch_async(bank_id=bank_id, contents=[{"content": content, "context": context}])
             return "Memory stored successfully"
         except Exception as e:
             logger.error(f"Error storing memory: {e}", exc_info=True)
@@ -95,16 +90,10 @@ def create_mcp_server(memory: MemoryEngine) -> FastMCP:
         """
         try:
             bank_id = get_current_bank_id()
-            if bank_id is None:
-                return "Error: No bank_id configured"
             from hindsight_api.engine.memory_engine import Budget
 
             search_result = await memory.recall_async(
-                bank_id=bank_id,
-                query=query,
-                fact_type=list(VALID_RECALL_FACT_TYPES),
-                budget=Budget.LOW,
-                request_context=RequestContext(),
+                bank_id=bank_id, query=query, fact_type=list(VALID_RECALL_FACT_TYPES), budget=Budget.LOW
             )
 
             results = [
@@ -113,7 +102,7 @@ def create_mcp_server(memory: MemoryEngine) -> FastMCP:
                     "text": fact.text,
                     "type": fact.fact_type,
                     "context": fact.context,
-                    "occurred_start": fact.occurred_start,
+                    "event_date": fact.event_date,
                 }
                 for fact in search_result.results[:max_results]
             ]

hindsight-api/hindsight_api/config.py

@@ -33,10 +33,6 @@ ENV_GRAPH_RETRIEVER = "HINDSIGHT_API_GRAPH_RETRIEVER"
 ENV_MCP_LOCAL_BANK_ID = "HINDSIGHT_API_MCP_LOCAL_BANK_ID"
 ENV_MCP_INSTRUCTIONS = "HINDSIGHT_API_MCP_INSTRUCTIONS"
 
-# Optimization flags
-ENV_SKIP_LLM_VERIFICATION = "HINDSIGHT_API_SKIP_LLM_VERIFICATION"
-ENV_LAZY_RERANKER = "HINDSIGHT_API_LAZY_RERANKER"
-
 # Default values
 DEFAULT_DATABASE_URL = "pg0"
 DEFAULT_LLM_PROVIDER = "openai"
@@ -111,10 +107,6 @@ class HindsightConfig:
     # Recall
     graph_retriever: str
 
-    # Optimization flags
-    skip_llm_verification: bool
-    lazy_reranker: bool
-
     @classmethod
     def from_env(cls) -> "HindsightConfig":
         """Create configuration from environment variables."""
@@ -141,9 +133,6 @@ class HindsightConfig:
             mcp_enabled=os.getenv(ENV_MCP_ENABLED, str(DEFAULT_MCP_ENABLED)).lower() == "true",
             # Recall
             graph_retriever=os.getenv(ENV_GRAPH_RETRIEVER, DEFAULT_GRAPH_RETRIEVER),
-            # Optimization flags
-            skip_llm_verification=os.getenv(ENV_SKIP_LLM_VERIFICATION, "false").lower() == "true",
-            lazy_reranker=os.getenv(ENV_LAZY_RERANKER, "false").lower() == "true",
         )
 
     def get_llm_base_url(self) -> str:

hindsight-api/hindsight_api/daemon.py

@@ -1,204 +0,0 @@
-"""
-Daemon mode support for Hindsight API.
-
-Provides idle timeout and lockfile management for running as a background daemon.
-"""
-
-import asyncio
-import fcntl
-import logging
-import os
-import sys
-import time
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-# Default daemon configuration
-DEFAULT_DAEMON_PORT = 8889
-DEFAULT_IDLE_TIMEOUT = 0  # 0 = no auto-exit (hindsight-embed passes its own timeout)
-LOCKFILE_PATH = Path.home() / ".hindsight" / "daemon.lock"
-DAEMON_LOG_PATH = Path.home() / ".hindsight" / "daemon.log"
-
-
-class IdleTimeoutMiddleware:
-    """ASGI middleware that tracks activity and exits after idle timeout."""
-
-    def __init__(self, app, idle_timeout: int = DEFAULT_IDLE_TIMEOUT):
-        self.app = app
-        self.idle_timeout = idle_timeout
-        self.last_activity = time.time()
-        self._checker_task = None
-
-    async def __call__(self, scope, receive, send):
-        # Update activity timestamp on each request
-        self.last_activity = time.time()
-        await self.app(scope, receive, send)
-
-    def start_idle_checker(self):
-        """Start the background task that checks for idle timeout."""
-        self._checker_task = asyncio.create_task(self._check_idle())
-
-    async def _check_idle(self):
-        """Background task that exits the process after idle timeout."""
-        # If idle_timeout is 0, don't auto-exit
-        if self.idle_timeout <= 0:
-            return
-
-        while True:
-            await asyncio.sleep(30)  # Check every 30 seconds
-            idle_time = time.time() - self.last_activity
-            if idle_time > self.idle_timeout:
-                logger.info(f"Idle timeout reached ({self.idle_timeout}s), shutting down daemon")
-                # Give a moment for any in-flight requests
-                await asyncio.sleep(1)
-                os._exit(0)
-
-
-class DaemonLock:
-    """
-    File-based lock to prevent multiple daemon instances.
-
-    Uses fcntl.flock for atomic locking on Unix systems.
-    """
-
-    def __init__(self, lockfile: Path = LOCKFILE_PATH):
-        self.lockfile = lockfile
-        self._fd = None
-
-    def acquire(self) -> bool:
-        """
-        Try to acquire the daemon lock.
-
-        Returns True if lock acquired, False if another daemon is running.
-        """
-        self.lockfile.parent.mkdir(parents=True, exist_ok=True)
-
-        try:
-            self._fd = open(self.lockfile, "w")
-            fcntl.flock(self._fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-            # Write PID for debugging
-            self._fd.write(str(os.getpid()))
-            self._fd.flush()
-            return True
-        except (IOError, OSError):
-            # Lock is held by another process
-            if self._fd:
-                self._fd.close()
-                self._fd = None
-            return False
-
-    def release(self):
-        """Release the daemon lock."""
-        if self._fd:
-            try:
-                fcntl.flock(self._fd.fileno(), fcntl.LOCK_UN)
-                self._fd.close()
-            except Exception:
-                pass
-            finally:
-                self._fd = None
-                # Remove lockfile
-                try:
-                    self.lockfile.unlink()
-                except Exception:
-                    pass
-
-    def is_locked(self) -> bool:
-        """Check if the lock is held by another process."""
-        if not self.lockfile.exists():
-            return False
-
-        try:
-            fd = open(self.lockfile, "r")
-            fcntl.flock(fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-            # We got the lock, so no one else has it
-            fcntl.flock(fd.fileno(), fcntl.LOCK_UN)
-            fd.close()
-            return False
-        except (IOError, OSError):
-            return True
-
-    def get_pid(self) -> int | None:
-        """Get the PID of the daemon holding the lock."""
-        if not self.lockfile.exists():
-            return None
-        try:
-            with open(self.lockfile, "r") as f:
-                return int(f.read().strip())
-        except (ValueError, IOError):
-            return None
-
-
-def daemonize():
-    """
-    Fork the current process into a background daemon.
-
-    Uses double-fork technique to properly detach from terminal.
-    """
-    # First fork
-    pid = os.fork()
-    if pid > 0:
-        # Parent exits
-        sys.exit(0)
-
-    # Create new session
-    os.setsid()
-
-    # Second fork to prevent zombie processes
-    pid = os.fork()
-    if pid > 0:
-        sys.exit(0)
-
-    # Redirect standard file descriptors to log file
-    DAEMON_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
-
-    sys.stdout.flush()
-    sys.stderr.flush()
-
-    # Redirect stdin to /dev/null
-    with open("/dev/null", "r") as devnull:
-        os.dup2(devnull.fileno(), sys.stdin.fileno())
-
-    # Redirect stdout/stderr to log file
-    log_fd = open(DAEMON_LOG_PATH, "a")
-    os.dup2(log_fd.fileno(), sys.stdout.fileno())
-    os.dup2(log_fd.fileno(), sys.stderr.fileno())
-
-
-def check_daemon_running(port: int = DEFAULT_DAEMON_PORT) -> bool:
-    """Check if a daemon is running and responsive on the given port."""
-    import socket
-
-    try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(1)
-        result = sock.connect_ex(("127.0.0.1", port))
-        sock.close()
-        return result == 0
-    except Exception:
-        return False
-
-
-def stop_daemon(port: int = DEFAULT_DAEMON_PORT) -> bool:
-    """Stop a running daemon by sending SIGTERM to the process."""
-    lock = DaemonLock()
-    pid = lock.get_pid()
-
-    if pid is None:
-        return False
-
-    try:
-        import signal
-
-        os.kill(pid, signal.SIGTERM)
-        # Wait for process to exit
-        for _ in range(50):  # Wait up to 5 seconds
-            time.sleep(0.1)
-            try:
-                os.kill(pid, 0)  # Check if process exists
-            except OSError:
-                return True  # Process exited
-        return False
-    except OSError:
-        return False

hindsight-api/hindsight_api/engine/__init__.py

@@ -11,13 +11,7 @@ from .cross_encoder import CrossEncoderModel, LocalSTCrossEncoder, RemoteTEICros
 from .db_utils import acquire_with_retry
 from .embeddings import Embeddings, LocalSTEmbeddings, RemoteTEIEmbeddings
 from .llm_wrapper import LLMConfig
-from .memory_engine import (
-    MemoryEngine,
-    UnqualifiedTableError,
-    fq_table,
-    get_current_schema,
-    validate_sql_schema,
-)
+from .memory_engine import MemoryEngine
 from .response_models import MemoryFact, RecallResult, ReflectResult
 from .search.trace import (
     EntryPoint,
@@ -55,9 +49,4 @@ __all__ = [
     "RecallResult",
     "ReflectResult",
     "MemoryFact",
-    # Schema safety utilities
-    "fq_table",
-    "get_current_schema",
-    "validate_sql_schema",
-    "UnqualifiedTableError",
 ]

hindsight-api/hindsight_api/engine/entity_resolver.py

@@ -11,7 +11,6 @@ from difflib import SequenceMatcher
 import asyncpg
 
 from .db_utils import acquire_with_retry
-from .memory_engine import fq_table
 
 # Load spaCy model (singleton)
 _nlp = None
@@ -69,9 +68,9 @@ class EntityResolver:
     ) -> list[str]:
         # Query ALL candidates for this bank
         all_entities = await conn.fetch(
-            f"""
+            """
             SELECT canonical_name, id, metadata, last_seen, mention_count
-            FROM {fq_table("entities")}
+            FROM entities
             WHERE bank_id = $1
             """,
             bank_id,
@@ -83,11 +82,11 @@ class EntityResolver:
         # Query ALL co-occurrences for this bank's entities in one query
         # This builds a map of entity_id -> set of co-occurring entity names
         all_cooccurrences = await conn.fetch(
-            f"""
+            """
             SELECT ec.entity_id_1, ec.entity_id_2, ec.cooccurrence_count
-            FROM {fq_table("entity_cooccurrences")} ec
-            WHERE ec.entity_id_1 IN (SELECT id FROM {fq_table("entities")} WHERE bank_id = $1)
-               OR ec.entity_id_2 IN (SELECT id FROM {fq_table("entities")} WHERE bank_id = $1)
+            FROM entity_cooccurrences ec
+            WHERE ec.entity_id_1 IN (SELECT id FROM entities WHERE bank_id = $1)
+               OR ec.entity_id_2 IN (SELECT id FROM entities WHERE bank_id = $1)
             """,
             bank_id,
         )
@@ -196,8 +195,8 @@ class EntityResolver:
         # Batch update existing entities
         if entities_to_update:
             await conn.executemany(
-                f"""
-                UPDATE {fq_table("entities")} SET
+                """
+                UPDATE entities SET
                     mention_count = mention_count + 1,
                     last_seen = $2
                 WHERE id = $1::uuid
@@ -233,13 +232,13 @@ class EntityResolver:
             # Batch INSERT ... ON CONFLICT with RETURNING
             # This is much faster than individual inserts
             rows = await conn.fetch(
-                f"""
-                INSERT INTO {fq_table("entities")} (bank_id, canonical_name, first_seen, last_seen, mention_count)
+                """
+                INSERT INTO entities (bank_id, canonical_name, first_seen, last_seen, mention_count)
                 SELECT $1, name, event_date, event_date, 1
                 FROM unnest($2::text[], $3::timestamptz[]) AS t(name, event_date)
                 ON CONFLICT (bank_id, LOWER(canonical_name))
                 DO UPDATE SET
-                    mention_count = {fq_table("entities")}.mention_count + 1,
+                    mention_count = entities.mention_count + 1,
                     last_seen = EXCLUDED.last_seen
                 RETURNING id
                 """,
@@ -280,9 +279,9 @@ class EntityResolver:
         async with acquire_with_retry(self.pool) as conn:
             # Find candidate entities with similar name
             candidates = await conn.fetch(
-                f"""
+                """
                 SELECT id, canonical_name, metadata, last_seen
-                FROM {fq_table("entities")}
+                FROM entities
                 WHERE bank_id = $1
                   AND (
                     canonical_name ILIKE $2
@@ -327,10 +326,10 @@ class EntityResolver:
                 # Get entities that co-occurred with this candidate before
                 # Use the materialized co-occurrence cache for fast lookup
                 co_entity_rows = await conn.fetch(
-                    f"""
+                    """
                     SELECT e.canonical_name, ec.cooccurrence_count
-                    FROM {fq_table("entity_cooccurrences")} ec
-                    JOIN {fq_table("entities")} e ON (
+                    FROM entity_cooccurrences ec
+                    JOIN entities e ON (
                         CASE
                             WHEN ec.entity_id_1 = $1 THEN ec.entity_id_2
                             WHEN ec.entity_id_2 = $1 THEN ec.entity_id_1
@@ -366,8 +365,8 @@ class EntityResolver:
             if best_score > threshold:
                 # Update entity
                 await conn.execute(
-                    f"""
-                    UPDATE {fq_table("entities")}
+                    """
+                    UPDATE entities
                     SET mention_count = mention_count + 1,
                         last_seen = $1
                     WHERE id = $2
@@ -403,12 +402,12 @@ class EntityResolver:
             Entity ID
         """
         entity_id = await conn.fetchval(
-            f"""
-            INSERT INTO {fq_table("entities")} (bank_id, canonical_name, first_seen, last_seen, mention_count)
+            """
+            INSERT INTO entities (bank_id, canonical_name, first_seen, last_seen, mention_count)
             VALUES ($1, $2, $3, $4, 1)
             ON CONFLICT (bank_id, LOWER(canonical_name))
             DO UPDATE SET
-                mention_count = {fq_table("entities")}.mention_count + 1,
+                mention_count = entities.mention_count + 1,
                 last_seen = EXCLUDED.last_seen
             RETURNING id
             """,
@@ -431,8 +430,8 @@ class EntityResolver:
         async with acquire_with_retry(self.pool) as conn:
             # Insert unit-entity link
             await conn.execute(
-                f"""
-                INSERT INTO {fq_table("unit_entities")} (unit_id, entity_id)
+                """
+                INSERT INTO unit_entities (unit_id, entity_id)
                 VALUES ($1, $2)
                 ON CONFLICT DO NOTHING
                 """,
@@ -442,9 +441,9 @@ class EntityResolver:
 
             # Update co-occurrence cache: find other entities in this unit
             rows = await conn.fetch(
-                f"""
+                """
                 SELECT entity_id
-                FROM {fq_table("unit_entities")}
+                FROM unit_entities
                 WHERE unit_id = $1 AND entity_id != $2
                 """,
                 unit_id,
@@ -473,12 +472,12 @@ class EntityResolver:
             entity_id_1, entity_id_2 = entity_id_2, entity_id_1
 
         await conn.execute(
-            f"""
-            INSERT INTO {fq_table("entity_cooccurrences")} (entity_id_1, entity_id_2, cooccurrence_count, last_cooccurred)
+            """
+            INSERT INTO entity_cooccurrences (entity_id_1, entity_id_2, cooccurrence_count, last_cooccurred)
             VALUES ($1, $2, 1, NOW())
             ON CONFLICT (entity_id_1, entity_id_2)
             DO UPDATE SET
-                cooccurrence_count = {fq_table("entity_cooccurrences")}.cooccurrence_count + 1,
+                cooccurrence_count = entity_cooccurrences.cooccurrence_count + 1,
                 last_cooccurred = NOW()
             """,
             entity_id_1,
@@ -507,8 +506,8 @@ class EntityResolver:
     async def _link_units_to_entities_batch_impl(self, conn, unit_entity_pairs: list[tuple[str, str]]):
         # Batch insert all unit-entity links
         await conn.executemany(
-            f"""
-            INSERT INTO {fq_table("unit_entities")} (unit_id, entity_id)
+            """
+            INSERT INTO unit_entities (unit_id, entity_id)
             VALUES ($1, $2)
             ON CONFLICT DO NOTHING
             """,
@@ -542,12 +541,12 @@ class EntityResolver:
         if cooccurrence_pairs:
             now = datetime.now(UTC)
             await conn.executemany(
-                f"""
-                INSERT INTO {fq_table("entity_cooccurrences")} (entity_id_1, entity_id_2, cooccurrence_count, last_cooccurred)
+                """
+                INSERT INTO entity_cooccurrences (entity_id_1, entity_id_2, cooccurrence_count, last_cooccurred)
                 VALUES ($1, $2, $3, $4)
                 ON CONFLICT (entity_id_1, entity_id_2)
                 DO UPDATE SET
-                    cooccurrence_count = {fq_table("entity_cooccurrences")}.cooccurrence_count + 1,
+                    cooccurrence_count = entity_cooccurrences.cooccurrence_count + 1,
                     last_cooccurred = EXCLUDED.last_cooccurred
                 """,
                 [(e1, e2, 1, now) for e1, e2 in cooccurrence_pairs],
@@ -566,9 +565,9 @@ class EntityResolver:
         """
         async with acquire_with_retry(self.pool) as conn:
             rows = await conn.fetch(
-                f"""
+                """
                 SELECT unit_id
-                FROM {fq_table("unit_entities")}
+                FROM unit_entities
                 WHERE entity_id = $1
                 ORDER BY unit_id
                 LIMIT $2
@@ -595,8 +594,8 @@ class EntityResolver:
         """
         async with acquire_with_retry(self.pool) as conn:
             row = await conn.fetchrow(
-                f"""
-                SELECT id FROM {fq_table("entities")}
+                """
+                SELECT id FROM entities
                 WHERE bank_id = $1
                   AND canonical_name ILIKE $2
                 ORDER BY mention_count DESC

hindsight-api/hindsight_api/engine/interface.py

@@ -1,592 +0,0 @@
-"""Abstract interface for MemoryEngine public methods.
-
-This module defines the public API that HTTP endpoints and extensions should use
-to interact with the memory system. All methods require a RequestContext for
-authentication when a TenantExtension is configured.
-"""
-
-from abc import ABC, abstractmethod
-from datetime import datetime
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from hindsight_api.engine.memory_engine import Budget
-    from hindsight_api.engine.response_models import RecallResult, ReflectResult
-    from hindsight_api.models import RequestContext
-
-
-class MemoryEngineInterface(ABC):
-    """
-    Abstract interface for the Memory Engine.
-
-    This defines the public API that should be used by HTTP endpoints and extensions.
-    All methods require a RequestContext for authentication.
-    """
-
-    # =========================================================================
-    # Health & Status
-    # =========================================================================
-
-    @abstractmethod
-    async def health_check(self) -> dict:
-        """
-        Check the health of the memory system.
-
-        Returns:
-            Dict with 'status' key ('healthy' or 'unhealthy') and additional info.
-        """
-        ...
-
-    # =========================================================================
-    # Core Memory Operations
-    # =========================================================================
-
-    @abstractmethod
-    async def retain_batch_async(
-        self,
-        bank_id: str,
-        contents: list[dict[str, Any]],
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Retain a batch of memory items.
-
-        Args:
-            bank_id: The memory bank ID.
-            contents: List of content dicts with 'content', optional 'event_date',
-                     'context', 'metadata', 'document_id'.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with processing results.
-        """
-        ...
-
-    @abstractmethod
-    async def recall_async(
-        self,
-        bank_id: str,
-        query: str,
-        *,
-        budget: "Budget | None" = None,
-        max_tokens: int = 4096,
-        enable_trace: bool = False,
-        fact_type: list[str] | None = None,
-        question_date: datetime | None = None,
-        include_entities: bool = False,
-        max_entity_tokens: int = 500,
-        include_chunks: bool = False,
-        max_chunk_tokens: int = 8192,
-        request_context: "RequestContext",
-    ) -> "RecallResult":
-        """
-        Recall memories relevant to a query.
-
-        Args:
-            bank_id: The memory bank ID.
-            query: The search query.
-            budget: Search budget (LOW, MID, HIGH).
-            max_tokens: Maximum tokens in response.
-            enable_trace: Include trace information.
-            fact_type: Filter by fact types.
-            question_date: Context date for temporal relevance.
-            include_entities: Include entity observations.
-            max_entity_tokens: Max tokens for entity observations.
-            include_chunks: Include raw chunks.
-            max_chunk_tokens: Max tokens for chunks.
-            request_context: Request context for authentication.
-
-        Returns:
-            RecallResult with matching memories.
-        """
-        ...
-
-    @abstractmethod
-    async def reflect_async(
-        self,
-        bank_id: str,
-        query: str,
-        *,
-        budget: "Budget | None" = None,
-        context: str | None = None,
-        request_context: "RequestContext",
-    ) -> "ReflectResult":
-        """
-        Reflect on a query and generate a thoughtful response.
-
-        Args:
-            bank_id: The memory bank ID.
-            query: The question to reflect on.
-            budget: Search budget for retrieving context.
-            context: Additional context for the reflection.
-            request_context: Request context for authentication.
-
-        Returns:
-            ReflectResult with generated response and supporting facts.
-        """
-        ...
-
-    # =========================================================================
-    # Bank Management
-    # =========================================================================
-
-    @abstractmethod
-    async def list_banks(
-        self,
-        *,
-        request_context: "RequestContext",
-    ) -> list[dict[str, Any]]:
-        """
-        List all memory banks.
-
-        Args:
-            request_context: Request context for authentication.
-
-        Returns:
-            List of bank info dicts.
-        """
-        ...
-
-    @abstractmethod
-    async def get_bank_profile(
-        self,
-        bank_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Get bank profile including disposition and background.
-
-        Args:
-            bank_id: The memory bank ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            Bank profile dict.
-        """
-        ...
-
-    @abstractmethod
-    async def update_bank_disposition(
-        self,
-        bank_id: str,
-        disposition: dict[str, int],
-        *,
-        request_context: "RequestContext",
-    ) -> None:
-        """
-        Update bank disposition traits.
-
-        Args:
-            bank_id: The memory bank ID.
-            disposition: Dict with trait values.
-            request_context: Request context for authentication.
-        """
-        ...
-
-    @abstractmethod
-    async def merge_bank_background(
-        self,
-        bank_id: str,
-        new_info: str,
-        *,
-        update_disposition: bool = True,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Merge new background information into bank profile.
-
-        Args:
-            bank_id: The memory bank ID.
-            new_info: New background information to merge.
-            update_disposition: Whether to infer disposition from background.
-            request_context: Request context for authentication.
-
-        Returns:
-            Updated background info.
-        """
-        ...
-
-    @abstractmethod
-    async def delete_bank(
-        self,
-        bank_id: str,
-        *,
-        fact_type: str | None = None,
-        request_context: "RequestContext",
-    ) -> dict[str, int]:
-        """
-        Delete a bank or its memories.
-
-        Args:
-            bank_id: The memory bank ID.
-            fact_type: If specified, only delete memories of this type.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with deletion counts.
-        """
-        ...
-
-    # =========================================================================
-    # Memory Units
-    # =========================================================================
-
-    @abstractmethod
-    async def list_memory_units(
-        self,
-        bank_id: str,
-        *,
-        fact_type: str | None = None,
-        search_query: str | None = None,
-        limit: int = 100,
-        offset: int = 0,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        List memory units with pagination.
-
-        Args:
-            bank_id: The memory bank ID.
-            fact_type: Filter by fact type.
-            search_query: Full-text search query.
-            limit: Maximum results.
-            offset: Pagination offset.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with 'items', 'total', 'limit', 'offset'.
-        """
-        ...
-
-    @abstractmethod
-    async def delete_memory_unit(
-        self,
-        unit_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Delete a specific memory unit.
-
-        Args:
-            unit_id: The memory unit ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            Deletion result.
-        """
-        ...
-
-    @abstractmethod
-    async def get_graph_data(
-        self,
-        bank_id: str,
-        *,
-        fact_type: str | None = None,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Get graph data for visualization.
-
-        Args:
-            bank_id: The memory bank ID.
-            fact_type: Filter by fact type.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with nodes, edges, table_rows, total_units.
-        """
-        ...
-
-    # =========================================================================
-    # Documents
-    # =========================================================================
-
-    @abstractmethod
-    async def list_documents(
-        self,
-        bank_id: str,
-        *,
-        search_query: str | None = None,
-        limit: int = 100,
-        offset: int = 0,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        List documents with pagination.
-
-        Args:
-            bank_id: The memory bank ID.
-            search_query: Search query.
-            limit: Maximum results.
-            offset: Pagination offset.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with 'items', 'total', 'limit', 'offset'.
-        """
-        ...
-
-    @abstractmethod
-    async def get_document(
-        self,
-        document_id: str,
-        bank_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any] | None:
-        """
-        Get a specific document.
-
-        Args:
-            document_id: The document ID.
-            bank_id: The memory bank ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            Document dict or None if not found.
-        """
-        ...
-
-    @abstractmethod
-    async def delete_document(
-        self,
-        document_id: str,
-        bank_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, int]:
-        """
-        Delete a document and its memory units.
-
-        Args:
-            document_id: The document ID.
-            bank_id: The memory bank ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with deletion counts.
-        """
-        ...
-
-    @abstractmethod
-    async def get_chunk(
-        self,
-        chunk_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any] | None:
-        """
-        Get a specific chunk.
-
-        Args:
-            chunk_id: The chunk ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            Chunk dict or None if not found.
-        """
-        ...
-
-    # =========================================================================
-    # Entities
-    # =========================================================================
-
-    @abstractmethod
-    async def list_entities(
-        self,
-        bank_id: str,
-        *,
-        limit: int = 100,
-        request_context: "RequestContext",
-    ) -> list[dict[str, Any]]:
-        """
-        List entities for a bank.
-
-        Args:
-            bank_id: The memory bank ID.
-            limit: Maximum results.
-            request_context: Request context for authentication.
-
-        Returns:
-            List of entity dicts.
-        """
-        ...
-
-    @abstractmethod
-    async def get_entity_observations(
-        self,
-        bank_id: str,
-        entity_id: str,
-        *,
-        limit: int = 10,
-        request_context: "RequestContext",
-    ) -> list[Any]:
-        """
-        Get observations for an entity.
-
-        Args:
-            bank_id: The memory bank ID.
-            entity_id: The entity ID.
-            limit: Maximum observations.
-            request_context: Request context for authentication.
-
-        Returns:
-            List of EntityObservation objects.
-        """
-        ...
-
-    @abstractmethod
-    async def regenerate_entity_observations(
-        self,
-        bank_id: str,
-        entity_id: str,
-        entity_name: str,
-        *,
-        request_context: "RequestContext",
-    ) -> None:
-        """
-        Regenerate observations for an entity.
-
-        Args:
-            bank_id: The memory bank ID.
-            entity_id: The entity ID.
-            entity_name: The entity's canonical name.
-            request_context: Request context for authentication.
-        """
-        ...
-
-    # =========================================================================
-    # Statistics & Operations
-    # =========================================================================
-
-    @abstractmethod
-    async def get_bank_stats(
-        self,
-        bank_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Get statistics about memory nodes and links for a bank.
-
-        Args:
-            bank_id: The memory bank ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with node_counts, link_counts, link_counts_by_fact_type,
-            link_breakdown, and operations stats.
-        """
-        ...
-
-    @abstractmethod
-    async def get_entity(
-        self,
-        bank_id: str,
-        entity_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any] | None:
-        """
-        Get entity details including metadata and observations.
-
-        Args:
-            bank_id: The memory bank ID.
-            entity_id: The entity ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            Entity dict with id, canonical_name, mention_count, first_seen,
-            last_seen, metadata, and observations. None if not found.
-        """
-        ...
-
-    @abstractmethod
-    async def list_operations(
-        self,
-        bank_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> list[dict[str, Any]]:
-        """
-        List async operations for a bank.
-
-        Args:
-            bank_id: The memory bank ID.
-            request_context: Request context for authentication.
-
-        Returns:
-            List of operation dicts with id, task_type, status, etc.
-        """
-        ...
-
-    @abstractmethod
-    async def cancel_operation(
-        self,
-        bank_id: str,
-        operation_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Cancel a pending async operation.
-
-        Args:
-            bank_id: The memory bank ID.
-            operation_id: The operation ID to cancel.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with success status and message.
-
-        Raises:
-            ValueError: If operation not found.
-        """
-        ...
-
-    @abstractmethod
-    async def update_bank(
-        self,
-        bank_id: str,
-        *,
-        name: str | None = None,
-        background: str | None = None,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Update bank name and/or background.
-
-        Args:
-            bank_id: The memory bank ID.
-            name: New bank name (optional).
-            background: New background text (optional, replaces existing).
-            request_context: Request context for authentication.
-
-        Returns:
-            Updated bank profile dict.
-        """
-        ...
-
-    @abstractmethod
-    async def submit_async_retain(
-        self,
-        bank_id: str,
-        contents: list[dict[str, Any]],
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, Any]:
-        """
-        Submit a batch retain operation to run asynchronously.
-
-        Args:
-            bank_id: The memory bank ID.
-            contents: List of content dicts to retain.
-            request_context: Request context for authentication.
-
-        Returns:
-            Dict with operation_id and items_count.
-        """
-        ...

hindsight-api/hindsight_api/engine/llm_wrapper.py

@@ -3,13 +3,11 @@ LLM wrapper for unified configuration across providers.
 """
 
 import asyncio
-import json
 import logging
 import os
 import time
 from typing import Any
 
-import httpx
 from google import genai
 from google.genai import errors as genai_errors
 from google.genai import types as genai_types
@@ -98,7 +96,7 @@ class LLMProvider:
             client_kwargs = {"api_key": self.api_key, "max_retries": 0}
             if self.base_url:
                 client_kwargs["base_url"] = self.base_url
-            self._client = AsyncOpenAI(**client_kwargs)  # type: ignore[invalid-argument-type] - dict kwargs
+            self._client = AsyncOpenAI(**client_kwargs)
             self._gemini_client = None
 
     async def verify_connection(self) -> None:
@@ -159,6 +157,7 @@ class LLMProvider:
         """
         async with _global_llm_semaphore:
             start_time = time.time()
+            import json
 
             # Handle Gemini provider separately
             if self.provider == "gemini":
@@ -166,20 +165,6 @@ class LLMProvider:
                     messages, response_format, max_retries, initial_backoff, max_backoff, skip_validation, start_time
                 )
 
-            # Handle Ollama with native API for structured output (better schema enforcement)
-            if self.provider == "ollama" and response_format is not None:
-                return await self._call_ollama_native(
-                    messages,
-                    response_format,
-                    max_completion_tokens,
-                    temperature,
-                    max_retries,
-                    initial_backoff,
-                    max_backoff,
-                    skip_validation,
-                    start_time,
-                )
-
             call_params = {
                 "model": self.model,
                 "messages": messages,
@@ -242,31 +227,7 @@ class LLMProvider:
                         response = await self._client.chat.completions.create(**call_params)
 
                         content = response.choices[0].message.content
-
-                        # Log raw LLM response for debugging JSON parse issues
-                        try:
-                            json_data = json.loads(content)
-                        except json.JSONDecodeError as json_err:
-                            # Truncate content for logging (first 500 and last 200 chars)
-                            content_preview = content[:500] if content else "<empty>"
-                            if content and len(content) > 700:
-                                content_preview = f"{content[:500]}...TRUNCATED...{content[-200:]}"
-                            logger.warning(
-                                f"JSON parse error from LLM response (attempt {attempt + 1}/{max_retries + 1}): {json_err}\n"
-                                f"  Model: {self.provider}/{self.model}\n"
-                                f"  Content length: {len(content) if content else 0} chars\n"
-                                f"  Content preview: {content_preview!r}\n"
-                                f"  Finish reason: {response.choices[0].finish_reason if response.choices else 'unknown'}"
-                            )
-                            # Retry on JSON parse errors - LLM may return valid JSON on next attempt
-                            if attempt < max_retries:
-                                backoff = min(initial_backoff * (2**attempt), max_backoff)
-                                await asyncio.sleep(backoff)
-                                last_exception = json_err
-                                continue
-                            else:
-                                logger.error(f"JSON parse error after {max_retries + 1} attempts, giving up")
-                                raise
+                        json_data = json.loads(content)
 
                         if skip_validation:
                             result = json_data
@@ -339,129 +300,6 @@ class LLMProvider:
                 raise last_exception
             raise RuntimeError("LLM call failed after all retries with no exception captured")
 
-    async def _call_ollama_native(
-        self,
-        messages: list[dict[str, str]],
-        response_format: Any,
-        max_completion_tokens: int | None,
-        temperature: float | None,
-        max_retries: int,
-        initial_backoff: float,
-        max_backoff: float,
-        skip_validation: bool,
-        start_time: float,
-    ) -> Any:
-        """
-        Call Ollama using native API with JSON schema enforcement.
-
-        Ollama's native API supports passing a full JSON schema in the 'format' parameter,
-        which provides better structured output control than the OpenAI-compatible API.
-        """
-        # Get the JSON schema from the Pydantic model
-        schema = response_format.model_json_schema() if hasattr(response_format, "model_json_schema") else None
-
-        # Build the base URL for Ollama's native API
-        # Default OpenAI-compatible URL is http://localhost:11434/v1
-        # Native API is at http://localhost:11434/api/chat
-        base_url = self.base_url or "http://localhost:11434/v1"
-        if base_url.endswith("/v1"):
-            native_url = base_url[:-3] + "/api/chat"
-        else:
-            native_url = base_url.rstrip("/") + "/api/chat"
-
-        # Build request payload
-        payload = {
-            "model": self.model,
-            "messages": messages,
-            "stream": False,
-        }
-
-        # Add schema as format parameter for structured output
-        if schema:
-            payload["format"] = schema
-
-        # Add optional parameters with optimized defaults for Ollama
-        # Benchmarking shows num_ctx=16384 + num_batch=512 is optimal
-        options = {
-            "num_ctx": 16384,  # 16k context window for larger prompts
-            "num_batch": 512,  # Optimal batch size for prompt processing
-        }
-        if max_completion_tokens:
-            options["num_predict"] = max_completion_tokens
-        if temperature is not None:
-            options["temperature"] = temperature
-        payload["options"] = options
-
-        last_exception = None
-
-        async with httpx.AsyncClient(timeout=300.0) as client:
-            for attempt in range(max_retries + 1):
-                try:
-                    response = await client.post(native_url, json=payload)
-                    response.raise_for_status()
-
-                    result = response.json()
-                    content = result.get("message", {}).get("content", "")
-
-                    # Parse JSON response
-                    try:
-                        json_data = json.loads(content)
-                    except json.JSONDecodeError as json_err:
-                        content_preview = content[:500] if content else "<empty>"
-                        if content and len(content) > 700:
-                            content_preview = f"{content[:500]}...TRUNCATED...{content[-200:]}"
-                        logger.warning(
-                            f"Ollama JSON parse error (attempt {attempt + 1}/{max_retries + 1}): {json_err}\n"
-                            f"  Model: ollama/{self.model}\n"
-                            f"  Content length: {len(content) if content else 0} chars\n"
-                            f"  Content preview: {content_preview!r}"
-                        )
-                        if attempt < max_retries:
-                            backoff = min(initial_backoff * (2**attempt), max_backoff)
-                            await asyncio.sleep(backoff)
-                            last_exception = json_err
-                            continue
-                        else:
-                            raise
-
-                    # Validate against Pydantic model or return raw JSON
-                    if skip_validation:
-                        return json_data
-                    else:
-                        return response_format.model_validate(json_data)
-
-                except httpx.HTTPStatusError as e:
-                    last_exception = e
-                    if attempt < max_retries:
-                        logger.warning(
-                            f"Ollama HTTP error (attempt {attempt + 1}/{max_retries + 1}): {e.response.status_code}"
-                        )
-                        backoff = min(initial_backoff * (2**attempt), max_backoff)
-                        await asyncio.sleep(backoff)
-                        continue
-                    else:
-                        logger.error(f"Ollama HTTP error after {max_retries + 1} attempts: {e}")
-                        raise
-
-                except httpx.RequestError as e:
-                    last_exception = e
-                    if attempt < max_retries:
-                        logger.warning(f"Ollama connection error (attempt {attempt + 1}/{max_retries + 1}): {e}")
-                        backoff = min(initial_backoff * (2**attempt), max_backoff)
-                        await asyncio.sleep(backoff)
-                        continue
-                    else:
-                        logger.error(f"Ollama connection error after {max_retries + 1} attempts: {e}")
-                        raise
-
-                except Exception as e:
-                    logger.error(f"Unexpected error during Ollama call: {type(e).__name__}: {e}")
-                    raise
-
-        if last_exception:
-            raise last_exception
-        raise RuntimeError("Ollama call failed after all retries")
-
     async def _call_gemini(
         self,
         messages: list[dict[str, str]],
@@ -473,6 +311,8 @@ class LLMProvider:
         start_time: float,
     ) -> Any:
         """Handle Gemini-specific API calls."""
+        import json
+
         # Convert OpenAI-style messages to Gemini format
         system_instruction = None
         gemini_contents = []
@@ -603,8 +443,6 @@ class LLMProvider:
         """Create provider for memory operations from environment variables."""
         provider = os.getenv("HINDSIGHT_API_LLM_PROVIDER", "groq")
         api_key = os.getenv("HINDSIGHT_API_LLM_API_KEY")
-        if not api_key:
-            raise ValueError("HINDSIGHT_API_LLM_API_KEY environment variable is required")
         base_url = os.getenv("HINDSIGHT_API_LLM_BASE_URL", "")
         model = os.getenv("HINDSIGHT_API_LLM_MODEL", "openai/gpt-oss-120b")
 
@@ -615,10 +453,6 @@ class LLMProvider:
         """Create provider for answer generation. Falls back to memory config if not set."""
         provider = os.getenv("HINDSIGHT_API_ANSWER_LLM_PROVIDER", os.getenv("HINDSIGHT_API_LLM_PROVIDER", "groq"))
         api_key = os.getenv("HINDSIGHT_API_ANSWER_LLM_API_KEY", os.getenv("HINDSIGHT_API_LLM_API_KEY"))
-        if not api_key:
-            raise ValueError(
-                "HINDSIGHT_API_LLM_API_KEY or HINDSIGHT_API_ANSWER_LLM_API_KEY environment variable is required"
-            )
         base_url = os.getenv("HINDSIGHT_API_ANSWER_LLM_BASE_URL", os.getenv("HINDSIGHT_API_LLM_BASE_URL", ""))
         model = os.getenv("HINDSIGHT_API_ANSWER_LLM_MODEL", os.getenv("HINDSIGHT_API_LLM_MODEL", "openai/gpt-oss-120b"))
 
@@ -629,10 +463,6 @@ class LLMProvider:
         """Create provider for judge/evaluator operations. Falls back to memory config if not set."""
         provider = os.getenv("HINDSIGHT_API_JUDGE_LLM_PROVIDER", os.getenv("HINDSIGHT_API_LLM_PROVIDER", "groq"))
         api_key = os.getenv("HINDSIGHT_API_JUDGE_LLM_API_KEY", os.getenv("HINDSIGHT_API_LLM_API_KEY"))
-        if not api_key:
-            raise ValueError(
-                "HINDSIGHT_API_LLM_API_KEY or HINDSIGHT_API_JUDGE_LLM_API_KEY environment variable is required"
-            )
         base_url = os.getenv("HINDSIGHT_API_JUDGE_LLM_BASE_URL", os.getenv("HINDSIGHT_API_LLM_BASE_URL", ""))
         model = os.getenv("HINDSIGHT_API_JUDGE_LLM_MODEL", os.getenv("HINDSIGHT_API_LLM_MODEL", "openai/gpt-oss-120b"))
 

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

@@ -10,7 +10,6 @@ from typing import TypedDict
 from pydantic import BaseModel, Field
 
 from ..db_utils import acquire_with_retry
-from ..memory_engine import fq_table
 from ..response_models import DispositionTraits
 
 logger = logging.getLogger(__name__)
@@ -52,9 +51,9 @@ async def get_bank_profile(pool, bank_id: str) -> BankProfile:
     async with acquire_with_retry(pool) as conn:
         # Try to get existing bank
         row = await conn.fetchrow(
-            f"""
+            """
             SELECT name, disposition, background
-            FROM {fq_table("banks")} WHERE bank_id = $1
+            FROM banks WHERE bank_id = $1
             """,
             bank_id,
         )
@@ -71,8 +70,8 @@ async def get_bank_profile(pool, bank_id: str) -> BankProfile:
 
         # Bank doesn't exist, create with defaults
         await conn.execute(
-            f"""
-            INSERT INTO {fq_table("banks")} (bank_id, name, disposition, background)
+            """
+            INSERT INTO banks (bank_id, name, disposition, background)
             VALUES ($1, $2, $3::jsonb, $4)
             ON CONFLICT (bank_id) DO NOTHING
             """,
@@ -99,8 +98,8 @@ async def update_bank_disposition(pool, bank_id: str, disposition: dict[str, int
 
     async with acquire_with_retry(pool) as conn:
         await conn.execute(
-            f"""
-            UPDATE {fq_table("banks")}
+            """
+            UPDATE banks
             SET disposition = $2::jsonb,
                 updated_at = NOW()
             WHERE bank_id = $1
@@ -141,8 +140,8 @@ async def merge_bank_background(pool, llm_config, bank_id: str, new_info: str, u
         if inferred_disposition:
             # Update both background and disposition
             await conn.execute(
-                f"""
-                UPDATE {fq_table("banks")}
+                """
+                UPDATE banks
                 SET background = $2,
                     disposition = $3::jsonb,
                     updated_at = NOW()
@@ -155,8 +154,8 @@ async def merge_bank_background(pool, llm_config, bank_id: str, new_info: str, u
         else:
             # Update only background
             await conn.execute(
-                f"""
-                UPDATE {fq_table("banks")}
+                """
+                UPDATE banks
                 SET background = $2,
                     updated_at = NOW()
                 WHERE bank_id = $1
@@ -362,9 +361,9 @@ async def list_banks(pool) -> list:
     """
     async with acquire_with_retry(pool) as conn:
         rows = await conn.fetch(
-            f"""
+            """
             SELECT bank_id, name, disposition, background, created_at, updated_at
-            FROM {fq_table("banks")}
+            FROM banks
             ORDER BY updated_at DESC
             """
         )

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

@@ -6,7 +6,6 @@ Handles storage of document chunks in the database.
 
 import logging
 
-from ..memory_engine import fq_table
 from .types import ChunkMetadata
 
 logger = logging.getLogger(__name__)
@@ -43,8 +42,8 @@ async def store_chunks_batch(conn, bank_id: str, document_id: str, chunks: list[
 
     # Batch insert all chunks
     await conn.execute(
-        f"""
-        INSERT INTO {fq_table("chunks")} (chunk_id, document_id, bank_id, chunk_text, chunk_index)
+        """
+        INSERT INTO chunks (chunk_id, document_id, bank_id, chunk_text, chunk_index)
         SELECT * FROM unnest($1::text[], $2::text[], $3::text[], $4::text[], $5::integer[])
         """,
         chunk_ids,

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 ..memory_engine import fq_table
 from .types import ProcessedFact
 
 logger = logging.getLogger(__name__)
@@ -68,8 +67,8 @@ async def insert_facts_batch(
 
     # Batch insert all facts
     results = await conn.fetch(
-        f"""
-        INSERT INTO {fq_table("memory_units")} (bank_id, text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
+        """
+        INSERT INTO memory_units (bank_id, text, embedding, event_date, occurred_start, occurred_end, mentioned_at,
                                  context, fact_type, confidence_score, access_count, metadata, chunk_id, document_id)
         SELECT $1, * FROM unnest(
             $2::text[], $3::vector[], $4::timestamptz[], $5::timestamptz[], $6::timestamptz[], $7::timestamptz[],
@@ -108,8 +107,8 @@ async def ensure_bank_exists(conn, bank_id: str) -> None:
         bank_id: Bank identifier
     """
     await conn.execute(
-        f"""
-        INSERT INTO {fq_table("banks")} (bank_id, disposition, background)
+        """
+        INSERT INTO banks (bank_id, disposition, background)
         VALUES ($1, $2::jsonb, $3)
         ON CONFLICT (bank_id) DO UPDATE
         SET updated_at = NOW()
@@ -142,14 +141,12 @@ async def handle_document_tracking(
     # Always delete old document first if it exists (cascades to units and links)
     # Only delete on the first batch to avoid deleting data we just inserted
     if is_first_batch:
-        await conn.fetchval(
-            f"DELETE FROM {fq_table('documents')} WHERE id = $1 AND bank_id = $2 RETURNING id", document_id, bank_id
-        )
+        await conn.fetchval("DELETE FROM documents WHERE id = $1 AND bank_id = $2 RETURNING id", document_id, bank_id)
 
     # Insert document (or update if exists from concurrent operations)
     await conn.execute(
-        f"""
-        INSERT INTO {fq_table("documents")} (id, bank_id, original_text, content_hash, metadata, retain_params)
+        """
+        INSERT INTO documents (id, bank_id, original_text, content_hash, metadata, retain_params)
         VALUES ($1, $2, $3, $4, $5, $6)
         ON CONFLICT (id, bank_id) DO UPDATE
         SET original_text = EXCLUDED.original_text,

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

@@ -7,7 +7,6 @@ import time
 from datetime import UTC, datetime, timedelta
 from uuid import UUID
 
-from ..memory_engine import fq_table
 from .types import EntityLink
 
 logger = logging.getLogger(__name__)
@@ -291,9 +290,9 @@ async def extract_entities_batch_optimized(
 
             entity_id_list = [uuid.UUID(eid) if isinstance(eid, str) else eid for eid in all_entity_ids]
             rows = await conn.fetch(
-                f"""
+                """
                 SELECT entity_id, unit_id
-                FROM {fq_table("unit_entities")}
+                FROM unit_entities
                 WHERE entity_id = ANY($1::uuid[])
                 """,
                 entity_id_list,
@@ -414,9 +413,9 @@ async def create_temporal_links_batch_per_fact(
         # Get the event_date for each new unit
         fetch_dates_start = time_mod.time()
         rows = await conn.fetch(
-            f"""
+            """
             SELECT id, event_date
-            FROM {fq_table("memory_units")}
+            FROM memory_units
             WHERE id::text = ANY($1)
             """,
             unit_ids,
@@ -433,9 +432,9 @@ async def create_temporal_links_batch_per_fact(
 
         fetch_neighbors_start = time_mod.time()
         all_candidates = await conn.fetch(
-            f"""
+            """
             SELECT id, event_date
-            FROM {fq_table("memory_units")}
+            FROM memory_units
             WHERE bank_id = $1
               AND event_date BETWEEN $2 AND $3
               AND id::text != ALL($4)
@@ -480,8 +479,8 @@ async def create_temporal_links_batch_per_fact(
         if links:
             insert_start = time_mod.time()
             await conn.executemany(
-                f"""
-                INSERT INTO {fq_table("memory_links")} (from_unit_id, to_unit_id, link_type, weight, entity_id)
+                """
+                INSERT INTO memory_links (from_unit_id, to_unit_id, link_type, weight, entity_id)
                 VALUES ($1, $2, $3, $4, $5)
                 ON CONFLICT (from_unit_id, to_unit_id, link_type, COALESCE(entity_id, '00000000-0000-0000-0000-000000000000'::uuid)) DO NOTHING
                 """,
@@ -536,9 +535,9 @@ async def create_semantic_links_batch(
         # Fetch ALL existing units with embeddings in ONE query
         fetch_start = time_mod.time()
         all_existing = await conn.fetch(
-            f"""
+            """
             SELECT id, embedding
-            FROM {fq_table("memory_units")}
+            FROM memory_units
             WHERE bank_id = $1
               AND embedding IS NOT NULL
               AND id::text != ALL($2)
@@ -645,8 +644,8 @@ async def create_semantic_links_batch(
         if all_links:
             insert_start = time_mod.time()
             await conn.executemany(
-                f"""
-                INSERT INTO {fq_table("memory_links")} (from_unit_id, to_unit_id, link_type, weight, entity_id)
+                """
+                INSERT INTO memory_links (from_unit_id, to_unit_id, link_type, weight, entity_id)
                 VALUES ($1, $2, $3, $4, $5)
                 ON CONFLICT (from_unit_id, to_unit_id, link_type, COALESCE(entity_id, '00000000-0000-0000-0000-000000000000'::uuid)) DO NOTHING
                 """,
@@ -722,8 +721,8 @@ async def insert_entity_links_batch(conn, links: list[EntityLink], chunk_size: i
 
     # Insert from temp table with ON CONFLICT (single query for all rows)
     insert_start = time_mod.time()
-    await conn.execute(f"""
-        INSERT INTO {fq_table("memory_links")} (from_unit_id, to_unit_id, link_type, weight, entity_id)
+    await conn.execute("""
+        INSERT INTO memory_links (from_unit_id, to_unit_id, link_type, weight, entity_id)
         SELECT from_unit_id, to_unit_id, link_type, weight, entity_id
         FROM _temp_entity_links
         ON CONFLICT (from_unit_id, to_unit_id, link_type, COALESCE(entity_id, '00000000-0000-0000-0000-000000000000'::uuid)) DO NOTHING
@@ -809,8 +808,8 @@ async def create_causal_links_batch(
             insert_start = time_mod.time()
             try:
                 await conn.executemany(
-                    f"""
-                    INSERT INTO {fq_table("memory_links")} (from_unit_id, to_unit_id, link_type, weight, entity_id)
+                    """
+                    INSERT INTO memory_links (from_unit_id, to_unit_id, link_type, weight, entity_id)
                     VALUES ($1, $2, $3, $4, $5)
                     ON CONFLICT (from_unit_id, to_unit_id, link_type, COALESCE(entity_id, '00000000-0000-0000-0000-000000000000'::uuid)) DO NOTHING
                     """,

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

@@ -9,7 +9,6 @@ import time
 import uuid
 from datetime import UTC, datetime
 
-from ..memory_engine import fq_table
 from ..search import observation_utils
 from . import embedding_utils
 from .types import EntityLink
@@ -76,8 +75,8 @@ async def regenerate_observations_batch(
 
     # Batch query for entity names
     entity_rows = await conn.fetch(
-        f"""
-        SELECT id, canonical_name FROM {fq_table("entities")}
+        """
+        SELECT id, canonical_name FROM entities
         WHERE id = ANY($1) AND bank_id = $2
         """,
         entity_uuids,
@@ -87,10 +86,10 @@ async def regenerate_observations_batch(
 
     # Batch query for fact counts
     fact_counts = await conn.fetch(
-        f"""
+        """
         SELECT ue.entity_id, COUNT(*) as cnt
-        FROM {fq_table("unit_entities")} ue
-        JOIN {fq_table("memory_units")} mu ON ue.unit_id = mu.id
+        FROM unit_entities ue
+        JOIN memory_units mu ON ue.unit_id = mu.id
         WHERE ue.entity_id = ANY($1) AND mu.bank_id = $2
         GROUP BY ue.entity_id
         """,
@@ -155,10 +154,10 @@ async def _regenerate_entity_observations(
 
     # Get all facts mentioning this entity (exclude observations themselves)
     rows = await conn.fetch(
-        f"""
+        """
         SELECT mu.id, mu.text, mu.context, mu.occurred_start, mu.fact_type
-        FROM {fq_table("memory_units")} mu
-        JOIN {fq_table("unit_entities")} ue ON mu.id = ue.unit_id
+        FROM memory_units mu
+        JOIN unit_entities ue ON mu.id = ue.unit_id
         WHERE mu.bank_id = $1
           AND ue.entity_id = $2
           AND mu.fact_type IN ('world', 'experience')
@@ -194,12 +193,12 @@ async def _regenerate_entity_observations(
 
     # Delete old observations for this entity
     await conn.execute(
-        f"""
-        DELETE FROM {fq_table("memory_units")}
+        """
+        DELETE FROM memory_units
         WHERE id IN (
             SELECT mu.id
-            FROM {fq_table("memory_units")} mu
-            JOIN {fq_table("unit_entities")} ue ON mu.id = ue.unit_id
+            FROM memory_units mu
+            JOIN unit_entities ue ON mu.id = ue.unit_id
             WHERE mu.bank_id = $1
               AND mu.fact_type = 'observation'
               AND ue.entity_id = $2
@@ -218,8 +217,8 @@ async def _regenerate_entity_observations(
 
     for obs_text, embedding in zip(observations, embeddings):
         result = await conn.fetchrow(
-            f"""
-            INSERT INTO {fq_table("memory_units")} (
+            """
+            INSERT INTO memory_units (
                 bank_id, text, embedding, context, event_date,
                 occurred_start, occurred_end, mentioned_at,
                 fact_type, access_count
@@ -241,8 +240,8 @@ async def _regenerate_entity_observations(
 
         # Link observation to entity
         await conn.execute(
-            f"""
-            INSERT INTO {fq_table("unit_entities")} (unit_id, entity_id)
+            """
+            INSERT INTO unit_entities (unit_id, entity_id)
             VALUES ($1, $2)
             """,
             uuid.UUID(obs_id),

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

@@ -8,6 +8,7 @@ import logging
 import time
 import uuid
 from datetime import UTC, datetime
+from typing import Any
 
 from ..db_utils import acquire_with_retry
 from . import bank_utils
@@ -28,7 +29,7 @@ from . import (
     link_creation,
     observation_regeneration,
 )
-from .types import ExtractedFact, ProcessedFact, RetainContent, RetainContentDict
+from .types import ExtractedFact, ProcessedFact, RetainContent
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +43,7 @@ async def retain_batch(
     format_date_fn,
     duplicate_checker_fn,
     bank_id: str,
-    contents_dicts: list[RetainContentDict],
+    contents_dicts: list[dict[str, Any]],
     document_id: str | None = None,
     is_first_batch: bool = True,
     fact_type_override: str | None = None,
@@ -106,62 +107,9 @@ async def retain_batch(
     )
 
     if not extracted_facts:
-        # Still need to create document if document_id was provided
-        async with acquire_with_retry(pool) as conn:
-            async with conn.transaction():
-                await fact_storage.ensure_bank_exists(conn, bank_id)
-
-                # Handle document tracking even with no facts
-                if document_id:
-                    combined_content = "\n".join([c.get("content", "") for c in contents_dicts])
-                    retain_params = {}
-                    if contents_dicts:
-                        first_item = contents_dicts[0]
-                        if first_item.get("context"):
-                            retain_params["context"] = first_item["context"]
-                        if first_item.get("event_date"):
-                            retain_params["event_date"] = (
-                                first_item["event_date"].isoformat()
-                                if hasattr(first_item["event_date"], "isoformat")
-                                else str(first_item["event_date"])
-                            )
-                        if first_item.get("metadata"):
-                            retain_params["metadata"] = first_item["metadata"]
-                    await fact_storage.handle_document_tracking(
-                        conn, bank_id, document_id, combined_content, is_first_batch, retain_params
-                    )
-                else:
-                    # Check for per-item document_ids
-                    from collections import defaultdict
-
-                    contents_by_doc = defaultdict(list)
-                    for idx, content_dict in enumerate(contents_dicts):
-                        doc_id = content_dict.get("document_id")
-                        if doc_id:
-                            contents_by_doc[doc_id].append((idx, content_dict))
-
-                    for doc_id, doc_contents in contents_by_doc.items():
-                        combined_content = "\n".join([c.get("content", "") for _, c in doc_contents])
-                        retain_params = {}
-                        if doc_contents:
-                            first_item = doc_contents[0][1]
-                            if first_item.get("context"):
-                                retain_params["context"] = first_item["context"]
-                            if first_item.get("event_date"):
-                                retain_params["event_date"] = (
-                                    first_item["event_date"].isoformat()
-                                    if hasattr(first_item["event_date"], "isoformat")
-                                    else str(first_item["event_date"])
-                                )
-                            if first_item.get("metadata"):
-                                retain_params["metadata"] = first_item["metadata"]
-                        await fact_storage.handle_document_tracking(
-                            conn, bank_id, doc_id, combined_content, is_first_batch, retain_params
-                        )
-
         total_time = time.time() - start_time
         logger.info(
-            f"RETAIN_BATCH COMPLETE: 0 facts extracted from {len(contents)} contents in {total_time:.3f}s (document tracked, no facts)"
+            f"RETAIN_BATCH COMPLETE: 0 facts extracted from {len(contents)} contents in {total_time:.3f}s (nothing to store)"
         )
         return [[] for _ in contents]
 

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

@@ -7,33 +7,9 @@ from content input to fact storage.
 
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
-from typing import TypedDict
 from uuid import UUID
 
 
-class RetainContentDict(TypedDict, total=False):
-    """Type definition for content items in retain_batch_async.
-
-    Fields:
-        content: Text content to store (required)
-        context: Context about the content (optional)
-        event_date: When the content occurred (optional, defaults to now)
-        metadata: Custom key-value metadata (optional)
-        document_id: Document ID for this content item (optional)
-    """
-
-    content: str  # Required
-    context: str
-    event_date: datetime
-    metadata: dict[str, str]
-    document_id: str
-
-
-def _now_utc() -> datetime:
-    """Factory function for default event_date."""
-    return datetime.now(UTC)
-
-
 @dataclass
 class RetainContent:
     """
@@ -44,9 +20,16 @@ class RetainContent:
 
     content: str
     context: str = ""
-    event_date: datetime = field(default_factory=_now_utc)
+    event_date: datetime | None = None
     metadata: dict[str, str] = field(default_factory=dict)
 
+    def __post_init__(self):
+        """Ensure event_date is set."""
+        if self.event_date is None:
+            from datetime import datetime
+
+            self.event_date = datetime.now(UTC)
+
 
 @dataclass
 class ChunkMetadata:

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

@@ -10,7 +10,6 @@ import logging
 from abc import ABC, abstractmethod
 
 from ..db_utils import acquire_with_retry
-from ..memory_engine import fq_table
 from .types import RetrievalResult
 
 logger = logging.getLogger(__name__)
@@ -140,11 +139,11 @@ class BFSGraphRetriever(GraphRetriever):
 
         # Step 1: Find entry points
         entry_points = await conn.fetch(
-            f"""
+            """
             SELECT id, text, context, event_date, occurred_start, occurred_end,
                    mentioned_at, access_count, embedding, fact_type, document_id, chunk_id,
                    1 - (embedding <=> $1::vector) AS similarity
-            FROM {fq_table("memory_units")}
+            FROM memory_units
             WHERE bank_id = $2
               AND embedding IS NOT NULL
               AND fact_type = $3
@@ -189,13 +188,13 @@ class BFSGraphRetriever(GraphRetriever):
             if batch_nodes and budget_remaining > 0:
                 max_neighbors = len(batch_nodes) * 20
                 neighbors = await conn.fetch(
-                    f"""
+                    """
                     SELECT mu.id, mu.text, mu.context, mu.occurred_start, mu.occurred_end,
                            mu.mentioned_at, mu.access_count, mu.embedding, mu.fact_type,
                            mu.document_id, mu.chunk_id,
                            ml.weight, ml.link_type, ml.from_unit_id
-                    FROM {fq_table("memory_links")} ml
-                    JOIN {fq_table("memory_units")} mu ON ml.to_unit_id = mu.id
+                    FROM memory_links ml
+                    JOIN memory_units mu ON ml.to_unit_id = mu.id
                     WHERE ml.from_unit_id = ANY($1::uuid[])
                       AND ml.weight >= $2
                       AND mu.fact_type = $3

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

@@ -20,7 +20,6 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 
 from ..db_utils import acquire_with_retry
-from ..memory_engine import fq_table
 from .graph_retrieval import GraphRetriever
 from .types import RetrievalResult
 
@@ -218,10 +217,10 @@ async def load_typed_adjacency(pool, bank_id: str) -> TypedAdjacency:
     """
     async with acquire_with_retry(pool) as conn:
         rows = await conn.fetch(
-            f"""
+            """
             SELECT ml.from_unit_id, ml.to_unit_id, ml.link_type, ml.weight
-            FROM {fq_table("memory_links")} ml
-            JOIN {fq_table("memory_units")} mu ON ml.from_unit_id = mu.id
+            FROM memory_links ml
+            JOIN memory_units mu ON ml.from_unit_id = mu.id
             WHERE mu.bank_id = $1
               AND ml.weight >= 0.1
             ORDER BY ml.from_unit_id, ml.weight DESC
@@ -253,10 +252,10 @@ async def fetch_memory_units_by_ids(
 
     async with acquire_with_retry(pool) as conn:
         rows = await conn.fetch(
-            f"""
+            """
             SELECT id, text, context, event_date, occurred_start, occurred_end,
                    mentioned_at, access_count, embedding, fact_type, document_id, chunk_id
-            FROM {fq_table("memory_units")}
+            FROM memory_units
             WHERE id = ANY($1::uuid[])
               AND fact_type = $2
             """,
@@ -419,9 +418,9 @@ class MPFPGraphRetriever(GraphRetriever):
         """Fallback: find semantic seeds via embedding search."""
         async with acquire_with_retry(pool) as conn:
             rows = await conn.fetch(
-                f"""
+                """
                 SELECT id, 1 - (embedding <=> $1::vector) AS similarity
-                FROM {fq_table("memory_units")}
+                FROM memory_units
                 WHERE bank_id = $2
                   AND embedding IS NOT NULL
                   AND fact_type = $3

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

@@ -26,23 +26,6 @@ class CrossEncoderReranker:
 
             cross_encoder = create_cross_encoder_from_env()
         self.cross_encoder = cross_encoder
-        self._initialized = False
-
-    async def ensure_initialized(self):
-        """Ensure the cross-encoder model is initialized (for lazy initialization)."""
-        if self._initialized:
-            return
-
-        import asyncio
-
-        cross_encoder = self.cross_encoder
-        # For local providers, run in thread pool to avoid blocking event loop
-        if cross_encoder.provider_name == "local":
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, lambda: asyncio.run(cross_encoder.initialize()))
-        else:
-            await cross_encoder.initialize()
-        self._initialized = True
 
     def rerank(self, query: str, candidates: list[MergedCandidate]) -> list[ScoredResult]:
         """

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

@@ -16,7 +16,6 @@ from typing import Optional
 
 from ...config import get_config
 from ..db_utils import acquire_with_retry
-from ..memory_engine import fq_table
 from .graph_retrieval import BFSGraphRetriever, GraphRetriever
 from .mpfp_retrieval import MPFPGraphRetriever
 from .types import RetrievalResult
@@ -81,10 +80,10 @@ async def retrieve_semantic(
         List of RetrievalResult objects
     """
     results = await conn.fetch(
-        f"""
+        """
         SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, access_count, embedding, fact_type, document_id, chunk_id,
                1 - (embedding <=> $1::vector) AS similarity
-        FROM {fq_table("memory_units")}
+        FROM memory_units
         WHERE bank_id = $2
           AND embedding IS NOT NULL
           AND fact_type = $3
@@ -132,10 +131,10 @@ async def retrieve_bm25(conn, query_text: str, bank_id: str, fact_type: str, lim
     query_tsquery = " | ".join(tokens)
 
     results = await conn.fetch(
-        f"""
+        """
         SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, access_count, embedding, fact_type, document_id, chunk_id,
                ts_rank_cd(search_vector, to_tsquery('english', $1)) AS bm25_score
-        FROM {fq_table("memory_units")}
+        FROM memory_units
         WHERE bank_id = $2
           AND fact_type = $3
           AND search_vector @@ to_tsquery('english', $1)
@@ -189,10 +188,10 @@ async def retrieve_temporal(
         end_date = end_date.replace(tzinfo=UTC)
 
     entry_points = await conn.fetch(
-        f"""
+        """
         SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at, access_count, embedding, fact_type, document_id, chunk_id,
                1 - (embedding <=> $1::vector) AS similarity
-        FROM {fq_table("memory_units")}
+        FROM memory_units
         WHERE bank_id = $2
           AND fact_type = $3
           AND embedding IS NOT NULL
@@ -273,12 +272,12 @@ async def retrieve_temporal(
         # Get neighbors via temporal and causal links
         if budget_remaining > 0:
             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.access_count, mu.embedding, mu.fact_type, mu.document_id, mu.chunk_id,
                        ml.weight, ml.link_type,
                        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
+                FROM memory_links ml
+                JOIN memory_units mu ON ml.to_unit_id = mu.id
                 WHERE ml.from_unit_id = $2
                   AND ml.link_type IN ('temporal', 'causes', 'caused_by', 'enables', 'prevents')
                   AND ml.weight >= 0.1
@@ -547,11 +546,11 @@ async def _get_temporal_entry_points(
         end_date = end_date.replace(tzinfo=UTC)
 
     rows = await conn.fetch(
-        f"""
+        """
         SELECT id, text, context, event_date, occurred_start, occurred_end, mentioned_at,
                access_count, embedding, fact_type, document_id, chunk_id,
                1 - (embedding <=> $1::vector) AS similarity
-        FROM {fq_table("memory_units")}
+        FROM memory_units
         WHERE bank_id = $2
           AND fact_type = $3
           AND embedding IS NOT NULL

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

@@ -101,7 +101,7 @@ def build_think_prompt(
     name: str,
     disposition: DispositionTraits,
     background: str,
-    context: str | None = None,
+    context: str = None,
 ) -> str:
     """Build the think prompt for the LLM."""
     disposition_desc = build_disposition_description(disposition)

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

@@ -115,7 +115,7 @@ class SearchTracer:
         node_id: str,
         text: str,
         context: str,
-        event_date: datetime | None,
+        event_date: datetime,
         access_count: int,
         is_entry_point: bool,
         parent_node_id: str | None,

hindsight-api/hindsight_api/engine/task_backend.py

@@ -89,38 +89,6 @@ class TaskBackend(ABC):
             traceback.print_exc()
 
 
-class SyncTaskBackend(TaskBackend):
-    """
-    Synchronous task backend that executes tasks immediately.
-
-    This is useful for embedded/CLI usage where we don't want background
-    workers that prevent clean exit. Tasks are executed inline rather than
-    being queued.
-    """
-
-    async def initialize(self):
-        """No-op for sync backend."""
-        self._initialized = True
-        logger.debug("SyncTaskBackend initialized")
-
-    async def submit_task(self, task_dict: dict[str, Any]):
-        """
-        Execute the task immediately (synchronously).
-
-        Args:
-            task_dict: Task dictionary to execute
-        """
-        if not self._initialized:
-            await self.initialize()
-
-        await self._execute_task(task_dict)
-
-    async def shutdown(self):
-        """No-op for sync backend."""
-        self._initialized = False
-        logger.debug("SyncTaskBackend shutdown")
-
-
 class AsyncIOQueueBackend(TaskBackend):
     """
     Task backend implementation using asyncio queues.

hindsight-api/hindsight_api/extensions/__init__.py

@@ -1,66 +0,0 @@
-"""
-Hindsight Extensions System.
-
-Extensions allow customizing and extending Hindsight behavior without modifying core code.
-Extensions are loaded via environment variables pointing to implementation classes.
-
-Example:
-    HINDSIGHT_API_OPERATION_VALIDATOR_EXTENSION=mypackage.validators:MyValidator
-    HINDSIGHT_API_OPERATION_VALIDATOR_MAX_RETRIES=3
-
-    HINDSIGHT_API_HTTP_EXTENSION=mypackage.http:MyHttpExtension
-    HINDSIGHT_API_HTTP_SOME_CONFIG=value
-
-Extensions receive an ExtensionContext that provides a controlled API for interacting
-with the system (e.g., running migrations for tenant schemas).
-"""
-
-from hindsight_api.extensions.base import Extension
-from hindsight_api.extensions.builtin import ApiKeyTenantExtension
-from hindsight_api.extensions.context import DefaultExtensionContext, ExtensionContext
-from hindsight_api.extensions.http import HttpExtension
-from hindsight_api.extensions.loader import load_extension
-from hindsight_api.extensions.operation_validator import (
-    OperationValidationError,
-    OperationValidatorExtension,
-    RecallContext,
-    RecallResult,
-    ReflectContext,
-    ReflectResultContext,
-    RetainContext,
-    RetainResult,
-    ValidationResult,
-)
-from hindsight_api.extensions.tenant import (
-    AuthenticationError,
-    TenantContext,
-    TenantExtension,
-)
-from hindsight_api.models import RequestContext
-
-__all__ = [
-    # Base
-    "Extension",
-    "load_extension",
-    # Context
-    "ExtensionContext",
-    "DefaultExtensionContext",
-    # HTTP Extension
-    "HttpExtension",
-    # Operation Validator
-    "OperationValidationError",
-    "OperationValidatorExtension",
-    "RecallContext",
-    "RecallResult",
-    "ReflectContext",
-    "ReflectResultContext",
-    "RetainContext",
-    "RetainResult",
-    "ValidationResult",
-    # Tenant/Auth
-    "ApiKeyTenantExtension",
-    "AuthenticationError",
-    "RequestContext",
-    "TenantContext",
-    "TenantExtension",
-]

hindsight-api/hindsight_api/extensions/base.py

@@ -1,81 +0,0 @@
-"""Base Extension class for all Hindsight extensions."""
-
-from abc import ABC
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from hindsight_api.extensions.context import ExtensionContext
-
-
-class Extension(ABC):
-    """
-    Base class for all Hindsight extensions.
-
-    Extensions are loaded via environment variables and receive configuration
-    from prefixed environment variables.
-
-    Example:
-        HINDSIGHT_API_MY_EXTENSION=mypackage.ext:MyExtension
-        HINDSIGHT_API_MY_SOME_CONFIG=value
-
-        The extension receives: {"some_config": "value"}
-
-    Extensions also receive an ExtensionContext that provides a controlled API
-    for interacting with the system (e.g., running migrations for tenant schemas).
-    """
-
-    def __init__(self, config: dict[str, str]):
-        """
-        Initialize the extension with configuration.
-
-        Args:
-            config: Dictionary of configuration values from environment variables.
-                    Keys are lowercased with the prefix stripped.
-        """
-        self.config = config
-        self._context: "ExtensionContext | None" = None
-
-    def set_context(self, context: "ExtensionContext") -> None:
-        """
-        Set the extension context.
-
-        Called by the extension loader after instantiation.
-        Extensions should not call this directly.
-
-        Args:
-            context: The ExtensionContext providing system APIs.
-        """
-        self._context = context
-
-    @property
-    def context(self) -> "ExtensionContext":
-        """
-        Get the extension context.
-
-        Returns:
-            The ExtensionContext providing system APIs.
-
-        Raises:
-            RuntimeError: If context has not been set yet.
-        """
-        if self._context is None:
-            raise RuntimeError(
-                "Extension context not set. Context is available after the extension is loaded by the system."
-            )
-        return self._context
-
-    async def on_startup(self) -> None:
-        """
-        Called when the application starts.
-
-        Override to perform initialization tasks like connecting to external services.
-        """
-        pass
-
-    async def on_shutdown(self) -> None:
-        """
-        Called when the application shuts down.
-
-        Override to perform cleanup tasks like closing connections.
-        """
-        pass

hindsight-api/hindsight_api/extensions/builtin/__init__.py

@@ -1,18 +0,0 @@
-"""
-Built-in extension implementations.
-
-These are ready-to-use implementations of the extension interfaces.
-They can be used directly or serve as examples for custom implementations.
-
-Available built-in extensions:
-    - ApiKeyTenantExtension: Simple API key validation with public schema
-
-Example usage:
-    HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.tenant:ApiKeyTenantExtension
-"""
-
-from hindsight_api.extensions.builtin.tenant import ApiKeyTenantExtension
-
-__all__ = [
-    "ApiKeyTenantExtension",
-]

hindsight-api/hindsight_api/extensions/builtin/tenant.py

@@ -1,33 +0,0 @@
-"""Built-in tenant extension implementations."""
-
-from hindsight_api.extensions.tenant import AuthenticationError, TenantContext, TenantExtension
-from hindsight_api.models import RequestContext
-
-
-class ApiKeyTenantExtension(TenantExtension):
-    """
-    Built-in tenant extension that validates API key against an environment variable.
-
-    This is a simple implementation that:
-    1. Validates the API key matches HINDSIGHT_API_TENANT_API_KEY
-    2. Returns 'public' as the schema for all authenticated requests
-
-    Configuration:
-        HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.tenant:ApiKeyTenantExtension
-        HINDSIGHT_API_TENANT_API_KEY=your-secret-key
-
-    For multi-tenant setups with separate schemas per tenant, implement a custom
-    TenantExtension that looks up the schema based on the API key or token claims.
-    """
-
-    def __init__(self, config: dict[str, str]):
-        super().__init__(config)
-        self.expected_api_key = config.get("api_key")
-        if not self.expected_api_key:
-            raise ValueError("HINDSIGHT_API_TENANT_API_KEY is required when using ApiKeyTenantExtension")
-
-    async def authenticate(self, context: RequestContext) -> TenantContext:
-        """Validate API key and return public schema context."""
-        if context.api_key != self.expected_api_key:
-            raise AuthenticationError("Invalid API key")
-        return TenantContext(schema_name="public")

hindsight-api/hindsight_api/extensions/context.py

@@ -1,110 +0,0 @@
-"""Extension context providing a controlled API for extensions to interact with the system."""
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from hindsight_api.engine.interface import MemoryEngineInterface
-
-
-class ExtensionContext(ABC):
-    """
-    Abstract context providing a controlled API for extensions.
-
-    Extensions receive this context instead of direct access to internal
-    components like MemoryEngine or database connections. This provides:
-    - A stable API that won't break when internals change
-    - Security by limiting what extensions can access
-    - Clear documentation of what extensions can do
-
-    Built-in implementation:
-        hindsight_api.extensions.builtin.context.DefaultExtensionContext
-
-    Example usage in an extension:
-        class MyTenantExtension(TenantExtension):
-            async def on_startup(self) -> None:
-                # Run migrations for a new tenant schema
-                await self.context.run_migration("tenant_acme")
-
-        class MyHttpExtension(HttpExtension):
-            def get_router(self, memory):
-                # Use memory engine for custom endpoints
-                engine = self.context.get_memory_engine()
-                ...
-    """
-
-    @abstractmethod
-    async def run_migration(self, schema: str) -> None:
-        """
-        Run database migrations for a specific schema.
-
-        This creates the schema if it doesn't exist and runs all pending
-        migrations. Uses advisory locks to coordinate between distributed workers.
-
-        Args:
-            schema: PostgreSQL schema name (e.g., "tenant_acme").
-                    The schema will be created if it doesn't exist.
-
-        Raises:
-            RuntimeError: If migrations fail to complete.
-
-        Example:
-            # Provision a new tenant schema
-            await context.run_migration("tenant_acme")
-        """
-        ...
-
-    @abstractmethod
-    def get_memory_engine(self) -> "MemoryEngineInterface":
-        """
-        Get the memory engine interface.
-
-        Returns the MemoryEngineInterface for performing memory operations
-        like retain, recall, reflect, and entity/document management.
-
-        Returns:
-            MemoryEngineInterface instance.
-
-        Example:
-            engine = context.get_memory_engine()
-            result = await engine.recall_async(bank_id, query)
-        """
-        ...
-
-
-class DefaultExtensionContext(ExtensionContext):
-    """
-    Default implementation of ExtensionContext.
-
-    Uses the system's database URL and migration infrastructure.
-    """
-
-    def __init__(
-        self,
-        database_url: str,
-        memory_engine: "MemoryEngineInterface | None" = None,
-    ):
-        """
-        Initialize the context.
-
-        Args:
-            database_url: SQLAlchemy database URL for migrations.
-            memory_engine: Optional MemoryEngine instance for memory operations.
-        """
-        self._database_url = database_url
-        self._memory_engine = memory_engine
-
-    async def run_migration(self, schema: str) -> None:
-        """Run migrations for a specific schema."""
-        from hindsight_api.migrations import run_migrations
-
-        run_migrations(self._database_url, schema=schema)
-
-    def get_memory_engine(self) -> "MemoryEngineInterface":
-        """Get the memory engine interface."""
-        if self._memory_engine is None:
-            raise RuntimeError(
-                "Memory engine not configured in ExtensionContext. "
-                "Ensure the context was created with a memory_engine parameter."
-            )
-        return self._memory_engine

hindsight-api/hindsight_api/extensions/http.py

@@ -1,89 +0,0 @@
-"""
-HTTP Extension for adding custom endpoints to the Hindsight API.
-
-This extension allows adding custom HTTP endpoints under the /ext/ path prefix.
-The extension provides a FastAPI router that is mounted on the main application.
-"""
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
-
-from fastapi import APIRouter
-
-from hindsight_api.extensions.base import Extension
-
-if TYPE_CHECKING:
-    from hindsight_api import MemoryEngine
-
-
-class HttpExtension(Extension, ABC):
-    """
-    Base class for HTTP extensions that add custom API endpoints.
-
-    HTTP extensions provide a FastAPI router that gets mounted under /ext/.
-    The extension has full control over the routes, request/response models, and handlers.
-
-    Example:
-        ```python
-        from fastapi import APIRouter
-        from hindsight_api.extensions import HttpExtension
-
-        class MyHttpExtension(HttpExtension):
-            def get_router(self, memory: MemoryEngine) -> APIRouter:
-                router = APIRouter()
-
-                @router.get("/hello")
-                async def hello():
-                    return {"message": "Hello from extension!"}
-
-                @router.post("/custom/{bank_id}/action")
-                async def custom_action(bank_id: str):
-                    # Access memory engine for database operations
-                    pool = await memory._get_pool()
-                    # ... custom logic
-                    return {"status": "ok"}
-
-                return router
-        ```
-
-    The routes will be available at:
-        - GET /ext/hello
-        - POST /ext/custom/{bank_id}/action
-
-    Configuration via environment variables:
-        HINDSIGHT_API_HTTP_EXTENSION=mypackage.ext:MyHttpExtension
-        HINDSIGHT_API_HTTP_SOME_CONFIG=value
-
-    The extension receives config: {"some_config": "value"}
-    """
-
-    @abstractmethod
-    def get_router(self, memory: "MemoryEngine") -> APIRouter:
-        """
-        Return a FastAPI router with custom endpoints.
-
-        The router will be mounted at /ext/ on the main application.
-        All routes defined in the router will be prefixed with /ext/.
-
-        Args:
-            memory: The MemoryEngine instance for database access and core operations.
-                   Use this to access the connection pool, run queries, or call
-                   memory operations like retain, recall, etc.
-
-        Returns:
-            A FastAPI APIRouter with the custom endpoints defined.
-
-        Example:
-            ```python
-            def get_router(self, memory: MemoryEngine) -> APIRouter:
-                router = APIRouter(tags=["My Extension"])
-
-                @router.get("/status")
-                async def status():
-                    health = await memory.health_check()
-                    return {"extension": "healthy", "memory": health}
-
-                return router
-            ```
-        """
-        pass

hindsight-api/hindsight_api/extensions/loader.py

@@ -1,125 +0,0 @@
-"""Extension loader utilities."""
-
-import importlib
-import logging
-import os
-from typing import TYPE_CHECKING, TypeVar
-
-from hindsight_api.extensions.base import Extension
-
-if TYPE_CHECKING:
-    from hindsight_api.extensions.context import ExtensionContext
-
-logger = logging.getLogger(__name__)
-
-T = TypeVar("T", bound=Extension)
-
-
-class ExtensionLoadError(Exception):
-    """Raised when an extension fails to load."""
-
-    pass
-
-
-def load_extension(
-    prefix: str,
-    base_class: type[T],
-    env_prefix: str = "HINDSIGHT_API",
-    context: "ExtensionContext | None" = None,
-) -> T | None:
-    """
-    Load an extension from environment variable configuration.
-
-    The extension class is specified via {env_prefix}_{prefix}_EXTENSION environment
-    variable in the format "module.path:ClassName".
-
-    Configuration for the extension is collected from all environment variables
-    matching {env_prefix}_{prefix}_* (excluding the EXTENSION variable itself).
-
-    Args:
-        prefix: The extension prefix (e.g., "OPERATION_VALIDATOR").
-        base_class: The base class that the extension must inherit from.
-        env_prefix: The environment variable prefix (default: "HINDSIGHT_API").
-        context: Optional ExtensionContext to provide system APIs to the extension.
-
-    Returns:
-        An instance of the extension, or None if not configured.
-
-    Raises:
-        ExtensionLoadError: If the extension fails to load or validate.
-
-    Example:
-        HINDSIGHT_API_OPERATION_VALIDATOR_EXTENSION=mypackage.validators:MyValidator
-        HINDSIGHT_API_OPERATION_VALIDATOR_MAX_REQUESTS=100
-
-        ext = load_extension("OPERATION_VALIDATOR", OperationValidatorExtension)
-        # ext.config == {"max_requests": "100"}
-    """
-    env_var = f"{env_prefix}_{prefix}_EXTENSION"
-    ext_path = os.getenv(env_var)
-
-    if not ext_path:
-        logger.debug(f"No extension configured for {env_var}")
-        return None
-
-    logger.info(f"Loading extension from {env_var}={ext_path}")
-
-    # Parse "module.path:ClassName"
-    if ":" not in ext_path:
-        raise ExtensionLoadError(f"Invalid extension path '{ext_path}'. Expected format: 'module.path:ClassName'")
-
-    module_path, class_name = ext_path.rsplit(":", 1)
-
-    # Import the module
-    try:
-        module = importlib.import_module(module_path)
-    except ImportError as e:
-        raise ExtensionLoadError(f"Failed to import extension module '{module_path}': {e}") from e
-
-    # Get the class
-    try:
-        ext_class = getattr(module, class_name)
-    except AttributeError as e:
-        raise ExtensionLoadError(f"Extension class '{class_name}' not found in module '{module_path}'") from e
-
-    # Validate inheritance
-    if not isinstance(ext_class, type) or not issubclass(ext_class, base_class):
-        raise ExtensionLoadError(f"Extension class '{ext_class.__name__}' must inherit from '{base_class.__name__}'")
-
-    # Collect configuration from environment variables
-    config = _collect_config(env_prefix, prefix)
-
-    logger.info(f"Loaded extension {ext_class.__name__} with config keys: {list(config.keys())}")
-
-    # Instantiate the extension
-    try:
-        extension = ext_class(config)
-    except Exception as e:
-        raise ExtensionLoadError(f"Failed to instantiate extension '{ext_class.__name__}': {e}") from e
-
-    # Set the context if provided
-    if context is not None:
-        extension.set_context(context)
-        logger.debug(f"Set context on extension {ext_class.__name__}")
-
-    return extension
-
-
-def _collect_config(env_prefix: str, prefix: str) -> dict[str, str]:
-    """
-    Collect configuration from environment variables.
-
-    Collects all variables matching {env_prefix}_{prefix}_* except for
-    {env_prefix}_{prefix}_EXTENSION, strips the prefix, and lowercases keys.
-    """
-    config = {}
-    full_prefix = f"{env_prefix}_{prefix}_"
-    extension_var = f"{full_prefix}EXTENSION"
-
-    for key, value in os.environ.items():
-        if key.startswith(full_prefix) and key != extension_var:
-            # Strip prefix and lowercase the key
-            config_key = key[len(full_prefix) :].lower()
-            config[config_key] = value
-
-    return config

hindsight-api/hindsight_api/extensions/operation_validator.py

@@ -1,325 +0,0 @@
-"""Operation Validator Extension for validating retain/recall/reflect operations."""
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import TYPE_CHECKING, Any
-
-from hindsight_api.extensions.base import Extension
-
-if TYPE_CHECKING:
-    from hindsight_api.engine.memory_engine import Budget
-    from hindsight_api.engine.response_models import RecallResult as RecallResultModel
-    from hindsight_api.engine.response_models import ReflectResult
-    from hindsight_api.models import RequestContext
-
-
-class OperationValidationError(Exception):
-    """Raised when an operation fails validation."""
-
-    def __init__(self, reason: str):
-        self.reason = reason
-        super().__init__(f"Operation validation failed: {reason}")
-
-
-@dataclass
-class ValidationResult:
-    """Result of an operation validation."""
-
-    allowed: bool
-    reason: str | None = None
-
-    @classmethod
-    def accept(cls) -> "ValidationResult":
-        """Create an accepted validation result."""
-        return cls(allowed=True)
-
-    @classmethod
-    def reject(cls, reason: str) -> "ValidationResult":
-        """Create a rejected validation result with a reason."""
-        return cls(allowed=False, reason=reason)
-
-
-# =============================================================================
-# Pre-operation Contexts (all user-provided parameters)
-# =============================================================================
-
-
-@dataclass
-class RetainContext:
-    """Context for a retain operation validation (pre-operation).
-
-    Contains ALL user-provided parameters for the retain operation.
-    """
-
-    bank_id: str
-    contents: list[dict]  # List of {content, context, event_date, document_id}
-    request_context: "RequestContext"
-    document_id: str | None = None
-    fact_type_override: str | None = None
-    confidence_score: float | None = None
-
-
-@dataclass
-class RecallContext:
-    """Context for a recall operation validation (pre-operation).
-
-    Contains ALL user-provided parameters for the recall operation.
-    """
-
-    bank_id: str
-    query: str
-    request_context: "RequestContext"
-    budget: "Budget | None" = None
-    max_tokens: int = 4096
-    enable_trace: bool = False
-    fact_types: list[str] = field(default_factory=list)
-    question_date: datetime | None = None
-    include_entities: bool = False
-    max_entity_tokens: int = 500
-    include_chunks: bool = False
-    max_chunk_tokens: int = 8192
-
-
-@dataclass
-class ReflectContext:
-    """Context for a reflect operation validation (pre-operation).
-
-    Contains ALL user-provided parameters for the reflect operation.
-    """
-
-    bank_id: str
-    query: str
-    request_context: "RequestContext"
-    budget: "Budget | None" = None
-    context: str | None = None
-
-
-# =============================================================================
-# Post-operation Contexts (includes results)
-# =============================================================================
-
-
-@dataclass
-class RetainResult:
-    """Result context for post-retain hook.
-
-    Contains the operation parameters and the result.
-    """
-
-    bank_id: str
-    contents: list[dict]
-    request_context: "RequestContext"
-    document_id: str | None
-    fact_type_override: str | None
-    confidence_score: float | None
-    # Result
-    unit_ids: list[list[str]]  # List of unit IDs per content item
-    success: bool = True
-    error: str | None = None
-
-
-@dataclass
-class RecallResult:
-    """Result context for post-recall hook.
-
-    Contains the operation parameters and the result.
-    """
-
-    bank_id: str
-    query: str
-    request_context: "RequestContext"
-    budget: "Budget | None"
-    max_tokens: int
-    enable_trace: bool
-    fact_types: list[str]
-    question_date: datetime | None
-    include_entities: bool
-    max_entity_tokens: int
-    include_chunks: bool
-    max_chunk_tokens: int
-    # Result
-    result: "RecallResultModel | None" = None
-    success: bool = True
-    error: str | None = None
-
-
-@dataclass
-class ReflectResultContext:
-    """Result context for post-reflect hook.
-
-    Contains the operation parameters and the result.
-    """
-
-    bank_id: str
-    query: str
-    request_context: "RequestContext"
-    budget: "Budget | None"
-    context: str | None
-    # Result
-    result: "ReflectResult | None" = None
-    success: bool = True
-    error: str | None = None
-
-
-class OperationValidatorExtension(Extension, ABC):
-    """
-    Validates and hooks into retain/recall/reflect operations.
-
-    This extension allows implementing custom logic such as:
-    - Rate limiting (pre-operation)
-    - Quota enforcement (pre-operation)
-    - Permission checks (pre-operation)
-    - Content filtering (pre-operation)
-    - Usage tracking (post-operation)
-    - Audit logging (post-operation)
-    - Metrics collection (post-operation)
-
-    Enable via environment variable:
-        HINDSIGHT_API_OPERATION_VALIDATOR_EXTENSION=mypackage.validators:MyValidator
-
-    Configuration is passed from prefixed environment variables:
-        HINDSIGHT_API_OPERATION_VALIDATOR_MAX_REQUESTS=100
-        -> config = {"max_requests": "100"}
-
-    Hook execution order:
-        1. validate_retain/validate_recall/validate_reflect (pre-operation)
-        2. [operation executes]
-        3. on_retain_complete/on_recall_complete/on_reflect_complete (post-operation)
-    """
-
-    # =========================================================================
-    # Pre-operation validation hooks (abstract - must be implemented)
-    # =========================================================================
-
-    @abstractmethod
-    async def validate_retain(self, ctx: RetainContext) -> ValidationResult:
-        """
-        Validate a retain operation before execution.
-
-        Called before the retain operation is processed. Return ValidationResult.reject()
-        to prevent the operation from executing.
-
-        Args:
-            ctx: Context containing all user-provided parameters:
-                - bank_id: Bank identifier
-                - contents: List of content dicts
-                - request_context: Request context with auth info
-                - document_id: Optional document ID
-                - fact_type_override: Optional fact type override
-                - confidence_score: Optional confidence score
-
-        Returns:
-            ValidationResult indicating whether the operation is allowed.
-        """
-        ...
-
-    @abstractmethod
-    async def validate_recall(self, ctx: RecallContext) -> ValidationResult:
-        """
-        Validate a recall operation before execution.
-
-        Called before the recall operation is processed. Return ValidationResult.reject()
-        to prevent the operation from executing.
-
-        Args:
-            ctx: Context containing all user-provided parameters:
-                - bank_id: Bank identifier
-                - query: Search query
-                - request_context: Request context with auth info
-                - budget: Budget level
-                - max_tokens: Maximum tokens to return
-                - enable_trace: Whether to include trace info
-                - fact_types: List of fact types to search
-                - question_date: Optional date context for query
-                - include_entities: Whether to include entity data
-                - max_entity_tokens: Max tokens for entities
-                - include_chunks: Whether to include chunks
-                - max_chunk_tokens: Max tokens for chunks
-
-        Returns:
-            ValidationResult indicating whether the operation is allowed.
-        """
-        ...
-
-    @abstractmethod
-    async def validate_reflect(self, ctx: ReflectContext) -> ValidationResult:
-        """
-        Validate a reflect operation before execution.
-
-        Called before the reflect operation is processed. Return ValidationResult.reject()
-        to prevent the operation from executing.
-
-        Args:
-            ctx: Context containing all user-provided parameters:
-                - bank_id: Bank identifier
-                - query: Question to answer
-                - request_context: Request context with auth info
-                - budget: Budget level
-                - context: Optional additional context
-
-        Returns:
-            ValidationResult indicating whether the operation is allowed.
-        """
-        ...
-
-    # =========================================================================
-    # Post-operation hooks (optional - override to implement)
-    # =========================================================================
-
-    async def on_retain_complete(self, result: RetainResult) -> None:
-        """
-        Called after a retain operation completes (success or failure).
-
-        Override this method to implement post-operation logic such as:
-        - Usage tracking
-        - Audit logging
-        - Metrics collection
-        - Notifications
-
-        Args:
-            result: Result context containing:
-                - All original operation parameters
-                - unit_ids: List of created unit IDs (if success)
-                - success: Whether the operation succeeded
-                - error: Error message (if failed)
-        """
-        pass
-
-    async def on_recall_complete(self, result: RecallResult) -> None:
-        """
-        Called after a recall operation completes (success or failure).
-
-        Override this method to implement post-operation logic such as:
-        - Usage tracking
-        - Audit logging
-        - Metrics collection
-        - Query analytics
-
-        Args:
-            result: Result context containing:
-                - All original operation parameters
-                - result: RecallResultModel (if success)
-                - success: Whether the operation succeeded
-                - error: Error message (if failed)
-        """
-        pass
-
-    async def on_reflect_complete(self, result: ReflectResultContext) -> None:
-        """
-        Called after a reflect operation completes (success or failure).
-
-        Override this method to implement post-operation logic such as:
-        - Usage tracking
-        - Audit logging
-        - Metrics collection
-        - Response analytics
-
-        Args:
-            result: Result context containing:
-                - All original operation parameters
-                - result: ReflectResult (if success)
-                - success: Whether the operation succeeded
-                - error: Error message (if failed)
-        """
-        pass

hindsight-api/hindsight_api/extensions/tenant.py

@@ -1,63 +0,0 @@
-"""Tenant Extension for multi-tenancy and API key authentication."""
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-
-from hindsight_api.extensions.base import Extension
-from hindsight_api.models import RequestContext
-
-
-class AuthenticationError(Exception):
-    """Raised when authentication fails."""
-
-    def __init__(self, reason: str):
-        self.reason = reason
-        super().__init__(f"Authentication failed: {reason}")
-
-
-@dataclass
-class TenantContext:
-    """
-    Tenant context returned by authentication.
-
-    Contains the PostgreSQL schema name for tenant isolation.
-    All database queries will use fully-qualified table names
-    with this schema (e.g., schema_name.memory_units).
-    """
-
-    schema_name: str
-
-
-class TenantExtension(Extension, ABC):
-    """
-    Extension for multi-tenancy and API key authentication.
-
-    This extension validates incoming requests and returns the tenant context
-    including the PostgreSQL schema to use for database operations.
-
-    Built-in implementation:
-        hindsight_api.extensions.builtin.tenant.ApiKeyTenantExtension
-
-    Enable via environment variable:
-        HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.tenant:ApiKeyTenantExtension
-        HINDSIGHT_API_TENANT_API_KEY=your-secret-key
-
-    The returned schema_name is used for fully-qualified table names in queries,
-    enabling tenant isolation at the database level.
-    """
-
-    @abstractmethod
-    async def authenticate(self, context: RequestContext) -> TenantContext:
-        """
-        Authenticate the action context and return tenant context.
-
-        Args:
-            context: The action context containing API key and other auth data.
-
-        Returns:
-            TenantContext with the schema_name for database operations.
-
-        Raises:
-            AuthenticationError: If authentication fails.
-        """
-        ...

hindsight-api/hindsight_api/main.py

@@ -4,9 +4,6 @@ Command-line interface for Hindsight API.
 Run the server with:
     hindsight-api
 
-Run as background daemon:
-    hindsight-api --daemon
-
 Stop with Ctrl+C.
 """
 
@@ -24,13 +21,9 @@ from . import MemoryEngine
 from .api import create_app
 from .banner import print_banner
 from .config import HindsightConfig, get_config
-from .daemon import (
-    DEFAULT_DAEMON_PORT,
-    DEFAULT_IDLE_TIMEOUT,
-    DaemonLock,
-    IdleTimeoutMiddleware,
-    daemonize,
-)
+
+print()
+print_banner()
 
 # Filter deprecation warnings from third-party libraries
 warnings.filterwarnings("ignore", message="websockets.legacy is deprecated")
@@ -113,52 +106,8 @@ def main():
     parser.add_argument("--ssl-keyfile", default=None, help="SSL key file")
     parser.add_argument("--ssl-certfile", default=None, help="SSL certificate file")
 
-    # Daemon mode options
-    parser.add_argument(
-        "--daemon",
-        action="store_true",
-        help=f"Run as background daemon (uses port {DEFAULT_DAEMON_PORT}, auto-exits after idle)",
-    )
-    parser.add_argument(
-        "--idle-timeout",
-        type=int,
-        default=DEFAULT_IDLE_TIMEOUT,
-        help=f"Idle timeout in seconds before auto-exit in daemon mode (default: {DEFAULT_IDLE_TIMEOUT})",
-    )
-
     args = parser.parse_args()
 
-    # Daemon mode handling
-    if args.daemon:
-        # Use fixed daemon port
-        args.port = DEFAULT_DAEMON_PORT
-        args.host = "127.0.0.1"  # Only bind to localhost for security
-
-        # Check if another daemon is already running
-        daemon_lock = DaemonLock()
-        if not daemon_lock.acquire():
-            print(f"Daemon already running (PID: {daemon_lock.get_pid()})", file=sys.stderr)
-            sys.exit(1)
-
-        # Fork into background
-        daemonize()
-
-        # Re-acquire lock in child process
-        daemon_lock = DaemonLock()
-        if not daemon_lock.acquire():
-            sys.exit(1)
-
-        # Register cleanup to release lock
-        def release_lock():
-            daemon_lock.release()
-
-        atexit.register(release_lock)
-
-    # Print banner (not in daemon mode)
-    if not args.daemon:
-        print()
-        print_banner()
-
     # Configure Python logging based on log level
     # Update config with CLI override if provided
     if args.log_level != config.log_level:
@@ -179,12 +128,9 @@ def main():
             log_level=args.log_level,
             mcp_enabled=config.mcp_enabled,
             graph_retriever=config.graph_retriever,
-            skip_llm_verification=config.skip_llm_verification,
-            lazy_reranker=config.lazy_reranker,
         )
     config.configure_logging()
-    if not args.daemon:
-        config.log_config()
+    config.log_config()
 
     # Register cleanup handlers
     atexit.register(_cleanup)
@@ -203,12 +149,6 @@ def main():
         initialize_memory=True,
     )
 
-    # Wrap with idle timeout middleware in daemon mode
-    idle_middleware = None
-    if args.daemon:
-        idle_middleware = IdleTimeoutMiddleware(app, idle_timeout=args.idle_timeout)
-        app = idle_middleware
-
     # Prepare uvicorn config
     uvicorn_config = {
         "app": app,
@@ -232,40 +172,20 @@ def main():
     if args.ssl_certfile:
         uvicorn_config["ssl_certfile"] = args.ssl_certfile
 
-    # Print startup info (not in daemon mode)
-    if not args.daemon:
-        from .banner import print_startup_info
+    from .banner import print_startup_info
 
-        print_startup_info(
-            host=args.host,
-            port=args.port,
-            database_url=config.database_url,
-            llm_provider=config.llm_provider,
-            llm_model=config.llm_model,
-            embeddings_provider=config.embeddings_provider,
-            reranker_provider=config.reranker_provider,
-            mcp_enabled=config.mcp_enabled,
-        )
+    print_startup_info(
+        host=args.host,
+        port=args.port,
+        database_url=config.database_url,
+        llm_provider=config.llm_provider,
+        llm_model=config.llm_model,
+        embeddings_provider=config.embeddings_provider,
+        reranker_provider=config.reranker_provider,
+        mcp_enabled=config.mcp_enabled,
+    )
 
-    # Start idle checker in daemon mode
-    if idle_middleware is not None:
-        # Start the idle checker in a background thread with its own event loop
-        import threading
-
-        def run_idle_checker():
-            import time
-
-            time.sleep(2)  # Wait for uvicorn to start
-            try:
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                loop.run_until_complete(idle_middleware._check_idle())
-            except Exception:
-                pass
-
-        threading.Thread(target=run_idle_checker, daemon=True).start()
-
-    uvicorn.run(**uvicorn_config)  # type: ignore[invalid-argument-type] - dict kwargs
+    uvicorn.run(**uvicorn_config)
 
 
 if __name__ == "__main__":

hindsight-api/hindsight_api/mcp_local.py

@@ -87,7 +87,6 @@ def create_local_mcp_server(bank_id: str, memory=None) -> FastMCP:
     from hindsight_api import MemoryEngine
     from hindsight_api.engine.memory_engine import Budget
     from hindsight_api.engine.response_models import VALID_RECALL_FACT_TYPES
-    from hindsight_api.models import RequestContext
 
     # Create memory engine with pg0 embedded database if not provided
     if memory is None:
@@ -116,11 +115,7 @@ def create_local_mcp_server(bank_id: str, memory=None) -> FastMCP:
 
         async def _retain():
             try:
-                await memory.retain_batch_async(
-                    bank_id=bank_id,
-                    contents=[{"content": content, "context": context}],
-                    request_context=RequestContext(),
-                )
+                await memory.retain_batch_async(bank_id=bank_id, contents=[{"content": content, "context": context}])
             except Exception as e:
                 logger.error(f"Error storing memory: {e}", exc_info=True)
 
@@ -147,7 +142,6 @@ def create_local_mcp_server(bank_id: str, memory=None) -> FastMCP:
                 fact_type=list(VALID_RECALL_FACT_TYPES),
                 budget=budget_enum,
                 max_tokens=max_tokens,
-                request_context=RequestContext(),
             )
 
             return search_result.model_dump()

hindsight-api/hindsight_api/migrations.py

@@ -6,16 +6,12 @@ on application startup. It is designed to be safe for concurrent
 execution using PostgreSQL advisory locks to coordinate between
 distributed workers.
 
-Supports multi-tenant schema isolation: migrations can target a specific
-PostgreSQL schema, allowing each tenant to have isolated tables.
-
 Important: All migrations must be backward-compatible to allow
 safe rolling deployments.
 
 No alembic.ini required - all configuration is done programmatically.
 """
 
-import hashlib
 import logging
 import os
 from pathlib import Path
@@ -30,29 +26,11 @@ logger = logging.getLogger(__name__)
 MIGRATION_LOCK_ID = 123456789
 
 
-def _get_schema_lock_id(schema: str) -> int:
-    """
-    Generate a unique advisory lock ID for a schema.
-
-    Uses hash of schema name to create a deterministic lock ID.
-    """
-    # Use hash to create a unique lock ID per schema
-    # Keep within PostgreSQL's bigint range
-    hash_bytes = hashlib.sha256(schema.encode()).digest()[:8]
-    return int.from_bytes(hash_bytes, byteorder="big") % (2**31)
-
-
-def _run_migrations_internal(database_url: str, script_location: str, schema: str | None = None) -> None:
+def _run_migrations_internal(database_url: str, script_location: str) -> None:
     """
     Internal function to run migrations without locking.
-
-    Args:
-        database_url: SQLAlchemy database URL
-        script_location: Path to alembic scripts
-        schema: Target schema (None for default/public)
     """
-    schema_name = schema or "public"
-    logger.info(f"Running database migrations to head for schema '{schema_name}'...")
+    logger.info("Running database migrations to head...")
     logger.info(f"Database URL: {database_url}")
     logger.info(f"Script location: {script_location}")
 
@@ -72,22 +50,13 @@ def _run_migrations_internal(database_url: str, script_location: str, schema: st
     # Set path_separator to avoid deprecation warning
     alembic_cfg.set_main_option("path_separator", "os")
 
-    # If targeting a specific schema, pass it to env.py via config
-    # env.py will handle setting search_path and version_table_schema
-    if schema:
-        alembic_cfg.set_main_option("target_schema", schema)
-
-    # Run migrations
+    # Run migrations to head (latest version)
     command.upgrade(alembic_cfg, "head")
 
-    logger.info(f"Database migrations completed successfully for schema '{schema_name}'")
+    logger.info("Database migrations completed successfully")
 
 
-def run_migrations(
-    database_url: str,
-    script_location: str | None = None,
-    schema: str | None = None,
-) -> None:
+def run_migrations(database_url: str, script_location: str | None = None) -> None:
     """
     Run database migrations to the latest version using programmatic Alembic configuration.
 
@@ -96,28 +65,19 @@ def run_migrations(
     - Other workers wait for the lock, then verify migrations are complete
     - If schema is already up-to-date, this is a fast no-op
 
-    Supports multi-tenant schema isolation: when a schema is specified, migrations
-    run in that schema instead of public. This allows tenant extensions to provision
-    new tenant schemas with their own isolated tables.
-
     Args:
         database_url: SQLAlchemy database URL (e.g., "postgresql://user:pass@host/db")
         script_location: Path to alembic migrations directory (e.g., "/path/to/alembic").
                         If None, defaults to hindsight-api/alembic directory.
-        schema: Target PostgreSQL schema name. If None, uses default (public).
-                When specified, creates the schema if needed and runs migrations there.
 
     Raises:
         RuntimeError: If migrations fail to complete
         FileNotFoundError: If script_location doesn't exist
 
     Example:
-        # Using default location and public schema
+        # Using default location (hindsight_api package)
         run_migrations("postgresql://user:pass@host/db")
 
-        # Run migrations for a specific tenant schema
-        run_migrations("postgresql://user:pass@host/db", schema="tenant_acme")
-
         # Using custom location (when importing from another project)
         run_migrations(
             "postgresql://user:pass@host/db",
@@ -139,25 +99,21 @@ def run_migrations(
                 f"Alembic script location not found at {script_location}. Database migrations cannot be run."
             )
 
-        # Use schema-specific lock ID for multi-tenant isolation
-        lock_id = _get_schema_lock_id(schema) if schema else MIGRATION_LOCK_ID
-        schema_name = schema or "public"
-
         # Use PostgreSQL advisory lock to coordinate between distributed workers
         engine = create_engine(database_url)
         with engine.connect() as conn:
             # pg_advisory_lock blocks until the lock is acquired
             # The lock is automatically released when the connection closes
-            logger.debug(f"Acquiring migration advisory lock for schema '{schema_name}' (id={lock_id})...")
-            conn.execute(text(f"SELECT pg_advisory_lock({lock_id})"))
+            logger.debug(f"Acquiring migration advisory lock (id={MIGRATION_LOCK_ID})...")
+            conn.execute(text(f"SELECT pg_advisory_lock({MIGRATION_LOCK_ID})"))
             logger.debug("Migration advisory lock acquired")
 
             try:
                 # Run migrations while holding the lock
-                _run_migrations_internal(database_url, script_location, schema=schema)
+                _run_migrations_internal(database_url, script_location)
             finally:
                 # Explicitly release the lock (also released on connection close)
-                conn.execute(text(f"SELECT pg_advisory_unlock({lock_id})"))
+                conn.execute(text(f"SELECT pg_advisory_unlock({MIGRATION_LOCK_ID})"))
                 logger.debug("Migration advisory lock released")
 
     except FileNotFoundError:

hindsight-api/hindsight_api/models.py

@@ -2,24 +2,9 @@
 SQLAlchemy models for the memory system.
 """
 
-from dataclasses import dataclass
 from datetime import datetime
 from uuid import UUID as PyUUID
 
-
-@dataclass
-class RequestContext:
-    """
-    Context for request authentication and authorization.
-
-    This dataclass carries authentication data from HTTP requests to the
-    memory engine operations. It can be extended to include additional
-    context like headers, tokens, user info, etc.
-    """
-
-    api_key: str | None = None
-
-
 from pgvector.sqlalchemy import Vector
 from sqlalchemy import (
     CheckConstraint,

hindsight-api/hindsight_api/pg0.py

@@ -40,7 +40,7 @@ class EmbeddedPostgres:
             # Only set port if explicitly specified
             if self.port is not None:
                 kwargs["port"] = self.port
-            self._pg0 = Pg0(**kwargs)  # type: ignore[invalid-argument-type] - dict kwargs
+            self._pg0 = Pg0(**kwargs)
         return self._pg0
 
     async def start(self, max_retries: int = 5, retry_delay: float = 4.0) -> str:

hindsight-api/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hindsight-api"
-version = "0.1.14"
+version = "0.1.11"
 description = "Hindsight: Agent Memory That Works Like Human Memory"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -92,7 +92,6 @@ dev = [
     "python-dotenv>=1.2.1",
     "filelock>=3.0.0",
     "ruff>=0.8.0",
-    "ty>=0.0.1",
 ]
 
 [tool.ruff]
@@ -122,28 +121,3 @@ ignore = [
 [tool.ruff.format]
 quote-style = "double"
 indent-style = "space"
-
-[tool.ty]
-# Type checking configuration
-# ty is an extremely fast Python type checker from Astral (same team as ruff/uv)
-
-[tool.ty.environment]
-python-version = "3.11"
-
-[tool.ty.src]
-exclude = [
-    "tests/",
-    "hindsight_api/alembic/",
-]
-
-[tool.ty.rules]
-# Disable noisy rules while keeping important ones
-invalid-argument-type = "ignore"    # False positives with **kwargs patterns
-invalid-return-type = "ignore"      # Often intentional in async code
-invalid-parameter-default = "ignore" # Optional params with None default
-possibly-missing-attribute = "ignore" # Common with Optional types
-invalid-raise = "ignore"            # False positives with exception tracking
-call-non-callable = "ignore"        # False positives with Optional types
-invalid-key = "ignore"              # Pydantic ConfigDict not understood
-invalid-method-override = "ignore"  # Intentional signature differences
-unresolved-reference = "ignore"     # Forward references not always resolved

hindsight-api/tests/conftest.py

@@ -8,7 +8,7 @@ import os
 import filelock
 from pathlib import Path
 from dotenv import load_dotenv
-from hindsight_api import MemoryEngine, LLMConfig, LocalSTEmbeddings, RequestContext
+from hindsight_api import MemoryEngine, LLMConfig, LocalSTEmbeddings
 
 from hindsight_api.engine.cross_encoder import LocalSTCrossEncoder
 from hindsight_api.engine.query_analyzer import DateparserQueryAnalyzer
@@ -99,12 +99,6 @@ def pg0_db_url(db_url, tmp_path_factory, worker_id):
     return url
 
 
-@pytest.fixture(scope="function")
-def request_context():
-    """Provide a default RequestContext for tests."""
-    return RequestContext()
-
-
 @pytest.fixture(scope="session")
 def llm_config():
     """

hindsight-api/tests/test_agents_api.py

@@ -3,7 +3,7 @@ Tests for agent management API (profile, disposition, background).
 """
 import pytest
 import uuid
-from hindsight_api import MemoryEngine, RequestContext
+from hindsight_api import MemoryEngine
 from hindsight_api.api import CreateBankRequest, DispositionTraits
 from hindsight_api.engine.memory_engine import Budget
 
@@ -17,11 +17,11 @@ class TestAgentProfile:
     """Tests for agent profile management."""
 
     @pytest.mark.asyncio
-    async def test_get_agent_profile_creates_default(self, memory: MemoryEngine, request_context):
+    async def test_get_agent_profile_creates_default(self, memory: MemoryEngine):
         """Test that getting a profile for a new agent creates default disposition."""
         bank_id = unique_agent_id("test_profile_default")
 
-        profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        profile = await memory.get_bank_profile(bank_id)
 
         assert profile is not None
         assert "disposition" in profile
@@ -35,11 +35,11 @@ class TestAgentProfile:
         assert profile["background"] == ""
 
     @pytest.mark.asyncio
-    async def test_update_agent_disposition(self, memory: MemoryEngine, request_context):
+    async def test_update_agent_disposition(self, memory: MemoryEngine):
         """Test updating agent disposition traits."""
         bank_id = unique_agent_id("test_profile_update")
 
-        profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        profile = await memory.get_bank_profile(bank_id)
         assert profile["disposition"].skepticism == 3
 
         new_disposition = {
@@ -47,26 +47,26 @@ class TestAgentProfile:
             "literalism": 4,
             "empathy": 2,
         }
-        await memory.update_bank_disposition(bank_id, new_disposition, request_context=request_context)
+        await memory.update_bank_disposition(bank_id, new_disposition)
 
-        updated_profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        updated_profile = await memory.get_bank_profile(bank_id)
         disposition = updated_profile["disposition"]
         assert disposition.skepticism == new_disposition["skepticism"]
         assert disposition.literalism == new_disposition["literalism"]
         assert disposition.empathy == new_disposition["empathy"]
 
     @pytest.mark.asyncio
-    async def test_list_agents(self, memory: MemoryEngine, request_context):
+    async def test_list_agents(self, memory: MemoryEngine):
         """Test listing all agents."""
         agent_id_1 = unique_agent_id("test_list")
         agent_id_2 = unique_agent_id("test_list")
         agent_id_3 = unique_agent_id("test_list")
 
-        await memory.get_bank_profile(agent_id_1, request_context=request_context)
-        await memory.get_bank_profile(agent_id_2, request_context=request_context)
-        await memory.get_bank_profile(agent_id_3, request_context=request_context)
+        await memory.get_bank_profile(agent_id_1)
+        await memory.get_bank_profile(agent_id_2)
+        await memory.get_bank_profile(agent_id_3)
 
-        agents = await memory.list_banks(request_context=request_context)
+        agents = await memory.list_banks()
 
         agent_ids = [a["bank_id"] for a in agents]
         assert agent_id_1 in agent_ids
@@ -85,50 +85,46 @@ class TestAgentBackground:
     """Tests for agent background management."""
 
     @pytest.mark.asyncio
-    async def test_merge_agent_background(self, memory: MemoryEngine, request_context):
+    async def test_merge_agent_background(self, memory: MemoryEngine):
         """Test merging agent background information."""
         bank_id = unique_agent_id("test_profile_merge")
 
-        profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        profile = await memory.get_bank_profile(bank_id)
         assert profile["background"] == ""
 
         result1 = await memory.merge_bank_background(
             bank_id,
             "I was born in Texas",
-            update_disposition=False,
-            request_context=request_context,
+            update_disposition=False
         )
         assert "Texas" in result1["background"]
 
         result2 = await memory.merge_bank_background(
             bank_id,
             "I have 10 years of startup experience",
-            update_disposition=False,
-            request_context=request_context,
+            update_disposition=False
         )
         assert "Texas" in result2["background"] or "startup" in result2["background"]
 
-        final_profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        final_profile = await memory.get_bank_profile(bank_id)
         assert final_profile["background"] != ""
 
     @pytest.mark.asyncio
-    async def test_merge_background_handles_conflicts(self, memory: MemoryEngine, request_context):
+    async def test_merge_background_handles_conflicts(self, memory: MemoryEngine):
         """Test that merging background handles conflicts (new overwrites old)."""
         bank_id = unique_agent_id("test_profile_conflict")
 
         result1 = await memory.merge_bank_background(
             bank_id,
             "I was born in Colorado",
-            update_disposition=False,
-            request_context=request_context,
+            update_disposition=False
         )
         assert "Colorado" in result1["background"]
 
         result2 = await memory.merge_bank_background(
             bank_id,
             "You were born in Texas",
-            update_disposition=False,
-            request_context=request_context,
+            update_disposition=False
         )
         assert "Texas" in result2["background"]
 
@@ -137,7 +133,7 @@ class TestAgentEndpoint:
     """Tests for agent PUT endpoint logic."""
 
     @pytest.mark.asyncio
-    async def test_put_agent_create(self, memory: MemoryEngine, request_context):
+    async def test_put_agent_create(self, memory: MemoryEngine):
         """Test creating an agent via PUT endpoint."""
         bank_id = unique_agent_id("test_put_create")
 
@@ -150,13 +146,12 @@ class TestAgentEndpoint:
             background="I am a creative software engineer"
         )
 
-        profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        profile = await memory.get_bank_profile(bank_id)
 
         if request.disposition is not None:
             await memory.update_bank_disposition(
                 bank_id,
-                request.disposition.model_dump(),
-                request_context=request_context,
+                request.disposition.model_dump()
             )
 
         if request.background is not None:
@@ -173,14 +168,14 @@ class TestAgentEndpoint:
                     request.background
                 )
 
-        final_profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        final_profile = await memory.get_bank_profile(bank_id)
 
         assert final_profile["disposition"].skepticism == 4
         assert final_profile["disposition"].literalism == 5
         assert final_profile["background"] == "I am a creative software engineer"
 
     @pytest.mark.asyncio
-    async def test_put_agent_partial_update(self, memory: MemoryEngine, request_context):
+    async def test_put_agent_partial_update(self, memory: MemoryEngine):
         """Test updating only background."""
         bank_id = unique_agent_id("test_put_partial")
 
@@ -188,7 +183,7 @@ class TestAgentEndpoint:
             background="I am a data scientist"
         )
 
-        profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        profile = await memory.get_bank_profile(bank_id)
 
         if request.background is not None:
             pool = await memory._get_pool()
@@ -204,7 +199,7 @@ class TestAgentEndpoint:
                     request.background
                 )
 
-        final_profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        final_profile = await memory.get_bank_profile(bank_id)
 
         assert final_profile["disposition"].skepticism == 3  # Default
         assert final_profile["background"] == "I am a data scientist"
@@ -214,7 +209,7 @@ class TestAgentDispositionIntegration:
     """Tests for disposition integration with other features."""
 
     @pytest.mark.asyncio
-    async def test_think_uses_disposition(self, memory: MemoryEngine, request_context):
+    async def test_think_uses_disposition(self, memory: MemoryEngine):
         """Test that THINK operation uses agent disposition."""
         bank_id = unique_agent_id("test_think")
 
@@ -223,13 +218,12 @@ class TestAgentDispositionIntegration:
             "literalism": 4,  # High literalism
             "empathy": 2,     # Low empathy
         }
-        await memory.update_bank_disposition(bank_id, disposition, request_context=request_context)
+        await memory.update_bank_disposition(bank_id, disposition)
 
         await memory.merge_bank_background(
             bank_id,
             "I am a creative artist who values innovation over tradition",
-            update_disposition=False,
-            request_context=request_context,
+            update_disposition=False
         )
 
         await memory.retain_batch_async(
@@ -238,14 +232,13 @@ class TestAgentDispositionIntegration:
                 {"content": "Traditional painting techniques have been used for centuries"},
                 {"content": "Modern digital art is changing the art world"}
             ],
-            request_context=request_context,
+            document_id="art_facts"
         )
 
         result = await memory.reflect_async(
             bank_id=bank_id,
             query="What do you think about traditional vs modern art?",
-            budget=Budget.LOW,
-            request_context=request_context,
+            budget=Budget.LOW
         )
 
         assert result.text is not None

hindsight-api/tests/test_batch_chunking.py

@@ -6,7 +6,7 @@ import os
 
 
 @pytest.mark.asyncio
-async def test_large_batch_auto_chunks(memory, request_context):
+async def test_large_batch_auto_chunks(memory):
     bank_id = "test_chunking_agent"
     # Create a large batch that should trigger chunking
     # Each item is ~2000 chars, so 30 items = 60k chars (exceeds 50k threshold)
@@ -24,8 +24,7 @@ async def test_large_batch_auto_chunks(memory, request_context):
     # Ingest the large batch (should auto-chunk)
     result = await memory.retain_batch_async(
         bank_id=bank_id,
-        contents=contents,
-        request_context=request_context,
+        contents=contents
     )
 
     # Verify we got results back
@@ -34,7 +33,7 @@ async def test_large_batch_auto_chunks(memory, request_context):
 
 
 @pytest.mark.asyncio
-async def test_small_batch_no_chunking(memory, request_context):
+async def test_small_batch_no_chunking(memory):
     bank_id = "test_no_chunking_agent"
 
     # Create a small batch that should NOT trigger chunking
@@ -51,8 +50,7 @@ async def test_small_batch_no_chunking(memory, request_context):
     # Ingest the small batch (should NOT auto-chunk)
     result = await memory.retain_batch_async(
         bank_id=bank_id,
-        contents=contents,
-        request_context=request_context,
+        contents=contents
     )
 
     # Verify we got results back

hindsight-api/tests/test_combined_scoring.py

@@ -10,7 +10,6 @@ import pytest
 from datetime import datetime, timezone
 from hindsight_api.engine.search.types import RetrievalResult, MergedCandidate, ScoredResult
 from hindsight_api.engine.memory_engine import Budget
-from hindsight_api import RequestContext
 
 
 class TestRRFNormalization:
@@ -126,7 +125,7 @@ class TestCombinedScoringFormula:
 
 
 @pytest.mark.asyncio
-async def test_trace_has_normalized_rrf(memory, request_context):
+async def test_trace_has_normalized_rrf(memory):
     """Integration test: verify trace contains normalized RRF values, not raw."""
     bank_id = f"test_scoring_{datetime.now(timezone.utc).timestamp()}"
 
@@ -136,25 +135,21 @@ async def test_trace_has_normalized_rrf(memory, request_context):
             bank_id=bank_id,
             content="Python is a programming language created by Guido van Rossum",
             context="tech facts",
-            request_context=request_context,
         )
         await memory.retain_async(
             bank_id=bank_id,
             content="JavaScript was created by Brendan Eich at Netscape",
             context="tech facts",
-            request_context=request_context,
         )
         await memory.retain_async(
             bank_id=bank_id,
             content="The Eiffel Tower is located in Paris, France",
             context="geography facts",
-            request_context=request_context,
         )
         await memory.retain_async(
             bank_id=bank_id,
             content="Mount Everest is the tallest mountain on Earth",
             context="geography facts",
-            request_context=request_context,
         )
 
         # Search with tracing
@@ -165,7 +160,6 @@ async def test_trace_has_normalized_rrf(memory, request_context):
             budget=Budget.LOW,
             max_tokens=1024,
             enable_trace=True,
-            request_context=request_context,
         )
 
         assert result.trace is not None, "Trace should be present"
@@ -216,11 +210,11 @@ async def test_trace_has_normalized_rrf(memory, request_context):
             print(f"  - First result score components: {sc}")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_rrf_normalized_not_raw_in_trace(memory, request_context):
+async def test_rrf_normalized_not_raw_in_trace(memory):
     """Verify that raw RRF scores (0.04-0.06 range) don't appear as normalized values."""
     bank_id = f"test_rrf_raw_{datetime.now(timezone.utc).timestamp()}"
 
@@ -231,7 +225,6 @@ async def test_rrf_normalized_not_raw_in_trace(memory, request_context):
                 bank_id=bank_id,
                 content=f"Test fact number {i} about various topics",
                 context="test context",
-                request_context=request_context,
             )
 
         result = await memory.recall_async(
@@ -241,7 +234,6 @@ async def test_rrf_normalized_not_raw_in_trace(memory, request_context):
             budget=Budget.LOW,
             max_tokens=512,
             enable_trace=True,
-            request_context=request_context,
         )
 
         trace = result.trace
@@ -276,11 +268,11 @@ async def test_rrf_normalized_not_raw_in_trace(memory, request_context):
         print("\n✓ RRF raw vs normalized test passed!")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_combined_score_matches_components(memory, request_context):
+async def test_combined_score_matches_components(memory):
     """Verify the final score actually equals the weighted sum of components."""
     bank_id = f"test_combined_{datetime.now(timezone.utc).timestamp()}"
 
@@ -289,13 +281,11 @@ async def test_combined_score_matches_components(memory, request_context):
             bank_id=bank_id,
             content="The quick brown fox jumps over the lazy dog",
             context="test",
-            request_context=request_context,
         )
         await memory.retain_async(
             bank_id=bank_id,
             content="A quick test of the emergency broadcast system",
             context="test",
-            request_context=request_context,
         )
 
         result = await memory.recall_async(
@@ -305,7 +295,6 @@ async def test_combined_score_matches_components(memory, request_context):
             budget=Budget.LOW,
             max_tokens=512,
             enable_trace=True,
-            request_context=request_context,
         )
 
         trace = result.trace
@@ -331,4 +320,4 @@ async def test_combined_score_matches_components(memory, request_context):
         print("\n✓ Combined score verification test passed!")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)

hindsight-api/tests/test_document_tracking.py

@@ -4,11 +4,10 @@ Tests for document tracking and upsert functionality.
 import logging
 import pytest
 from datetime import datetime, timezone
-from hindsight_api import RequestContext
 
 
 @pytest.mark.asyncio
-async def test_document_creation_and_retrieval(memory, request_context):
+async def test_document_creation_and_retrieval(memory):
     """Test that documents are created and can be retrieved."""
     bank_id = f"test_doc_{datetime.now(timezone.utc).timestamp()}"
 
@@ -20,12 +19,11 @@ async def test_document_creation_and_retrieval(memory, request_context):
             bank_id=bank_id,
             content="Alice works at Google. Bob works at Microsoft.",
             context="Team meeting",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         # Retrieve document
-        doc = await memory.get_document(document_id, bank_id, request_context=request_context)
+        doc = await memory.get_document(document_id, bank_id)
 
         assert doc is not None
         assert doc["id"] == document_id
@@ -34,11 +32,11 @@ async def test_document_creation_and_retrieval(memory, request_context):
         assert doc["memory_unit_count"] > 0
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_document_upsert(memory, request_context):
+async def test_document_upsert(memory):
     """Test that providing the same document_id automatically upserts (deletes old units and creates new ones)."""
     bank_id = f"test_upsert_{datetime.now(timezone.utc).timestamp()}"
 
@@ -50,12 +48,11 @@ async def test_document_upsert(memory, request_context):
             bank_id=bank_id,
             content="Alice works at Google.",
             context="Initial",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         # Get document stats
-        doc_v1 = await memory.get_document(document_id, bank_id, request_context=request_context)
+        doc_v1 = await memory.get_document(document_id, bank_id)
         count_v1 = doc_v1["memory_unit_count"]
 
         # Update with different content (automatic upsert when same document_id is provided)
@@ -63,12 +60,11 @@ async def test_document_upsert(memory, request_context):
             bank_id=bank_id,
             content="Alice works at Microsoft. Bob works at Apple.",
             context="Updated",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         # Get updated document stats
-        doc_v2 = await memory.get_document(document_id, bank_id, request_context=request_context)
+        doc_v2 = await memory.get_document(document_id, bank_id)
         count_v2 = doc_v2["memory_unit_count"]
 
         # Verify old units were replaced
@@ -79,11 +75,11 @@ async def test_document_upsert(memory, request_context):
         assert set(units_v1).isdisjoint(set(units_v2))
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_document_deletion(memory, request_context):
+async def test_document_deletion(memory):
     """Test that deleting a document cascades to memory units."""
     bank_id = f"test_delete_{datetime.now(timezone.utc).timestamp()}"
 
@@ -95,30 +91,29 @@ async def test_document_deletion(memory, request_context):
             bank_id=bank_id,
             content="Alice works at Google.",
             context="Test",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         # Verify it exists
-        doc = await memory.get_document(document_id, bank_id, request_context=request_context)
+        doc = await memory.get_document(document_id, bank_id)
         assert doc is not None
         assert doc["memory_unit_count"] > 0
 
         # Delete document
-        result = await memory.delete_document(document_id, bank_id, request_context=request_context)
+        result = await memory.delete_document(document_id, bank_id)
         assert result["document_deleted"] == 1
         assert result["memory_units_deleted"] > 0
 
         # Verify it's gone
-        doc_after = await memory.get_document(document_id, bank_id, request_context=request_context)
+        doc_after = await memory.get_document(document_id, bank_id)
         assert doc_after is None
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_memory_without_document(memory, request_context):
+async def test_memory_without_document(memory):
     """Test that memories can still be created without document tracking."""
     bank_id = f"test_no_doc_{datetime.now(timezone.utc).timestamp()}"
 
@@ -127,11 +122,10 @@ async def test_memory_without_document(memory, request_context):
         units = await memory.retain_async(
             bank_id=bank_id,
             content="Alice works at Google.",
-            context="Test",
-            request_context=request_context,
+            context="Test"
         )
 
         assert len(units) > 0
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)

hindsight-api/tests/test_extensions.py

@@ -1,796 +0,0 @@
-"""Tests for the Hindsight extensions system."""
-
-from collections import defaultdict
-
-import pytest
-from fastapi import APIRouter
-from fastapi.testclient import TestClient
-
-from hindsight_api.extensions import (
-    ApiKeyTenantExtension,
-    AuthenticationError,
-    Extension,
-    HttpExtension,
-    OperationValidationError,
-    OperationValidatorExtension,
-    RecallContext,
-    RecallResult,
-    ReflectContext,
-    ReflectResultContext,
-    RequestContext,
-    RetainContext,
-    RetainResult,
-    TenantContext,
-    TenantExtension,
-    ValidationResult,
-    load_extension,
-)
-
-
-class TestExtensionLoader:
-    """Tests for extension loading and lifecycle."""
-
-    def test_load_extension_with_config(self, monkeypatch):
-        """Extension receives config from prefixed env vars and supports lifecycle."""
-        monkeypatch.setenv(
-            "HINDSIGHT_API_TEST_EXTENSION",
-            "tests.test_extensions:LifecycleTestExtension",
-        )
-        monkeypatch.setenv("HINDSIGHT_API_TEST_API_URL", "https://example.com")
-        monkeypatch.setenv("HINDSIGHT_API_TEST_MAX_RETRIES", "5")
-
-        ext = load_extension("TEST", Extension)
-
-        assert ext is not None
-        assert ext.config["api_url"] == "https://example.com"
-        assert ext.config["max_retries"] == "5"
-
-    @pytest.mark.asyncio
-    async def test_extension_lifecycle(self, monkeypatch):
-        """Extension on_startup and on_shutdown are called."""
-        monkeypatch.setenv(
-            "HINDSIGHT_API_TEST_EXTENSION",
-            "tests.test_extensions:LifecycleTestExtension",
-        )
-
-        ext = load_extension("TEST", Extension)
-
-        assert not ext.started
-        assert not ext.stopped
-
-        await ext.on_startup()
-        assert ext.started
-
-        await ext.on_shutdown()
-        assert ext.stopped
-
-
-class LifecycleTestExtension(Extension):
-    """Test extension for config and lifecycle tests."""
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.started = False
-        self.stopped = False
-
-    async def on_startup(self):
-        self.started = True
-
-    async def on_shutdown(self):
-        self.stopped = True
-
-
-class RateLimitingValidator(OperationValidatorExtension):
-    """
-    Mock validator that blocks after N attempts per bank_id.
-
-    Used for testing the extension integration with MemoryEngine.
-    """
-
-    def __init__(self, config: dict):
-        super().__init__(config)
-        self.max_attempts = int(config.get("max_attempts", "2"))
-        self.retain_counts: dict[str, int] = defaultdict(int)
-        self.recall_counts: dict[str, int] = defaultdict(int)
-        self.reflect_counts: dict[str, int] = defaultdict(int)
-
-    async def validate_retain(self, ctx: RetainContext) -> ValidationResult:
-        self.retain_counts[ctx.bank_id] += 1
-        if self.retain_counts[ctx.bank_id] > self.max_attempts:
-            return ValidationResult.reject(
-                f"Retain limit exceeded for bank {ctx.bank_id}"
-            )
-        return ValidationResult.accept()
-
-    async def validate_recall(self, ctx: RecallContext) -> ValidationResult:
-        self.recall_counts[ctx.bank_id] += 1
-        if self.recall_counts[ctx.bank_id] > self.max_attempts:
-            return ValidationResult.reject(
-                f"Recall limit exceeded for bank {ctx.bank_id}"
-            )
-        return ValidationResult.accept()
-
-    async def validate_reflect(self, ctx: ReflectContext) -> ValidationResult:
-        self.reflect_counts[ctx.bank_id] += 1
-        if self.reflect_counts[ctx.bank_id] > self.max_attempts:
-            return ValidationResult.reject(
-                f"Reflect limit exceeded for bank {ctx.bank_id}"
-            )
-        return ValidationResult.accept()
-
-
-class TrackingValidator(OperationValidatorExtension):
-    """
-    Mock validator that tracks all pre and post hook calls with full parameters.
-
-    Used for testing that hooks receive all user-provided parameters.
-    """
-
-    def __init__(self, config: dict):
-        super().__init__(config)
-        # Pre-hook tracking
-        self.pre_retain_calls: list[RetainContext] = []
-        self.pre_recall_calls: list[RecallContext] = []
-        self.pre_reflect_calls: list[ReflectContext] = []
-        # Post-hook tracking
-        self.post_retain_calls: list[RetainResult] = []
-        self.post_recall_calls: list[RecallResult] = []
-        self.post_reflect_calls: list[ReflectResultContext] = []
-
-    async def validate_retain(self, ctx: RetainContext) -> ValidationResult:
-        self.pre_retain_calls.append(ctx)
-        return ValidationResult.accept()
-
-    async def validate_recall(self, ctx: RecallContext) -> ValidationResult:
-        self.pre_recall_calls.append(ctx)
-        return ValidationResult.accept()
-
-    async def validate_reflect(self, ctx: ReflectContext) -> ValidationResult:
-        self.pre_reflect_calls.append(ctx)
-        return ValidationResult.accept()
-
-    async def on_retain_complete(self, result: RetainResult) -> None:
-        self.post_retain_calls.append(result)
-
-    async def on_recall_complete(self, result: RecallResult) -> None:
-        self.post_recall_calls.append(result)
-
-    async def on_reflect_complete(self, result: ReflectResultContext) -> None:
-        self.post_reflect_calls.append(result)
-
-
-class TestMemoryEngineValidation:
-    """Tests for validation integration with MemoryEngine.
-
-    The OperationValidatorExtension is integrated at the MemoryEngine level,
-    so all interfaces (HTTP API, MCP, SDK) get the same validation behavior.
-
-    For retain, the batch is validated as a whole (all or nothing) using
-    retain_batch_async which is the public method used by the HTTP API.
-    """
-
-    @pytest.mark.asyncio
-    async def test_retain_batch_validation(self, memory_with_validator):
-        """Retain batch is validated as a whole - accepts or rejects entire batch."""
-        memory = memory_with_validator
-        bank_id = "test-retain-batch"
-        ctx = RequestContext()
-
-        # First batch should succeed
-        await memory.retain_batch_async(
-            bank_id=bank_id,
-            contents=[
-                {"content": "First item"},
-                {"content": "Second item"},
-            ],
-            request_context=ctx,
-        )
-
-        # Second batch should succeed (2nd attempt)
-        await memory.retain_batch_async(
-            bank_id=bank_id,
-            contents=[{"content": "Third item"}],
-            request_context=ctx,
-        )
-
-        # Third batch should be blocked entirely (exceeds limit)
-        with pytest.raises(OperationValidationError) as exc_info:
-            await memory.retain_batch_async(
-                bank_id=bank_id,
-                contents=[
-                    {"content": "Should not be stored"},
-                    {"content": "Neither should this"},
-                ],
-                request_context=ctx,
-            )
-
-        assert "limit exceeded" in str(exc_info.value).lower()
-
-    @pytest.mark.asyncio
-    async def test_recall_validation(self, memory_with_validator):
-        """Recall is validated before execution."""
-        memory = memory_with_validator
-        bank_id = "test-recall-validation"
-        ctx = RequestContext()
-
-        # First recall should pass validation
-        await memory.recall_async(bank_id, "test query", fact_type=["world"], request_context=ctx)
-
-        # Second recall should pass validation
-        await memory.recall_async(bank_id, "another query", fact_type=["world"], request_context=ctx)
-
-        # Third recall should be blocked by validator
-        with pytest.raises(OperationValidationError) as exc_info:
-            await memory.recall_async(bank_id, "blocked query", fact_type=["world"], request_context=ctx)
-
-        assert "limit exceeded" in str(exc_info.value).lower()
-
-    @pytest.mark.asyncio
-    async def test_reflect_validation(self, memory_with_validator):
-        """Reflect is validated before execution."""
-        memory = memory_with_validator
-        bank_id = "test-reflect-validation"
-        ctx = RequestContext()
-
-        # First reflect should pass validation (may fail internally but validation passes)
-        try:
-            await memory.reflect_async(bank_id, "test question", request_context=ctx)
-        except OperationValidationError:
-            raise  # Re-raise validation errors
-        except Exception:
-            pass  # Other errors are fine (e.g., no data)
-
-        # Second reflect should pass validation
-        try:
-            await memory.reflect_async(bank_id, "another question", request_context=ctx)
-        except OperationValidationError:
-            raise
-        except Exception:
-            pass
-
-        # Third reflect should be blocked by validator
-        with pytest.raises(OperationValidationError) as exc_info:
-            await memory.reflect_async(bank_id, "blocked question", request_context=ctx)
-
-        assert "limit exceeded" in str(exc_info.value).lower()
-
-
-@pytest.fixture
-def memory_with_validator(memory):
-    """Memory engine with a rate-limiting validator (max 2 attempts per bank)."""
-    validator = RateLimitingValidator({"max_attempts": "2"})
-    memory._operation_validator = validator
-    return memory
-
-
-@pytest.fixture
-def memory_with_tracking_validator(memory):
-    """Memory engine with a tracking validator that records all hook calls."""
-    validator = TrackingValidator({})
-    memory._operation_validator = validator
-    return memory, validator
-
-
-class TestOperationHooksParameters:
-    """Tests for pre and post operation hooks receiving all user-provided parameters."""
-
-    @pytest.mark.asyncio
-    async def test_retain_pre_hook_receives_all_parameters(self, memory_with_tracking_validator):
-        """Pre-retain hook receives all user-provided parameters."""
-        memory, validator = memory_with_tracking_validator
-        bank_id = "test-retain-params"
-        ctx = RequestContext(api_key="test-key")
-        contents = [{"content": "Test content", "context": "test context"}]
-        document_id = "doc-123"
-
-        await memory.retain_batch_async(
-            bank_id=bank_id,
-            contents=contents,
-            document_id=document_id,
-            fact_type_override="world",
-            confidence_score=0.9,
-            request_context=ctx,
-        )
-
-        assert len(validator.pre_retain_calls) == 1
-        pre_ctx = validator.pre_retain_calls[0]
-
-        # Verify all parameters are present
-        assert pre_ctx.bank_id == bank_id
-        # Note: contents is copied before document_id is applied to individual items
-        assert len(pre_ctx.contents) == len(contents)
-        assert pre_ctx.contents[0]["content"] == contents[0]["content"]
-        assert pre_ctx.document_id == document_id
-        assert pre_ctx.fact_type_override == "world"
-        assert pre_ctx.confidence_score == 0.9
-        assert pre_ctx.request_context == ctx
-
-    @pytest.mark.asyncio
-    async def test_retain_post_hook_receives_all_parameters_and_result(self, memory_with_tracking_validator):
-        """Post-retain hook receives all parameters plus the result."""
-        memory, validator = memory_with_tracking_validator
-        bank_id = "test-retain-post"
-        ctx = RequestContext(api_key="test-key")
-        contents = [{"content": "Test content for post hook"}]
-        document_id = "doc-456"
-
-        result = await memory.retain_batch_async(
-            bank_id=bank_id,
-            contents=contents,
-            document_id=document_id,
-            fact_type_override="experience",
-            confidence_score=0.8,
-            request_context=ctx,
-        )
-
-        assert len(validator.post_retain_calls) == 1
-        post_result = validator.post_retain_calls[0]
-
-        # Verify all parameters are present
-        assert post_result.bank_id == bank_id
-        assert post_result.document_id == document_id
-        assert post_result.fact_type_override == "experience"
-        assert post_result.confidence_score == 0.8
-        assert post_result.request_context == ctx
-
-        # Verify result data
-        assert post_result.success is True
-        assert post_result.error is None
-        assert post_result.unit_ids == result  # Should match the return value
-
-    @pytest.mark.asyncio
-    async def test_recall_pre_hook_receives_all_parameters(self, memory_with_tracking_validator):
-        """Pre-recall hook receives all user-provided parameters."""
-        from datetime import datetime, timezone
-        from hindsight_api.engine.memory_engine import Budget
-
-        memory, validator = memory_with_tracking_validator
-        bank_id = "test-recall-params"
-        ctx = RequestContext(api_key="test-key")
-        query = "test query"
-        question_date = datetime(2024, 1, 15, tzinfo=timezone.utc)
-
-        await memory.recall_async(
-            bank_id=bank_id,
-            query=query,
-            budget=Budget.HIGH,
-            max_tokens=2048,
-            enable_trace=True,
-            fact_type=["world", "experience"],
-            question_date=question_date,
-            include_entities=True,
-            max_entity_tokens=300,
-            include_chunks=True,
-            max_chunk_tokens=4096,
-            request_context=ctx,
-        )
-
-        assert len(validator.pre_recall_calls) == 1
-        pre_ctx = validator.pre_recall_calls[0]
-
-        # Verify all parameters are present
-        assert pre_ctx.bank_id == bank_id
-        assert pre_ctx.query == query
-        assert pre_ctx.budget == Budget.HIGH
-        assert pre_ctx.max_tokens == 2048
-        assert pre_ctx.enable_trace is True
-        assert pre_ctx.fact_types == ["world", "experience"]
-        assert pre_ctx.question_date == question_date
-        assert pre_ctx.include_entities is True
-        assert pre_ctx.max_entity_tokens == 300
-        assert pre_ctx.include_chunks is True
-        assert pre_ctx.max_chunk_tokens == 4096
-        assert pre_ctx.request_context == ctx
-
-    @pytest.mark.asyncio
-    async def test_recall_post_hook_receives_all_parameters_and_result(self, memory_with_tracking_validator):
-        """Post-recall hook receives all parameters plus the result."""
-        from hindsight_api.engine.memory_engine import Budget
-
-        memory, validator = memory_with_tracking_validator
-        bank_id = "test-recall-post"
-        ctx = RequestContext(api_key="test-key")
-
-        result = await memory.recall_async(
-            bank_id=bank_id,
-            query="test query for post",
-            budget=Budget.LOW,
-            max_tokens=1024,
-            fact_type=["world"],
-            request_context=ctx,
-        )
-
-        assert len(validator.post_recall_calls) == 1
-        post_result = validator.post_recall_calls[0]
-
-        # Verify all parameters are present
-        assert post_result.bank_id == bank_id
-        assert post_result.query == "test query for post"
-        assert post_result.budget == Budget.LOW
-        assert post_result.max_tokens == 1024
-        assert post_result.fact_types == ["world"]
-        assert post_result.request_context == ctx
-
-        # Verify result data
-        assert post_result.success is True
-        assert post_result.error is None
-        assert post_result.result == result  # Should match the return value
-
-    @pytest.mark.asyncio
-    async def test_reflect_pre_hook_receives_all_parameters(self, memory_with_tracking_validator):
-        """Pre-reflect hook receives all user-provided parameters."""
-        from hindsight_api.engine.memory_engine import Budget
-
-        memory, validator = memory_with_tracking_validator
-        bank_id = "test-reflect-params"
-        ctx = RequestContext(api_key="test-key")
-
-        try:
-            await memory.reflect_async(
-                bank_id=bank_id,
-                query="test question",
-                budget=Budget.MID,
-                context="additional context",
-                request_context=ctx,
-            )
-        except Exception:
-            pass  # May fail if no data, but pre-hook should still be called
-
-        assert len(validator.pre_reflect_calls) == 1
-        pre_ctx = validator.pre_reflect_calls[0]
-
-        # Verify all parameters are present
-        assert pre_ctx.bank_id == bank_id
-        assert pre_ctx.query == "test question"
-        assert pre_ctx.budget == Budget.MID
-        assert pre_ctx.context == "additional context"
-        assert pre_ctx.request_context == ctx
-
-    @pytest.mark.asyncio
-    async def test_reflect_post_hook_receives_all_parameters_and_result(self, memory_with_tracking_validator):
-        """Post-reflect hook receives all parameters plus the result on success."""
-        from hindsight_api.engine.memory_engine import Budget
-
-        memory, validator = memory_with_tracking_validator
-        bank_id = "test-reflect-post"
-        ctx = RequestContext(api_key="test-key")
-
-        # Store some content first so reflect has something to work with
-        await memory.retain_batch_async(
-            bank_id=bank_id,
-            contents=[{"content": "Alice is a software engineer at Google."}],
-            request_context=ctx,
-        )
-
-        result = await memory.reflect_async(
-            bank_id=bank_id,
-            query="What does Alice do?",
-            budget=Budget.LOW,
-            context="work context",
-            request_context=ctx,
-        )
-
-        assert len(validator.post_reflect_calls) == 1
-        post_result = validator.post_reflect_calls[0]
-
-        # Verify all parameters are present
-        assert post_result.bank_id == bank_id
-        assert post_result.query == "What does Alice do?"
-        assert post_result.budget == Budget.LOW
-        assert post_result.context == "work context"
-        assert post_result.request_context == ctx
-
-        # Verify result data
-        assert post_result.success is True
-        assert post_result.error is None
-        assert post_result.result == result  # Should match the return value
-        assert post_result.result.text is not None
-
-    @pytest.mark.asyncio
-    async def test_post_hooks_called_in_order_after_pre_hooks(self, memory_with_tracking_validator):
-        """Post hooks are called after pre hooks and after operation completes."""
-        memory, validator = memory_with_tracking_validator
-        bank_id = "test-hook-order"
-        ctx = RequestContext()
-
-        # Retain operation
-        await memory.retain_batch_async(
-            bank_id=bank_id,
-            contents=[{"content": "Test content"}],
-            request_context=ctx,
-        )
-
-        # Pre-hook should be called before post-hook
-        assert len(validator.pre_retain_calls) == 1
-        assert len(validator.post_retain_calls) == 1
-
-        # Recall operation
-        await memory.recall_async(
-            bank_id=bank_id,
-            query="test",
-            fact_type=["world"],
-            request_context=ctx,
-        )
-
-        assert len(validator.pre_recall_calls) == 1
-        assert len(validator.post_recall_calls) == 1
-
-
-class TestTenantExtension:
-    """Tests for TenantExtension and ApiKeyTenantExtension."""
-
-    @pytest.mark.asyncio
-    async def test_api_key_tenant_extension_valid_key(self):
-        """ApiKeyTenantExtension accepts valid API key."""
-        ext = ApiKeyTenantExtension({"api_key": "secret-key-123"})
-
-        result = await ext.authenticate(RequestContext(api_key="secret-key-123"))
-
-        assert result.schema_name == "public"
-
-    @pytest.mark.asyncio
-    async def test_api_key_tenant_extension_invalid_key(self):
-        """ApiKeyTenantExtension rejects invalid API key."""
-        ext = ApiKeyTenantExtension({"api_key": "secret-key-123"})
-
-        with pytest.raises(AuthenticationError) as exc_info:
-            await ext.authenticate(RequestContext(api_key="wrong-key"))
-
-        assert "Invalid API key" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_api_key_tenant_extension_missing_key(self):
-        """ApiKeyTenantExtension rejects missing API key."""
-        ext = ApiKeyTenantExtension({"api_key": "secret-key-123"})
-
-        with pytest.raises(AuthenticationError):
-            await ext.authenticate(RequestContext(api_key=None))
-
-    def test_api_key_tenant_extension_requires_config(self):
-        """ApiKeyTenantExtension requires api_key in config."""
-        with pytest.raises(ValueError) as exc_info:
-            ApiKeyTenantExtension({})
-
-        assert "HINDSIGHT_API_TENANT_API_KEY is required" in str(exc_info.value)
-
-
-class TestMemoryEngineTenantAuth:
-    """Tests for tenant authentication in MemoryEngine."""
-
-    @pytest.mark.asyncio
-    async def test_retain_requires_tenant_request_when_extension_configured(
-        self, memory_with_tenant
-    ):
-        """Retain fails without RequestContext when tenant extension is configured."""
-        memory = memory_with_tenant
-
-        with pytest.raises(AuthenticationError) as exc_info:
-            await memory.retain_batch_async(
-                bank_id="test-bank",
-                contents=[{"content": "test"}],
-                request_context=None,  # Missing!
-            )
-
-        assert "RequestContext is required" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_retain_succeeds_with_valid_tenant_request(self, memory_with_tenant):
-        """Retain succeeds with valid RequestContext."""
-        memory = memory_with_tenant
-
-        # Should not raise
-        await memory.retain_batch_async(
-            bank_id="test-bank-tenant",
-            contents=[{"content": "test content"}],
-            request_context=RequestContext(api_key="test-api-key"),
-        )
-
-    @pytest.mark.asyncio
-    async def test_retain_fails_with_invalid_api_key(self, memory_with_tenant):
-        """Retain fails with invalid API key."""
-        memory = memory_with_tenant
-
-        with pytest.raises(AuthenticationError) as exc_info:
-            await memory.retain_batch_async(
-                bank_id="test-bank",
-                contents=[{"content": "test"}],
-                request_context=RequestContext(api_key="wrong-key"),
-            )
-
-        assert "Invalid API key" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_recall_requires_tenant_request_when_extension_configured(
-        self, memory_with_tenant
-    ):
-        """Recall fails without RequestContext when tenant extension is configured."""
-        memory = memory_with_tenant
-
-        with pytest.raises(AuthenticationError):
-            await memory.recall_async(
-                bank_id="test-bank",
-                query="test query",
-                fact_type=["world"],
-                request_context=None,
-            )
-
-    @pytest.mark.asyncio
-    async def test_no_tenant_request_needed_without_extension(self, memory):
-        """Operations work with empty RequestContext when no tenant extension configured."""
-        # Should not raise - no tenant extension configured, just pass empty RequestContext
-        await memory.retain_batch_async(
-            bank_id="test-bank-no-tenant",
-            contents=[{"content": "test content"}],
-            request_context=RequestContext(),
-        )
-
-
-@pytest.fixture
-def memory_with_tenant(memory):
-    """Memory engine with a tenant extension (API key auth)."""
-    tenant_ext = ApiKeyTenantExtension({"api_key": "test-api-key"})
-    memory._tenant_extension = tenant_ext
-    return memory
-
-
-class SampleHttpExtension(HttpExtension):
-    """Sample HTTP extension for testing that provides custom endpoints."""
-
-    def __init__(self, config: dict):
-        super().__init__(config)
-        self.started = False
-        self.stopped = False
-        self.request_count = 0
-
-    async def on_startup(self):
-        self.started = True
-
-    async def on_shutdown(self):
-        self.stopped = True
-
-    def get_router(self, memory) -> APIRouter:
-        router = APIRouter()
-
-        @router.get("/hello")
-        async def hello():
-            self.request_count += 1
-            return {"message": "Hello from extension!"}
-
-        @router.get("/config")
-        async def get_config():
-            return {"config": self.config}
-
-        @router.get("/health-check")
-        async def extension_health():
-            health = await memory.health_check()
-            return {"extension": "healthy", "memory": health}
-
-        @router.post("/echo")
-        async def echo(data: dict):
-            return {"echoed": data}
-
-        return router
-
-
-class TestHttpExtensionIntegration:
-    """Tests for HTTP extension integration."""
-
-    def test_load_http_extension(self, monkeypatch):
-        """HttpExtension can be loaded from environment variable."""
-        monkeypatch.setenv(
-            "HINDSIGHT_API_HTTP_EXTENSION",
-            "tests.test_extensions:SampleHttpExtension",
-        )
-        monkeypatch.setenv("HINDSIGHT_API_HTTP_CUSTOM_PARAM", "custom_value")
-
-        ext = load_extension("HTTP", HttpExtension)
-
-        assert ext is not None
-        assert isinstance(ext, SampleHttpExtension)
-        assert ext.config["custom_param"] == "custom_value"
-
-    def test_http_extension_router_mounted_at_ext(self, memory):
-        """HTTP extension router is mounted at /ext/."""
-        from hindsight_api.api.http import create_app
-
-        ext = SampleHttpExtension({"test_key": "test_value"})
-        app = create_app(memory, initialize_memory=False, http_extension=ext)
-
-        client = TestClient(app)
-
-        # Extension endpoint should be accessible at /ext/
-        response = client.get("/ext/hello")
-        assert response.status_code == 200
-        assert response.json() == {"message": "Hello from extension!"}
-
-        # Should track request count
-        assert ext.request_count == 1
-
-        # Old path should NOT work
-        response = client.get("/extension/hello")
-        assert response.status_code == 404
-
-    def test_http_extension_config_endpoint(self, memory):
-        """Extension can expose its config via custom endpoint."""
-        from hindsight_api.api.http import create_app
-
-        ext = SampleHttpExtension({"api_key": "secret", "limit": "100"})
-        app = create_app(memory, initialize_memory=False, http_extension=ext)
-
-        client = TestClient(app)
-
-        response = client.get("/ext/config")
-        assert response.status_code == 200
-        assert response.json()["config"]["api_key"] == "secret"
-        assert response.json()["config"]["limit"] == "100"
-
-    def test_http_extension_can_access_memory(self, memory):
-        """Extension endpoints can access memory engine."""
-        from hindsight_api.api.http import create_app
-
-        ext = SampleHttpExtension({})
-        app = create_app(memory, initialize_memory=False, http_extension=ext)
-
-        client = TestClient(app)
-
-        response = client.get("/ext/health-check")
-        assert response.status_code == 200
-        data = response.json()
-        assert data["extension"] == "healthy"
-        assert "memory" in data
-
-    def test_http_extension_post_endpoint(self, memory):
-        """Extension can handle POST requests with JSON body."""
-        from hindsight_api.api.http import create_app
-
-        ext = SampleHttpExtension({})
-        app = create_app(memory, initialize_memory=False, http_extension=ext)
-
-        client = TestClient(app)
-
-        response = client.post("/ext/echo", json={"key": "value", "number": 42})
-        assert response.status_code == 200
-        assert response.json() == {"echoed": {"key": "value", "number": 42}}
-
-    def test_http_extension_not_mounted_when_none(self, memory):
-        """No extension routes when http_extension is None."""
-        from hindsight_api.api.http import create_app
-
-        app = create_app(memory, initialize_memory=False, http_extension=None)
-
-        client = TestClient(app)
-
-        # Extension endpoint should not exist
-        response = client.get("/ext/hello")
-        assert response.status_code == 404
-
-    @pytest.mark.asyncio
-    async def test_http_extension_lifecycle(self):
-        """HTTP extension on_startup and on_shutdown are called."""
-        ext = SampleHttpExtension({})
-
-        assert not ext.started
-        assert not ext.stopped
-
-        await ext.on_startup()
-        assert ext.started
-
-        await ext.on_shutdown()
-        assert ext.stopped
-
-    def test_core_routes_still_work_with_extension(self, memory):
-        """Core API routes still work when extension is mounted."""
-        from hindsight_api.api.http import create_app
-
-        ext = SampleHttpExtension({})
-        app = create_app(memory, initialize_memory=False, http_extension=ext)
-
-        client = TestClient(app)
-
-        # Health endpoint should work
-        response = client.get("/health")
-        assert response.status_code in (200, 503)  # May be unhealthy if DB not connected
-
-        # Banks list endpoint should work
-        response = client.get("/v1/default/banks")
-        assert response.status_code in (200, 500)  # May fail if DB not ready

hindsight-api/tests/test_fact_extraction_quality.py

@@ -897,7 +897,7 @@ class TestDispositionInference:
     """Tests for LLM-based disposition trait inference from background."""
 
     @pytest.mark.asyncio
-    async def test_background_merge_with_disposition_inference(self, memory, request_context):
+    async def test_background_merge_with_disposition_inference(self, memory):
         """Test that background merge infers disposition traits by default."""
         import uuid
         bank_id = f"test_infer_{uuid.uuid4().hex[:8]}"
@@ -905,8 +905,7 @@ class TestDispositionInference:
         result = await memory.merge_bank_background(
             bank_id,
             "I am a creative software engineer who loves innovation and trying new technologies",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
 
         assert "background" in result
@@ -924,31 +923,30 @@ class TestDispositionInference:
             assert 1 <= disposition[trait] <= 5
 
     @pytest.mark.asyncio
-    async def test_background_merge_without_disposition_inference(self, memory, request_context):
+    async def test_background_merge_without_disposition_inference(self, memory):
         """Test that background merge skips disposition inference when disabled."""
         import uuid
         bank_id = f"test_no_infer_{uuid.uuid4().hex[:8]}"
 
-        initial_profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        initial_profile = await memory.get_bank_profile(bank_id)
         initial_disposition = initial_profile["disposition"]
 
         result = await memory.merge_bank_background(
             bank_id,
             "I am a data scientist",
-            update_disposition=False,
-            request_context=request_context,
+            update_disposition=False
         )
 
         assert "background" in result
         assert "disposition" not in result
 
-        final_profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        final_profile = await memory.get_bank_profile(bank_id)
         final_disposition = final_profile["disposition"]
 
         assert initial_disposition == final_disposition
 
     @pytest.mark.asyncio
-    async def test_disposition_inference_for_lawyer(self, memory, request_context):
+    async def test_disposition_inference_for_lawyer(self, memory):
         """Test disposition inference for lawyer profile (high skepticism, high literalism)."""
         import uuid
         bank_id = f"test_lawyer_{uuid.uuid4().hex[:8]}"
@@ -956,8 +954,7 @@ class TestDispositionInference:
         result = await memory.merge_bank_background(
             bank_id,
             "I am a lawyer who focuses on contract details and never takes claims at face value",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
 
         disposition = result["disposition"]
@@ -967,7 +964,7 @@ class TestDispositionInference:
         assert disposition["literalism"] >= 3
 
     @pytest.mark.asyncio
-    async def test_disposition_inference_for_therapist(self, memory, request_context):
+    async def test_disposition_inference_for_therapist(self, memory):
         """Test disposition inference for therapist profile (high empathy)."""
         import uuid
         bank_id = f"test_therapist_{uuid.uuid4().hex[:8]}"
@@ -975,8 +972,7 @@ class TestDispositionInference:
         result = await memory.merge_bank_background(
             bank_id,
             "I am a therapist who deeply understands and connects with people's emotional struggles",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
 
         disposition = result["disposition"]
@@ -985,7 +981,7 @@ class TestDispositionInference:
         assert disposition["empathy"] >= 3
 
     @pytest.mark.asyncio
-    async def test_disposition_updates_in_database(self, memory, request_context):
+    async def test_disposition_updates_in_database(self, memory):
         """Test that inferred disposition is actually stored in database."""
         import uuid
         bank_id = f"test_db_update_{uuid.uuid4().hex[:8]}"
@@ -993,13 +989,12 @@ class TestDispositionInference:
         result = await memory.merge_bank_background(
             bank_id,
             "I am an innovative designer",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
 
         inferred_disposition = result["disposition"]
 
-        profile = await memory.get_bank_profile(bank_id, request_context=request_context)
+        profile = await memory.get_bank_profile(bank_id)
         db_disposition = profile["disposition"]
 
         # Compare values (db_disposition is a Pydantic model)
@@ -1008,7 +1003,7 @@ class TestDispositionInference:
         assert db_disposition.empathy == inferred_disposition["empathy"]
 
     @pytest.mark.asyncio
-    async def test_multiple_background_merges_update_disposition(self, memory, request_context):
+    async def test_multiple_background_merges_update_disposition(self, memory):
         """Test that each background merge can update disposition."""
         import uuid
         bank_id = f"test_multi_merge_{uuid.uuid4().hex[:8]}"
@@ -1016,16 +1011,14 @@ class TestDispositionInference:
         result1 = await memory.merge_bank_background(
             bank_id,
             "I am a software engineer",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
         disposition1 = result1["disposition"]
 
         result2 = await memory.merge_bank_background(
             bank_id,
             "I love creative problem solving and innovation",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
         disposition2 = result2["disposition"]
 
@@ -1033,7 +1026,7 @@ class TestDispositionInference:
         assert "creative" in result2["background"].lower() or "innovation" in result2["background"].lower()
 
     @pytest.mark.asyncio
-    async def test_background_merge_conflict_resolution_with_disposition(self, memory, request_context):
+    async def test_background_merge_conflict_resolution_with_disposition(self, memory):
         """Test that conflicts are resolved and disposition reflects final background."""
         import uuid
         bank_id = f"test_conflict_{uuid.uuid4().hex[:8]}"
@@ -1041,15 +1034,13 @@ class TestDispositionInference:
         await memory.merge_bank_background(
             bank_id,
             "I was born in Colorado and prefer stability",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
 
         result = await memory.merge_bank_background(
             bank_id,
             "You were born in Texas and are very skeptical of people",
-            update_disposition=True,
-            request_context=request_context,
+            update_disposition=True
         )
 
         background = result["background"]

hindsight-api/tests/test_fact_ordering.py

@@ -7,24 +7,24 @@ distinguish between things said earlier vs later.
 """
 import pytest
 from datetime import datetime, timezone
-from hindsight_api import MemoryEngine, RequestContext
+from hindsight_api import MemoryEngine
 from hindsight_api.engine.memory_engine import Budget
 import os
 
 
 @pytest.mark.asyncio
-async def test_fact_ordering_within_conversation(memory, request_context):
+async def test_fact_ordering_within_conversation(memory):
     bank_id = "test_ordering_agent"
 
     # Get/create agent (auto-creates with defaults)
-    await memory.get_bank_profile(bank_id, request_context=request_context)
+    await memory.get_bank_profile(bank_id)
 
     # Update disposition to match Marcus
     await memory.update_bank_disposition(bank_id, {
         "skepticism": 3,
         "literalism": 3,
         "empathy": 3
-    }, request_context=request_context)
+    })
 
     # A conversation where Marcus changes his position
     conversation = """
@@ -43,8 +43,7 @@ Marcus: Yeah, I realized I was being too optimistic about their defense.
         content=conversation,
         context="podcast discussion about NFL game",
         event_date=base_event_date,
-        document_id="test_conv_1",
-        request_context=request_context,
+        document_id="test_conv_1"
     )
 
     # Search for all facts about Marcus's predictions
@@ -53,8 +52,7 @@ Marcus: Yeah, I realized I was being too optimistic about their defense.
         query="Marcus prediction Rams",
         fact_type=['opinion', 'experience', 'world'],
         budget=Budget.LOW,
-        max_tokens=8192,
-        request_context=request_context,
+        max_tokens=8192
     )
 
     print(f"\n=== Retrieved {len(results.results)} facts ===")
@@ -115,17 +113,17 @@ Marcus: Yeah, I realized I was being too optimistic about their defense.
         print(f"\n✅ Temporal ordering preserved: First prediction came before changed prediction")
 
     # Cleanup
-    await memory.delete_bank(bank_id, request_context=request_context)
+    await memory.delete_bank(bank_id)
 
     print(f"\n✅ Test passed: Fact ordering within conversation is preserved")
 
 
 @pytest.mark.asyncio
-async def test_multiple_documents_ordering(memory, request_context):
+async def test_multiple_documents_ordering(memory):
 
     bank_id = "test_multi_doc_agent"
 
-    await memory.get_bank_profile(bank_id, request_context=request_context)  # Auto-creates with defaults
+    await memory.get_bank_profile(bank_id)  # Auto-creates with defaults
 
     # Two separate conversations with same base time
     base_time = datetime(2024, 11, 14, 10, 0, 0, tzinfo=timezone.utc)
@@ -148,8 +146,7 @@ Alice: I reconsidered the team's experience level.
         contents=[
             {"content": conv1, "context": "project discussion 1", "event_date": base_time},
             {"content": conv2, "context": "project discussion 2", "event_date": base_time}
-        ],
-        request_context=request_context,
+        ]
     )
 
     # Search for Alice's preferences
@@ -158,8 +155,7 @@ Alice: I reconsidered the team's experience level.
         query="Alice preference React Vue",
         fact_type=['opinion', 'experience'],
         budget=Budget.LOW,
-        max_tokens=8192,
-        request_context=request_context,
+        max_tokens=8192
     )
 
     print(f"\n=== Retrieved {len(results.results)} agent facts ===")
@@ -179,6 +175,6 @@ Alice: I reconsidered the team's experience level.
         print(f"\n✅ Facts from {len(agent_facts)} statements have {len(unique_timestamps)} unique timestamps")
 
     # Cleanup
-    await memory.delete_bank(bank_id, request_context=request_context)
+    await memory.delete_bank(bank_id)
 
     print(f"\n✅ Test passed: Multiple documents maintain separate ordering")

hindsight-api/tests/test_llm_provider.py

@@ -26,9 +26,6 @@ MODEL_MATRIX = [
     ("gemini", "gemini-2.5-flash"),
     ("gemini", "gemini-2.5-flash-lite"),
     ("gemini", "gemini-3-pro-preview"),
-    # Ollama models (local)
-    ("ollama", "gemma3:12b"),
-    ("ollama", "gemma3:1b"),
 ]
 
 
@@ -51,18 +48,12 @@ async def test_llm_provider_memory_operations(provider: str, model: str):
     All models must pass this test.
     """
     api_key = get_api_key_for_provider(provider)
-
-    # Skip Ollama tests in CI (no models available)
-    if provider == "ollama" and os.getenv("CI"):
-        pytest.skip(f"Skipping {provider}/{model}: Ollama not available in CI")
-
-    # Other providers need an API key
-    if provider != "ollama" and not api_key:
+    if not api_key:
         pytest.skip(f"Skipping {provider}/{model}: no API key available")
 
     llm = LLMProvider(
         provider=provider,
-        api_key=api_key or "",
+        api_key=api_key,
         base_url="",
         model=model,
     )

hindsight-api/tests/test_observations.py

@@ -3,12 +3,11 @@ Test observation generation and entity state functionality.
 """
 import pytest
 from hindsight_api.engine.memory_engine import Budget
-from hindsight_api import RequestContext
 from datetime import datetime, timezone
 
 
 @pytest.mark.asyncio
-async def test_observation_generation_on_put(memory, request_context):
+async def test_observation_generation_on_put(memory):
     """
     Test that observations are generated SYNCHRONOUSLY when new facts are added.
 
@@ -37,8 +36,7 @@ async def test_observation_generation_on_put(memory, request_context):
                 bank_id=bank_id,
                 content=content,
                 context="work info",
-                event_date=datetime(2024, 1, 15 + i, tzinfo=timezone.utc),
-                request_context=request_context,
+                event_date=datetime(2024, 1, 15 + i, tzinfo=timezone.utc)
             )
 
         # Observations are generated SYNCHRONOUSLY during retain,
@@ -77,7 +75,7 @@ async def test_observation_generation_on_put(memory, request_context):
         print(f"Entity: {entity_name} (id: {entity_id})")
 
         # Get observations for the entity - should be available immediately
-        observations = await memory.get_entity_observations(bank_id, entity_id, limit=10, request_context=request_context)
+        observations = await memory.get_entity_observations(bank_id, entity_id, limit=10)
 
         print(f"\n=== Observations for {entity_name} ===")
         print(f"Total observations: {len(observations)}")
@@ -104,7 +102,7 @@ async def test_observation_generation_on_put(memory, request_context):
 
 
 @pytest.mark.asyncio
-async def test_regenerate_entity_observations(memory, request_context):
+async def test_regenerate_entity_observations(memory):
     """
     Test explicit regeneration of observations for an entity.
     """
@@ -116,8 +114,7 @@ async def test_regenerate_entity_observations(memory, request_context):
             bank_id=bank_id,
             content="Sarah is a product manager who loves user research and data analysis.",
             context="work info",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
+            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc)
         )
 
         await memory.wait_for_background_tasks()
@@ -143,15 +140,14 @@ async def test_regenerate_entity_observations(memory, request_context):
             created_ids = await memory.regenerate_entity_observations(
                 bank_id=bank_id,
                 entity_id=entity_id,
-                entity_name=entity_name,
-                request_context=request_context,
+                entity_name=entity_name
             )
 
             print(f"\n=== Regenerated Observations ===")
             print(f"Created {len(created_ids)} observations for {entity_name}")
 
             # Get the observations
-            observations = await memory.get_entity_observations(bank_id, entity_id, limit=10, request_context=request_context)
+            observations = await memory.get_entity_observations(bank_id, entity_id, limit=10)
             for obs in observations:
                 print(f"  - {obs.text}")
 
@@ -174,108 +170,7 @@ async def test_regenerate_entity_observations(memory, request_context):
 
 
 @pytest.mark.asyncio
-async def test_manual_regenerate_with_few_facts(memory, request_context):
-    """
-    Test that manual regeneration works even with fewer than 5 facts.
-
-    This is important because:
-    - Automatic generation during retain requires MIN_FACTS_THRESHOLD (5)
-    - But manual regeneration via API should work with any number of facts
-    - The UI triggers manual regeneration, so it should work regardless of fact count
-    """
-    bank_id = f"test_manual_regen_{datetime.now(timezone.utc).timestamp()}"
-
-    try:
-        # Store only 2 facts - below the automatic threshold
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Alice works at Google as a senior software engineer.",
-            context="work info",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Alice loves hiking and outdoor photography.",
-            context="hobbies",
-            event_date=datetime(2024, 1, 16, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-
-        # Find the Alice entity
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            entity_row = await conn.fetchrow(
-                """
-                SELECT id, canonical_name
-                FROM entities
-                WHERE bank_id = $1 AND LOWER(canonical_name) LIKE '%alice%'
-                LIMIT 1
-                """,
-                bank_id
-            )
-
-        assert entity_row is not None, "Alice entity should have been extracted"
-
-        entity_id = str(entity_row['id'])
-        entity_name = entity_row['canonical_name']
-
-        # Check fact count - should be < 5
-        async with pool.acquire() as conn:
-            fact_count = await conn.fetchval(
-                "SELECT COUNT(*) FROM unit_entities WHERE entity_id = $1",
-                entity_row['id']
-            )
-
-        print(f"\n=== Manual Regeneration Test ===")
-        print(f"Entity: {entity_name} (id: {entity_id})")
-        print(f"Linked facts: {fact_count}")
-
-        # Verify we're testing with fewer than the automatic threshold
-        assert fact_count < 5, f"Test requires < 5 facts, but entity has {fact_count}"
-
-        # Before regeneration - should have no observations (auto threshold not met)
-        obs_before = await memory.get_entity_observations(bank_id, entity_id, limit=10, request_context=request_context)
-        print(f"Observations before manual regenerate: {len(obs_before)}")
-
-        # Manually regenerate observations - this should work regardless of fact count
-        created_ids = await memory.regenerate_entity_observations(
-            bank_id=bank_id,
-            entity_id=entity_id,
-            entity_name=entity_name,
-            request_context=request_context,
-        )
-
-        print(f"Observations created by manual regenerate: {len(created_ids)}")
-
-        # Get observations after regeneration
-        observations = await memory.get_entity_observations(bank_id, entity_id, limit=10, request_context=request_context)
-        print(f"Observations after manual regenerate: {len(observations)}")
-        for obs in observations:
-            print(f"  - {obs.text}")
-
-        # Manual regeneration should create observations even with < 5 facts
-        assert len(observations) > 0, \
-            f"Manual regeneration should create observations even with only {fact_count} facts. " \
-            f"The LLM should synthesize at least 1 observation from the available facts."
-
-        # Verify observations contain relevant content
-        obs_texts = " ".join([o.text.lower() for o in observations])
-        assert any(keyword in obs_texts for keyword in ["google", "engineer", "hiking", "photography", "alice"]), \
-            "Observations should contain relevant information about Alice"
-
-        print(f"✓ Manual regeneration works with {fact_count} facts (below automatic threshold of 5)")
-
-    finally:
-        # Cleanup
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            await conn.execute("DELETE FROM memory_units WHERE bank_id = $1", bank_id)
-            await conn.execute("DELETE FROM entities WHERE bank_id = $1", bank_id)
-
-
-@pytest.mark.asyncio
-async def test_search_with_include_entities(memory, request_context):
+async def test_search_with_include_entities(memory):
     """
     Test that search with include_entities=True returns entity observations.
 
@@ -301,8 +196,7 @@ async def test_search_with_include_entities(memory, request_context):
                 bank_id=bank_id,
                 content=content,
                 context="work info",
-                event_date=datetime(2024, 1, 15 + i, tzinfo=timezone.utc),
-                request_context=request_context,
+                event_date=datetime(2024, 1, 15 + i, tzinfo=timezone.utc)
             )
 
         # Observations are generated synchronously during retain, no need to wait
@@ -315,8 +209,7 @@ async def test_search_with_include_entities(memory, request_context):
             budget=Budget.LOW,
             max_tokens=2000,
             include_entities=True,
-            max_entity_tokens=500,
-            request_context=request_context,
+            max_entity_tokens=500
         )
 
         print(f"\n=== Search Results ===")
@@ -370,7 +263,7 @@ async def test_search_with_include_entities(memory, request_context):
 
 
 @pytest.mark.asyncio
-async def test_get_entity_state(memory, request_context):
+async def test_get_entity_state(memory):
     """
     Test getting the full state of an entity.
     """
@@ -382,8 +275,7 @@ async def test_get_entity_state(memory, request_context):
             bank_id=bank_id,
             content="Bob is a frontend developer who specializes in React and TypeScript.",
             context="work info",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
+            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc)
         )
 
         await memory.wait_for_background_tasks()
@@ -410,8 +302,7 @@ async def test_get_entity_state(memory, request_context):
                 bank_id=bank_id,
                 entity_id=entity_id,
                 entity_name=entity_name,
-                limit=10,
-                request_context=request_context,
+                limit=10
             )
 
             print(f"\n=== Entity State for {entity_name} ===")
@@ -433,7 +324,7 @@ async def test_get_entity_state(memory, request_context):
 
 
 @pytest.mark.asyncio
-async def test_observation_fact_type_in_database(memory, request_context):
+async def test_observation_fact_type_in_database(memory):
     """
     Test that observations are stored with correct fact_type in database.
     """
@@ -445,8 +336,7 @@ async def test_observation_fact_type_in_database(memory, request_context):
             bank_id=bank_id,
             content="Charlie is a DevOps engineer who manages the Kubernetes infrastructure.",
             context="work info",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
+            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc)
         )
 
         await memory.wait_for_background_tasks()
@@ -484,7 +374,7 @@ async def test_observation_fact_type_in_database(memory, request_context):
 
 
 @pytest.mark.asyncio
-async def test_user_entity_prioritized_for_observations(memory, request_context):
+async def test_user_entity_prioritized_for_observations(memory):
     """
     Test that the 'user' entity gets observations even when many other entities exist.
 
@@ -520,8 +410,7 @@ async def test_user_entity_prioritized_for_observations(memory, request_context)
                 bank_id=bank_id,
                 content=content,
                 context="personal info",
-                event_date=datetime(2024, 1, 15 + i, tzinfo=timezone.utc),
-                request_context=request_context,
+                event_date=datetime(2024, 1, 15 + i, tzinfo=timezone.utc)
             )
 
         # Observations are generated synchronously during retain
@@ -577,7 +466,7 @@ async def test_user_entity_prioritized_for_observations(memory, request_context)
             f"User entity should have at least 5 facts, but has {user_fact_count}"
 
         # Get observations for user entity
-        observations = await memory.get_entity_observations(bank_id, user_entity_id, limit=10, request_context=request_context)
+        observations = await memory.get_entity_observations(bank_id, user_entity_id, limit=10)
 
         print(f"\n=== User Entity Observations ===")
         print(f"Total observations: {len(observations)}")

hindsight-api/tests/test_retain.py

@@ -5,13 +5,12 @@ import pytest
 import logging
 from datetime import datetime, timezone, timedelta
 from hindsight_api.engine.memory_engine import Budget
-from hindsight_api import RequestContext
 
 logger = logging.getLogger(__name__)
 
 
 @pytest.mark.asyncio
-async def test_retain_with_chunks(memory, request_context):
+async def test_retain_with_chunks(memory):
     """
     Test that retain function:
     1. Stores facts with associated chunks
@@ -42,8 +41,7 @@ async def test_retain_with_chunks(memory, request_context):
             content=long_content,
             context="team overview",
             event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         print(f"\n=== Retained {len(unit_ids)} facts ===")
@@ -58,8 +56,7 @@ async def test_retain_with_chunks(memory, request_context):
             fact_type=["world"],  # Search for world facts
             include_entities=False,  # Disable entities for simpler test
             include_chunks=True,  # Enable chunks
-            max_chunk_tokens=8192,
-            request_context=request_context,
+            max_chunk_tokens=8192
         )
 
         print(f"\n=== Recall Results (with chunks) ===")
@@ -91,12 +88,12 @@ async def test_retain_with_chunks(memory, request_context):
 
     finally:
         # Cleanup - delete the test bank
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
         print(f"\n=== Cleaned up bank: {bank_id} ===")
 
 
 @pytest.mark.asyncio
-async def test_chunks_and_entities_follow_fact_order(memory, request_context):
+async def test_chunks_and_entities_follow_fact_order(memory):
     """
     Test that chunks and entities in recall results follow the same order as facts.
     This is critical because token limits may truncate later items.
@@ -133,8 +130,7 @@ async def test_chunks_and_entities_follow_fact_order(memory, request_context):
                 content=item["content"],
                 context=item["context"],
                 event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-                document_id=item["document_id"],
-                request_context=request_context,
+                document_id=item["document_id"]
             )
 
         print("\n=== Stored 3 separate documents ===")
@@ -148,8 +144,7 @@ async def test_chunks_and_entities_follow_fact_order(memory, request_context):
             fact_type=["world"],
             include_entities=True,
             include_chunks=True,
-            max_chunk_tokens=8192,
-            request_context=request_context,
+            max_chunk_tokens=8192
         )
 
         print(f"\n=== Recall Results ===")
@@ -219,12 +214,12 @@ async def test_chunks_and_entities_follow_fact_order(memory, request_context):
 
     finally:
         # Cleanup
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
         print(f"\n=== Cleaned up bank: {bank_id} ===")
 
 
 @pytest.mark.asyncio
-async def test_event_date_storage(memory, request_context):
+async def test_event_date_storage(memory):
     """
     Test that event_date is correctly stored as occurred_start.
     Verifies that we can track when events actually happened vs when they were stored.
@@ -240,8 +235,7 @@ async def test_event_date_storage(memory, request_context):
             bank_id=bank_id,
             content="Alice completed the Q2 product launch on June 15th, 2023.",
             context="project history",
-            event_date=past_event_date,
-            request_context=request_context,
+            event_date=past_event_date
         )
 
         assert len(unit_ids) > 0, "Should have created at least one memory unit"
@@ -252,8 +246,7 @@ async def test_event_date_storage(memory, request_context):
             query="When did Alice complete the product launch?",
             budget=Budget.LOW,
             max_tokens=500,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) > 0, "Should recall the stored fact"
@@ -275,11 +268,11 @@ async def test_event_date_storage(memory, request_context):
         print(f"\n✓ Event date correctly stored: {occurred_dt}")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_temporal_ordering(memory, request_context):
+async def test_temporal_ordering(memory):
     """
     Test that facts can be stored and retrieved with correct temporal ordering.
     Stores facts with different event_dates and verifies temporal relationships.
@@ -312,8 +305,7 @@ async def test_temporal_ordering(memory, request_context):
                 bank_id=bank_id,
                 content=event["content"],
                 context=event["context"],
-                event_date=event["event_date"],
-                request_context=request_context,
+                event_date=event["event_date"]
             )
 
         print("\n=== Stored 3 events with different temporal dates ===")
@@ -324,8 +316,7 @@ async def test_temporal_ordering(memory, request_context):
             query="Tell me about Alice's career progression",
             budget=Budget.MID,
             max_tokens=1000,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) >= 3, f"Should recall all 3 events, got {len(result.results)}"
@@ -354,11 +345,11 @@ async def test_temporal_ordering(memory, request_context):
         print(f"\n✓ Temporal ordering preserved: {min_date.date()} to {max_date.date()}")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_mentioned_at_vs_occurred(memory, request_context):
+async def test_mentioned_at_vs_occurred(memory):
     """
     Test distinction between when fact occurred vs when it was mentioned.
 
@@ -378,8 +369,7 @@ async def test_mentioned_at_vs_occurred(memory, request_context):
             bank_id=bank_id,
             content="Alice graduated from MIT in March 2020.",
             context="education history",
-            event_date=conversation_date,  # When this conversation happened
-            request_context=request_context,
+            event_date=conversation_date  # When this conversation happened
         )
 
         assert len(unit_ids) > 0, "Should create memory unit"
@@ -390,8 +380,7 @@ async def test_mentioned_at_vs_occurred(memory, request_context):
             query="Where did Alice go to school?",
             budget=Budget.LOW,
             max_tokens=500,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) > 0, "Should recall the fact"
@@ -426,11 +415,11 @@ async def test_mentioned_at_vs_occurred(memory, request_context):
         print(f"✓ Test passed: Historical conversation correctly ingested with event_date=2020")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_occurred_dates_not_defaulted(memory, request_context):
+async def test_occurred_dates_not_defaulted(memory):
     """
     Test that occurred_start and occurred_end are NOT defaulted to mentioned_at.
 
@@ -452,8 +441,7 @@ async def test_occurred_dates_not_defaulted(memory, request_context):
             bank_id=bank_id,
             content="Alice likes coffee. The weather is sunny today.",
             context="current observations",
-            event_date=event_date,
-            request_context=request_context,
+            event_date=event_date
         )
 
         assert len(unit_ids) > 0, "Should create memory unit"
@@ -464,8 +452,7 @@ async def test_occurred_dates_not_defaulted(memory, request_context):
             query="What does Alice like?",
             budget=Budget.LOW,
             max_tokens=500,
-            fact_type=["world", "opinion"],
-            request_context=request_context,
+            fact_type=["world", "opinion"]
         )
 
         assert len(result.results) > 0, "Should recall the fact"
@@ -517,11 +504,11 @@ async def test_occurred_dates_not_defaulted(memory, request_context):
         print(f"✓ Test passed: occurred dates are not incorrectly defaulted to mentioned_at")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_mentioned_at_from_context_string(memory, request_context):
+async def test_mentioned_at_from_context_string(memory):
     """
     Test that mentioned_at is extracted from context string by LLM.
 
@@ -540,8 +527,7 @@ async def test_mentioned_at_from_context_string(memory, request_context):
             bank_id=bank_id,
             content="Alice mentioned she loves hiking in the mountains.",
             context=f"Session ABC123 - you are the assistant in this conversation - happened on {session_date.strftime('%Y-%m-%d %H:%M:%S')} UTC.",
-            event_date=None,  # Not providing event_date - should default to now() if LLM doesn't extract
-            request_context=request_context,
+            event_date=None  # Not providing event_date - should default to now() if LLM doesn't extract
         )
 
         assert len(unit_ids) > 0, "Should create memory unit"
@@ -552,8 +538,7 @@ async def test_mentioned_at_from_context_string(memory, request_context):
             query="What does Alice like?",
             budget=Budget.LOW,
             max_tokens=500,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) > 0, "Should recall the fact"
@@ -589,7 +574,7 @@ async def test_mentioned_at_from_context_string(memory, request_context):
         print(f"✓ mentioned_at is always set (never None)")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 # ============================================================
@@ -597,7 +582,7 @@ async def test_mentioned_at_from_context_string(memory, request_context):
 # ============================================================
 
 @pytest.mark.asyncio
-async def test_context_preservation(memory, request_context):
+async def test_context_preservation(memory):
     """
     Test that context is preserved and retrievable.
     Context helps understand why/how memory was formed.
@@ -612,8 +597,7 @@ async def test_context_preservation(memory, request_context):
             bank_id=bank_id,
             content="The team decided to prioritize mobile development for next quarter.",
             context=specific_context,
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
+            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc)
         )
 
         assert len(unit_ids) > 0, "Should create at least one memory unit"
@@ -624,8 +608,7 @@ async def test_context_preservation(memory, request_context):
             query="What did the team decide?",
             budget=Budget.LOW,
             max_tokens=500,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) > 0, "Should recall the stored fact"
@@ -637,11 +620,11 @@ async def test_context_preservation(memory, request_context):
         print(f"  Retrieved {len(result.results)} facts")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_context_with_batch(memory, request_context):
+async def test_context_with_batch(memory):
     """
     Test that each item in a batch can have different contexts.
     """
@@ -667,8 +650,7 @@ async def test_context_with_batch(memory, request_context):
                     "context": "incident response",
                     "event_date": datetime(2024, 1, 12, tzinfo=timezone.utc)
                 }
-            ],
-            request_context=request_context,
+            ]
         )
 
         # Should have created facts from all items
@@ -679,7 +661,7 @@ async def test_context_with_batch(memory, request_context):
         print(f"  Created {total_units} total memory units")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 # ============================================================
@@ -687,7 +669,7 @@ async def test_context_with_batch(memory, request_context):
 # ============================================================
 
 @pytest.mark.asyncio
-async def test_metadata_storage_and_retrieval(memory, request_context):
+async def test_metadata_storage_and_retrieval(memory):
     """
     Test that user-defined metadata is preserved.
     Metadata allows arbitrary key-value data to be stored with facts.
@@ -710,8 +692,7 @@ async def test_metadata_storage_and_retrieval(memory, request_context):
             bank_id=bank_id,
             content="The product launch is scheduled for March 1st.",
             context="planning meeting",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
+            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc)
         )
 
         assert len(unit_ids) > 0, "Should create memory units"
@@ -722,8 +703,7 @@ async def test_metadata_storage_and_retrieval(memory, request_context):
             query="When is the product launch?",
             budget=Budget.LOW,
             max_tokens=500,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) > 0, "Should recall stored facts"
@@ -732,7 +712,7 @@ async def test_metadata_storage_and_retrieval(memory, request_context):
         print(f"  (Note: Metadata support depends on API implementation)")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 # ============================================================
@@ -740,7 +720,7 @@ async def test_metadata_storage_and_retrieval(memory, request_context):
 # ============================================================
 
 @pytest.mark.asyncio
-async def test_empty_batch(memory, request_context):
+async def test_empty_batch(memory):
     """
     Test that empty batch is handled gracefully without errors.
     """
@@ -750,8 +730,7 @@ async def test_empty_batch(memory, request_context):
         # Attempt to store empty batch
         unit_ids = await memory.retain_batch_async(
             bank_id=bank_id,
-            contents=[],
-            request_context=request_context,
+            contents=[]
         )
 
         # Should return empty list or handle gracefully
@@ -762,11 +741,11 @@ async def test_empty_batch(memory, request_context):
 
     finally:
         # Clean up (though nothing should be stored)
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_single_item_batch(memory, request_context):
+async def test_single_item_batch(memory):
     """
     Test that batch with one item works correctly.
     """
@@ -782,8 +761,7 @@ async def test_single_item_batch(memory, request_context):
                     "context": "deployment log",
                     "event_date": datetime(2024, 1, 15, tzinfo=timezone.utc)
                 }
-            ],
-            request_context=request_context,
+            ]
         )
 
         assert len(unit_ids) == 1, "Should return one list of unit IDs"
@@ -792,11 +770,11 @@ async def test_single_item_batch(memory, request_context):
         print(f"✓ Single-item batch created {len(unit_ids[0])} units")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_mixed_content_batch(memory, request_context):
+async def test_mixed_content_batch(memory):
     """
     Test batch with varying content sizes (short and long).
     """
@@ -820,8 +798,7 @@ async def test_mixed_content_batch(memory, request_context):
                 {"content": short_content, "context": "onboarding"},
                 {"content": long_content, "context": "performance review"},
                 {"content": "Charlie is on vacation this week.", "context": "team status"}
-            ],
-            request_context=request_context,
+            ]
         )
 
         # All items should be processed
@@ -836,11 +813,11 @@ async def test_mixed_content_batch(memory, request_context):
         print(f"  Long content: {long_units} units")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_batch_with_missing_optional_fields(memory, request_context):
+async def test_batch_with_missing_optional_fields(memory):
     """
     Test that batch handles items with missing optional fields.
     """
@@ -865,8 +842,7 @@ async def test_batch_with_missing_optional_fields(memory, request_context):
                     "context": "code review",
                     # No event_date
                 }
-            ],
-            request_context=request_context,
+            ]
         )
 
         # All items should be processed successfully
@@ -876,7 +852,7 @@ async def test_batch_with_missing_optional_fields(memory, request_context):
         print(f"✓ Batch with mixed optional fields created {total_units} total units")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 # ============================================================
@@ -884,7 +860,7 @@ async def test_batch_with_missing_optional_fields(memory, request_context):
 # ============================================================
 
 @pytest.mark.asyncio
-async def test_single_batch_multiple_documents(memory, request_context):
+async def test_single_batch_multiple_documents(memory):
     """
     Test storing multiple distinct documents in a single batch call.
     Each should be tracked separately.
@@ -900,24 +876,21 @@ async def test_single_batch_multiple_documents(memory, request_context):
             bank_id=bank_id,
             content="Alice's resume: 10 years Python experience, worked at Google.",
             context="resume review",
-            document_id="resume_alice",
-            request_context=request_context,
+            document_id="resume_alice"
         )
 
         doc2_units = await memory.retain_async(
             bank_id=bank_id,
             content="Bob's resume: 5 years JavaScript experience, worked at Meta.",
             context="resume review",
-            document_id="resume_bob",
-            request_context=request_context,
+            document_id="resume_bob"
         )
 
         doc3_units = await memory.retain_async(
             bank_id=bank_id,
             content="Charlie's resume: 8 years Go experience, worked at Amazon.",
             context="resume review",
-            document_id="resume_charlie",
-            request_context=request_context,
+            document_id="resume_charlie"
         )
 
         # All documents should be stored
@@ -934,18 +907,17 @@ async def test_single_batch_multiple_documents(memory, request_context):
             query="Who worked at Google?",
             budget=Budget.MID,
             max_tokens=1000,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) > 0, "Should find facts about Alice"
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_document_upsert_behavior(memory, request_context):
+async def test_document_upsert_behavior(memory):
     """
     Test that upserting a document replaces the old content.
     """
@@ -958,8 +930,7 @@ async def test_document_upsert_behavior(memory, request_context):
             bank_id=bank_id,
             content="Project is in planning phase. Alice is the lead.",
             context="status update v1",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         assert len(v1_units) > 0, "Should create units for v1"
@@ -969,8 +940,7 @@ async def test_document_upsert_behavior(memory, request_context):
             bank_id=bank_id,
             content="Project is in development phase. Bob has joined as co-lead.",
             context="status update v2",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         assert len(v2_units) > 0, "Should create units for v2"
@@ -981,8 +951,7 @@ async def test_document_upsert_behavior(memory, request_context):
             query="What is the project status?",
             budget=Budget.MID,
             max_tokens=1000,
-            fact_type=["world"],
-            request_context=request_context,
+            fact_type=["world"]
         )
 
         assert len(result.results) > 0, "Should recall facts"
@@ -990,7 +959,7 @@ async def test_document_upsert_behavior(memory, request_context):
         print(f"✓ Document upsert created v1: {len(v1_units)} units, v2: {len(v2_units)} units")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 # ============================================================
@@ -998,7 +967,7 @@ async def test_document_upsert_behavior(memory, request_context):
 # ============================================================
 
 @pytest.mark.asyncio
-async def test_chunk_fact_mapping(memory, request_context):
+async def test_chunk_fact_mapping(memory):
     """
     Test that facts correctly reference their source chunks via chunk_id.
     """
@@ -1021,8 +990,7 @@ async def test_chunk_fact_mapping(memory, request_context):
             bank_id=bank_id,
             content=content,
             context="technical documentation",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         assert len(unit_ids) > 0, "Should create memory units"
@@ -1035,8 +1003,7 @@ async def test_chunk_fact_mapping(memory, request_context):
             max_tokens=1000,
             fact_type=["world"],
             include_chunks=True,
-            max_chunk_tokens=8192,
-            request_context=request_context,
+            max_chunk_tokens=8192
         )
 
         assert len(result.results) > 0, "Should recall facts"
@@ -1059,11 +1026,11 @@ async def test_chunk_fact_mapping(memory, request_context):
             print(f"  Returned {len(result.chunks)} chunks matching fact references")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_chunk_ordering_preservation(memory, request_context):
+async def test_chunk_ordering_preservation(memory):
     """
     Test that chunk_index reflects the correct order within a document.
     """
@@ -1103,8 +1070,7 @@ async def test_chunk_ordering_preservation(memory, request_context):
             bank_id=bank_id,
             content=content,
             context="multi-section document",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         assert len(unit_ids) > 0, "Should create units"
@@ -1117,8 +1083,7 @@ async def test_chunk_ordering_preservation(memory, request_context):
             max_tokens=2000,
             fact_type=["world"],
             include_chunks=True,
-            max_chunk_tokens=8192,
-            request_context=request_context,
+            max_chunk_tokens=8192
         )
 
         if result.chunks:
@@ -1138,11 +1103,11 @@ async def test_chunk_ordering_preservation(memory, request_context):
             print("✓ Content stored (may have created single chunk or no chunks returned)")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_chunks_truncation_behavior(memory, request_context):
+async def test_chunks_truncation_behavior(memory):
     """
     Test that when chunks exceed max_chunk_tokens, truncation is indicated.
     """
@@ -1200,8 +1165,7 @@ async def test_chunks_truncation_behavior(memory, request_context):
             bank_id=bank_id,
             content=large_content,
             context="large document test",
-            document_id=document_id,
-            request_context=request_context,
+            document_id=document_id
         )
 
         assert len(unit_ids) > 0, "Should create units"
@@ -1214,8 +1178,7 @@ async def test_chunks_truncation_behavior(memory, request_context):
             max_tokens=1000,
             fact_type=["world"],
             include_chunks=True,
-            max_chunk_tokens=500,  # Small limit to test truncation
-            request_context=request_context,
+            max_chunk_tokens=500  # Small limit to test truncation
         )
 
         if result.chunks:
@@ -1235,7 +1198,7 @@ async def test_chunks_truncation_behavior(memory, request_context):
             print("✓ No chunks returned (may be under token limit)")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 # ============================================================
@@ -1243,7 +1206,7 @@ async def test_chunks_truncation_behavior(memory, request_context):
 # ============================================================
 
 @pytest.mark.asyncio
-async def test_temporal_links_creation(memory, request_context):
+async def test_temporal_links_creation(memory):
     """
     Test that temporal links are created between facts with nearby event dates.
 
@@ -1260,8 +1223,7 @@ async def test_temporal_links_creation(memory, request_context):
             bank_id=bank_id,
             content="Alice started working on the authentication module.",
             context="daily standup",
-            event_date=base_date,
-            request_context=request_context,
+            event_date=base_date
         )
 
         # Fact 2 at 2:00 PM same day (4 hours later)
@@ -1269,8 +1231,7 @@ async def test_temporal_links_creation(memory, request_context):
             bank_id=bank_id,
             content="Bob reviewed the API design document.",
             context="daily standup",
-            event_date=base_date.replace(hour=14),
-            request_context=request_context,
+            event_date=base_date.replace(hour=14)
         )
 
         # Fact 3 at 9:00 AM next day (23 hours later)
@@ -1278,8 +1239,7 @@ async def test_temporal_links_creation(memory, request_context):
             bank_id=bank_id,
             content="Charlie deployed the new database schema.",
             context="daily standup",
-            event_date=base_date.replace(day=16, hour=9),
-            request_context=request_context,
+            event_date=base_date.replace(day=16, hour=9)
         )
 
         assert len(unit_ids_1) > 0 and len(unit_ids_2) > 0 and len(unit_ids_3) > 0
@@ -1318,11 +1278,11 @@ async def test_temporal_links_creation(memory, request_context):
             logger.info("Temporal links created successfully with proper weights")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_semantic_links_creation(memory, request_context):
+async def test_semantic_links_creation(memory):
     """
     Test that semantic links are created between facts with similar content.
 
@@ -1335,24 +1295,21 @@ async def test_semantic_links_creation(memory, request_context):
         unit_ids_1 = await memory.retain_async(
             bank_id=bank_id,
             content="Alice is an expert in Python programming and has built many web applications.",
-            context="team skills",
-            request_context=request_context,
+            context="team skills"
         )
 
         # Similar content - should create semantic link
         unit_ids_2 = await memory.retain_async(
             bank_id=bank_id,
             content="Bob is proficient in Python development and specializes in building APIs.",
-            context="team skills",
-            request_context=request_context,
+            context="team skills"
         )
 
         # Different content - less likely to create strong semantic link
         unit_ids_3 = await memory.retain_async(
             bank_id=bank_id,
             content="The quarterly sales meeting is scheduled for next Tuesday at 3 PM.",
-            context="calendar events",
-            request_context=request_context,
+            context="calendar events"
         )
 
         assert len(unit_ids_1) > 0 and len(unit_ids_2) > 0 and len(unit_ids_3) > 0
@@ -1392,11 +1349,11 @@ async def test_semantic_links_creation(memory, request_context):
             logger.info("Semantic links created successfully between similar content")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_entity_links_creation(memory, request_context):
+async def test_entity_links_creation(memory):
     """
     Test that entity links are created between facts that mention the same entities.
 
@@ -1410,32 +1367,28 @@ async def test_entity_links_creation(memory, request_context):
         unit_ids_1 = await memory.retain_async(
             bank_id=bank_id,
             content="Alice joined Google as a software engineer in 2020.",
-            context="career history",
-            request_context=request_context,
+            context="career history"
         )
 
         # Mentions same entity (Alice) - should create entity link
         unit_ids_2 = await memory.retain_async(
             bank_id=bank_id,
             content="Alice led the development of the new authentication system.",
-            context="project updates",
-            request_context=request_context,
+            context="project updates"
         )
 
         # Mentions same entity (Google) - should create entity link
         unit_ids_3 = await memory.retain_async(
             bank_id=bank_id,
             content="Google announced new cloud services at their annual conference.",
-            context="tech news",
-            request_context=request_context,
+            context="tech news"
         )
 
         # Different entities - no entity link expected
         unit_ids_4 = await memory.retain_async(
             bank_id=bank_id,
             content="Bob works at Meta on machine learning infrastructure.",
-            context="career history",
-            request_context=request_context,
+            context="career history"
         )
 
         assert len(unit_ids_1) > 0 and len(unit_ids_2) > 0 and len(unit_ids_3) > 0 and len(unit_ids_4) > 0
@@ -1492,11 +1445,11 @@ async def test_entity_links_creation(memory, request_context):
             logger.info("Entity links are properly bidirectional")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_causal_links_creation(memory, request_context):
+async def test_causal_links_creation(memory):
     """
     Test that causal links are created between facts with causal relationships.
 
@@ -1518,8 +1471,7 @@ async def test_causal_links_creation(memory, request_context):
         unit_ids = await memory.retain_async(
             bank_id=bank_id,
             content=content,
-            context="project timeline",
-            request_context=request_context,
+            context="project timeline"
         )
 
         assert len(unit_ids) > 0, "Should have created facts"
@@ -1565,11 +1517,11 @@ async def test_causal_links_creation(memory, request_context):
         logger.info("Test completed (causal link extraction is LLM-dependent)")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_all_link_types_together(memory, request_context):
+async def test_all_link_types_together(memory):
     """
     Integration test: Verify all link types can be created in a single retain operation.
 
@@ -1587,8 +1539,7 @@ async def test_all_link_types_together(memory, request_context):
             bank_id=bank_id,
             content="Alice completed the Python backend service for the authentication system.",
             context="sprint review",
-            event_date=base_date,
-            request_context=request_context,
+            event_date=base_date
         )
 
         # Fact 2: Related to Alice, similar topic (Python), close in time
@@ -1596,8 +1547,7 @@ async def test_all_link_types_together(memory, request_context):
             bank_id=bank_id,
             content="Alice optimized the Python code and improved the authentication performance by 40%.",
             context="sprint review",
-            event_date=base_date.replace(hour=14),  # Same day, 4 hours later
-            request_context=request_context,
+            event_date=base_date.replace(hour=14)  # Same day, 4 hours later
         )
 
         # Fact 3: Related to Alice, different topic but same entity
@@ -1605,8 +1555,7 @@ async def test_all_link_types_together(memory, request_context):
             bank_id=bank_id,
             content="Alice presented the security architecture at the team meeting.",
             context="team meeting",
-            event_date=base_date.replace(day=16),  # Next day
-            request_context=request_context,
+            event_date=base_date.replace(day=16)  # Next day
         )
 
         assert len(unit_ids_1) > 0 and len(unit_ids_2) > 0 and len(unit_ids_3) > 0
@@ -1645,11 +1594,11 @@ async def test_all_link_types_together(memory, request_context):
             logger.info("All major link types (temporal, semantic, entity) are working correctly")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_semantic_links_within_same_batch(memory, request_context):
+async def test_semantic_links_within_same_batch(memory):
     """
     Test that semantic links are created between facts retained in the SAME batch.
 
@@ -1668,8 +1617,7 @@ async def test_semantic_links_within_same_batch(memory, request_context):
 
         result = await memory.retain_batch_async(
             bank_id=bank_id,
-            contents=contents,
-            request_context=request_context,
+            contents=contents
         )
 
         # Flatten the list of lists
@@ -1704,11 +1652,11 @@ async def test_semantic_links_within_same_batch(memory, request_context):
                 logger.info(f"  Semantic link: {str(link['from_unit_id'])[:8]}... -> {str(link['to_unit_id'])[:8]}... (weight: {link['weight']:.3f})")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_temporal_links_within_same_batch(memory, request_context):
+async def test_temporal_links_within_same_batch(memory):
     """
     Test that temporal links are created between facts retained in the SAME batch.
 
@@ -1741,8 +1689,7 @@ async def test_temporal_links_within_same_batch(memory, request_context):
 
         result = await memory.retain_batch_async(
             bank_id=bank_id,
-            contents=contents,
-            request_context=request_context,
+            contents=contents
         )
 
         # Flatten the list of lists
@@ -1777,4 +1724,4 @@ async def test_temporal_links_within_same_batch(memory, request_context):
                 logger.info(f"  Temporal link: {str(link['from_unit_id'])[:8]}... -> {str(link['to_unit_id'])[:8]}... (weight: {link['weight']:.3f})")
 
     finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)

hindsight-api/tests/test_schema_isolation.py

@@ -1,406 +0,0 @@
-"""
-Tests for multi-tenant schema isolation.
-
-Verifies that concurrent retain operations from different tenants
-are properly isolated in their respective PostgreSQL schemas.
-"""
-
-import asyncio
-import uuid
-
-import pytest
-import pytest_asyncio
-
-from hindsight_api.extensions import RequestContext, TenantContext, TenantExtension
-from hindsight_api.engine.memory_engine import _current_schema, fq_table
-from hindsight_api.migrations import run_migrations
-
-
-class MultiSchemaTestTenantExtension(TenantExtension):
-    """
-    Test tenant extension that maps API keys to schema names.
-
-    API keys are in format: "key-{schema_name}"
-    Provisions schemas on first access using run_migrations(schema=name).
-    """
-
-    def __init__(self, config: dict):
-        super().__init__(config)
-        self.db_url = config.get("db_url")
-        # Pre-configured valid schemas for test
-        self.valid_schemas = config.get("valid_schemas", set())
-        # Track provisioned schemas
-        self._provisioned: set[str] = set()
-
-    async def authenticate(self, context: RequestContext) -> TenantContext:
-        if not context.api_key:
-            from hindsight_api.extensions import AuthenticationError
-
-            raise AuthenticationError("API key required")
-
-        # Parse schema from API key (format: "key-{schema}")
-        if context.api_key.startswith("key-"):
-            schema = context.api_key[4:]  # Remove "key-" prefix
-            if schema in self.valid_schemas:
-                # Provision schema on first access
-                if schema not in self._provisioned and self.db_url:
-                    run_migrations(self.db_url, schema=schema)
-                    self._provisioned.add(schema)
-                return TenantContext(schema_name=schema)
-
-        from hindsight_api.extensions import AuthenticationError
-
-        raise AuthenticationError(f"Unknown API key: {context.api_key}")
-
-
-async def drop_schema(conn, schema_name: str) -> None:
-    """Drop a schema and all its contents."""
-    await conn.execute(f'DROP SCHEMA IF EXISTS "{schema_name}" CASCADE')
-
-
-async def count_memories_in_schema(conn, schema_name: str, bank_id: str) -> int:
-    """Count memory units in a specific schema for a bank."""
-    result = await conn.fetchval(
-        f'SELECT COUNT(*) FROM "{schema_name}".memory_units WHERE bank_id = $1',
-        bank_id,
-    )
-    return result or 0
-
-
-async def get_memory_texts_in_schema(conn, schema_name: str, bank_id: str) -> list[str]:
-    """Get all memory texts in a specific schema for a bank."""
-    rows = await conn.fetch(
-        f'SELECT text FROM "{schema_name}".memory_units WHERE bank_id = $1 ORDER BY text',
-        bank_id,
-    )
-    return [row["text"] for row in rows]
-
-
-class TestSchemaIsolation:
-    """Tests for multi-tenant schema isolation."""
-
-    @pytest.mark.asyncio
-    async def test_concurrent_inserts_isolated_by_schema(self, memory, pg0_db_url):
-        """
-        Multiple concurrent database operations from different tenants
-        should store data in their respective schemas without cross-contamination.
-
-        Uses run_migrations(schema=x) to provision schemas like a real extension.
-        """
-        import asyncpg
-
-        # Test schemas
-        schemas = ["tenant_alpha", "tenant_beta", "tenant_gamma"]
-        bank_id = f"test-isolation-{uuid.uuid4().hex[:8]}"
-
-        # Clean up any existing schemas
-        conn = await asyncpg.connect(pg0_db_url)
-        try:
-            for schema in schemas:
-                await drop_schema(conn, schema)
-        finally:
-            await conn.close()
-
-        # Configure tenant extension that provisions schemas via run_migrations
-        tenant_ext = MultiSchemaTestTenantExtension({
-            "db_url": pg0_db_url,
-            "valid_schemas": set(schemas),
-        })
-        memory._tenant_extension = tenant_ext
-
-        # Define concurrent insert tasks for each tenant
-        async def insert_for_tenant(schema_name: str, content_prefix: str):
-            """Insert memories for a specific tenant using schema context."""
-            # Authenticate to set the schema context
-            tenant_request = RequestContext(api_key=f"key-{schema_name}")
-            await memory._authenticate_tenant(tenant_request)
-
-            # Now fq_table will use the correct schema
-            pool = await memory._get_pool()
-            from hindsight_api.engine.db_utils import acquire_with_retry
-
-            async with acquire_with_retry(pool) as conn:
-                # Insert 3 memories for this tenant
-                for i in range(3):
-                    await conn.execute(
-                        f"""
-                        INSERT INTO {fq_table('memory_units')} (bank_id, text, event_date, fact_type)
-                        VALUES ($1, $2, now(), 'world')
-                        """,
-                        bank_id,
-                        f"MARKER_{content_prefix}_DOC{i}: Memory for {schema_name}",
-                    )
-
-        # Run concurrent inserts for all tenants
-        await asyncio.gather(
-            insert_for_tenant("tenant_alpha", "ALPHA"),
-            insert_for_tenant("tenant_beta", "BETA"),
-            insert_for_tenant("tenant_gamma", "GAMMA"),
-        )
-
-        # Verify isolation - each schema should only have its own data
-        conn = await asyncpg.connect(pg0_db_url)
-        try:
-            for schema in schemas:
-                texts = await get_memory_texts_in_schema(conn, schema, bank_id)
-                prefix = schema.replace("tenant_", "").upper()
-
-                # Should have exactly 3 memories
-                assert len(texts) == 3, f"Schema {schema} should have 3 memories, got {len(texts)}"
-
-                # All texts should contain the schema's marker
-                for text in texts:
-                    assert f"MARKER_{prefix}" in text, (
-                        f"Memory in {schema} missing its marker: {text}"
-                    )
-
-                # Should NOT contain other tenants' markers
-                other_prefixes = ["ALPHA", "BETA", "GAMMA"]
-                other_prefixes.remove(prefix)
-                for other in other_prefixes:
-                    for text in texts:
-                        assert f"MARKER_{other}" not in text, (
-                            f"Cross-contamination! Schema {schema} has {other}'s marker: {text}"
-                        )
-
-        finally:
-            # Cleanup
-            for schema in schemas:
-                await drop_schema(conn, schema)
-            await conn.close()
-
-        # Reset tenant extension
-        memory._tenant_extension = None
-        _current_schema.set("public")
-
-    @pytest.mark.asyncio
-    async def test_schema_context_isolation_in_concurrent_tasks(self, pg0_db_url):
-        """
-        Verify that _current_schema contextvar is properly isolated
-        between concurrent async tasks.
-        """
-        results = {}
-        errors = []
-
-        async def check_schema_context(schema_name: str, delay: float):
-            """Set schema context, wait, then verify it's still correct."""
-            try:
-                # Set the schema
-                _current_schema.set(schema_name)
-
-                # Small delay to allow interleaving
-                await asyncio.sleep(delay)
-
-                # Verify schema is still correct
-                current = _current_schema.get()
-                if current != schema_name:
-                    errors.append(f"Expected {schema_name}, got {current}")
-
-                # Verify fq_table uses correct schema
-                table = fq_table("memory_units")
-                expected = f"{schema_name}.memory_units"
-                if table != expected:
-                    errors.append(f"Expected {expected}, got {table}")
-
-                results[schema_name] = current
-
-            except Exception as e:
-                errors.append(f"Error in {schema_name}: {e}")
-
-        # Run many concurrent tasks with different schemas
-        tasks = []
-        for i in range(10):
-            for schema in ["schema_a", "schema_b", "schema_c"]:
-                # Vary delays to create interleaving
-                delay = 0.01 * (i % 3)
-                tasks.append(check_schema_context(f"{schema}_{i}", delay))
-
-        await asyncio.gather(*tasks)
-
-        # No errors should have occurred
-        assert not errors, f"Schema context isolation errors: {errors}"
-
-    @pytest.mark.asyncio
-    async def test_list_memories_respects_schema(self, memory, pg0_db_url):
-        """
-        list_memory_units should only return memories from the current schema.
-
-        Uses run_migrations(schema=x) to provision schemas.
-        """
-        import asyncpg
-
-        schemas = ["tenant_list_a", "tenant_list_b"]
-        bank_id = f"test-list-{uuid.uuid4().hex[:8]}"
-
-        # Clean up any existing schemas and provision via migrations
-        conn = await asyncpg.connect(pg0_db_url)
-        try:
-            for schema in schemas:
-                await drop_schema(conn, schema)
-        finally:
-            await conn.close()
-
-        # Provision schemas using run_migrations
-        for schema in schemas:
-            run_migrations(pg0_db_url, schema=schema)
-
-        # Insert test data directly into each schema
-        conn = await asyncpg.connect(pg0_db_url)
-        try:
-            for schema in schemas:
-                await conn.execute(
-                    f"""
-                    INSERT INTO "{schema}".memory_units (bank_id, text, event_date, fact_type)
-                    VALUES ($1, $2, now(), 'world')
-                    """,
-                    bank_id,
-                    f"Direct insert for {schema}",
-                )
-        finally:
-            await conn.close()
-
-        # Configure tenant extension
-        tenant_ext = MultiSchemaTestTenantExtension({
-            "db_url": pg0_db_url,
-            "valid_schemas": set(schemas),
-        })
-        memory._tenant_extension = tenant_ext
-
-        try:
-            # Query as tenant_list_a - should only see tenant_list_a's data
-            tenant_a_request = RequestContext(api_key="key-tenant_list_a")
-            await memory._authenticate_tenant(tenant_a_request)
-
-            result_a = await memory.list_memory_units(bank_id=bank_id, request_context=tenant_a_request)
-            texts_a = [item["text"] for item in result_a.get("items", [])]
-
-            assert len(texts_a) == 1, f"Expected 1 memory for tenant_list_a, got {len(texts_a)}"
-            assert "tenant_list_a" in texts_a[0], f"Wrong content: {texts_a[0]}"
-
-            # Query as tenant_list_b - should only see tenant_list_b's data
-            tenant_b_request = RequestContext(api_key="key-tenant_list_b")
-            await memory._authenticate_tenant(tenant_b_request)
-
-            result_b = await memory.list_memory_units(bank_id=bank_id, request_context=tenant_b_request)
-            texts_b = [item["text"] for item in result_b.get("items", [])]
-
-            assert len(texts_b) == 1, f"Expected 1 memory for tenant_list_b, got {len(texts_b)}"
-            assert "tenant_list_b" in texts_b[0], f"Wrong content: {texts_b[0]}"
-
-        finally:
-            # Cleanup
-            conn = await asyncpg.connect(pg0_db_url)
-            try:
-                for schema in schemas:
-                    await drop_schema(conn, schema)
-            finally:
-                await conn.close()
-
-            memory._tenant_extension = None
-            _current_schema.set("public")
-
-    @pytest.mark.asyncio
-    async def test_high_concurrency_schema_isolation(self, memory, pg0_db_url):
-        """
-        Stress test: Many concurrent operations across multiple schemas
-        should maintain perfect isolation.
-
-        Uses run_migrations(schema=x) to provision schemas like a real extension.
-        """
-        import asyncpg
-
-        # Create more schemas for stress test
-        num_schemas = 5
-        ops_per_schema = 10
-        schemas = [f"stress_tenant_{i}" for i in range(num_schemas)]
-        bank_id = f"test-stress-{uuid.uuid4().hex[:8]}"
-
-        # Clean up any existing schemas first
-        conn = await asyncpg.connect(pg0_db_url)
-        try:
-            for schema in schemas:
-                await drop_schema(conn, schema)
-        finally:
-            await conn.close()
-
-        # Provision schemas using run_migrations
-        for schema in schemas:
-            run_migrations(pg0_db_url, schema=schema)
-
-        # Configure tenant extension (schemas already provisioned)
-        tenant_ext = MultiSchemaTestTenantExtension({
-            "db_url": pg0_db_url,
-            "valid_schemas": set(schemas),
-        })
-        # Mark schemas as already provisioned so extension doesn't re-run migrations
-        tenant_ext._provisioned = set(schemas)
-        memory._tenant_extension = tenant_ext
-
-        errors = []
-
-        async def insert_one(schema: str, item_id: int):
-            """Single insert operation for tracking."""
-            try:
-                # Authenticate to set the schema context
-                tenant_request = RequestContext(api_key=f"key-{schema}")
-                await memory._authenticate_tenant(tenant_request)
-
-                # Insert using fq_table
-                pool = await memory._get_pool()
-                from hindsight_api.engine.db_utils import acquire_with_retry
-
-                async with acquire_with_retry(pool) as conn:
-                    await conn.execute(
-                        f"""
-                        INSERT INTO {fq_table('memory_units')} (bank_id, text, event_date, fact_type)
-                        VALUES ($1, $2, now(), 'world')
-                        """,
-                        bank_id,
-                        f"STRESS_MARKER_{schema}_ITEM{item_id}: Memory for {schema}",
-                    )
-            except Exception as e:
-                errors.append(f"Insert error for {schema}: {e}")
-
-        # Run many concurrent operations
-        tasks = []
-        for i in range(ops_per_schema):
-            for schema in schemas:
-                tasks.append(insert_one(schema, i))
-
-        await asyncio.gather(*tasks)
-
-        # Check for errors during insert
-        assert not errors, f"Errors during insert: {errors}"
-
-        # Verify no cross-contamination
-        conn = await asyncpg.connect(pg0_db_url)
-        try:
-            for schema in schemas:
-                texts = await get_memory_texts_in_schema(conn, schema, bank_id)
-
-                # Should have exactly ops_per_schema memories
-                assert len(texts) == ops_per_schema, (
-                    f"Schema {schema} should have {ops_per_schema} memories, got {len(texts)}"
-                )
-
-                # All memories should reference this schema only
-                for text in texts:
-                    # Check it contains our schema marker
-                    assert f"STRESS_MARKER_{schema}" in text, (
-                        f"Memory in {schema} doesn't contain schema marker: {text}"
-                    )
-
-                    # Check it doesn't contain other schema markers
-                    for other_schema in schemas:
-                        if other_schema != schema:
-                            assert f"STRESS_MARKER_{other_schema}" not in text, (
-                                f"Cross-contamination! {schema} has {other_schema}'s data: {text}"
-                            )
-        finally:
-            # Cleanup
-            for schema in schemas:
-                await drop_schema(conn, schema)
-            await conn.close()
-
-        memory._tenant_extension = None
-        _current_schema.set("public")

hindsight-api/tests/test_search_trace.py

@@ -3,12 +3,12 @@ Test search tracing functionality.
 """
 import pytest
 from hindsight_api.engine.memory_engine import Budget
-from hindsight_api import SearchTrace, RequestContext
+from hindsight_api import SearchTrace
 from datetime import datetime, timezone
 
 
 @pytest.mark.asyncio
-async def test_search_with_trace(memory, request_context):
+async def test_search_with_trace(memory):
     """Test that search with enable_trace=True returns a valid SearchTrace."""
     # Generate a unique agent ID for this test
     bank_id = f"test_trace_{datetime.now(timezone.utc).timestamp()}"
@@ -20,19 +20,16 @@ async def test_search_with_trace(memory, request_context):
             bank_id=bank_id,
             content="Alice works at Google in Mountain View",
             context="test context",
-            request_context=request_context,
         )
         await memory.retain_async(
             bank_id=bank_id,
             content="Bob also works at Google but in New York",
             context="test context",
-            request_context=request_context,
         )
         await memory.retain_async(
             bank_id=bank_id,
             content="Charlie founded a startup called TechCorp",
             context="test context",
-            request_context=request_context,
         )
 
         # Search with tracing enabled
@@ -43,7 +40,6 @@ async def test_search_with_trace(memory, request_context):
             budget=Budget.LOW, # 20,
             max_tokens=512,
             enable_trace=True,
-            request_context=request_context,
         )
 
         # Verify results
@@ -106,11 +102,11 @@ async def test_search_with_trace(memory, request_context):
 
     finally:
         # Cleanup
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
 
 
 @pytest.mark.asyncio
-async def test_search_without_trace(memory, request_context):
+async def test_search_without_trace(memory):
     """Test that search with enable_trace=False returns None for trace."""
     bank_id = f"test_no_trace_{datetime.now(timezone.utc).timestamp()}"
 
@@ -121,7 +117,6 @@ async def test_search_without_trace(memory, request_context):
             bank_id=bank_id,
             content="Test memory without trace",
             context="test",
-            request_context=request_context,
         )
 
         # Search without tracing
@@ -132,7 +127,6 @@ async def test_search_without_trace(memory, request_context):
             budget=Budget.LOW, # 10,
             max_tokens=512,
             enable_trace=False,
-            request_context=request_context,
         )
 
         # Verify trace is None
@@ -143,4 +137,4 @@ async def test_search_without_trace(memory, request_context):
 
     finally:
         # Cleanup
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)

hindsight-api/tests/test_sql_schema_safety.py

@@ -1,136 +0,0 @@
-"""
-Safety tests to ensure all SQL queries use fully-qualified table names.
-
-This prevents cross-tenant data access by ensuring every table reference
-includes the schema prefix (e.g., public.memory_units instead of just memory_units).
-"""
-
-import re
-from pathlib import Path
-
-import pytest
-
-# All tables that MUST be schema-qualified in SQL queries
-TABLES = [
-    "memory_units",
-    "memory_links",
-    "unit_entities",
-    "entities",
-    "entity_cooccurrences",
-    "banks",
-    "documents",
-    "chunks",
-    "async_operations",
-]
-
-# Files to scan for SQL queries
-SCAN_PATHS = [
-    "hindsight_api/engine",
-    "hindsight_api/api",
-]
-
-# Files to exclude (e.g., migrations, tests)
-EXCLUDE_PATTERNS = [
-    "alembic",
-    "__pycache__",
-    "test_",
-]
-
-
-def get_python_files() -> list[Path]:
-    """Get all Python files to scan."""
-    root = Path(__file__).parent.parent
-    files = []
-    for scan_path in SCAN_PATHS:
-        path = root / scan_path
-        if path.exists():
-            for py_file in path.rglob("*.py"):
-                # Check exclusions
-                if any(excl in str(py_file) for excl in EXCLUDE_PATTERNS):
-                    continue
-                files.append(py_file)
-    return files
-
-
-def find_unqualified_table_refs(content: str, filename: str) -> list[tuple[int, str, str]]:
-    """
-    Find SQL statements with unqualified table references.
-
-    Returns list of (line_number, table_name, line_content).
-    """
-    violations = []
-
-    # Patterns that indicate SQL context
-    sql_keywords = r"(?:FROM|JOIN|INTO|UPDATE|DELETE\s+FROM)\s+"
-
-    # Additional SQL indicators to confirm this is actually SQL, not prose
-    sql_indicators = re.compile(
-        r"(SELECT|INSERT|DELETE|UPDATE|CREATE|ALTER|DROP|WHERE|SET|VALUES|"
-        r'f"""|f\'\'\'|""".*SELECT|\'\'\'.*SELECT)',
-        re.IGNORECASE,
-    )
-
-    lines = content.split("\n")
-    for line_num, line in enumerate(lines, 1):
-        # Skip comments and strings that are clearly not SQL
-        stripped = line.strip()
-        if stripped.startswith("#"):
-            continue
-
-        for table in TABLES:
-            # Pattern: SQL keyword followed by unqualified table name
-            # Should match: FROM memory_units, JOIN memory_units, INTO memory_units
-            # Should NOT match: FROM public.memory_units, FROM {schema}.memory_units
-            # Should NOT match: fq_table("memory_units")
-
-            # Check for unqualified table after SQL keyword
-            pattern = rf"{sql_keywords}{table}(?:\s|$|,|\))"
-
-            if re.search(pattern, line, re.IGNORECASE):
-                # Check if it's actually qualified (has schema prefix)
-                qualified_pattern = rf"\.\s*{table}(?:\s|$|,|\))"
-                fq_table_pattern = rf'fq_table\s*\(\s*["\']?{table}'
-
-                if not re.search(qualified_pattern, line) and not re.search(
-                    fq_table_pattern, line
-                ):
-                    # Additional check: line must have SQL indicators
-                    # This avoids false positives in docstrings like "split into chunks"
-                    if sql_indicators.search(line):
-                        violations.append((line_num, table, stripped))
-
-    return violations
-
-
-class TestSQLSchemaSafety:
-    """Ensure all SQL uses schema-qualified table names."""
-
-    def test_no_unqualified_table_references(self):
-        """All SQL queries must use fq_table() or schema.table format."""
-        all_violations = []
-
-        for py_file in get_python_files():
-            content = py_file.read_text()
-            violations = find_unqualified_table_refs(content, py_file.name)
-
-            for line_num, table, line in violations:
-                all_violations.append(
-                    f"{py_file.relative_to(py_file.parent.parent)}:{line_num} - "
-                    f"unqualified '{table}': {line[:80]}..."
-                )
-
-        if all_violations:
-            msg = (
-                f"Found {len(all_violations)} unqualified table references!\n"
-                "These could cause cross-tenant data access.\n"
-                "Use fq_table('table_name') for all table references.\n\n"
-                + "\n".join(all_violations[:20])  # Show first 20
-            )
-            if len(all_violations) > 20:
-                msg += f"\n... and {len(all_violations) - 20} more"
-            pytest.fail(msg)
-
-    def test_tables_list_is_complete(self):
-        """Verify we're checking for all tables (sanity check)."""
-        # This is a sanity check - if you add a new table, add it to TABLES
-        assert len(TABLES) >= 9, "Update TABLES list if you added new tables"

hindsight-api/tests/test_temporal_ranges.py

@@ -3,17 +3,16 @@ import asyncio
 from datetime import datetime, timezone, timedelta
 import pytest
 from hindsight_api.engine.memory_engine import Budget
-from hindsight_api import RequestContext
 
 
 @pytest.mark.asyncio
-async def test_temporal_ranges_are_written(memory, request_context):
+async def test_temporal_ranges_are_written(memory):
     """Test that occurred_start, occurred_end, and mentioned_at are actually written to database."""
     bank_id = "test_temporal_ranges"
 
     # Clean up any existing data
     try:
-        await memory.delete_bank(bank_id, request_context=request_context)
+        await memory.delete_bank(bank_id)
     except Exception:
         pass
 
@@ -24,8 +23,7 @@ async def test_temporal_ranges_are_written(memory, request_context):
     await memory.retain_async(
         bank_id=bank_id,
         content=text1,
-        event_date=conversation_date,
-        request_context=request_context,
+        event_date=conversation_date
     )
 
     # Test 2: Period event (month range)
@@ -34,8 +32,7 @@ async def test_temporal_ranges_are_written(memory, request_context):
     await memory.retain_async(
         bank_id=bank_id,
         content=text2,
-        event_date=conversation_date,
-        request_context=request_context,
+        event_date=conversation_date
     )
 
     # Give it a moment for async processing
@@ -117,8 +114,7 @@ async def test_temporal_ranges_are_written(memory, request_context):
         query="pottery workshop",
         fact_type=["world", "experience"],
         budget=Budget.LOW,
-        max_tokens=4096,
-        request_context=request_context,
+        max_tokens=4096
     )
 
     print(f"Found {len(search_result.results)} search results")
@@ -136,4 +132,4 @@ async def test_temporal_ranges_are_written(memory, request_context):
             print("⚠ Temporal fields not yet populated in search results (known issue)")
 
     # Clean up
-    await memory.delete_bank(bank_id, request_context=request_context)
+    await memory.delete_bank(bank_id)

hindsight-api/tests/test_think.py

@@ -4,11 +4,10 @@ Test think function for opinion generation and consistency.
 import pytest
 from datetime import datetime, timezone
 from hindsight_api.engine.memory_engine import Budget
-from hindsight_api import RequestContext
 
 
 @pytest.mark.asyncio
-async def test_think_opinion_consistency(memory, request_context):
+async def test_think_opinion_consistency(memory):
     """
     Test that think function:
     1. Generates an opinion
@@ -24,16 +23,14 @@ async def test_think_opinion_consistency(memory, request_context):
             bank_id=bank_id,
             content="Alice is a software engineer who has worked on 5 major projects. She always delivers on time and writes clean, well-documented code.",
             context="performance review",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
+            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc)
         )
 
         await memory.retain_async(
             bank_id=bank_id,
             content="Bob recently joined the team. He missed his first deadline and his code had many bugs.",
             context="performance review",
-            event_date=datetime(2024, 2, 1, tzinfo=timezone.utc),
-            request_context=request_context,
+            event_date=datetime(2024, 2, 1, tzinfo=timezone.utc)
         )
 
         # First think call - should generate opinions
@@ -42,7 +39,6 @@ async def test_think_opinion_consistency(memory, request_context):
             bank_id=bank_id,
             query=query,
             budget=Budget.LOW,
-            request_context=request_context,
         )
 
         print(f"\n=== First Think Call ===")
@@ -86,7 +82,6 @@ async def test_think_opinion_consistency(memory, request_context):
             bank_id=bank_id,
             query=query,
             budget=Budget.LOW,
-            request_context=request_context,
         )
 
         print(f"\n=== Second Think Call ===")
@@ -127,13 +122,13 @@ async def test_think_opinion_consistency(memory, request_context):
     finally:
         # Clean up agent data
         try:
-            await memory.delete_bank(bank_id, request_context=request_context)
+            await memory.delete_bank(bank_id)
         except Exception as e:
             print(f"Warning: Error during cleanup: {e}")
 
 
 @pytest.mark.asyncio
-async def test_think_without_prior_context(memory, request_context):
+async def test_think_without_prior_context(memory):
     """
     Test that think function handles queries when there's no relevant context.
     """
@@ -144,7 +139,6 @@ async def test_think_without_prior_context(memory, request_context):
         bank_id=bank_id,
         query="What is the capital of France?",
         budget=Budget.LOW,
-        request_context=request_context,
     )
 
     print(f"\n=== Think Without Context ===")

hindsight-cli/.github/workflows/release.yml

@@ -0,0 +1,102 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build ${{ matrix.target }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            artifact_name: memora
+            release_name: memora-linux-x86_64
+          - os: ubuntu-latest
+            target: aarch64-unknown-linux-gnu
+            artifact_name: memora
+            release_name: memora-linux-arm64
+          - os: macos-latest
+            target: x86_64-apple-darwin
+            artifact_name: memora
+            release_name: memora-macos-x86_64
+          - os: macos-latest
+            target: aarch64-apple-darwin
+            artifact_name: memora
+            release_name: memora-macos-arm64
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Install cross-compilation tools (Linux ARM64)
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Strip binary (Linux)
+        if: runner.os == 'Linux'
+        run: strip target/${{ matrix.target }}/release/${{ matrix.artifact_name }}
+
+      - name: Strip binary (macOS)
+        if: runner.os == 'macOS'
+        run: strip target/${{ matrix.target }}/release/${{ matrix.artifact_name }}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.release_name }}
+          path: target/${{ matrix.target }}/release/${{ matrix.artifact_name }}
+
+  release:
+    name: Create Release
+    needs: build
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Create checksums
+        run: |
+          cd artifacts
+          for dir in */; do
+            cd "$dir"
+            sha256sum * > SHA256SUMS
+            cd ..
+          done
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            artifacts/memora-linux-x86_64/memora
+            artifacts/memora-linux-arm64/memora
+            artifacts/memora-macos-x86_64/memora
+            artifacts/memora-macos-arm64/memora
+            artifacts/*/SHA256SUMS
+          draft: false
+          prerelease: false
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

hindsight-cli/Cargo.toml

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

hindsight-cli/smoke-test.sh

@@ -1,128 +0,0 @@
-#!/bin/bash
-# CLI smoke test - verifies basic CLI functionality against a running API server
-#
-# Prerequisites:
-#   - hindsight CLI must be in PATH or HINDSIGHT_CLI env var set
-#   - API server must be running at HINDSIGHT_API_URL (default: http://localhost:8888)
-#
-# Usage:
-#   ./hindsight-cli/smoke-test.sh
-#   HINDSIGHT_CLI=/path/to/hindsight ./hindsight-cli/smoke-test.sh
-
-set -e
-
-# Configuration
-HINDSIGHT_CLI="${HINDSIGHT_CLI:-hindsight}"
-export HINDSIGHT_API_URL="${HINDSIGHT_API_URL:-http://localhost:8888}"
-TEST_BANK="cli-smoke-test-$(date +%s)"
-
-echo "=== Hindsight CLI Smoke Test ==="
-echo "CLI: $HINDSIGHT_CLI"
-echo "API URL: $HINDSIGHT_API_URL"
-echo "Test bank: $TEST_BANK"
-echo ""
-
-# Helper function
-run_test() {
-    local name="$1"
-    shift
-    echo -n "Testing: $name... "
-    if "$@" > /tmp/cli-test-output.txt 2>&1; then
-        echo "OK"
-        return 0
-    else
-        echo "FAILED"
-        echo "  Command: $*"
-        echo "  Output:"
-        cat /tmp/cli-test-output.txt | sed 's/^/    /'
-        return 1
-    fi
-}
-
-run_test_output() {
-    local name="$1"
-    local expected="$2"
-    shift 2
-    echo -n "Testing: $name... "
-    if "$@" > /tmp/cli-test-output.txt 2>&1; then
-        if grep -qi "$expected" /tmp/cli-test-output.txt; then
-            echo "OK"
-            return 0
-        else
-            echo "FAILED (expected '$expected' not found)"
-            echo "  Command: $*"
-            echo "  Output:"
-            cat /tmp/cli-test-output.txt | sed 's/^/    /'
-            return 1
-        fi
-    else
-        echo "FAILED"
-        echo "  Command: $*"
-        echo "  Output:"
-        cat /tmp/cli-test-output.txt | sed 's/^/    /'
-        return 1
-    fi
-}
-
-cleanup() {
-    echo ""
-    echo "Cleaning up test bank..."
-    "$HINDSIGHT_CLI" bank delete "$TEST_BANK" 2>/dev/null || true
-}
-trap cleanup EXIT
-
-FAILED=0
-
-# Test 1: Version
-run_test "version" "$HINDSIGHT_CLI" --version || FAILED=1
-
-# Test 2: Help
-run_test "help" "$HINDSIGHT_CLI" --help || FAILED=1
-
-# Test 3: Configure help
-run_test "configure help" "$HINDSIGHT_CLI" configure --help || FAILED=1
-
-# Test 4: List banks (JSON output)
-run_test "list banks" "$HINDSIGHT_CLI" bank list -o json || FAILED=1
-
-# Test 5: Set bank name (creates the bank)
-run_test "set bank name" "$HINDSIGHT_CLI" bank name "$TEST_BANK" "CLI Smoke Test Bank" || FAILED=1
-
-# Test 6: Get bank disposition
-run_test_output "get bank disposition" "CLI Smoke Test Bank" "$HINDSIGHT_CLI" bank disposition "$TEST_BANK" || FAILED=1
-
-# Test 7: Retain memory
-run_test "retain memory" "$HINDSIGHT_CLI" memory retain "$TEST_BANK" "Alice is a software engineer who loves Rust programming" || FAILED=1
-
-# Test 8: Retain more memories
-run_test "retain more memories" "$HINDSIGHT_CLI" memory retain "$TEST_BANK" "Bob is Alice's colleague who prefers Python" || FAILED=1
-
-# Test 9: Recall memories
-run_test_output "recall memories" "Alice" "$HINDSIGHT_CLI" memory recall "$TEST_BANK" "Who is Alice?" || FAILED=1
-
-# Test 10: Reflect on memories
-run_test_output "reflect" "Alice" "$HINDSIGHT_CLI" memory reflect "$TEST_BANK" "What do you know about Alice?" || FAILED=1
-
-# Test 11: Get bank stats
-run_test "bank stats" "$HINDSIGHT_CLI" bank stats "$TEST_BANK" || FAILED=1
-
-# Test 12: List entities
-run_test "list entities" "$HINDSIGHT_CLI" entity list "$TEST_BANK" || FAILED=1
-
-# Test 13: List documents
-run_test "list documents" "$HINDSIGHT_CLI" document list "$TEST_BANK" || FAILED=1
-
-# Test 14: Clear memories
-run_test "clear memories" "$HINDSIGHT_CLI" memory clear "$TEST_BANK" || FAILED=1
-
-# Test 15: Delete bank
-run_test "delete bank" "$HINDSIGHT_CLI" bank delete "$TEST_BANK" || FAILED=1
-
-echo ""
-if [ $FAILED -eq 0 ]; then
-    echo "=== All smoke tests passed! ==="
-    exit 0
-else
-    echo "=== Some smoke tests failed ==="
-    exit 1
-fi

hindsight-cli/src/api.rs

@@ -64,24 +64,13 @@ pub struct ApiClient {
 }
 
 impl ApiClient {
-    pub fn new(base_url: String, api_key: Option<String>) -> Result<Self> {
+    pub fn new(base_url: String) -> Result<Self> {
         let runtime = std::sync::Arc::new(tokio::runtime::Runtime::new()?);
 
-        // Create HTTP client with 2-minute timeout and optional auth header
-        let mut client_builder = reqwest::Client::builder()
-            .timeout(std::time::Duration::from_secs(120));
-
-        if let Some(key) = api_key {
-            let mut headers = reqwest::header::HeaderMap::new();
-            let auth_value = format!("Bearer {}", key);
-            headers.insert(
-                reqwest::header::AUTHORIZATION,
-                reqwest::header::HeaderValue::from_str(&auth_value)?,
-            );
-            client_builder = client_builder.default_headers(headers);
-        }
-
-        let http_client = client_builder.build()?;
+        // Create HTTP client with 2-minute timeout
+        let http_client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(120))
+            .build()?;
 
         let client = AsyncClient::new_with_client(&base_url, http_client);
         Ok(ApiClient { client, runtime })
@@ -89,14 +78,14 @@ impl ApiClient {
 
     pub fn list_agents(&self, _verbose: bool) -> Result<Vec<types::BankListItem>> {
         self.runtime.block_on(async {
-            let response = self.client.list_banks(None).await?;
+            let response = self.client.list_banks().await?;
             Ok(response.into_inner().banks)
         })
     }
 
     pub fn get_profile(&self, agent_id: &str, _verbose: bool) -> Result<types::BankProfileResponse> {
         self.runtime.block_on(async {
-            let response = self.client.get_bank_profile(agent_id, None).await?;
+            let response = self.client.get_bank_profile(agent_id).await?;
             Ok(response.into_inner())
         })
     }
@@ -105,9 +94,7 @@ impl ApiClient {
         self.runtime.block_on(async {
             let response = self.client.get_agent_stats(agent_id).await?;
             let value = response.into_inner();
-            // Convert to JSON Value first, then parse into our type
-            let json_value = serde_json::to_value(&value)?;
-            let stats: AgentStats = serde_json::from_value(json_value)?;
+            let stats: AgentStats = serde_json::from_value(value)?;
             Ok(stats)
         })
     }
@@ -119,7 +106,7 @@ impl ApiClient {
                 background: None,
                 disposition: None,
             };
-            let response = self.client.create_or_update_bank(agent_id, None, &request).await?;
+            let response = self.client.create_or_update_bank(agent_id, &request).await?;
             Ok(response.into_inner())
         })
     }
@@ -130,7 +117,7 @@ impl ApiClient {
                 content: content.to_string(),
                 update_disposition,
             };
-            let response = self.client.add_bank_background(agent_id, None, &request).await?;
+            let response = self.client.add_bank_background(agent_id, &request).await?;
             Ok(response.into_inner())
         })
     }
@@ -140,21 +127,21 @@ impl ApiClient {
             eprintln!("Request body: {}", serde_json::to_string_pretty(request).unwrap_or_default());
         }
         self.runtime.block_on(async {
-            let response = self.client.recall_memories(agent_id, None, request).await?;
+            let response = self.client.recall_memories(agent_id, request).await?;
             Ok(response.into_inner())
         })
     }
 
     pub fn reflect(&self, agent_id: &str, request: &types::ReflectRequest, _verbose: bool) -> Result<types::ReflectResponse> {
         self.runtime.block_on(async {
-            let response = self.client.reflect(agent_id, None, request).await?;
+            let response = self.client.reflect(agent_id, request).await?;
             Ok(response.into_inner())
         })
     }
 
     pub fn retain(&self, agent_id: &str, request: &types::RetainRequest, _async_mode: bool, _verbose: bool) -> Result<MemoryPutResult> {
         self.runtime.block_on(async {
-            let response = self.client.retain_memories(agent_id, None, request).await?;
+            let response = self.client.retain_memories(agent_id, request).await?;
             let result = response.into_inner();
             Ok(MemoryPutResult {
                 success: result.success,
@@ -172,7 +159,7 @@ impl ApiClient {
 
     pub fn clear_memories(&self, agent_id: &str, fact_type: Option<&str>, _verbose: bool) -> Result<types::DeleteResponse> {
         self.runtime.block_on(async {
-            let response = self.client.clear_bank_memories(agent_id, None, Some(fact_type)).await?;
+            let response = self.client.clear_bank_memories(agent_id, fact_type).await?;
             Ok(response.into_inner())
         })
     }
@@ -183,8 +170,7 @@ impl ApiClient {
                 agent_id,
                 limit.map(|l| l as i64),
                 offset.map(|o| o as i64),
-                q,
-                None,
+                q
             ).await?;
             Ok(response.into_inner())
         })
@@ -192,79 +178,69 @@ impl ApiClient {
 
     pub fn get_document(&self, agent_id: &str, document_id: &str, _verbose: bool) -> Result<types::DocumentResponse> {
         self.runtime.block_on(async {
-            let response = self.client.get_document(agent_id, document_id, None).await?;
+            let response = self.client.get_document(agent_id, document_id).await?;
             Ok(response.into_inner())
         })
     }
 
     pub fn delete_document(&self, agent_id: &str, document_id: &str, _verbose: bool) -> Result<types::DeleteResponse> {
         self.runtime.block_on(async {
-            let response = self.client.delete_document(agent_id, document_id, None).await?;
+            let response = self.client.delete_document(agent_id, document_id).await?;
             let value = response.into_inner();
-            // Convert typed response to DeleteResponse
-            Ok(types::DeleteResponse {
-                deleted_count: Some(value.memory_units_deleted),
-                message: Some(value.message),
-                success: value.success,
-            })
+            let result: types::DeleteResponse = serde_json::from_value(value)?;
+            Ok(result)
         })
     }
 
     pub fn list_operations(&self, agent_id: &str, _verbose: bool) -> Result<OperationsResponse> {
         self.runtime.block_on(async {
-            let response = self.client.list_operations(agent_id, None).await?;
+            let response = self.client.list_operations(agent_id).await?;
             let value = response.into_inner();
-            // Convert to JSON Value first, then parse into our type
-            let json_value = serde_json::to_value(&value)?;
-            let ops: OperationsResponse = serde_json::from_value(json_value)?;
+            let ops: OperationsResponse = serde_json::from_value(value)?;
             Ok(ops)
         })
     }
 
     pub fn cancel_operation(&self, agent_id: &str, operation_id: &str, _verbose: bool) -> Result<types::DeleteResponse> {
         self.runtime.block_on(async {
-            let response = self.client.cancel_operation(agent_id, operation_id, None).await?;
+            let response = self.client.cancel_operation(agent_id, operation_id).await?;
             let value = response.into_inner();
-            // Convert typed response to DeleteResponse
-            Ok(types::DeleteResponse {
-                deleted_count: None,
-                message: Some(value.message),
-                success: value.success,
-            })
+            let result: types::DeleteResponse = serde_json::from_value(value)?;
+            Ok(result)
         })
     }
 
     pub fn list_memories(&self, bank_id: &str, type_filter: Option<&str>, q: Option<&str>, limit: Option<i64>, offset: Option<i64>, _verbose: bool) -> Result<types::ListMemoryUnitsResponse> {
         self.runtime.block_on(async {
-            let response = self.client.list_memories(bank_id, limit, offset, q, type_filter, None).await?;
+            let response = self.client.list_memories(bank_id, limit, offset, q, type_filter).await?;
             Ok(response.into_inner())
         })
     }
 
     pub fn list_entities(&self, bank_id: &str, limit: Option<i64>, _verbose: bool) -> Result<types::EntityListResponse> {
         self.runtime.block_on(async {
-            let response = self.client.list_entities(bank_id, limit, None).await?;
+            let response = self.client.list_entities(bank_id, limit).await?;
             Ok(response.into_inner())
         })
     }
 
     pub fn get_entity(&self, bank_id: &str, entity_id: &str, _verbose: bool) -> Result<types::EntityDetailResponse> {
         self.runtime.block_on(async {
-            let response = self.client.get_entity(bank_id, entity_id, None).await?;
+            let response = self.client.get_entity(bank_id, entity_id).await?;
             Ok(response.into_inner())
         })
     }
 
     pub fn regenerate_entity(&self, bank_id: &str, entity_id: &str, _verbose: bool) -> Result<types::EntityDetailResponse> {
         self.runtime.block_on(async {
-            let response = self.client.regenerate_entity_observations(bank_id, entity_id, None).await?;
+            let response = self.client.regenerate_entity_observations(bank_id, entity_id).await?;
             Ok(response.into_inner())
         })
     }
 
     pub fn delete_bank(&self, bank_id: &str, _verbose: bool) -> Result<types::DeleteResponse> {
         self.runtime.block_on(async {
-            let response = self.client.delete_bank(bank_id, None).await?;
+            let response = self.client.delete_bank(bank_id).await?;
             Ok(response.into_inner())
         })
     }

hindsight-cli/src/commands/explore.rs

@@ -944,7 +944,7 @@ fn render_banks(f: &mut Frame, app: &mut App, area: Rect) {
         .banks
         .iter()
         .map(|bank| {
-            let name = bank.name.as_deref().filter(|s| !s.is_empty()).unwrap_or("Unnamed");
+            let name = if bank.name.is_empty() { "Unnamed" } else { &bank.name };
             let content = format!("{} - {}", bank.bank_id, name);
             ListItem::new(content).style(Style::default().fg(Color::White))
         })

hindsight-cli/src/config.rs

@@ -10,7 +10,6 @@ const CONFIG_DIR_NAME: &str = ".hindsight";
 
 pub struct Config {
     pub api_url: String,
-    pub api_key: Option<String>,
     pub source: ConfigSource,
 }
 
@@ -33,27 +32,22 @@ impl std::fmt::Display for ConfigSource {
 
 impl Config {
     /// Load configuration with the following priority:
-    /// 1. Environment variable (HINDSIGHT_API_URL, HINDSIGHT_API_KEY) - highest priority, for overrides
+    /// 1. Environment variable (HINDSIGHT_API_URL) - highest priority, for overrides
     /// 2. Local config file (~/.hindsight/config.toml)
     /// 3. Default (http://localhost:8888)
     pub fn load() -> Result<Self> {
-        // Load API key from environment (highest priority)
-        let env_api_key = env::var("HINDSIGHT_API_KEY").ok();
-
         // 1. Environment variable takes highest priority (for overrides)
         if let Ok(api_url) = env::var("HINDSIGHT_API_URL") {
-            return Self::validate_and_create(api_url, env_api_key, ConfigSource::Environment);
+            return Self::validate_and_create(api_url, ConfigSource::Environment);
         }
 
         // 2. Try local config file
-        if let Some((api_url, file_api_key)) = Self::load_from_file()? {
-            // Environment api_key takes precedence over file api_key
-            let api_key = env_api_key.or(file_api_key);
-            return Self::validate_and_create(api_url, api_key, ConfigSource::LocalFile);
+        if let Some(api_url) = Self::load_from_file()? {
+            return Self::validate_and_create(api_url, ConfigSource::LocalFile);
         }
 
         // 3. Fall back to default
-        Self::validate_and_create(DEFAULT_API_URL.to_string(), env_api_key, ConfigSource::Default)
+        Self::validate_and_create(DEFAULT_API_URL.to_string(), ConfigSource::Default)
     }
 
     /// Legacy method for backwards compatibility
@@ -61,14 +55,14 @@ impl Config {
         Self::load()
     }
 
-    fn validate_and_create(api_url: String, api_key: Option<String>, source: ConfigSource) -> Result<Self> {
+    fn validate_and_create(api_url: String, source: ConfigSource) -> Result<Self> {
         if !api_url.starts_with("http://") && !api_url.starts_with("https://") {
             anyhow::bail!(
                 "Invalid API URL: {}. Must start with http:// or https://",
                 api_url
             );
         }
-        Ok(Config { api_url, api_key, source })
+        Ok(Config { api_url, source })
     }
 
     fn config_dir() -> Option<PathBuf> {
@@ -79,7 +73,7 @@ impl Config {
         Self::config_dir().map(|dir| dir.join(CONFIG_FILE_NAME))
     }
 
-    fn load_from_file() -> Result<Option<(String, Option<String>)>> {
+    fn load_from_file() -> Result<Option<String>> {
         let config_path = match Self::config_file_path() {
             Some(path) => path,
             None => return Ok(None),
@@ -92,40 +86,23 @@ impl Config {
         let content = fs::read_to_string(&config_path)
             .with_context(|| format!("Failed to read config file: {}", config_path.display()))?;
 
-        let mut api_url: Option<String> = None;
-        let mut api_key: Option<String> = None;
-
-        // Simple TOML parsing for api_url and api_key
+        // Simple TOML parsing for api_url
         for line in content.lines() {
             let line = line.trim();
             if line.starts_with("api_url") {
                 if let Some(value) = line.split('=').nth(1) {
                     let value = value.trim().trim_matches('"').trim_matches('\'');
                     if !value.is_empty() {
-                        api_url = Some(value.to_string());
-                    }
-                }
-            } else if line.starts_with("api_key") {
-                if let Some(value) = line.split('=').nth(1) {
-                    let value = value.trim().trim_matches('"').trim_matches('\'');
-                    if !value.is_empty() {
-                        api_key = Some(value.to_string());
+                        return Ok(Some(value.to_string()));
                     }
                 }
             }
         }
 
-        match api_url {
-            Some(url) => Ok(Some((url, api_key))),
-            None => Ok(None),
-        }
+        Ok(None)
     }
 
     pub fn save_api_url(api_url: &str) -> Result<PathBuf> {
-        Self::save_config(api_url, None)
-    }
-
-    pub fn save_config(api_url: &str, api_key: Option<&str>) -> Result<PathBuf> {
         let config_dir = Self::config_dir()
             .ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
 
@@ -136,10 +113,7 @@ impl Config {
         }
 
         let config_path = config_dir.join(CONFIG_FILE_NAME);
-        let mut content = format!("api_url = \"{}\"\n", api_url);
-        if let Some(key) = api_key {
-            content.push_str(&format!("api_key = \"{}\"\n", key));
-        }
+        let content = format!("api_url = \"{}\"\n", api_url);
 
         fs::write(&config_path, content)
             .with_context(|| format!("Failed to write config file: {}", config_path.display()))?;

hindsight-cli/src/main.rs

@@ -94,15 +94,12 @@ enum Commands {
     /// Launch the web-based control plane UI
     Ui,
 
-    /// Configure the CLI (API URL, API key, etc.)
-    #[command(after_help = "Configuration priority:\n  1. Environment variables (HINDSIGHT_API_URL, HINDSIGHT_API_KEY) - highest priority\n  2. Config file (~/.hindsight/config)\n  3. Default (http://localhost:8888)")]
+    /// Configure the CLI (API URL, etc.)
+    #[command(after_help = "Configuration priority:\n  1. Environment variable (HINDSIGHT_API_URL) - highest priority\n  2. Config file (~/.hindsight/config)\n  3. Default (http://localhost:8888)")]
     Configure {
         /// API URL to connect to (interactive prompt if not provided)
         #[arg(long)]
         api_url: Option<String>,
-        /// API key for authentication (sent as Bearer token)
-        #[arg(long)]
-        api_key: Option<String>,
     },
 }
 
@@ -375,8 +372,8 @@ fn run() -> Result<()> {
     let verbose = cli.verbose;
 
     // Handle configure command before loading full config (it doesn't need API client)
-    if let Commands::Configure { api_url, api_key } = cli.command {
-        return handle_configure(api_url, api_key, output_format);
+    if let Commands::Configure { api_url } = cli.command {
+        return handle_configure(api_url, output_format);
     }
 
     // Handle ui command - needs config but not API client
@@ -392,10 +389,9 @@ fn run() -> Result<()> {
     });
 
     let api_url = config.api_url().to_string();
-    let api_key = config.api_key.clone();
 
     // Create API client
-    let client = ApiClient::new(api_url.clone(), api_key).unwrap_or_else(|e| {
+    let client = ApiClient::new(api_url.clone()).unwrap_or_else(|e| {
         errors::handle_api_error(e, &api_url);
     });
 
@@ -480,7 +476,7 @@ fn run() -> Result<()> {
     Ok(())
 }
 
-fn handle_configure(api_url: Option<String>, api_key: Option<String>, output_format: OutputFormat) -> Result<()> {
+fn handle_configure(api_url: Option<String>, output_format: OutputFormat) -> Result<()> {
     // Load current config to show current state
     let current_config = Config::load().ok();
 
@@ -491,15 +487,6 @@ fn handle_configure(api_url: Option<String>, api_key: Option<String>, output_for
         // Show current configuration
         if let Some(ref config) = current_config {
             println!("  Current API URL: {}", config.api_url);
-            if let Some(ref key) = config.api_key {
-                // Mask the API key for display
-                let masked = if key.len() > 8 {
-                    format!("{}...{}", &key[..4], &key[key.len()-4..])
-                } else {
-                    "****".to_string()
-                };
-                println!("  Current API Key: {}", masked);
-            }
             println!("  Source: {}", config.source);
             println!();
         }
@@ -524,30 +511,18 @@ fn handle_configure(api_url: Option<String>, api_key: Option<String>, output_for
         return Ok(());
     }
 
-    // Use provided api_key, or keep existing one if not provided
-    let new_api_key = api_key.or_else(|| current_config.as_ref().and_then(|c| c.api_key.clone()));
-
     // Save to config file
-    let config_path = Config::save_config(&new_api_url, new_api_key.as_deref())?;
+    let config_path = Config::save_api_url(&new_api_url)?;
 
     if output_format == OutputFormat::Pretty {
         ui::print_success(&format!("Configuration saved to {}", config_path.display()));
         println!();
         println!("  API URL: {}", new_api_url);
-        if let Some(ref key) = new_api_key {
-            let masked = if key.len() > 8 {
-                format!("{}...{}", &key[..4], &key[key.len()-4..])
-            } else {
-                "****".to_string()
-            };
-            println!("  API Key: {}", masked);
-        }
         println!();
-        println!("Note: Environment variables HINDSIGHT_API_URL and HINDSIGHT_API_KEY will override these settings.");
+        println!("Note: Environment variable HINDSIGHT_API_URL will override this setting.");
     } else {
         let result = serde_json::json!({
             "api_url": new_api_url,
-            "api_key_set": new_api_key.is_some(),
             "config_path": config_path.display().to_string(),
         });
         output::print_output(&result, output_format)?;

hindsight-cli/src/utils.rs

@@ -5,7 +5,7 @@ use crate::output::OutputFormat;
 
 /// Get API client from config
 pub fn get_client(config: &Config) -> Result<ApiClient> {
-    ApiClient::new(config.api_url.clone(), config.api_key.clone())
+    ApiClient::new(config.api_url.clone())
         .context("Failed to create API client")
 }
 

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

@@ -1,11 +1,7 @@
 hindsight_client_api/__init__.py
 hindsight_client_api/api/__init__.py
-hindsight_client_api/api/banks_api.py
-hindsight_client_api/api/documents_api.py
-hindsight_client_api/api/entities_api.py
-hindsight_client_api/api/memory_api.py
+hindsight_client_api/api/default_api.py
 hindsight_client_api/api/monitoring_api.py
-hindsight_client_api/api/operations_api.py
 hindsight_client_api/api_client.py
 hindsight_client_api/api_response.py
 hindsight_client_api/configuration.py
@@ -14,20 +10,15 @@ hindsight_client_api/docs/BackgroundResponse.md
 hindsight_client_api/docs/BankListItem.md
 hindsight_client_api/docs/BankListResponse.md
 hindsight_client_api/docs/BankProfileResponse.md
-hindsight_client_api/docs/BankStatsResponse.md
-hindsight_client_api/docs/BanksApi.md
 hindsight_client_api/docs/Budget.md
-hindsight_client_api/docs/CancelOperationResponse.md
 hindsight_client_api/docs/ChunkData.md
 hindsight_client_api/docs/ChunkIncludeOptions.md
 hindsight_client_api/docs/ChunkResponse.md
 hindsight_client_api/docs/CreateBankRequest.md
-hindsight_client_api/docs/DeleteDocumentResponse.md
+hindsight_client_api/docs/DefaultApi.md
 hindsight_client_api/docs/DeleteResponse.md
 hindsight_client_api/docs/DispositionTraits.md
 hindsight_client_api/docs/DocumentResponse.md
-hindsight_client_api/docs/DocumentsApi.md
-hindsight_client_api/docs/EntitiesApi.md
 hindsight_client_api/docs/EntityDetailResponse.md
 hindsight_client_api/docs/EntityIncludeOptions.md
 hindsight_client_api/docs/EntityListItem.md
@@ -39,12 +30,8 @@ hindsight_client_api/docs/HTTPValidationError.md
 hindsight_client_api/docs/IncludeOptions.md
 hindsight_client_api/docs/ListDocumentsResponse.md
 hindsight_client_api/docs/ListMemoryUnitsResponse.md
-hindsight_client_api/docs/MemoryApi.md
 hindsight_client_api/docs/MemoryItem.md
 hindsight_client_api/docs/MonitoringApi.md
-hindsight_client_api/docs/OperationResponse.md
-hindsight_client_api/docs/OperationsApi.md
-hindsight_client_api/docs/OperationsListResponse.md
 hindsight_client_api/docs/RecallRequest.md
 hindsight_client_api/docs/RecallResponse.md
 hindsight_client_api/docs/RecallResult.md
@@ -64,14 +51,11 @@ hindsight_client_api/models/background_response.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/chunk_data.py
 hindsight_client_api/models/chunk_include_options.py
 hindsight_client_api/models/chunk_response.py
 hindsight_client_api/models/create_bank_request.py
-hindsight_client_api/models/delete_document_response.py
 hindsight_client_api/models/delete_response.py
 hindsight_client_api/models/disposition_traits.py
 hindsight_client_api/models/document_response.py
@@ -87,8 +71,6 @@ hindsight_client_api/models/include_options.py
 hindsight_client_api/models/list_documents_response.py
 hindsight_client_api/models/list_memory_units_response.py
 hindsight_client_api/models/memory_item.py
-hindsight_client_api/models/operation_response.py
-hindsight_client_api/models/operations_list_response.py
 hindsight_client_api/models/recall_request.py
 hindsight_client_api/models/recall_response.py
 hindsight_client_api/models/recall_result.py
@@ -108,20 +90,15 @@ hindsight_client_api/test/test_background_response.py
 hindsight_client_api/test/test_bank_list_item.py
 hindsight_client_api/test/test_bank_list_response.py
 hindsight_client_api/test/test_bank_profile_response.py
-hindsight_client_api/test/test_bank_stats_response.py
-hindsight_client_api/test/test_banks_api.py
 hindsight_client_api/test/test_budget.py
-hindsight_client_api/test/test_cancel_operation_response.py
 hindsight_client_api/test/test_chunk_data.py
 hindsight_client_api/test/test_chunk_include_options.py
 hindsight_client_api/test/test_chunk_response.py
 hindsight_client_api/test/test_create_bank_request.py
-hindsight_client_api/test/test_delete_document_response.py
+hindsight_client_api/test/test_default_api.py
 hindsight_client_api/test/test_delete_response.py
 hindsight_client_api/test/test_disposition_traits.py
 hindsight_client_api/test/test_document_response.py
-hindsight_client_api/test/test_documents_api.py
-hindsight_client_api/test/test_entities_api.py
 hindsight_client_api/test/test_entity_detail_response.py
 hindsight_client_api/test/test_entity_include_options.py
 hindsight_client_api/test/test_entity_list_item.py
@@ -133,12 +110,8 @@ hindsight_client_api/test/test_http_validation_error.py
 hindsight_client_api/test/test_include_options.py
 hindsight_client_api/test/test_list_documents_response.py
 hindsight_client_api/test/test_list_memory_units_response.py
-hindsight_client_api/test/test_memory_api.py
 hindsight_client_api/test/test_memory_item.py
 hindsight_client_api/test/test_monitoring_api.py
-hindsight_client_api/test/test_operation_response.py
-hindsight_client_api/test/test_operations_api.py
-hindsight_client_api/test/test_operations_list_response.py
 hindsight_client_api/test/test_recall_request.py
 hindsight_client_api/test/test_recall_response.py
 hindsight_client_api/test/test_recall_result.py

hindsight-clients/python/hindsight_client/hindsight_client.py

@@ -10,7 +10,7 @@ from typing import Optional, List, Dict, Any
 from datetime import datetime
 
 import hindsight_client_api
-from hindsight_client_api.api import memory_api, banks_api
+from hindsight_client_api.api import default_api
 from hindsight_client_api.models import (
     recall_request,
     retain_request,
@@ -44,12 +44,8 @@ class Hindsight:
         ```python
         from hindsight_client import Hindsight
 
-        # Without authentication
         client = Hindsight(base_url="http://localhost:8888")
 
-        # With API key authentication
-        client = Hindsight(base_url="http://localhost:8888", api_key="your-api-key")
-
         # Store a memory
         client.retain(bank_id="alice", content="Alice loves AI")
 
@@ -63,19 +59,17 @@ class Hindsight:
         ```
     """
 
-    def __init__(self, base_url: str, api_key: Optional[str] = None, timeout: float = 30.0):
+    def __init__(self, base_url: str, timeout: float = 30.0):
         """
         Initialize the Hindsight client.
 
         Args:
             base_url: The base URL of the Hindsight API server
-            api_key: Optional API key for authentication (sent as Bearer token)
             timeout: Request timeout in seconds (default: 30.0)
         """
-        config = hindsight_client_api.Configuration(host=base_url, access_token=api_key)
+        config = hindsight_client_api.Configuration(host=base_url)
         self._api_client = hindsight_client_api.ApiClient(config)
-        self._memory_api = memory_api.MemoryApi(self._api_client)
-        self._banks_api = banks_api.BanksApi(self._api_client)
+        self._api = default_api.DefaultApi(self._api_client)
 
     def __enter__(self):
         """Context manager entry."""
@@ -86,21 +80,9 @@ class Hindsight:
         self.close()
 
     def close(self):
-        """Close the API client (sync version - use aclose() in async code)."""
+        """Close the API client."""
         if self._api_client:
-            try:
-                loop = asyncio.get_running_loop()
-                # We're in an async context - schedule but don't wait
-                # The caller should use aclose() instead
-                loop.create_task(self._api_client.close())
-            except RuntimeError:
-                # No running loop - safe to run synchronously
-                _run_async(self._api_client.close())
-
-    async def aclose(self):
-        """Close the API client (async version)."""
-        if self._api_client:
-            await self._api_client.close()
+            _run_async(self._api_client.close())
 
     # Simplified methods for main operations
 
@@ -169,7 +151,7 @@ class Hindsight:
             async_=retain_async,
         )
 
-        return _run_async(self._memory_api.retain_memories(bank_id, request_obj))
+        return _run_async(self._api.retain_memories(bank_id, request_obj))
 
     def recall(
         self,
@@ -221,7 +203,7 @@ class Hindsight:
             include=include_opts,
         )
 
-        return _run_async(self._memory_api.recall_memories(bank_id, request_obj))
+        return _run_async(self._api.recall_memories(bank_id, request_obj))
 
     def reflect(
         self,
@@ -248,7 +230,7 @@ class Hindsight:
             context=context,
         )
 
-        return _run_async(self._memory_api.reflect(bank_id, request_obj))
+        return _run_async(self._api.reflect(bank_id, request_obj))
 
     def list_memories(
         self,
@@ -259,7 +241,7 @@ class Hindsight:
         offset: int = 0,
     ) -> ListMemoryUnitsResponse:
         """List memory units with pagination."""
-        return _run_async(self._memory_api.list_memories(
+        return _run_async(self._api.list_memories(
             bank_id=bank_id,
             type=type,
             q=search_query,
@@ -287,7 +269,7 @@ class Hindsight:
             disposition=disposition_obj,
         )
 
-        return _run_async(self._banks_api.create_or_update_bank(bank_id, request_obj))
+        return _run_async(self._api.create_or_update_bank(bank_id, request_obj))
 
     # Async methods (native async, no _run_async wrapper)
 
@@ -327,7 +309,7 @@ class Hindsight:
             async_=retain_async,
         )
 
-        return await self._memory_api.retain_memories(bank_id, request_obj)
+        return await self._api.retain_memories(bank_id, request_obj)
 
     async def aretain(
         self,
@@ -387,7 +369,7 @@ class Hindsight:
             trace=False,
         )
 
-        response = await self._memory_api.recall_memories(bank_id, request_obj)
+        response = await self._api.recall_memories(bank_id, request_obj)
         return response.results if hasattr(response, 'results') else []
 
     async def areflect(
@@ -415,4 +397,4 @@ class Hindsight:
             context=context,
         )
 
-        return await self._memory_api.reflect(bank_id, request_obj)
+        return await self._api.reflect(bank_id, request_obj)

hindsight-clients/python/hindsight_client_api/__init__.py

@@ -7,7 +7,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.1.0
+    The version of the OpenAPI document: 1.0.0
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -18,12 +18,8 @@ __version__ = "0.0.7"
 
 # Define package exports
 __all__ = [
-    "BanksApi",
-    "DocumentsApi",
-    "EntitiesApi",
-    "MemoryApi",
     "MonitoringApi",
-    "OperationsApi",
+    "DefaultApi",
     "ApiResponse",
     "ApiClient",
     "Configuration",
@@ -38,14 +34,11 @@ __all__ = [
     "BankListItem",
     "BankListResponse",
     "BankProfileResponse",
-    "BankStatsResponse",
     "Budget",
-    "CancelOperationResponse",
     "ChunkData",
     "ChunkIncludeOptions",
     "ChunkResponse",
     "CreateBankRequest",
-    "DeleteDocumentResponse",
     "DeleteResponse",
     "DispositionTraits",
     "DocumentResponse",
@@ -61,8 +54,6 @@ __all__ = [
     "ListDocumentsResponse",
     "ListMemoryUnitsResponse",
     "MemoryItem",
-    "OperationResponse",
-    "OperationsListResponse",
     "RecallRequest",
     "RecallResponse",
     "RecallResult",
@@ -78,12 +69,8 @@ __all__ = [
 ]
 
 # import apis into sdk package
-from hindsight_client_api.api.banks_api import BanksApi as BanksApi
-from hindsight_client_api.api.documents_api import DocumentsApi as DocumentsApi
-from hindsight_client_api.api.entities_api import EntitiesApi as EntitiesApi
-from hindsight_client_api.api.memory_api import MemoryApi as MemoryApi
 from hindsight_client_api.api.monitoring_api import MonitoringApi as MonitoringApi
-from hindsight_client_api.api.operations_api import OperationsApi as OperationsApi
+from hindsight_client_api.api.default_api import DefaultApi as DefaultApi
 
 # import ApiClient
 from hindsight_client_api.api_response import ApiResponse as ApiResponse
@@ -102,14 +89,11 @@ from hindsight_client_api.models.background_response import BackgroundResponse a
 from hindsight_client_api.models.bank_list_item import BankListItem as BankListItem
 from hindsight_client_api.models.bank_list_response import BankListResponse as BankListResponse
 from hindsight_client_api.models.bank_profile_response import BankProfileResponse as BankProfileResponse
-from hindsight_client_api.models.bank_stats_response import BankStatsResponse as BankStatsResponse
 from hindsight_client_api.models.budget import Budget as Budget
-from hindsight_client_api.models.cancel_operation_response import CancelOperationResponse as CancelOperationResponse
 from hindsight_client_api.models.chunk_data import ChunkData as ChunkData
 from hindsight_client_api.models.chunk_include_options import ChunkIncludeOptions as ChunkIncludeOptions
 from hindsight_client_api.models.chunk_response import ChunkResponse as ChunkResponse
 from hindsight_client_api.models.create_bank_request import CreateBankRequest as CreateBankRequest
-from hindsight_client_api.models.delete_document_response import DeleteDocumentResponse as DeleteDocumentResponse
 from hindsight_client_api.models.delete_response import DeleteResponse as DeleteResponse
 from hindsight_client_api.models.disposition_traits import DispositionTraits as DispositionTraits
 from hindsight_client_api.models.document_response import DocumentResponse as DocumentResponse
@@ -125,8 +109,6 @@ from hindsight_client_api.models.include_options import IncludeOptions as Includ
 from hindsight_client_api.models.list_documents_response import ListDocumentsResponse as ListDocumentsResponse
 from hindsight_client_api.models.list_memory_units_response import ListMemoryUnitsResponse as ListMemoryUnitsResponse
 from hindsight_client_api.models.memory_item import MemoryItem as MemoryItem
-from hindsight_client_api.models.operation_response import OperationResponse as OperationResponse
-from hindsight_client_api.models.operations_list_response import OperationsListResponse as OperationsListResponse
 from hindsight_client_api.models.recall_request import RecallRequest as RecallRequest
 from hindsight_client_api.models.recall_response import RecallResponse as RecallResponse
 from hindsight_client_api.models.recall_result import RecallResult as RecallResult

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

@@ -1,10 +1,6 @@
 # flake8: noqa
 
 # import apis into api package
-from hindsight_client_api.api.banks_api import BanksApi
-from hindsight_client_api.api.documents_api import DocumentsApi
-from hindsight_client_api.api.entities_api import EntitiesApi
-from hindsight_client_api.api.memory_api import MemoryApi
 from hindsight_client_api.api.monitoring_api import MonitoringApi
-from hindsight_client_api.api.operations_api import OperationsApi
+from hindsight_client_api.api.default_api import DefaultApi
 

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

@@ -1,921 +0,0 @@
-# coding: utf-8
-
-"""
-    Hindsight HTTP API
-
-    HTTP API for Hindsight
-
-    The version of the OpenAPI document: 0.1.0
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-import warnings
-from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
-from typing import Any, Dict, List, Optional, Tuple, Union
-from typing_extensions import Annotated
-
-from pydantic import Field, StrictInt, StrictStr
-from typing import Optional
-from typing_extensions import Annotated
-from hindsight_client_api.models.entity_detail_response import EntityDetailResponse
-from hindsight_client_api.models.entity_list_response import EntityListResponse
-
-from hindsight_client_api.api_client import ApiClient, RequestSerialized
-from hindsight_client_api.api_response import ApiResponse
-from hindsight_client_api.rest import RESTResponseType
-
-
-class EntitiesApi:
-    """NOTE: This class is auto generated by OpenAPI Generator
-    Ref: https://openapi-generator.tech
-
-    Do not edit the class manually.
-    """
-
-    def __init__(self, api_client=None) -> None:
-        if api_client is None:
-            api_client = ApiClient.get_default()
-        self.api_client = api_client
-
-
-    @validate_call
-    async def get_entity(
-        self,
-        bank_id: StrictStr,
-        entity_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,
-    ) -> EntityDetailResponse:
-        """Get entity details
-
-        Get detailed information about an entity including observations (mental model).
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param entity_id: (required)
-        :type entity_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_entity_serialize(
-            bank_id=bank_id,
-            entity_id=entity_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': "EntityDetailResponse",
-            '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_entity_with_http_info(
-        self,
-        bank_id: StrictStr,
-        entity_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[EntityDetailResponse]:
-        """Get entity details
-
-        Get detailed information about an entity including observations (mental model).
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param entity_id: (required)
-        :type entity_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_entity_serialize(
-            bank_id=bank_id,
-            entity_id=entity_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': "EntityDetailResponse",
-            '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_entity_without_preload_content(
-        self,
-        bank_id: StrictStr,
-        entity_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 entity details
-
-        Get detailed information about an entity including observations (mental model).
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param entity_id: (required)
-        :type entity_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_entity_serialize(
-            bank_id=bank_id,
-            entity_id=entity_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': "EntityDetailResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _get_entity_serialize(
-        self,
-        bank_id,
-        entity_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
-        if entity_id is not None:
-            _path_params['entity_id'] = entity_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}/entities/{entity_id}',
-            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 list_entities(
-        self,
-        bank_id: StrictStr,
-        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of entities to return")] = None,
-        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,
-    ) -> EntityListResponse:
-        """List entities
-
-        List all entities (people, organizations, etc.) known by the bank, ordered by mention count.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param limit: Maximum number of entities to return
-        :type limit: int
-        :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._list_entities_serialize(
-            bank_id=bank_id,
-            limit=limit,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "EntityListResponse",
-            '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 list_entities_with_http_info(
-        self,
-        bank_id: StrictStr,
-        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of entities to return")] = None,
-        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[EntityListResponse]:
-        """List entities
-
-        List all entities (people, organizations, etc.) known by the bank, ordered by mention count.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param limit: Maximum number of entities to return
-        :type limit: int
-        :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._list_entities_serialize(
-            bank_id=bank_id,
-            limit=limit,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "EntityListResponse",
-            '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 list_entities_without_preload_content(
-        self,
-        bank_id: StrictStr,
-        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of entities to return")] = None,
-        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:
-        """List entities
-
-        List all entities (people, organizations, etc.) known by the bank, ordered by mention count.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param limit: Maximum number of entities to return
-        :type limit: int
-        :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._list_entities_serialize(
-            bank_id=bank_id,
-            limit=limit,
-            authorization=authorization,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "EntityListResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _list_entities_serialize(
-        self,
-        bank_id,
-        limit,
-        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
-        if limit is not None:
-            
-            _query_params.append(('limit', limit))
-            
-        # 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}/entities',
-            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 regenerate_entity_observations(
-        self,
-        bank_id: StrictStr,
-        entity_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,
-    ) -> EntityDetailResponse:
-        """Regenerate entity observations
-
-        Regenerate observations for an entity based on all facts mentioning it.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param entity_id: (required)
-        :type entity_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._regenerate_entity_observations_serialize(
-            bank_id=bank_id,
-            entity_id=entity_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': "EntityDetailResponse",
-            '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 regenerate_entity_observations_with_http_info(
-        self,
-        bank_id: StrictStr,
-        entity_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[EntityDetailResponse]:
-        """Regenerate entity observations
-
-        Regenerate observations for an entity based on all facts mentioning it.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param entity_id: (required)
-        :type entity_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._regenerate_entity_observations_serialize(
-            bank_id=bank_id,
-            entity_id=entity_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': "EntityDetailResponse",
-            '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 regenerate_entity_observations_without_preload_content(
-        self,
-        bank_id: StrictStr,
-        entity_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:
-        """Regenerate entity observations
-
-        Regenerate observations for an entity based on all facts mentioning it.
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param entity_id: (required)
-        :type entity_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._regenerate_entity_observations_serialize(
-            bank_id=bank_id,
-            entity_id=entity_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': "EntityDetailResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _regenerate_entity_observations_serialize(
-        self,
-        bank_id,
-        entity_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
-        if entity_id is not None:
-            _path_params['entity_id'] = entity_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='POST',
-            resource_path='/v1/default/banks/{bank_id}/entities/{entity_id}/regenerate',
-            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
-        )
-
-

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.1.0
+    The version of the OpenAPI document: 1.0.0
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

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

@@ -1,610 +0,0 @@
-# coding: utf-8
-
-"""
-    Hindsight HTTP API
-
-    HTTP API for Hindsight
-
-    The version of the OpenAPI document: 0.1.0
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-import warnings
-from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
-from typing import Any, Dict, List, Optional, Tuple, Union
-from typing_extensions import Annotated
-
-from pydantic import StrictStr
-from typing import Optional
-from hindsight_client_api.models.cancel_operation_response import CancelOperationResponse
-from hindsight_client_api.models.operations_list_response import OperationsListResponse
-
-from hindsight_client_api.api_client import ApiClient, RequestSerialized
-from hindsight_client_api.api_response import ApiResponse
-from hindsight_client_api.rest import RESTResponseType
-
-
-class OperationsApi:
-    """NOTE: This class is auto generated by OpenAPI Generator
-    Ref: https://openapi-generator.tech
-
-    Do not edit the class manually.
-    """
-
-    def __init__(self, api_client=None) -> None:
-        if api_client is None:
-            api_client = ApiClient.get_default()
-        self.api_client = api_client
-
-
-    @validate_call
-    async def cancel_operation(
-        self,
-        bank_id: StrictStr,
-        operation_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,
-    ) -> CancelOperationResponse:
-        """Cancel a pending async operation
-
-        Cancel a pending async operation by removing it from the queue
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param operation_id: (required)
-        :type operation_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._cancel_operation_serialize(
-            bank_id=bank_id,
-            operation_id=operation_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': "CancelOperationResponse",
-            '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 cancel_operation_with_http_info(
-        self,
-        bank_id: StrictStr,
-        operation_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[CancelOperationResponse]:
-        """Cancel a pending async operation
-
-        Cancel a pending async operation by removing it from the queue
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param operation_id: (required)
-        :type operation_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._cancel_operation_serialize(
-            bank_id=bank_id,
-            operation_id=operation_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': "CancelOperationResponse",
-            '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 cancel_operation_without_preload_content(
-        self,
-        bank_id: StrictStr,
-        operation_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:
-        """Cancel a pending async operation
-
-        Cancel a pending async operation by removing it from the queue
-
-        :param bank_id: (required)
-        :type bank_id: str
-        :param operation_id: (required)
-        :type operation_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._cancel_operation_serialize(
-            bank_id=bank_id,
-            operation_id=operation_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': "CancelOperationResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _cancel_operation_serialize(
-        self,
-        bank_id,
-        operation_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
-        if operation_id is not None:
-            _path_params['operation_id'] = operation_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}/operations/{operation_id}',
-            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 list_operations(
-        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,
-    ) -> OperationsListResponse:
-        """List async operations
-
-        Get a list of all async operations (pending and failed) for a specific agent, including error messages for failed operations
-
-        :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._list_operations_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': "OperationsListResponse",
-            '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 list_operations_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[OperationsListResponse]:
-        """List async operations
-
-        Get a list of all async operations (pending and failed) for a specific agent, including error messages for failed operations
-
-        :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._list_operations_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': "OperationsListResponse",
-            '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 list_operations_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:
-        """List async operations
-
-        Get a list of all async operations (pending and failed) for a specific agent, including error messages for failed operations
-
-        :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._list_operations_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': "OperationsListResponse",
-            '422': "HTTPValidationError",
-        }
-        response_data = await self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _list_operations_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}/operations',
-            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
-        )
-
-

hindsight-clients/python/hindsight_client_api/api_client.py

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

hindsight-clients/python/hindsight_client_api/docs/BankListItem.md

@@ -7,9 +7,9 @@ Bank list item with profile summary.
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **bank_id** | **str** |  | 
-**name** | **str** |  | [optional] 
+**name** | **str** |  | 
 **disposition** | [**DispositionTraits**](DispositionTraits.md) |  | 
-**background** | **str** |  | [optional] 
+**background** | **str** |  | 
 **created_at** | **str** |  | [optional] 
 **updated_at** | **str** |  | [optional] 
 

hindsight-clients/python/hindsight_client_api/docs/BankStatsResponse.md

@@ -1,39 +0,0 @@
-# BankStatsResponse
-
-Response model for bank statistics endpoint.
-
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**bank_id** | **str** |  | 
-**total_nodes** | **int** |  | 
-**total_links** | **int** |  | 
-**total_documents** | **int** |  | 
-**nodes_by_fact_type** | **Dict[str, int]** |  | 
-**links_by_link_type** | **Dict[str, int]** |  | 
-**links_by_fact_type** | **Dict[str, int]** |  | 
-**links_breakdown** | **Dict[str, Dict[str, int]]** |  | 
-**pending_operations** | **int** |  | 
-**failed_operations** | **int** |  | 
-
-## Example
-
-```python
-from hindsight_client_api.models.bank_stats_response import BankStatsResponse
-
-# TODO update the JSON string below
-json = "{}"
-# create an instance of BankStatsResponse from a JSON string
-bank_stats_response_instance = BankStatsResponse.from_json(json)
-# print the JSON string representation of the object
-print(BankStatsResponse.to_json())
-
-# convert the object into a dict
-bank_stats_response_dict = bank_stats_response_instance.to_dict()
-# create an instance of BankStatsResponse from a dict
-bank_stats_response_from_dict = BankStatsResponse.from_dict(bank_stats_response_dict)
-```
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
-

hindsight-clients/python/hindsight_client_api/docs/BanksApi.md

@@ -1,517 +0,0 @@
-# hindsight_client_api.BanksApi
-
-All URIs are relative to *http://localhost*
-
-Method | HTTP request | Description
-------------- | ------------- | -------------
-[**add_bank_background**](BanksApi.md#add_bank_background) | **POST** /v1/default/banks/{bank_id}/background | Add/merge memory bank background
-[**create_or_update_bank**](BanksApi.md#create_or_update_bank) | **PUT** /v1/default/banks/{bank_id} | Create or update memory bank
-[**delete_bank**](BanksApi.md#delete_bank) | **DELETE** /v1/default/banks/{bank_id} | Delete memory bank
-[**get_agent_stats**](BanksApi.md#get_agent_stats) | **GET** /v1/default/banks/{bank_id}/stats | Get statistics for memory bank
-[**get_bank_profile**](BanksApi.md#get_bank_profile) | **GET** /v1/default/banks/{bank_id}/profile | Get memory bank profile
-[**list_banks**](BanksApi.md#list_banks) | **GET** /v1/default/banks | List all memory banks
-[**update_bank_disposition**](BanksApi.md#update_bank_disposition) | **PUT** /v1/default/banks/{bank_id}/profile | Update memory bank disposition
-
-
-# **add_bank_background**
-> BackgroundResponse add_bank_background(bank_id, add_background_request, authorization=authorization)
-
-Add/merge memory bank background
-
-Add new background information or merge with existing. LLM intelligently resolves conflicts, normalizes to first person, and optionally infers disposition traits.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.add_background_request import AddBackgroundRequest
-from hindsight_client_api.models.background_response import BackgroundResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.BanksApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    add_background_request = hindsight_client_api.AddBackgroundRequest() # AddBackgroundRequest | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Add/merge memory bank background
-        api_response = await api_instance.add_bank_background(bank_id, add_background_request, authorization=authorization)
-        print("The response of BanksApi->add_bank_background:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling BanksApi->add_bank_background: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **add_background_request** | [**AddBackgroundRequest**](AddBackgroundRequest.md)|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**BackgroundResponse**](BackgroundResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: application/json
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **create_or_update_bank**
-> BankProfileResponse create_or_update_bank(bank_id, create_bank_request, authorization=authorization)
-
-Create or update memory bank
-
-Create a new agent or update existing agent with disposition and background. Auto-fills missing fields with defaults.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.bank_profile_response import BankProfileResponse
-from hindsight_client_api.models.create_bank_request import CreateBankRequest
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.BanksApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    create_bank_request = hindsight_client_api.CreateBankRequest() # CreateBankRequest | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Create or update memory bank
-        api_response = await api_instance.create_or_update_bank(bank_id, create_bank_request, authorization=authorization)
-        print("The response of BanksApi->create_or_update_bank:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling BanksApi->create_or_update_bank: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **create_bank_request** | [**CreateBankRequest**](CreateBankRequest.md)|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**BankProfileResponse**](BankProfileResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: application/json
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **delete_bank**
-> DeleteResponse delete_bank(bank_id, authorization=authorization)
-
-Delete memory bank
-
-Delete an entire memory bank including all memories, entities, documents, and the bank profile itself. This is a destructive operation that cannot be undone.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.delete_response import DeleteResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.BanksApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Delete memory bank
-        api_response = await api_instance.delete_bank(bank_id, authorization=authorization)
-        print("The response of BanksApi->delete_bank:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling BanksApi->delete_bank: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**DeleteResponse**](DeleteResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **get_agent_stats**
-> BankStatsResponse get_agent_stats(bank_id)
-
-Get statistics for memory bank
-
-Get statistics about nodes and links for a specific agent
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.bank_stats_response import BankStatsResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.BanksApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-
-    try:
-        # Get statistics for memory bank
-        api_response = await api_instance.get_agent_stats(bank_id)
-        print("The response of BanksApi->get_agent_stats:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling BanksApi->get_agent_stats: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
-
-### Return type
-
-[**BankStatsResponse**](BankStatsResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **get_bank_profile**
-> BankProfileResponse get_bank_profile(bank_id, authorization=authorization)
-
-Get memory bank profile
-
-Get disposition traits and background for a memory bank. Auto-creates agent with defaults if not exists.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.bank_profile_response import BankProfileResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.BanksApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Get memory bank profile
-        api_response = await api_instance.get_bank_profile(bank_id, authorization=authorization)
-        print("The response of BanksApi->get_bank_profile:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling BanksApi->get_bank_profile: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**BankProfileResponse**](BankProfileResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **list_banks**
-> BankListResponse list_banks(authorization=authorization)
-
-List all memory banks
-
-Get a list of all agents with their profiles
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.bank_list_response import BankListResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.BanksApi(api_client)
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # List all memory banks
-        api_response = await api_instance.list_banks(authorization=authorization)
-        print("The response of BanksApi->list_banks:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling BanksApi->list_banks: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**BankListResponse**](BankListResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **update_bank_disposition**
-> BankProfileResponse update_bank_disposition(bank_id, update_disposition_request, authorization=authorization)
-
-Update memory bank disposition
-
-Update bank's disposition traits (skepticism, literalism, empathy)
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.bank_profile_response import BankProfileResponse
-from hindsight_client_api.models.update_disposition_request import UpdateDispositionRequest
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.BanksApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    update_disposition_request = hindsight_client_api.UpdateDispositionRequest() # UpdateDispositionRequest | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Update memory bank disposition
-        api_response = await api_instance.update_bank_disposition(bank_id, update_disposition_request, authorization=authorization)
-        print("The response of BanksApi->update_bank_disposition:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling BanksApi->update_bank_disposition: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **update_disposition_request** | [**UpdateDispositionRequest**](UpdateDispositionRequest.md)|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**BankProfileResponse**](BankProfileResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: application/json
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-

hindsight-clients/python/hindsight_client_api/docs/CancelOperationResponse.md

@@ -1,32 +0,0 @@
-# CancelOperationResponse
-
-Response model for cancel operation endpoint.
-
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**success** | **bool** |  | 
-**message** | **str** |  | 
-**operation_id** | **str** |  | 
-
-## Example
-
-```python
-from hindsight_client_api.models.cancel_operation_response import CancelOperationResponse
-
-# TODO update the JSON string below
-json = "{}"
-# create an instance of CancelOperationResponse from a JSON string
-cancel_operation_response_instance = CancelOperationResponse.from_json(json)
-# print the JSON string representation of the object
-print(CancelOperationResponse.to_json())
-
-# convert the object into a dict
-cancel_operation_response_dict = cancel_operation_response_instance.to_dict()
-# create an instance of CancelOperationResponse from a dict
-cancel_operation_response_from_dict = CancelOperationResponse.from_dict(cancel_operation_response_dict)
-```
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
-

hindsight-clients/python/hindsight_client_api/docs/DeleteDocumentResponse.md

@@ -1,33 +0,0 @@
-# DeleteDocumentResponse
-
-Response model for delete document endpoint.
-
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**success** | **bool** |  | 
-**message** | **str** |  | 
-**document_id** | **str** |  | 
-**memory_units_deleted** | **int** |  | 
-
-## Example
-
-```python
-from hindsight_client_api.models.delete_document_response import DeleteDocumentResponse
-
-# TODO update the JSON string below
-json = "{}"
-# create an instance of DeleteDocumentResponse from a JSON string
-delete_document_response_instance = DeleteDocumentResponse.from_json(json)
-# print the JSON string representation of the object
-print(DeleteDocumentResponse.to_json())
-
-# convert the object into a dict
-delete_document_response_dict = delete_document_response_instance.to_dict()
-# create an instance of DeleteDocumentResponse from a dict
-delete_document_response_from_dict = DeleteDocumentResponse.from_dict(delete_document_response_dict)
-```
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
-

hindsight-clients/python/hindsight_client_api/docs/DeleteResponse.md

@@ -7,8 +7,6 @@ Response model for delete operations.
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **success** | **bool** |  | 
-**message** | **str** |  | [optional] 
-**deleted_count** | **int** |  | [optional] 
 
 ## Example
 

hindsight-clients/python/hindsight_client_api/docs/DocumentsApi.md

@@ -1,313 +0,0 @@
-# hindsight_client_api.DocumentsApi
-
-All URIs are relative to *http://localhost*
-
-Method | HTTP request | Description
-------------- | ------------- | -------------
-[**delete_document**](DocumentsApi.md#delete_document) | **DELETE** /v1/default/banks/{bank_id}/documents/{document_id} | Delete a document
-[**get_chunk**](DocumentsApi.md#get_chunk) | **GET** /v1/default/chunks/{chunk_id} | Get chunk details
-[**get_document**](DocumentsApi.md#get_document) | **GET** /v1/default/banks/{bank_id}/documents/{document_id} | Get document details
-[**list_documents**](DocumentsApi.md#list_documents) | **GET** /v1/default/banks/{bank_id}/documents | List documents
-
-
-# **delete_document**
-> DeleteDocumentResponse delete_document(bank_id, document_id, authorization=authorization)
-
-Delete a document
-
-Delete a document and all its associated memory units and links.
-
-This will cascade delete:
-- The document itself
-- All memory units extracted from this document
-- All links (temporal, semantic, entity) associated with those memory units
-
-This operation cannot be undone.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.delete_document_response import DeleteDocumentResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.DocumentsApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    document_id = 'document_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Delete a document
-        api_response = await api_instance.delete_document(bank_id, document_id, authorization=authorization)
-        print("The response of DocumentsApi->delete_document:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling DocumentsApi->delete_document: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **document_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**DeleteDocumentResponse**](DeleteDocumentResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **get_chunk**
-> ChunkResponse get_chunk(chunk_id, authorization=authorization)
-
-Get chunk details
-
-Get a specific chunk by its ID
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.chunk_response import ChunkResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.DocumentsApi(api_client)
-    chunk_id = 'chunk_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Get chunk details
-        api_response = await api_instance.get_chunk(chunk_id, authorization=authorization)
-        print("The response of DocumentsApi->get_chunk:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling DocumentsApi->get_chunk: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **chunk_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**ChunkResponse**](ChunkResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **get_document**
-> DocumentResponse get_document(bank_id, document_id, authorization=authorization)
-
-Get document details
-
-Get a specific document including its original text
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.document_response import DocumentResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.DocumentsApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    document_id = 'document_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Get document details
-        api_response = await api_instance.get_document(bank_id, document_id, authorization=authorization)
-        print("The response of DocumentsApi->get_document:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling DocumentsApi->get_document: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **document_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**DocumentResponse**](DocumentResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **list_documents**
-> ListDocumentsResponse list_documents(bank_id, q=q, limit=limit, offset=offset, authorization=authorization)
-
-List documents
-
-List documents with pagination and optional search. Documents are the source content from which memory units are extracted.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.list_documents_response import ListDocumentsResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.DocumentsApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    q = 'q_example' # str |  (optional)
-    limit = 100 # int |  (optional) (default to 100)
-    offset = 0 # int |  (optional) (default to 0)
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # List documents
-        api_response = await api_instance.list_documents(bank_id, q=q, limit=limit, offset=offset, authorization=authorization)
-        print("The response of DocumentsApi->list_documents:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling DocumentsApi->list_documents: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **q** | **str**|  | [optional] 
- **limit** | **int**|  | [optional] [default to 100]
- **offset** | **int**|  | [optional] [default to 0]
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**ListDocumentsResponse**](ListDocumentsResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-

hindsight-clients/python/hindsight_client_api/docs/EntitiesApi.md

@@ -1,230 +0,0 @@
-# hindsight_client_api.EntitiesApi
-
-All URIs are relative to *http://localhost*
-
-Method | HTTP request | Description
-------------- | ------------- | -------------
-[**get_entity**](EntitiesApi.md#get_entity) | **GET** /v1/default/banks/{bank_id}/entities/{entity_id} | Get entity details
-[**list_entities**](EntitiesApi.md#list_entities) | **GET** /v1/default/banks/{bank_id}/entities | List entities
-[**regenerate_entity_observations**](EntitiesApi.md#regenerate_entity_observations) | **POST** /v1/default/banks/{bank_id}/entities/{entity_id}/regenerate | Regenerate entity observations
-
-
-# **get_entity**
-> EntityDetailResponse get_entity(bank_id, entity_id, authorization=authorization)
-
-Get entity details
-
-Get detailed information about an entity including observations (mental model).
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.entity_detail_response import EntityDetailResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.EntitiesApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    entity_id = 'entity_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Get entity details
-        api_response = await api_instance.get_entity(bank_id, entity_id, authorization=authorization)
-        print("The response of EntitiesApi->get_entity:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling EntitiesApi->get_entity: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **entity_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**EntityDetailResponse**](EntityDetailResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **list_entities**
-> EntityListResponse list_entities(bank_id, limit=limit, authorization=authorization)
-
-List entities
-
-List all entities (people, organizations, etc.) known by the bank, ordered by mention count.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.entity_list_response import EntityListResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.EntitiesApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    limit = 100 # int | Maximum number of entities to return (optional) (default to 100)
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # List entities
-        api_response = await api_instance.list_entities(bank_id, limit=limit, authorization=authorization)
-        print("The response of EntitiesApi->list_entities:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling EntitiesApi->list_entities: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **limit** | **int**| Maximum number of entities to return | [optional] [default to 100]
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**EntityListResponse**](EntityListResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **regenerate_entity_observations**
-> EntityDetailResponse regenerate_entity_observations(bank_id, entity_id, authorization=authorization)
-
-Regenerate entity observations
-
-Regenerate observations for an entity based on all facts mentioning it.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.entity_detail_response import EntityDetailResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.EntitiesApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    entity_id = 'entity_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Regenerate entity observations
-        api_response = await api_instance.regenerate_entity_observations(bank_id, entity_id, authorization=authorization)
-        print("The response of EntitiesApi->regenerate_entity_observations:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling EntitiesApi->regenerate_entity_observations: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **entity_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**EntityDetailResponse**](EntityDetailResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-

hindsight-clients/python/hindsight_client_api/docs/MemoryApi.md

@@ -1,499 +0,0 @@
-# hindsight_client_api.MemoryApi
-
-All URIs are relative to *http://localhost*
-
-Method | HTTP request | Description
-------------- | ------------- | -------------
-[**clear_bank_memories**](MemoryApi.md#clear_bank_memories) | **DELETE** /v1/default/banks/{bank_id}/memories | Clear memory bank memories
-[**get_graph**](MemoryApi.md#get_graph) | **GET** /v1/default/banks/{bank_id}/graph | Get memory graph data
-[**list_memories**](MemoryApi.md#list_memories) | **GET** /v1/default/banks/{bank_id}/memories/list | List memory units
-[**recall_memories**](MemoryApi.md#recall_memories) | **POST** /v1/default/banks/{bank_id}/memories/recall | Recall memory
-[**reflect**](MemoryApi.md#reflect) | **POST** /v1/default/banks/{bank_id}/reflect | Reflect and generate answer
-[**retain_memories**](MemoryApi.md#retain_memories) | **POST** /v1/default/banks/{bank_id}/memories | Retain memories
-
-
-# **clear_bank_memories**
-> DeleteResponse clear_bank_memories(bank_id, type=type, authorization=authorization)
-
-Clear memory bank memories
-
-Delete memory units for a memory bank. Optionally filter by type (world, experience, opinion) to delete only specific types. This is a destructive operation that cannot be undone. The bank profile (disposition and background) will be preserved.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.delete_response import DeleteResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.MemoryApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    type = 'type_example' # str | Optional fact type filter (world, experience, opinion) (optional)
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Clear memory bank memories
-        api_response = await api_instance.clear_bank_memories(bank_id, type=type, authorization=authorization)
-        print("The response of MemoryApi->clear_bank_memories:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling MemoryApi->clear_bank_memories: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **type** | **str**| Optional fact type filter (world, experience, opinion) | [optional] 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**DeleteResponse**](DeleteResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **get_graph**
-> GraphDataResponse get_graph(bank_id, type=type, authorization=authorization)
-
-Get memory graph data
-
-Retrieve graph data for visualization, optionally filtered by type (world/experience/opinion). Limited to 1000 most recent items.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.graph_data_response import GraphDataResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.MemoryApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    type = 'type_example' # str |  (optional)
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Get memory graph data
-        api_response = await api_instance.get_graph(bank_id, type=type, authorization=authorization)
-        print("The response of MemoryApi->get_graph:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling MemoryApi->get_graph: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **type** | **str**|  | [optional] 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**GraphDataResponse**](GraphDataResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **list_memories**
-> ListMemoryUnitsResponse list_memories(bank_id, type=type, q=q, limit=limit, offset=offset, authorization=authorization)
-
-List memory units
-
-List memory units with pagination and optional full-text search. Supports filtering by type. Results are sorted by most recent first (mentioned_at DESC, then created_at DESC).
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.list_memory_units_response import ListMemoryUnitsResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.MemoryApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    type = 'type_example' # str |  (optional)
-    q = 'q_example' # str |  (optional)
-    limit = 100 # int |  (optional) (default to 100)
-    offset = 0 # int |  (optional) (default to 0)
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # List memory units
-        api_response = await api_instance.list_memories(bank_id, type=type, q=q, limit=limit, offset=offset, authorization=authorization)
-        print("The response of MemoryApi->list_memories:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling MemoryApi->list_memories: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **type** | **str**|  | [optional] 
- **q** | **str**|  | [optional] 
- **limit** | **int**|  | [optional] [default to 100]
- **offset** | **int**|  | [optional] [default to 0]
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**ListMemoryUnitsResponse**](ListMemoryUnitsResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **recall_memories**
-> RecallResponse recall_memories(bank_id, recall_request, authorization=authorization)
-
-Recall memory
-
-Recall memory using semantic similarity and spreading activation.
-
-The type parameter is optional and must be one of:
-- `world`: General knowledge about people, places, events, and things that happen
-- `experience`: Memories about experience, conversations, actions taken, and tasks performed
-- `opinion`: The bank's formed beliefs, perspectives, and viewpoints
-
-Set `include_entities=true` to get entity observations alongside recall results.
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.recall_request import RecallRequest
-from hindsight_client_api.models.recall_response import RecallResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.MemoryApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    recall_request = hindsight_client_api.RecallRequest() # RecallRequest | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Recall memory
-        api_response = await api_instance.recall_memories(bank_id, recall_request, authorization=authorization)
-        print("The response of MemoryApi->recall_memories:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling MemoryApi->recall_memories: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **recall_request** | [**RecallRequest**](RecallRequest.md)|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**RecallResponse**](RecallResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: application/json
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **reflect**
-> ReflectResponse reflect(bank_id, reflect_request, authorization=authorization)
-
-Reflect and generate answer
-
-Reflect and formulate an answer using bank identity, world facts, and opinions.
-
-This endpoint:
-1. Retrieves experience (conversations and events)
-2. Retrieves world facts relevant to the query
-3. Retrieves existing opinions (bank's perspectives)
-4. Uses LLM to formulate a contextual answer
-5. Extracts and stores any new opinions formed
-6. Returns plain text answer, the facts used, and new opinions
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.reflect_request import ReflectRequest
-from hindsight_client_api.models.reflect_response import ReflectResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.MemoryApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    reflect_request = hindsight_client_api.ReflectRequest() # ReflectRequest | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Reflect and generate answer
-        api_response = await api_instance.reflect(bank_id, reflect_request, authorization=authorization)
-        print("The response of MemoryApi->reflect:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling MemoryApi->reflect: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **reflect_request** | [**ReflectRequest**](ReflectRequest.md)|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**ReflectResponse**](ReflectResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: application/json
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **retain_memories**
-> RetainResponse retain_memories(bank_id, retain_request, authorization=authorization)
-
-Retain memories
-
-Retain memory items with automatic fact extraction.
-
-This is the main endpoint for storing memories. It supports both synchronous and asynchronous processing via the `async` parameter.
-
-**Features:**
-- Efficient batch processing
-- Automatic fact extraction from natural language
-- Entity recognition and linking
-- Document tracking with automatic upsert (when document_id is provided)
-- Temporal and semantic linking
-- Optional asynchronous processing
-
-**The system automatically:**
-1. Extracts semantic facts from the content
-2. Generates embeddings
-3. Deduplicates similar facts
-4. Creates temporal, semantic, and entity links
-5. Tracks document metadata
-
-**When `async=true`:** Returns immediately after queuing. Use the operations endpoint to monitor progress.
-
-**When `async=false` (default):** Waits for processing to complete.
-
-**Note:** If a memory item has a `document_id` that already exists, the old document and its memory units will be deleted before creating new ones (upsert behavior).
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.retain_request import RetainRequest
-from hindsight_client_api.models.retain_response import RetainResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.MemoryApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    retain_request = hindsight_client_api.RetainRequest() # RetainRequest | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Retain memories
-        api_response = await api_instance.retain_memories(bank_id, retain_request, authorization=authorization)
-        print("The response of MemoryApi->retain_memories:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling MemoryApi->retain_memories: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **retain_request** | [**RetainRequest**](RetainRequest.md)|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**RetainResponse**](RetainResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: application/json
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-

hindsight-clients/python/hindsight_client_api/docs/OperationResponse.md

@@ -1,36 +0,0 @@
-# OperationResponse
-
-Response model for a single async operation.
-
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**id** | **str** |  | 
-**task_type** | **str** |  | 
-**items_count** | **int** |  | 
-**document_id** | **str** |  | 
-**created_at** | **str** |  | 
-**status** | **str** |  | 
-**error_message** | **str** |  | 
-
-## Example
-
-```python
-from hindsight_client_api.models.operation_response import OperationResponse
-
-# TODO update the JSON string below
-json = "{}"
-# create an instance of OperationResponse from a JSON string
-operation_response_instance = OperationResponse.from_json(json)
-# print the JSON string representation of the object
-print(OperationResponse.to_json())
-
-# convert the object into a dict
-operation_response_dict = operation_response_instance.to_dict()
-# create an instance of OperationResponse from a dict
-operation_response_from_dict = OperationResponse.from_dict(operation_response_dict)
-```
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
-

hindsight-clients/python/hindsight_client_api/docs/OperationsApi.md

@@ -1,154 +0,0 @@
-# hindsight_client_api.OperationsApi
-
-All URIs are relative to *http://localhost*
-
-Method | HTTP request | Description
-------------- | ------------- | -------------
-[**cancel_operation**](OperationsApi.md#cancel_operation) | **DELETE** /v1/default/banks/{bank_id}/operations/{operation_id} | Cancel a pending async operation
-[**list_operations**](OperationsApi.md#list_operations) | **GET** /v1/default/banks/{bank_id}/operations | List async operations
-
-
-# **cancel_operation**
-> CancelOperationResponse cancel_operation(bank_id, operation_id, authorization=authorization)
-
-Cancel a pending async operation
-
-Cancel a pending async operation by removing it from the queue
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.cancel_operation_response import CancelOperationResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.OperationsApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    operation_id = 'operation_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # Cancel a pending async operation
-        api_response = await api_instance.cancel_operation(bank_id, operation_id, authorization=authorization)
-        print("The response of OperationsApi->cancel_operation:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling OperationsApi->cancel_operation: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **operation_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**CancelOperationResponse**](CancelOperationResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-# **list_operations**
-> OperationsListResponse list_operations(bank_id, authorization=authorization)
-
-List async operations
-
-Get a list of all async operations (pending and failed) for a specific agent, including error messages for failed operations
-
-### Example
-
-
-```python
-import hindsight_client_api
-from hindsight_client_api.models.operations_list_response import OperationsListResponse
-from hindsight_client_api.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to http://localhost
-# See configuration.py for a list of all supported configuration parameters.
-configuration = hindsight_client_api.Configuration(
-    host = "http://localhost"
-)
-
-
-# Enter a context with an instance of the API client
-async with hindsight_client_api.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = hindsight_client_api.OperationsApi(api_client)
-    bank_id = 'bank_id_example' # str | 
-    authorization = 'authorization_example' # str |  (optional)
-
-    try:
-        # List async operations
-        api_response = await api_instance.list_operations(bank_id, authorization=authorization)
-        print("The response of OperationsApi->list_operations:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling OperationsApi->list_operations: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
-------------- | ------------- | ------------- | -------------
- **bank_id** | **str**|  | 
- **authorization** | **str**|  | [optional] 
-
-### Return type
-
-[**OperationsListResponse**](OperationsListResponse.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | Successful Response |  -  |
-**422** | Validation Error |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-

hindsight-clients/python/hindsight_client_api/docs/OperationsListResponse.md

@@ -1,31 +0,0 @@
-# OperationsListResponse
-
-Response model for list operations endpoint.
-
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**bank_id** | **str** |  | 
-**operations** | [**List[OperationResponse]**](OperationResponse.md) |  | 
-
-## Example
-
-```python
-from hindsight_client_api.models.operations_list_response import OperationsListResponse
-
-# TODO update the JSON string below
-json = "{}"
-# create an instance of OperationsListResponse from a JSON string
-operations_list_response_instance = OperationsListResponse.from_json(json)
-# print the JSON string representation of the object
-print(OperationsListResponse.to_json())
-
-# convert the object into a dict
-operations_list_response_dict = operations_list_response_instance.to_dict()
-# create an instance of OperationsListResponse from a dict
-operations_list_response_from_dict = OperationsListResponse.from_dict(operations_list_response_dict)
-```
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
-

hindsight-clients/python/hindsight_client_api/exceptions.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.1.0
+    The version of the OpenAPI document: 1.0.0
     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.1.0
+    The version of the OpenAPI document: 1.0.0
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -18,14 +18,11 @@ from hindsight_client_api.models.background_response import BackgroundResponse
 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.chunk_data import ChunkData
 from hindsight_client_api.models.chunk_include_options import ChunkIncludeOptions
 from hindsight_client_api.models.chunk_response import ChunkResponse
 from hindsight_client_api.models.create_bank_request import CreateBankRequest
-from hindsight_client_api.models.delete_document_response import DeleteDocumentResponse
 from hindsight_client_api.models.delete_response import DeleteResponse
 from hindsight_client_api.models.disposition_traits import DispositionTraits
 from hindsight_client_api.models.document_response import DocumentResponse
@@ -41,8 +38,6 @@ from hindsight_client_api.models.include_options import IncludeOptions
 from hindsight_client_api.models.list_documents_response import ListDocumentsResponse
 from hindsight_client_api.models.list_memory_units_response import ListMemoryUnitsResponse
 from hindsight_client_api.models.memory_item import MemoryItem
-from hindsight_client_api.models.operation_response import OperationResponse
-from hindsight_client_api.models.operations_list_response import OperationsListResponse
 from hindsight_client_api.models.recall_request import RecallRequest
 from hindsight_client_api.models.recall_response import RecallResponse
 from hindsight_client_api.models.recall_result import RecallResult