OpenRAG 0.4.1.dev7__tar.gz → 0.4.1.dev8__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.4.1.dev7"
+version = "0.4.1.dev8"
 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.dev8}/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.dev8}/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(

{openrag-0.4.1.dev7 → openrag-0.4.1.dev8/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.dev8
 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.dev8}/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.dev8}/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": {