hindsight-api 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

hindsight_api/engine/memory_engine.py

@@ -11,17 +11,20 @@ This implements a sophisticated memory architecture that combines:
 import json
 import os
 from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional, Tuple, Union, TypedDict
+from typing import Any, Dict, List, Optional, Tuple, Union, TypedDict, TYPE_CHECKING
 import asyncpg
 import asyncio
-from .embeddings import Embeddings, SentenceTransformersEmbeddings
-from .cross_encoder import CrossEncoderModel
+from .embeddings import Embeddings, create_embeddings_from_env
+from .cross_encoder import CrossEncoderModel, create_cross_encoder_from_env
 import time
 import numpy as np
 import uuid
 import logging
 from pydantic import BaseModel, Field
 
+if TYPE_CHECKING:
+    from ..config import HindsightConfig
+
 
 class RetainContentDict(TypedDict, total=False):
     """Type definition for content items in retain_batch_async.
@@ -99,10 +102,10 @@ class MemoryEngine:
 
     def __init__(
         self,
-        db_url: str,
-        memory_llm_provider: str,
-        memory_llm_api_key: str,
-        memory_llm_model: str,
+        db_url: Optional[str] = None,
+        memory_llm_provider: Optional[str] = None,
+        memory_llm_api_key: Optional[str] = None,
+        memory_llm_model: Optional[str] = None,
         memory_llm_base_url: Optional[str] = None,
         embeddings: Optional[Embeddings] = None,
         cross_encoder: Optional[CrossEncoderModel] = None,
@@ -115,26 +118,34 @@ class MemoryEngine:
         """
         Initialize the temporal + semantic memory system.
 
+        All parameters are optional and will be read from environment variables if not provided.
+        See hindsight_api.config for environment variable names and defaults.
+
         Args:
-            db_url: PostgreSQL connection URL (postgresql://user:pass@host:port/dbname). Required.
+            db_url: PostgreSQL connection URL. Defaults to HINDSIGHT_API_DATABASE_URL env var or "pg0".
                     Also supports pg0 URLs: "pg0" or "pg0://instance-name" or "pg0://instance-name:port"
-            memory_llm_provider: LLM provider for memory operations: "openai", "groq", or "ollama". Required.
-            memory_llm_api_key: API key for the LLM provider. Required.
-            memory_llm_model: Model name to use for all memory operations (put/think/opinions). Required.
-            memory_llm_base_url: Base URL for the LLM API. Optional. Defaults based on provider:
-                                - groq: https://api.groq.com/openai/v1
-                                - ollama: http://localhost:11434/v1
-            embeddings: Embeddings implementation to use. If not provided, uses SentenceTransformersEmbeddings
-            cross_encoder: Cross-encoder model for reranking. If not provided, uses default when cross-encoder reranker is selected
-            query_analyzer: Query analyzer implementation to use. If not provided, uses TransformerQueryAnalyzer
+            memory_llm_provider: LLM provider. Defaults to HINDSIGHT_API_LLM_PROVIDER env var or "groq".
+            memory_llm_api_key: API key for the LLM provider. Defaults to HINDSIGHT_API_LLM_API_KEY env var.
+            memory_llm_model: Model name. Defaults to HINDSIGHT_API_LLM_MODEL env var.
+            memory_llm_base_url: Base URL for the LLM API. Defaults based on provider.
+            embeddings: Embeddings implementation. If not provided, created from env vars.
+            cross_encoder: Cross-encoder model. If not provided, created from env vars.
+            query_analyzer: Query analyzer implementation. If not provided, uses DateparserQueryAnalyzer.
             pool_min_size: Minimum number of connections in the pool (default: 5)
             pool_max_size: Maximum number of connections in the pool (default: 100)
-                          Increase for parallel think/search operations (e.g., 200-300 for 100+ parallel thinks)
-            task_backend: Custom task backend for async task execution. If not provided, uses AsyncIOQueueBackend
+            task_backend: Custom task backend. If not provided, uses AsyncIOQueueBackend.
             run_migrations: Whether to run database migrations during initialize(). Default: True
         """
-        if not db_url:
-            raise ValueError("Database url is required")
+        # Load config from environment for any missing parameters
+        from ..config import get_config
+        config = get_config()
+
+        # Apply defaults from config
+        db_url = db_url or config.database_url
+        memory_llm_provider = memory_llm_provider or config.llm_provider
+        memory_llm_api_key = memory_llm_api_key or config.llm_api_key
+        memory_llm_model = memory_llm_model or config.llm_model
+        memory_llm_base_url = memory_llm_base_url or config.get_llm_base_url() or None
         # Track pg0 instance (if used)
         self._pg0: Optional[EmbeddedPostgres] = None
         self._pg0_instance_name: Optional[str] = None
@@ -184,11 +195,11 @@ class MemoryEngine:
         # Initialize entity resolver (will be created in initialize())
         self.entity_resolver = None
 
-        # Initialize embeddings
+        # Initialize embeddings (from env vars if not provided)
         if embeddings is not None:
             self.embeddings = embeddings
         else:
-            self.embeddings = SentenceTransformersEmbeddings("BAAI/bge-small-en-v1.5")
+            self.embeddings = create_embeddings_from_env()
 
         # Initialize query analyzer
         if query_analyzer is not None:
@@ -319,7 +330,7 @@ class MemoryEngine:
                 await self._handle_reinforce_opinion(task_dict)
             elif task_type == 'form_opinion':
                 await self._handle_form_opinion(task_dict)
-            elif task_type == 'batch_put':
+            elif task_type == 'batch_retain':
                 await self._handle_batch_retain(task_dict)
             elif task_type == 'regenerate_observations':
                 await self._handle_regenerate_observations(task_dict)
@@ -414,32 +425,41 @@ class MemoryEngine:
                 if not was_already_running:
                     self._pg0 = pg0
 
-        def load_embeddings():
-            """Load embedding model (CPU-bound)."""
-            self.embeddings.load()
-
-        def load_cross_encoder():
-            """Load cross-encoder model (CPU-bound)."""
-            self._cross_encoder_reranker.cross_encoder.load()
-
-        def load_query_analyzer():
-            """Load query analyzer model (CPU-bound)."""
-            self.query_analyzer.load()
-
-        # Run pg0 and all model loads in parallel
-        # pg0 is async (IO-bound), models are sync (CPU-bound in thread pool)
-        # Use 3 workers to load all models concurrently
-        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
-            # Start all tasks
-            pg0_task = asyncio.create_task(start_pg0())
-            embeddings_future = loop.run_in_executor(executor, load_embeddings)
-            cross_encoder_future = loop.run_in_executor(executor, load_cross_encoder)
-            query_analyzer_future = loop.run_in_executor(executor, load_query_analyzer)
-
-            # Wait for all to complete
-            await asyncio.gather(
-                pg0_task, embeddings_future, cross_encoder_future, query_analyzer_future
-            )
+        async def init_embeddings():
+            """Initialize embedding model."""
+            # For local providers, run in thread pool to avoid blocking event loop
+            if self.embeddings.provider_name == "local":
+                await loop.run_in_executor(
+                    None,
+                    lambda: asyncio.run(self.embeddings.initialize())
+                )
+            else:
+                await self.embeddings.initialize()
+
+        async def init_cross_encoder():
+            """Initialize cross-encoder model."""
+            cross_encoder = self._cross_encoder_reranker.cross_encoder
+            # For local providers, run in thread pool to avoid blocking event loop
+            if cross_encoder.provider_name == "local":
+                await loop.run_in_executor(
+                    None,
+                    lambda: asyncio.run(cross_encoder.initialize())
+                )
+            else:
+                await cross_encoder.initialize()
+
+        async def init_query_analyzer():
+            """Initialize query analyzer model."""
+            # Query analyzer load is sync and CPU-bound
+            await loop.run_in_executor(None, self.query_analyzer.load)
+
+        # Run pg0 and all model initializations in parallel
+        await asyncio.gather(
+            start_pg0(),
+            init_embeddings(),
+            init_cross_encoder(),
+            init_query_analyzer(),
+        )
 
         # Run database migrations if enabled
         if self._run_migrations:
@@ -2692,7 +2712,7 @@ Guidelines:
             ],
             scope="memory_think",
             temperature=0.9,
-            max_tokens=1000
+            max_completion_tokens=1000
         )
         llm_time = time.time() - llm_start
 

hindsight_api/engine/retain/bank_utils.py

@@ -273,7 +273,7 @@ Merged background:"""
                     response_format=BackgroundMergeResponse,
                     scope="bank_background",
                     temperature=0.3,
-                    max_tokens=8192
+                    max_completion_tokens=8192
                 )
                 logger.info(f"Successfully got structured response: background={parsed.background[:100]}")
 
@@ -291,7 +291,7 @@ Merged background:"""
             messages=messages,
             scope="bank_background",
             temperature=0.3,
-            max_tokens=8192
+            max_completion_tokens=8192
         )
 
         logger.info(f"LLM response for background merge (first 500 chars): {content[:500]}")

hindsight_api/engine/retain/fact_extraction.py

@@ -579,7 +579,7 @@ Text:
                 response_format=FactExtractionResponse,
                 scope="memory_extract_facts",
                 temperature=0.1,
-                max_tokens=65000,
+                max_completion_tokens=65000,
                 skip_validation=True,  # Get raw JSON, we'll validate leniently
             )
 

hindsight_api/engine/search/reranking.py

@@ -10,10 +10,8 @@ class CrossEncoderReranker:
     """
     Neural reranking using a cross-encoder model.
 
-    Uses cross-encoder/ms-marco-MiniLM-L-6-v2 by default:
-    - Fast inference (~80ms for 100 pairs on CPU)
-    - Small model (80MB)
-    - Trained for passage re-ranking
+    Configured via environment variables (see cross_encoder.py).
+    Default local model is cross-encoder/ms-marco-MiniLM-L-6-v2.
     """
 
     def __init__(self, cross_encoder=None):
@@ -21,14 +19,12 @@ class CrossEncoderReranker:
         Initialize cross-encoder reranker.
 
         Args:
-            cross_encoder: CrossEncoderReranker instance. If None, uses default
-                          SentenceTransformersCrossEncoder with ms-marco-MiniLM-L-6-v2
-                          (loaded lazily for faster startup)
+            cross_encoder: CrossEncoderModel instance. If None, creates one from
+                          environment variables (defaults to local provider)
         """
         if cross_encoder is None:
-            from hindsight_api.engine.cross_encoder import SentenceTransformersCrossEncoder
-            # Model is loaded lazily - call ensure_loaded() during initialize()
-            cross_encoder = SentenceTransformersCrossEncoder()
+            from hindsight_api.engine.cross_encoder import create_cross_encoder_from_env
+            cross_encoder = create_cross_encoder_from_env()
         self.cross_encoder = cross_encoder
 
     def rerank(

hindsight_api/engine/search/tracer.py

@@ -368,7 +368,7 @@ class SearchTracer:
 
             # Extract score components (only include non-None values)
             score_components = {}
-            for key in ["semantic_similarity", "bm25_score", "rrf_score", "recency_normalized", "frequency_normalized"]:
+            for key in ["semantic_similarity", "bm25_score", "rrf_score", "recency_normalized", "frequency_normalized", "cross_encoder_score", "cross_encoder_score_normalized"]:
                 if key in result and result[key] is not None:
                     score_components[key] = result[key]
 

hindsight_api/main.py

@@ -0,0 +1,201 @@
+"""
+Command-line interface for Hindsight API.
+
+Run the server with:
+    hindsight-api
+
+Stop with Ctrl+C.
+"""
+import argparse
+import asyncio
+import atexit
+import os
+import signal
+import sys
+import warnings
+from typing import Optional
+
+import uvicorn
+
+from . import MemoryEngine
+from .api import create_app
+from .config import get_config, HindsightConfig
+
+# Filter deprecation warnings from third-party libraries
+warnings.filterwarnings("ignore", message="websockets.legacy is deprecated")
+warnings.filterwarnings("ignore", message="websockets.server.WebSocketServerProtocol is deprecated")
+
+# Disable tokenizers parallelism to avoid warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# Global reference for cleanup
+_memory: Optional[MemoryEngine] = None
+
+
+def _cleanup():
+    """Synchronous cleanup function to stop resources on exit."""
+    global _memory
+    if _memory is not None and _memory._pg0 is not None:
+        try:
+            loop = asyncio.new_event_loop()
+            loop.run_until_complete(_memory._pg0.stop())
+            loop.close()
+            print("\npg0 stopped.")
+        except Exception as e:
+            print(f"\nError stopping pg0: {e}")
+
+
+def _signal_handler(signum, frame):
+    """Handle SIGINT/SIGTERM to ensure cleanup."""
+    print(f"\nReceived signal {signum}, shutting down...")
+    _cleanup()
+    sys.exit(0)
+
+
+def main():
+    """Main entry point for the CLI."""
+    global _memory
+
+    # Load configuration from environment (for CLI args defaults)
+    config = get_config()
+
+    parser = argparse.ArgumentParser(
+        prog="hindsight-api",
+        description="Hindsight API Server",
+    )
+
+    # Server options
+    parser.add_argument(
+        "--host", default=config.host,
+        help=f"Host to bind to (default: {config.host}, env: HINDSIGHT_API_HOST)"
+    )
+    parser.add_argument(
+        "--port", type=int, default=config.port,
+        help=f"Port to bind to (default: {config.port}, env: HINDSIGHT_API_PORT)"
+    )
+    parser.add_argument(
+        "--log-level", default=config.log_level,
+        choices=["critical", "error", "warning", "info", "debug", "trace"],
+        help=f"Log level (default: {config.log_level}, env: HINDSIGHT_API_LOG_LEVEL)"
+    )
+
+    # Development options
+    parser.add_argument(
+        "--reload", action="store_true",
+        help="Enable auto-reload on code changes (development only)"
+    )
+    parser.add_argument(
+        "--workers", type=int, default=1,
+        help="Number of worker processes (default: 1)"
+    )
+
+    # Access log options
+    parser.add_argument(
+        "--access-log", action="store_true",
+        help="Enable access log"
+    )
+    parser.add_argument(
+        "--no-access-log", dest="access_log", action="store_false",
+        help="Disable access log (default)"
+    )
+    parser.set_defaults(access_log=False)
+
+    # Proxy options
+    parser.add_argument(
+        "--proxy-headers", action="store_true",
+        help="Enable X-Forwarded-Proto, X-Forwarded-For headers"
+    )
+    parser.add_argument(
+        "--forwarded-allow-ips", default=None,
+        help="Comma separated list of IPs to trust with proxy headers"
+    )
+
+    # SSL options
+    parser.add_argument(
+        "--ssl-keyfile", default=None,
+        help="SSL key file"
+    )
+    parser.add_argument(
+        "--ssl-certfile", default=None,
+        help="SSL certificate file"
+    )
+
+    args = parser.parse_args()
+
+    # Configure Python logging based on log level
+    # Update config with CLI override if provided
+    if args.log_level != config.log_level:
+        config = HindsightConfig(
+            database_url=config.database_url,
+            llm_provider=config.llm_provider,
+            llm_api_key=config.llm_api_key,
+            llm_model=config.llm_model,
+            llm_base_url=config.llm_base_url,
+            embeddings_provider=config.embeddings_provider,
+            embeddings_local_model=config.embeddings_local_model,
+            embeddings_tei_url=config.embeddings_tei_url,
+            reranker_provider=config.reranker_provider,
+            reranker_local_model=config.reranker_local_model,
+            reranker_tei_url=config.reranker_tei_url,
+            host=args.host,
+            port=args.port,
+            log_level=args.log_level,
+            mcp_enabled=config.mcp_enabled,
+        )
+    config.configure_logging()
+
+    # Register cleanup handlers
+    atexit.register(_cleanup)
+    signal.signal(signal.SIGINT, _signal_handler)
+    signal.signal(signal.SIGTERM, _signal_handler)
+
+    # Create MemoryEngine (reads configuration from environment)
+    _memory = MemoryEngine()
+
+    # Create FastAPI app
+    app = create_app(
+        memory=_memory,
+        http_api_enabled=True,
+        mcp_api_enabled=config.mcp_enabled,
+        mcp_mount_path="/mcp",
+        initialize_memory=True,
+    )
+
+    # Prepare uvicorn config
+    uvicorn_config = {
+        "app": app,
+        "host": args.host,
+        "port": args.port,
+        "log_level": args.log_level,
+        "access_log": args.access_log,
+        "proxy_headers": args.proxy_headers,
+        "ws": "wsproto",  # Use wsproto instead of websockets to avoid deprecation warnings
+    }
+
+    # Add optional parameters if provided
+    if args.reload:
+        uvicorn_config["reload"] = True
+    if args.workers > 1:
+        uvicorn_config["workers"] = args.workers
+    if args.forwarded_allow_ips:
+        uvicorn_config["forwarded_allow_ips"] = args.forwarded_allow_ips
+    if args.ssl_keyfile:
+        uvicorn_config["ssl_keyfile"] = args.ssl_keyfile
+    if args.ssl_certfile:
+        uvicorn_config["ssl_certfile"] = args.ssl_certfile
+
+    print(f"\nStarting Hindsight API...")
+    print(f"  URL: http://{args.host}:{args.port}")
+    print(f"  Database: {config.database_url}")
+    print(f"  LLM: {config.llm_provider} / {config.llm_model}")
+    print(f"  Embeddings: {config.embeddings_provider}")
+    print(f"  Reranker: {config.reranker_provider}")
+    if config.mcp_enabled:
+        print(f"  MCP: enabled at /mcp")
+    print()
+
+    uvicorn.run(**uvicorn_config)
+
+
+if __name__ == "__main__":
+    main()

hindsight_api/migrations.py

@@ -88,11 +88,11 @@ def run_migrations(database_url: str, script_location: Optional[str] = None) ->
     try:
         # Determine script location
         if script_location is None:
-            # Default: use the alembic directory in the hindsight_api package
-            # This file is in: hindsight-api/hindsight_api/migrations.py
-            # Default location is: hindsight-api/alembic
-            package_root = Path(__file__).parent.parent
-            script_location = str(package_root / "alembic")
+            # Default: use the alembic directory inside the hindsight_api package
+            # This file is in: hindsight_api/migrations.py
+            # Alembic is in: hindsight_api/alembic/
+            package_dir = Path(__file__).parent
+            script_location = str(package_dir / "alembic")
 
         script_path = Path(script_location)
         if not script_path.exists():
@@ -162,8 +162,8 @@ def check_migration_status(database_url: Optional[str] = None, script_location:
 
         # Get head revision from migration scripts
         if script_location is None:
-            package_root = Path(__file__).parent.parent
-            script_location = str(package_root / "alembic")
+            package_dir = Path(__file__).parent
+            script_location = str(package_dir / "alembic")
 
         script_path = Path(script_location)
         if not script_path.exists():

hindsight_api/server.py

@@ -0,0 +1,43 @@
+"""
+FastAPI server for Hindsight API.
+
+This module provides the ASGI app for uvicorn import string usage:
+    uvicorn hindsight_api.server:app
+
+For CLI usage, use the hindsight-api command instead.
+"""
+import os
+import warnings
+
+# Filter deprecation warnings from third-party libraries
+warnings.filterwarnings("ignore", message="websockets.legacy is deprecated")
+warnings.filterwarnings("ignore", message="websockets.server.WebSocketServerProtocol is deprecated")
+
+from hindsight_api import MemoryEngine
+from hindsight_api.api import create_app
+from hindsight_api.config import get_config
+
+# Disable tokenizers parallelism to avoid warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# Load configuration and configure logging
+config = get_config()
+config.configure_logging()
+
+# Create app at module level (required for uvicorn import string)
+# MemoryEngine reads configuration from environment variables automatically
+_memory = MemoryEngine()
+
+# Create unified app with both HTTP and optionally MCP
+app = create_app(
+    memory=_memory,
+    http_api_enabled=True,
+    mcp_api_enabled=config.mcp_enabled,
+    mcp_mount_path="/mcp"
+)
+
+
+if __name__ == "__main__":
+    # When run directly, delegate to the CLI
+    from hindsight_api.main import main
+    main()

{hindsight_api-0.1.0.dist-info → hindsight_api-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hindsight-api
-Version: 0.1.0
+Version: 0.1.2
 Summary: Temporal + Semantic + Entity Memory System for AI agents using PostgreSQL
 Requires-Python: >=3.11
 Requires-Dist: alembic>=1.17.1

{hindsight_api-0.1.0.dist-info → hindsight_api-0.1.2.dist-info}/RECORD

@@ -1,31 +1,42 @@
-hindsight_api/__init__.py,sha256=yQWYWUWEhvs1OY1coENhZV_CuOAWmN_YKZXQMIvGN94,851
-hindsight_api/cli.py,sha256=NPuykf35Us8J40iV4-mrGk13d1GSt2TeBl5Nd88CY0I,3274
+hindsight_api/__init__.py,sha256=gPkRHnMATZqBgc7b-Mcro4f_gY9W0BlnGBE0zg1t_IY,1139
+hindsight_api/config.py,sha256=V29wimS9xCOP20lXL6VUJZZKB46YbD_8TV9LHUtJKng,5186
+hindsight_api/main.py,sha256=Tl_w0kM-bcB0Y37_rKv_RzGOj_ReMuio20JtSunz9aE,6079
 hindsight_api/metrics.py,sha256=j4-eeqVjjcGQxAxS_GgEaBNm10KdUxrGS_I2d1IM1hY,7255
-hindsight_api/migrations.py,sha256=A6D1LVuReJ7Ua10ABWyW2-neE7CtRErGWFipbVNH7mw,7382
+hindsight_api/migrations.py,sha256=nSbU37ZszVZifYJTU_vEXfusTxWaUea9dRi7-Ao3-SQ,7349
 hindsight_api/models.py,sha256=ncIi8agl3PVk7ffyXlJosFym1jJZZhVmXTguZ3EnAEc,12515
 hindsight_api/pg0.py,sha256=_GuVccjE0_OthaK72_GXC3NkcI9q3MkU3i8m685mDfQ,13542
+hindsight_api/server.py,sha256=C_w3_xzKRVkSsFkujhMz9S4nDlAc0eOFClGIefTCZIk,1263
+hindsight_api/alembic/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
+hindsight_api/alembic/env.py,sha256=i0gc3GN2rWidtqRp-vdvnJTIR0zl1X4Uokqp_WnTsAo,4837
+hindsight_api/alembic/script.py.mako,sha256=04kgeBtNMa4cCnG8CfQcKt6P6rnloIfj8wy0u_DBydM,704
+hindsight_api/alembic/versions/5a366d414dce_initial_schema.py,sha256=qTrvBWf-48sL2kx7eNq1BoDjF_QfePGq2-wKrK__wWk,16774
+hindsight_api/alembic/versions/b7c4d8e9f1a2_add_chunks_table.py,sha256=g0edMh_4w8WDVcnB-GA1l-RdreYJkV-kJWZX9VJHYp8,2592
+hindsight_api/alembic/versions/c8e5f2a3b4d1_add_retain_params_to_documents.py,sha256=brlAuHO5ygarkfsjW-p70NiVDGfj98BjczaptGPyYNg,1159
+hindsight_api/alembic/versions/d9f6a3b4c5e2_rename_bank_to_interactions.py,sha256=pLz_s5kV3IHQ3TrpvHmtXQOkdfK4iQ07w93dEsXu3Qk,1536
+hindsight_api/alembic/versions/e0a1b2c3d4e5_disposition_to_3_traits.py,sha256=fykAU4V4jq1wVpCBoH0TzvSFyeyxZtk-6hpaZAbrFxU,2327
+hindsight_api/alembic/versions/rename_personality_to_disposition.py,sha256=xlp-Is96e3TvCwSqhPctQRqLBHcl3dvDmlzbCMZGw1A,2196
 hindsight_api/api/__init__.py,sha256=dIJqoygqYaEgm-Bd7qwZ4UTnb9UPyXtlDxZnQpvVC0o,2946
-hindsight_api/api/http.py,sha256=7g6ij_Kegu5fSoqDIpPYWVS1cqxpD1Uc_0moQ5bbddA,69206
+hindsight_api/api/http.py,sha256=_vy70aWQ5TJlhXgIw6PbH0mrqat8_J_0rQwY73h24Pg,69863
 hindsight_api/api/mcp.py,sha256=DldtC8LQUguAbJSSHnEBS65wC-AQBjcF8rl51xUR1gQ,7808
-hindsight_api/engine/__init__.py,sha256=5DU5DvnJdzkrgNgKchpzkiJr-37I-kE1tegJg2LF04k,1214
-hindsight_api/engine/cross_encoder.py,sha256=8BBMyM5ryRuQ7W8x0jea4Y6GW3MtqtxyHGz1yyCXz2g,3175
+hindsight_api/engine/__init__.py,sha256=W_y6iAHgu-HUpvdXlI6JJ0KO42wVkrWvcUSJZqTCj_M,1406
+hindsight_api/engine/cross_encoder.py,sha256=D6iTTXv23R1n8O_IoAsBCsCbevZTNhnJSt4AirADksg,10789
 hindsight_api/engine/db_utils.py,sha256=p1Ne70wPP327xdPI_XjMfnagilY8sknbkhEIZuED6DU,2724
-hindsight_api/engine/embeddings.py,sha256=9drPQoK8LtertxsnI8GU24bPQtOJb8n3Uguhz6Nl_x0,3886
+hindsight_api/engine/embeddings.py,sha256=RdK9A3lUjp1FZFArllhTgKo70Pot4ZUEJ1Pw70BpNmk,10218
 hindsight_api/engine/entity_resolver.py,sha256=w5DPCuYNsK4GF8Qe3oY7jCKcOT1WYx2h0YD1nX0QRtA,23184
-hindsight_api/engine/llm_wrapper.py,sha256=Pro7r-bkilfqRH3x4E_k08p41kntRoCpJQ0FyrQBzJ0,22003
-hindsight_api/engine/memory_engine.py,sha256=dk3NjIQo-re8Y1rrRNDwukQdAqr5Yxe-Nuaf27XeCnU,133449
+hindsight_api/engine/llm_wrapper.py,sha256=v7XWms1uCj9Bev-Txy4iGhofZTQmA29aaudZCSD3UHs,18672
+hindsight_api/engine/memory_engine.py,sha256=QQz-5vD_Qh_0qFtNoWcynUQesw_Hyh8TZ3qzq4tTB7g,134144
 hindsight_api/engine/query_analyzer.py,sha256=K0QCg7tsbqtwC7TR5wt3FPoP8QDuZsX9r0Zljc8nnYo,19733
 hindsight_api/engine/response_models.py,sha256=e-_vE1zAVFLpkl6SeHIYvHcQ4Z-AaOdq0jjjhh8yHk4,8683
 hindsight_api/engine/task_backend.py,sha256=ojxMC9PeHdnkWVs2ozeqycjI_1mmpkDa0_Qfej9AHrg,7287
 hindsight_api/engine/utils.py,sha256=VAjpZSbdiwhlE6cDlYfTt_-5hIJ--0xtfixETK0LPSk,6910
 hindsight_api/engine/retain/__init__.py,sha256=L_QuR1YLHsJ7OCmVFNsZe8WDjbsTTHL-wCiUXtw1aUE,1230
-hindsight_api/engine/retain/bank_utils.py,sha256=j5vzmNwUvtx3kCIQgzSHCvByCvpIRjLbjx74r1XGEIg,14121
+hindsight_api/engine/retain/bank_utils.py,sha256=r-_411UuuQwxlIxEteA2GE_Wr9BdsNt0OVCjaJgcISU,14143
 hindsight_api/engine/retain/chunk_storage.py,sha256=rjmfnllS185tmjJGkMjWZ9q_6hJO4N6Ll9jgPx6f5xo,2081
 hindsight_api/engine/retain/deduplication.py,sha256=9YXgVI_m1Mtz5Cv46ZceCEs0GwpLqTPHrZ-vlWlXk6I,3313
 hindsight_api/engine/retain/embedding_processing.py,sha256=cHTt3rPvDCWBWVPfSeg6bwH8HoXYGmP4bvS21boNONI,1734
 hindsight_api/engine/retain/embedding_utils.py,sha256=Q24h_iw6pRAW2vDWPvauWY1o3bXLzW3eWvSxDALDiE0,1588
 hindsight_api/engine/retain/entity_processing.py,sha256=F_6yYjf7Me5khg-X57ZW4wK5BBAmzMpry-TXwVFQZ-8,2658
-hindsight_api/engine/retain/fact_extraction.py,sha256=ZBT--eKLcAW0a3GJ-TE7k_nzA_R4fJboEaakKx5W2iA,50807
+hindsight_api/engine/retain/fact_extraction.py,sha256=dZ0FYepvndUfWTowGxM5vrrF0NV_LIIGsANA6Ze6Mf4,50818
 hindsight_api/engine/retain/fact_storage.py,sha256=rKJiWr_1lrqyB6s0mTCnTiHVZIUbCfd3zigNwISnVPI,5637
 hindsight_api/engine/retain/link_creation.py,sha256=rkYKO73dWBL8BbRBeiwNgHzwrU-sKWUjmrgLIxr3LiA,3280
 hindsight_api/engine/retain/link_utils.py,sha256=g80xUMr45na8UX505VnoZ7jSKdvyRgxDHnDoINd8GNI,28828
@@ -35,17 +46,15 @@ hindsight_api/engine/retain/types.py,sha256=JJ4t8Qtp64kTPB9CKOFDXqdos2i8GZXmJZNz
 hindsight_api/engine/search/__init__.py,sha256=7X6U10bVw0JRWxQdE5RCfVpawDlSUldi1mPoCzY0V0A,363
 hindsight_api/engine/search/fusion.py,sha256=so6LU7kWRR-VJd1Pxlu8idRJ7P2WLCoDwXUnb8jQifo,4309
 hindsight_api/engine/search/observation_utils.py,sha256=SPrDx6M0daJ_zLLkk78GlQIG3EL7DqMKSu_etKerUfU,4331
-hindsight_api/engine/search/reranking.py,sha256=Bk5i5kal5yy4CM8m2uSxAumLPgLeHdncBX6wk4WTmEI,3525
+hindsight_api/engine/search/reranking.py,sha256=znjN78VfuT4PqprhGRPd2B9WtVMhAU5A662s0xCvU7g,3329
 hindsight_api/engine/search/retrieval.py,sha256=i6pffxsfYkTjQYS8iNMC60owMr__a8i7khkHb4LUWuI,19661
 hindsight_api/engine/search/scoring.py,sha256=feFPalpbIMndp8j2Ab0zvu7fRq3c43Wmzrjw3piQ0eM,5167
 hindsight_api/engine/search/temporal_extraction.py,sha256=5klrZdza3mkgk5A15_m_j4IIfOHMc6fUR9UJuzLa790,1812
 hindsight_api/engine/search/think_utils.py,sha256=VJJXFmBg03yO4Mg--UBMlTQW9IZOj2eyTZztjzhT8F8,11315
 hindsight_api/engine/search/trace.py,sha256=Hx-siW9yAfqZoK9LG6esbed0vQuHMNsGxSvCg4FK6-4,11042
-hindsight_api/engine/search/tracer.py,sha256=mcM9qZpj3YFudrBCESwc6YKNAiWIMx1lScXWn5ru-ok,15017
+hindsight_api/engine/search/tracer.py,sha256=LQ78knpMxyZmPUvm3PJNN2opCyA-LpB47JZ84n0g2pw,15074
 hindsight_api/engine/search/types.py,sha256=qIeHW_gT7f291vteTZXygAM8oAaPp2dq6uEdvOyOwzs,5488
-hindsight_api/web/__init__.py,sha256=WABqyqiAVFJJWOhKCytkj5Vcb61eAsRib3Ek7IMX6_U,378
-hindsight_api/web/server.py,sha256=l-Tw8G9IRdcSay-KWiUT4VlIJBzxbe-TV0rjX0fwLMc,4464
-hindsight_api-0.1.0.dist-info/METADATA,sha256=7KQUZY0Kcdl83K9zVA4gPVJAMOy12IxL7sr0PjI9EKs,1466
-hindsight_api-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-hindsight_api-0.1.0.dist-info/entry_points.txt,sha256=53Fn-VxtkqreZhOPTJB_FupH7e5GyiMY3gzEp22d8xs,57
-hindsight_api-0.1.0.dist-info/RECORD,,
+hindsight_api-0.1.2.dist-info/METADATA,sha256=lgnN2q6oLQ8zseo3n01WgcUv3DQAgRMZJ9PzGvP94y8,1466
+hindsight_api-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hindsight_api-0.1.2.dist-info/entry_points.txt,sha256=ZDj1gJCi6Ga6VLdPgRSrRizQ4dUTreefjeG_tO1CuHk,58
+hindsight_api-0.1.2.dist-info/RECORD,,

hindsight_api-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hindsight-api = hindsight_api.main:main