feat: integrate PostgreSQL persistence for documents, trees, and chat sessions

.env.example

@@ -7,5 +7,11 @@ PAGEINDEX_API_KEY_3=your_third_key
 HF_TOKEN=hf_your_free_token_here
 
 HF_RETRIEVAL_MODEL=meta-llama/Llama-3.1-8B-Instruct
+HF_CHAT_MODEL=meta-llama/Llama-3.1-8B-Instruct
 
-HF_CHAT_MODEL=Qwen/Qwen2.5-72B-Instruct
+GROQ_API_KEY=gsk_your_key_here
+GROQ_CHAT_MODEL=qwen/qwen3.8-27b
+GROQ_RETRIEVAL_MODEL=qwen/qwen3.8-27b
+
+# PostgreSQL Database Persistence (Local Docker or Cloud: Neon, Supabase, Railway)
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/rag_pageindex

Dockerfile

@@ -7,9 +7,9 @@ WORKDIR /app
 
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
 
-COPY pyproject.toml uv.lock ./
+COPY requirements.txt pyproject.toml uv.lock ./
 
-RUN uv pip install --system -r pyproject.toml fastapi uvicorn python-multipart
+RUN uv pip install --system -r requirements.txt
 
 COPY app/ ./app/
 

app/core/persistent_db.py

@@ -1,10 +1,9 @@
 """
 persistent_db.py
 ────────────────
-SQLite-backed persistence layer for long-term memory.
-Stores chat sessions, messages, and chat→document associations.
-The heavy document trees are kept on-disk in CACHE_DIR (JSON) –
-this layer only records the *metadata* needed to reload them.
+Unified persistence layer supporting both PostgreSQL and SQLite.
+If `DATABASE_URL` or `POSTGRES_URL` is set, PostgreSQL is used for durability across
+restarts/deployments. Otherwise, it gracefully falls back to local SQLite.
 """
 
 import os
@@ -15,6 +14,7 @@ import time
 import uuid
 from contextlib import contextmanager
 from typing import Any, Dict, List, Optional
+from utils.logger import app_logger
 
 # ── paths ──────────────────────────────────────────────────────────────────
 _THIS_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -23,8 +23,8 @@ DATA_DIR = "/data" if (os.path.exists("/data") and os.access("/data", os.W_OK))
 DB_PATH = os.path.join(DATA_DIR, "memory.db")
 os.makedirs(DATA_DIR, exist_ok=True)
 
-# ── schema ─────────────────────────────────────────────────────────────────
-_DDL = """
+# ── SQLite schema ───────────────────────────────────────────────────────────
+_SQLITE_DDL = """
 PRAGMA journal_mode=WAL;
 PRAGMA foreign_keys=ON;
 
@@ -64,6 +64,21 @@ CREATE TABLE IF NOT EXISTS doc_meta (
     updated_at      REAL NOT NULL
 );
 
+CREATE INDEX IF NOT EXISTS idx_doc_meta_hash ON doc_meta(content_hash);
+
+CREATE TABLE IF NOT EXISTS doc_indices (
+    doc_id          TEXT PRIMARY KEY REFERENCES doc_meta(doc_id) ON DELETE CASCADE,
+    content_hash    TEXT,
+    tree            TEXT,
+    node_map        TEXT,
+    flat_sections   TEXT,
+    file_base64     TEXT,
+    created_at      REAL NOT NULL,
+    updated_at      REAL NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_doc_indices_hash ON doc_indices(content_hash);
+
 CREATE TABLE IF NOT EXISTS chat_documents (
     chat_id     TEXT NOT NULL REFERENCES chats(chat_id) ON DELETE CASCADE,
     doc_id      TEXT NOT NULL REFERENCES doc_meta(doc_id) ON DELETE CASCADE,
@@ -100,7 +115,7 @@ CREATE TABLE IF NOT EXISTS global_knowledge_summary (
 """
 
 
-class PersistentDB:
+class SQLitePersistentDB:
     """Thread-safe SQLite wrapper for long-term chat & document memory."""
 
     def __init__(self, db_path: str = DB_PATH) -> None:
@@ -128,7 +143,7 @@ class PersistentDB:
 
     def _init_schema(self) -> None:
         with self._tx() as conn:
-            conn.executescript(_DDL)
+            conn.executescript(_SQLITE_DDL)
             # Ensure newly added columns exist in older DB instances
             cursor = conn.execute("PRAGMA table_info(doc_meta)")
             existing_cols = {row["name"] for row in cursor.fetchall()}
@@ -218,7 +233,7 @@ class PersistentDB:
         q = "SELECT role, content FROM messages WHERE chat_id=? ORDER BY created_at ASC"
         if limit > 0:
             rows = self._conn().execute(
-                f"SELECT role, content FROM messages WHERE chat_id=? ORDER BY created_at DESC LIMIT ?",
+                "SELECT role, content FROM messages WHERE chat_id=? ORDER BY created_at DESC LIMIT ?",
                 (chat_id, limit),
             ).fetchall()
             return [{"role": r["role"], "content": r["content"]} for r in reversed(rows)]
@@ -289,7 +304,6 @@ class PersistentDB:
         return [dict(r) for r in rows]
 
     def find_doc_by_hash(self, content_hash: str) -> Optional[Dict[str, Any]]:
-        # Match latest document with this hash
         row = self._conn().execute(
             "SELECT * FROM doc_meta WHERE content_hash=? ORDER BY updated_at DESC LIMIT 1",
             (content_hash,),
@@ -302,8 +316,82 @@ class PersistentDB:
             conn.execute("UPDATE chats SET doc_id=NULL, doc_name=NULL WHERE doc_id=?", (doc_id,))
             conn.execute("DELETE FROM chat_documents WHERE doc_id=?", (doc_id,))
             conn.execute("DELETE FROM knowledge_memory WHERE doc_id=?", (doc_id,))
+            conn.execute("DELETE FROM doc_indices WHERE doc_id=?", (doc_id,))
             return cur.rowcount > 0
 
+    # ── document heavy indices store ─────────────────────────────────────────
+    def save_doc_index(
+        self,
+        doc_id: str,
+        content_hash: Optional[str],
+        tree: Any,
+        node_map: Optional[Dict[str, Any]] = None,
+        flat_sections: Optional[List[Dict[str, Any]]] = None,
+        file_base64: Optional[str] = None,
+    ) -> None:
+        now = time.time()
+        with self._tx() as conn:
+            conn.execute(
+                """
+                INSERT INTO doc_indices(
+                    doc_id, content_hash, tree, node_map, flat_sections, file_base64, created_at, updated_at
+                )
+                VALUES(?,?,?,?,?,?,?,?)
+                ON CONFLICT(doc_id) DO UPDATE SET
+                    content_hash=COALESCE(excluded.content_hash, doc_indices.content_hash),
+                    tree=excluded.tree,
+                    node_map=excluded.node_map,
+                    flat_sections=excluded.flat_sections,
+                    file_base64=COALESCE(excluded.file_base64, doc_indices.file_base64),
+                    updated_at=excluded.updated_at
+                """,
+                (
+                    doc_id,
+                    content_hash,
+                    json.dumps(tree) if tree is not None else None,
+                    json.dumps(node_map) if node_map is not None else None,
+                    json.dumps(flat_sections) if flat_sections is not None else None,
+                    file_base64,
+                    now,
+                    now,
+                ),
+            )
+
+    def get_doc_index(self, doc_id: str) -> Optional[Dict[str, Any]]:
+        row = self._conn().execute(
+            "SELECT * FROM doc_indices WHERE doc_id=?", (doc_id,)
+        ).fetchone()
+        if not row:
+            return None
+        res = dict(row)
+        for k in ("tree", "node_map", "flat_sections"):
+            if res.get(k) and isinstance(res[k], str):
+                try:
+                    res[k] = json.loads(res[k])
+                except Exception:
+                    pass
+        return res
+
+    def get_doc_index_by_hash(self, content_hash: str) -> Optional[Dict[str, Any]]:
+        row = self._conn().execute(
+            "SELECT * FROM doc_indices WHERE content_hash=? ORDER BY updated_at DESC LIMIT 1",
+            (content_hash,),
+        ).fetchone()
+        if not row:
+            return None
+        res = dict(row)
+        for k in ("tree", "node_map", "flat_sections"):
+            if res.get(k) and isinstance(res[k], str):
+                try:
+                    res[k] = json.loads(res[k])
+                except Exception:
+                    pass
+        return res
+
+    def delete_doc_index(self, doc_id: str) -> None:
+        with self._tx() as conn:
+            conn.execute("DELETE FROM doc_indices WHERE doc_id=?", (doc_id,))
+
     # ── multi-doc session associations ──────────────────────────────────────
     def add_chat_document(self, chat_id: str, doc_id: str, doc_name: Optional[str] = None) -> None:
         now = time.time()
@@ -318,7 +406,6 @@ class PersistentDB:
                 """,
                 (chat_id, doc_id, doc_name, now),
             )
-            # Maintain backward compatibility on chats table with latest doc
             conn.execute(
                 "UPDATE chats SET doc_id=?, doc_name=?, updated_at=? WHERE chat_id=?",
                 (doc_id, doc_name, now, chat_id),
@@ -496,6 +583,98 @@ class PersistentDB:
         return res
 
 
+def _migrate_sqlite_to_postgres_if_needed(pg_db: Any) -> None:
+    """If local SQLite contains chats/docs and PostgreSQL is newly initialized, migrate data smoothly."""
+    if not os.path.exists(DB_PATH):
+        return
+
+    # Check if Postgres already has documents or chats
+    if pg_db.list_docs() or pg_db.list_chats():
+        return
+
+    sqlite_db = SQLitePersistentDB(DB_PATH)
+    sqlite_chats = sqlite_db.list_chats()
+    sqlite_docs = sqlite_db.list_docs()
+
+    if not sqlite_chats and not sqlite_docs:
+        return
+
+    app_logger.info(f"[Migration] Migrating {len(sqlite_docs)} docs and {len(sqlite_chats)} chats from SQLite to PostgreSQL...")
+
+    for d in sqlite_docs:
+        try:
+            pg_db.upsert_doc_meta(
+                doc_id=d["doc_id"],
+                filename=d.get("filename", "document.pdf"),
+                status=d.get("status", "ready"),
+                page_count=d.get("page_count", 0),
+                section_count=d.get("section_count", 0),
+                progress=d.get("progress", 100),
+                current_stage=d.get("current_stage", "Ready"),
+                indexing_method=d.get("indexing_method"),
+                duration=d.get("duration"),
+                error=d.get("error"),
+                content_hash=d.get("content_hash"),
+                file_path=d.get("file_path"),
+            )
+            # Check if index exists in SQLite
+            s_idx = sqlite_db.get_doc_index(d["doc_id"])
+            if s_idx:
+                pg_db.save_doc_index(
+                    doc_id=d["doc_id"],
+                    content_hash=d.get("content_hash"),
+                    tree=s_idx.get("tree"),
+                    node_map=s_idx.get("node_map"),
+                    flat_sections=s_idx.get("flat_sections"),
+                    file_base64=s_idx.get("file_base64"),
+                )
+        except Exception as dex:
+            app_logger.warning(f"[Migration] Error migrating doc {d.get('doc_id')}: {dex}")
+
+    for c in sqlite_chats:
+        try:
+            cid = c["chat_id"]
+            pg_db.create_chat(chat_id=cid, title=c.get("title"))
+            if c.get("doc_id"):
+                pg_db.set_chat_doc(cid, c["doc_id"], c.get("doc_name"))
+            # Migrate messages
+            msgs = sqlite_db.get_messages(cid)
+            for m in msgs:
+                pg_db.add_message(cid, m["role"], m["content"])
+            # Migrate attached documents
+            att = sqlite_db.get_chat_documents(cid)
+            for a in att:
+                pg_db.add_chat_document(cid, a["doc_id"], a.get("doc_name"))
+        except Exception as cex:
+            app_logger.warning(f"[Migration] Error migrating chat {c.get('chat_id')}: {cex}")
+
+    app_logger.info("[Migration] SQLite to PostgreSQL migration completed successfully.")
+
+
+def create_persistent_db() -> Any:
+    """
+    Factory function for persistent database.
+    Checks environment for DATABASE_URL / POSTGRES_URL.
+    If provided and accessible, uses PostgresDB. Otherwise falls back to SQLite.
+    """
+    pg_url = os.getenv("DATABASE_URL") or os.getenv("POSTGRES_URL") or os.getenv("POSTGRESQL_URL")
+    if pg_url:
+        try:
+            from core.postgres_db import PostgresDB
+            pg_db = PostgresDB(pg_url)
+            safe_url = pg_url.split("@")[-1] if "@" in pg_url else "local"
+            app_logger.info(f"[PersistentDB] Connected to PostgreSQL: {safe_url}")
+            try:
+                _migrate_sqlite_to_postgres_if_needed(pg_db)
+            except Exception as mex:
+                app_logger.warning(f"[PersistentDB] Auto-migration skipped: {mex}")
+            return pg_db
+        except Exception as e:
+            app_logger.error(f"[PersistentDB] Failed to connect to PostgreSQL ({e}). Falling back to SQLite.")
+
+    app_logger.info(f"[PersistentDB] Using SQLite persistence at {DB_PATH}")
+    return SQLitePersistentDB(DB_PATH)
+
 
-# Global singleton
-persistent_db = PersistentDB()
+# Global singleton instance
+persistent_db = create_persistent_db()

app/core/postgres_db.py

@@ -0,0 +1,639 @@
+"""
+postgres_db.py
+──────────────
+PostgreSQL persistence layer for enterprise-grade durability.
+Stores chat sessions, messages, document metadata, and heavy document index trees (JSONB).
+Even if the container or app restarts or sleeps, all documents, chats, and indices remain intact.
+"""
+
+import os
+import json
+import time
+import uuid
+import base64
+from contextlib import contextmanager
+from typing import Any, Dict, List, Optional
+import psycopg2
+import psycopg2.extras
+import psycopg2.pool
+from utils.logger import app_logger
+
+# Register JSON/JSONB handlers so JSON columns are transparently converted to/from dict/list
+psycopg2.extras.register_default_jsonb()
+
+_PG_DDL = """
+CREATE TABLE IF NOT EXISTS chats (
+    chat_id     TEXT PRIMARY KEY,
+    title       TEXT,
+    doc_id      TEXT,
+    doc_name    TEXT,
+    created_at  DOUBLE PRECISION NOT NULL,
+    updated_at  DOUBLE PRECISION NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id          BIGSERIAL PRIMARY KEY,
+    chat_id     TEXT NOT NULL REFERENCES chats(chat_id) ON DELETE CASCADE,
+    role        TEXT NOT NULL CHECK(role IN ('user','assistant','system')),
+    content     TEXT NOT NULL,
+    created_at  DOUBLE PRECISION NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_pg_messages_chat ON messages(chat_id, created_at);
+
+CREATE TABLE IF NOT EXISTS doc_meta (
+    doc_id          TEXT PRIMARY KEY,
+    filename        TEXT,
+    status          TEXT,
+    page_count      INTEGER DEFAULT 0,
+    section_count   INTEGER DEFAULT 0,
+    progress        INTEGER DEFAULT 0,
+    current_stage   TEXT DEFAULT 'uploaded',
+    indexing_method TEXT,
+    duration        DOUBLE PRECISION,
+    error           TEXT,
+    content_hash    TEXT,
+    file_path       TEXT,
+    created_at      DOUBLE PRECISION NOT NULL,
+    updated_at      DOUBLE PRECISION NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_pg_doc_meta_hash ON doc_meta(content_hash);
+
+CREATE TABLE IF NOT EXISTS doc_indices (
+    doc_id          TEXT PRIMARY KEY REFERENCES doc_meta(doc_id) ON DELETE CASCADE,
+    content_hash    TEXT,
+    tree            JSONB,
+    node_map        JSONB,
+    flat_sections   JSONB,
+    file_base64     TEXT,
+    created_at      DOUBLE PRECISION NOT NULL,
+    updated_at      DOUBLE PRECISION NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_pg_doc_indices_hash ON doc_indices(content_hash);
+
+CREATE TABLE IF NOT EXISTS chat_documents (
+    chat_id     TEXT NOT NULL REFERENCES chats(chat_id) ON DELETE CASCADE,
+    doc_id      TEXT NOT NULL REFERENCES doc_meta(doc_id) ON DELETE CASCADE,
+    doc_name    TEXT,
+    attached_at DOUBLE PRECISION NOT NULL,
+    PRIMARY KEY (chat_id, doc_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_pg_chat_docs ON chat_documents(chat_id);
+
+CREATE TABLE IF NOT EXISTS chat_summaries (
+    chat_id     TEXT PRIMARY KEY REFERENCES chats(chat_id) ON DELETE CASCADE,
+    summary     TEXT NOT NULL,
+    turn_count  INTEGER DEFAULT 0,
+    updated_at  DOUBLE PRECISION NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS knowledge_memory (
+    doc_id            TEXT PRIMARY KEY REFERENCES doc_meta(doc_id) ON DELETE CASCADE,
+    filename          TEXT NOT NULL,
+    executive_summary TEXT,
+    key_entities      JSONB,
+    key_findings      JSONB,
+    topics            JSONB,
+    updated_at        DOUBLE PRECISION NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS global_knowledge_summary (
+    id                  TEXT PRIMARY KEY,
+    collective_summary  TEXT NOT NULL,
+    total_documents     INTEGER DEFAULT 0,
+    key_insights        JSONB,
+    updated_at          DOUBLE PRECISION NOT NULL
+);
+"""
+
+
+class PostgresDB:
+    """Robust, thread-safe PostgreSQL database client with connection pool and auto-reconnect."""
+
+    def __init__(self, dsn: str):
+        # Normalize postgres:// to postgresql:// if needed
+        if dsn.startswith("postgres://"):
+            dsn = "postgresql://" + dsn[len("postgres://"):]
+        self._dsn = dsn
+        self._pool: Optional[psycopg2.pool.ThreadedConnectionPool] = None
+        self._init_pool()
+        self._init_schema()
+
+    def _init_pool(self) -> None:
+        try:
+            self._pool = psycopg2.pool.ThreadedConnectionPool(
+                minconn=1,
+                maxconn=20,
+                dsn=self._dsn,
+            )
+            app_logger.info("[PostgresDB] Connection pool created successfully.")
+        except Exception as e:
+            app_logger.error(f"[PostgresDB] Failed to initialize connection pool: {e}")
+            raise
+
+    @contextmanager
+    def _conn(self):
+        """Context manager that borrows a healthy connection from the pool and handles commits/rollbacks."""
+        conn = None
+        try:
+            conn = self._pool.getconn()
+            # Test connection liveness
+            if conn.closed:
+                conn = psycopg2.connect(self._dsn)
+            else:
+                try:
+                    with conn.cursor() as cur:
+                        cur.execute("SELECT 1;")
+                except Exception:
+                    # Connection is dead, recreate
+                    try:
+                        self._pool.putconn(conn, close=True)
+                    except Exception:
+                        pass
+                    conn = psycopg2.connect(self._dsn)
+
+            yield conn
+            conn.commit()
+        except Exception:
+            if conn and not conn.closed:
+                conn.rollback()
+            raise
+        finally:
+            if conn and self._pool:
+                try:
+                    self._pool.putconn(conn)
+                except Exception:
+                    pass
+
+    def _init_schema(self) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(_PG_DDL)
+        app_logger.info("[PostgresDB] Schema initialized / verified successfully.")
+
+    # ── chat CRUD ───────────────────────────────────────────────────────────
+    def create_chat(self, chat_id: Optional[str] = None, title: Optional[str] = None) -> str:
+        cid = chat_id or str(uuid.uuid4())
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO chats(chat_id, title, created_at, updated_at)
+                    VALUES (%s, %s, %s, %s)
+                    ON CONFLICT (chat_id) DO NOTHING
+                    """,
+                    (cid, title, now, now),
+                )
+        return cid
+
+    def get_chat(self, chat_id: str) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM chats WHERE chat_id = %s", (chat_id,))
+                row = cur.fetchone()
+                return dict(row) if row else None
+
+    def list_chats(self) -> List[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM chats ORDER BY updated_at DESC")
+                rows = cur.fetchall()
+                return [dict(r) for r in rows]
+
+    def update_chat_title(self, chat_id: str, title: str) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "UPDATE chats SET title = %s, updated_at = %s WHERE chat_id = %s",
+                    (title, time.time(), chat_id),
+                )
+
+    def set_chat_doc(self, chat_id: str, doc_id: str, doc_name: Optional[str] = None) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "UPDATE chats SET doc_id = %s, doc_name = %s, updated_at = %s WHERE chat_id = %s",
+                    (doc_id, doc_name, time.time(), chat_id),
+                )
+
+    def remove_chat_doc(self, chat_id: str) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "UPDATE chats SET doc_id = NULL, doc_name = NULL, updated_at = %s WHERE chat_id = %s",
+                    (time.time(), chat_id),
+                )
+
+    def delete_chat(self, chat_id: str) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute("DELETE FROM chats WHERE chat_id = %s", (chat_id,))
+
+    # ── message CRUD ────────────────────────────────────────────────────────
+    def add_message(self, chat_id: str, role: str, content: str) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO chats(chat_id, title, created_at, updated_at)
+                    VALUES (%s, 'New research', %s, %s)
+                    ON CONFLICT (chat_id) DO NOTHING
+                    """,
+                    (chat_id, now, now),
+                )
+                cur.execute(
+                    "INSERT INTO messages(chat_id, role, content, created_at) VALUES (%s, %s, %s, %s)",
+                    (chat_id, role, content, now),
+                )
+                cur.execute(
+                    "UPDATE chats SET updated_at = %s WHERE chat_id = %s",
+                    (now, chat_id),
+                )
+
+    def get_messages(self, chat_id: str, limit: int = 0) -> List[Dict[str, str]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                if limit > 0:
+                    cur.execute(
+                        "SELECT role, content FROM messages WHERE chat_id = %s ORDER BY created_at DESC LIMIT %s",
+                        (chat_id, limit),
+                    )
+                    rows = cur.fetchall()
+                    return [{"role": r["role"], "content": r["content"]} for r in reversed(rows)]
+                cur.execute(
+                    "SELECT role, content FROM messages WHERE chat_id = %s ORDER BY created_at ASC",
+                    (chat_id,),
+                )
+                rows = cur.fetchall()
+                return [{"role": r["role"], "content": r["content"]} for r in rows]
+
+    def clear_messages(self, chat_id: str) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute("DELETE FROM messages WHERE chat_id = %s", (chat_id,))
+
+    # ── document metadata ────────────────────────────────────────────────────
+    def upsert_doc_meta(
+        self,
+        doc_id: str,
+        filename: str,
+        status: str,
+        page_count: int = 0,
+        section_count: int = 0,
+        progress: int = 0,
+        current_stage: str = "uploaded",
+        indexing_method: Optional[str] = None,
+        duration: Optional[float] = None,
+        error: Optional[str] = None,
+        content_hash: Optional[str] = None,
+        file_path: Optional[str] = None,
+    ) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO doc_meta(
+                        doc_id, filename, status, page_count, section_count,
+                        progress, current_stage, indexing_method, duration,
+                        error, content_hash, file_path, created_at, updated_at
+                    )
+                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                    ON CONFLICT (doc_id) DO UPDATE SET
+                        filename = EXCLUDED.filename,
+                        status = EXCLUDED.status,
+                        page_count = EXCLUDED.page_count,
+                        section_count = EXCLUDED.section_count,
+                        progress = EXCLUDED.progress,
+                        current_stage = EXCLUDED.current_stage,
+                        indexing_method = COALESCE(EXCLUDED.indexing_method, doc_meta.indexing_method),
+                        duration = COALESCE(EXCLUDED.duration, doc_meta.duration),
+                        error = EXCLUDED.error,
+                        content_hash = COALESCE(EXCLUDED.content_hash, doc_meta.content_hash),
+                        file_path = COALESCE(EXCLUDED.file_path, doc_meta.file_path),
+                        updated_at = EXCLUDED.updated_at
+                    """,
+                    (
+                        doc_id,
+                        filename,
+                        status,
+                        page_count,
+                        section_count,
+                        progress,
+                        current_stage,
+                        indexing_method,
+                        duration,
+                        error,
+                        content_hash,
+                        file_path,
+                        now,
+                        now,
+                    ),
+                )
+
+    def get_doc_meta(self, doc_id: str) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM doc_meta WHERE doc_id = %s", (doc_id,))
+                row = cur.fetchone()
+                return dict(row) if row else None
+
+    def list_docs(self) -> List[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM doc_meta ORDER BY created_at DESC")
+                rows = cur.fetchall()
+                return [dict(r) for r in rows]
+
+    def find_doc_by_hash(self, content_hash: str) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute(
+                    "SELECT * FROM doc_meta WHERE content_hash = %s ORDER BY updated_at DESC LIMIT 1",
+                    (content_hash,),
+                )
+                row = cur.fetchone()
+                return dict(row) if row else None
+
+    def delete_doc(self, doc_id: str) -> bool:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute("DELETE FROM doc_meta WHERE doc_id = %s", (doc_id,))
+                rc = cur.rowcount
+                cur.execute("UPDATE chats SET doc_id = NULL, doc_name = NULL WHERE doc_id = %s", (doc_id,))
+                cur.execute("DELETE FROM chat_documents WHERE doc_id = %s", (doc_id,))
+                cur.execute("DELETE FROM knowledge_memory WHERE doc_id = %s", (doc_id,))
+                cur.execute("DELETE FROM doc_indices WHERE doc_id = %s", (doc_id,))
+                return rc > 0
+
+    # ── document heavy indices store (JSONB) ─────────────────────────────────
+    def save_doc_index(
+        self,
+        doc_id: str,
+        content_hash: Optional[str],
+        tree: Any,
+        node_map: Optional[Dict[str, Any]] = None,
+        flat_sections: Optional[List[Dict[str, Any]]] = None,
+        file_base64: Optional[str] = None,
+    ) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO doc_indices (
+                        doc_id, content_hash, tree, node_map, flat_sections, file_base64, created_at, updated_at
+                    )
+                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+                    ON CONFLICT (doc_id) DO UPDATE SET
+                        content_hash = COALESCE(EXCLUDED.content_hash, doc_indices.content_hash),
+                        tree = EXCLUDED.tree,
+                        node_map = EXCLUDED.node_map,
+                        flat_sections = EXCLUDED.flat_sections,
+                        file_base64 = COALESCE(EXCLUDED.file_base64, doc_indices.file_base64),
+                        updated_at = EXCLUDED.updated_at
+                    """,
+                    (
+                        doc_id,
+                        content_hash,
+                        psycopg2.extras.Json(tree) if tree is not None else None,
+                        psycopg2.extras.Json(node_map) if node_map is not None else None,
+                        psycopg2.extras.Json(flat_sections) if flat_sections is not None else None,
+                        file_base64,
+                        now,
+                        now,
+                    ),
+                )
+
+    def get_doc_index(self, doc_id: str) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM doc_indices WHERE doc_id = %s", (doc_id,))
+                row = cur.fetchone()
+                return dict(row) if row else None
+
+    def get_doc_index_by_hash(self, content_hash: str) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute(
+                    "SELECT * FROM doc_indices WHERE content_hash = %s ORDER BY updated_at DESC LIMIT 1",
+                    (content_hash,),
+                )
+                row = cur.fetchone()
+                return dict(row) if row else None
+
+    def delete_doc_index(self, doc_id: str) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute("DELETE FROM doc_indices WHERE doc_id = %s", (doc_id,))
+
+    # ── multi-doc session associations ──────────────────────────────────────
+    def add_chat_document(self, chat_id: str, doc_id: str, doc_name: Optional[str] = None) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO chat_documents(chat_id, doc_id, doc_name, attached_at)
+                    VALUES (%s, %s, %s, %s)
+                    ON CONFLICT (chat_id, doc_id) DO UPDATE SET
+                        doc_name = COALESCE(EXCLUDED.doc_name, chat_documents.doc_name),
+                        attached_at = EXCLUDED.attached_at
+                    """,
+                    (chat_id, doc_id, doc_name, now),
+                )
+                # Maintain backward compatibility on chats table
+                cur.execute(
+                    "UPDATE chats SET doc_id = %s, doc_name = %s, updated_at = %s WHERE chat_id = %s",
+                    (doc_id, doc_name, now, chat_id),
+                )
+
+    def remove_chat_document(self, chat_id: str, doc_id: str) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("DELETE FROM chat_documents WHERE chat_id = %s AND doc_id = %s", (chat_id, doc_id))
+                cur.execute(
+                    "SELECT doc_id, doc_name FROM chat_documents WHERE chat_id = %s ORDER BY attached_at DESC LIMIT 1",
+                    (chat_id,),
+                )
+                rem = cur.fetchone()
+                if rem:
+                    cur.execute(
+                        "UPDATE chats SET doc_id = %s, doc_name = %s, updated_at = %s WHERE chat_id = %s",
+                        (rem["doc_id"], rem["doc_name"], now, chat_id),
+                    )
+                else:
+                    cur.execute(
+                        "UPDATE chats SET doc_id = NULL, doc_name = NULL, updated_at = %s WHERE chat_id = %s",
+                        (now, chat_id),
+                    )
+
+    def get_chat_documents(self, chat_id: str) -> List[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute(
+                    """
+                    SELECT cd.chat_id, cd.doc_id, cd.doc_name, cd.attached_at,
+                           dm.status, dm.page_count, dm.section_count, dm.filename
+                    FROM chat_documents cd
+                    LEFT JOIN doc_meta dm ON cd.doc_id = dm.doc_id
+                    WHERE cd.chat_id = %s
+                    ORDER BY cd.attached_at ASC
+                    """,
+                    (chat_id,),
+                )
+                rows = cur.fetchall()
+                return [dict(r) for r in rows]
+
+    def clear_chat_documents(self, chat_id: str) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute("DELETE FROM chat_documents WHERE chat_id = %s", (chat_id,))
+                cur.execute(
+                    "UPDATE chats SET doc_id = NULL, doc_name = NULL, updated_at = %s WHERE chat_id = %s",
+                    (now, chat_id),
+                )
+
+    # ── session long memory & rolling summaries ─────────────────────────────
+    def set_chat_summary(self, chat_id: str, summary: str, turn_count: int = 0) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO chat_summaries(chat_id, summary, turn_count, updated_at)
+                    VALUES (%s, %s, %s, %s)
+                    ON CONFLICT (chat_id) DO UPDATE SET
+                        summary = EXCLUDED.summary,
+                        turn_count = EXCLUDED.turn_count,
+                        updated_at = EXCLUDED.updated_at
+                    """,
+                    (chat_id, summary, turn_count, now),
+                )
+
+    def get_chat_summary(self, chat_id: str) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM chat_summaries WHERE chat_id = %s", (chat_id,))
+                row = cur.fetchone()
+                return dict(row) if row else None
+
+    # ── global knowledge memory & document dossiers ────────────────────────
+    def save_knowledge_dossier(
+        self,
+        doc_id: str,
+        filename: str,
+        executive_summary: str,
+        key_entities: Optional[List[str]] = None,
+        key_findings: Optional[List[str]] = None,
+        topics: Optional[List[str]] = None,
+    ) -> None:
+        now = time.time()
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO knowledge_memory(
+                        doc_id, filename, executive_summary, key_entities, key_findings, topics, updated_at
+                    )
+                    VALUES (%s, %s, %s, %s, %s, %s, %s)
+                    ON CONFLICT (doc_id) DO UPDATE SET
+                        filename = EXCLUDED.filename,
+                        executive_summary = EXCLUDED.executive_summary,
+                        key_entities = EXCLUDED.key_entities,
+                        key_findings = EXCLUDED.key_findings,
+                        topics = EXCLUDED.topics,
+                        updated_at = EXCLUDED.updated_at
+                    """,
+                    (
+                        doc_id,
+                        filename,
+                        executive_summary,
+                        psycopg2.extras.Json(key_entities or []),
+                        psycopg2.extras.Json(key_findings or []),
+                        psycopg2.extras.Json(topics or []),
+                        now,
+                    ),
+                )
+
+    def get_knowledge_dossier(self, doc_id: str) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM knowledge_memory WHERE doc_id = %s", (doc_id,))
+                row = cur.fetchone()
+                if not row:
+                    return None
+                res = dict(row)
+                for k in ("key_entities", "key_findings", "topics"):
+                    if res.get(k) is None:
+                        res[k] = []
+                return res
+
+    def list_knowledge_dossiers(self) -> List[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM knowledge_memory ORDER BY updated_at DESC")
+                rows = cur.fetchall()
+                result = []
+                for r in rows:
+                    item = dict(r)
+                    for k in ("key_entities", "key_findings", "topics"):
+                        if item.get(k) is None:
+                            item[k] = []
+                    result.append(item)
+                return result
+
+    def delete_knowledge_dossier(self, doc_id: str) -> None:
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute("DELETE FROM knowledge_memory WHERE doc_id = %s", (doc_id,))
+
+    def save_global_knowledge_summary(
+        self,
+        collective_summary: str,
+        total_documents: int,
+        key_insights: Optional[List[str]] = None,
+    ) -> None:
+        now = time.time()
+        gid = "global"
+        with self._conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO global_knowledge_summary(
+                        id, collective_summary, total_documents, key_insights, updated_at
+                    )
+                    VALUES (%s, %s, %s, %s, %s)
+                    ON CONFLICT (id) DO UPDATE SET
+                        collective_summary = EXCLUDED.collective_summary,
+                        total_documents = EXCLUDED.total_documents,
+                        key_insights = EXCLUDED.key_insights,
+                        updated_at = EXCLUDED.updated_at
+                    """,
+                    (
+                        gid,
+                        collective_summary,
+                        total_documents,
+                        psycopg2.extras.Json(key_insights or []),
+                        now,
+                    ),
+                )
+
+    def get_global_knowledge_summary(self) -> Optional[Dict[str, Any]]:
+        with self._conn() as conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute("SELECT * FROM global_knowledge_summary WHERE id = 'global'")
+                row = cur.fetchone()
+                if not row:
+                    return None
+                res = dict(row)
+                if res.get("key_insights") is None:
+                    res["key_insights"] = []
+                return res

app/core/storage.py

@@ -2,6 +2,7 @@ import os
 import json
 import time
 import uuid
+import base64
 from typing import Dict, List, Optional, Any
 
 from core.persistent_db import persistent_db
@@ -79,43 +80,70 @@ class MemoryStorage:
                 return doc_obj
 
             # 3. Try to load tree from disk JSON cache for ready documents
+            cached = None
             cache_path = os.path.join(CACHE_DIR, f"{content_hash}.json")
             if os.path.exists(cache_path):
                 try:
                     with open(cache_path, "r", encoding="utf-8") as f:
                         cached = json.load(f)
-                    self._documents[doc_id] = {
-                        "doc_id": doc_id,
-                        "document_id": doc_id,
-                        "filename": cached.get("filename", db_meta.get("filename", "document.pdf")),
-                        "status": "ready",
-                        "progress": 100,
-                        "current_stage": "Ready",
-                        "tree": cached.get("tree"),
-                        "page_count": cached.get("page_count", db_meta.get("page_count", 1)),
-                        "section_count": cached.get("section_count", db_meta.get("section_count", len(cached.get("flat_sections", [])))),
-                        "indexing_method": db_meta.get("indexing_method", "pageindex"),
-                        "duration": db_meta.get("duration"),
-                        "error": None,
-                        "content_hash": content_hash,
-                        "created_at": cached.get("created_at", time.time()),
-                        "updated_at": time.time(),
-                    }
-                    self._trees[doc_id] = cached.get("tree")
-                    if cached.get("node_map"):
-                        self._node_maps[doc_id] = cached["node_map"]
-                    if cached.get("flat_sections"):
-                        self._flat_sections[doc_id] = cached["flat_sections"]
-                    self._hash_to_doc_id[content_hash] = doc_id
-                    return self._documents[doc_id]
                 except Exception:
-                    pass
+                    cached = None
+
+            # 4. If disk cache is missing (e.g. fresh container start), load from DB
+            if not cached or not cached.get("tree"):
+                db_idx = persistent_db.get_doc_index_by_hash(content_hash) or persistent_db.get_doc_index(doc_id)
+                if db_idx and db_idx.get("tree"):
+                    cached = {
+                        "filename": db_meta.get("filename", "document.pdf"),
+                        "tree": db_idx.get("tree"),
+                        "node_map": db_idx.get("node_map"),
+                        "flat_sections": db_idx.get("flat_sections"),
+                        "page_count": db_meta.get("page_count", 1),
+                        "section_count": db_meta.get("section_count", len(db_idx.get("flat_sections", [])) if db_idx.get("flat_sections") else 0),
+                        "created_at": db_idx.get("created_at", time.time()),
+                    }
+
+            if cached and cached.get("tree"):
+                self._documents[doc_id] = {
+                    "doc_id": doc_id,
+                    "document_id": doc_id,
+                    "filename": cached.get("filename", db_meta.get("filename", "document.pdf")),
+                    "status": "ready",
+                    "progress": 100,
+                    "current_stage": "Ready",
+                    "tree": cached.get("tree"),
+                    "page_count": cached.get("page_count", db_meta.get("page_count", 1)),
+                    "section_count": cached.get("section_count", db_meta.get("section_count", len(cached.get("flat_sections", [])))),
+                    "indexing_method": db_meta.get("indexing_method", "pageindex"),
+                    "duration": db_meta.get("duration"),
+                    "error": None,
+                    "content_hash": content_hash,
+                    "created_at": cached.get("created_at", time.time()),
+                    "updated_at": time.time(),
+                }
+                self._trees[doc_id] = cached.get("tree")
+                if cached.get("node_map"):
+                    self._node_maps[doc_id] = cached["node_map"]
+                if cached.get("flat_sections"):
+                    self._flat_sections[doc_id] = cached["flat_sections"]
+                self._hash_to_doc_id[content_hash] = doc_id
+                return self._documents[doc_id]
         return None
 
     def set_hash_mapping(self, content_hash: str, doc_id: str) -> None:
         self._hash_to_doc_id[content_hash] = doc_id
         doc = self._documents.get(doc_id)
         if doc and doc.get("status") == "ready" and doc.get("tree"):
+            try:
+                persistent_db.save_doc_index(
+                    doc_id=doc_id,
+                    content_hash=content_hash,
+                    tree=doc.get("tree"),
+                    node_map=self._node_maps.get(doc_id),
+                    flat_sections=self._flat_sections.get(doc_id),
+                )
+            except Exception:
+                pass
             cache_path = os.path.join(CACHE_DIR, f"{content_hash}.json")
             try:
                 payload = {
@@ -302,6 +330,26 @@ class MemoryStorage:
         except Exception:
             pass
 
+        # Backup original PDF bytes (base64) so it survives ephemeral restarts
+        file_b64 = None
+        target_path = file_path or doc.get("file_path")
+        if target_path and os.path.exists(target_path):
+            try:
+                with open(target_path, "rb") as bf:
+                    file_b64 = base64.b64encode(bf.read()).decode("utf-8")
+            except Exception:
+                pass
+
+        # Persist full tree & index to DB (PostgreSQL / SQLite)
+        persistent_db.save_doc_index(
+            doc_id=doc_id,
+            content_hash=doc.get("content_hash"),
+            tree=tree,
+            node_map=self._node_maps.get(doc_id),
+            flat_sections=self._flat_sections.get(doc_id),
+            file_base64=file_b64,
+        )
+
         persistent_db.upsert_doc_meta(
             doc_id=doc_id,
             filename=doc["filename"],
@@ -353,10 +401,10 @@ class MemoryStorage:
         if not doc_id:
             return None
         doc = self._documents.get(doc_id)
-        if doc:
+        if doc and doc.get("status") == "ready" and doc.get("tree"):
             return doc
 
-        # Check SQLite
+        # Check Persistent DB
         db_meta = persistent_db.get_doc_meta(doc_id)
         if db_meta:
             doc_obj = {
@@ -377,6 +425,7 @@ class MemoryStorage:
                 "updated_at": db_meta.get("updated_at", time.time()),
             }
             if doc_obj["status"] == "ready":
+                # 1. Try disk cache
                 candidates = [f"{doc_id}.json"]
                 if doc_obj.get("content_hash"):
                     candidates.append(f"{doc_obj['content_hash']}.json")
@@ -396,6 +445,45 @@ class MemoryStorage:
                         except Exception:
                             pass
 
+                # 2. If tree was not found on disk, load directly from Persistent DB!
+                if doc_obj.get("tree") is None:
+                    idx = persistent_db.get_doc_index(doc_id)
+                    if not idx and doc_obj.get("content_hash"):
+                        idx = persistent_db.get_doc_index_by_hash(doc_obj["content_hash"])
+                    if idx and idx.get("tree"):
+                        doc_obj["tree"] = idx["tree"]
+                        self._trees[doc_id] = idx["tree"]
+                        if idx.get("node_map"):
+                            self._node_maps[doc_id] = idx["node_map"]
+                        if idx.get("flat_sections"):
+                            self._flat_sections[doc_id] = idx["flat_sections"]
+
+                        # Recreate file on disk if missing
+                        if idx.get("file_base64") and doc_obj.get("file_path") and not os.path.exists(doc_obj["file_path"]):
+                            try:
+                                os.makedirs(os.path.dirname(doc_obj["file_path"]), exist_ok=True)
+                                with open(doc_obj["file_path"], "wb") as bf:
+                                    bf.write(base64.b64decode(idx["file_base64"]))
+                            except Exception:
+                                pass
+
+                        # Cache to disk for local speedup
+                        try:
+                            cache_path = os.path.join(CACHE_DIR, f"{doc_id}.json")
+                            with open(cache_path, "w", encoding="utf-8") as f:
+                                json.dump({
+                                    "doc_id": doc_id,
+                                    "filename": doc_obj.get("filename"),
+                                    "tree": doc_obj["tree"],
+                                    "page_count": doc_obj.get("page_count", 1),
+                                    "section_count": doc_obj.get("section_count", 0),
+                                    "node_map": self._node_maps.get(doc_id),
+                                    "flat_sections": self._flat_sections.get(doc_id),
+                                    "created_at": doc_obj.get("created_at", time.time()),
+                                }, f)
+                        except Exception:
+                            pass
+
             self._documents[doc_id] = doc_obj
             return doc_obj
         return None
@@ -444,6 +532,7 @@ class MemoryStorage:
         self._node_maps.pop(doc_id, None)
         self._flat_sections.pop(doc_id, None)
         self._active_tasks.pop(doc_id, None)
+        persistent_db.delete_doc_index(doc_id)
         return persistent_db.delete_doc(doc_id)
 
 

docker-compose.yml

@@ -0,0 +1,39 @@
+version: '3.8'
+
+services:
+  db:
+    image: postgres:16-alpine
+    container_name: rag_postgres
+    restart: always
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: rag_pageindex
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d rag_pageindex"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  backend:
+    build: .
+    container_name: rag_backend
+    restart: always
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres@db:5432/rag_pageindex
+    env_file:
+      - .env
+    ports:
+      - "7860:7860"
+    volumes:
+      - ./data:/app/data
+
+volumes:
+  postgres_data:

pyproject.toml

@@ -10,6 +10,7 @@ dependencies = [
     "huggingface-hub>=2.1.1",
     "openai>=2.36.0",
     "pageindex>=0.2.8",
+    "psycopg2-binary>=2.9.13",
     "pymupdf>=1.27.2.3",
     "python-dotenv>=1.2.2",
     "python-multipart>=0.0.28",

requirements.txt

@@ -0,0 +1,136 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+aiohappyeyeballs==2.7.1
+    # via aiohttp
+aiohttp==3.14.5
+    # via edge-tts
+aiosignal==1.4.0
+    # via aiohttp
+annotated-doc==0.0.5
+    # via fastapi
+annotated-types==0.8.0
+    # via pydantic
+anyio==4.15.1
+    # via
+    #   httpx2
+    #   openai
+    #   starlette
+attrs==26.1.0
+    # via aiohttp
+certifi==2026.7.22
+    # via
+    #   edge-tts
+    #   requests
+charset-normalizer==3.5.2
+    # via requests
+click==8.5.0
+    # via
+    #   huggingface-hub
+    #   uvicorn
+edge-tts==7.3.1
+    # via pageindex-rag (pyproject.toml)
+fastapi==0.143.3
+    # via pageindex-rag (pyproject.toml)
+filelock==4.2.1
+    # via huggingface-hub
+frozenlist==1.8.0
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2026.9.0
+    # via huggingface-hub
+h11==0.16.0
+    # via
+    #   httpcore2
+    #   uvicorn
+hf-xet==1.7.0
+    # via huggingface-hub
+httpcore2==2.13.1
+    # via httpx2
+httpx2==2.13.1
+    # via
+    #   huggingface-hub
+    #   openai
+huggingface-hub==2.2.0
+    # via pageindex-rag (pyproject.toml)
+idna==3.20
+    # via
+    #   anyio
+    #   httpx2
+    #   requests
+    #   yarl
+jiter==0.17.0
+    # via openai
+multidict==7.1.0
+    # via
+    #   aiohttp
+    #   yarl
+openai==3.34.0
+    # via
+    #   pageindex-rag (pyproject.toml)
+    #   pageindex
+opentelemetry-api==1.45.1
+    # via fastapi
+packaging==26.3
+    # via huggingface-hub
+pageindex==0.2.8.1
+    # via pageindex-rag (pyproject.toml)
+propcache==0.5.4
+    # via
+    #   aiohttp
+    #   yarl
+psycopg2-binary==2.9.13
+    # via pageindex-rag (pyproject.toml)
+pydantic==2.14.1
+    # via
+    #   fastapi
+    #   openai
+pydantic-core==2.50.1
+    # via pydantic
+pymupdf==1.28.2
+    # via pageindex-rag (pyproject.toml)
+python-dotenv==1.2.4
+    # via pageindex-rag (pyproject.toml)
+python-multipart==0.0.32
+    # via pageindex-rag (pyproject.toml)
+pyyaml==6.0.3
+    # via huggingface-hub
+requests==2.34.2
+    # via pageindex
+sniffio==1.3.1
+    # via openai
+starlette==1.8.0
+    # via fastapi
+tabulate==0.10.0
+    # via edge-tts
+tqdm==4.70.1
+    # via huggingface-hub
+truststore==0.10.5
+    # via
+    #   httpcore2
+    #   httpx2
+typing-extensions==4.16.0
+    # via
+    #   aiohttp
+    #   aiosignal
+    #   anyio
+    #   edge-tts
+    #   fastapi
+    #   httpx2
+    #   huggingface-hub
+    #   openai
+    #   opentelemetry-api
+    #   pydantic
+    #   pydantic-core
+    #   starlette
+    #   typing-inspection
+typing-inspection==0.4.4
+    # via
+    #   fastapi
+    #   pydantic
+urllib3==2.8.0
+    # via requests
+uvicorn==0.54.0
+    # via pageindex-rag (pyproject.toml)
+yarl==1.25.1
+    # via aiohttp

test_postgres_persistence.py

@@ -0,0 +1,101 @@
+import os
+import sys
+
+# Ensure app is in path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "app"))
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from core.persistent_db import persistent_db
+from core.postgres_db import PostgresDB
+from core.storage import MemoryStorage
+
+def test_persistence():
+    print("Testing PersistentDB connection...")
+    print(f"PersistentDB active instance: {type(persistent_db).__name__}")
+    assert isinstance(persistent_db, PostgresDB), "Expected PostgresDB to be active!"
+
+    # 1. Test Chat & Message CRUD
+    chat_id = "test-chat-pg-1"
+    persistent_db.create_chat(chat_id=chat_id, title="Test PostgreSQL Chat")
+    chat = persistent_db.get_chat(chat_id)
+    assert chat is not None, "Failed to get chat"
+    assert chat["title"] == "Test PostgreSQL Chat"
+
+    persistent_db.add_message(chat_id, "user", "Hello Postgres!")
+    persistent_db.add_message(chat_id, "assistant", "Hello! I remember everything.")
+    msgs = persistent_db.get_messages(chat_id)
+    assert len(msgs) == 2, f"Expected 2 messages, got {len(msgs)}"
+    assert msgs[0]["content"] == "Hello Postgres!"
+    print("✓ Chat & Messages working!")
+
+    # 2. Test Document Meta & Index Storage
+    doc_id = "test-doc-pg-1"
+    filename = "report_2026.pdf"
+    content_hash = "abcdef1234567890"
+
+    persistent_db.upsert_doc_meta(
+        doc_id=doc_id,
+        filename=filename,
+        status="ready",
+        page_count=15,
+        section_count=4,
+        progress=100,
+        current_stage="Ready",
+        indexing_method="pageindex",
+        duration=3.5,
+        content_hash=content_hash,
+    )
+
+    test_tree = [
+        {"title": "Executive Summary", "page_index": 1, "children": []},
+        {"title": "Financial Results", "page_index": 5, "children": [
+            {"title": "Q1 Revenue", "page_index": 6, "children": []}
+        ]}
+    ]
+    test_node_map = {"node_1": {"title": "Executive Summary", "page": 1}}
+    test_sections = [{"title": "Executive Summary", "content": "Summary text", "page": 1}]
+
+    persistent_db.save_doc_index(
+        doc_id=doc_id,
+        content_hash=content_hash,
+        tree=test_tree,
+        node_map=test_node_map,
+        flat_sections=test_sections,
+        file_base64="dGVzdCBwZGYgY29udGVudA==",
+    )
+
+    # Read back index
+    idx = persistent_db.get_doc_index(doc_id)
+    assert idx is not None, "Failed to read doc index"
+    assert idx["tree"] == test_tree, "Tree does not match!"
+    assert idx["node_map"] == test_node_map, "Node map does not match!"
+    assert idx["flat_sections"] == test_sections, "Flat sections do not match!"
+    print("✓ Document Index (JSONB) storage working!")
+
+    # 3. Test Chat Documents
+    persistent_db.add_chat_document(chat_id, doc_id, filename)
+    attached = persistent_db.get_chat_documents(chat_id)
+    assert len(attached) == 1, f"Expected 1 attached doc, got {len(attached)}"
+    assert attached[0]["doc_id"] == doc_id
+    print("✓ Chat Documents working!")
+
+    # 4. Test MemoryStorage Integration with Simulated Cache Wipe
+    storage = MemoryStorage()
+    # Notice: _trees and _documents in storage are currently empty!
+    # get_document should fetch from PostgreSQL, restore tree and sections!
+    restored_doc = storage.get_document(doc_id)
+    assert restored_doc is not None, "Failed to get document via storage"
+    assert restored_doc["status"] == "ready"
+    assert restored_doc["tree"] == test_tree, "Restored tree does not match!"
+    assert storage.get_node_map(doc_id) == test_node_map, "Restored node map does not match!"
+    print("✓ MemoryStorage seamlessly loaded wiped document from PostgreSQL!")
+
+    # Cleanup test data
+    persistent_db.delete_chat(chat_id)
+    persistent_db.delete_doc(doc_id)
+    print("✓ All tests passed successfully!")
+
+if __name__ == "__main__":
+    test_persistence()

uv.lock

@@ -935,6 +935,7 @@ dependencies = [
     { name = "huggingface-hub" },
     { name = "openai" },
     { name = "pageindex" },
+    { name = "psycopg2-binary" },
     { name = "pymupdf" },
     { name = "python-dotenv" },
     { name = "python-multipart" },
@@ -948,6 +949,7 @@ requires-dist = [
     { name = "huggingface-hub", specifier = ">=2.1.1" },
     { name = "openai", specifier = ">=2.36.0" },
     { name = "pageindex", specifier = ">=0.2.8" },
+    { name = "psycopg2-binary", specifier = ">=2.9.13" },
     { name = "pymupdf", specifier = ">=1.27.2.3" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
     { name = "python-multipart", specifier = ">=0.0.28" },
@@ -1082,6 +1084,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f5/cd/785c64ed382f3f04201870267b02783f63b4678c2acfddc177a3ebcc2727/propcache-0.5.4-py3-none-any.whl", hash = "sha256:62c60aec739ed00124573cce1178138fd690c7676352d67a37328c1cf51d7468", size = 16338, upload-time = "2026-09-16T00:17:13.106Z" },
 ]
 
+[[package]]
+name = "psycopg2-binary"
+version = "2.9.13"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/76/7b4383014be0fcc6c1c0e24292845a14e1672cf17fca62ca0a2bd5f4563d/psycopg2_binary-2.9.13.tar.gz", hash = "sha256:e324ecf60f952d21dd11413b8bbed0951bbd99579a06fd06f28bfc37737cd373", size = 378112, upload-time = "2026-09-10T00:06:12.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/03/639c96ff8ffb933868252308a9917ff4170d8c7f4bd16cd0ea2536814126/psycopg2_binary-2.9.13-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d19aec88857d2a52f99eefcefdbbb45921fb2f777bee5186a355a23d9cf8a0b9", size = 3725651, upload-time = "2026-09-09T23:54:29.277Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5e/d50eb688e7e6dfd1499e68cf2d02f44a348b88f381cbc2bebeed15e345f4/psycopg2_binary-2.9.13-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:32cd049095135d2b69e824aea9056745a4aaaa9115a9febbc65584793665d0d0", size = 3817384, upload-time = "2026-09-09T23:54:31.118Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/f3/4004cfbbfc52b9b13ffd499f2103eb05246e92828c7237d2c198e028b95c/psycopg2_binary-2.9.13-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6e696297891b56ff0115f0665de6ad774e1e301e4f60745b8d5024001ae7c2f6", size = 4585497, upload-time = "2026-09-09T23:54:33.169Z" },
+    { url = "https://files.pythonhosted.org/packages/97/63/057c65532bd12cdf9d4f568e59c2a078a38e9ba8f7f251292968dc781905/psycopg2_binary-2.9.13-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:930e7e58b33a4f9c39e7532d7a40147925cf3372baed4229cbebe0cf3ba9ce6b", size = 4281172, upload-time = "2026-09-09T23:54:35.747Z" },
+    { url = "https://files.pythonhosted.org/packages/43/4b/9fd928eaea9ec1e8d74fed83c9e82826f830506ba0d8c58a8fd41ca93656/psycopg2_binary-2.9.13-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3aea95340825f5ff236e7b40f0b5602c2c77a1e95943f71fae34909834043d29", size = 5900973, upload-time = "2026-09-09T23:54:37.866Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/2b/59e1519a22622169e2244f12227b3acde6114ea531a349292f455ab8503f/psycopg2_binary-2.9.13-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:27e539b4cafd5e03dcd32921db1b12dd72fe549dd06bae6d4d2a5b5838465f24", size = 4118611, upload-time = "2026-09-09T23:54:39.739Z" },
+    { url = "https://files.pythonhosted.org/packages/87/c7/c3d84e330d1584efa0560b756914f9128b1b6fa2aba93fde54bf101d4f65/psycopg2_binary-2.9.13-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a6444ac48e2c04f691c2ddd542b38ba30c89463a2d446b3d74ec7d8fc90c964", size = 3659643, upload-time = "2026-09-09T23:54:41.882Z" },
+    { url = "https://files.pythonhosted.org/packages/af/fc/317d248503aa29a5051ee49a7253daffe1c57e43ba174020e00bbd87c479/psycopg2_binary-2.9.13-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:8cb734989420c18ca1b71a82da880e11988f5ff3fcdaadd669161de3e98794ac", size = 3305145, upload-time = "2026-09-09T23:54:43.818Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d2/8b23c57591c6d29a463748ffc634401ce14719dba7e78ab91bcbeac70934/psycopg2_binary-2.9.13-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f47f23db2d70db39cfb714b64fd5df76595b51b2ec0a669710a78f2dceb0c3f8", size = 3051614, upload-time = "2026-09-09T23:54:45.548Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/f2/b10a046cc19ab1e01b92226eeb6e8653be7e6691939991b2f347995831b1/psycopg2_binary-2.9.13-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f28b5f2fa8154d0d97e97a664136f58d1639ca008d45d6e09e69fff24826abee", size = 3353133, upload-time = "2026-09-09T23:54:47.285Z" },
+    { url = "https://files.pythonhosted.org/packages/40/2c/dd379facaa4bd41d7b04711ff30931ca62981c00a91502250ffb49da08a7/psycopg2_binary-2.9.13-cp311-cp311-win_amd64.whl", hash = "sha256:70d091f5c3a6177fac50c0da20181ce0e0c053f1e43c872d5f75bd6d9429c020", size = 2771441, upload-time = "2026-09-09T23:54:49.016Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/d1/d0125c56b865e3bc9f318d84930b2df71a729229dbb0ce12de748a82a6d7/psycopg2_binary-2.9.13-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2bf9f97a6df69a5d89d054b8cf5257a0916096c479800715fbfe7974dbcb3a26", size = 3725735, upload-time = "2026-09-09T23:54:51.182Z" },
+    { url = "https://files.pythonhosted.org/packages/54/a5/b5a73d0910555e38ee12c49c1740855f8a1e9776e87d65f0c51e1bab762a/psycopg2_binary-2.9.13-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:07b7bd9f410650c34c3532162cc329f112368d78a3fc8668cb1ea9df61bc11bf", size = 3818000, upload-time = "2026-09-09T23:54:53.229Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/43/3e4783f62ae3f4fc19a5acf8d1c394df54458f1336febe188f317556d2a7/psycopg2_binary-2.9.13-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:0463c00f946517f3e69192a59e6601e023ff9de45ad0a875eda3d6b1bebeb7ce", size = 4585760, upload-time = "2026-09-09T23:54:55.313Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/c4/a9a67ae65ad3d567eb0fc9cdf9a5a2783b779aecdcdc8945f1807b13d99e/psycopg2_binary-2.9.13-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e3861eba31f8ea8663fd876166b032fd89179e42aa63764d6feb281f13f9eb60", size = 4282380, upload-time = "2026-09-09T23:54:57.362Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/db/9d459d3da12e0b841cf1596579455aaa27e9e593e3e9a5a4ded5a55a7c15/psycopg2_binary-2.9.13-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3dc3372b3731b3ef23407fe06b94f640ef87a2bda242fa386033d5589c87514a", size = 5902039, upload-time = "2026-09-09T23:55:01.955Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/53/21079c10a581c50b6817498eda7c3481c1b3cdb41482bd08ebfccd3664c4/psycopg2_binary-2.9.13-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0405dd4d97720e7ab177aa02e493f524907c4cb3c445ac173e2627948d3d0528", size = 4119840, upload-time = "2026-09-09T23:55:04.336Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ce/71e8d9e1b4f3e78157b49a5abdff50d915e95f2812550f6c9b4f2e4d5e94/psycopg2_binary-2.9.13-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b6ae51708201f501a171b02419d0c30878a743c369c9054eb1289f0f8d5979e2", size = 3661077, upload-time = "2026-09-09T23:55:06.118Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/54/b17616472f09a0fae96f8852692948b7eaa7c971d7629696da0e5932d996/psycopg2_binary-2.9.13-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:81682c227cc1849c4a6adf7b85274229073bb4c9d6ad5697222c695dcea5a8a7", size = 3307202, upload-time = "2026-09-09T23:55:08.061Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c7/d9737e222a377dac67a0ce0a2c73e7231a57f5cf18bb35a65d5c8d45d5d2/psycopg2_binary-2.9.13-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:13d955f6054a705a19554364fe9888d0a6e8b0746dc7ebc08a447c7b4fd4145c", size = 3052893, upload-time = "2026-09-09T23:55:10.209Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/3d/c406c9f698f518c264381192c2bdf8952ee84e469ffa9f82db1411f57385/psycopg2_binary-2.9.13-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7e2405196a8cfe6cd3e54172a54452dcf85c241eaf2e9dde7190d7469f7f5ef7", size = 3355210, upload-time = "2026-09-09T23:55:11.883Z" },
+    { url = "https://files.pythonhosted.org/packages/27/64/6e3a96699770af2d0d49a2002f722c69b656fc27623ff89281cf2b109644/psycopg2_binary-2.9.13-cp312-cp312-win_amd64.whl", hash = "sha256:376ebf7d8aee4b7386b2bac31fdc27911e7e57cd0a88f1e038b8b149398ac008", size = 2767784, upload-time = "2026-09-09T23:55:13.823Z" },
+    { url = "https://files.pythonhosted.org/packages/82/0a/795f2869788373cf7d08410341a444196e8ccebbac07a70a8f9a1f60e72f/psycopg2_binary-2.9.13-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4d66bfd44a46eb88cff0287929a4193fb45166b6c1f84bb1b233cc17ece0813c", size = 3725723, upload-time = "2026-09-09T23:55:15.887Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/63/5a9633f4563a73beba69b20a846ddd14c1c6ac072f5e8aab0da97ffabc2a/psycopg2_binary-2.9.13-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f818161d2302b3b3e9c75d5a1d0a5c5679e92e45cfec6432b9d5432dde5ff1f1", size = 3817976, upload-time = "2026-09-09T23:55:18.025Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/e2/b2e3b3a4331dc8b58e328cda30f3d0cc43a94b7aaf0c8383efd53dd10e95/psycopg2_binary-2.9.13-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:31db6cba66df5231dfd91d9f69188bec3fe6c8baae384e93a0ce792067ee2d98", size = 4585813, upload-time = "2026-09-09T23:55:20.112Z" },
+    { url = "https://files.pythonhosted.org/packages/56/5c/87daea77c4132114d1a5da3a4928dd59446c3b3cc73d288cae08cf0b91a6/psycopg2_binary-2.9.13-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f04ada42bcd537adbaf8b7f3140237a204e452a88d0c1831cfce69f7d2e59f4e", size = 4282438, upload-time = "2026-09-09T23:55:22.329Z" },
+    { url = "https://files.pythonhosted.org/packages/91/e5/56f9efdc9337acbd1a75798d97163183b63a1babc17602f7163009506c96/psycopg2_binary-2.9.13-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa37089795bd9701576edc2eb5849ce77a439eda9dfdfa47857449332cfa5292", size = 5902064, upload-time = "2026-09-09T23:55:24.37Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/15/f7ed0b90b47b73a9087306b42267eccfd919f92c0fb057e46bd2fa2efa4d/psycopg2_binary-2.9.13-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:41c2eb569ebd0e1b02d30d361a46932923b193fe1b5e641fb4d547c75e218955", size = 4119848, upload-time = "2026-09-09T23:55:26.433Z" },
+    { url = "https://files.pythonhosted.org/packages/42/08/3091347b9fc5766e979aba6b0756ad14ce867a6bb245f3d69ac71fb768c6/psycopg2_binary-2.9.13-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3f699a5225094a5c61402984e2fc1eca20e940223e76767c88189efb0c313f69", size = 3661129, upload-time = "2026-09-09T23:55:28.449Z" },
+    { url = "https://files.pythonhosted.org/packages/34/c4/4f9a84d55484c9794b364548eb6e1fe10a57f123afd19729e5a1cc8ad7fc/psycopg2_binary-2.9.13-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5f04ae99c9fbb94c3197ec88599ed7db921f6adcddfe83687a74c7ead4037c22", size = 3307262, upload-time = "2026-09-09T23:55:30.384Z" },
+    { url = "https://files.pythonhosted.org/packages/83/42/6eba8306a61dc890805ae475a9e71790a1c5461ccacbd4f0a1f3f57b40f0/psycopg2_binary-2.9.13-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:81404c37e0344ebcf10aac127d33d35137e5dbab1daf9f3deee46188fd5879c2", size = 3052898, upload-time = "2026-09-09T23:55:32.961Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/5d/42a8935ab280e8dcd7c07a655c0c3d25d62e9e242be1961ac14630f1294a/psycopg2_binary-2.9.13-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:feb7b1856f6ca805cc0e08739858f6cdfed8ce903390126af30343c62899a389", size = 3355265, upload-time = "2026-09-09T23:55:35.071Z" },
+    { url = "https://files.pythonhosted.org/packages/87/c2/0e0ffb4caeb651631cbc6c8ead83e2a16457750b1d2eb7f5ef111c1f4d36/psycopg2_binary-2.9.13-cp313-cp313-win_amd64.whl", hash = "sha256:691da68ae5dd7c3ac77514357d35ece7b1ba8b5f3e6c92735198aa6159c355c8", size = 2767914, upload-time = "2026-09-09T23:55:37.14Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/32/897c074cb99fbdda7d34b0a2546097a59162bb3d04c0d546ae4ec82345e3/psycopg2_binary-2.9.13-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2ca263643ae37998ae04d18e431df34d0d61f12b47640dab585f14b6dbe00798", size = 3725788, upload-time = "2026-09-09T23:55:39.04Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/f4/e3a789de34c9ac25d20b25c2be583da16394a2ba0926da1c863653831f41/psycopg2_binary-2.9.13-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4c0214c7da18a28d108aa7108c8a3cca8035c7911ec97ef9ec0827569c9a2720", size = 3818111, upload-time = "2026-09-09T23:55:40.979Z" },
+    { url = "https://files.pythonhosted.org/packages/72/29/647724c43ac510dbc59b80e20e85d439deb94f5d5a024153c32330fa041d/psycopg2_binary-2.9.13-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5d89e064bb12b40cad696cf4975e6da86f8c60f14cd06cb6c1bc0a7f5d01761f", size = 4586235, upload-time = "2026-09-09T23:55:43.012Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ad/7f52f92cc65c23778daff7eec4ee2099236694a0a4723a5f180d0708b607/psycopg2_binary-2.9.13-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:190c18b97d9ef72f2e88c451b6588af90d6bd7bf54cb94b963280dc86a2c7076", size = 4282424, upload-time = "2026-09-09T23:55:44.843Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2a/1a472059b198942d99651656e2bc610575584478bfe68d297ecabbd4887f/psycopg2_binary-2.9.13-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c00ebe9a2f31151aade0db233dc1446513a95e92c39ce055ee097af0ae86be1c", size = 5902365, upload-time = "2026-09-09T23:55:46.619Z" },
+    { url = "https://files.pythonhosted.org/packages/91/1a/171ea5dac7b3a0fa57b3cb59c2ad6d7b8bc60732368fecfd2ed1f1288392/psycopg2_binary-2.9.13-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5085f7ff7b1e890f279577cedeb8c628957869a340fa34a39f7f406500b3c916", size = 4119938, upload-time = "2026-09-09T23:55:49.381Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ce/3c6d4ad71853a59eee6a575fe36df4bb40752a9735a27bd62af66b454ed5/psycopg2_binary-2.9.13-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4e55357d1943673d491bbabb171c891704fc6a22441fea539e05a5c27a79ea3c", size = 3661557, upload-time = "2026-09-09T23:55:51.269Z" },
+    { url = "https://files.pythonhosted.org/packages/10/a3/1819a01bf951eab2afb5ca2a3d11f50500bf536fecff088154372a8d1985/psycopg2_binary-2.9.13-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:3e60b06ec7f9dc3e5f1106d12706514b6d6b92c3dc438fcdf4e43e65cc660d1b", size = 3307770, upload-time = "2026-09-09T23:55:53.196Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/df/22f4aec952cd5b2dd02f438399583ed69f7d04b90e7c31659d9571bbe188/psycopg2_binary-2.9.13-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:dde942b46ce20f6c4464cdf551f3293207f803f4e4354454eb1f5599c3eb1fa1", size = 3052935, upload-time = "2026-09-09T23:55:55.117Z" },
+    { url = "https://files.pythonhosted.org/packages/95/42/aab651bc22bafa961806ca3b21027bb0739a2730b0e6f7f0778baeb95e67/psycopg2_binary-2.9.13-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:215777c62ce81c3b487cefdb6a41969944eb982309f91349ff3ca0323d6f17ed", size = 3355387, upload-time = "2026-09-09T23:55:57.366Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/af/3b8220633eaf955e95ea7be67d76e81a0d1cd3c76362ea504b91ffa079db/psycopg2_binary-2.9.13-cp314-cp314-win_amd64.whl", hash = "sha256:f3088eb80f58ed933c62d87128741d31e786edc862e23266d3c286763d646de0", size = 2863890, upload-time = "2026-09-09T23:55:59.056Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f1/377d17fc8425220d17552691cd2b97aa232da92173f5dead71278b83f8ab/psycopg2_binary-2.9.13-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:38397def2d794ffde9db80f63d6820253e61b17483112652a318355f51a56f50", size = 3725913, upload-time = "2026-09-09T23:56:00.736Z" },
+    { url = "https://files.pythonhosted.org/packages/67/64/27208e67cd6e663f69bf7bf905cf69db066a015c90ac9ca948a56a8e9d78/psycopg2_binary-2.9.13-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:dff5c70ed9789ccb0d97ff4a7da51dc523a255c4ec95df188fa5d44adcae4ea8", size = 3818303, upload-time = "2026-09-09T23:56:02.551Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/98/67d2f34a1d18367b5f655bdd101759f8474286c74ffe701b7d6e3abd7fda/psycopg2_binary-2.9.13-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:08d3b81a6a91775c937abf97d4c58fc9142e8e35fb91c387d24f81d15c98e6cf", size = 4586508, upload-time = "2026-09-09T23:56:04.706Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/47/46c227deaf322dceafa0b7b321b4e5de9cc797014b7a353349b2e09b1118/psycopg2_binary-2.9.13-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:541a487a9ccd72b5e38f37f27b0ce78cb7eb3e336e7b5277d45463010c03a7a8", size = 4282383, upload-time = "2026-09-09T23:56:06.678Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/3c/e8705ffa381160d842eaf06a8446e8416f1a2497dd70a7e62277f3be6e7a/psycopg2_binary-2.9.13-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:562fe2a43b30e781848dce63d9080c15414c777c96df348c4342558338cc7bf3", size = 5902765, upload-time = "2026-09-09T23:56:08.634Z" },
+    { url = "https://files.pythonhosted.org/packages/53/cc/359821c18317228b8032456a3740c98045b719ed003a594b9ebac9330b86/psycopg2_binary-2.9.13-cp315-cp315-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dddfe650e7dda464d676c27fbedb5061f1ad05e1604627f54c770d7f799d36e9", size = 4122849, upload-time = "2026-09-09T23:56:10.671Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e5/4d935acb6d3258c7a767b3d527e54c0b537649101b55002a5dbcfe747e2a/psycopg2_binary-2.9.13-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:4ff0f575cbb14f30445858dcfdd751e043486f5290915df78a9818bc74042eff", size = 3662084, upload-time = "2026-09-09T23:56:12.316Z" },
+    { url = "https://files.pythonhosted.org/packages/89/56/9e9bbc7c773c5de7bb25dd35d7f041c2a6f0fcfa9207a1ceaf01a1bc687c/psycopg2_binary-2.9.13-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:d79530b4c1af657d5620a1d21b8e39f2996aa06821d5564d05b22d6b8cd413d0", size = 3308077, upload-time = "2026-09-09T23:56:15.262Z" },
+    { url = "https://files.pythonhosted.org/packages/36/fa/ed742cd4e5dbddcb44702f9c4a97f7f5b62d97e3d9d00907ecc8ac750ef4/psycopg2_binary-2.9.13-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:6ede8595767e19d30a7e8a84a7d47bfde6176d45d194fed08dbb68d1584a780b", size = 3055143, upload-time = "2026-09-09T23:56:17.168Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/3a/5c2cb71a844ee236be2ce91b286d797e34a21489909357c7cfba0f5c0197/psycopg2_binary-2.9.13-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:0ebcf3c4266a695df9d0ef51296155f60c86ac51cf82f0d0dd2e827255a891c5", size = 3355374, upload-time = "2026-09-09T23:56:18.793Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/30/3991c9fdcca90a5a1e55435292f4d74d176da2be15f3998f6858da3658cc/psycopg2_binary-2.9.13-cp315-cp315-win_amd64.whl", hash = "sha256:1752b9821f1377404d65ac43af03d59a1eccc57fb2c1eb8305f9a3fe8eb7a8ba", size = 2867246, upload-time = "2026-09-09T23:56:20.501Z" },
+]
+
 [[package]]
 name = "pydantic"
 version = "2.13.4"