FK U SQL

pyproject.toml

@@ -14,6 +14,7 @@ dependencies = [
     "openai>=2.14.0",
     "psutil>=7.2.1",
     "pydantic>=2.12.5",
+    "pymongo>=4.16.0",
     "pypdf>=6.5.0",
     "python-multipart>=0.0.21",
     "qdrant-client>=1.16.2",

requirements.txt

@@ -8,6 +8,7 @@ langchain-google-genai>=4.1.2
 langchain-huggingface>=1.2.0
 langchain-qdrant>=1.1.0
 psutil>=7.2.1
+pymongo[srv]>=4.6.0
 pydantic>=2.12.5
 pypdf>=6.5.0
 python-dotenv>=1.0.0

src/database.py

@@ -0,0 +1,243 @@
+import os
+import time
+import logging
+from datetime import datetime, timezone
+from typing import Optional, List
+
+from pymongo import MongoClient, DESCENDING
+from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+
+logger = logging.getLogger("rag-api")
+
+MONGODB_URI = os.getenv("MONGODB_URI")
+_client: Optional[MongoClient] = None
+_db = None
+
+
+def get_database():
+    global _client, _db
+    
+    if _db is not None:
+        return _db
+    
+    try:
+        _client = MongoClient(
+            MONGODB_URI, 
+            serverSelectionTimeoutMS=5000,
+            tls=True,
+            tlsAllowInvalidCertificates=True
+        )
+        _client.admin.command('ping')
+        _db = _client.askbookie
+        logger.info("MongoDB connected successfully")
+        _create_indexes(_db)
+        return _db
+    except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+        logger.error(f"MongoDB connection failed: {e}")
+        raise
+
+
+def _create_indexes(db):
+    try:
+        db.rate_limits.create_index("timestamp", expireAfterSeconds=60)
+        db.rate_limits.create_index([("key_id", 1), ("endpoint", 1), ("timestamp", 1)])
+        db.failed_auth.create_index("timestamp", expireAfterSeconds=300)
+        db.failed_auth.create_index([("ip", 1), ("timestamp", 1)])
+        db.jobs.create_index("created_at", expireAfterSeconds=86400)
+        db.jobs.create_index([("key_id", 1), ("created_at", -1)])
+        db.jobs.create_index("job_id", unique=True)
+        db.metrics.create_index([("key_id", 1), ("endpoint", 1), ("timestamp", -1)])
+        db.query_history.create_index([("timestamp", -1)])
+        logger.info("MongoDB indexes created")
+    except Exception as e:
+        logger.warning(f"Index creation warning: {e}")
+
+
+def check_rate_limit(key_id: str, endpoint: str, limit: int) -> bool:
+    db = get_database()
+    now = datetime.now(timezone.utc)
+    window_start = datetime.fromtimestamp(time.time() - 60, tz=timezone.utc)
+    
+    count = db.rate_limits.count_documents({
+        "key_id": key_id,
+        "endpoint": endpoint,
+        "timestamp": {"$gte": window_start}
+    })
+    
+    if count >= limit:
+        return False
+    
+    db.rate_limits.insert_one({
+        "key_id": key_id,
+        "endpoint": endpoint,
+        "timestamp": now
+    })
+    return True
+
+
+def record_failed_auth(ip: str):
+    db = get_database()
+    db.failed_auth.insert_one({
+        "ip": ip,
+        "timestamp": datetime.now(timezone.utc)
+    })
+
+
+def check_auth_lockout(ip: str, limit: int = 5) -> bool:
+    db = get_database()
+    window_start = datetime.fromtimestamp(time.time() - 300, tz=timezone.utc)
+    count = db.failed_auth.count_documents({
+        "ip": ip,
+        "timestamp": {"$gte": window_start}
+    })
+    return count >= limit
+
+
+def create_job(job_id: str, key_id: str, filename: str, subject: str, size: int) -> dict:
+    db = get_database()
+    job = {
+        "job_id": job_id,
+        "key_id": key_id,
+        "filename": filename,
+        "subject": subject,
+        "size": size,
+        "status": "queued",
+        "error": None,
+        "created_at": datetime.now(timezone.utc),
+        "updated_at": None
+    }
+    db.jobs.insert_one(job)
+    return job
+
+
+def update_job_status(job_id: str, status: str, error: str = None):
+    db = get_database()
+    db.jobs.update_one(
+        {"job_id": job_id},
+        {"$set": {
+            "status": status,
+            "error": error,
+            "updated_at": datetime.now(timezone.utc)
+        }}
+    )
+
+
+def get_job(job_id: str, key_id: str) -> Optional[dict]:
+    db = get_database()
+    job = db.jobs.find_one({"job_id": job_id, "key_id": key_id})
+    if job:
+        job["_id"] = str(job["_id"])
+        job["created_at"] = job["created_at"].timestamp() if job.get("created_at") else None
+        job["updated_at"] = job["updated_at"].timestamp() if job.get("updated_at") else None
+    return job
+
+
+def list_user_jobs(key_id: str) -> List[dict]:
+    db = get_database()
+    jobs = list(db.jobs.find(
+        {"key_id": key_id},
+        {"_id": 0, "job_id": 1, "filename": 1, "subject": 1, "size": 1, "status": 1, "error": 1, "created_at": 1}
+    ).sort("created_at", DESCENDING))
+    
+    for job in jobs:
+        if job.get("created_at"):
+            job["created_at"] = job["created_at"].timestamp()
+    return jobs
+
+
+def count_active_uploads(key_id: str) -> int:
+    db = get_database()
+    return db.jobs.count_documents({
+        "key_id": key_id,
+        "status": {"$in": ["queued", "processing"]}
+    })
+
+
+def record_metric(key_id: str, endpoint: str, success: bool, latency_ms: float):
+    db = get_database()
+    db.metrics.insert_one({
+        "key_id": key_id,
+        "endpoint": endpoint,
+        "success": success,
+        "latency_ms": latency_ms,
+        "timestamp": datetime.now(timezone.utc)
+    })
+
+
+def get_metrics_summary() -> dict:
+    import psutil
+    
+    db = get_database()
+    
+    total_calls = db.metrics.count_documents({})
+    total_questions = db.metrics.count_documents({"endpoint": "/ask"})
+    active_jobs = db.jobs.count_documents({"status": {"$in": ["queued", "processing"]}})
+    
+    pipeline = [
+        {"$group": {
+            "_id": "$key_id",
+            "api_calls": {"$sum": 1},
+            "questions_asked": {"$sum": {"$cond": [{"$eq": ["$endpoint", "/ask"]}, 1, 0]}},
+            "uploads_attempted": {"$sum": {"$cond": [{"$eq": ["$endpoint", "/upload"]}, 1, 0]}},
+            "success_count": {"$sum": {"$cond": ["$success", 1, 0]}},
+            "total_latency": {"$sum": "$latency_ms"},
+            "ask_fails": {"$sum": {"$cond": [{"$and": [{"$eq": ["$endpoint", "/ask"]}, {"$not": "$success"}]}, 1, 0]}},
+            "upload_fails": {"$sum": {"$cond": [{"$and": [{"$eq": ["$endpoint", "/upload"]}, {"$not": "$success"}]}, 1, 0]}}
+        }}
+    ]
+    
+    per_user = {}
+    for doc in db.metrics.aggregate(pipeline):
+        kid = doc["_id"]
+        total = doc["api_calls"]
+        per_user[kid] = {
+            "api_calls": total,
+            "questions_asked": doc["questions_asked"],
+            "uploads_attempted": doc["uploads_attempted"],
+            "success_rate": round((doc["success_count"] / total * 100) if total > 0 else 100, 1),
+            "average_latency_seconds": round((doc["total_latency"] / total / 1000) if total > 0 else 0, 2),
+            "ask_fails": doc["ask_fails"],
+            "upload_fails": doc["upload_fails"],
+        }
+    
+    process = psutil.Process()
+    return {
+        "total_api_calls": total_calls,
+        "total_questions": total_questions,
+        "active_jobs": active_jobs,
+        "memory_mb": round(process.memory_info().rss / (1024 * 1024), 1),
+        "per_user": per_user,
+    }
+
+
+def store_query_history(key_id: str, subject: str, query: str, answer: str,
+                        sources: list, request_id: str, latency_ms: float):
+    db = get_database()
+    db.query_history.insert_one({
+        "key_id": key_id,
+        "subject": subject,
+        "query": query,
+        "answer": answer,
+        "sources": sources,
+        "request_id": request_id,
+        "latency_ms": latency_ms,
+        "timestamp": datetime.now(timezone.utc)
+    })
+
+
+def get_query_history(limit: int = 100, offset: int = 0) -> tuple[List[dict], int]:
+    db = get_database()
+    
+    total = db.query_history.count_documents({})
+    
+    history = list(db.query_history.find(
+        {},
+        {"_id": 0}
+    ).sort("timestamp", DESCENDING).skip(offset).limit(limit))
+    
+    for i, item in enumerate(history):
+        item["id"] = offset + i + 1
+        if item.get("timestamp"):
+            item["timestamp"] = item["timestamp"].timestamp()
+    
+    return history, total

src/main.py

@@ -5,14 +5,12 @@ import secrets
 import hmac
 import hashlib
 import logging
-import sqlite3
 import tempfile
 import atexit
 import re
 import json
 from datetime import datetime, timedelta, timezone
-from threading import Lock
-from contextlib import contextmanager, asynccontextmanager
+from contextlib import asynccontextmanager
 from typing import Optional
 from pathlib import Path
 
@@ -25,6 +23,7 @@ from dotenv import load_dotenv
 load_dotenv()
 
 from rag import RAGService, process_pdf, model_manager, MODEL_OPTIONS
+import database as db
 
 logging.basicConfig(
     level=logging.INFO,
@@ -33,7 +32,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger("rag-api")
 
-DB_PATH = os.getenv("DB_PATH", "rag_security.db")
 MAX_FILE_SIZE = 10 * 1024 * 1024
 ALLOWED_MIME_TYPES = {"application/pdf"}
 UPLOAD_DIR = Path(tempfile.mkdtemp(prefix="rag_uploads_"))
@@ -41,90 +39,12 @@ MAX_JSON_BODY = 16 * 1024
 MAX_DEFAULT_BODY = 32 * 1024
 RATE_LIMITS = {"/ask": 30, "/upload": 2, "default": 50}
 FAILED_AUTH_LIMIT = 5
-FAILED_AUTH_WINDOW = 300
-JOB_TTL_SECONDS = 24 * 3600
 KEY_EXPIRY_DAYS = 90
 HMAC_TIME_WINDOW = 300
 MAX_CONCURRENT_UPLOADS = 3
-PDF_PROCESS_TIMEOUT = 300
 SUBJECT_PATTERN = re.compile(r'^[a-zA-Z0-9_-]+$')
 STARTUP_TIME = time.time()
 
-_db_lock = Lock()
-
-def get_db_connection() -> sqlite3.Connection:
-    conn = sqlite3.connect(DB_PATH, timeout=10)
-    conn.row_factory = sqlite3.Row
-    return conn
-
-@contextmanager
-def db_transaction():
-    with _db_lock:
-        conn = get_db_connection()
-        try:
-            yield conn
-            conn.commit()
-        except Exception:
-            conn.rollback()
-            raise
-        finally:
-            conn.close()
-
-def init_database():
-    with db_transaction() as conn:
-        conn.execute("PRAGMA journal_mode=WAL;")
-        conn.execute("PRAGMA busy_timeout=5000;")
-        conn.executescript("""
-            CREATE TABLE IF NOT EXISTS rate_limits (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                key_id TEXT NOT NULL,
-                endpoint TEXT NOT NULL,
-                timestamp REAL NOT NULL
-            );
-            CREATE INDEX IF NOT EXISTS idx_rate_key_endpoint ON rate_limits(key_id, endpoint, timestamp);
-            CREATE TABLE IF NOT EXISTS failed_auth (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                ip TEXT NOT NULL,
-                timestamp REAL NOT NULL
-            );
-            CREATE INDEX IF NOT EXISTS idx_failed_ip ON failed_auth(ip, timestamp);
-            CREATE TABLE IF NOT EXISTS jobs (
-                job_id TEXT PRIMARY KEY,
-                key_id TEXT NOT NULL,
-                filename TEXT,
-                subject TEXT,
-                size INTEGER,
-                status TEXT NOT NULL,
-                error TEXT,
-                created_at REAL NOT NULL,
-                updated_at REAL
-            );
-            CREATE INDEX IF NOT EXISTS idx_jobs_key ON jobs(key_id, created_at);
-            CREATE TABLE IF NOT EXISTS metrics (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                key_id TEXT NOT NULL,
-                endpoint TEXT NOT NULL,
-                success INTEGER NOT NULL,
-                latency_ms REAL NOT NULL,
-                timestamp REAL NOT NULL
-            );
-            CREATE INDEX IF NOT EXISTS idx_metrics_key ON metrics(key_id, endpoint, timestamp);
-            CREATE TABLE IF NOT EXISTS query_history (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                key_id TEXT NOT NULL,
-                subject TEXT NOT NULL,
-                query TEXT NOT NULL,
-                answer TEXT NOT NULL,
-                sources TEXT,
-                request_id TEXT,
-                latency_ms REAL,
-                timestamp REAL NOT NULL
-            );
-            CREATE INDEX IF NOT EXISTS idx_history_timestamp ON query_history(timestamp);
-        """)
-
-init_database()
-
 _api_key_configs = [
     ("askbookie-pesu", "SERVICE_A_SECRET", "user"),
     ("ask-bookie", "SERVICE_B_SECRET", "user"),
@@ -155,17 +75,6 @@ def get_client_ip(request: Request) -> str:
         return forwarded.split(",")[-1].strip()
     return request.client.host if request.client else "unknown"
 
-def record_failed_auth(ip: str):
-    with db_transaction() as conn:
-        conn.execute("INSERT INTO failed_auth (ip, timestamp) VALUES (?, ?)", (ip, time.time()))
-
-def check_auth_lockout(ip: str) -> bool:
-    cutoff = time.time() - FAILED_AUTH_WINDOW
-    with db_transaction() as conn:
-        conn.execute("DELETE FROM failed_auth WHERE timestamp < ?", (cutoff,))
-        cursor = conn.execute("SELECT COUNT(*) FROM failed_auth WHERE ip = ? AND timestamp > ?", (ip, cutoff))
-        return cursor.fetchone()[0] >= FAILED_AUTH_LIMIT
-
 def verify_hmac_signature(request: Request) -> Optional[str]:
     key_id = request.headers.get("X-API-Key-Id")
     sig = request.headers.get("X-API-Signature")
@@ -194,143 +103,51 @@ def verify_hmac_signature(request: Request) -> Optional[str]:
 
 async def verify_api_key(request: Request) -> str:
     ip = get_client_ip(request)
-    if check_auth_lockout(ip):
+    if db.check_auth_lockout(ip, FAILED_AUTH_LIMIT):
         raise HTTPException(status_code=429, detail="Too many failed attempts")
     key_id = verify_hmac_signature(request)
     if key_id:
         return key_id
-    record_failed_auth(ip)
+    db.record_failed_auth(ip)
     await asyncio.sleep(0.1)
     raise HTTPException(status_code=401, detail="Unauthorized")
 
-def check_rate_limit(key_id: str, endpoint: str) -> bool:
-    limit = RATE_LIMITS.get(endpoint, RATE_LIMITS["default"])
-    now = time.time()
-    window_start = now - 60
-    with db_transaction() as conn:
-        conn.execute("DELETE FROM rate_limits WHERE timestamp < ?", (window_start,))
-        cursor = conn.execute(
-            "SELECT COUNT(*) FROM rate_limits WHERE key_id = ? AND endpoint = ? AND timestamp > ?",
-            (key_id, endpoint, window_start)
-        )
-        if cursor.fetchone()[0] >= limit:
-            return False
-        conn.execute("INSERT INTO rate_limits (key_id, endpoint, timestamp) VALUES (?, ?, ?)", (key_id, endpoint, now))
-    return True
-
 def rate_limited(endpoint: str):
     async def dependency(request: Request):
         key_id = await verify_api_key(request)
-        if not check_rate_limit(key_id, endpoint):
+        limit = RATE_LIMITS.get(endpoint, RATE_LIMITS["default"])
+        if not db.check_rate_limit(key_id, endpoint, limit):
             raise HTTPException(status_code=429, detail="Rate limit exceeded", headers={"Retry-After": "60"})
         request.state.key_id = key_id
         return key_id
     return dependency
 
-def update_job_status(job_id: str, status: str, error: str = None):
-    with db_transaction() as conn:
-        conn.execute("UPDATE jobs SET status = ?, error = ?, updated_at = ? WHERE job_id = ?", 
-                     (status, error, time.time(), job_id))
-
-def get_job(job_id: str, key_id: str) -> Optional[dict]:
-    with db_transaction() as conn:
-        cursor = conn.execute("SELECT * FROM jobs WHERE job_id = ? AND key_id = ?", (job_id, key_id))
-        row = cursor.fetchone()
-    return dict(row) if row else None
-
-def list_user_jobs(key_id: str) -> list:
-    cutoff = time.time() - JOB_TTL_SECONDS
-    with db_transaction() as conn:
-        conn.execute("DELETE FROM jobs WHERE created_at < ?", (cutoff,))
-        cursor = conn.execute(
-            "SELECT job_id, filename, subject, size, status, error, created_at FROM jobs WHERE key_id = ? ORDER BY created_at DESC",
-            (key_id,)
-        )
-        return [dict(row) for row in cursor.fetchall()]
-
-def count_active_uploads(key_id: str) -> int:
-    with db_transaction() as conn:
-        cursor = conn.execute(
-            "SELECT COUNT(*) FROM jobs WHERE key_id = ? AND status IN ('queued', 'processing')",
-            (key_id,)
-        )
-        return cursor.fetchone()[0]
-
 def sanitize_subject(subject: str) -> str:
     clean = subject.strip().lower()
     if not SUBJECT_PATTERN.match(clean):
         clean = re.sub(r'[^a-zA-Z0-9_-]', '', clean)
     return clean[:50] if clean else "default"
 
-def record_metric(key_id: str, endpoint: str, success: bool, latency_ms: float):
-    with db_transaction() as conn:
-        conn.execute(
-            "INSERT INTO metrics (key_id, endpoint, success, latency_ms, timestamp) VALUES (?, ?, ?, ?, ?)",
-            (key_id, endpoint, 1 if success else 0, latency_ms, time.time())
-        )
-
-def store_query_history(key_id: str, subject: str, query: str, answer: str, 
-                        sources: list, request_id: str, latency_ms: float):
-    with db_transaction() as conn:
-        conn.execute(
-            """INSERT INTO query_history 
-               (key_id, subject, query, answer, sources, request_id, latency_ms, timestamp) 
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
-            (key_id, subject, query, answer, json.dumps(sources), request_id, latency_ms, time.time())
-        )
-
 def get_metrics_summary() -> dict:
-    import psutil
-    with db_transaction() as conn:
-        total_calls = conn.execute("SELECT COUNT(*) FROM metrics").fetchone()[0]
-        total_questions = conn.execute("SELECT COUNT(*) FROM metrics WHERE endpoint = '/ask'").fetchone()[0]
-        active_jobs = conn.execute("SELECT COUNT(*) FROM jobs WHERE status IN ('queued', 'processing')").fetchone()[0]
-        per_user = {}
-        cursor = conn.execute("""
-            SELECT key_id, COUNT(*) as api_calls,
-                   SUM(CASE WHEN endpoint = '/ask' THEN 1 ELSE 0 END) as questions_asked,
-                   SUM(CASE WHEN endpoint = '/upload' THEN 1 ELSE 0 END) as uploads_attempted,
-                   AVG(CASE WHEN success = 1 THEN 100.0 ELSE 0.0 END) as success_rate,
-                   AVG(latency_ms) / 1000.0 as average_latency_seconds,
-                   SUM(CASE WHEN endpoint = '/ask' AND success = 0 THEN 1 ELSE 0 END) as ask_fails,
-                   SUM(CASE WHEN endpoint = '/upload' AND success = 0 THEN 1 ELSE 0 END) as upload_fails
-            FROM metrics GROUP BY key_id
-        """)
-        for row in cursor.fetchall():
-            kid = row[0]
-            per_user[kid] = {
-                "api_calls": row[1],
-                "questions_asked": row[2],
-                "uploads_attempted": row[3],
-                "success_rate": round(row[4], 1) if row[4] else 100,
-                "average_latency_seconds": round(row[5], 2) if row[5] else 0,
-                "ask_fails": row[6] or 0,
-                "upload_fails": row[7] or 0,
-                "role": API_KEYS.get(kid, {}).get("role", "user"),
-            }
-    process = psutil.Process()
-    return {
-        "uptime_hours": round((time.time() - STARTUP_TIME) / 3600, 2),
-        "total_api_calls": total_calls,
-        "total_questions": total_questions,
-        "active_jobs": active_jobs,
-        "memory_mb": round(process.memory_info().rss / (1024 * 1024), 1),
-        "per_user": per_user,
-    }
+    metrics = db.get_metrics_summary()
+    metrics["uptime_hours"] = round((time.time() - STARTUP_TIME) / 3600, 2)
+    for kid in metrics.get("per_user", {}):
+        metrics["per_user"][kid]["role"] = API_KEYS.get(kid, {}).get("role", "user")
+    return metrics
 
 async def process_pdf_job(job_id: str, file_path: Path, original_filename: str, subject: str):
     def status_callback(status: str):
-        update_job_status(job_id, status)
+        db.update_job_status(job_id, status)
         logger.info(f"Job {job_id}: {status}")
     try:
-        update_job_status(job_id, "processing")
+        db.update_job_status(job_id, "processing")
         logger.info(f"Job {job_id}: Starting RAG processing")
         process_pdf(str(file_path), original_filename, subject, status_callback)
-        update_job_status(job_id, "done")
+        db.update_job_status(job_id, "done")
         logger.info(f"Job {job_id}: Complete")
     except Exception as e:
         logger.exception(f"Job {job_id} failed")
-        update_job_status(job_id, "failed", str(e)[:200])
+        db.update_job_status(job_id, "failed", str(e)[:200])
     finally:
         try:
             if file_path.exists():
@@ -443,7 +260,7 @@ async def ask(request: Request, body: AskRequest, key_id: str = Depends(rate_lim
         result = rag_service.ask(body.query, subject)
         success = True
         latency_ms = (time.time() - start_time) * 1000
-        store_query_history(
+        db.store_query_history(
             key_id=key_id,
             subject=subject,
             query=body.query,
@@ -457,7 +274,7 @@ async def ask(request: Request, body: AskRequest, key_id: str = Depends(rate_lim
         logger.exception(f"RAG query failed: {e}")
         raise HTTPException(status_code=500, detail="Query failed")
     finally:
-        record_metric(key_id, "/ask", success, (time.time() - start_time) * 1000)
+        db.record_metric(key_id, "/ask", success, (time.time() - start_time) * 1000)
 
 @app.post("/upload")
 async def upload(
@@ -472,7 +289,7 @@ async def upload(
     subject = sanitize_subject(subject)
     if not subject:
         raise HTTPException(status_code=400, detail="Invalid subject")
-    if count_active_uploads(key_id) >= MAX_CONCURRENT_UPLOADS:
+    if db.count_active_uploads(key_id) >= MAX_CONCURRENT_UPLOADS:
         raise HTTPException(status_code=429, detail="Too many concurrent uploads")
     if not file.filename or not file.filename.lower().endswith(".pdf"):
         raise HTTPException(status_code=400, detail="Only PDF files allowed")
@@ -495,11 +312,7 @@ async def upload(
                 f.write(chunk)
         if size == 0:
             raise HTTPException(status_code=400, detail="Empty file")
-        with db_transaction() as conn:
-            conn.execute(
-                "INSERT INTO jobs (job_id, key_id, filename, subject, size, status, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
-                (job_id, key_id, file.filename, subject, size, "queued", time.time())
-            )
+        db.create_job(job_id, key_id, file.filename, subject, size)
         background_tasks.add_task(process_pdf_job, job_id, temp_path, file.filename, subject)
         logger.info(f"Upload queued: job={job_id}")
         success = True
@@ -514,18 +327,18 @@ async def upload(
         logger.exception("Upload failed")
         raise HTTPException(status_code=500, detail="Upload failed")
     finally:
-        record_metric(key_id, "/upload", success, (time.time() - start_time) * 1000)
+        db.record_metric(key_id, "/upload", success, (time.time() - start_time) * 1000)
 
 @app.get("/jobs/{job_id}")
 async def get_job_status(request: Request, job_id: str, key_id: str = Depends(rate_limited("default"))):
-    job = get_job(job_id, key_id)
+    job = db.get_job(job_id, key_id)
     if not job:
         raise HTTPException(status_code=404, detail="Job not found")
     return job
 
 @app.get("/jobs")
 async def list_jobs(request: Request, key_id: str = Depends(rate_limited("default"))):
-    jobs = list_user_jobs(key_id)
+    jobs = db.list_user_jobs(key_id)
     return {"jobs": jobs, "total": len(jobs)}
 
 @app.get("/health")
@@ -592,35 +405,11 @@ async def get_query_history(
     if API_KEYS.get(key_id, {}).get("role") != "admin":
         raise HTTPException(status_code=403, detail="Forbidden")
     
-    with db_transaction() as conn:
-        cursor = conn.execute(
-            """SELECT id, key_id, subject, query, answer, sources, request_id, 
-                      latency_ms, timestamp 
-               FROM query_history 
-               ORDER BY timestamp DESC 
-               LIMIT ? OFFSET ?""",
-            (limit, offset)
-        )
-        history = []
-        for row in cursor.fetchall():
-            history.append({
-                "id": row[0],
-                "key_id": row[1],
-                "subject": row[2],
-                "query": row[3],
-                "answer": row[4],
-                "sources": json.loads(row[5]) if row[5] else [],
-                "request_id": row[6],
-                "latency_ms": row[7],
-                "timestamp": row[8],
-            })
-        
-        total = conn.execute("SELECT COUNT(*) FROM query_history").fetchone()[0]
-    
+    history, total = db.get_query_history(limit, offset)
     return {"history": history, "total": total, "limit": limit, "offset": offset}
 
 class ModelSwitchRequest(BaseModel):
-    model_id: int = Field(..., ge=1, le=5, description="Model ID to switch to (1-5)")
+    model_id: int = Field(..., ge=1, le=5)
 
 @app.get("/admin/models/current")
 async def get_current_model(request: Request, key_id: str = Depends(rate_limited("default"))):

src/rag.py

@@ -197,7 +197,7 @@ class RAGService:
                     continue
                 raise last_error
 
-        top_results = results[:3]
+        top_results = results[:5]
         context_text = "\n\n---\n\n".join([doc.page_content for doc, _ in top_results])
         
         full_prompt = PROMPT_TEMPLATE.format(context=context_text, question=query_text)

uv.lock

@@ -162,6 +162,7 @@ dependencies = [
     { name = "openai" },
     { name = "psutil" },
     { name = "pydantic" },
+    { name = "pymongo" },
     { name = "pypdf" },
     { name = "python-multipart" },
     { name = "qdrant-client" },
@@ -181,6 +182,7 @@ requires-dist = [
     { name = "openai", specifier = ">=2.14.0" },
     { name = "psutil", specifier = ">=7.2.1" },
     { name = "pydantic", specifier = ">=2.12.5" },
+    { name = "pymongo", specifier = ">=4.16.0" },
     { name = "pypdf", specifier = ">=6.5.0" },
     { name = "python-multipart", specifier = ">=0.0.21" },
     { name = "qdrant-client", specifier = ">=1.16.2" },
@@ -389,6 +391,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
 ]
 
+[[package]]
+name = "dnspython"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },
+]
+
 [[package]]
 name = "exceptiongroup"
 version = "1.3.1"
@@ -1955,6 +1966,57 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" },
 ]
 
+[[package]]
+name = "pymongo"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dnspython" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/9c/a4895c4b785fc9865a84a56e14b5bd21ca75aadc3dab79c14187cdca189b/pymongo-4.16.0.tar.gz", hash = "sha256:8ba8405065f6e258a6f872fe62d797a28f383a12178c7153c01ed04e845c600c", size = 2495323, upload-time = "2026-01-07T18:05:48.107Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/93/c36c0998dd91ad8b5031d2e77a903d5cd705b5ba05ca92bcc8731a2c3a8d/pymongo-4.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ed162b2227f98d5b270ecbe1d53be56c8c81db08a1a8f5f02d89c7bb4d19591d", size = 807993, upload-time = "2026-01-07T18:03:40.302Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/96/d2117d792fa9fedb2f6ccf0608db31f851e8382706d7c3c88c6ac92cc958/pymongo-4.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4a9390dce61d705a88218f0d7b54d7e1fa1b421da8129fc7c009e029a9a6b81e", size = 808355, upload-time = "2026-01-07T18:03:42.13Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/2e/e79b7b86c0dd6323d0985c201583c7921d67b842b502aae3f3327cbe3935/pymongo-4.16.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:92a232af9927710de08a6c16a9710cc1b175fb9179c0d946cd4e213b92b2a69a", size = 1182337, upload-time = "2026-01-07T18:03:44.126Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/82/07ec9966381c57d941fddc52637e9c9653e63773be410bd8605f74683084/pymongo-4.16.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d79aa147ce86aef03079096d83239580006ffb684eead593917186aee407767", size = 1200928, upload-time = "2026-01-07T18:03:45.52Z" },
+    { url = "https://files.pythonhosted.org/packages/44/15/9d45e3cc6fa428b0a3600b0c1c86b310f28c91251c41493460695ab40b6b/pymongo-4.16.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:19a1c96e7f39c7a59a9cfd4d17920cf9382f6f684faeff4649bf587dc59f8edc", size = 1239418, upload-time = "2026-01-07T18:03:47.03Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b3/f35ee51e2a3f05f673ad4f5e803ae1284c42f4413e8d121c4958f1af4eb9/pymongo-4.16.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efe020c46ce3c3a89af6baec6569635812129df6fb6cf76d4943af3ba6ee2069", size = 1229045, upload-time = "2026-01-07T18:03:48.377Z" },
+    { url = "https://files.pythonhosted.org/packages/18/2d/1688b88d7c0a5c01da8c703dea831419435d9ce67c6ddbb0ac629c9c72d2/pymongo-4.16.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9dc2c00bed568732b89e211b6adca389053d5e6d2d5a8979e80b813c3ec4d1f9", size = 1196517, upload-time = "2026-01-07T18:03:50.205Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/c6/e89db0f23bd20757b627a5d8c73a609ffd6741887b9004ab229208a79764/pymongo-4.16.0-cp310-cp310-win32.whl", hash = "sha256:5b9c6d689bbe5beb156374508133218610e14f8c81e35bc17d7a14e30ab593e6", size = 794911, upload-time = "2026-01-07T18:03:52.701Z" },
+    { url = "https://files.pythonhosted.org/packages/37/54/e00a5e517153f310a33132375159e42dceb12bee45b51b35aa0df14f1866/pymongo-4.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:2290909275c9b8f637b0a92eb9b89281e18a72922749ebb903403ab6cc7da914", size = 804801, upload-time = "2026-01-07T18:03:57.671Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/0a/2572faf89195a944c99c6d756227019c8c5f4b5658ecc261c303645dfe69/pymongo-4.16.0-cp310-cp310-win_arm64.whl", hash = "sha256:6af1aaa26f0835175d2200e62205b78e7ec3ffa430682e322cc91aaa1a0dbf28", size = 797579, upload-time = "2026-01-07T18:03:59.1Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3a/907414a763c4270b581ad6d960d0c6221b74a70eda216a1fdd8fa82ba89f/pymongo-4.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6f2077ec24e2f1248f9cac7b9a2dfb894e50cc7939fcebfb1759f99304caabef", size = 862561, upload-time = "2026-01-07T18:04:00.628Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/58/787d8225dd65cb2383c447346ea5e200ecfde89962d531111521e3b53018/pymongo-4.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4d4f7ba040f72a9f43a44059872af5a8c8c660aa5d7f90d5344f2ed1c3c02721", size = 862923, upload-time = "2026-01-07T18:04:02.213Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a7/cc2865aae32bc77ade7b35f957a58df52680d7f8506f93c6edbf458e5738/pymongo-4.16.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8a0f73af1ea56c422b2dcfc0437459148a799ef4231c6aee189d2d4c59d6728f", size = 1426779, upload-time = "2026-01-07T18:04:03.942Z" },
+    { url = "https://files.pythonhosted.org/packages/81/25/3e96eb7998eec05382174da2fefc58d28613f46bbdf821045539d0ed60ab/pymongo-4.16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa30cd16ddd2f216d07ba01d9635c873e97ddb041c61cf0847254edc37d1c60e", size = 1454207, upload-time = "2026-01-07T18:04:05.387Z" },
+    { url = "https://files.pythonhosted.org/packages/86/7b/8e817a7df8c5d565d39dd4ca417a5e0ef46cc5cc19aea9405f403fec6449/pymongo-4.16.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d638b0b1b294d95d0fdc73688a3b61e05cc4188872818cd240d51460ccabcb5", size = 1511654, upload-time = "2026-01-07T18:04:08.458Z" },
+    { url = "https://files.pythonhosted.org/packages/39/7a/50c4d075ccefcd281cdcfccc5494caa5665b096b85e65a5d6afabb80e09e/pymongo-4.16.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:21d02cc10a158daa20cb040985e280e7e439832fc6b7857bff3d53ef6914ad50", size = 1496794, upload-time = "2026-01-07T18:04:10.355Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/cd/ebdc1aaca5deeaf47310c369ef4083e8550e04e7bf7e3752cfb7d95fcdb8/pymongo-4.16.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4fbb8d3552c2ad99d9e236003c0b5f96d5f05e29386ba7abae73949bfebc13dd", size = 1448371, upload-time = "2026-01-07T18:04:11.76Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/c9/50fdd78c37f68ea49d590c027c96919fbccfd98f3a4cb39f84f79970bd37/pymongo-4.16.0-cp311-cp311-win32.whl", hash = "sha256:be1099a8295b1a722d03fb7b48be895d30f4301419a583dcf50e9045968a041c", size = 841024, upload-time = "2026-01-07T18:04:13.522Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/dd/a3aa1ade0cf9980744db703570afac70a62c85b432c391dea0577f6da7bb/pymongo-4.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:61567f712bda04c7545a037e3284b4367cad8d29b3dec84b4bf3b2147020a75b", size = 855838, upload-time = "2026-01-07T18:04:14.923Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/10/9ad82593ccb895e8722e4884bad4c5ce5e8ff6683b740d7823a6c2bcfacf/pymongo-4.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:c53338613043038005bf2e41a2fafa08d29cdbc0ce80891b5366c819456c1ae9", size = 845007, upload-time = "2026-01-07T18:04:17.099Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/03/6dd7c53cbde98de469a3e6fb893af896dca644c476beb0f0c6342bcc368b/pymongo-4.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bd4911c40a43a821dfd93038ac824b756b6e703e26e951718522d29f6eb166a8", size = 917619, upload-time = "2026-01-07T18:04:19.173Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e1/328915f2734ea1f355dc9b0e98505ff670f5fab8be5e951d6ed70971c6aa/pymongo-4.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25a6b03a68f9907ea6ec8bc7cf4c58a1b51a18e23394f962a6402f8e46d41211", size = 917364, upload-time = "2026-01-07T18:04:20.861Z" },
+    { url = "https://files.pythonhosted.org/packages/41/fe/4769874dd9812a1bc2880a9785e61eba5340da966af888dd430392790ae0/pymongo-4.16.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:91ac0cb0fe2bf17616c2039dac88d7c9a5088f5cb5829b27c9d250e053664d31", size = 1686901, upload-time = "2026-01-07T18:04:22.219Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/8d/15707b9669fdc517bbc552ac60da7124dafe7ac1552819b51e97ed4038b4/pymongo-4.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cf0ec79e8ca7077f455d14d915d629385153b6a11abc0b93283ed73a8013e376", size = 1723034, upload-time = "2026-01-07T18:04:24.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/af/3d5d16ff11d447d40c1472da1b366a31c7380d7ea2922a449c7f7f495567/pymongo-4.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2d0082631a7510318befc2b4fdab140481eb4b9dd62d9245e042157085da2a70", size = 1797161, upload-time = "2026-01-07T18:04:25.964Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/04/725ab8664eeec73ec125b5a873448d80f5d8cf2750aaaf804cbc538a50a5/pymongo-4.16.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85dc2f3444c346ea019a371e321ac868a4fab513b7a55fe368f0cc78de8177cc", size = 1780938, upload-time = "2026-01-07T18:04:28.745Z" },
+    { url = "https://files.pythonhosted.org/packages/22/50/dd7e9095e1ca35f93c3c844c92eb6eb0bc491caeb2c9bff3b32fe3c9b18f/pymongo-4.16.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dabbf3c14de75a20cc3c30bf0c6527157224a93dfb605838eabb1a2ee3be008d", size = 1714342, upload-time = "2026-01-07T18:04:30.331Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c9/542776987d5c31ae8e93e92680ea2b6e5a2295f398b25756234cabf38a39/pymongo-4.16.0-cp312-cp312-win32.whl", hash = "sha256:60307bb91e0ab44e560fe3a211087748b2b5f3e31f403baf41f5b7b0a70bd104", size = 887868, upload-time = "2026-01-07T18:04:32.124Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/d4/b4045a7ccc5680fb496d01edf749c7a9367cc8762fbdf7516cf807ef679b/pymongo-4.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:f513b2c6c0d5c491f478422f6b5b5c27ac1af06a54c93ef8631806f7231bd92e", size = 907554, upload-time = "2026-01-07T18:04:33.685Z" },
+    { url = "https://files.pythonhosted.org/packages/60/4c/33f75713d50d5247f2258405142c0318ff32c6f8976171c4fcae87a9dbdf/pymongo-4.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:dfc320f08ea9a7ec5b2403dc4e8150636f0d6150f4b9792faaae539c88e7db3b", size = 892971, upload-time = "2026-01-07T18:04:35.594Z" },
+    { url = "https://files.pythonhosted.org/packages/47/84/148d8b5da8260f4679d6665196ae04ab14ffdf06f5fe670b0ab11942951f/pymongo-4.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d15f060bc6d0964a8bb70aba8f0cb6d11ae99715438f640cff11bbcf172eb0e8", size = 972009, upload-time = "2026-01-07T18:04:38.303Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/5e/9f3a8daf583d0adaaa033a3e3e58194d2282737dc164014ff33c7a081103/pymongo-4.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4a19ea46a0fe71248965305a020bc076a163311aefbaa1d83e47d06fa30ac747", size = 971784, upload-time = "2026-01-07T18:04:39.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/f2/b6c24361fcde24946198573c0176406bfd5f7b8538335f3d939487055322/pymongo-4.16.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:311d4549d6bf1f8c61d025965aebb5ba29d1481dc6471693ab91610aaffbc0eb", size = 1947174, upload-time = "2026-01-07T18:04:41.368Z" },
+    { url = "https://files.pythonhosted.org/packages/47/1a/8634192f98cf740b3d174e1018dd0350018607d5bd8ac35a666dc49c732b/pymongo-4.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46ffb728d92dd5b09fc034ed91acf5595657c7ca17d4cf3751322cd554153c17", size = 1991727, upload-time = "2026-01-07T18:04:42.965Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/2f/0c47ac84572b28e23028a23a3798a1f725e1c23b0cf1c1424678d16aff42/pymongo-4.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:acda193f440dd88c2023cb00aa8bd7b93a9df59978306d14d87a8b12fe426b05", size = 2082497, upload-time = "2026-01-07T18:04:44.652Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/57/9f46ef9c862b2f0cf5ce798f3541c201c574128d31ded407ba4b3918d7b6/pymongo-4.16.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5d9fdb386cf958e6ef6ff537d6149be7edb76c3268cd6833e6c36aa447e4443f", size = 2064947, upload-time = "2026-01-07T18:04:46.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/5421c0998f38e32288100a07f6cb2f5f9f352522157c901910cb2927e211/pymongo-4.16.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:91899dd7fb9a8c50f09c3c1cf0cb73bfbe2737f511f641f19b9650deb61c00ca", size = 1980478, upload-time = "2026-01-07T18:04:48.017Z" },
+    { url = "https://files.pythonhosted.org/packages/92/93/bfc448d025e12313a937d6e1e0101b50cc9751636b4b170e600fe3203063/pymongo-4.16.0-cp313-cp313-win32.whl", hash = "sha256:2cd60cd1e05de7f01927f8e25ca26b3ea2c09de8723241e5d3bcfdc70eaff76b", size = 934672, upload-time = "2026-01-07T18:04:49.538Z" },
+    { url = "https://files.pythonhosted.org/packages/96/10/12710a5e01218d50c3dd165fd72c5ed2699285f77348a3b1a119a191d826/pymongo-4.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3ead8a0050c53eaa55935895d6919d393d0328ec24b2b9115bdbe881aa222673", size = 959237, upload-time = "2026-01-07T18:04:51.382Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/56/d288bcd1d05bc17ec69df1d0b1d67bc710c7c5dbef86033a5a4d2e2b08e6/pymongo-4.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:dbbc5b254c36c37d10abb50e899bc3939bbb7ab1e7c659614409af99bd3e7675", size = 940909, upload-time = "2026-01-07T18:04:52.904Z" },
+]
+
 [[package]]
 name = "pypdf"
 version = "6.5.0"