openrag 0.6.0.dev20__tar.gz → 0.6.0.dev22__tar.gz

{openrag-0.6.0.dev20/src/openrag.egg-info → openrag-0.6.0.dev22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.6.0.dev20
+Version: 0.6.0.dev22
 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.6.0.dev20 → openrag-0.6.0.dev22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.6.0.dev20"
+version = "0.6.0.dev22"
 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.6.0.dev20 → openrag-0.6.0.dev22/src/openrag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.6.0.dev20
+Version: 0.6.0.dev22
 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.6.0.dev20 → openrag-0.6.0.dev22}/src/services/flows_service.py

@@ -1099,128 +1099,128 @@ class FlowsService:
                 return label
             return None
 
-            # Update embedding component
-            if not get_openrag_config().knowledge.disable_ingest_with_langflow and (
-                embedding_model or force_embedding_update
+        # Update embedding component
+        if not get_openrag_config().knowledge.disable_ingest_with_langflow and (
+            embedding_model or force_embedding_update
+        ):
+            # Get all embedding nodes in the flow
+            embedding_nodes = self._find_nodes_in_flow(
+                flow_data, display_name=OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME
+            )
+            logger.info(
+                f"Found {len(embedding_nodes)} embedding nodes in flow {flow_name} with display name '{OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME}'"
+            )
+
+            # Count configured embedding-enabled providers
+            config_obj = get_openrag_config()
+            configured_providers = []
+            if config_obj.providers.openai.configured:
+                configured_providers.append("openai")
+            if config_obj.providers.watsonx.configured:
+                configured_providers.append("watsonx")
+            if config_obj.providers.ollama.configured:
+                configured_providers.append("ollama")
+
+            # Ensure current provider is in the list for counting purposes if it's being configured
+            if (
+                provider in ["openai", "watsonx", "ollama"]
+                and provider not in configured_providers
             ):
-                # Get all embedding nodes in the flow
-                embedding_nodes = self._find_nodes_in_flow(
-                    flow_data, display_name=OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME
-                )
-                logger.info(
-                    f"Found {len(embedding_nodes)} embedding nodes in flow {flow_name} with display name '{OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME}'"
-                )
+                configured_providers.append(provider)
 
-                # Count configured embedding-enabled providers
-                config_obj = get_openrag_config()
-                configured_providers = []
-                if config_obj.providers.openai.configured:
-                    configured_providers.append("openai")
-                if config_obj.providers.watsonx.configured:
-                    configured_providers.append("watsonx")
-                if config_obj.providers.ollama.configured:
-                    configured_providers.append("ollama")
-
-                # Ensure current provider is in the list for counting purposes if it's being configured
-                if (
-                    provider in ["openai", "watsonx", "ollama"]
-                    and provider not in configured_providers
-                ):
-                    configured_providers.append(provider)
+            all_possible = ["openai", "watsonx", "ollama"]
+            configured_providers = [p for p in all_possible if p in configured_providers]
+            provider_count = len(configured_providers)
+            logger.info(
+                f"Configured embedding providers: {configured_providers} (count: {provider_count})"
+            )
+
+            # 1. Check if any node is already this provider - always update those first
+            matched_nodes = []
+            provider_display = self._get_provider_name_display(provider)
+            for node, idx in embedding_nodes:
+                if self._get_node_provider(node) == provider_display:
+                    matched_nodes.append((node, idx))
 
-                all_possible = ["openai", "watsonx", "ollama"]
-                configured_providers = [p for p in all_possible if p in configured_providers]
-                provider_count = len(configured_providers)
+            if matched_nodes:
                 logger.info(
-                    f"Configured embedding providers: {configured_providers} (count: {provider_count})"
+                    f"Found {len(matched_nodes)} nodes already configured for provider '{provider}'"
                 )
-
-                # 1. Check if any node is already this provider - always update those first
-                matched_nodes = []
-                provider_display = self._get_provider_name_display(provider)
-                for node, idx in embedding_nodes:
-                    if self._get_node_provider(node) == provider_display:
-                        matched_nodes.append((node, idx))
-
-                if matched_nodes:
+                for node, _idx in matched_nodes:
+                    node_tasks.append(
+                        wrap_node_update(
+                            node,
+                            provider,
+                            embedding_model,
+                            f"embedding model: {embedding_model} (updated existing {provider} node)",
+                        )
+                    )
+            else:
+                # 2. No existing node matched, use slot-based logic
+                try:
+                    p_index = configured_providers.index(provider)
                     logger.info(
-                        f"Found {len(matched_nodes)} nodes already configured for provider '{provider}'"
+                        f"Using slot-based logic for provider '{provider}' (p_index: {p_index}, total configured: {provider_count})"
                     )
-                    for node, _idx in matched_nodes:
-                        node_tasks.append(
-                            wrap_node_update(
-                                node,
-                                provider,
-                                embedding_model,
-                                f"embedding model: {embedding_model} (updated existing {provider} node)",
-                            )
-                        )
-                else:
-                    # 2. No existing node matched, use slot-based logic
-                    try:
-                        p_index = configured_providers.index(provider)
+
+                    if provider_count == 1:
+                        # Single provider mode: update all available nodes (up to 3)
                         logger.info(
-                            f"Using slot-based logic for provider '{provider}' (p_index: {p_index}, total configured: {provider_count})"
+                            f"Single provider mode: updating all available embedding nodes (available: {len(embedding_nodes)})"
                         )
-
-                        if provider_count == 1:
-                            # Single provider mode: update all available nodes (up to 3)
+                        for i in range(min(3, len(embedding_nodes))):
+                            node, idx = embedding_nodes[i]
+                            node_tasks.append(
+                                wrap_node_update(
+                                    node,
+                                    provider,
+                                    embedding_model,
+                                    f"embedding model: {embedding_model} (set node {i + 1})",
+                                )
+                            )
+                    else:
+                        # Multiple providers: each gets one slot based on its list index
+                        if p_index < len(embedding_nodes):
+                            node, idx = embedding_nodes[p_index]
                             logger.info(
-                                f"Single provider mode: updating all available embedding nodes (available: {len(embedding_nodes)})"
+                                f"Multiple provider mode: assigning provider '{provider}' to node slot {p_index} (node {p_index + 1})"
                             )
-                            for i in range(min(3, len(embedding_nodes))):
-                                node, idx = embedding_nodes[i]
-                                node_tasks.append(
-                                    wrap_node_update(
-                                        node,
-                                        provider,
-                                        embedding_model,
-                                        f"embedding model: {embedding_model} (set node {i + 1})",
-                                    )
+                            node_tasks.append(
+                                wrap_node_update(
+                                    node,
+                                    provider,
+                                    embedding_model,
+                                    f"embedding model: {embedding_model} (set node {p_index + 1})",
                                 )
+                            )
                         else:
-                            # Multiple providers: each gets one slot based on its list index
-                            if p_index < len(embedding_nodes):
-                                node, idx = embedding_nodes[p_index]
-                                logger.info(
-                                    f"Multiple provider mode: assigning provider '{provider}' to node slot {p_index} (node {p_index + 1})"
-                                )
-                                node_tasks.append(
-                                    wrap_node_update(
-                                        node,
-                                        provider,
-                                        embedding_model,
-                                        f"embedding model: {embedding_model} (set node {p_index + 1})",
-                                    )
-                                )
-                            else:
-                                logger.info(
-                                    f"Provider index {p_index} exceeds available embedding nodes ({len(embedding_nodes)}) - skipping automatic assignment"
-                                )
-                    except ValueError:
-                        logger.warning(
-                            f"Current provider '{provider}' not found in configured providers list: {configured_providers}"
-                        )
-
-            # Update LLM component (if exists in this flow)
-            if llm_model or force_llm_update:
-                llm_node, _ = self._find_node_in_flow(
-                    flow_data, display_name=OPENAI_LLM_COMPONENT_DISPLAY_NAME
-                )
-                if llm_node:
-                    node_tasks.append(
-                        wrap_node_update(llm_node, provider, llm_model, f"llm model: {llm_model}")
+                            logger.info(
+                                f"Provider index {p_index} exceeds available embedding nodes ({len(embedding_nodes)}) - skipping automatic assignment"
+                            )
+                except ValueError:
+                    logger.warning(
+                        f"Current provider '{provider}' not found in configured providers list: {configured_providers}"
                     )
 
-                agent_node, _ = self._find_node_in_flow(
-                    flow_data, display_name=AGENT_COMPONENT_DISPLAY_NAME
+        # Update LLM component (if exists in this flow)
+        if llm_model or force_llm_update:
+            llm_node, _ = self._find_node_in_flow(
+                flow_data, display_name=OPENAI_LLM_COMPONENT_DISPLAY_NAME
+            )
+            if llm_node:
+                node_tasks.append(
+                    wrap_node_update(llm_node, provider, llm_model, f"llm model: {llm_model}")
                 )
-                if agent_node:
-                    node_tasks.append(
-                        wrap_node_update(
-                            agent_node, provider, llm_model, f"agent model: {llm_model}"
-                        )
+
+            agent_node, _ = self._find_node_in_flow(
+                flow_data, display_name=AGENT_COMPONENT_DISPLAY_NAME
+            )
+            if agent_node:
+                node_tasks.append(
+                    wrap_node_update(
+                        agent_node, provider, llm_model, f"agent model: {llm_model}"
                     )
+                )
 
         # Execute all node updates simultaneously
         if node_tasks:

{openrag-0.6.0.dev20 → openrag-0.6.0.dev22}/src/tui/cli.py

@@ -227,15 +227,18 @@ def _setup_walkthrough(
         _, _, already_running = _get_service_states(container_manager, docling_manager)
         if already_running:
             _stop_services_cli(container_manager, docling_manager)
-        _start_services_cli(container_manager, docling_manager)
+        fully_started = _start_services_cli(container_manager, docling_manager)
 
-        console.print()
-        frontend_url = f"http://localhost:{os.getenv('FRONTEND_PORT', '3000')}"
-        console.print(f"[bold green]OpenRAG is running at {frontend_url}[/bold green]")
-        try:
-            webbrowser.open(frontend_url)
-        except Exception:
-            pass
+        # Only announce the app URL / open the browser once everything is up;
+        # _start_services_cli already surfaced a warning for a partial startup.
+        if fully_started:
+            console.print()
+            frontend_url = f"http://localhost:{os.getenv('FRONTEND_PORT', '3000')}"
+            console.print(f"[bold green]OpenRAG is running at {frontend_url}[/bold green]")
+            try:
+                webbrowser.open(frontend_url)
+            except Exception:
+                pass
 
 
 def _collect_config(
@@ -345,11 +348,14 @@ def _start_services_cli(
     console.print("Starting OpenRAG services...", style="bold")
 
     async def _inner():
+        containers_ok = True
+        docling_ok = docling_manager.is_running()
+
         # Start container services
         if container_manager.is_available():
             async for item in container_manager.start_services():
                 # start_services yields (success, message) or (success, message, replace_last)
-                success = item[0]
+                containers_ok = item[0]
                 message = item[1]
                 replace_last = item[2] if len(item) > 2 else False
                 if replace_last:
@@ -358,24 +364,40 @@ def _start_services_cli(
                 else:
                     console.print(f"  {message}")
 
-                if not success and "error" in message.lower():
-                    console.print(f"  [red]✗ {message}[/red]")
+            if not containers_ok:
+                statuses = await container_manager.get_service_status(force_refresh=True)
+                containers_ok = bool(statuses) and all(
+                    s.status == ServiceStatus.RUNNING for s in statuses.values()
+                )
         else:
             console.print("  [yellow]No container runtime available[/yellow]")
+            containers_ok = False
 
-        # Start docling
-        if not docling_manager.is_running():
-            success, message = await docling_manager.start()
-            if success:
+        if not docling_ok:
+            docling_ok, message = await docling_manager.start()
+            if docling_ok:
                 console.print(f"  {message}")
             else:
                 console.print(f"  [yellow]{message}[/yellow]")
 
+        return containers_ok, docling_ok
+
     try:
-        asyncio.run(_inner())
-        console.print("[green]✓ All services started[/green]")
+        containers_ok, docling_ok = asyncio.run(_inner())
+
+        # On full success the menu header already reports "Services are running",
+        # so only surface partial/failed startup here to avoid a duplicate message.
+        results = {"containers": containers_ok, "docling-serve": docling_ok}
+        failed = [name for name, ok in results.items() if not ok]
+        if failed:
+            console.print(
+                f"[yellow]⚠ Startup incomplete: {', '.join(failed)} did not start "
+                "(run Show status for details)[/yellow]"
+            )
+        return not failed
     except Exception as e:
         console.print(f"[red]✗ Error starting services: {e}[/red]")
+        return False
 
 
 def _stop_services_cli(
@@ -393,7 +415,7 @@ def _stop_services_cli(
                 console.print(f"  {message}")
         # Stop docling
         if docling_manager.is_running():
-            success, message = await docling_manager.stop()
+            _success, message = await docling_manager.stop()
             console.print(f"  {message}")
 
     try:

{openrag-0.6.0.dev20 → openrag-0.6.0.dev22}/src/tui/managers/container_manager.py

@@ -644,6 +644,13 @@ class ContainerManager:
 
         return True, images, ""
 
+    def _resolve_service_name(self, compose_service: str | None, container_name: str) -> str | None:
+        """Resolve a container to its canonical OpenRAG service name"""
+        if compose_service and compose_service in self.expected_services:
+            return compose_service
+
+        return self.container_name_map.get(container_name)
+
     def _process_service_json(self, service: dict, services: dict[str, ServiceInfo]) -> None:
         """Process a service JSON object and add it to the services dict."""
         # Debug print to see the actual service data
@@ -651,8 +658,8 @@ class ContainerManager:
 
         container_name = service.get("Name", "")
 
-        # Map container name to service name
-        service_name = self.container_name_map.get(container_name)
+        # Resolve to canonical service name (compose 'Service' field first, then name map)
+        service_name = self._resolve_service_name(service.get("Service"), container_name)
         if not service_name:
             return
 
@@ -802,7 +809,10 @@ class ContainerManager:
                             continue
 
                         container_name = names[0]
-                        service_name = self.container_name_map.get(container_name)
+                        labels = container.get("Labels") or {}
+                        service_name = self._resolve_service_name(
+                            labels.get("com.docker.compose.service"), container_name
+                        )
                         if not service_name:
                             continue