feat(auth): enforce client ownership and data isolation across all endpoints and databases

app/app.py

@@ -49,6 +49,12 @@ except Exception as mcp_err:
     app_logger.warning(f"Could not mount FastMCP at /mcp: {mcp_err}")
 
 
+@app.get("/", tags=["Health"])
+async def root():
+    """Public root endpoint."""
+    return {"message": "Atlas - Document Intelligence API", "docs": "/docs", "health": "/health"}
+
+
 @app.get("/health", tags=["Health"])
 async def health_check():
     """Health check endpoint to verify service availability and database status."""

app/core/dependencies.py

@@ -1,11 +1,31 @@
 import os
+import uuid
+from typing import Optional
 from functools import lru_cache
+from fastapi import Header, HTTPException, status
 from services.document_service import DocumentService
 from services.llm_service import LLMService
 from core.rag_pipeline import VectorlessRAG
 from core.storage import storage, MemoryStorage
 
 
+def get_client_id(x_client_id: Optional[str] = Header(None, alias="X-Client-ID")) -> str:
+    """FastAPI dependency validating the X-Client-ID header as a valid UUIDv4."""
+    if not x_client_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Missing required header: X-Client-ID",
+        )
+    try:
+        val = uuid.UUID(x_client_id.strip(), version=4)
+        return str(val)
+    except (ValueError, AttributeError):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid X-Client-ID format: must be a valid UUIDv4 string",
+        )
+
+
 @lru_cache()
 def get_document_service() -> DocumentService:
     return DocumentService(api_key=os.getenv("PAGEINDEX_API_KEY"))

app/core/persistent_db.py

@@ -37,6 +37,7 @@ CREATE TABLE IF NOT EXISTS chats (
     title       TEXT,
     doc_id      TEXT,
     doc_name    TEXT,
+    owner_id    TEXT,
     created_at  REAL NOT NULL,
     updated_at  REAL NOT NULL
 );
@@ -64,6 +65,7 @@ CREATE TABLE IF NOT EXISTS doc_meta (
     error           TEXT,
     content_hash    TEXT,
     file_path       TEXT,
+    owner_id        TEXT,
     created_at      REAL NOT NULL,
     updated_at      REAL NOT NULL
 );
@@ -111,6 +113,7 @@ CREATE TABLE IF NOT EXISTS knowledge_memory (
 
 CREATE TABLE IF NOT EXISTS global_knowledge_summary (
     id                  TEXT PRIMARY KEY,
+    owner_id            TEXT,
     collective_summary  TEXT NOT NULL,
     total_documents     INTEGER DEFAULT 0,
     key_insights        TEXT,
@@ -158,9 +161,23 @@ class SQLitePersistentDB:
                 ("indexing_method", "TEXT", "NULL"),
                 ("duration", "REAL", "NULL"),
                 ("error", "TEXT", "NULL"),
+                ("owner_id", "TEXT", "NULL"),
             ]:
                 if col not in existing_cols:
                     conn.execute(f"ALTER TABLE doc_meta ADD COLUMN {col} {col_type} DEFAULT {default_val}")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_sqlite_doc_meta_owner ON doc_meta(owner_id)")
+
+            cursor = conn.execute("PRAGMA table_info(chats)")
+            chat_cols = {row["name"] for row in cursor.fetchall()}
+            if "owner_id" not in chat_cols:
+                conn.execute("ALTER TABLE chats ADD COLUMN owner_id TEXT DEFAULT NULL")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_sqlite_chats_owner ON chats(owner_id)")
+
+            cursor = conn.execute("PRAGMA table_info(global_knowledge_summary)")
+            gks_cols = {row["name"] for row in cursor.fetchall()}
+            if "owner_id" not in gks_cols:
+                conn.execute("ALTER TABLE global_knowledge_summary ADD COLUMN owner_id TEXT DEFAULT NULL")
+            conn.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_sqlite_gks_owner ON global_knowledge_summary(owner_id)")
 
             # Migrate existing chats.doc_id into chat_documents table
             conn.execute("""
@@ -170,26 +187,36 @@ class SQLitePersistentDB:
             """)
 
     # ── chat CRUD ───────────────────────────────────────────────────────────
-    def create_chat(self, chat_id: Optional[str] = None, title: Optional[str] = None) -> str:
+    def create_chat(self, chat_id: Optional[str] = None, title: Optional[str] = None, owner_id: Optional[str] = None) -> str:
         cid = chat_id or str(uuid.uuid4())
         now = time.time()
         with self._tx() as conn:
             conn.execute(
-                "INSERT OR IGNORE INTO chats(chat_id, title, created_at, updated_at) VALUES(?,?,?,?)",
-                (cid, title, now, now),
+                "INSERT OR IGNORE INTO chats(chat_id, title, owner_id, created_at, updated_at) VALUES(?,?,?,?,?)",
+                (cid, title, owner_id, now, now),
             )
         return cid
 
-    def get_chat(self, chat_id: str) -> Optional[Dict[str, Any]]:
-        row = self._conn().execute(
-            "SELECT * FROM chats WHERE chat_id=?", (chat_id,)
-        ).fetchone()
+    def get_chat(self, chat_id: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        if owner_id:
+            row = self._conn().execute(
+                "SELECT * FROM chats WHERE chat_id=? AND owner_id=?", (chat_id, owner_id)
+            ).fetchone()
+        else:
+            row = self._conn().execute(
+                "SELECT * FROM chats WHERE chat_id=?", (chat_id,)
+            ).fetchone()
         return dict(row) if row else None
 
-    def list_chats(self) -> List[Dict[str, Any]]:
-        rows = self._conn().execute(
-            "SELECT * FROM chats ORDER BY updated_at DESC"
-        ).fetchall()
+    def list_chats(self, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        if owner_id:
+            rows = self._conn().execute(
+                "SELECT * FROM chats WHERE owner_id=? ORDER BY updated_at DESC", (owner_id,)
+            ).fetchall()
+        else:
+            rows = self._conn().execute(
+                "SELECT * FROM chats ORDER BY updated_at DESC"
+            ).fetchall()
         return [dict(r) for r in rows]
 
     def update_chat_title(self, chat_id: str, title: str) -> None:
@@ -213,17 +240,21 @@ class SQLitePersistentDB:
                 (time.time(), chat_id),
             )
 
-    def delete_chat(self, chat_id: str) -> None:
+    def delete_chat(self, chat_id: str, owner_id: Optional[str] = None) -> bool:
         with self._tx() as conn:
-            conn.execute("DELETE FROM chats WHERE chat_id=?", (chat_id,))
+            if owner_id:
+                cur = conn.execute("DELETE FROM chats WHERE chat_id=? AND owner_id=?", (chat_id, owner_id))
+            else:
+                cur = conn.execute("DELETE FROM chats WHERE chat_id=?", (chat_id,))
+            return cur.rowcount > 0
 
     # ── message CRUD ────────────────────────────────────────────────────────
-    def add_message(self, chat_id: str, role: str, content: str) -> None:
+    def add_message(self, chat_id: str, role: str, content: str, owner_id: Optional[str] = None) -> None:
         now = time.time()
         with self._tx() as conn:
             conn.execute(
-                "INSERT OR IGNORE INTO chats(chat_id, title, created_at, updated_at) VALUES(?, 'New research', ?, ?)",
-                (chat_id, now, now),
+                "INSERT OR IGNORE INTO chats(chat_id, title, owner_id, created_at, updated_at) VALUES(?, 'New research', ?, ?, ?)",
+                (chat_id, owner_id, now, now),
             )
             conn.execute(
                 "INSERT INTO messages(chat_id, role, content, created_at) VALUES(?,?,?,?)",
@@ -263,6 +294,7 @@ class SQLitePersistentDB:
         error: Optional[str] = None,
         content_hash: Optional[str] = None,
         file_path: Optional[str] = None,
+        owner_id: Optional[str] = None,
     ) -> None:
         now = time.time()
         with self._tx() as conn:
@@ -271,9 +303,9 @@ class SQLitePersistentDB:
                 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
+                    error, content_hash, file_path, owner_id, created_at, updated_at
                 )
-                VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
                 ON CONFLICT(doc_id) DO UPDATE SET
                     filename=excluded.filename,
                     status=excluded.status,
@@ -286,36 +318,57 @@ class SQLitePersistentDB:
                     error=excluded.error,
                     content_hash=COALESCE(excluded.content_hash, doc_meta.content_hash),
                     file_path=COALESCE(excluded.file_path, doc_meta.file_path),
+                    owner_id=COALESCE(excluded.owner_id, doc_meta.owner_id),
                     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
+                    error, content_hash, file_path, owner_id, now, now
                 ),
             )
 
-    def get_doc_meta(self, doc_id: str) -> Optional[Dict[str, Any]]:
-        row = self._conn().execute(
-            "SELECT * FROM doc_meta WHERE doc_id=?", (doc_id,)
-        ).fetchone()
+    def get_doc_meta(self, doc_id: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        if owner_id:
+            row = self._conn().execute(
+                "SELECT * FROM doc_meta WHERE doc_id=? AND owner_id=?", (doc_id, owner_id)
+            ).fetchone()
+        else:
+            row = self._conn().execute(
+                "SELECT * FROM doc_meta WHERE doc_id=?", (doc_id,)
+            ).fetchone()
         return dict(row) if row else None
 
-    def list_docs(self) -> List[Dict[str, Any]]:
-        rows = self._conn().execute(
-            "SELECT * FROM doc_meta ORDER BY created_at DESC"
-        ).fetchall()
+    def list_docs(self, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        if owner_id:
+            rows = self._conn().execute(
+                "SELECT * FROM doc_meta WHERE owner_id=? ORDER BY created_at DESC", (owner_id,)
+            ).fetchall()
+        else:
+            rows = self._conn().execute(
+                "SELECT * FROM doc_meta ORDER BY created_at DESC"
+            ).fetchall()
         return [dict(r) for r in rows]
 
-    def find_doc_by_hash(self, content_hash: str) -> Optional[Dict[str, Any]]:
-        row = self._conn().execute(
-            "SELECT * FROM doc_meta WHERE content_hash=? ORDER BY updated_at DESC LIMIT 1",
-            (content_hash,),
-        ).fetchone()
+    def find_doc_by_hash(self, content_hash: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        if owner_id:
+            row = self._conn().execute(
+                "SELECT * FROM doc_meta WHERE content_hash=? AND owner_id=? ORDER BY updated_at DESC LIMIT 1",
+                (content_hash, owner_id),
+            ).fetchone()
+        else:
+            row = self._conn().execute(
+                "SELECT * FROM doc_meta WHERE content_hash=? ORDER BY updated_at DESC LIMIT 1",
+                (content_hash,),
+            ).fetchone()
         return dict(row) if row else None
 
-    def delete_doc(self, doc_id: str) -> bool:
+    def delete_doc(self, doc_id: str, owner_id: Optional[str] = None) -> bool:
         with self._tx() as conn:
+            if owner_id:
+                doc = self.get_doc_meta(doc_id, owner_id=owner_id)
+                if not doc:
+                    return False
             cur = conn.execute("DELETE FROM doc_meta WHERE doc_id=?", (doc_id,))
             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,))
@@ -434,7 +487,11 @@ class SQLitePersistentDB:
                     (now, chat_id),
                 )
 
-    def get_chat_documents(self, chat_id: str) -> List[Dict[str, Any]]:
+    def get_chat_documents(self, chat_id: str, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        if owner_id:
+            chat = self.get_chat(chat_id, owner_id=owner_id)
+            if not chat:
+                return []
         rows = self._conn().execute(
             """
             SELECT cd.chat_id, cd.doc_id, cd.doc_name, cd.attached_at,
@@ -513,10 +570,20 @@ class SQLitePersistentDB:
                 ),
             )
 
-    def get_knowledge_dossier(self, doc_id: str) -> Optional[Dict[str, Any]]:
-        row = self._conn().execute(
-            "SELECT * FROM knowledge_memory WHERE doc_id=?", (doc_id,)
-        ).fetchone()
+    def get_knowledge_dossier(self, doc_id: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        if owner_id:
+            row = self._conn().execute(
+                """
+                SELECT km.* FROM knowledge_memory km
+                JOIN doc_meta dm ON km.doc_id = dm.doc_id
+                WHERE km.doc_id=? AND dm.owner_id=?
+                """,
+                (doc_id, owner_id),
+            ).fetchone()
+        else:
+            row = self._conn().execute(
+                "SELECT * FROM knowledge_memory WHERE doc_id=?", (doc_id,)
+            ).fetchone()
         if not row:
             return None
         res = dict(row)
@@ -528,10 +595,21 @@ class SQLitePersistentDB:
                     res[k] = []
         return res
 
-    def list_knowledge_dossiers(self) -> List[Dict[str, Any]]:
-        rows = self._conn().execute(
-            "SELECT * FROM knowledge_memory ORDER BY updated_at DESC"
-        ).fetchall()
+    def list_knowledge_dossiers(self, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        if owner_id:
+            rows = self._conn().execute(
+                """
+                SELECT km.* FROM knowledge_memory km
+                JOIN doc_meta dm ON km.doc_id = dm.doc_id
+                WHERE dm.owner_id=?
+                ORDER BY km.updated_at DESC
+                """,
+                (owner_id,),
+            ).fetchall()
+        else:
+            rows = self._conn().execute(
+                "SELECT * FROM knowledge_memory ORDER BY updated_at DESC"
+            ).fetchall()
         result = []
         for r in rows:
             item = dict(r)
@@ -553,29 +631,51 @@ class SQLitePersistentDB:
         collective_summary: str,
         total_documents: int,
         key_insights: Optional[List[str]] = None,
+        owner_id: Optional[str] = None,
     ) -> None:
         now = time.time()
-        gid = "global"
+        gid = owner_id or "global"
         with self._tx() as conn:
-            conn.execute(
-                """
-                INSERT INTO global_knowledge_summary(
-                    id, collective_summary, total_documents, key_insights, updated_at
+            if owner_id:
+                conn.execute(
+                    """
+                    INSERT INTO global_knowledge_summary(
+                        id, owner_id, collective_summary, total_documents, key_insights, updated_at
+                    )
+                    VALUES(?,?,?,?,?,?)
+                    ON CONFLICT(owner_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, owner_id, collective_summary, total_documents, json.dumps(key_insights or []), now),
+                )
+            else:
+                conn.execute(
+                    """
+                    INSERT INTO global_knowledge_summary(
+                        id, collective_summary, total_documents, key_insights, updated_at
+                    )
+                    VALUES(?,?,?,?,?)
+                    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, json.dumps(key_insights or []), now),
                 )
-                VALUES(?,?,?,?,?)
-                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, json.dumps(key_insights or []), now),
-            )
 
-    def get_global_knowledge_summary(self) -> Optional[Dict[str, Any]]:
-        row = self._conn().execute(
-            "SELECT * FROM global_knowledge_summary WHERE id='global'"
-        ).fetchone()
+    def get_global_knowledge_summary(self, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        if owner_id:
+            row = self._conn().execute(
+                "SELECT * FROM global_knowledge_summary WHERE owner_id=?", (owner_id,)
+            ).fetchone()
+        else:
+            row = self._conn().execute(
+                "SELECT * FROM global_knowledge_summary WHERE id='global'"
+            ).fetchone()
         if not row:
             return None
         res = dict(row)

app/core/postgres_db.py

@@ -27,10 +27,13 @@ CREATE TABLE IF NOT EXISTS chats (
     title       TEXT,
     doc_id      TEXT,
     doc_name    TEXT,
+    owner_id    TEXT,
     created_at  DOUBLE PRECISION NOT NULL,
     updated_at  DOUBLE PRECISION NOT NULL
 );
 
+CREATE INDEX IF NOT EXISTS idx_pg_chats_owner ON chats(owner_id);
+
 CREATE TABLE IF NOT EXISTS messages (
     id          BIGSERIAL PRIMARY KEY,
     chat_id     TEXT NOT NULL REFERENCES chats(chat_id) ON DELETE CASCADE,
@@ -54,11 +57,13 @@ CREATE TABLE IF NOT EXISTS doc_meta (
     error           TEXT,
     content_hash    TEXT,
     file_path       TEXT,
+    owner_id        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 INDEX IF NOT EXISTS idx_pg_doc_meta_owner ON doc_meta(owner_id);
 
 CREATE TABLE IF NOT EXISTS doc_indices (
     doc_id          TEXT PRIMARY KEY REFERENCES doc_meta(doc_id) ON DELETE CASCADE,
@@ -102,11 +107,14 @@ CREATE TABLE IF NOT EXISTS knowledge_memory (
 
 CREATE TABLE IF NOT EXISTS global_knowledge_summary (
     id                  TEXT PRIMARY KEY,
+    owner_id            TEXT,
     collective_summary  TEXT NOT NULL,
     total_documents     INTEGER DEFAULT 0,
     key_insights        JSONB,
     updated_at          DOUBLE PRECISION NOT NULL
 );
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_pg_gks_owner ON global_knowledge_summary(owner_id);
 """
 
 
@@ -172,35 +180,59 @@ class PostgresDB:
         with self._conn() as conn:
             with conn.cursor() as cur:
                 cur.execute(_PG_DDL)
+                for tbl, idx in [
+                    ("chats", "idx_pg_chats_owner"),
+                    ("doc_meta", "idx_pg_doc_meta_owner"),
+                    ("global_knowledge_summary", "idx_pg_gks_owner"),
+                ]:
+                    cur.execute(
+                        """
+                        SELECT column_name FROM information_schema.columns 
+                        WHERE table_name = %s AND column_name = 'owner_id';
+                        """,
+                        (tbl,),
+                    )
+                    if not cur.fetchone():
+                        cur.execute(f"ALTER TABLE {tbl} ADD COLUMN owner_id TEXT;")
+                    if tbl == "global_knowledge_summary":
+                        cur.execute(f"CREATE UNIQUE INDEX IF NOT EXISTS {idx} ON {tbl}(owner_id);")
+                    else:
+                        cur.execute(f"CREATE INDEX IF NOT EXISTS {idx} ON {tbl}(owner_id);")
         app_logger.info("[PostgresDB] Schema initialized / verified successfully.")
 
     # ── chat CRUD ───────────────────────────────────────────────────────────
-    def create_chat(self, chat_id: Optional[str] = None, title: Optional[str] = None) -> str:
+    def create_chat(self, chat_id: Optional[str] = None, title: Optional[str] = None, owner_id: 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)
+                    INSERT INTO chats(chat_id, title, owner_id, created_at, updated_at)
+                    VALUES (%s, %s, %s, %s, %s)
                     ON CONFLICT (chat_id) DO NOTHING
                     """,
-                    (cid, title, now, now),
+                    (cid, title, owner_id, now, now),
                 )
         return cid
 
-    def get_chat(self, chat_id: str) -> Optional[Dict[str, Any]]:
+    def get_chat(self, chat_id: str, owner_id: Optional[str] = None) -> 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,))
+                if owner_id:
+                    cur.execute("SELECT * FROM chats WHERE chat_id = %s AND owner_id = %s", (chat_id, owner_id))
+                else:
+                    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]]:
+    def list_chats(self, owner_id: Optional[str] = None) -> 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")
+                if owner_id:
+                    cur.execute("SELECT * FROM chats WHERE owner_id = %s ORDER BY updated_at DESC", (owner_id,))
+                else:
+                    cur.execute("SELECT * FROM chats ORDER BY updated_at DESC")
                 rows = cur.fetchall()
                 return [dict(r) for r in rows]
 
@@ -228,23 +260,27 @@ class PostgresDB:
                     (time.time(), chat_id),
                 )
 
-    def delete_chat(self, chat_id: str) -> None:
+    def delete_chat(self, chat_id: str, owner_id: Optional[str] = None) -> bool:
         with self._conn() as conn:
             with conn.cursor() as cur:
-                cur.execute("DELETE FROM chats WHERE chat_id = %s", (chat_id,))
+                if owner_id:
+                    cur.execute("DELETE FROM chats WHERE chat_id = %s AND owner_id = %s", (chat_id, owner_id))
+                else:
+                    cur.execute("DELETE FROM chats WHERE chat_id = %s", (chat_id,))
+                return cur.rowcount > 0
 
     # ── message CRUD ────────────────────────────────────────────────────────
-    def add_message(self, chat_id: str, role: str, content: str) -> None:
+    def add_message(self, chat_id: str, role: str, content: str, owner_id: Optional[str] = None) -> 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)
+                    INSERT INTO chats(chat_id, title, owner_id, created_at, updated_at)
+                    VALUES (%s, 'New research', %s, %s, %s)
                     ON CONFLICT (chat_id) DO NOTHING
                     """,
-                    (chat_id, now, now),
+                    (chat_id, owner_id, now, now),
                 )
                 cur.execute(
                     "INSERT INTO messages(chat_id, role, content, created_at) VALUES (%s, %s, %s, %s)",
@@ -292,6 +328,7 @@ class PostgresDB:
         error: Optional[str] = None,
         content_hash: Optional[str] = None,
         file_path: Optional[str] = None,
+        owner_id: Optional[str] = None,
     ) -> None:
         now = time.time()
         with self._conn() as conn:
@@ -301,9 +338,9 @@ class PostgresDB:
                     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
+                        error, content_hash, file_path, owner_id, created_at, updated_at
                     )
-                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                    VALUES (%s, %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,
@@ -316,6 +353,7 @@ class PostgresDB:
                         error = EXCLUDED.error,
                         content_hash = COALESCE(EXCLUDED.content_hash, doc_meta.content_hash),
                         file_path = COALESCE(EXCLUDED.file_path, doc_meta.file_path),
+                        owner_id = COALESCE(EXCLUDED.owner_id, doc_meta.owner_id),
                         updated_at = EXCLUDED.updated_at
                     """,
                     (
@@ -331,38 +369,55 @@ class PostgresDB:
                         error,
                         content_hash,
                         file_path,
+                        owner_id,
                         now,
                         now,
                     ),
                 )
 
-    def get_doc_meta(self, doc_id: str) -> Optional[Dict[str, Any]]:
+    def get_doc_meta(self, doc_id: str, owner_id: Optional[str] = None) -> 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,))
+                if owner_id:
+                    cur.execute("SELECT * FROM doc_meta WHERE doc_id = %s AND owner_id = %s", (doc_id, owner_id))
+                else:
+                    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]]:
+    def list_docs(self, owner_id: Optional[str] = None) -> 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")
+                if owner_id:
+                    cur.execute("SELECT * FROM doc_meta WHERE owner_id = %s ORDER BY created_at DESC", (owner_id,))
+                else:
+                    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]]:
+    def find_doc_by_hash(self, content_hash: str, owner_id: Optional[str] = None) -> 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,),
-                )
+                if owner_id:
+                    cur.execute(
+                        "SELECT * FROM doc_meta WHERE content_hash = %s AND owner_id = %s ORDER BY updated_at DESC LIMIT 1",
+                        (content_hash, owner_id),
+                    )
+                else:
+                    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:
+    def delete_doc(self, doc_id: str, owner_id: Optional[str] = None) -> bool:
         with self._conn() as conn:
             with conn.cursor() as cur:
+                if owner_id:
+                    cur.execute("SELECT doc_id FROM doc_meta WHERE doc_id = %s AND owner_id = %s", (doc_id, owner_id))
+                    if not cur.fetchone():
+                        return False
                 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,))
@@ -474,9 +529,13 @@ class PostgresDB:
                         (now, chat_id),
                     )
 
-    def get_chat_documents(self, chat_id: str) -> List[Dict[str, Any]]:
+    def get_chat_documents(self, chat_id: str, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
         with self._conn() as conn:
             with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                if owner_id:
+                    cur.execute("SELECT chat_id FROM chats WHERE chat_id = %s AND owner_id = %s", (chat_id, owner_id))
+                    if not cur.fetchone():
+                        return []
                 cur.execute(
                     """
                     SELECT cd.chat_id, cd.doc_id, cd.doc_name, cd.attached_at,
@@ -563,10 +622,20 @@ class PostgresDB:
                     ),
                 )
 
-    def get_knowledge_dossier(self, doc_id: str) -> Optional[Dict[str, Any]]:
+    def get_knowledge_dossier(self, doc_id: str, owner_id: Optional[str] = None) -> 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,))
+                if owner_id:
+                    cur.execute(
+                        """
+                        SELECT km.* FROM knowledge_memory km
+                        JOIN doc_meta dm ON km.doc_id = dm.doc_id
+                        WHERE km.doc_id = %s AND dm.owner_id = %s
+                        """,
+                        (doc_id, owner_id),
+                    )
+                else:
+                    cur.execute("SELECT * FROM knowledge_memory WHERE doc_id = %s", (doc_id,))
                 row = cur.fetchone()
                 if not row:
                     return None
@@ -576,10 +645,21 @@ class PostgresDB:
                         res[k] = []
                 return res
 
-    def list_knowledge_dossiers(self) -> List[Dict[str, Any]]:
+    def list_knowledge_dossiers(self, owner_id: Optional[str] = None) -> 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")
+                if owner_id:
+                    cur.execute(
+                        """
+                        SELECT km.* FROM knowledge_memory km
+                        JOIN doc_meta dm ON km.doc_id = dm.doc_id
+                        WHERE dm.owner_id = %s
+                        ORDER BY km.updated_at DESC
+                        """,
+                        (owner_id,),
+                    )
+                else:
+                    cur.execute("SELECT * FROM knowledge_memory ORDER BY updated_at DESC")
                 rows = cur.fetchall()
                 result = []
                 for r in rows:
@@ -600,36 +680,63 @@ class PostgresDB:
         collective_summary: str,
         total_documents: int,
         key_insights: Optional[List[str]] = None,
+        owner_id: Optional[str] = None,
     ) -> None:
         now = time.time()
-        gid = "global"
+        gid = owner_id or "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
+                if owner_id:
+                    cur.execute(
+                        """
+                        INSERT INTO global_knowledge_summary(
+                            id, owner_id, collective_summary, total_documents, key_insights, updated_at
+                        )
+                        VALUES (%s, %s, %s, %s, %s, %s)
+                        ON CONFLICT (owner_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,
+                            owner_id,
+                            collective_summary,
+                            total_documents,
+                            psycopg2.extras.Json(key_insights or []),
+                            now,
+                        ),
+                    )
+                else:
+                    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,
+                        ),
                     )
-                    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]]:
+    def get_global_knowledge_summary(self, owner_id: Optional[str] = None) -> 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'")
+                if owner_id:
+                    cur.execute("SELECT * FROM global_knowledge_summary WHERE owner_id = %s", (owner_id,))
+                else:
+                    cur.execute("SELECT * FROM global_knowledge_summary WHERE id = 'global'")
                 row = cur.fetchone()
                 if not row:
                     return None

app/core/storage.py

@@ -48,18 +48,27 @@ class MemoryStorage:
     # ──────────────────────────────────────────────────────────────────────
     # Document hash / cache helpers
     # ──────────────────────────────────────────────────────────────────────
-    def get_doc_by_hash(self, content_hash: str) -> Optional[Dict[str, Any]]:
+    def get_doc_by_hash(self, content_hash: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
         # 1. In-memory hot cache
         doc_id = self._hash_to_doc_id.get(content_hash)
         if doc_id and doc_id in self._documents:
             doc = self._documents[doc_id]
-            if doc.get("status") == "ready" and doc.get("tree"):
-                return doc
-            if doc.get("status") == "indexing":
-                return doc
-
-        # 2. SQLite metadata
-        db_meta = persistent_db.find_doc_by_hash(content_hash)
+            if owner_id is not None:
+                doc_owner = doc.get("owner_id")
+                if doc_owner is None:
+                    db_meta = persistent_db.get_doc_meta(doc_id)
+                    doc_owner = db_meta.get("owner_id") if db_meta else None
+                    doc["owner_id"] = doc_owner
+                if doc_owner != owner_id:
+                    doc = None
+            if doc:
+                if doc.get("status") == "ready" and doc.get("tree"):
+                    return doc
+                if doc.get("status") == "indexing":
+                    return doc
+
+        # 2. Persistent metadata
+        db_meta = persistent_db.find_doc_by_hash(content_hash, owner_id=owner_id)
         if db_meta:
             doc_id = db_meta["doc_id"]
             if db_meta.get("status") == "indexing":
@@ -74,6 +83,7 @@ class MemoryStorage:
                     "section_count": 0,
                     "content_hash": content_hash,
                     "file_path": db_meta.get("file_path"),
+                    "owner_id": db_meta.get("owner_id"),
                     "error": None,
                 }
                 self._documents[doc_id] = doc_obj
@@ -119,6 +129,7 @@ class MemoryStorage:
                     "duration": db_meta.get("duration"),
                     "error": None,
                     "content_hash": content_hash,
+                    "owner_id": db_meta.get("owner_id"),
                     "created_at": cached.get("created_at", time.time()),
                     "updated_at": time.time(),
                 }
@@ -194,6 +205,7 @@ class MemoryStorage:
         file_path: Optional[str] = None,
         current_stage: str = "Processing PDF",
         progress: int = 10,
+        owner_id: Optional[str] = None,
     ) -> str:
         document_id = doc_id or str(uuid.uuid4())
         now = time.time()
@@ -212,6 +224,7 @@ class MemoryStorage:
             "error": None,
             "content_hash": content_hash,
             "file_path": file_path,
+            "owner_id": owner_id,
             "created_at": now,
             "updated_at": now,
         }
@@ -227,6 +240,7 @@ class MemoryStorage:
             current_stage=current_stage,
             content_hash=content_hash,
             file_path=file_path,
+            owner_id=owner_id,
         )
         return document_id
 
@@ -404,15 +418,25 @@ class MemoryStorage:
             file_path=doc.get("file_path"),
         )
 
-    def get_document(self, doc_id: str) -> Optional[Dict[str, Any]]:
+    def get_document(self, doc_id: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
         if not doc_id:
             return None
+
+        # Check Persistent DB first if owner_id is specified to enforce isolation
+        db_meta = persistent_db.get_doc_meta(doc_id, owner_id=owner_id) if owner_id is not None else persistent_db.get_doc_meta(doc_id)
+        if owner_id is not None and not db_meta:
+            return None
+
         doc = self._documents.get(doc_id)
-        if doc and doc.get("status") == "ready" and doc.get("tree"):
-            return doc
+        if doc:
+            if owner_id is not None:
+                if doc.get("owner_id") is None and db_meta:
+                    doc["owner_id"] = db_meta.get("owner_id")
+                if doc.get("owner_id") != owner_id:
+                    return None
+            if doc.get("status") == "ready" and doc.get("tree"):
+                return doc
 
-        # Check Persistent DB
-        db_meta = persistent_db.get_doc_meta(doc_id)
         if db_meta:
             doc_obj = {
                 "doc_id": doc_id,
@@ -428,6 +452,7 @@ class MemoryStorage:
                 "error": db_meta.get("error"),
                 "content_hash": db_meta.get("content_hash"),
                 "file_path": db_meta.get("file_path"),
+                "owner_id": db_meta.get("owner_id"),
                 "created_at": db_meta.get("created_at", time.time()),
                 "updated_at": db_meta.get("updated_at", time.time()),
             }
@@ -498,24 +523,25 @@ class MemoryStorage:
     # ──────────────────────────────────────────────────────────────────────
     # Legacy / convenience tree helpers
     # ──────────────────────────────────────────────────────────────────────
-    def save_tree(self, tree: Any, doc_id: Optional[str] = None, filename: str = "document.pdf") -> str:
+    def save_tree(self, tree: Any, doc_id: Optional[str] = None, filename: str = "document.pdf", owner_id: Optional[str] = None) -> str:
         document_id = doc_id or str(uuid.uuid4())
         self.set_document_ready(document_id, tree=tree, filename=filename)
+        if owner_id:
+            persistent_db.upsert_doc_meta(doc_id=document_id, filename=filename, status="ready", owner_id=owner_id)
         return document_id
 
-    def get_tree(self, doc_id: str) -> Optional[Any]:
-        doc = self._documents.get(doc_id)
+    def get_tree(self, doc_id: str, owner_id: Optional[str] = None) -> Optional[Any]:
+        doc = self.get_document(doc_id, owner_id=owner_id)
         if doc and doc.get("tree") is not None:
             return doc["tree"]
-        return self._trees.get(doc_id)
+        return self._trees.get(doc_id) if owner_id is None else None
 
-    def tree_exists(self, doc_id: str) -> bool:
-        if doc_id in self._documents and self._documents[doc_id].get("status") == "ready" and self._documents[doc_id].get("tree"):
-            return True
-        return doc_id in self._trees
+    def tree_exists(self, doc_id: str, owner_id: Optional[str] = None) -> bool:
+        doc = self.get_document(doc_id, owner_id=owner_id)
+        return doc is not None and doc.get("status") == "ready" and doc.get("tree") is not None
 
-    def list_documents(self) -> List[Dict[str, Any]]:
-        db_docs = persistent_db.list_docs()
+    def list_documents(self, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        db_docs = persistent_db.list_docs(owner_id=owner_id)
         results = []
         for d in db_docs:
             doc_id = d["doc_id"]
@@ -527,98 +553,112 @@ class MemoryStorage:
                 results.append(d)
         return results
 
-    def get_document_tree(self, doc_id: str) -> Optional[Any]:
-        doc = self.get_document(doc_id)
+    def get_document_tree(self, doc_id: str, owner_id: Optional[str] = None) -> Optional[Any]:
+        doc = self.get_document(doc_id, owner_id=owner_id)
         if doc and doc.get("tree") is not None:
             return doc["tree"]
-        return self._trees.get(doc_id)
+        return self._trees.get(doc_id) if owner_id is None else None
 
-    def delete_document(self, doc_id: str) -> bool:
+    def delete_document(self, doc_id: str, owner_id: Optional[str] = None) -> bool:
+        if owner_id is not None:
+            doc = self.get_document(doc_id, owner_id=owner_id)
+            if not doc:
+                return False
         self._documents.pop(doc_id, None)
         self._trees.pop(doc_id, None)
         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)
+        return persistent_db.delete_doc(doc_id, owner_id=owner_id)
 
 
     # ──────────────────────────────────────────────────────────────────────
-    # Chat operations  (all backed by SQLite now)
+    # Chat operations  (backed by persistent DB)
     # ──────────────────────────────────────────────────────────────────────
-    def create_chat(self, chat_id: Optional[str] = None, title: Optional[str] = None) -> str:
+    def create_chat(self, chat_id: Optional[str] = None, title: Optional[str] = None, owner_id: Optional[str] = None) -> str:
         cid = chat_id or str(uuid.uuid4())
-        persistent_db.create_chat(chat_id=cid, title=title)
+        persistent_db.create_chat(chat_id=cid, title=title, owner_id=owner_id)
         return cid
 
-    def get_chat_history(self, chat_id: str) -> List[Dict[str, str]]:
-        if not self.chat_exists(chat_id):
+    def get_chat(self, chat_id: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        return persistent_db.get_chat(chat_id, owner_id=owner_id)
+
+    def get_chat_history(self, chat_id: str, owner_id: Optional[str] = None) -> List[Dict[str, str]]:
+        if not self.chat_exists(chat_id, owner_id=owner_id):
+            if owner_id is not None:
+                return []
             persistent_db.create_chat(chat_id=chat_id)
             return []
         return persistent_db.get_messages(chat_id)
 
-    def chat_exists(self, chat_id: str) -> bool:
-        return persistent_db.get_chat(chat_id) is not None
+    def chat_exists(self, chat_id: str, owner_id: Optional[str] = None) -> bool:
+        return persistent_db.get_chat(chat_id, owner_id=owner_id) is not None
 
-    def ensure_chat(self, chat_id: str) -> List[Dict[str, str]]:
-        if not self.chat_exists(chat_id):
-            persistent_db.create_chat(chat_id=chat_id)
+    def ensure_chat(self, chat_id: str, owner_id: Optional[str] = None) -> List[Dict[str, str]]:
+        if not self.chat_exists(chat_id, owner_id=owner_id):
+            persistent_db.create_chat(chat_id=chat_id, owner_id=owner_id)
         return persistent_db.get_messages(chat_id)
 
-    def add_message(self, chat_id: str, role: str, content: str) -> None:
-        persistent_db.add_message(chat_id=chat_id, role=role, content=content)
+    def add_message(self, chat_id: str, role: str, content: str, owner_id: Optional[str] = None) -> None:
+        persistent_db.add_message(chat_id=chat_id, role=role, content=content, owner_id=owner_id)
 
-    def update_chat_history(self, chat_id: str, history: List[Dict[str, str]]) -> None:
+    def update_chat_history(self, chat_id: str, history: List[Dict[str, str]], owner_id: Optional[str] = None) -> None:
+        if owner_id and not self.chat_exists(chat_id, owner_id=owner_id):
+            return
         persistent_db.clear_messages(chat_id)
         for msg in history:
-            persistent_db.add_message(chat_id=chat_id, role=msg["role"], content=msg["content"])
+            persistent_db.add_message(chat_id=chat_id, role=msg["role"], content=msg["content"], owner_id=owner_id)
 
-    def set_chat_doc(self, chat_id: str, doc_id: str, doc_name: Optional[str] = None) -> None:
-        # ensure the chat row exists first
-        if not self.chat_exists(chat_id):
-            persistent_db.create_chat(chat_id=chat_id)
-        # look up doc name if not supplied
+    def set_chat_doc(self, chat_id: str, doc_id: str, doc_name: Optional[str] = None, owner_id: Optional[str] = None) -> None:
+        if not self.chat_exists(chat_id, owner_id=owner_id):
+            persistent_db.create_chat(chat_id=chat_id, owner_id=owner_id)
         if doc_name is None:
-            doc = self._documents.get(doc_id)
+            doc = self.get_document(doc_id, owner_id=owner_id)
             doc_name = doc.get("filename") if doc else None
         persistent_db.set_chat_doc(chat_id=chat_id, doc_id=doc_id, doc_name=doc_name)
         persistent_db.add_chat_document(chat_id=chat_id, doc_id=doc_id, doc_name=doc_name)
 
-    def add_chat_doc(self, chat_id: str, doc_id: str, doc_name: Optional[str] = None) -> None:
-        if not self.chat_exists(chat_id):
-            persistent_db.create_chat(chat_id=chat_id)
+    def add_chat_doc(self, chat_id: str, doc_id: str, doc_name: Optional[str] = None, owner_id: Optional[str] = None) -> None:
+        if not self.chat_exists(chat_id, owner_id=owner_id):
+            persistent_db.create_chat(chat_id=chat_id, owner_id=owner_id)
         if doc_name is None:
-            doc = self._documents.get(doc_id)
+            doc = self.get_document(doc_id, owner_id=owner_id)
             doc_name = doc.get("filename") if doc else None
         persistent_db.add_chat_document(chat_id=chat_id, doc_id=doc_id, doc_name=doc_name)
 
-    def get_chat_doc(self, chat_id: str) -> Optional[str]:
-        # Return primary attached doc or first multi-doc
-        meta = persistent_db.get_chat(chat_id)
+    def get_chat_doc(self, chat_id: str, owner_id: Optional[str] = None) -> Optional[str]:
+        meta = persistent_db.get_chat(chat_id, owner_id=owner_id)
         if meta and meta.get("doc_id"):
             return meta["doc_id"]
-        docs = persistent_db.get_chat_documents(chat_id)
+        docs = persistent_db.get_chat_documents(chat_id, owner_id=owner_id)
         return docs[0]["doc_id"] if docs else None
 
-    def get_chat_docs(self, chat_id: str) -> List[Dict[str, Any]]:
-        return persistent_db.get_chat_documents(chat_id)
+    def get_chat_docs(self, chat_id: str, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        return persistent_db.get_chat_documents(chat_id, owner_id=owner_id)
 
-    def remove_chat_doc(self, chat_id: str, doc_id: Optional[str] = None) -> None:
+    def remove_chat_doc(self, chat_id: str, doc_id: Optional[str] = None, owner_id: Optional[str] = None) -> None:
+        if owner_id and not self.chat_exists(chat_id, owner_id=owner_id):
+            return
         if doc_id:
             persistent_db.remove_chat_document(chat_id, doc_id)
         else:
             persistent_db.remove_chat_doc(chat_id)
 
-    def clear_chat_docs(self, chat_id: str) -> None:
+    def clear_chat_docs(self, chat_id: str, owner_id: Optional[str] = None) -> None:
+        if owner_id and not self.chat_exists(chat_id, owner_id=owner_id):
+            return
         persistent_db.clear_chat_documents(chat_id)
 
-    def delete_chat(self, chat_id: str) -> None:
-        persistent_db.delete_chat(chat_id)
+    def delete_chat(self, chat_id: str, owner_id: Optional[str] = None) -> bool:
+        return persistent_db.delete_chat(chat_id, owner_id=owner_id)
 
-    def list_chats(self) -> List[Dict[str, Any]]:
-        return persistent_db.list_chats()
+    def list_chats(self, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        return persistent_db.list_chats(owner_id=owner_id)
 
-    def update_chat_title(self, chat_id: str, title: str) -> None:
+    def update_chat_title(self, chat_id: str, title: str, owner_id: Optional[str] = None) -> None:
+        if owner_id and not self.chat_exists(chat_id, owner_id=owner_id):
+            return
         persistent_db.update_chat_title(chat_id=chat_id, title=title)
 
     # ── session long memory & rolling summaries ─────────────────────────────
@@ -628,7 +668,6 @@ class MemoryStorage:
     def get_chat_summary(self, chat_id: str) -> Optional[Dict[str, Any]]:
         return persistent_db.get_chat_summary(chat_id=chat_id)
 
-    # ── global knowledge memory & document dossiers ────────────────────────
     def save_knowledge_dossier(
         self,
         doc_id: str,
@@ -637,6 +676,7 @@ class MemoryStorage:
         key_entities: Optional[List[str]] = None,
         key_findings: Optional[List[str]] = None,
         topics: Optional[List[str]] = None,
+        owner_id: Optional[str] = None,
     ) -> None:
         persistent_db.save_knowledge_dossier(
             doc_id=doc_id,
@@ -647,11 +687,11 @@ class MemoryStorage:
             topics=topics,
         )
 
-    def get_knowledge_dossier(self, doc_id: str) -> Optional[Dict[str, Any]]:
-        return persistent_db.get_knowledge_dossier(doc_id)
+    def get_knowledge_dossier(self, doc_id: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        return persistent_db.get_knowledge_dossier(doc_id, owner_id=owner_id)
 
-    def list_knowledge_dossiers(self) -> List[Dict[str, Any]]:
-        return persistent_db.list_knowledge_dossiers()
+    def list_knowledge_dossiers(self, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        return persistent_db.list_knowledge_dossiers(owner_id=owner_id)
 
     def delete_knowledge_dossier(self, doc_id: str) -> None:
         persistent_db.delete_knowledge_dossier(doc_id)
@@ -661,15 +701,17 @@ class MemoryStorage:
         collective_summary: str,
         total_documents: int,
         key_insights: Optional[List[str]] = None,
+        owner_id: Optional[str] = None,
     ) -> None:
         persistent_db.save_global_knowledge_summary(
             collective_summary=collective_summary,
             total_documents=total_documents,
             key_insights=key_insights,
+            owner_id=owner_id,
         )
 
-    def get_global_knowledge_summary(self) -> Optional[Dict[str, Any]]:
-        return persistent_db.get_global_knowledge_summary()
+    def get_global_knowledge_summary(self, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        return persistent_db.get_global_knowledge_summary(owner_id=owner_id)
 
 
 # Global singleton storage instance

app/mcp_server/web_search_mcp.py

@@ -10,6 +10,7 @@ and natively importable across Atlas services and external MCP clients (Claude D
 6. Internal Atlas Document Intelligence Tools (`atlas_list_documents`, `atlas_query_document`, `atlas_get_knowledge_dossier`).
 """
 
+import os
 import asyncio
 import json
 import re
@@ -261,92 +262,94 @@ def mcp_evaluate_math_expression(expression: str) -> str:
     return f"Math Evaluation Error: {res.get('error')}"
 
 
-@mcp.tool(
-    name="atlas_list_documents",
-    description="List all ingested documents in Atlas knowledge base with document IDs, filenames, page counts, and statuses.",
-)
-def mcp_atlas_list_documents() -> str:
-    """List all indexed documents stored in Atlas."""
-    docs = atlas_list_documents_impl()
-    if not docs:
-        return "No documents currently indexed in the Atlas knowledge base."
-
-    lines = ["### Atlas Ingested Documents\n"]
-    for idx, d in enumerate(docs, 1):
-        lines.append(
-            f"{idx}. **{d['filename']}** (ID: `{d['doc_id']}`)\n"
-            f"   - Status: `{d['status']}` | Pages: {d['page_count']} | Sections: {d['section_count']} | Method: {d['indexing_method']}"
-        )
-    return "\n".join(lines)
-
-
-@mcp.tool(
-    name="atlas_query_document",
-    description="Query a specific document tree in Atlas and retrieve grounded passages with exact (Section, Page) citations.",
-)
-def mcp_atlas_query_document(doc_id: str, query: str) -> str:
-    """Run vectorless hierarchical retrieval on a specific indexed document."""
-    res = atlas_query_document_impl(doc_id=doc_id, query=query)
-    if res.get("status") != "success":
-        return f"Error querying document {doc_id}: {res.get('error')}"
-
-    passages = res.get("passages", [])
-    if not passages:
-        return f"No matching sections found for query '{query}' in document {res.get('filename')}."
-
-    lines = [f"### Grounded Retrieval Passages for '{query}' in {res.get('filename')}\n"]
-    for idx, p in enumerate(passages, 1):
-        lines.append(f"{idx}. **[{p['section_title']} - Page {p['page']}]** (Citation: `{p['citation']}`)")
-        lines.append(f"{p['text']}\n")
-    return "\n".join(lines).strip()
-
-
-@mcp.tool(
-    name="atlas_get_knowledge_dossier",
-    description="Retrieve the executive knowledge dossier (summary, key entities, findings, topics) and workspace global summary for a document.",
-)
-def mcp_atlas_get_knowledge_dossier(doc_id: str) -> str:
-    """Retrieve structured document dossier and workspace knowledge synthesis."""
-    res = atlas_get_knowledge_dossier_impl(doc_id=doc_id)
-    if res.get("status") != "success":
-        return f"Knowledge Dossier for {doc_id}: {res.get('message', res.get('error', 'Not found'))}"
-
-    lines = [
-        f"### Knowledge Dossier: {res.get('filename')} (ID: `{doc_id}`)\n",
-        f"**Executive Summary**:\n{res.get('executive_summary')}\n",
-        f"**Key Entities**: {', '.join(res.get('key_entities', []))}\n",
-        "**Key Findings**:",
-    ]
-    for kf in res.get("key_findings", []):
-        lines.append(f"- {kf}")
-    lines.append(f"\n**Topics**: {', '.join(res.get('topics', []))}\n")
-
-    if res.get("global_workspace_summary"):
-        lines.append(f"**Workspace Global Summary**:\n{res.get('global_workspace_summary')}")
-
-    return "\n".join(lines).strip()
-
-
 # ==============================================================================
-# FASTMCP RESOURCES
+# INTERNAL ATLAS DOCUMENT INTELLIGENCE TOOLS (Gated by ATLAS_MCP_INTERNAL_TOOLS)
 # ==============================================================================
-
-@mcp.resource("atlas://documents")
-def resource_atlas_documents() -> str:
-    """Resource returning JSON list of all documents in the knowledge base."""
-    docs = atlas_list_documents_impl()
-    return json.dumps(docs, indent=2)
-
-
-@mcp.resource("atlas://knowledge-summary")
-def resource_atlas_knowledge_summary() -> str:
-    """Resource returning the collective master knowledge summary of the workspace."""
-    try:
-        from core.storage import storage
-        summary = storage.get_global_knowledge_summary() or {}
-        return json.dumps(summary, indent=2)
-    except Exception as e:
-        return json.dumps({"error": str(e)})
+ENABLE_INTERNAL_TOOLS = os.getenv("ATLAS_MCP_INTERNAL_TOOLS", "false").lower() in ("true", "1", "yes")
+
+if ENABLE_INTERNAL_TOOLS:
+    @mcp.tool(
+        name="atlas_list_documents",
+        description="List all ingested documents in Atlas knowledge base with document IDs, filenames, page counts, and statuses.",
+    )
+    def mcp_atlas_list_documents() -> str:
+        """List all indexed documents stored in Atlas."""
+        docs = atlas_list_documents_impl()
+        if not docs:
+            return "No documents currently indexed in the Atlas knowledge base."
+
+        lines = ["### Atlas Ingested Documents\n"]
+        for idx, d in enumerate(docs, 1):
+            lines.append(
+                f"{idx}. **{d['filename']}** (ID: `{d['doc_id']}`)\n"
+                f"   - Status: `{d['status']}` | Pages: {d['page_count']} | Sections: {d['section_count']} | Method: {d['indexing_method']}"
+            )
+        return "\n".join(lines)
+
+
+    @mcp.tool(
+        name="atlas_query_document",
+        description="Query a specific document tree in Atlas and retrieve grounded passages with exact (Section, Page) citations.",
+    )
+    def mcp_atlas_query_document(doc_id: str, query: str) -> str:
+        """Run vectorless hierarchical retrieval on a specific indexed document."""
+        res = atlas_query_document_impl(doc_id=doc_id, query=query)
+        if res.get("status") != "success":
+            return f"Error querying document {doc_id}: {res.get('error')}"
+
+        passages = res.get("passages", [])
+        if not passages:
+            return f"No matching sections found for query '{query}' in document {res.get('filename')}."
+
+        lines = [f"### Grounded Retrieval Passages for '{query}' in {res.get('filename')}\n"]
+        for idx, p in enumerate(passages, 1):
+            lines.append(f"{idx}. **[{p['section_title']} - Page {p['page']}]** (Citation: `{p['citation']}`)")
+            lines.append(f"{p['text']}\n")
+        return "\n".join(lines).strip()
+
+
+    @mcp.tool(
+        name="atlas_get_knowledge_dossier",
+        description="Retrieve the executive knowledge dossier (summary, key entities, findings, topics) and workspace global summary for a document.",
+    )
+    def mcp_atlas_get_knowledge_dossier(doc_id: str) -> str:
+        """Retrieve structured document dossier and workspace knowledge synthesis."""
+        res = atlas_get_knowledge_dossier_impl(doc_id=doc_id)
+        if res.get("status") != "success":
+            return f"Knowledge Dossier for {doc_id}: {res.get('message', res.get('error', 'Not found'))}"
+
+        lines = [
+            f"### Knowledge Dossier: {res.get('filename')} (ID: `{doc_id}`)\n",
+            f"**Executive Summary**:\n{res.get('executive_summary')}\n",
+            f"**Key Entities**: {', '.join(res.get('key_entities', []))}\n",
+            "**Key Findings**:",
+        ]
+        for kf in res.get("key_findings", []):
+            lines.append(f"- {kf}")
+        lines.append(f"\n**Topics**: {', '.join(res.get('topics', []))}\n")
+
+        if res.get("global_workspace_summary"):
+            lines.append(f"**Workspace Global Summary**:\n{res.get('global_workspace_summary')}")
+
+        return "\n".join(lines).strip()
+
+
+    @mcp.resource("atlas://documents")
+    def resource_atlas_documents() -> str:
+        """Resource returning JSON list of all documents in the knowledge base."""
+        docs = atlas_list_documents_impl()
+        return json.dumps(docs, indent=2)
+
+
+    @mcp.resource("atlas://knowledge-summary")
+    def resource_atlas_knowledge_summary() -> str:
+        """Resource returning the collective master knowledge summary of the workspace."""
+        try:
+            from core.storage import storage
+            summary = storage.get_global_knowledge_summary() or {}
+            return json.dumps(summary, indent=2)
+        except Exception as e:
+            return json.dumps({"error": str(e)})
 
 
 if __name__ == "__main__":

app/routers/chat.py

@@ -18,6 +18,7 @@ from core.dependencies import (
     get_rag_pipeline,
     get_storage,
     get_memory_service,
+    get_client_id,
 )
 from core.rag_pipeline import VectorlessRAG
 from services.llm_service import LLMService
@@ -28,9 +29,12 @@ router = APIRouter(tags=["Chat"])
 
 
 @router.post("/chat/new", response_model=NewChatResponse)
-async def create_chat(storage: MemoryStorage = Depends(get_storage)):
-    chat_id = storage.create_chat()
-    app_logger.info(f"Created new chat session: {chat_id}")
+async def create_chat(
+    storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
+):
+    chat_id = storage.create_chat(owner_id=client_id)
+    app_logger.info(f"Created new chat session: {chat_id} for client: {client_id}")
     return NewChatResponse(chat_id=chat_id)
 
 
@@ -39,11 +43,14 @@ async def attach_document_to_chat(
     chat_id: str,
     body: AttachDocRequest,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Attach an indexed document to an active conversation session."""
-    if not storage.tree_exists(body.doc_id):
+    if not storage.chat_exists(chat_id, owner_id=client_id):
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    if not storage.tree_exists(body.doc_id, owner_id=client_id):
         raise HTTPException(status_code=404, detail="Document ID not found in memory")
-    storage.add_chat_doc(chat_id, body.doc_id, doc_name=body.doc_name)
+    storage.add_chat_doc(chat_id, body.doc_id, doc_name=body.doc_name, owner_id=client_id)
     app_logger.info(f"Attached document {body.doc_id} to chat session {chat_id}")
     return {"message": "Document attached successfully", "chat_id": chat_id, "doc_id": body.doc_id}
 
@@ -53,12 +60,15 @@ async def attach_multiple_documents_to_chat(
     chat_id: str,
     body: AttachMultipleDocsRequest,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Attach multiple indexed documents to an active conversation session."""
+    if not storage.chat_exists(chat_id, owner_id=client_id):
+        raise HTTPException(status_code=404, detail="Chat session not found")
     attached = []
     for doc_id in body.doc_ids:
-        if storage.tree_exists(doc_id):
-            storage.add_chat_doc(chat_id, doc_id)
+        if storage.tree_exists(doc_id, owner_id=client_id):
+            storage.add_chat_doc(chat_id, doc_id, owner_id=client_id)
             attached.append(doc_id)
     app_logger.info(f"Attached {len(attached)} documents to chat session {chat_id}")
     return {"message": f"Attached {len(attached)} documents successfully", "chat_id": chat_id, "doc_ids": attached}
@@ -68,12 +78,15 @@ async def attach_multiple_documents_to_chat(
 async def get_chat_documents(
     chat_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Return all attached documents for this session with status and page counts."""
-    docs = storage.get_chat_docs(chat_id)
+    if not storage.chat_exists(chat_id, owner_id=client_id):
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    docs = storage.get_chat_docs(chat_id, owner_id=client_id)
     detailed_docs = []
     for d in docs:
-        doc_info = storage.get_document(d["doc_id"])
+        doc_info = storage.get_document(d["doc_id"], owner_id=client_id)
         if doc_info:
             detailed_docs.append({
                 "doc_id": d["doc_id"],
@@ -92,9 +105,12 @@ async def detach_specific_document_from_chat(
     chat_id: str,
     doc_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Detach a specific document from the active chat session."""
-    storage.remove_chat_doc(chat_id, doc_id=doc_id)
+    if not storage.chat_exists(chat_id, owner_id=client_id):
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    storage.remove_chat_doc(chat_id, doc_id=doc_id, owner_id=client_id)
     app_logger.info(f"Detached document {doc_id} from chat session {chat_id}")
     return {"message": "Document detached successfully", "chat_id": chat_id, "doc_id": doc_id}
 
@@ -103,10 +119,13 @@ async def detach_specific_document_from_chat(
 async def detach_document_from_chat(
     chat_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Detach all documents from active chat session."""
-    storage.clear_chat_docs(chat_id)
-    storage.remove_chat_doc(chat_id)
+    if not storage.chat_exists(chat_id, owner_id=client_id):
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    storage.clear_chat_docs(chat_id, owner_id=client_id)
+    storage.remove_chat_doc(chat_id, owner_id=client_id)
     app_logger.info(f"Cleared all documents from chat session {chat_id}")
     return {"message": "All documents detached successfully", "chat_id": chat_id}
 
@@ -118,9 +137,14 @@ async def ask_question(
     llm_service: LLMService = Depends(get_llm_service),
     rag_pipeline: VectorlessRAG = Depends(get_rag_pipeline),
     memory_service: MemoryService = Depends(get_memory_service),
+    client_id: str = Depends(get_client_id),
 ):
-    # Ensure chat session exists in persistent storage
-    storage.ensure_chat(request.chat_id)
+    # Ensure chat session exists in persistent storage and is owned by client_id
+    if storage.chat_exists(request.chat_id):
+        if not storage.chat_exists(request.chat_id, owner_id=client_id):
+            raise HTTPException(status_code=404, detail="Chat session not found")
+    else:
+        storage.create_chat(request.chat_id, owner_id=client_id)
 
     # 1. Resolve target document IDs for this query session
     target_doc_ids: List[str] = []
@@ -130,16 +154,18 @@ async def ask_question(
         target_doc_ids.append(request.doc_id)
 
     if target_doc_ids:
-        # Associate newly requested docs with this session
+        # Validate ownership of each explicitly requested document
         for did in target_doc_ids:
-            storage.add_chat_doc(request.chat_id, did)
+            if not storage.get_document(did, owner_id=client_id):
+                raise HTTPException(status_code=404, detail=f"Document {did} not found")
+            storage.add_chat_doc(request.chat_id, did, owner_id=client_id)
     else:
         # Check existing docs attached to this session
-        session_docs = storage.get_chat_docs(request.chat_id)
+        session_docs = storage.get_chat_docs(request.chat_id, owner_id=client_id)
         if session_docs:
             target_doc_ids = [d["doc_id"] for d in session_docs]
         else:
-            primary_id = storage.get_chat_doc(request.chat_id)
+            primary_id = storage.get_chat_doc(request.chat_id, owner_id=client_id)
             if primary_id:
                 target_doc_ids = [primary_id]
 
@@ -152,7 +178,7 @@ async def ask_question(
     error_docs = []
 
     for did in target_doc_ids:
-        doc_state = storage.get_document(did)
+        doc_state = storage.get_document(did, owner_id=client_id)
         if not doc_state:
             error_docs.append({"doc_id": did, "filename": did, "error": "Document not found or expired"})
         elif doc_state.get("status") == "ready" and doc_state.get("tree"):
@@ -193,12 +219,12 @@ async def ask_question(
     )
 
     # 4. Retrieve session memory (isolated short-term window + long-term rolling summary)
-    mem_context = memory_service.get_session_context(request.chat_id)
+    mem_context = memory_service.get_session_context(request.chat_id, owner_id=client_id)
     recent_turns = mem_context.get("recent_turns", [])
     session_summary = mem_context.get("session_summary")
 
-    # 5. Retrieve global workspace knowledge summary
-    global_knowledge = memory_service.get_global_knowledge()
+    # 5. Retrieve global workspace knowledge summary scoped to owner
+    global_knowledge = memory_service.get_global_knowledge(owner_id=client_id)
 
     is_arabic = any("\u0600" <= c <= "\u06ff" for c in request.query)
 
@@ -288,9 +314,9 @@ async def ask_question(
         finally:
             if full_answer:
                 clean_answer = re.sub(r'<!--STAGE:.*?-->\n?', '', full_answer).strip()
-                storage.add_message(request.chat_id, role="user", content=request.query)
+                storage.add_message(request.chat_id, role="user", content=request.query, owner_id=client_id)
                 storage.add_message(
-                    request.chat_id, role="assistant", content=clean_answer or full_answer
+                    request.chat_id, role="assistant", content=clean_answer or full_answer, owner_id=client_id
                 )
                 # Asynchronously update long-term rolling summary if conversation threshold reached
                 try:
@@ -307,17 +333,23 @@ async def ask_question(
 async def get_chat_history(
     chat_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
-    history = storage.get_chat_history(chat_id)
+    if not storage.chat_exists(chat_id, owner_id=client_id):
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    history = storage.get_chat_history(chat_id, owner_id=client_id)
     return ChatHistoryResponse(history=history or [])
 
 
 # ── Long Memory & Conversation Management Endpoints ────────────────────────
 
 @router.get("/chats")
-async def list_all_chats(storage: MemoryStorage = Depends(get_storage)):
+async def list_all_chats(
+    storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
+):
     """Return all persisted chat sessions ordered by most recent."""
-    chats = storage.list_chats()
+    chats = storage.list_chats(owner_id=client_id)
     return {"chats": chats}
 
 
@@ -325,9 +357,12 @@ async def list_all_chats(storage: MemoryStorage = Depends(get_storage)):
 async def delete_chat(
     chat_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Permanently delete a chat session and all its messages."""
-    storage.delete_chat(chat_id)
+    deleted = storage.delete_chat(chat_id, owner_id=client_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Chat session not found")
     app_logger.info(f"Deleted chat session: {chat_id}")
     return {"message": "Chat deleted", "chat_id": chat_id}
 
@@ -341,7 +376,10 @@ async def rename_chat(
     chat_id: str,
     body: RenameChatRequest,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Update the display title of a chat session."""
-    storage.update_chat_title(chat_id, body.title)
+    if not storage.chat_exists(chat_id, owner_id=client_id):
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    storage.update_chat_title(chat_id, body.title, owner_id=client_id)
     return {"message": "Title updated", "chat_id": chat_id, "title": body.title}

app/routers/documents.py

@@ -8,7 +8,7 @@ from fastapi import APIRouter, UploadFile, File, Form, HTTPException, Depends, R
 from services.document_service import DocumentService
 from services.llm_service import LLMService
 from core.storage import MemoryStorage
-from core.dependencies import get_document_service, get_llm_service, get_storage
+from core.dependencies import get_document_service, get_llm_service, get_storage, get_client_id
 from schemas.schemas import UploadResponse, DocumentStatusResponse
 from utils.logger import app_logger
 from core.persistent_db import DATA_DIR
@@ -27,6 +27,7 @@ async def run_background_indexing(
     doc_service: DocumentService,
     llm_service: LLMService,
     storage: MemoryStorage,
+    owner_id: Optional[str] = None,
 ):
     """Background task for long-running PDF parsing, PageIndex polling, and fallback extraction."""
     t_start = time.monotonic()
@@ -96,6 +97,7 @@ async def run_background_indexing(
                     filename=filename,
                     tree=tree,
                     flat_sections=flat_sections,
+                    owner_id=owner_id,
                 )
             )
         except Exception as mex:
@@ -126,6 +128,7 @@ async def upload_pdf(
     doc_service: DocumentService = Depends(get_document_service),
     llm_service: LLMService = Depends(get_llm_service),
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """
     Asynchronous PDF upload and indexing endpoint.
@@ -147,14 +150,14 @@ async def upload_pdf(
 
     content_hash = hashlib.sha256(contents).hexdigest()
 
-    # Deduplication check: Check if same document is already ready or currently indexing
-    existing_doc = storage.get_doc_by_hash(content_hash)
+    # Deduplication check: Check if same document is already ready or currently indexing for this owner
+    existing_doc = storage.get_doc_by_hash(content_hash, owner_id=client_id)
     if existing_doc:
         doc_id = existing_doc["doc_id"]
         doc_status = existing_doc.get("status")
 
         if chat_id:
-            storage.set_chat_doc(chat_id, doc_id)
+            storage.set_chat_doc(chat_id, doc_id, owner_id=client_id)
 
         if doc_status == "ready":
             app_logger.info(
@@ -194,10 +197,10 @@ async def upload_pdf(
 
     app_logger.info(
         f"[INDEX] document_id={doc_id} stage=upload filename='{file.filename}' "
-        f"size={len(contents)} hash={content_hash[:12]}"
+        f"size={len(contents)} hash={content_hash[:12]} owner={client_id}"
     )
 
-    # Register document in storage
+    # Register document in storage with owner_id
     storage.create_document(
         doc_id=doc_id,
         filename=file.filename,
@@ -206,10 +209,11 @@ async def upload_pdf(
         file_path=file_path,
         current_stage="Processing PDF",
         progress=10,
+        owner_id=client_id,
     )
 
     if chat_id:
-        storage.set_chat_doc(chat_id, doc_id)
+        storage.set_chat_doc(chat_id, doc_id, owner_id=client_id)
         app_logger.info(f"Associated document {doc_id} ('{file.filename}') with chat {chat_id}")
 
     # Launch detached asynchronous background task
@@ -222,6 +226,7 @@ async def upload_pdf(
             doc_service=doc_service,
             llm_service=llm_service,
             storage=storage,
+            owner_id=client_id,
         )
     )
     storage.register_active_task(doc_id, task)
@@ -241,9 +246,10 @@ async def upload_pdf(
 async def get_document_status(
     document_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Retrieve indexing/ready/failed status and operational metadata for a document."""
-    doc = storage.get_document(document_id)
+    doc = storage.get_document(document_id, owner_id=client_id)
     if not doc:
         raise HTTPException(status_code=404, detail="Document ID not found.")
 
@@ -279,9 +285,10 @@ async def retry_document_indexing(
     doc_service: DocumentService = Depends(get_document_service),
     llm_service: LLMService = Depends(get_llm_service),
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Explicitly retry indexing for a failed document."""
-    doc = storage.get_document(document_id)
+    doc = storage.get_document(document_id, owner_id=client_id)
     if not doc:
         raise HTTPException(status_code=404, detail="Document ID not found.")
 
@@ -319,6 +326,7 @@ async def retry_document_indexing(
             doc_service=doc_service,
             llm_service=llm_service,
             storage=storage,
+            owner_id=client_id,
         )
     )
     storage.register_active_task(document_id, task)
@@ -334,9 +342,12 @@ async def retry_document_indexing(
 
 
 @router.get("/documents")
-async def list_documents(storage: MemoryStorage = Depends(get_storage)):
-    """List all ingested documents with status and metadata."""
-    docs = storage.list_documents()
+async def list_documents(
+    storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
+):
+    """List all ingested documents with status and metadata for current client."""
+    docs = storage.list_documents(owner_id=client_id)
     return {"documents": docs}
 
 
@@ -344,9 +355,10 @@ async def list_documents(storage: MemoryStorage = Depends(get_storage)):
 async def get_document_details(
     document_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Retrieve details and operational metadata for a specific document."""
-    doc = storage.get_document(document_id)
+    doc = storage.get_document(document_id, owner_id=client_id)
     if not doc:
         raise HTTPException(status_code=404, detail="Document ID not found.")
     return {
@@ -371,13 +383,14 @@ async def get_document_tree(
     storage: MemoryStorage = Depends(get_storage),
     doc_service: DocumentService = Depends(get_document_service),
     llm_service: LLMService = Depends(get_llm_service),
+    client_id: str = Depends(get_client_id),
 ):
     """Retrieve the hierarchical section tree for a document."""
-    doc = storage.get_document(document_id)
+    doc = storage.get_document(document_id, owner_id=client_id)
     if not doc:
         raise HTTPException(status_code=404, detail="Document ID not found.")
 
-    tree = storage.get_document_tree(document_id)
+    tree = storage.get_document_tree(document_id, owner_id=client_id)
     if tree is None and doc.get("file_path") and os.path.exists(doc["file_path"]):
         # Reconstruct tree using local parser and cache
         tree = doc_service._local_pdf_parse(doc["file_path"])
@@ -390,6 +403,7 @@ async def get_document_tree(
             indexing_method=doc.get("indexing_method") or "pymupdf",
             filename=doc.get("filename"),
             file_path=doc.get("file_path"),
+            owner_id=client_id,
         )
 
     if tree is None:
@@ -405,14 +419,14 @@ async def get_document_tree(
     }
 
 
-
 @router.delete("/documents/{document_id}")
 async def delete_document(
     document_id: str,
     storage: MemoryStorage = Depends(get_storage),
+    client_id: str = Depends(get_client_id),
 ):
     """Permanently delete a document, its cached index, and local file."""
-    doc = storage.get_document(document_id)
+    doc = storage.get_document(document_id, owner_id=client_id)
     if not doc:
         raise HTTPException(status_code=404, detail="Document ID not found.")
 
@@ -423,7 +437,7 @@ async def delete_document(
         except Exception as e:
             app_logger.warning(f"Could not remove document file {file_path}: {e}")
 
-    storage.delete_document(document_id)
+    storage.delete_document(document_id, owner_id=client_id)
     app_logger.info(f"Deleted document {document_id}")
     return {"message": "Document deleted successfully", "doc_id": document_id}
 

app/routers/memory.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter, HTTPException, Depends
 from typing import Optional, List, Dict, Any
 from pydantic import BaseModel
 
-from core.dependencies import get_memory_service, get_storage
+from core.dependencies import get_memory_service, get_storage, get_client_id
 from core.storage import MemoryStorage
 from services.memory_service import MemoryService
 from utils.logger import app_logger
@@ -13,25 +13,27 @@ router = APIRouter(prefix="/memory", tags=["Memory & Knowledge"])
 
 @router.get("/knowledge")
 async def get_global_knowledge(
+    client_id: str = Depends(get_client_id),
     memory_service: MemoryService = Depends(get_memory_service),
 ):
     """
-    Retrieve workspace collective knowledge summary and all per-document knowledge dossiers.
+    Retrieve workspace collective knowledge summary and per-document knowledge dossiers for this client.
     Provides cross-document intelligence and long-term memory across sessions.
     """
-    return memory_service.get_global_knowledge()
+    return memory_service.get_global_knowledge(owner_id=client_id)
 
 
 @router.post("/knowledge/refresh")
 async def refresh_global_knowledge(
+    client_id: str = Depends(get_client_id),
     memory_service: MemoryService = Depends(get_memory_service),
 ):
     """
-    Synthesize and rebuild the global workspace knowledge memory across all indexed documents.
+    Synthesize and rebuild the global workspace knowledge memory across all indexed documents for this client.
     """
-    app_logger.info("Triggered manual refresh of global knowledge memory")
-    result = await memory_service.synthesize_global_knowledge()
-    dossiers = memory_service.list_knowledge_dossiers()
+    app_logger.info(f"Triggered manual refresh of global knowledge memory for client {client_id}")
+    result = await memory_service.synthesize_global_knowledge(owner_id=client_id)
+    dossiers = memory_service.list_knowledge_dossiers(owner_id=client_id)
     return {
         "message": "Global knowledge memory refreshed successfully",
         "collective_summary": result.get("collective_summary"),
@@ -44,12 +46,13 @@ async def refresh_global_knowledge(
 @router.get("/dossier/{doc_id}")
 async def get_document_dossier(
     doc_id: str,
+    client_id: str = Depends(get_client_id),
     memory_service: MemoryService = Depends(get_memory_service),
 ):
     """
-    Retrieve structured knowledge dossier for an individual document.
+    Retrieve structured knowledge dossier for an individual document belonging to this client.
     """
-    dossier = memory_service.get_document_dossier(doc_id)
+    dossier = memory_service.get_document_dossier(doc_id, owner_id=client_id)
     if not dossier:
         raise HTTPException(status_code=404, detail="Knowledge dossier not found for this document")
     return dossier
@@ -58,17 +61,18 @@ async def get_document_dossier(
 @router.get("/chat/{chat_id}")
 async def get_chat_memory_context(
     chat_id: str,
+    client_id: str = Depends(get_client_id),
     memory_service: MemoryService = Depends(get_memory_service),
     storage: MemoryStorage = Depends(get_storage),
 ):
     """
-    Inspect the short-term and long-term isolated memory for a specific chat session.
+    Inspect the short-term and long-term isolated memory for a specific chat session belonging to this client.
     """
-    if not storage.chat_exists(chat_id):
+    if not storage.chat_exists(chat_id, owner_id=client_id):
         raise HTTPException(status_code=404, detail="Chat session not found")
 
-    context = memory_service.get_session_context(chat_id)
-    attached_docs = storage.get_chat_docs(chat_id)
+    context = memory_service.get_session_context(chat_id, owner_id=client_id)
+    attached_docs = storage.get_chat_docs(chat_id, owner_id=client_id)
     return {
         "chat_id": chat_id,
         "session_summary": context.get("session_summary"),
@@ -81,16 +85,17 @@ async def get_chat_memory_context(
 @router.post("/chat/{chat_id}/summarize")
 async def force_summarize_chat(
     chat_id: str,
+    client_id: str = Depends(get_client_id),
     memory_service: MemoryService = Depends(get_memory_service),
     storage: MemoryStorage = Depends(get_storage),
 ):
     """
-    Force-generate or update the rolling long-term memory summary for this chat session.
+    Force-generate or update the rolling long-term memory summary for this chat session belonging to this client.
     """
-    if not storage.chat_exists(chat_id):
+    if not storage.chat_exists(chat_id, owner_id=client_id):
         raise HTTPException(status_code=404, detail="Chat session not found")
 
-    summary = await memory_service.update_session_summary_if_needed(chat_id, force=True)
+    summary = await memory_service.update_session_summary_if_needed(chat_id, owner_id=client_id, force=True)
     return {
         "message": "Chat session summary updated",
         "chat_id": chat_id,

app/routers/studio.py

@@ -4,7 +4,7 @@ from typing import List, Dict, Any, Optional
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
 
-from core.dependencies import get_storage, get_document_service, get_llm_service, get_memory_service
+from core.dependencies import get_storage, get_document_service, get_llm_service, get_memory_service, get_client_id
 from core.storage import MemoryStorage
 from services.document_service import DocumentService
 from services.llm_service import LLMService
@@ -23,6 +23,7 @@ class QuizGenerateRequest(BaseModel):
 @router.get("/{doc_id}/mindmap")
 async def get_document_mindmap(
     doc_id: str,
+    client_id: str = Depends(get_client_id),
     storage: MemoryStorage = Depends(get_storage),
     doc_service: DocumentService = Depends(get_document_service),
     llm_service: LLMService = Depends(get_llm_service),
@@ -32,7 +33,7 @@ async def get_document_mindmap(
     into a structured node-edge graph for interactive visualization.
     Each node includes: id, label, section_title, page_number, type, summary, level.
     """
-    doc = storage.get_document(doc_id)
+    doc = storage.get_document(doc_id, owner_id=client_id)
     if not doc:
         raise HTTPException(status_code=404, detail="Document ID not found.")
 
@@ -50,7 +51,7 @@ async def get_document_mindmap(
         tree = []
 
     # Retrieve dossier if available
-    dossier = storage.get_knowledge_dossier(doc_id) or {}
+    dossier = storage.get_knowledge_dossier(doc_id, owner_id=client_id) or {}
     topics = dossier.get("topics") or []
     key_findings = dossier.get("key_findings") or []
 
@@ -165,6 +166,7 @@ async def get_document_mindmap(
 async def generate_document_quiz(
     doc_id: str,
     payload: Optional[QuizGenerateRequest] = None,
+    client_id: str = Depends(get_client_id),
     storage: MemoryStorage = Depends(get_storage),
     doc_service: DocumentService = Depends(get_document_service),
     llm_service: LLMService = Depends(get_llm_service),
@@ -175,7 +177,7 @@ async def generate_document_quiz(
     Each item includes question, options, answer, explanation, and exact citation (Section, Page).
     """
     t0 = time.monotonic()
-    doc = storage.get_document(doc_id)
+    doc = storage.get_document(doc_id, owner_id=client_id)
     if not doc:
         raise HTTPException(status_code=404, detail="Document ID not found.")
 
@@ -186,7 +188,7 @@ async def generate_document_quiz(
         tree = llm_service.normalize_tree(tree)
         storage.set_document_tree(doc_id, tree)
 
-    dossier = storage.get_knowledge_dossier(doc_id)
+    dossier = storage.get_knowledge_dossier(doc_id, owner_id=client_id)
 
     app_logger.info(f"[STUDIO-QUIZ] Generating quiz and flashcards for doc_id={doc_id} ('{filename}')...")
     result = await llm_service.generate_quiz_and_flashcards(

app/routers/tools.py

@@ -9,9 +9,10 @@ Exposes direct REST endpoints for MCP tools:
 """
 
 from typing import Any, Dict, Optional
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Depends
 from pydantic import BaseModel, Field
 
+from core.dependencies import get_client_id
 from mcp_server.web_search_mcp import execute_web_search
 from mcp_server.research_tools import (
     fetch_webpage_markdown,
@@ -20,7 +21,7 @@ from mcp_server.research_tools import (
     evaluate_math_expression_safe,
 )
 
-router = APIRouter(prefix="/tools", tags=["Tools & MCP"])
+router = APIRouter(prefix="/tools", tags=["Tools & MCP"], dependencies=[Depends(get_client_id)])
 
 
 class WebSearchRequest(BaseModel):

app/services/memory_service.py

@@ -22,14 +22,14 @@ class MemoryService:
 
     # ── 1. Short-Term & Long-Term Session Memory ────────────────────────────
     def get_session_context(
-        self, chat_id: str, max_recent_turns: int = 6
+        self, chat_id: str, max_recent_turns: int = 6, owner_id: Optional[str] = None
     ) -> Dict[str, Any]:
         """
         Retrieves strictly isolated session memory:
         - Recent turns (short-term memory window)
         - Rolling session summary (long-term memory)
         """
-        full_history = storage.get_chat_history(chat_id) or []
+        full_history = storage.get_chat_history(chat_id, owner_id=owner_id) or []
         summary_record = storage.get_chat_summary(chat_id)
         session_summary = summary_record.get("summary") if summary_record else None
 
@@ -42,27 +42,34 @@ class MemoryService:
             "total_messages": len(full_history),
         }
 
-    async def update_session_summary_if_needed(self, chat_id: str) -> None:
-        """Trigger rolling summarization if conversation length exceeds threshold."""
+    async def update_session_summary_if_needed(
+        self, chat_id: str, owner_id: Optional[str] = None, force: bool = False
+    ) -> Optional[str]:
+        """Trigger rolling summarization if conversation length exceeds threshold or if force=True."""
         try:
-            full_history = storage.get_chat_history(chat_id) or []
-            if len(full_history) < 8:
-                return
+            full_history = storage.get_chat_history(chat_id, owner_id=owner_id) or []
+            if not full_history:
+                return None
+            if not force and len(full_history) < 8:
+                return None
 
             last_summary = storage.get_chat_summary(chat_id)
             last_count = last_summary.get("turn_count", 0) if last_summary else 0
 
-            # Only re-summarize if at least 4 new messages occurred
-            if (len(full_history) - last_count) < 4:
-                return
+            # Only re-summarize if force=True or at least 4 new messages occurred
+            if not force and (len(full_history) - last_count) < 4:
+                return last_summary.get("summary") if last_summary else None
 
             app_logger.info(f"[MEMORY] Updating rolling summary for chat_id={chat_id}")
             summary = await self.llm.summarize_conversation(full_history)
             if summary:
                 storage.set_chat_summary(chat_id, summary, turn_count=len(full_history))
                 app_logger.info(f"[MEMORY] Successfully updated summary for chat_id={chat_id}")
+                return summary
+            return None
         except Exception as e:
             app_logger.error(f"[MEMORY] Error updating session summary: {e}")
+            return None
 
     # ── 2. Document Knowledge Dossier ──────────────────────────────────────
     async def generate_document_dossier(
@@ -166,28 +173,28 @@ Return ONLY valid JSON matching this schema:
             }
         except Exception as e:
             app_logger.error(f"[MEMORY] Failed to generate document dossier for {doc_id}: {e}", exc_info=True)
-    def get_document_dossier(self, doc_id: str) -> Optional[Dict[str, Any]]:
+    def get_document_dossier(self, doc_id: str, owner_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
         """Retrieve structured knowledge dossier for an individual document."""
-        return storage.get_knowledge_dossier(doc_id)
+        return storage.get_knowledge_dossier(doc_id, owner_id=owner_id)
 
-    def list_knowledge_dossiers(self) -> List[Dict[str, Any]]:
+    def list_knowledge_dossiers(self, owner_id: Optional[str] = None) -> List[Dict[str, Any]]:
         """Retrieve all knowledge dossiers across indexed documents."""
-        return storage.list_knowledge_dossiers()
+        return storage.list_knowledge_dossiers(owner_id=owner_id)
 
     # ── 3. Global Knowledge Summary Across All Data ────────────────────────
-    async def synthesize_global_knowledge(self) -> Dict[str, Any]:
+    async def synthesize_global_knowledge(self, owner_id: Optional[str] = None) -> Dict[str, Any]:
         """
         Synthesizes a collective master knowledge summary of all indexed documents in the workspace.
         """
-        dossiers = storage.list_knowledge_dossiers()
+        dossiers = storage.list_knowledge_dossiers(owner_id=owner_id)
         total_docs = len(dossiers)
 
         if not dossiers:
             # Check if any documents exist in doc_meta without dossiers yet
-            all_docs = storage.list_documents()
+            all_docs = storage.list_documents(owner_id=owner_id)
             if not all_docs:
                 default_summary = "No documents currently indexed in the knowledge base."
-                storage.save_global_knowledge_summary(default_summary, 0, [])
+                storage.save_global_knowledge_summary(default_summary, 0, [], owner_id=owner_id)
                 return {"collective_summary": default_summary, "total_documents": 0, "key_insights": []}
 
         # Build combined summary representation of all dossiers
@@ -252,7 +259,7 @@ Return ONLY valid JSON with this exact schema:
         collective = data.get("collective_summary") or "Atlas Global Knowledge Base synthesis complete."
         insights = data.get("key_insights") or []
 
-        storage.save_global_knowledge_summary(collective, total_docs, insights)
+        storage.save_global_knowledge_summary(collective, total_docs, insights, owner_id=owner_id)
         app_logger.info(f"[MEMORY] Successfully synthesized global knowledge across {total_docs} documents.")
 
         return {
@@ -262,10 +269,10 @@ Return ONLY valid JSON with this exact schema:
             "updated_at": time.time(),
         }
 
-    def get_global_knowledge(self) -> Dict[str, Any]:
+    def get_global_knowledge(self, owner_id: Optional[str] = None) -> Dict[str, Any]:
         """Fetch current global knowledge summary and document dossiers."""
-        global_rec = storage.get_global_knowledge_summary() or {}
-        dossiers = storage.list_knowledge_dossiers()
+        global_rec = storage.get_global_knowledge_summary(owner_id=owner_id) or {}
+        dossiers = storage.list_knowledge_dossiers(owner_id=owner_id)
         return {
             "collective_summary": global_rec.get(
                 "collective_summary", "No collective summary available yet. Ingest documents to build knowledge."

pyproject.toml

@@ -22,3 +22,14 @@ dependencies = [
     "uvicorn>=0.46.0",
     "youtube-transcript-api>=1.2.4",
 ]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.1",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["app", "."]

tests/conftest.py

@@ -0,0 +1,46 @@
+import os
+import sys
+import tempfile
+import pytest
+
+# Ensure app is discoverable on python path
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+APP_DIR = os.path.join(BASE_DIR, "app")
+if APP_DIR not in sys.path:
+    sys.path.insert(0, APP_DIR)
+if BASE_DIR not in sys.path:
+    sys.path.insert(0, BASE_DIR)
+
+# Strictly isolate test execution from any live database and default directories BEFORE imports
+_SESSION_TMP = tempfile.mkdtemp(prefix="atlas_test_isolation_")
+_SESSION_DATA = os.path.join(_SESSION_TMP, "data")
+_SESSION_UPLOADS = os.path.join(_SESSION_TMP, "uploads")
+_SESSION_STATIC = os.path.join(_SESSION_TMP, "static")
+os.makedirs(_SESSION_DATA, exist_ok=True)
+os.makedirs(_SESSION_UPLOADS, exist_ok=True)
+os.makedirs(_SESSION_STATIC, exist_ok=True)
+
+os.environ["DATABASE_URL"] = ""
+os.environ["POSTGRES_URL"] = ""
+os.environ["POSTGRESQL_URL"] = ""
+os.environ["ATLAS_DATA_DIR"] = _SESSION_DATA
+os.environ["ATLAS_UPLOAD_DIR"] = _SESSION_UPLOADS
+
+
+@pytest.fixture(autouse=True)
+def setup_isolated_test_env(tmp_path, monkeypatch):
+    """Enforces completely isolated local directories and SQLite database for each test."""
+    data_dir = str(tmp_path / "data")
+    upload_dir = str(tmp_path / "uploads")
+    static_dir = str(tmp_path / "static")
+    os.makedirs(data_dir, exist_ok=True)
+    os.makedirs(upload_dir, exist_ok=True)
+    os.makedirs(static_dir, exist_ok=True)
+
+    monkeypatch.setenv("DATABASE_URL", "")
+    monkeypatch.setenv("POSTGRES_URL", "")
+    monkeypatch.setenv("POSTGRESQL_URL", "")
+    monkeypatch.setenv("ATLAS_DATA_DIR", data_dir)
+    monkeypatch.setenv("ATLAS_UPLOAD_DIR", upload_dir)
+
+    yield

tests/test_client_isolation.py

@@ -0,0 +1,160 @@
+import uuid
+import pytest
+from fastapi.testclient import TestClient
+
+from app import app
+
+
+@pytest.fixture
+def client():
+    return TestClient(app)
+
+
+def test_public_endpoints_accessible_without_client_id(client):
+    """Verifies that public endpoints (/, /health, /docs, /openapi.json) require no X-Client-ID."""
+    r_root = client.get("/")
+    assert r_root.status_code == 200
+    assert "message" in r_root.json()
+
+    r_health = client.get("/health")
+    assert r_health.status_code == 200
+    assert r_health.json()["status"] == "ok"
+
+    r_docs = client.get("/docs")
+    assert r_docs.status_code == 200
+
+    r_openapi = client.get("/openapi.json")
+    assert r_openapi.status_code == 200
+
+
+def test_protected_endpoints_reject_missing_client_id(client):
+    """Protected endpoints must return 400 if X-Client-ID is missing."""
+    r = client.get("/chats")
+    assert r.status_code == 400
+    assert "Missing required header: X-Client-ID" in r.json()["detail"]
+
+    r_docs = client.get("/documents")
+    assert r_docs.status_code == 400
+
+    r_tools = client.post("/tools/calculate-math", json={"expression": "1 + 1"})
+    assert r_tools.status_code == 400
+
+
+def test_protected_endpoints_reject_invalid_uuid(client):
+    """Protected endpoints must return 400 if X-Client-ID is not a valid UUIDv4."""
+    bad_headers = {"X-Client-ID": "not-a-valid-uuid-string"}
+    r = client.get("/chats", headers=bad_headers)
+    assert r.status_code == 400
+    assert "valid UUID" in r.json()["detail"]
+
+
+def test_chat_isolation_between_clients(client):
+    """Client A and Client B must have complete data isolation for chats and messages."""
+    client_a_id = str(uuid.uuid4())
+    client_b_id = str(uuid.uuid4())
+
+    headers_a = {"X-Client-ID": client_a_id}
+    headers_b = {"X-Client-ID": client_b_id}
+
+    # 1. Client A creates a chat
+    create_res = client.post("/chat/new", headers=headers_a)
+    assert create_res.status_code == 200
+    chat_a_id = create_res.json()["chat_id"]
+
+    # 2. Client A lists chats -> finds chat_a_id
+    list_a = client.get("/chats", headers=headers_a).json()["chats"]
+    assert any(c["chat_id"] == chat_a_id for c in list_a)
+
+    # 3. Client B lists chats -> must NOT find chat_a_id
+    list_b = client.get("/chats", headers=headers_b).json()["chats"]
+    assert not any(c["chat_id"] == chat_a_id for c in list_b)
+
+    # 4. Client B attempts to fetch Client A's chat history -> 404
+    hist_b = client.get(f"/chat/{chat_a_id}/history", headers=headers_b)
+    assert hist_b.status_code == 404
+
+    # 5. Client B attempts to delete Client A's chat -> 404
+    del_res = client.delete(f"/chat/{chat_a_id}", headers=headers_b)
+    assert del_res.status_code == 404
+
+    # 6. Client A renames chat -> succeeds
+    rename_res = client.patch(f"/chat/{chat_a_id}/title", headers=headers_a, json={"title": "Client A Topic"})
+    assert rename_res.status_code == 200
+
+    # 7. Client B attempts to rename Client A's chat -> 404
+    rename_b = client.patch(f"/chat/{chat_a_id}/title", headers=headers_b, json={"title": "Hacked Title"})
+    assert rename_b.status_code == 404
+
+    # 8. Client A deletes chat -> succeeds
+    del_res_a = client.delete(f"/chat/{chat_a_id}", headers=headers_a)
+    assert del_res_a.status_code == 200
+
+
+def test_tools_endpoint_accessible_with_valid_client_id(client):
+    """Tools endpoint succeeds with valid client_id."""
+    client_id = str(uuid.uuid4())
+    headers = {"X-Client-ID": client_id}
+    res = client.post("/tools/calculate-math", headers=headers, json={"expression": "10 * 5"})
+    assert res.status_code == 200
+    assert res.json()["result"] == 50
+
+
+def test_document_and_memory_isolation_between_clients(client):
+    """Client A's documents, dossiers, and summaries must remain invisible to Client B."""
+    from core.dependencies import get_storage
+    storage = get_storage()
+
+    client_a = str(uuid.uuid4())
+    client_b = str(uuid.uuid4())
+
+    doc_a_id = f"doc_test_{uuid.uuid4().hex[:8]}"
+
+    # Seed document metadata for Client A directly into storage
+    storage.create_document(
+        doc_id=doc_a_id,
+        filename="client_a_contract.pdf",
+        content_hash="hash_a_12345",
+        file_path="/tmp/fake_contract.pdf",
+        owner_id=client_a,
+    )
+    storage.save_knowledge_dossier(
+        doc_id=doc_a_id,
+        filename="client_a_contract.pdf",
+        executive_summary="Confidential contract for Client A",
+        key_entities=["Client A Corp"],
+        key_findings=["Revenue target $10M"],
+        topics=["Confidential", "Finance"],
+        owner_id=client_a,
+    )
+
+    # Client A lists documents -> sees doc_a_id
+    headers_a = {"X-Client-ID": client_a}
+    docs_a = client.get("/documents", headers=headers_a).json()["documents"]
+    assert any(d["doc_id"] == doc_a_id for d in docs_a)
+
+    # Client B lists documents -> does NOT see doc_a_id
+    headers_b = {"X-Client-ID": client_b}
+    docs_b = client.get("/documents", headers=headers_b).json()["documents"]
+    assert not any(d["doc_id"] == doc_a_id for d in docs_b)
+
+    # Client B attempts to fetch Client A's document details -> 404
+    get_doc_b = client.get(f"/documents/{doc_a_id}", headers=headers_b)
+    assert get_doc_b.status_code == 404
+
+    # Client B attempts to fetch Client A's dossier -> 404
+    dossier_b = client.get(f"/memory/dossier/{doc_a_id}", headers=headers_b)
+    assert dossier_b.status_code == 404
+
+    # Client A fetches dossier -> 200
+    dossier_a = client.get(f"/memory/dossier/{doc_a_id}", headers=headers_a)
+    assert dossier_a.status_code == 200
+    assert dossier_a.json()["executive_summary"] == "Confidential contract for Client A"
+
+    # Client B attempts to delete Client A's document -> 404
+    del_b = client.delete(f"/documents/{doc_a_id}", headers=headers_b)
+    assert del_b.status_code == 404
+
+    # Client A deletes document -> 200
+    del_a = client.delete(f"/documents/{doc_a_id}", headers=headers_a)
+    assert del_a.status_code == 200
+

uv.lock

@@ -1101,6 +1101,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/55/ecca97ae19075f1fac62def77731e7f535e6c1fb8f92ff08160c5e6dade8/importlib_metadata-9.0.1-py3-none-any.whl", hash = "sha256:bba5600596a7e21f3eef53281cf28d6a5195634d2f2b78ff9501a3272c6eaab0", size = 27920, upload-time = "2026-08-28T15:30:33.433Z" },
 ]
 
+[[package]]
+name = "iniconfig"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" },
+]
+
 [[package]]
 name = "jaraco-classes"
 version = "3.4.0"
@@ -1763,6 +1772,12 @@ dependencies = [
     { name = "youtube-transcript-api" },
 ]
 
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+]
+
 [package.metadata]
 requires-dist = [
     { name = "beautifulsoup4", specifier = ">=4.15.0" },
@@ -1783,6 +1798,12 @@ requires-dist = [
     { name = "youtube-transcript-api", specifier = ">=1.2.4" },
 ]
 
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=9.1.1" },
+    { name = "pytest-asyncio", specifier = ">=1.4.1" },
+]
+
 [[package]]
 name = "pathable"
 version = "0.6.0"
@@ -1801,6 +1822,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/51/5614d0537dd830ca64d95a2f254bd66bdf3ac61d41cffcccaec62121fcfd/platformdirs-4.13.4-py3-none-any.whl", hash = "sha256:502ce08e9d36cf90579ee44e1e764838842fa658e4975ef47344fd053011d2c8", size = 32782, upload-time = "2026-10-17T19:31:52.293Z" },
 ]
 
+[[package]]
+name = "pluggy"
+version = "1.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" },
+]
+
 [[package]]
 name = "primp"
 version = "2.0.1"
@@ -2249,6 +2279,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" },
 ]
 
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f8/9a/887535e477847f5159377ab35303923644840b13c0ca03c0a467f84d4680/pytest_asyncio-1.4.1.tar.gz", hash = "sha256:e8266eb094e5ee9ffdb2068c9836f33e209ea77a970eb846933d416b5602669b", size = 145237, upload-time = "2026-10-25T21:05:37.135Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/d7/cd9e2708afdbf059658adaf08bdb0792ca52489871051d6ce7d498b51277/pytest_asyncio-1.4.1-py3-none-any.whl", hash = "sha256:507afa78ec77c6661164ef1a2368bc7820383fd1a14b2a7f813de8b5a92949cc", size = 17061, upload-time = "2026-10-25T21:05:35.473Z" },
+]
+
 [[package]]
 name = "python-dotenv"
 version = "1.2.2"