OpenRAG 0.4.1.dev15__py3-none-any.whl → 0.4.1.dev16__py3-none-any.whl

api/settings.py

@@ -1,3 +1,4 @@
+from dependencies import get_models_service
 import asyncio
 import json
 import platform
@@ -9,7 +10,6 @@ from utils.telemetry import TelemetryClient, Category, MessageId
 from utils.version_utils import OPENRAG_VERSION
 from config.settings import (
     DEFAULT_DOCS_URL,
-    DISABLE_INGEST_WITH_LANGFLOW,
     INGEST_SAMPLE_DATA,
     LANGFLOW_URL,
     LANGFLOW_CHAT_FLOW_ID,
@@ -885,6 +885,7 @@ async def onboarding(
     flows_service=Depends(get_flows_service),
     session_manager=Depends(get_session_manager),
     document_service=Depends(get_document_service),
+    models_service=Depends(get_models_service),
     task_service=Depends(get_task_service),
     langflow_file_service=Depends(get_langflow_file_service),
     knowledge_filter_service=Depends(get_knowledge_filter_service),
@@ -936,7 +937,7 @@ async def onboarding(
         embedding_model_selected = None
         embedding_provider_selected = None
 
-        if body.embedding_model and not DISABLE_INGEST_WITH_LANGFLOW:
+        if body.embedding_model:
             embedding_model_selected = body.embedding_model.strip()
             current_config.knowledge.embedding_model = embedding_model_selected
             config_updated = True
@@ -1151,8 +1152,12 @@ async def onboarding(
                     # Import the function here to avoid circular imports
                     from main import ingest_default_documents_when_ready
 
+                    if not config_manager.save_config_file(current_config):
+                        logger.error("Failed to save embedding model to config")
+
                     task_id = await ingest_default_documents_when_ready(
                         document_service,
+                        models_service,
                         task_service,
                         langflow_file_service,
                         session_manager,
@@ -1888,6 +1893,7 @@ async def update_docling_preset(
 async def refresh_openrag_docs(
     document_service=Depends(get_document_service),
     task_service=Depends(get_task_service),
+    models_service=Depends(get_models_service),
     langflow_file_service=Depends(get_langflow_file_service),
     session_manager=Depends(get_session_manager),
     user: User = Depends(get_current_user),
@@ -1898,6 +1904,7 @@ async def refresh_openrag_docs(
 
         refreshed = await refresh_default_openrag_docs(
             document_service=document_service,
+            models_service=models_service,
             task_service=task_service,
             langflow_file_service=langflow_file_service,
             session_manager=session_manager,

api/upload.py

@@ -1,3 +1,4 @@
+from dependencies import get_models_service
 import os
 from typing import Optional
 from urllib.parse import urlparse
@@ -35,15 +36,10 @@ async def upload(
     try:
 
         from config.settings import is_no_auth_mode
-
-        if is_no_auth_mode():
-            owner_user_id = None
-            owner_name = None
-            owner_email = None
-        else:
-            owner_user_id = user.user_id
-            owner_name = user.name
-            owner_email = user.email
+        is_no_auth = is_no_auth_mode()
+        owner_user_id = user.user_id if (user and not is_no_auth) else None
+        owner_name = user.name if user else None
+        owner_email = user.email if user else None
 
         result = await document_service.process_upload_file(
             file,
@@ -84,15 +80,10 @@ async def upload_path(
     jwt_token = user.jwt_token
 
     from config.settings import is_no_auth_mode
-
-    if is_no_auth_mode():
-        owner_user_id = None
-        owner_name = None
-        owner_email = None
-    else:
-        owner_user_id = user.user_id
-        owner_name = user.name
-        owner_email = user.email
+    is_no_auth = is_no_auth_mode()
+    owner_user_id = user.user_id if (user and not is_no_auth) else None
+    owner_name = user.name if user else None
+    owner_email = user.email if user else None
 
     from api.documents import _ensure_index_exists
     await _ensure_index_exists()
@@ -163,6 +154,7 @@ async def upload_options(
 async def upload_bucket(
     body: UploadBucketBody,
     task_service=Depends(get_task_service),
+    models_service=Depends(get_models_service),
     session_manager=Depends(get_session_manager),
     user: User = Depends(get_current_user),
 ):
@@ -194,18 +186,13 @@ async def upload_bucket(
     jwt_token = user.jwt_token
 
     from models.processors import S3FileProcessor
-    from config.settings import is_no_auth_mode
 
-    if is_no_auth_mode():
-        owner_user_id = None
-        owner_name = None
-        owner_email = None
-        task_user_id = None
-    else:
-        owner_user_id = user.user_id
-        owner_name = user.name
-        owner_email = user.email
-        task_user_id = user.user_id
+    from config.settings import is_no_auth_mode
+    is_no_auth = is_no_auth_mode()
+    owner_user_id = user.user_id if (user and not is_no_auth) else None
+    owner_name = user.name if user else None
+    owner_email = user.email if user else None
+    task_user_id = user.user_id if (user and not is_no_auth) else None
 
     from api.documents import _ensure_index_exists
     await _ensure_index_exists()
@@ -213,6 +200,7 @@ async def upload_bucket(
     processor = S3FileProcessor(
         task_service.document_service,
         bucket,
+        models_service=models_service,
         s3_client=s3_client,
         owner_user_id=owner_user_id,
         jwt_token=jwt_token,

config/embedding_constants.py

@@ -0,0 +1,4 @@
+"""Embedding model constants."""
+
+OPENAI_DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small"
+OPENAI_EMBEDDING_MODEL_PREFIX = "text-embedding"

config/model_constants.py

@@ -31,8 +31,6 @@ OPENAI_VALIDATION_MODELS = [
 ]
 
 OPENAI_DEFAULT_LANGUAGE_MODEL = "gpt-4o"
-OPENAI_DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small"
-OPENAI_EMBEDDING_MODEL_PREFIX = "text-embedding"
 
 ANTHROPIC_DEFAULT_LANGUAGE_MODEL = "claude-sonnet-4-5-20250929"
 

config/settings.py

@@ -1,12 +1,16 @@
 import asyncio
 import os
+import threading
+import concurrent.futures
 from utils.env_utils import get_env_int, get_env_float
 
 import httpx
+from agentd.patch import patch_openai_with_mcp
 from dotenv import load_dotenv
 from openai import AsyncOpenAI
 from opensearchpy import AsyncOpenSearch
 from opensearchpy._async.http_aiohttp import AIOHttpConnection
+from config.embedding_constants import OPENAI_DEFAULT_EMBEDDING_MODEL
 
 from utils.container_utils import get_container_host
 from utils.logging_config import get_logger
@@ -106,26 +110,6 @@ WEBHOOK_BASE_URL = os.getenv(
 VECTOR_DIM = 1536
 KNN_EF_CONSTRUCTION = 100
 KNN_M = 16
-EMBED_MODEL = "text-embedding-3-small"
-
-OPENAI_EMBEDDING_DIMENSIONS = {
-        "text-embedding-3-small": 1536,
-        "text-embedding-3-large": 3072,
-        "text-embedding-ada-002": 1536,
-    }
-
-WATSONX_EMBEDDING_DIMENSIONS = {
-# IBM Models
-"ibm/granite-embedding-107m-multilingual": 384,
-"ibm/granite-embedding-278m-multilingual": 1024,
-"ibm/slate-125m-english-rtrvr": 768,
-"ibm/slate-125m-english-rtrvr-v2": 768,
-"ibm/slate-30m-english-rtrvr": 384,
-"ibm/slate-30m-english-rtrvr-v2": 384,
-# Third Party Models
-"intfloat/multilingual-e5-large": 1024,
-"sentence-transformers/all-minilm-l6-v2": 384,
-}
 
 INDEX_BODY = {
     "settings": {
@@ -319,7 +303,7 @@ class AppClients:
         self.langflow_client = None
         self.langflow_http_client = None
         self._patched_async_client = None  # Private attribute - single client for all providers
-        self._client_init_lock = __import__('threading').Lock()  # Lock for thread-safe initialization
+        self._client_init_lock = threading.Lock()  # Lock for thread-safe initialization
         self.docling_http_client = None
 
     async def initialize(self):
@@ -454,6 +438,11 @@ class AppClients:
                 if config.providers.openai.api_key:
                     os.environ["OPENAI_API_KEY"] = config.providers.openai.api_key
                     logger.debug("Loaded OpenAI API key from config")
+                elif not os.environ.get("OPENAI_API_KEY"):
+                    # Provide dummy key to satisfy AsyncOpenAI constructor; 
+                    # LiteLLM/MCP will handle routing to other providers if needed.
+                    os.environ["OPENAI_API_KEY"] = "no-key-required"
+                    logger.debug("Using dummy OpenAI API key to satisfy client constructor")
 
                 # Set Anthropic credentials
                 if config.providers.anthropic.api_key:
@@ -477,14 +466,23 @@ class AppClients:
                     os.environ["OLLAMA_ENDPOINT"] = config.providers.ollama.endpoint
                     logger.debug("Loaded Ollama endpoint from config")
 
+                # Determine model and provider for both probe and production client
+                model_name = config.knowledge.embedding_model or OPENAI_DEFAULT_EMBEDDING_MODEL
+                provider = config.knowledge.embedding_provider or "openai"
             except Exception as e:
                 logger.debug("Could not load provider credentials from config", error=str(e))
+                # Provide fallbacks if config loading failed
+                model_name = OPENAI_DEFAULT_EMBEDDING_MODEL
+                provider = "openai"
+                # Ensure a dummy key is available to satisfy the AsyncOpenAI constructor
+                # and avoid AuthenticationError if config loading failed.
+                if not os.environ.get("OPENAI_API_KEY"):
+                    os.environ["OPENAI_API_KEY"] = "no-key-required"
+                    logger.debug("Using dummy OpenAI API key fallback (config load failed)")
+
 
-            # Try to initialize the client - AsyncOpenAI() will read from environment
-            # We'll try HTTP/2 first with a probe, then fall back to HTTP/1.1 if it times out
-            import asyncio
-            import concurrent.futures
-            import threading
+            # API key for AsyncOpenAI constructor
+            api_key = os.environ.get("OPENAI_API_KEY")
 
             async def probe_http2():
                 """Returns True if HTTP/2 works, False to fall back to HTTP/1.1.
@@ -494,20 +492,21 @@ class AppClients:
                 production client is created after this thread exits, in the
                 caller's event loop, avoiding cross-loop SSL transport errors.
                 """
-                client = AsyncOpenAI()
-                logger.info("Probing OpenAI client with HTTP/2...")
+                # Use a standard OpenAI client for the probe (only runs for OpenAI provider)
+                client = AsyncOpenAI(api_key=api_key)
+                logger.info(f"Probing client with HTTP/2 using model {model_name}...")
                 try:
                     await asyncio.wait_for(
                         client.embeddings.create(
-                            model='text-embedding-3-small',
+                            model=model_name,
                             input=['test']
                         ),
                         timeout=5.0
                     )
-                    logger.info("HTTP/2 probe successful")
+                    logger.info(f"HTTP/2 probe successful with {model_name}")
                     return True
                 except (asyncio.TimeoutError, Exception) as probe_error:
-                    logger.warning("HTTP/2 probe failed, falling back to HTTP/1.1", error=str(probe_error))
+                    logger.warning(f"HTTP/2 probe failed with {model_name}, falling back to HTTP/1.1", error=str(probe_error))
                     return False
                 finally:
                     # Always close the probe client so its connections are fully
@@ -527,24 +526,32 @@ class AppClients:
                     loop.close()
 
             try:
-                # Run the probe in a separate thread with its own event loop.
-                # Only the probe result (bool) crosses the thread boundary;
-                # the production client is created here so its connections are
-                # bound to the caller's event loop, not the (now closed) probe loop.
-                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
-                    future = executor.submit(run_probe_in_thread)
-                    use_http2 = future.result(timeout=15)
+                # Run the probe only for OpenAI provider; local and other providers
+                # (Ollama, WatsonX) typically use HTTP/1.1 for reliability.
+                if provider.lower() == "openai":
+                    # Run the probe in a separate thread with its own event loop.
+                    # Only the probe result (bool) crosses the thread boundary;
+                    # the production client is created here so its connections are
+                    # bound to the caller's event loop, not the (now closed) probe loop.
+                    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                        future = executor.submit(run_probe_in_thread)
+                        use_http2 = future.result(timeout=15)
+                else:
+                    use_http2 = False
+                    logger.debug(f"Skipping HTTP/2 probe for provider: {provider}")
 
                 if use_http2:
-                    self._patched_async_client = AsyncOpenAI()
-                    logger.info("OpenAI client initialized with HTTP/2")
+                    self._patched_async_client = patch_openai_with_mcp(AsyncOpenAI(api_key=api_key))
+                    logger.info(f"OpenAI-compatible client initialized with HTTP/2 (model: {model_name})")
                 else:
                     http_client = httpx.AsyncClient(
                         http2=False,
                         timeout=httpx.Timeout(60.0, connect=10.0)
                     )
-                    self._patched_async_client = AsyncOpenAI(http_client=http_client)
-                    logger.info("OpenAI client initialized with HTTP/1.1 (fallback)")
+                    self._patched_async_client = patch_openai_with_mcp(
+                        AsyncOpenAI(api_key=api_key, http_client=http_client)
+                    )
+                    logger.info(f"OpenAI-compatible client initialized with HTTP/1.1 fallback (model: {model_name})")
                 logger.info("Successfully initialized OpenAI client")
             except Exception as e:
                 logger.error(f"Failed to initialize OpenAI client: {e.__class__.__name__}: {str(e)}")
@@ -861,7 +868,7 @@ def get_openrag_config():
 # Expose configuration settings for backward compatibility and easy access
 def get_provider_config():
     """Get provider configuration."""
-    return get_openrag_config().provider
+    return get_openrag_config().providers
 
 
 def get_knowledge_config():
@@ -876,7 +883,7 @@ def get_agent_config():
 
 def get_embedding_model() -> str:
     """Return the currently configured embedding model."""
-    return get_openrag_config().knowledge.embedding_model or EMBED_MODEL if DISABLE_INGEST_WITH_LANGFLOW else ""
+    return get_openrag_config().knowledge.embedding_model or (OPENAI_DEFAULT_EMBEDDING_MODEL if DISABLE_INGEST_WITH_LANGFLOW else "")
 
 
 def get_index_name() -> str:

connectors/service.py

@@ -20,6 +20,8 @@ class ConnectorService:
         index_name: str,
         task_service=None,
         session_manager=None,
+        models_service=None,
+        document_service=None,
     ):
         self.clients = patched_async_client
         self.embed_model = embed_model
@@ -27,6 +29,8 @@ class ConnectorService:
         self.task_service = task_service
         self.session_manager = session_manager
         self.connection_manager = ConnectionManager()
+        self.models_service = models_service
+        self.document_service = document_service
 
     async def initialize(self):
         """Initialize the service by loading existing connections"""
@@ -57,18 +61,12 @@ class ConnectorService:
             with open(tmp_path, "wb") as f:
                 f.write(document.content)
 
-            # Use existing process_file_common function with connector document metadata
-            # We'll use the document service's process_file_common method
-            from services.document_service import DocumentService
-
-            doc_service = DocumentService(session_manager=self.session_manager)
-
             logger.debug("Processing connector document", document_id=document.id)
 
             # Process using consolidated processing pipeline
             from models.processors import TaskProcessor
 
-            processor = TaskProcessor(document_service=doc_service)
+            processor = TaskProcessor(document_service=self.document_service, models_service=self.models_service)
             result = await processor.process_document_standard(
                 file_path=tmp_path,
                 file_hash=document.id,  # Use connector document ID as hash
@@ -284,6 +282,7 @@ class ConnectorService:
                 if self.task_service and self.task_service.document_service
                 else DocumentService(session_manager=self.session_manager)
             ),
+            models_service=self.models_service,
         )
 
         # Use file IDs as items (no more fake file paths!)
@@ -415,6 +414,7 @@ class ConnectorService:
                 if self.task_service and self.task_service.document_service
                 else DocumentService(session_manager=self.session_manager)
             ),
+            models_service=self.models_service,
         )
 
         # Create custom task using TaskService

main.py

@@ -15,7 +15,7 @@ from connectors.langflow_connector_service import LangflowConnectorService
 from connectors.service import ConnectorService
 from services.flows_service import FlowsService
 from utils.container_utils import detect_container_environment
-from utils.embeddings import create_dynamic_index_body
+from utils.embeddings import create_index_body
 from utils.logging_config import configure_from_env, get_logger
 from utils.telemetry import TelemetryClient, Category, MessageId
 from fastapi import FastAPI, Request
@@ -100,7 +100,7 @@ from services.knowledge_filter_service import KnowledgeFilterService
 from services.langflow_file_service import LangflowFileService
 from services.models_service import ModelsService
 from services.monitor_service import MonitorService
-from services.search_service import SearchService
+from services.search_service import SearchService, register_search_service
 from services.task_service import TaskService
 from session_manager import SessionManager
 
@@ -221,22 +221,15 @@ async def init_index():
         # Get the configured embedding model from user configuration
         config = get_openrag_config()
         embedding_model = config.knowledge.embedding_model
-        embedding_provider = config.knowledge.embedding_provider
-        embedding_provider_config = config.get_embedding_provider_config()
-
-        # Create dynamic index body based on the configured embedding model
-        # Pass provider and endpoint for dynamic dimension resolution (Ollama probing)
-        dynamic_index_body = await create_dynamic_index_body(
-            embedding_model,
-            provider=embedding_provider,
-            endpoint=getattr(embedding_provider_config, "endpoint", None),
-        )
+
+        # Create index body
+        index_body = await create_index_body()
 
         # Create documents index
         index_name = get_index_name()
         if not await clients.opensearch.indices.exists(index=index_name):
             await clients.opensearch.indices.create(
-                index=index_name, body=dynamic_index_body
+                index=index_name, body=index_body
             )
             logger.info(
                 "Created OpenSearch index",
@@ -435,7 +428,7 @@ def _should_use_url_default_docs_ingest() -> bool:
 
 
 async def ingest_openrag_docs_when_ready(
-    document_service, task_service, langflow_file_service, session_manager
+    document_service, models_service, task_service, langflow_file_service, session_manager
 ):
     """Ingest OpenRAG docs during onboarding."""
     use_url_ingest = _should_use_url_default_docs_ingest()
@@ -448,6 +441,7 @@ async def ingest_openrag_docs_when_ready(
             if DISABLE_INGEST_WITH_LANGFLOW:
                 task_id = await _ingest_default_documents_url(
                     document_service=document_service,
+                    models_service=models_service,
                     docs_url=DEFAULT_DOCS_URL,
                     crawl_depth=DEFAULT_DOCS_CRAWL_DEPTH,
                 )
@@ -475,7 +469,7 @@ async def ingest_openrag_docs_when_ready(
 
 
 async def ingest_default_documents_when_ready(
-    document_service, task_service, langflow_file_service, session_manager
+    document_service, models_service, task_service, langflow_file_service, session_manager
 ):
     """Ingest default OpenRAG docs during onboarding."""
     try:
@@ -487,11 +481,10 @@ async def ingest_default_documents_when_ready(
         await TelemetryClient.send_event(
             Category.DOCUMENT_INGESTION, MessageId.ORB_DOC_DEFAULT_START
         )
-        task_id = None
-        if _should_use_url_default_docs_ingest():
-            task_id = await ingest_openrag_docs_when_ready(
-                document_service, task_service, langflow_file_service, session_manager
-            )
+
+        task_id = await ingest_openrag_docs_when_ready(
+            document_service, models_service, task_service, langflow_file_service, session_manager
+        )
 
         base_dir = _get_documents_dir()
         if not os.path.isdir(base_dir):
@@ -515,7 +508,7 @@ async def ingest_default_documents_when_ready(
 
         if DISABLE_INGEST_WITH_LANGFLOW:
             new_task_id = await _ingest_default_documents_openrag(
-                document_service, task_service, file_paths, existing_task_id=task_id, connector_type="local"
+                document_service, models_service, task_service, file_paths, existing_task_id=task_id, connector_type="local"
             )
             task_id = new_task_id or task_id
         else:
@@ -670,6 +663,7 @@ async def _ingest_default_documents_url_langflow(
 
 async def _ingest_default_documents_url(
     document_service,
+    models_service,
     docs_url: str,
     crawl_depth: int,
 ):
@@ -690,12 +684,17 @@ async def _ingest_default_documents_url(
         from models.processors import DocumentFileProcessor
         from utils.hash_utils import hash_id
 
+        from session_manager import AnonymousUser
+
+        anonymous_user = AnonymousUser()
+
         processor = DocumentFileProcessor(
             document_service,
+            models_service=models_service,
             owner_user_id=None,
             jwt_token=None,
-            owner_name=None,
-            owner_email=None,
+            owner_name=anonymous_user.name,
+            owner_email=anonymous_user.email,
             is_sample_data=True,
             connector_type="openrag_docs",
         )
@@ -705,8 +704,8 @@ async def _ingest_default_documents_url(
             owner_user_id=None,
             original_filename="openrag-url-default.txt",
             jwt_token=None,
-            owner_name=None,
-            owner_email=None,
+            owner_name=anonymous_user.name,
+            owner_email=anonymous_user.email,
             file_size=os.path.getsize(temp_file_path),
             connector_type="openrag_docs",
             is_sample_data=True,
@@ -801,16 +800,6 @@ async def _delete_existing_default_docs(session_manager, connector_type: str):
                             ]
                         }
                     },
-                    # Legacy file-based default docs were ingested as local and
-                    # marked with is_sample_data=true.
-                    {
-                        "bool": {
-                            "must": [
-                                {"term": {"connector_type": "local"}},
-                                {"term": {"is_sample_data": "true"}},
-                            ]
-                        }
-                    },
                 ],
                 "minimum_should_match": 1,
             }
@@ -829,6 +818,7 @@ async def _delete_existing_default_docs(session_manager, connector_type: str):
 
 async def _reingest_default_docs_on_upgrade_if_needed(
     document_service,
+    models_service,
     task_service,
     langflow_file_service,
     session_manager,
@@ -857,6 +847,7 @@ async def _reingest_default_docs_on_upgrade_if_needed(
     await _delete_existing_default_docs(session_manager, connector_type="openrag_docs")
     await ingest_openrag_docs_when_ready(
         document_service,
+        models_service,
         task_service,
         langflow_file_service,
         session_manager,
@@ -926,6 +917,7 @@ async def _get_remote_docs_signature(docs_url: str):
 
 async def refresh_default_openrag_docs(
     document_service,
+    models_service,
     task_service,
     langflow_file_service,
     session_manager,
@@ -1015,6 +1007,7 @@ async def refresh_default_openrag_docs(
         await _delete_existing_default_docs(session_manager, connector_type="openrag_docs")
         await ingest_openrag_docs_when_ready(
             document_service,
+            models_service,
             task_service,
             langflow_file_service,
             session_manager,
@@ -1075,7 +1068,7 @@ async def opensearch_health_ready(request):
 
 
 async def _ingest_default_documents_openrag(
-    document_service, task_service, file_paths, existing_task_id: str = None, connector_type: str = "openrag_docs"
+    document_service, models_service, task_service, file_paths, existing_task_id: str = None, connector_type: str = "openrag_docs"
 ):
     """Ingest default documents using traditional OpenRAG processor."""
     logger.info(
@@ -1086,12 +1079,16 @@ async def _ingest_default_documents_openrag(
     # Build a processor that DOES NOT set 'owner' on documents (owner_user_id=None)
     from models.processors import DocumentFileProcessor
 
+    from session_manager import AnonymousUser
+    anonymous_user = AnonymousUser()
+
     processor = DocumentFileProcessor(
         document_service,
+        models_service=models_service,
         owner_user_id=None,
         jwt_token=None,
-        owner_name=None,
-        owner_email=None,
+        owner_name=anonymous_user.name,
+        owner_email=anonymous_user.email,
         is_sample_data=True,  # Mark as sample data
         connector_type=connector_type,
     )
@@ -1174,6 +1171,19 @@ async def startup_tasks(services):
     await TelemetryClient.send_event(
         Category.APPLICATION_STARTUP, MessageId.ORB_APP_START_INIT
     )
+
+    # Update model registry to allow further search calls to be instant
+    try:
+        models_service = services["models_service"]
+        await models_service.update_model_registry()
+    except Exception as e:
+        logger.error(
+            "Failed to update model registry at startup — "
+            "models may be missing until the next restart",
+            error=str(e),
+        )
+
+
     # Only initialize basic OpenSearch connection, not the index
     # Index will be created after onboarding when we know the embedding model
     await wait_for_opensearch()
@@ -1216,6 +1226,7 @@ async def startup_tasks(services):
     try:
         upgrade_reingested = await _reingest_default_docs_on_upgrade_if_needed(
             services["document_service"],
+            services["models_service"],
             services["task_service"],
             services["langflow_file_service"],
             services["session_manager"],
@@ -1227,6 +1238,7 @@ async def startup_tasks(services):
         try:
             await refresh_default_openrag_docs(
                 services["document_service"],
+                services["models_service"],
                 services["task_service"],
                 services["langflow_file_service"],
                 services["session_manager"],
@@ -1316,13 +1328,14 @@ async def initialize_services():
     session_manager = SessionManager(SESSION_SECRET)
 
     # Initialize services
-    document_service = DocumentService(session_manager=session_manager)
-    search_service = SearchService(session_manager)
-    task_service = TaskService(document_service, ingestion_timeout=INGESTION_TIMEOUT)
+    models_service = ModelsService()
+    document_service = DocumentService(session_manager=session_manager, models_service=models_service)
+    search_service = SearchService(session_manager, models_service)
+    register_search_service(search_service)
+    task_service = TaskService(document_service, models_service, ingestion_timeout=INGESTION_TIMEOUT)
     flows_service = FlowsService()
     chat_service = ChatService(flows_service=flows_service)
     knowledge_filter_service = KnowledgeFilterService(session_manager)
-    models_service = ModelsService()
     monitor_service = MonitorService(session_manager)
     langflow_file_service = LangflowFileService(flows_service=flows_service)
 
@@ -1337,6 +1350,8 @@ async def initialize_services():
         index_name=get_index_name(),
         task_service=task_service,
         session_manager=session_manager,
+        models_service=models_service,
+        document_service=document_service,
     )
 
     # Create connector router that chooses based on configuration