openrag 0.4.1.dev14__tar.gz → 0.4.1.dev16__tar.gz

{openrag-0.4.1.dev14/src/openrag.egg-info → openrag-0.4.1.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.4.1.dev14
+Version: 0.4.1.dev16
 Summary: OpenRAG is a comprehensive Retrieval-Augmented Generation platform that enables intelligent document search and AI-powered conversations.
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
@@ -15,6 +15,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: agentd>=0.8.1
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: cryptography>=45.0.6
 Requires-Dist: google-api-python-client>=2.143.0
@@ -36,9 +37,10 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: textual-fspicker>=0.6.0
 Requires-Dist: structlog>=25.4.0
 Requires-Dist: zxcvbn>=4.5.0
-Requires-Dist: openai>=1.0.0
+Requires-Dist: litellm==1.83.3
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tiktoken>=0.7.0
+Requires-Dist: openai>=2.30.0
 Dynamic: license-file
 
 <div align="center">

{openrag-0.4.1.dev14 → openrag-0.4.1.dev16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.4.1.dev14"
+version = "0.4.1.dev16"
 description = "OpenRAG is a comprehensive Retrieval-Augmented Generation platform that enables intelligent document search and AI-powered conversations."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -21,6 +21,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
+    "agentd>=0.8.1",
     "aiofiles>=24.1.0",
     "cryptography>=45.0.6",
     "google-api-python-client>=2.143.0",
@@ -42,9 +43,10 @@ dependencies = [
     "textual-fspicker>=0.6.0",
     "structlog>=25.4.0",
     "zxcvbn>=4.5.0",
-    "openai>=1.0.0",
+    "litellm==1.83.3",
     "pyyaml>=6.0",
     "tiktoken>=0.7.0",
+    "openai>=2.30.0",
 ]
 
 [dependency-groups]

{openrag-0.4.1.dev14 → openrag-0.4.1.dev16}/src/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,

{openrag-0.4.1.dev14 → openrag-0.4.1.dev16}/src/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,

openrag-0.4.1.dev16/src/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"

{openrag-0.4.1.dev14 → openrag-0.4.1.dev16}/src/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"
 

{openrag-0.4.1.dev14 → openrag-0.4.1.dev16}/src/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:

{openrag-0.4.1.dev14 → openrag-0.4.1.dev16}/src/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