hindsight-api 0.0.13__py3-none-any.whl

hindsight_api/pg0.py

@@ -0,0 +1,425 @@
+import asyncio
+import json
+import logging
+import os
+import platform
+import re
+import shutil
+import stat
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# pg0 configuration
+BINARY_NAME = "pg0"
+DEFAULT_PORT = 5555
+DEFAULT_USERNAME = "hindsight"
+DEFAULT_PASSWORD = "hindsight"
+DEFAULT_DATABASE = "hindsight"
+
+
+def get_platform_binary_name() -> str:
+    """Get the appropriate binary name for the current platform.
+
+    Supported platforms:
+    - macOS ARM64 (darwin-aarch64)
+    - Linux x86_64 (gnu)
+    - Linux ARM64 (gnu)
+    - Windows x86_64
+    """
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    # Normalize architecture names
+    if machine in ("x86_64", "amd64"):
+        arch = "x86_64"
+    elif machine in ("arm64", "aarch64"):
+        arch = "aarch64"
+    else:
+        raise RuntimeError(
+            f"Embedded PostgreSQL is not supported on architecture: {machine}. "
+            f"Supported architectures: x86_64/amd64 (Linux, Windows), aarch64/arm64 (macOS, Linux)"
+        )
+
+    if system == "darwin" and arch == "aarch64":
+        return "pg0-darwin-aarch64"
+    elif system == "linux" and arch == "x86_64":
+        return "pg0-linux-x86_64-gnu"
+    elif system == "linux" and arch == "aarch64":
+        return "pg0-linux-aarch64-gnu"
+    elif system == "windows" and arch == "x86_64":
+        return "pg0-windows-x86_64.exe"
+    else:
+        raise RuntimeError(
+            f"Embedded PostgreSQL is not supported on {system}-{arch}. "
+            f"Supported platforms: darwin-aarch64 (macOS ARM), linux-x86_64-gnu, linux-aarch64-gnu, windows-x86_64"
+        )
+
+
+def get_download_url(
+    version: str = "latest",
+    repo: str = "vectorize-io/pg0",
+) -> str:
+    """Get the download URL for pg0 binary."""
+    binary_name = get_platform_binary_name()
+
+    if version == "latest":
+        return f"https://github.com/{repo}/releases/latest/download/{binary_name}"
+    else:
+        return f"https://github.com/{repo}/releases/download/{version}/{binary_name}"
+
+
+def _find_pg0_binary() -> Optional[Path]:
+    """Find pg0 binary in PATH or default install location."""
+    # First check PATH
+    pg0_in_path = shutil.which("pg0")
+    if pg0_in_path:
+        return Path(pg0_in_path)
+
+    # Fall back to default install location
+    default_path = Path.home() / ".hindsight" / "bin" / "pg0"
+    if default_path.exists() and os.access(default_path, os.X_OK):
+        return default_path
+
+    return None
+
+
+class EmbeddedPostgres:
+    """
+    Manages an embedded PostgreSQL server instance using pg0.
+
+    This class handles:
+    - Finding or downloading the pg0 CLI
+    - Starting/stopping the PostgreSQL server
+    - Getting the connection URI
+
+    Example:
+        pg = EmbeddedPostgres()
+        await pg.ensure_installed()
+        await pg.start()
+        uri = await pg.get_uri()
+        # ... use uri with asyncpg ...
+        await pg.stop()
+    """
+
+    def __init__(
+        self,
+        version: str = "latest",
+        port: int = DEFAULT_PORT,
+        username: str = DEFAULT_USERNAME,
+        password: str = DEFAULT_PASSWORD,
+        database: str = DEFAULT_DATABASE,
+        name: str = "hindsight",
+    ):
+        """
+        Initialize the embedded PostgreSQL manager.
+
+        Args:
+            version: Version of pg0 to download if not found. Defaults to "latest"
+            port: Port to listen on. Defaults to 5555
+            username: Username for the database. Defaults to "hindsight"
+            password: Password for the database. Defaults to "hindsight"
+            database: Database name to create. Defaults to "hindsight"
+            name: Instance name for pg0. Defaults to "hindsight"
+        """
+        self.version = version
+        self.port = port
+        self.username = username
+        self.password = password
+        self.database = database
+        self.name = name
+
+        # Will be set when binary is found/installed
+        self._binary_path: Optional[Path] = _find_pg0_binary()
+
+    @property
+    def binary_path(self) -> Path:
+        """Get the path to the pg0 binary."""
+        if self._binary_path is None:
+            # Default install location
+            return Path.home() / ".hindsight" / "bin" / "pg0"
+        return self._binary_path
+
+    def is_installed(self) -> bool:
+        """Check if pg0 is available (in PATH or installed)."""
+        self._binary_path = _find_pg0_binary()
+        return self._binary_path is not None
+
+    async def ensure_installed(self) -> None:
+        """
+        Ensure pg0 is available.
+
+        First checks PATH, then default location, then downloads if needed.
+        """
+        if self.is_installed():
+            logger.debug(f"pg0 found at {self._binary_path}")
+            return
+
+        logger.info("pg0 not found, downloading...")
+
+        # Log platform information
+        binary_name = get_platform_binary_name()
+        logger.info(f"Detected platform: system={platform.system()}, machine={platform.machine()}")
+
+        # Install to default location
+        install_dir = Path.home() / ".hindsight" / "bin"
+        install_dir.mkdir(parents=True, exist_ok=True)
+        install_path = install_dir / "pg0"
+
+        # Download the binary
+        download_url = get_download_url(self.version)
+        logger.info(f"Downloading from {download_url}")
+
+        try:
+            async with httpx.AsyncClient(follow_redirects=True, timeout=300.0) as client:
+                response = await client.get(download_url)
+                response.raise_for_status()
+
+                # Write binary to disk
+                with open(install_path, "wb") as f:
+                    f.write(response.content)
+
+                # Make executable on Unix
+                if platform.system() != "Windows":
+                    st = os.stat(install_path)
+                    os.chmod(install_path, st.st_mode | stat.S_IEXEC)
+
+                self._binary_path = install_path
+                logger.info(f"Installed pg0 to {install_path}")
+
+        except httpx.HTTPError as e:
+            raise RuntimeError(f"Failed to download pg0: {e}") from e
+
+    def _run_command(self, *args: str, capture_output: bool = True) -> subprocess.CompletedProcess:
+        """Run a pg0 command synchronously."""
+        cmd = [str(self.binary_path), *args]
+        return subprocess.run(cmd, capture_output=capture_output, text=True)
+
+    async def _run_command_async(self, *args: str, timeout: int = 120) -> tuple[int, str, str]:
+        """Run a pg0 command asynchronously."""
+        cmd = [str(self.binary_path), *args]
+
+        def run_sync():
+            try:
+                result = subprocess.run(
+                    cmd,
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    timeout=timeout,
+                )
+                return result.returncode, result.stdout, result.stderr
+            except subprocess.TimeoutExpired:
+                return 1, "", "Command timed out"
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, run_sync)
+
+    def _extract_uri_from_output(self, output: str) -> Optional[str]:
+        """Extract the PostgreSQL URI from pg0 start output."""
+        match = re.search(r"Connection URI:\s*(postgresql://[^\s]+)", output)
+        if match:
+            return match.group(1)
+        return None
+
+    async def start(self, max_retries: int = 3, retry_delay: float = 2.0) -> str:
+        """
+        Start the PostgreSQL server with retry logic.
+
+        Args:
+            max_retries: Maximum number of start attempts (default: 3)
+            retry_delay: Initial delay between retries in seconds (default: 2.0)
+
+        Returns:
+            The connection URI for the started server.
+
+        Raises:
+            RuntimeError: If the server fails to start after all retries.
+        """
+        if not self.is_installed():
+            raise RuntimeError("pg0 is not installed. Call ensure_installed() first.")
+
+        logger.info(f"Starting embedded PostgreSQL (name: {self.name}, port: {self.port})...")
+
+        last_error = None
+        for attempt in range(1, max_retries + 1):
+            returncode, stdout, stderr = await self._run_command_async(
+                "start",
+                "--name", self.name,
+                "--port", str(self.port),
+                "--username", self.username,
+                "--password", self.password,
+                "--database", self.database,
+                timeout=300,
+            )
+
+            # Try to extract URI from output
+            uri = self._extract_uri_from_output(stdout)
+            if uri:
+                logger.info(f"PostgreSQL started on port {self.port}")
+                return uri
+
+            # Check if pg0 info can find the running instance
+            try:
+                uri = await self.get_uri()
+                logger.info(f"PostgreSQL started on port {self.port}")
+                return uri
+            except RuntimeError:
+                pass
+
+            # Start failed, log and retry
+            last_error = stderr or f"pg0 start returned exit code {returncode}"
+            if attempt < max_retries:
+                delay = retry_delay * (2 ** (attempt - 1))
+                logger.warning(f"pg0 start attempt {attempt}/{max_retries} failed: {last_error.strip()}")
+                logger.info(f"Retrying in {delay:.1f}s...")
+                await asyncio.sleep(delay)
+            else:
+                logger.warning(f"pg0 start attempt {attempt}/{max_retries} failed: {last_error.strip()}")
+
+        # All retries exhausted - use constructed URI as fallback
+        uri = f"postgresql://{self.username}:{self.password}@localhost:{self.port}/{self.database}"
+        logger.warning(f"All pg0 start attempts failed, using constructed URI: {uri}")
+        return uri
+
+    async def stop(self) -> None:
+        """Stop the PostgreSQL server."""
+        if not self.is_installed():
+            return
+
+        logger.info(f"Stopping embedded PostgreSQL (name: {self.name})...")
+
+        returncode, stdout, stderr = await self._run_command_async("stop", "--name", self.name)
+
+        if returncode != 0:
+            if "not running" in stderr.lower():
+                return
+            raise RuntimeError(f"Failed to stop PostgreSQL: {stderr}")
+
+        logger.info("Embedded PostgreSQL stopped")
+
+    async def _get_info(self) -> dict:
+        """Get info from pg0 using the `info -o json` command."""
+        if not self.is_installed():
+            raise RuntimeError("pg0 is not installed.")
+
+        returncode, stdout, stderr = await self._run_command_async(
+            "info", "--name", self.name, "-o", "json"
+        )
+
+        if returncode != 0:
+            raise RuntimeError(f"Failed to get PostgreSQL info: {stderr}")
+
+        try:
+            return json.loads(stdout.strip())
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Failed to parse pg0 info output: {e}")
+
+    async def get_uri(self) -> str:
+        """Get the connection URI for the PostgreSQL server."""
+        info = await self._get_info()
+        uri = info.get("uri")
+        if not uri:
+            raise RuntimeError("PostgreSQL server is not running or URI not available")
+        return uri
+
+    async def status(self) -> dict:
+        """Get the status of the PostgreSQL server."""
+        if not self.is_installed():
+            return {"installed": False, "running": False}
+
+        try:
+            info = await self._get_info()
+            return {
+                "installed": True,
+                "running": info.get("running", False),
+                "uri": info.get("uri"),
+            }
+        except RuntimeError:
+            return {"installed": True, "running": False}
+
+    async def is_running(self) -> bool:
+        """Check if the PostgreSQL server is currently running."""
+        if not self.is_installed():
+            return False
+        try:
+            info = await self._get_info()
+            return info.get("running", False)
+        except RuntimeError:
+            return False
+
+    async def ensure_running(self) -> str:
+        """
+        Ensure the PostgreSQL server is running.
+
+        Installs if needed, starts if not running.
+
+        Returns:
+            The connection URI.
+        """
+        await self.ensure_installed()
+
+        if await self.is_running():
+            return await self.get_uri()
+
+        return await self.start()
+
+    def uninstall(self) -> None:
+        """Remove the pg0 binary (only if we installed it)."""
+        default_path = Path.home() / ".hindsight" / "bin" / "pg0"
+        if default_path.exists():
+            default_path.unlink()
+            logger.info(f"Removed {default_path}")
+
+    def clear_data(self) -> None:
+        """Remove all PostgreSQL data (destructive!)."""
+        result = self._run_command("drop", "--name", self.name, "--force")
+        if result.returncode == 0:
+            logger.info(f"Dropped pg0 instance {self.name}")
+        else:
+            logger.warning(f"Failed to drop pg0 instance {self.name}: {result.stderr}")
+
+
+# Convenience functions
+
+_default_instance: Optional[EmbeddedPostgres] = None
+
+
+def get_embedded_postgres() -> EmbeddedPostgres:
+    """Get or create the default EmbeddedPostgres instance."""
+    global _default_instance
+
+    if _default_instance is None:
+        _default_instance = EmbeddedPostgres()
+
+    return _default_instance
+
+
+async def start_embedded_postgres() -> str:
+    """
+    Quick start function for embedded PostgreSQL.
+
+    Downloads, installs, and starts PostgreSQL in one call.
+
+    Returns:
+        Connection URI string
+
+    Example:
+        db_url = await start_embedded_postgres()
+        conn = await asyncpg.connect(db_url)
+    """
+    pg = get_embedded_postgres()
+    return await pg.ensure_running()
+
+
+async def stop_embedded_postgres() -> None:
+    """Stop the default embedded PostgreSQL instance."""
+    global _default_instance
+
+    if _default_instance:
+        await _default_instance.stop()

hindsight_api/web/__init__.py

@@ -0,0 +1,12 @@
+"""
+Web interface for memory system.
+
+Provides FastAPI app and visualization interface.
+"""
+from hindsight_api.api import create_app
+
+# Note: Don't import app from .server here to avoid circular import warnings
+# when running with `python -m hindsight_api.web.server`
+# If you need the app, import it directly: from hindsight_api.web.server import app
+
+__all__ = ["create_app"]

hindsight_api/web/server.py

@@ -0,0 +1,143 @@
+"""
+FastAPI server for memory graph visualization and API.
+
+Provides REST API endpoints for memory operations and serves
+the interactive visualization interface.
+"""
+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")
+
+import asyncio
+import atexit
+import logging
+import os
+import argparse
+import signal
+import sys
+
+from hindsight_api import MemoryEngine
+from hindsight_api.api import create_app
+
+# Disable tokenizers parallelism to avoid warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+
+def _cleanup_pg0():
+    """Synchronous cleanup function to stop pg0 on exit."""
+    global _memory
+    if _memory is not None and _memory._pg0 is not None:
+        try:
+            # Run async stop in a new event loop
+            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}")
+
+
+# Register cleanup on normal exit
+atexit.register(_cleanup_pg0)
+
+
+def _signal_handler(signum, frame):
+    """Handle SIGINT/SIGTERM to ensure pg0 cleanup."""
+    print(f"\nReceived signal {signum}, shutting down...")
+    _cleanup_pg0()
+    sys.exit(0)
+
+
+# Register signal handlers for graceful shutdown
+signal.signal(signal.SIGINT, _signal_handler)
+signal.signal(signal.SIGTERM, _signal_handler)
+
+
+# Create app at module level (required for uvicorn import string)
+_memory = MemoryEngine(
+    db_url=os.getenv("HINDSIGHT_API_DATABASE_URL", "pg0"),
+    memory_llm_provider=os.getenv("HINDSIGHT_API_LLM_PROVIDER", "groq"),
+    memory_llm_api_key=os.getenv("HINDSIGHT_API_LLM_API_KEY"),
+    memory_llm_model=os.getenv("HINDSIGHT_API_LLM_MODEL", "openai/gpt-oss-120b"),
+    memory_llm_base_url=os.getenv("HINDSIGHT_API_LLM_BASE_URL") or None,
+)
+
+# Check if MCP should be enabled
+mcp_enabled = os.getenv("HINDSIGHT_API_MCP_ENABLED", "true").lower() == "true"
+
+# Create unified app with both HTTP and optionally MCP
+app = create_app(
+    memory=_memory,
+    http_api_enabled=True,
+    mcp_api_enabled=mcp_enabled,
+    mcp_mount_path="/mcp"
+)
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    # Get log level from environment variable (default: info)
+    env_log_level = os.environ.get("HINDSIGHT_API_LOG_LEVEL", "info").lower()
+    if env_log_level not in ["critical", "error", "warning", "info", "debug", "trace"]:
+        env_log_level = "info"
+
+    # Parse CLI arguments
+    parser = argparse.ArgumentParser(description="Memory Graph API Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8888, help="Port to bind to (default: 8888)")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload on code changes")
+    parser.add_argument("--workers", type=int, default=1, help="Number of worker processes (default: 1)")
+    parser.add_argument("--log-level", default=env_log_level, choices=["critical", "error", "warning", "info", "debug", "trace"],
+                        help=f"Log level (default: {env_log_level}, from HINDSIGHT_API_LOG_LEVEL)")
+    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")
+    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")
+    parser.add_argument("--ssl-keyfile", default=None, help="SSL key file")
+    parser.add_argument("--ssl-certfile", default=None, help="SSL certificate file")
+    parser.set_defaults(access_log=False)
+
+    args = parser.parse_args()
+
+    # Configure Python logging based on log level
+    log_level_map = {
+        "critical": logging.CRITICAL,
+        "error": logging.ERROR,
+        "warning": logging.WARNING,
+        "info": logging.INFO,
+        "debug": logging.DEBUG,
+        "trace": logging.DEBUG,  # Python doesn't have TRACE, use DEBUG
+    }
+    logging.basicConfig(
+        level=log_level_map.get(args.log_level, logging.INFO),
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+    )
+    logging.info(f"Starting Hindsight API on {args.host}:{args.port}")
+
+    app_ref = "hindsight_api.web.server:app"
+
+    # Prepare uvicorn config
+    uvicorn_config = {
+        "app": app_ref,
+        "host": args.host,
+        "port": args.port,
+        "reload": args.reload,
+        "workers": args.workers,
+        "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.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
+
+    uvicorn.run(**uvicorn_config)

hindsight_api-0.0.13.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: hindsight-api
+Version: 0.0.13
+Summary: Temporal + Semantic + Entity Memory System for AI agents using PostgreSQL
+Requires-Python: >=3.11
+Requires-Dist: alembic>=1.17.1
+Requires-Dist: asyncpg>=0.29.0
+Requires-Dist: dateparser>=1.2.2
+Requires-Dist: fastapi[standard]>=0.120.3
+Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: greenlet>=3.2.4
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: langchain-text-splitters>=0.3.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-exporter-prometheus>=0.41b0
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.41b0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: pgvector>=0.4.1
+Requires-Dist: psycopg2-binary>=2.9.11
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: sqlalchemy>=2.0.44
+Requires-Dist: tiktoken>=0.12.0
+Requires-Dist: torch>=2.0.0
+Requires-Dist: transformers>=4.30.0
+Requires-Dist: uvicorn>=0.38.0
+Requires-Dist: wsproto>=1.0.0
+Provides-Extra: test
+Requires-Dist: filelock>=3.0.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
+Requires-Dist: pytest-timeout>=2.4.0; extra == 'test'
+Requires-Dist: pytest-xdist>=3.0.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Requires-Dist: testcontainers[postgres]>=4.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Memory 

hindsight_api-0.0.13.dist-info/RECORD

@@ -0,0 +1,48 @@
+hindsight_api/__init__.py,sha256=yQWYWUWEhvs1OY1coENhZV_CuOAWmN_YKZXQMIvGN94,851
+hindsight_api/metrics.py,sha256=j4-eeqVjjcGQxAxS_GgEaBNm10KdUxrGS_I2d1IM1hY,7255
+hindsight_api/migrations.py,sha256=VY-ILJLWEY1IaeJgQ2jlAVUtPLzq_41Dytg_DjuF0GA,6402
+hindsight_api/models.py,sha256=1vMn9jmDQvohfmxZXr1SYnhz5vhz52nrTd93A_lkVNE,12606
+hindsight_api/pg0.py,sha256=scFcYngOwbZ2oOQb7TysnUHgNgPyiN30pjPcIqMDmao,14158
+hindsight_api/api/__init__.py,sha256=cDqM1tXOk1aq5Hy__vJ97O4XOQUB4Qt-ea_szTnbQ3o,3037
+hindsight_api/api/http.py,sha256=anjh8axWcWF1dyqW3CnE9TUObLKxryjeQxT_keQEMak,71551
+hindsight_api/api/mcp.py,sha256=NbRSbEGih7zCFMmwddLgD_UYv-WjvwYWHLq2-vzz4SA,7862
+hindsight_api/engine/__init__.py,sha256=5DU5DvnJdzkrgNgKchpzkiJr-37I-kE1tegJg2LF04k,1214
+hindsight_api/engine/cross_encoder.py,sha256=kfwLiqlQUfvOgLyrkRReO1wWlO020lGbLXY8U0jKiPA,2875
+hindsight_api/engine/db_utils.py,sha256=p1Ne70wPP327xdPI_XjMfnagilY8sknbkhEIZuED6DU,2724
+hindsight_api/engine/embeddings.py,sha256=a0wox2SCIE7ezgy-B5_23Cp1_icYiUR3g06hPpzi_ck,3586
+hindsight_api/engine/entity_resolver.py,sha256=y_KWDkWaJwKluhGgJYAr_Amg4GTzyJAnrmRKnsyevsk,21737
+hindsight_api/engine/llm_wrapper.py,sha256=HeAJDwNZjDkWR-6SVIrRJ7XmP4V-euciMrSLfjOLRYg,11378
+hindsight_api/engine/memory_engine.py,sha256=3vUcZRSUIOYCMf_R_tqDjT1Q3FpAoVSrhG026weJEYQ,127985
+hindsight_api/engine/query_analyzer.py,sha256=K0QCg7tsbqtwC7TR5wt3FPoP8QDuZsX9r0Zljc8nnYo,19733
+hindsight_api/engine/response_models.py,sha256=eRafLz6JTRUsTZadfZxffMYNEz6kho3cF31m8xc4t4c,8783
+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=fvUR7bAlStLJ1z_kbs3AuF2XzPrMtXgHCA1u8uoU5nI,14482
+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=meHOjsFzdvh1tbe6YlTofhcUs2Y6TcAN3S-0EKOvFP0,2705
+hindsight_api/engine/retain/fact_extraction.py,sha256=D7nnDn7U0UhsAwbo9qahPSpGxiRP-L5tdHT1JAIKM44,45254
+hindsight_api/engine/retain/fact_storage.py,sha256=gRRQf_FCLsj5lUvdlOaxJsS5JosM6IhO_pik8Ur8VFg,5717
+hindsight_api/engine/retain/link_creation.py,sha256=XJx7U3HboJLHtGgt_tHGsCa58lGo2ZyywzMNosrY9Xc,3154
+hindsight_api/engine/retain/link_utils.py,sha256=PAXalIhAPZGcJv8EugcpwNgoWZ2D_ciVU3brHL-m090,26226
+hindsight_api/engine/retain/orchestrator.py,sha256=I-EVH2REQLE3CypvWjcB9iZoJcl6dhXo3QPJMeWUz_4,17524
+hindsight_api/engine/retain/types.py,sha256=AJPYxMy0Fh7zje2TPKXjPnr1QxaU7aVBCvjfCaPqvt8,6218
+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/retrieval.py,sha256=kfQTU34LPLgB1QVcCAv7v2IPhOB2ag68xJ8RzvdSP10,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=OOrMKEpkHvMD0-vmLZPk18s2AISLqPCJO68CyRccQDI,9629
+hindsight_api/engine/search/trace.py,sha256=GT86_LVKMyG2mw6EJzPjafvbqaot6XVy5fZ033pMXG8,11036
+hindsight_api/engine/search/tracer.py,sha256=mcM9qZpj3YFudrBCESwc6YKNAiWIMx1lScXWn5ru-ok,15017
+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=oPNJ_z4DO38MdK7Juyh2LdH0ipZ_BQF48cUM-4B_Uw0,5379
+hindsight_api-0.0.13.dist-info/METADATA,sha256=Lr36kApNId06zH-6m9LNNXR4zYLefSBMn2NqCSnMN24,1496
+hindsight_api-0.0.13.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hindsight_api-0.0.13.dist-info/RECORD,,

hindsight_api-0.0.13.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any