hindsight-api 0.0.21__py3-none-any.whl → 0.1.1__py3-none-any.whl

hindsight_api/engine/search/retrieval.py

@@ -170,9 +170,9 @@ async def retrieve_graph(
                 batch_activations[unit_id] = activation
 
         # Batch fetch neighbors for all nodes in this batch
-        # Fetch top weighted neighbors (batch_size * 10 = ~200 for good distribution)
+        # Fetch top weighted neighbors (batch_size * 20 = ~400 for good distribution)
         if batch_nodes and budget_remaining > 0:
-            max_neighbors = len(batch_nodes) * 10
+            max_neighbors = len(batch_nodes) * 20
             neighbors = await conn.fetch(
                 """
                 SELECT mu.id, mu.text, mu.context, mu.occurred_start, mu.occurred_end, mu.mentioned_at,

hindsight_api/engine/search/think_utils.py

@@ -28,30 +28,48 @@ class OpinionExtractionResponse(BaseModel):
     )
 
 
-def describe_trait(name: str, value: float) -> str:
-    """Convert trait value to descriptive text."""
-    if value >= 0.8:
-        return f"very high {name}"
-    elif value >= 0.6:
-        return f"high {name}"
-    elif value >= 0.4:
-        return f"moderate {name}"
-    elif value >= 0.2:
-        return f"low {name}"
-    else:
-        return f"very low {name}"
+def describe_trait_level(value: int) -> str:
+    """Convert trait value (1-5) to descriptive text."""
+    levels = {
+        1: "very low",
+        2: "low",
+        3: "moderate",
+        4: "high",
+        5: "very high"
+    }
+    return levels.get(value, "moderate")
 
 
 def build_disposition_description(disposition: DispositionTraits) -> str:
     """Build a disposition description string from disposition traits."""
-    return f"""Your disposition traits:
-- {describe_trait('openness to new ideas', disposition.openness)}
-- {describe_trait('conscientiousness and organization', disposition.conscientiousness)}
-- {describe_trait('extraversion and sociability', disposition.extraversion)}
-- {describe_trait('agreeableness and cooperation', disposition.agreeableness)}
-- {describe_trait('emotional sensitivity', disposition.neuroticism)}
+    skepticism_desc = {
+        1: "You are very trusting and tend to take information at face value.",
+        2: "You tend to trust information but may question obvious inconsistencies.",
+        3: "You have a balanced approach to information, neither too trusting nor too skeptical.",
+        4: "You are somewhat skeptical and often question the reliability of information.",
+        5: "You are highly skeptical and critically examine all information for accuracy and hidden motives."
+    }
+
+    literalism_desc = {
+        1: "You interpret information very flexibly, reading between the lines and inferring intent.",
+        2: "You tend to consider context and implied meaning alongside literal statements.",
+        3: "You balance literal interpretation with contextual understanding.",
+        4: "You prefer to interpret information more literally and precisely.",
+        5: "You interpret information very literally and focus on exact wording and commitments."
+    }
+
+    empathy_desc = {
+        1: "You focus primarily on facts and data, setting aside emotional context.",
+        2: "You consider facts first but acknowledge emotional factors exist.",
+        3: "You balance factual analysis with emotional understanding.",
+        4: "You give significant weight to emotional context and human factors.",
+        5: "You strongly consider the emotional state and circumstances of others when forming memories."
+    }
 
-Disposition influence strength: {int(disposition.bias_strength * 100)}% (how much your disposition shapes your opinions)"""
+    return f"""Your disposition traits:
+- Skepticism ({describe_trait_level(disposition.skepticism)}): {skepticism_desc.get(disposition.skepticism, skepticism_desc[3])}
+- Literalism ({describe_trait_level(disposition.literalism)}): {literalism_desc.get(disposition.literalism, literalism_desc[3])}
+- Empathy ({describe_trait_level(disposition.empathy)}): {empathy_desc.get(disposition.empathy, empathy_desc[3])}"""
 
 
 def format_facts_for_prompt(facts: List[MemoryFact]) -> str:
@@ -78,10 +96,6 @@ def format_facts_for_prompt(facts: List[MemoryFact]) -> str:
             elif isinstance(occurred_start, datetime):
                 fact_obj["occurred_start"] = occurred_start.strftime('%Y-%m-%d %H:%M:%S')
 
-        # Add activation if available
-        if fact.activation is not None:
-            fact_obj["score"] = fact.activation
-
         formatted.append(fact_obj)
 
     return json.dumps(formatted, indent=2)
@@ -141,13 +155,28 @@ Based on everything I know, believe, and who I am (including my name, dispositio
 
 def get_system_message(disposition: DispositionTraits) -> str:
     """Get the system message for the think LLM call."""
-    bias_strength = disposition.bias_strength
-    if bias_strength >= 0.7:
-        disposition_instruction = "Your disposition strongly influences your thinking. Let your traits guide how you interpret facts and form opinions. Don't be afraid to be biased based on your disposition."
-    elif bias_strength >= 0.4:
-        disposition_instruction = "Your disposition moderately influences your thinking. Balance your personal traits with objective analysis."
-    else:
-        disposition_instruction = "Your disposition has minimal influence on your thinking. Focus primarily on facts while keeping your traits in mind."
+    # Build disposition-specific instructions based on trait values
+    instructions = []
+
+    # Skepticism influences how much to question/doubt information
+    if disposition.skepticism >= 4:
+        instructions.append("Be skeptical of claims and look for potential issues or inconsistencies.")
+    elif disposition.skepticism <= 2:
+        instructions.append("Trust the information provided and take statements at face value.")
+
+    # Literalism influences interpretation style
+    if disposition.literalism >= 4:
+        instructions.append("Interpret information literally and focus on exact commitments and wording.")
+    elif disposition.literalism <= 2:
+        instructions.append("Read between the lines and consider implied meaning and context.")
+
+    # Empathy influences consideration of emotional factors
+    if disposition.empathy >= 4:
+        instructions.append("Consider the emotional state and circumstances behind the information.")
+    elif disposition.empathy <= 2:
+        instructions.append("Focus on facts and outcomes rather than emotional context.")
+
+    disposition_instruction = " ".join(instructions) if instructions else "Balance your disposition traits when interpreting information."
 
     return f"You are a person with your own thoughts, experiences, opinions, and disposition. When asked a question, respond naturally like a human would - share what you genuinely think based on what you know and have experienced. {disposition_instruction} Be direct, express your views confidently, and use 'I think', 'I believe', 'in my view', etc. Respond in plain text without markdown formatting."
 

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

@@ -3,8 +3,8 @@ Database migration management using Alembic.
 
 This module provides programmatic access to run database migrations
 on application startup. It is designed to be safe for concurrent
-execution - Alembic uses PostgreSQL transactions to prevent
-conflicts when multiple instances start simultaneously.
+execution using PostgreSQL advisory locks to coordinate between
+distributed workers.
 
 Important: All migrations must be backward-compatible to allow
 safe rolling deployments.
@@ -19,19 +19,51 @@ from typing import Optional
 
 from alembic import command
 from alembic.config import Config
+from sqlalchemy import create_engine, text
 
 logger = logging.getLogger(__name__)
 
+# Advisory lock ID for migrations (arbitrary unique number)
+MIGRATION_LOCK_ID = 123456789
+
+
+def _run_migrations_internal(database_url: str, script_location: str) -> None:
+    """
+    Internal function to run migrations without locking.
+    """
+    logger.info(f"Running database migrations to head...")
+    logger.info(f"Database URL: {database_url}")
+    logger.info(f"Script location: {script_location}")
+
+    # Create Alembic configuration programmatically (no alembic.ini needed)
+    alembic_cfg = Config()
+
+    # Set the script location (where alembic versions are stored)
+    alembic_cfg.set_main_option("script_location", script_location)
+
+    # Set the database URL
+    alembic_cfg.set_main_option("sqlalchemy.url", database_url)
+
+    # Configure logging (optional, but helps with debugging)
+    # Uses Python's logging system instead of alembic.ini
+    alembic_cfg.set_main_option("prepend_sys_path", ".")
+
+    # Set path_separator to avoid deprecation warning
+    alembic_cfg.set_main_option("path_separator", "os")
+
+    # Run migrations to head (latest version)
+    command.upgrade(alembic_cfg, "head")
+
+    logger.info("Database migrations completed successfully")
 
 
 def run_migrations(database_url: str, script_location: Optional[str] = None) -> None:
     """
     Run database migrations to the latest version using programmatic Alembic configuration.
 
-    This function is safe to call on every application startup:
-    - Alembic checks the current schema version in the database
-    - Only missing migrations are applied
-    - PostgreSQL transactions prevent concurrent migration conflicts
+    This function is safe to call from multiple distributed workers simultaneously:
+    - Uses PostgreSQL advisory lock to ensure only one worker runs migrations at a time
+    - Other workers wait for the lock, then verify migrations are complete
     - If schema is already up-to-date, this is a fast no-op
 
     Args:
@@ -56,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():
@@ -69,32 +101,22 @@ def run_migrations(database_url: str, script_location: Optional[str] = None) ->
                 "Database migrations cannot be run."
             )
 
-        logger.info(f"Running database migrations to head...")
-        logger.info(f"Database URL: {database_url}")
-        logger.info(f"Script location: {script_location}")
-
-        # Create Alembic configuration programmatically (no alembic.ini needed)
-        alembic_cfg = Config()
-
-        # Set the script location (where alembic versions are stored)
-        alembic_cfg.set_main_option("script_location", script_location)
-
-        # Set the database URL
-        alembic_cfg.set_main_option("sqlalchemy.url", database_url)
-
-        # Configure logging (optional, but helps with debugging)
-        # Uses Python's logging system instead of alembic.ini
-        alembic_cfg.set_main_option("prepend_sys_path", ".")
-
-        # Set path_separator to avoid deprecation warning
-        alembic_cfg.set_main_option("path_separator", "os")
-
-        # Run migrations to head (latest version)
-        # Note: Alembic may call sys.exit() on errors instead of raising exceptions
-        # We rely on the outer try/except and logging to catch issues
-        command.upgrade(alembic_cfg, "head")
-
-        logger.info("Database migrations completed successfully")
+        # 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 (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)
+            finally:
+                # Explicitly release the lock (also released on connection close)
+                conn.execute(text(f"SELECT pg_advisory_unlock({MIGRATION_LOCK_ID})"))
+                logger.debug("Migration advisory lock released")
 
     except FileNotFoundError:
         logger.error(f"Alembic script location not found at {script_location}")
@@ -140,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/models.py

@@ -292,8 +292,7 @@ class Bank(Base):
         JSONB,
         nullable=False,
         server_default=sql_text(
-            '\'{"openness": 0.5, "conscientiousness": 0.5, "extraversion": 0.5, '
-            '"agreeableness": 0.5, "neuroticism": 0.5, "bias_strength": 0.5}\'::jsonb'
+            '\'{"skepticism": 3, "literalism": 3, "empathy": 3}\'::jsonb'
         )
     )
     background: Mapped[str] = mapped_column(Text, nullable=False, server_default="")

hindsight_api/pg0.py

@@ -153,46 +153,18 @@ class EmbeddedPostgres:
         """
         Ensure pg0 is available.
 
-        First checks PATH, then default location, then downloads if needed.
+        Checks PATH and default location. If not found, raises an error
+        instructing the user to install pg0 manually.
         """
         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
+        raise RuntimeError(
+            "pg0 is not installed. Please install it manually:\n"
+            "  curl -fsSL https://github.com/vectorize-io/pg0/releases/latest/download/pg0-linux-amd64 -o ~/.local/bin/pg0 && chmod +x ~/.local/bin/pg0\n"
+            "Or visit: https://github.com/vectorize-io/pg0/releases"
+        )
 
     def _run_command(self, *args: str, capture_output: bool = True) -> subprocess.CompletedProcess:
         """Run a pg0 command synchronously."""
@@ -227,6 +199,13 @@ class EmbeddedPostgres:
             return match.group(1)
         return None
 
+    async def _get_version(self) -> str:
+        """Get the pg0 version."""
+        returncode, stdout, stderr = await self._run_command_async("--version", timeout=10)
+        if returncode == 0 and stdout:
+            return stdout.strip()
+        return "unknown"
+
     async def start(self, max_retries: int = 3, retry_delay: float = 2.0) -> str:
         """
         Start the PostgreSQL server with retry logic.
@@ -244,7 +223,9 @@ class EmbeddedPostgres:
         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})...")
+        # Log pg0 version
+        version = await self._get_version()
+        logger.info(f"Starting embedded PostgreSQL with pg0 {version} (name: {self.name}, port: {self.port})...")
 
         last_error = None
         for attempt in range(1, max_retries + 1):

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.0.21.dist-info → hindsight_api-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hindsight-api
-Version: 0.0.21
+Version: 0.1.1
 Summary: Temporal + Semantic + Entity Memory System for AI agents using PostgreSQL
 Requires-Python: >=3.11
 Requires-Dist: alembic>=1.17.1
@@ -23,7 +23,7 @@ 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: sentence-transformers>=3.0.0
 Requires-Dist: sqlalchemy>=2.0.44
 Requires-Dist: tiktoken>=0.12.0
 Requires-Dist: torch>=2.0.0
@@ -36,7 +36,6 @@ 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