openrag 0.4.1.dev7__tar.gz → 0.4.1.dev9__tar.gz

{openrag-0.4.1.dev7/src/openrag.egg-info → openrag-0.4.1.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.4.1.dev7
+Version: 0.4.1.dev9
 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.4.1.dev7 → openrag-0.4.1.dev9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.4.1.dev7"
+version = "0.4.1.dev9"
 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.4.1.dev7 → openrag-0.4.1.dev9}/src/agent.py

@@ -158,7 +158,7 @@ async def async_response_stream(
                 else:
                     delta_text = str(chunk.delta)
                 full_response += delta_text
-            
+
             # Enhanced logging for tool call detection (Granite 3.3 8b investigation)
             chunk_attrs = dir(chunk) if hasattr(chunk, '__dict__') else []
             tool_related_attrs = [attr for attr in chunk_attrs if 'tool' in attr.lower() or 'call' in attr.lower() or 'retrieval' in attr.lower()]
@@ -180,7 +180,7 @@ async def async_response_stream(
                     chunk_data = chunk.__dict__
                 else:
                     chunk_data = str(chunk)
-                
+
                 # Log detailed chunk structure for investigation (especially for Granite 3.3 8b)
                 if isinstance(chunk_data, dict):
                     # Check for any fields that might indicate tool usage
@@ -218,7 +218,7 @@ async def async_response_stream(
                         'retrieved_documents' in chunk_data,
                         'retrieval_results' in chunk_data,
                     ])
-                    
+
                     if has_results:
                         logger.info(
                             "Detected implicit tool call in backend, injecting synthetic event",
@@ -242,7 +242,7 @@ async def async_response_stream(
                         # Send the synthetic event first
                         yield (json.dumps(synthetic_event, default=str) + "\n").encode("utf-8")
                         detected_tool_call = True  # Mark that we've injected a tool call
-                
+
                 yield (json.dumps(chunk_data, default=str) + "\n").encode("utf-8")
             except Exception as e:
                 # Fallback to string representation
@@ -626,20 +626,68 @@ async def async_langflow_chat(
 
     # Extract sources from retrieval tool calls in the response
     sources = []
+
+    # Layer 1: Structured output items (OpenAI Responses API format).
+    # Relaxed: check for any output item with a non-empty `results` field,
+    # regardless of `type` string (Langflow may use different type names).
     if hasattr(response_obj, "output") and response_obj.output:
         for output_item in response_obj.output:
-            item_type = getattr(output_item, "type", None)
-            if item_type in ("tool_call", "retrieval_call"):
-                for result in getattr(output_item, "results", None) or []:
-                    rd = result.model_dump() if hasattr(result, "model_dump") else (result if isinstance(result, dict) else {})
-                    if "text" in rd:
-                        sources.append({
-                            "filename": rd.get("filename", ""),
-                            "text": rd.get("text", ""),
-                            "score": rd.get("score", 0),
-                            "page": rd.get("page"),
-                            "mimetype": rd.get("mimetype"),
-                        })
+            for result in getattr(output_item, "results", None) or []:
+                rd = (
+                    result.model_dump()
+                    if hasattr(result, "model_dump")
+                    else (result if isinstance(result, dict) else {})
+                )
+                if "text" in rd:
+                    sources.append({
+                        "filename": rd.get("filename", ""),
+                        "text": rd.get("text", ""),
+                        "score": rd.get("score", 0),
+                        "page": rd.get("page"),
+                        "mimetype": rd.get("mimetype"),
+                    })
+
+    # Layer 2: Top-level dict inspection (mirrors streaming middleware in async_response_stream).
+    # Langflow may embed retrieval results directly in the response dict rather than
+    # inside typed output items.
+    if not sources:
+        resp_dict = (
+            response_obj.model_dump()
+            if hasattr(response_obj, "model_dump")
+            else getattr(response_obj, "__dict__", {})
+        )
+        implicit_results = (
+            resp_dict.get("results")
+            or resp_dict.get("outputs")
+            or resp_dict.get("retrieved_documents")
+            or resp_dict.get("retrieval_results")
+            or []
+        )
+        if isinstance(implicit_results, list):
+            for result in implicit_results:
+                if isinstance(result, dict) and "text" in result:
+                    sources.append({
+                        "filename": result.get("filename", ""),
+                        "text": result.get("text", ""),
+                        "score": result.get("score", 0),
+                        "page": result.get("page"),
+                        "mimetype": result.get("mimetype"),
+                    })
+
+    # Layer 3: Citation-text fallback.
+    # Parse "(Source: filename)" patterns emitted by the LLM when it cites documents.
+    # This is the last-resort fallback when Langflow's response object carries no
+    # structured retrieval data.
+    if not sources:
+        import re
+        for match in re.finditer(r"\(Source:\s*([^\)]+)\)", response_text):
+            sources.append({
+                "filename": match.group(1).strip(),
+                "text": "",
+                "score": 0,
+                "page": None,
+                "mimetype": None,
+            })
 
     if not store_conversation:
         return response_text, response_id, sources
@@ -739,7 +787,7 @@ async def async_langflow_chat_stream(
                     response_id = chunk_data["id"]
                 elif "response_id" in chunk_data:
                     response_id = chunk_data["response_id"]
-                
+
                 # Check for error status
                 if chunk_data.get("finish_reason") == "error" or chunk_data.get("status") == "failed":
                     error_occurred = True
@@ -788,7 +836,7 @@ async def async_langflow_chat_stream(
         # Log the error
         logger.error(f"Error in langflow chat stream: {e}", exc_info=True)
         error_occurred = True
-        
+
         # Store error message in conversation history so it persists
         error_message = {
             "role": "assistant",
@@ -797,19 +845,19 @@ async def async_langflow_chat_stream(
             "error": True,
         }
         conversation_state["messages"].append(error_message)
-        
+
         # Try to store the conversation with error message
         # Use a temporary response_id if we don't have one
         if not response_id:
             response_id = f"error_{user_id}_{int(datetime.now().timestamp())}"
-        
+
         try:
             conversation_state["last_activity"] = datetime.now()
             await store_conversation_thread(user_id, response_id, conversation_state)
             logger.debug(f"Stored conversation with error for user {user_id}")
         except Exception as store_error:
             logger.error(f"Failed to store error conversation: {store_error}")
-        
+
         # Re-raise the exception so it propagates to the API layer
         raise
 

{openrag-0.4.1.dev7 → openrag-0.4.1.dev9}/src/api/settings.py

@@ -1664,8 +1664,6 @@ async def rollback_onboarding(
                 {"error": "No onboarding configuration to rollback"}, status_code=400
             )
 
-            jwt_token = user.jwt_token
-
         logger.info("Rolling back onboarding configuration due to file failures")
 
         # Get all tasks for the user
@@ -1728,7 +1726,7 @@ async def rollback_onboarding(
                         if filename:
                             try:
                                 opensearch_client = session_manager.get_user_opensearch_client(
-                                    user.user_id, jwt_token
+                                    user.user_id, user.jwt_token
                                 )
                                 from utils.opensearch_queries import build_filename_delete_body
                                 from config.settings import get_index_name

{openrag-0.4.1.dev7 → openrag-0.4.1.dev9}/src/main.py

@@ -248,10 +248,23 @@ async def init_index():
             )
         else:
             logger.info(
-                "Index already exists, skipping creation",
+                "Index already exists, skipping creation and changing number of replicas",
                 index_name=index_name,
                 embedding_model=embedding_model,
             )
+            # Set number of replicas to 0 to not create unused nodes in OpenSearch, in case it was created with more replicas
+            current = await clients.opensearch.indices.get_settings(index=index_name)
+            current_replicas = int(
+                current[index_name]["settings"]["index"].get("number_of_replicas", 1)
+            )
+            if current_replicas != 0:
+                await clients.opensearch.indices.put_settings(
+                    index=index_name,
+                    body={"index": {"number_of_replicas": 0}},
+                )
+                logger.info(
+                    "Updated documents index settings",
+                    )
             await TelemetryClient.send_event(
                 Category.OPENSEARCH_INDEX, MessageId.ORB_OS_INDEX_EXISTS
             )
@@ -259,6 +272,9 @@ async def init_index():
         # Create knowledge filters index
         knowledge_filter_index_name = "knowledge_filters"
         knowledge_filter_index_body = {
+            "settings": {
+                "index": {"number_of_replicas": 0, "number_of_shards": 1},
+            },
             "mappings": {
                 "properties": {
                     "id": {"type": "keyword"},
@@ -272,7 +288,7 @@ async def init_index():
                     "created_at": {"type": "date"},
                     "updated_at": {"type": "date"},
                 }
-            }
+            },
         }
 
         if not await clients.opensearch.indices.exists(
@@ -294,6 +310,19 @@ async def init_index():
                 index_name=knowledge_filter_index_name,
             )
 
+            current = await clients.opensearch.indices.get_settings(index=knowledge_filter_index_name)
+            current_replicas = int(
+                current[knowledge_filter_index_name]["settings"]["index"].get("number_of_replicas", 1)
+            )
+            if current_replicas != 0:
+                await clients.opensearch.indices.put_settings(
+                    index=knowledge_filter_index_name,
+                    body={"index": {"number_of_replicas": 0}},
+                )
+                logger.info(
+                    "Updated knowledge filters index settings",
+                    )
+
         # Create API keys index for public API authentication
         if not await clients.opensearch.indices.exists(index=API_KEYS_INDEX_NAME):
             await clients.opensearch.indices.create(
@@ -1861,6 +1890,16 @@ async def create_app():
         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)
+            clients.opensearch = None  # prevent double-close in clients.cleanup()
+        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()
@@ -1870,6 +1909,7 @@ async def create_app():
         from utils.telemetry.client import cleanup_telemetry_client
 
         await cleanup_telemetry_client()
+        logger.info("Application shutdown completed")
 
     return app
 

{openrag-0.4.1.dev7 → openrag-0.4.1.dev9/src/openrag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.4.1.dev7
+Version: 0.4.1.dev9
 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.4.1.dev7 → openrag-0.4.1.dev9}/src/services/task_service.py

@@ -411,6 +411,16 @@ class TaskService:
 
             # Mark task as completed if all files (including appended ones) are done
             if upload_task.processed_files >= upload_task.total_files:
+                # Force an index refresh BEFORE marking the task COMPLETED so that
+                # callers polling for COMPLETED status can immediately query or delete
+                # the newly indexed chunks without hitting the near-real-time refresh window.
+                if upload_task.successful_files > 0:
+                    try:
+                        from config.settings import clients, get_index_name
+                        await clients.opensearch.indices.refresh(index=get_index_name())
+                    except Exception as e:
+                        logger.debug("Index refresh after ingest failed (non-fatal)", error=str(e))
+
                 upload_task.status = TaskStatus.COMPLETED
                 upload_task.updated_at = time.time()
 

{openrag-0.4.1.dev7 → openrag-0.4.1.dev9}/src/tui/_assets/docker-compose.yml

@@ -10,26 +10,20 @@ services:
     environment:
       - discovery.type=single-node
       - OPENSEARCH_INITIAL_ADMIN_PASSWORD=${OPENSEARCH_PASSWORD}
-    # Run security setup in background after OpenSearch starts
-    command: >
-      bash -c "
-        # Ensure data directory has correct permissions
-        sudo chown -R opensearch:opensearch /usr/share/opensearch/data || true
-
-        # Start OpenSearch in background
-        /usr/share/opensearch/opensearch-docker-entrypoint.sh opensearch &
-
-        # Wait a bit for OpenSearch to start, then apply security config
-        sleep 10 && /usr/share/opensearch/setup-security.sh &
-
-        # Wait for background processes
-        wait
-      "
+      - OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g
     ports:
       - "9200:9200"
       - "9600:9600"
     volumes:
-      - ${OPENSEARCH_DATA_PATH:-./opensearch-data}:/usr/share/opensearch/data:U,z
+      - opensearch-data:/usr/share/opensearch/data
+    stop_grace_period: 2m
+    healthcheck:
+      test: ["CMD-SHELL", "curl -ku admin:$$OPENSEARCH_PASSWORD 'https://localhost:9200/_cluster/health' -s | grep -qE '\"status\":\"(green|yellow)\"'"]
+      interval: 15s
+      timeout: 10s
+      retries: 20
+      start_period: 60s
+    restart: unless-stopped
 
   dashboards:
     image: opensearchproject/opensearch-dashboards:3.0.0
@@ -186,3 +180,6 @@ services:
       - LANGFLOW_ENABLE_SUPERUSER_CLI=${LANGFLOW_ENABLE_SUPERUSER_CLI}
       # - DEFAULT_FOLDER_NAME=OpenRAG
       - HIDE_GETTING_STARTED_PROGRESS=true
+
+volumes:
+  opensearch-data:

{openrag-0.4.1.dev7 → openrag-0.4.1.dev9}/src/utils/embeddings.py

@@ -158,7 +158,7 @@ async def create_dynamic_index_body(
         "settings": {
             "index": {"knn": True},
             "number_of_shards": 1,
-            "number_of_replicas": 1,
+            "number_of_replicas": 0
         },
         "mappings": {
             "properties": {

{openrag-0.4.1.dev7 → openrag-0.4.1.dev9}/src/utils/opensearch_utils.py

@@ -121,3 +121,40 @@ async def wait_for_opensearch(
     message: str = "Failed to verify whether OpenSearch is ready."
     logger.error(message)
     raise OpenSearchNotReadyError(message)
+
+
+async def graceful_opensearch_shutdown(opensearch_client: AsyncOpenSearch) -> None:
+    """Gracefully shutdown OpenSearch client connection.
+    
+    This ensures that all pending operations are completed and connections
+    are properly closed before the application exits.
+    
+    Args:
+        opensearch_client: The OpenSearch client to shutdown.
+    """
+    if opensearch_client is None:
+        logger.debug("OpenSearch client is None, skipping graceful shutdown")
+        return
+    
+    try:
+        logger.info("Initiating graceful OpenSearch shutdown...")
+        
+        # Flush any pending write operations before closing
+        try:
+            await asyncio.wait_for(
+                opensearch_client.indices.flush(index="_all", wait_if_ongoing=True),
+                timeout=10.0
+            )
+            logger.debug("Index flush completed")
+        except asyncio.TimeoutError:
+            logger.warning("Timeout during index flush")
+        except Exception as e:
+            logger.warning("Error during index flush", error=str(e))
+        
+        # Close the client connection
+        await opensearch_client.close()
+        logger.info("OpenSearch client connection closed gracefully")
+        
+    except Exception as e:
+        logger.error("Error during graceful OpenSearch shutdown", error=str(e))
+