OpenRAG 0.4.0__tar.gz → 0.4.0.dev2__tar.gz

{openrag-0.4.0/src/openrag.egg-info → openrag-0.4.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.4.0
+Version: 0.4.0.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
@@ -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.2.2
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: cryptography>=45.0.6
 Requires-Dist: google-api-python-client>=2.143.0
@@ -36,9 +37,6 @@ 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: pyyaml>=6.0
-Requires-Dist: tiktoken>=0.7.0
 Dynamic: license-file
 
 <div align="center">

{openrag-0.4.0 → openrag-0.4.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.4.0"
+version = "0.4.0.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"
@@ -21,6 +21,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
+    "agentd>=0.2.2",
     "aiofiles>=24.1.0",
     "cryptography>=45.0.6",
     "google-api-python-client>=2.143.0",
@@ -41,10 +42,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
     "textual-fspicker>=0.6.0",
     "structlog>=25.4.0",
-    "zxcvbn>=4.5.0",
-    "openai>=1.0.0",
-    "pyyaml>=6.0",
-    "tiktoken>=0.7.0",
+    "zxcvbn>=4.5.0"
 ]
 
 [dependency-groups]

{openrag-0.4.0 → openrag-0.4.0.dev2}/src/api/documents.py

@@ -121,26 +121,16 @@ async def check_filename_exists(
         )
 
         from utils.opensearch_queries import build_filename_search_body
-        from utils.file_utils import get_filename_aliases
 
-        candidate_filenames = get_filename_aliases(filename)
-        if not candidate_filenames:
-            return JSONResponse({"exists": False, "filename": filename}, status_code=200)
+        search_body = build_filename_search_body(filename, size=1, source=["filename"])
 
         logger.debug("Checking filename existence", filename=filename, index_name=get_index_name())
-        exists = False
 
         try:
-            for candidate in candidate_filenames:
-                search_body = build_filename_search_body(candidate, size=1, source=["filename"])
-                response = await opensearch_client.search(
-                    index=get_index_name(),
-                    body=search_body
-                )
-                hits = response.get("hits", {}).get("hits", [])
-                if hits:
-                    exists = True
-                    break
+            response = await opensearch_client.search(
+                index=get_index_name(),
+                body=search_body
+            )
         except Exception as search_err:
             if "index_not_found_exception" in str(search_err):
                 logger.info("Index does not exist, creating it now before upload")
@@ -148,6 +138,9 @@ async def check_filename_exists(
                 return JSONResponse({"exists": False, "filename": filename}, status_code=200)
             raise
 
+        hits = response.get("hits", {}).get("hits", [])
+        exists = len(hits) > 0
+
         return JSONResponse({"exists": exists, "filename": filename}, status_code=200)
 
     except Exception as e:

{openrag-0.4.0 → openrag-0.4.0.dev2}/src/api/settings.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 import platform
 from fastapi import Depends, Request, HTTPException
@@ -37,7 +36,6 @@ from dependencies import (
 from session_manager import User
 
 logger = get_logger(__name__)
-_background_tasks: set[asyncio.Task] = set()
 
 
 class SettingsUpdateBody(BaseModel):
@@ -211,9 +209,6 @@ class RollbackResponse(BaseModel):
     cancelled_tasks: int
     deleted_files: int
 
-class RollbackBody(BaseModel):
-    embedding_only: bool = False
-
 
 # Docling preset configurations
 def get_docling_preset_configs(
@@ -610,12 +605,6 @@ async def update_settings(
                 logger.error(f"Failed to update docling settings in flow: {str(e)}")
 
         if body.chunk_size is not None:
-            effective_overlap = body.chunk_overlap if body.chunk_overlap is not None else current_config.knowledge.chunk_overlap
-            if effective_overlap >= body.chunk_size:
-                raise HTTPException(
-                    status_code=422,
-                    detail="chunk_overlap must be less than chunk_size"
-                )
             current_config.knowledge.chunk_size = body.chunk_size
             config_updated = True
             await TelemetryClient.send_event(
@@ -636,12 +625,6 @@ async def update_settings(
                 # The config will still be saved
 
         if body.chunk_overlap is not None:
-            effective_chunk_size = body.chunk_size if body.chunk_size is not None else current_config.knowledge.chunk_size
-            if body.chunk_overlap >= effective_chunk_size:
-                raise HTTPException(
-                    status_code=422,
-                    detail="chunk_overlap must be less than chunk_size"
-                )
             current_config.knowledge.chunk_overlap = body.chunk_overlap
             config_updated = True
             await TelemetryClient.send_event(
@@ -832,31 +815,30 @@ async def update_settings(
                 {"error": "Failed to save configuration"}, status_code=500
             )
 
-        # Refresh patched client immediately so subsequent requests pick up latest config.
+        # Update Langflow global variables and model values if provider settings changed
         await clients.refresh_patched_client()
 
-        # Run expensive Langflow sync in the background to keep settings updates responsive.
         if should_validate or provider_updated:
-            task = asyncio.create_task(
-                _run_async_post_save_langflow_updates(
-                    session_manager=session_manager,
-                    update_mcp_servers=(
-                        body.embedding_provider is not None
-                        or body.embedding_model is not None
-                        or provider_updated
-                    ),
-                    update_model_values=(
-                        body.llm_provider is not None
-                        or body.llm_model is not None
-                        or body.embedding_provider is not None
-                        or body.embedding_model is not None
-                        or provider_updated
-                    ),
-                )
-            )
-            # Keep a strong reference until completion to avoid premature GC cancellation.
-            _background_tasks.add(task)
-            task.add_done_callback(_background_tasks.discard)
+            try:
+                flows_service = _get_flows_service()
+
+                # Update global variables
+                await _update_langflow_global_variables(current_config, flows_service=flows_service)
+
+                # Update LLM client credentials when embedding selection changes
+                if body.embedding_provider is not None or body.embedding_model is not None:
+                    await _update_mcp_servers_with_provider_credentials(
+                        current_config, session_manager, flows_service=flows_service
+                    )
+
+                # Update model values if provider or model changed (including removals that trigger fallback)
+                if body.llm_provider is not None or body.llm_model is not None or body.embedding_provider is not None or body.embedding_model is not None or provider_updated:
+                    await _update_langflow_model_values(current_config, flows_service)
+
+            except Exception as e:
+                logger.error(f"Failed to update Langflow settings: {str(e)}")
+                # Don't fail the entire settings update if Langflow update fails
+                # The config was still saved
 
 
         set_fields = [k for k, v in body.model_dump().items() if v is not None]
@@ -1398,37 +1380,6 @@ async def _update_langflow_global_variables(config, flows_service=None):
         raise
 
 
-async def _run_async_post_save_langflow_updates(
-    session_manager,
-    update_mcp_servers: bool,
-    update_model_values: bool,
-) -> None:
-    """Apply post-save Langflow synchronization asynchronously."""
-    try:
-        current_config = get_openrag_config()
-        flows_service = _get_flows_service()
-
-        # Update global variables
-        await _update_langflow_global_variables(
-            current_config, flows_service=flows_service
-        )
-
-        # Update LLM client credentials when embedding selection changes
-        if update_mcp_servers:
-            await _update_mcp_servers_with_provider_credentials(
-                current_config, session_manager, flows_service=flows_service
-            )
-
-        # Update model values if provider/model changed (including removals/fallbacks)
-        if update_model_values:
-            await _update_langflow_model_values(current_config, flows_service)
-
-        logger.info("Completed asynchronous Langflow post-save sync")
-    except Exception as e:
-        # Do not fail user request if async sync fails; keep parity with existing behavior.
-        logger.error(f"Failed to update Langflow settings asynchronously: {str(e)}")
-
-
 async def _update_mcp_servers_with_provider_credentials(config, session_manager = None, flows_service=None):
     # Update MCP servers with provider credentials
     try:
@@ -1641,10 +1592,8 @@ async def reapply_all_settings(session_manager = None):
 
 async def rollback_onboarding(
     request: Request,
-    body: Optional[RollbackBody] = None,
     session_manager=Depends(get_session_manager),
     task_service=Depends(get_task_service),
-    knowledge_filter_service=Depends(get_knowledge_filter_service),
     user: User = Depends(get_current_user),
 ) -> RollbackResponse:
     """Rollback onboarding configuration when sample data files fail.
@@ -1674,36 +1623,7 @@ async def rollback_onboarding(
         cancelled_tasks = []
         deleted_files = []
 
-        # Delete knowledge filters created during onboarding
-        try:
-            async def remove_filter(filter_id: Optional[str]):
-                if filter_id and knowledge_filter_service:
-                    try:
-                        result = await knowledge_filter_service.delete_knowledge_filter(
-                            filter_id, user.user_id, user.jwt_token
-                        )
-                        if result and result.get("success"):
-                            logger.info(f"Deleted knowledge filter {filter_id}")
-                        else:
-                            error_msg = result.get("error") if result else "Unknown error"
-                            logger.warning(f"Could not delete knowledge filter {filter_id}: {error_msg}")
-                    except Exception as e:
-                        logger.warning(f"Exception deleting knowledge filter {filter_id}: {str(e)}")
-
-            if getattr(current_config.onboarding, 'openrag_docs_filter_id', None):
-                await remove_filter(current_config.onboarding.openrag_docs_filter_id)
-                current_config.onboarding.openrag_docs_filter_id = None
-                
-            if getattr(current_config.onboarding, 'user_doc_filter_id', None):
-                await remove_filter(current_config.onboarding.user_doc_filter_id)
-                current_config.onboarding.user_doc_filter_id = None
-        except Exception as e:
-            logger.error(f"Error while cleaning up knowledge filters: {e}")
-
         # Cancel all active tasks and collect successfully ingested files
-        from session_manager import AnonymousUser
-        anonymous_user_id = AnonymousUser().user_id
-
         for task_data in all_tasks:
             task_id = task_data.get("task_id")
             task_status = task_data.get("status")
@@ -1718,40 +1638,41 @@ async def rollback_onboarding(
                 except Exception as e:
                     logger.error(f"Failed to cancel task {task_id}: {str(e)}")
 
-            # Delete all files associated with any task, regardless of whether 
-            # the task failed or completed, to ensure no partial chunks remain in OpenSearch.
-            files = task_data.get("files", {})
-            if isinstance(files, dict):
-                for file_path, file_info in files.items():
-                    if isinstance(file_info, dict):
-                        filename = file_info.get("filename") or file_path.split("/")[-1]
-                        if filename:
-                            try:
-                                opensearch_client = session_manager.get_user_opensearch_client(
-                                    user.user_id, jwt_token
-                                )
-                                from utils.opensearch_queries import build_filename_delete_body
-                                from config.settings import get_index_name
-
-                                delete_query = build_filename_delete_body(filename)
-                                result = await opensearch_client.delete_by_query(
-                                    index=get_index_name(),
-                                    body=delete_query,
-                                    conflicts="proceed"
-                                )
-                                deleted_count = result.get("deleted", 0)
-                                if deleted_count > 0:
-                                    deleted_files.append(filename)
-                                    logger.info(f"Deleted {deleted_count} chunks for filename {filename}")
-                            except Exception as e:
-                                logger.error(f"Failed to delete documents for {filename}: {str(e)}")
-
-            # Wipe the task completely from memory so the frontend doesn't see it anymore
-            for check_user_id in [user.user_id, anonymous_user_id]:
-                if check_user_id in task_service.task_store and task_id in task_service.task_store[check_user_id]:
-                    task_service._task_locks.pop(task_id, None)
-                    task_service.task_store[check_user_id].pop(task_id, None)
-                    logger.info(f"Purged task {task_id} completely from task_store for user {check_user_id}")
+            # For completed tasks, find successfully ingested files and delete them
+            elif task_status == "completed":
+                files = task_data.get("files", {})
+                if isinstance(files, dict):
+                    for file_path, file_info in files.items():
+                        # Check if file was successfully ingested
+                        if isinstance(file_info, dict):
+                            file_status = file_info.get("status")
+                            filename = file_info.get("filename") or file_path.split("/")[-1]
+
+                            if file_status == "completed" and filename:
+                                try:
+                                    # Get user's OpenSearch client
+                                    opensearch_client = session_manager.get_user_opensearch_client(
+                                        user.user_id, jwt_token
+                                    )
+
+                                    # Delete documents by filename
+                                    from utils.opensearch_queries import build_filename_delete_body
+                                    from config.settings import get_index_name
+
+                                    delete_query = build_filename_delete_body(filename)
+
+                                    result = await opensearch_client.delete_by_query(
+                                        index=get_index_name(),
+                                        body=delete_query,
+                                        conflicts="proceed"
+                                    )
+
+                                    deleted_count = result.get("deleted", 0)
+                                    if deleted_count > 0:
+                                        deleted_files.append(filename)
+                                        logger.info(f"Deleted {deleted_count} chunks for filename {filename}")
+                                except Exception as e:
+                                    logger.error(f"Failed to delete documents for {filename}: {str(e)}")
 
         # Clear embedding provider and model settings
         current_config.knowledge.embedding_provider = "openai"  # Reset to default
@@ -1759,21 +1680,11 @@ async def rollback_onboarding(
         current_config.onboarding.openrag_docs_ingested_version = None
         current_config.onboarding.openrag_docs_remote_signature = None
 
-        embedding_only = body.embedding_only if body else False
-
         # Mark config as not edited so user can go through onboarding again
-        if not embedding_only:
-            current_config.edited = False
-            current_config.onboarding.current_step = 0
-            # Also clear LLM provider and model settings when doing a full rollback
-            current_config.agent.llm_provider = "openai"  # Reset to default
-            current_config.agent.llm_model = ""
-        else:
-            # When rolling back embedding only, we keep edited=True
-            # and set current_step to 1 (which is the embedding step)
-            current_config.onboarding.current_step = 1
+        current_config.edited = False
+        current_config.onboarding.current_step = 0
 
-        # Save the rolled back configuration manually
+        # Save the rolled back configuration manually to avoid save_config_file setting edited=True
         try:
             import yaml
             config_file = config_manager.config_file
@@ -1781,14 +1692,14 @@ async def rollback_onboarding(
             # Ensure directory exists
             config_file.parent.mkdir(parents=True, exist_ok=True)
 
-            # Save config with current edited state
+            # Save config with edited=False
             with open(config_file, "w") as f:
                 yaml.dump(current_config.to_dict(), f, default_flow_style=False, indent=2)
 
             # Update cached config
             config_manager._config = current_config
 
-            logger.info(f"Successfully saved rolled back configuration with edited={current_config.edited}")
+            logger.info("Successfully saved rolled back configuration with edited=False")
         except Exception as e:
             logger.error(f"Failed to save rolled back configuration: {e}")
             return JSONResponse(

{openrag-0.4.0 → openrag-0.4.0.dev2}/src/config/settings.py

@@ -3,6 +3,7 @@ import os
 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
@@ -536,14 +537,16 @@ class AppClients:
                     use_http2 = future.result(timeout=15)
 
                 if use_http2:
-                    self._patched_async_client = AsyncOpenAI()
+                    self._patched_async_client = patch_openai_with_mcp(AsyncOpenAI())
                     logger.info("OpenAI client initialized with HTTP/2")
                 else:
                     http_client = httpx.AsyncClient(
                         http2=False,
                         timeout=httpx.Timeout(60.0, connect=10.0)
                     )
-                    self._patched_async_client = AsyncOpenAI(http_client=http_client)
+                    self._patched_async_client = patch_openai_with_mcp(
+                        AsyncOpenAI(http_client=http_client)
+                    )
                     logger.info("OpenAI client initialized with HTTP/1.1 (fallback)")
                 logger.info("Successfully initialized OpenAI client")
             except Exception as e:

{openrag-0.4.0 → openrag-0.4.0.dev2}/src/main.py

@@ -410,14 +410,13 @@ async def ingest_openrag_docs_when_ready(
 ):
     """Ingest OpenRAG docs during onboarding."""
     use_url_ingest = _should_use_url_default_docs_ingest()
-    task_id = None
     if use_url_ingest:
         try:
             await TelemetryClient.send_event(
                 Category.DOCUMENT_INGESTION, MessageId.ORB_DOC_DEFAULT_URL_START
             )
             if DISABLE_INGEST_WITH_LANGFLOW:
-                task_id = await _ingest_default_documents_url(
+                await _ingest_default_documents_url(
                     document_service=document_service,
                     docs_url=DEFAULT_DOCS_URL,
                     crawl_depth=DEFAULT_DOCS_CRAWL_DEPTH,
@@ -427,7 +426,7 @@ async def ingest_openrag_docs_when_ready(
                     "Ingesting default documents using Langflow",
                     docs_url=DEFAULT_DOCS_URL,
                 )
-                task_id = await _ingest_default_documents_url_langflow(
+                await _ingest_default_documents_url_langflow(
                     langflow_file_service=langflow_file_service,
                     session_manager=session_manager,
                     task_service=task_service,
@@ -442,7 +441,6 @@ async def ingest_openrag_docs_when_ready(
             await TelemetryClient.send_event(
                 Category.DOCUMENT_INGESTION, MessageId.ORB_DOC_DEFAULT_URL_FAILED
             )
-    return task_id
 
 
 async def ingest_default_documents_when_ready(
@@ -458,11 +456,9 @@ 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
-            )
+        await ingest_openrag_docs_when_ready(
+            document_service, task_service, langflow_file_service, session_manager
+        )
 
         base_dir = _get_documents_dir()
         if not os.path.isdir(base_dir):
@@ -473,7 +469,8 @@ async def ingest_default_documents_when_ready(
         excluded_files = set(EXCLUDED_INGESTION_FILES)
         if _should_use_url_default_docs_ingest():
             excluded_files.update(URL_INGEST_EXCLUDED_INGESTION_FILES)
-        
+
+        # Collect files recursively, excluding warmup files and URL-ingested docs
         file_paths = [
             os.path.join(root, fn)
             for root, _, files in os.walk(base_dir)
@@ -485,22 +482,18 @@ async def ingest_default_documents_when_ready(
             raise FileNotFoundError(f"No default documents found in {base_dir}")
 
         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"
+            await _ingest_default_documents_openrag(
+                document_service, task_service, file_paths
             )
-            task_id = new_task_id or task_id
         else:
-            new_task_id = await _ingest_default_documents_langflow(
-                langflow_file_service, session_manager, task_service, file_paths, existing_task_id=task_id, connector_type="local"
+            await _ingest_default_documents_langflow(
+                langflow_file_service, session_manager, task_service, file_paths
             )
-            task_id = new_task_id or task_id
 
         await TelemetryClient.send_event(
             Category.DOCUMENT_INGESTION, MessageId.ORB_DOC_DEFAULT_COMPLETE
         )
 
-        return task_id
-
     except Exception as e:
         logger.error("Default documents ingestion failed", error=str(e))
         await TelemetryClient.send_event(
@@ -510,7 +503,7 @@ async def ingest_default_documents_when_ready(
 
 
 async def _ingest_default_documents_langflow(
-    langflow_file_service, session_manager, task_service, file_paths, existing_task_id: str = None, connector_type: str = "openrag_docs"
+    langflow_file_service, session_manager, task_service, file_paths
 ):
     """Ingest default documents using Langflow upload-ingest-delete pipeline."""
 
@@ -545,7 +538,7 @@ async def _ingest_default_documents_langflow(
                 {"key": "owner", "value": None},
                 {"key": "owner_name", "value": anonymous_user.name},
                 {"key": "owner_email", "value": anonymous_user.email},
-                {"key": "connector_type", "value": "openrag_docs"},
+                {"key": "connector_type", "value": "system_default"},
                 {"key": "is_sample_data", "value": "true"},
             ]
         }
@@ -565,8 +558,6 @@ async def _ingest_default_documents_langflow(
         settings=None,  # Use default ingestion settings
         delete_after_ingest=True,  # Clean up after ingestion
         replace_duplicates=True,
-        connector_type=connector_type,
-        existing_task_id=existing_task_id,
     )
 
     logger.info(
@@ -574,7 +565,6 @@ async def _ingest_default_documents_langflow(
         task_id=task_id,
         file_count=len(file_paths),
     )
-    return task_id
 
 
 async def _ingest_default_documents_url_langflow(
@@ -636,7 +626,6 @@ async def _ingest_default_documents_url_langflow(
         task_id=task_id,
         docs_url=docs_url,
     )
-    return task_id
 
 
 async def _ingest_default_documents_url(
@@ -668,7 +657,7 @@ async def _ingest_default_documents_url(
             owner_name=None,
             owner_email=None,
             is_sample_data=True,
-            connector_type="openrag_docs",
+            connector_type="system_default",
         )
         await processor.process_document_standard(
             file_path=temp_file_path,
@@ -679,7 +668,7 @@ async def _ingest_default_documents_url(
             owner_name=None,
             owner_email=None,
             file_size=os.path.getsize(temp_file_path),
-            connector_type="openrag_docs",
+            connector_type="system_default",
             is_sample_data=True,
         )
     finally:
@@ -1046,7 +1035,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, task_service, file_paths, connector_type: str = "local"
 ):
     """Ingest default documents using traditional OpenRAG processor."""
     logger.info(
@@ -1067,13 +1056,12 @@ async def _ingest_default_documents_openrag(
         connector_type=connector_type,
     )
 
-    task_id = await task_service.create_custom_task("anonymous", file_paths, processor, existing_task_id=existing_task_id)
+    task_id = await task_service.create_custom_task("anonymous", file_paths, processor)
     logger.info(
         "Started traditional OpenRAG ingestion task",
         task_id=task_id,
         file_count=len(file_paths),
     )
-    return task_id
 
 
 async def _update_mcp_servers_with_provider_credentials(services):
@@ -1210,20 +1198,6 @@ async def startup_tasks(services):
     # Update MCP servers with provider credentials (especially important for no-auth mode)
     await _update_mcp_servers_with_provider_credentials(services)
 
-    # Ensure all configured flows exist in Langflow (create-only, never overwrites).
-    # This replaces LANGFLOW_LOAD_FLOWS_PATH, which performed a blind upsert on
-    # every container start and discarded any user edits made in the Langflow UI.
-    newly_created: set[str] = set()
-    try:
-        flows_service = services["flows_service"]
-        newly_created = await flows_service.ensure_flows_exist()
-    except Exception as e:
-        logger.error(
-            "Failed to ensure Langflow flows exist at startup — "
-            "flows may be missing until the next restart",
-            error=str(e),
-        )
-
     # Check if flows were reset and reapply settings if config is edited
     try:
         config = get_openrag_config()
@@ -1231,9 +1205,6 @@ async def startup_tasks(services):
             logger.info("Checking if Langflow flows were reset")
             flows_service = services["flows_service"]
             reset_flows = await flows_service.check_flows_reset()
-            # Exclude flows that were just seeded — they match the JSON by design,
-            # not because they were externally reset.
-            reset_flows = [f for f in reset_flows if f not in newly_created]
 
             if reset_flows:
                 logger.info(