Merge branch 'main' of https://github.com/arc53/DocsGPT into multimodal-clean

Author: riyo264

application/requirements.txt

@@ -13,12 +13,12 @@ onnxruntime>=1.19.0
 docx2txt==0.9
 ddgs>=8.0.0
 fast-ebook
-elevenlabs==2.41.0
+elevenlabs==2.43.0
 Flask==3.1.3
 faiss-cpu==1.13.2
-fastmcp==3.2.0
+fastmcp==3.2.4
 flask-restx==1.3.2
-google-genai==1.69.0
+google-genai==1.73.1
 google-api-python-client==2.193.0
 google-auth-httplib2==0.3.1
 google-auth-oauthlib==1.3.1
@@ -47,7 +47,7 @@ msal==1.35.1
 mypy-extensions==1.1.0
 networkx==3.6.1
 numpy==2.4.4
-openai==2.30.0
+openai==2.32.0
 openapi3-parser==1.1.22
 orjson==3.11.7
 packaging==26.0

application/storage/db/engine.py

@@ -16,7 +16,7 @@
 
 from typing import Optional
 
-from sqlalchemy import Engine, create_engine
+from sqlalchemy import Engine, create_engine, event
 
 from application.core.settings import settings
 
@@ -43,17 +43,17 @@ def _resolve_uri() -> str:
 #: Per-statement wall-clock cap applied to every connection handed out by
 #: the engine. 30s is generous for interactive hot paths (reads under a few
 #: hundred ms are normal) but still catches a runaway query before it
-#: stacks up on PgBouncer or holds locks indefinitely. Override by
-#: rebuilding the engine with a different ``connect_args`` in tests.
+#: stacks up on PgBouncer or holds locks indefinitely.
 STATEMENT_TIMEOUT_MS = 30_000
 
 
 def get_engine() -> Engine:
     """Return the process-wide SQLAlchemy Engine, creating it if needed.
 
     The engine applies a server-side ``statement_timeout`` to every
-    connection it hands out, so both :func:`db_session` and
-    :func:`db_readonly` inherit the same guardrail.
+    connection it hands out via a ``connect`` event, so both
+    :func:`db_session` and :func:`db_readonly` inherit the same
+    guardrail.
 
     Returns:
         A SQLAlchemy ``Engine`` configured with a pooled connection to
@@ -68,13 +68,20 @@ def get_engine() -> Engine:
             pool_pre_ping=True,     # survive PgBouncer / idle-disconnect recycles
             pool_recycle=1800,
             future=True,
-            connect_args={
-                # ``-c`` passes a GUC to the backend at connect time. This
-                # covers *all* sessions — interactive, Celery, seeder — so
-                # no route-handler can opt out by accident.
-                "options": f"-c statement_timeout={STATEMENT_TIMEOUT_MS}",
-            },
         )
+
+        @event.listens_for(_engine, "connect")
+        def _apply_session_guardrails(dbapi_conn, _record):
+            # Apply as a SQL ``SET`` (not a libpq ``options=-c ...``
+            # startup parameter) so the engine works behind
+            # PgBouncer-style poolers — notably Neon's ``-pooler``
+            # endpoint, which rejects startup options. Explicit
+            # ``commit()`` so the session-level SET survives SA's
+            # transaction resets on pool return.
+            with dbapi_conn.cursor() as cur:
+                cur.execute(f"SET statement_timeout = {STATEMENT_TIMEOUT_MS}")
+            dbapi_conn.commit()
+
     return _engine
 
 

application/vectorstore/mongodb.py

@@ -1,9 +1,23 @@
 import logging
+from functools import cached_property
+
 from application.core.settings import settings
 from application.vectorstore.base import BaseVectorStore
 from application.vectorstore.document_class import Document
 
 
+def _lazy_import_pymongo():
+    """Lazy import of pymongo so installations that don't use the MongoDB vectorstore don't need it."""
+    try:
+        import pymongo
+    except ImportError as exc:
+        raise ImportError(
+            "Could not import pymongo python package. "
+            "Please install it with `pip install pymongo`."
+        ) from exc
+    return pymongo
+
+
 class MongoDBVectorStore(BaseVectorStore):
     def __init__(
         self,
@@ -20,20 +34,23 @@ def __init__(
         self._embedding_key = embedding_key
         self._embeddings_key = embeddings_key
         self._mongo_uri = settings.MONGO_URI
+        self._database_name = database
+        self._collection_name = collection
         self._source_id = source_id.replace("application/indexes/", "").rstrip("/")
         self._embedding = self._get_embeddings(settings.EMBEDDINGS_NAME, embeddings_key)
 
-        try:
-            import pymongo
-        except ImportError:
-            raise ImportError(
-                "Could not import pymongo python package. "
-                "Please install it with `pip install pymongo`."
-            )
-
-        self._client = pymongo.MongoClient(self._mongo_uri)
-        self._database = self._client[database]
-        self._collection = self._database[collection]
+    @cached_property
+    def _client(self):
+        pymongo = _lazy_import_pymongo()
+        return pymongo.MongoClient(self._mongo_uri)
+
+    @cached_property
+    def _database(self):
+        return self._client[self._database_name]
+
+    @cached_property
+    def _collection(self):
+        return self._database[self._collection_name]
 
     def search(self, question, k=2, *args, **kwargs):
         query_vector = self._embedding.embed_query(question)