openrag 0.5.0.dev38__tar.gz → 0.5.1.dev2__tar.gz

{openrag-0.5.0.dev38/src/openrag.egg-info → openrag-0.5.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.5.0.dev38
+Version: 0.5.1.dev2
 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

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.5.0.dev38"
+version = "0.5.1.dev2"
 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"

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/agent.py

@@ -171,8 +171,16 @@ async def async_response_stream(
             try:
                 # Try to serialize the chunk object
                 if hasattr(chunk, "model_dump"):
-                    # Pydantic model
-                    chunk_data = chunk.model_dump()
+                    # Pydantic model. Exclude "delta" from serialization since Langflow's
+                    # /response SSE wraps text deltas as {"content": "..."} for every provider but
+                    # openai SDK's event models declare/expect delta to be str so model_dump() will
+                    # emit noisy logs (PydanticSerializationUnexpectedValue) for every chunk. Basically
+                    # just reattach the raw (unvalidated) value afterwards to preserve same shape.
+                    # TODO: replace this with just chunk.model_dump() if langflow's /response SSE matches openai's 
+                    # SDK's delta: str schema
+                    chunk_data = chunk.model_dump(exclude={"delta"})
+                    if hasattr(chunk, "delta"):
+                        chunk_data["delta"] = chunk.delta
                 elif hasattr(chunk, "__dict__"):
                     chunk_data = chunk.__dict__
                 else:

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/api/connectors.py

@@ -734,8 +734,8 @@ async def connector_sync(
             {
                 "task_ids": task_ids,
                 "status": "sync_started",
-                "message": f"Started syncing files from {len(active_connections)} {connector_type} connection(s)",
-                "connections_synced": len(active_connections),
+                "message": f"Started syncing files from 1 {connector_type} connection",
+                "connections_synced": len(task_ids),
             },
             status_code=201,
         )

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/api/settings.py

@@ -391,16 +391,27 @@ async def get_settings(
             environment=ENVIRONMENT or None,
         )
 
-    except Exception as e:
-        logger.error(f"Failed to retrieve settings: {str(e)}")
+    except Exception:
+        logger.exception("Failed to retrieve settings")
         return JSONResponse(
-            {"error": f"Failed to retrieve settings: {str(e)}"}, status_code=500
+            {"error": "Failed to retrieve settings"}, status_code=500
         )
 
 
+# Provider names in priority order. LLM supports anthropic; embeddings do not.
+_LLM_PROVIDER_NAMES = ("openai", "anthropic", "watsonx", "ollama")
+_EMBEDDING_PROVIDER_NAMES = ("openai", "watsonx", "ollama")
+
+
+def _configured_provider_names(config, provider_names) -> list:
+    """Return the provider names from `provider_names` marked configured in the OpenRAG config."""
+    providers = config.providers
+    return [name for name in provider_names if getattr(providers, name).configured]
+
+
 def _first_configured_llm_provider(config, excluding: str) -> str:
     """Return the first configured LLM provider that isn't `excluding`."""
-    for p in ["openai", "anthropic", "watsonx", "ollama"]:
+    for p in _LLM_PROVIDER_NAMES:
         if p != excluding and getattr(config.providers, p).configured:
             return p
     return "openai"
@@ -408,7 +419,7 @@ def _first_configured_llm_provider(config, excluding: str) -> str:
 
 def _first_configured_embedding_provider(config, excluding: str) -> str:
     """Return the first configured embedding provider (openai/watsonx/ollama) that isn't `excluding`."""
-    for p in ["openai", "watsonx", "ollama"]:
+    for p in _EMBEDDING_PROVIDER_NAMES:
         if p != excluding and getattr(config.providers, p).configured:
             return p
     return "openai"
@@ -1003,14 +1014,14 @@ async def update_settings(
         )
         return SettingsUpdateResponse(message="Configuration updated successfully")
 
-    except Exception as e:
-        logger.error("Failed to update settings", error=str(e))
+    except Exception:
+        logger.exception("Failed to update settings")
         await TelemetryClient.send_event(
             Category.SETTINGS_OPERATIONS,
             MessageId.ORB_SETTINGS_UPDATE_FAILED
         )
         return JSONResponse(
-            {"error": f"Failed to update settings: {str(e)}"}, status_code=500
+            {"error": "Failed to update settings"}, status_code=500
         )
 
 
@@ -1272,15 +1283,10 @@ async def onboarding(
                 admin_username = user.user_id if IBM_AUTH_ENABLED and user else None
                 await init_index(opensearch_client, admin_username=admin_username)
                 logger.info("OpenSearch index initialization completed successfully")
-            except Exception as e:
-                logger.error(
-                    "Failed to initialize OpenSearch index after onboarding",
-                    error=str(e),
-                )
+            except Exception:
+                logger.exception("Failed to initialize OpenSearch index after onboarding")
                 return JSONResponse(
-                    {
-                        "error": str(e),
-                    },
+                    {"Failed to initialize OpenSearch index after onboarding"},
                     status_code=500,
                 )
 
@@ -1643,14 +1649,31 @@ async def _update_langflow_model_values(config, flows_service, llm_model=None, l
             )
 
         if not (embedding_model or embedding_provider or llm_model or llm_provider):
+            # 1. Update ALL configured LLM providers.
+            # Regression fix (#1587): the no-argument fallback used by
+            # reapply_all_settings previously only reapplied embedding providers,
+            # leaving LLM model values unset whenever flows were reset.
+            llm_providers = _configured_provider_names(config, _LLM_PROVIDER_NAMES)
+
+            current_llm_provider = config.agent.llm_provider.lower()
+            for provider in llm_providers:
+                # Use configured model for current provider, or None (first available) for others
+                provider_llm_model = (
+                    config.agent.llm_model
+                    if provider == current_llm_provider
+                    else None
+                )
+                await flows_service.change_langflow_model_value(
+                        provider,
+                        llm_model=provider_llm_model,
+                        force_llm_update=True
+                    )
+                logger.info(
+                    f"Successfully updated Langflow flows for LLM provider {provider}"
+                )
+
             # 2. Update ALL configured embedding providers
-            embedding_providers = []
-            if config.providers.openai.configured:
-                embedding_providers.append("openai")
-            if config.providers.watsonx.configured:
-                embedding_providers.append("watsonx")
-            if config.providers.ollama.configured:
-                embedding_providers.append("ollama")
+            embedding_providers = _configured_provider_names(config, _EMBEDDING_PROVIDER_NAMES)
 
             current_embedding_provider = config.knowledge.embedding_provider.lower()
             for provider in embedding_providers:
@@ -1676,10 +1699,7 @@ async def _update_langflow_model_values(config, flows_service, llm_model=None, l
 async def _update_langflow_system_prompt(config, flows_service):
     """Update system prompt in chat flow"""
     try:
-        llm_provider = config.agent.llm_provider.lower()
-        await flows_service.update_chat_flow_system_prompt(
-            config.agent.system_prompt, llm_provider
-        )
+        await flows_service.update_chat_flow_system_prompt(config.agent.system_prompt)
         logger.info("Successfully updated chat flow system prompt")
     except Exception as e:
         logger.error(f"Failed to update chat flow system prompt: {str(e)}")
@@ -1999,10 +2019,10 @@ async def rollback_onboarding(
             deleted_conversations=deleted_conversations_count
         )
 
-    except Exception as e:
-        logger.error("Failed to rollback onboarding configuration", error=str(e))
+    except Exception:
+        logger.error("Failed to rollback onboarding configuration")
         return JSONResponse(
-            {"error": f"Failed to rollback onboarding: {str(e)}"}, status_code=500
+            {"error": "Failed to rollback onboarding"}, status_code=500
         )
 
 
@@ -2070,11 +2090,12 @@ async def update_docling_preset(
             settings=settings_toggles,
             preset_config=preset_config,
         )
-
+    except HTTPException:
+        # Preserve intended HTTP status codes (e.g. 400 for an invalid preset)
+        raise
     except Exception as e:
         logger.error("Failed to update docling settings", error=str(e))
-        raise HTTPException(status_code=500, detail=f"Failed to update docling settings: {str(e)}")
-
+        raise HTTPException(status_code=500, detail="Failed to update docling settings") from e
 
 async def refresh_openrag_docs(
     document_service=Depends(get_document_service),
@@ -2110,4 +2131,4 @@ async def refresh_openrag_docs(
         raise HTTPException(
             status_code=500,
             detail=f"Failed to refresh OpenRAG docs: {str(e)}",
-        )
+        )

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/main.py

@@ -1619,7 +1619,7 @@ async def create_app():
     """Create and configure the FastAPI application"""
     services = await initialize_services()
 
-    app = FastAPI(title="OpenRAG API", version=OPENRAG_VERSION, debug=True)
+    app = FastAPI(title="OpenRAG API", version=OPENRAG_VERSION, debug=True, lifespan=lifespan)
     app.state.services = services  # Store services for cleanup
     app.state.background_tasks = set()
 
@@ -2139,102 +2139,9 @@ async def create_app():
     # FastMCP requires its own lifespan to be run so that the
     # StreamableHTTPSessionManager task group is initialized before requests arrive.
     # FastAPI does not automatically propagate lifespan to mounted sub-apps,
-    # so we wire it in manually via startup/shutdown handlers.
+    # so we wire it in manually via the parent's lifespan (using app.state).
     _mcp_lifespan_ctx = mcp_http_app.router.lifespan_context(mcp_http_app)
-
-    async def _start_mcp_lifespan():
-        await _mcp_lifespan_ctx.__aenter__()
-        logger.info("FastMCP lifespan started")
-
-    async def _stop_mcp_lifespan():
-        await _mcp_lifespan_ctx.__aexit__(None, None, None)
-        logger.info("FastMCP lifespan stopped")
-
-    app.add_event_handler("startup", _start_mcp_lifespan)
-    app.add_event_handler("shutdown", _stop_mcp_lifespan)
-
-    # Add startup event handler
-    @app.on_event("startup")
-    async def startup_event():
-        await TelemetryClient.send_event(
-            Category.APPLICATION_STARTUP, MessageId.ORB_APP_STARTED
-        )
-        # Start index initialization in background to avoid blocking OIDC endpoints
-        t1 = asyncio.create_task(startup_tasks(services))
-        app.state.background_tasks.add(t1)
-        t1.add_done_callback(app.state.background_tasks.discard)
-
-        # Start periodic task cleanup scheduler
-        services["task_service"].start_cleanup_scheduler()
-
-        # Start periodic flow backup task (every 5 minutes)
-        async def periodic_backup():
-            """Periodic backup task that runs every 15 minutes"""
-            while True:
-                try:
-                    await asyncio.sleep(5 * 60)  # Wait 5 minutes
-
-                    # Check if onboarding has been completed
-                    config = get_openrag_config()
-                    if not config.edited:
-                        logger.debug(
-                            "Onboarding not completed yet, skipping periodic backup"
-                        )
-                        continue
-
-                    flows_service = services.get("flows_service")
-                    if flows_service:
-                        logger.info("Running periodic flow backup")
-                        backup_results = await flows_service.backup_all_flows(
-                            only_if_changed=True
-                        )
-                        if backup_results["backed_up"]:
-                            logger.info(
-                                "Periodic backup completed",
-                                backed_up=len(backup_results["backed_up"]),
-                                skipped=len(backup_results["skipped"]),
-                            )
-                        else:
-                            logger.debug(
-                                "Periodic backup: no flows changed",
-                                skipped=len(backup_results["skipped"]),
-                            )
-                except asyncio.CancelledError:
-                    logger.info("Periodic backup task cancelled")
-                    break
-                except Exception as e:
-                    logger.error(f"Error in periodic backup task: {str(e)}")
-                    # Continue running even if one backup fails
-
-        backup_task = asyncio.create_task(periodic_backup())
-        app.state.background_tasks.add(backup_task)
-        backup_task.add_done_callback(app.state.background_tasks.discard)
-
-    # Add shutdown event handler
-    @app.on_event("shutdown")
-    async def shutdown_event():
-        await TelemetryClient.send_event(
-            Category.APPLICATION_SHUTDOWN, MessageId.ORB_APP_SHUTDOWN
-        )
-        logger.info("Application shutdown initiated")
-
-        # Gracefully shutdown OpenSearch connection first
-        try:
-            from utils.opensearch_utils import graceful_opensearch_shutdown
-            await graceful_opensearch_shutdown(clients.opensearch)
-        except Exception as e:
-            logger.error("Error during graceful OpenSearch shutdown", error=str(e))
-
-        await cleanup_subscriptions_proper(services)
-        # Cleanup task service (cancels background tasks and process pool)
-        await services["task_service"].shutdown()
-        # Cleanup async clients (this will also close OpenSearch client if not already closed)
-        await clients.cleanup()
-        # Cleanup telemetry client
-        from utils.telemetry.client import cleanup_telemetry_client
-
-        await cleanup_telemetry_client()
-        logger.info("Application shutdown completed")
+    app.state.mcp_lifespan_ctx = _mcp_lifespan_ctx
 
     return app
 

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2/src/openrag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.5.0.dev38
+Version: 0.5.1.dev2
 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

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/services/api_key_service.py

@@ -205,7 +205,7 @@ class APIKeyService:
         jwt_token: str = None,
     ) -> Dict[str, Any]:
         """
-        List all API keys for a user (without the actual keys).
+        List all active (non-revoked) API keys for a user (without the actual keys).
 
         Args:
             user_id: The user's ID
@@ -220,7 +220,12 @@ class APIKeyService:
             # Search for user's keys
             search_body = {
                 "query": {
-                    "term": {"user_id": user_id}
+                    "bool": {
+                        "must": [
+                            {"term": {"user_id": user_id}},
+                            {"term": {"revoked": False }},
+                        ]
+                    }
                 },
                 "sort": [{"created_at": {"order": "desc"}}],
                 "_source": [

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/services/flows_service.py

@@ -673,16 +673,14 @@ class FlowsService:
         await self._update_flow_field(LANGFLOW_CHAT_FLOW_ID, "model_name", model_name,
                                 node_display_name=target_llm_id)
 
-    async def update_chat_flow_system_prompt(self, system_prompt: str, provider: str):
+    async def update_chat_flow_system_prompt(self, system_prompt: str):
         """Helper function to update the system prompt in the chat flow"""
         if not LANGFLOW_CHAT_FLOW_ID:
             raise ValueError("LANGFLOW_CHAT_FLOW_ID is not configured")
 
-        # Determine target component IDs based on provider
-        target_agent_id = self._get_provider_component_ids(provider)[1]
-
-        await self._update_flow_field(LANGFLOW_CHAT_FLOW_ID, "system_prompt", system_prompt,
-                                node_display_name=target_agent_id)
+        await self._update_flow_field(
+            LANGFLOW_CHAT_FLOW_ID, "system_prompt", system_prompt, node_display_name=AGENT_COMPONENT_DISPLAY_NAME
+        )
 
     async def update_flow_docling_preset(self, preset: str, preset_config: dict):
         """Helper function to update docling preset in the ingest flow"""

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/services/search_service.py

@@ -2,6 +2,7 @@ import asyncio
 import copy
 import os
 import json
+import re
 from collections import Counter
 from typing import Any, Dict
 from agentd.tool_decorator import tool
@@ -22,6 +23,19 @@ EMBED_RETRY_MAX_DELAY = 8.0
 _global_search_service = None
 
 
+def _is_exact_token_query(query: str) -> bool:
+    """Return True for code/token-like queries that should not allow partial fuzzy matches."""
+    if not query or len(query.strip()) < 3:
+        return False
+
+    query = query.strip()
+
+    if re.search(r"[^a-zA-Z0-9\s]", query):
+        return True
+
+    return bool(re.search(r"[a-zA-Z]", query) and re.search(r"\d", query))
+
+
 def register_search_service(service: "SearchService") -> None:
     """
     Explicitly register the active search service for the @tool wrapper.
@@ -584,8 +598,17 @@ class SearchService:
                     )
                 )
             }
-            if exact_files:
-                chunks = [chunk for chunk in chunks if chunk.get("filename") in exact_files]
+            
+            # Determine if we should apply exact-token filtering
+            should_filter_exact = bool(exact_files) or _is_exact_token_query(query)
+            
+            if should_filter_exact:
+                if exact_files:
+                    # Filter to only chunks from files with exact matches
+                    chunks = [chunk for chunk in chunks if chunk.get("filename") in exact_files]
+                else:
+                    # No exact matches found for a token-like query - return empty results
+                    chunks = []
 
                 def _build_terms_agg(field: str) -> Dict[str, Any]:
                     counts = Counter(

{openrag-0.5.0.dev38 → openrag-0.5.1.dev2}/src/tui/_assets/docker-compose.yml

@@ -1,6 +1,6 @@
 services:
   opensearch:
-    image: langflowai/openrag-opensearch:${OPENRAG_VERSION:-latest}
+    image: docker.io/langflowai/openrag-opensearch:${OPENRAG_VERSION:-latest}
     # build:
     #   context: .
     #   dockerfile: Dockerfile
@@ -26,7 +26,7 @@ services:
     restart: unless-stopped
 
   dashboards:
-    image: opensearchproject/opensearch-dashboards:3.0.0
+    image: docker.io/opensearchproject/opensearch-dashboards:3.0.0
     container_name: osdash
     depends_on:
       - opensearch
@@ -38,7 +38,7 @@ services:
       - "5601:5601"
 
   openrag-backend:
-    image: langflowai/openrag-backend:${OPENRAG_VERSION:-latest}
+    image: docker.io/langflowai/openrag-backend:${OPENRAG_VERSION:-latest}
     build:
       context: .
       dockerfile: Dockerfile.backend
@@ -116,7 +116,7 @@ services:
       - "host.docker.internal:host-gateway"
 
   openrag-frontend:
-    image: langflowai/openrag-frontend:${OPENRAG_VERSION:-latest}
+    image: docker.io/langflowai/openrag-frontend:${OPENRAG_VERSION:-latest}
     build:
       context: .
       dockerfile: Dockerfile.frontend
@@ -129,7 +129,7 @@ services:
       - "${FRONTEND_PORT:-3000}:3000"
 
   langflow:
-    image: langflowai/openrag-langflow:${OPENRAG_VERSION:-latest}
+    image: docker.io/langflowai/openrag-langflow:${OPENRAG_VERSION:-latest}
     build:
       context: .
       dockerfile: Dockerfile.langflow