cleanup of all cache-related code/comments; README revision

README.md

@@ -95,29 +95,17 @@ The orchestrator implements a dual-mode workflow designed to handle non-standard
 
 #### Mode 1: Direct Output (DIRECT_OUTPUT = True)
 
-**Purpose:** Immediately return long-running ingestor results to the user without LLM processing, then use those results as context for follow-up questions.
+**Purpose:** Immediately return long-running ingestor results to the user without Generator (LLM) processing. Results are maintained in message history context for follow-up questions.
 
-**First File Upload:**
+**File Upload:**
 ```
 File Upload → Detect Type → Direct Output Ingest → Return Raw Results
-                                         ↓
-                                    Cache Result (by file hash)
-```
-
-**Subsequent Conversation Turns:**
-```
-Follow-up Query → Detect Cached File → Retrieved Context → Combined Context → Generator
-                         ↓
-                  Use Cached Ingestor Output as Context
 ```
 
 **Key Behaviors:**
-- First upload returns raw ingestor output immediately (no LLM generation)
-- File content is hashed (SHA256) for deduplication
-- Ingestor results are cached with the file hash
-- All follow-up queries in the conversation use the cached ingestor output as retrieval context
-
-**Noteable Unintuitive Behavior:** Once the file is cached on the Orchestrator, re-uploading the same file (even with different filename in a different chat) skips re-processing.
+- File uploads return raw ingestor output immediately (no LLM generation)
+- Each file upload is processed through the ingestor
+- Suitable for immediate analysis results (e.g., Whisp API responses)
 
 **Example Conversation Flow:**
 ```
@@ -125,15 +113,15 @@ User: [Uploads plot_boundaries.geojson]
 System: [Returns API analysis results directly - no LLM processing]
 
 User: "What deforestation risks were identified?"
-System: [Uses cached GeoJSON results + retrieval → LLM generation]
+System: [Conversation history + Retrieval → Generator - processes as standard query]
 
 User: "How does this compare to EUDR requirements?"
-System: [Uses same cached results + conversation history + retrieval → LLM generation]
+System: [Conversation history + Retrieval → Generator - processes as standard query]
 ```
 
 #### Mode 2: Standard RAG (DIRECT_OUTPUT = False)
 
-**Purpose:** Traditional RAG pipeline where uploaded files are treated as additional context for generation from first instance.
+**Purpose:** Traditional RAG pipeline where uploaded files are treated as additional context for query-based generation from first instance.
 
 **Every Query (with or without file):**
 ```
@@ -146,7 +134,6 @@ Query + Optional File → Detect Type → Ingest → Retrieved Context → Combi
 - Files are processed through ingestor when uploaded
 - Ingestor output is added to the retrieval context (not returned directly)
 - Generator always processes the combined context (ingestor + retriever)
-- No special caching or deduplication logic
 
 **Example Conversation Flow:**
 ```
@@ -157,29 +144,6 @@ User: "Summarize section 3"
 System: [Retrieval → Combined Context → Generator]
 ```
 
-### File Hash Caching Mechanism
-
-The orchestrator uses SHA256 hashing to detect duplicate file uploads:
-
-**Cache Structure:**
-```python
-{
-  "a3f5c91...": {
-    "ingestor_context": "API results...",
-    "timestamp": "2025-10-02T14:30:00",
-    "filename": "boundaries.geojson",
-    "file_type": "geojson"
-  }
-}
-```
-
-**Detection Logic:**
-1. File is uploaded
-2. Compute SHA256 hash of file content
-3. Check if hash exists in cache
-4. If not found: Process through ingestor, cache results
-5. If found: Use cached results (Skip Ingestion → Retrieved Context → Combined Context → Generator)
-
 
 ### Conversation Context Management
 
@@ -196,7 +160,7 @@ The system maintains conversation history separately from file processing with a
 - Ensures relevant document retrieval based on current question
 
 **Generation Context:**
-- Combines: Conversation history + Retrieved context + Cached file results
+- Combines: Conversation history + Retrieved context + File ingestor results (if present)
 - Generator uses full context to produce coherent, contextually-aware responses
 
 
@@ -207,7 +171,6 @@ The system maintains conversation history separately from file processing with a
 - LangServe endpoints for ChatUI integration
 - Gradio web interface for testing
 - FastAPI endpoints for diagnostics and future use (e.g. /health)
-- Cache management endpoint (for direct output use cases)
 
 **Key Functions:**
 - `chatui_adapter()`: Handles text-only queries
@@ -230,8 +193,6 @@ LangGraph nodes that implement the processing pipeline:
 **Helper Functions:**
 
 - `process_query_streaming()`: Unified streaming interface
-- `compute_file_hash()`: SHA256 hashing for deduplication
-- `clear_direct_output_cache()`: Cache management
 
 ### 3. Data Models (`models.py`)
 
@@ -567,19 +528,6 @@ Content-Type: application/json
 }
 ```
 
-#### Clear Cache
-```
-POST /clear-cache
-```
-Clears the direct output file cache.
-
-**Response:**
-```json
-{
-  "status": "cache cleared"
-}
-```
-
 ### Gradio Interface
 
 #### Interactive Query
@@ -612,16 +560,7 @@ Gradio's default API endpoint for UI interactions. If running on huggingface spa
 - Consider enabling `DIRECT_OUTPUT` for suitable file types
 - Check logs for retrieval/generation bottlenecks
 
-#### 3. Cache Not Clearing
-
-**Symptoms:** Same file shows cached results when it shouldn't
-
-**Solutions:**
-- Call `/clear-cache` endpoint
-- Restart the service (clears in-memory cache)
-- Check if `DIRECT_OUTPUT=True` in config
-
-#### 4. Service Connection Errors
+#### 3. Service Connection Errors
 
 **Symptoms:** "Connection refused" or timeout errors
 
@@ -635,7 +574,7 @@ Gradio's default API endpoint for UI interactions. If running on huggingface spa
 ### Version History
 
 - **v1.0.0**: Initial release with LangGraph orchestration
-- Current implementation supports streaming, caching, and dual-mode processing
+- Current implementation supports streaming and dual-mode processing
 
 ---
 

app/main.py

@@ -40,14 +40,13 @@ workflow.add_node("direct_output", direct_output_node)
 workflow.add_node("retrieve", retrieve_node)
 workflow.add_node("generate", generate_node_streaming)
 
-# Simple linear path - node logic handles caching and routing
+# Simple linear path - node logic handles routing
 workflow.add_edge(START, "detect_file_type")
 workflow.add_edge("detect_file_type", "ingest")
 
 # Route after ingestion based on direct output mode
-# Direct output files route to direct_output only on FIRST upload
-# This allows for follow-up queries to go through the full pipeline
-# Cached direct output files route to standard (retrieve + generate)
+# Direct output mode routes to direct_output (return ingestor results)
+# Standard mode routes to retrieve + generate (full RAG pipeline)
 workflow.add_conditional_edges(
     "ingest",
     route_workflow,
@@ -264,20 +263,11 @@ async def root():
             "health": "/health",
             "chatfed-ui-stream": "/chatfed-ui-stream (LangServe)",  
             "chatfed-with-file-stream": "/chatfed-with-file-stream (LangServe)",
-            "clear-cache": "/clear-cache (Clear direct output cache)",
             "gradio": "/gradio"
         }
     }
 
 
-@app.post("/clear-cache")
-async def clear_cache():
-    """Clear the direct output file cache"""
-    from nodes import clear_direct_output_cache
-    clear_direct_output_cache()
-    return {"status": "cache cleared"}
-
-
 #----------------------------------------
 # LANGSERVE ROUTES - endpoints for ChatUI
 #----------------------------------------

app/nodes.py

@@ -1,6 +1,5 @@
 import tempfile
 import os
-import hashlib
 from models import GraphState
 from datetime import datetime
 from gradio_client import Client, file
@@ -8,7 +7,7 @@ import logging
 import dotenv
 import httpx
 import json
-from typing import Generator, Optional, Dict
+from typing import Generator, Optional
 
 from utils import detect_file_type, convert_context_to_list, merge_state, getconfig
 from retriever_adapter import RetrieverAdapter
@@ -29,16 +28,6 @@ DIRECT_OUTPUT_ENABLED = config.getboolean("file_processing", "DIRECT_OUTPUT", fa
 
 retriever_adapter = RetrieverAdapter("params.cfg")
 
-# Cache ONLY for direct output from ingestor (to prevent re-displaying results)
-# Standard output file uploads are NOT cached - they always go through normal processing
-# This means ChatUI will resend the file alongside conversation history with each turn
-_direct_output_cache: Dict[str, dict] = {}
-
-
-def compute_file_hash(file_content: bytes) -> str:
-    """Compute SHA256 hash of file content for duplicate detection"""
-    return hashlib.sha256(file_content).hexdigest()
-
 
 #----------------------------------------
 # LANGGRAPH NODE FUNCTIONS
@@ -48,23 +37,13 @@ def detect_file_type_node(state: GraphState) -> GraphState:
     """Detect file type and determine workflow"""
     file_type = "unknown"
     workflow_type = "standard"
-    is_cached_direct_output = False
     
     if state.get("file_content") and state.get("filename"):
         file_type = detect_file_type(state["filename"], state["file_content"])
         
         # Check if direct output mode is enabled
         if DIRECT_OUTPUT_ENABLED:
-            # Check if we've already shown direct output for this exact file
-            file_hash = compute_file_hash(state["file_content"])
-            
-            # Comment out the cache check:
-            # if file_hash in _direct_output_cache:
-            #     logger.info(f"Direct output file already processed (hash: {file_hash[:8]}...) - will route to standard RAG for follow-up")
-            #     workflow_type = "standard"  # Override to standard for follow-up queries
-            #     is_cached_direct_output = True
-            # else:
-            logger.info(f"Direct output mode enabled - new file will show ingestor results directly")
+            logger.info(f"Direct output mode enabled - file will show ingestor results directly")
             workflow_type = "direct_output"
         else:
             # Direct output disabled - use standard workflow
@@ -75,16 +54,12 @@ def detect_file_type_node(state: GraphState) -> GraphState:
     metadata.update({
         "file_type": file_type,
         "workflow_type": workflow_type,
-        "is_cached_direct_output": is_cached_direct_output,
         "direct_output_enabled": DIRECT_OUTPUT_ENABLED
     })
     
-    file_hash = compute_file_hash(state["file_content"]) if state.get("file_content") else None
-    
     return {
         "file_type": file_type,
         "workflow_type": workflow_type,
-        "file_hash": file_hash,
         "metadata": metadata
     }
 
@@ -98,25 +73,6 @@ def ingest_node(state: GraphState) -> GraphState:
         return {"ingestor_context": "", "metadata": state.get("metadata", {})}
     
     file_type = state.get("file_type", "unknown")
-    file_hash = state.get("file_hash")
-    
-    # Check cache ONLY if direct output is enabled and file was previously processed
-    # if DIRECT_OUTPUT_ENABLED and file_hash and file_hash in _direct_output_cache:
-    #     cached_data = _direct_output_cache[file_hash]
-    #     logger.info(f"Using cached result for direct output file: {state['filename']}")
-        
-    #     metadata = state.get("metadata", {})
-    #     metadata.update({
-    #         "ingestion_duration": 0,
-    #         "ingestor_context_length": len(cached_data["ingestor_context"]),
-    #         "ingestion_success": True,
-    #         "cached": True,
-    #         "cache_timestamp": cached_data["timestamp"]
-    #     })
-        
-    #     return {"ingestor_context": cached_data["ingestor_context"], "metadata": metadata}
-    
-    # Standard processing (both for new direct output files and all standard files)
     logger.info(f"Ingesting {file_type} file: {state['filename']}")
     
     try:
@@ -139,24 +95,13 @@ def ingest_node(state: GraphState) -> GraphState:
         finally:
             os.unlink(tmp_file_path)
         
-        # Cache ONLY if direct output mode is enabled
-        # if DIRECT_OUTPUT_ENABLED and file_hash:
-        #     _direct_output_cache[file_hash] = {
-        #         "ingestor_context": ingestor_context,
-        #         "timestamp": datetime.now().isoformat(),
-        #         "filename": state["filename"],
-        #         "file_type": file_type
-        #     }
-        #     logger.info(f"Cached direct output result for file hash: {file_hash[:8]}...")
-        
         duration = (datetime.now() - start_time).total_seconds()
         metadata = state.get("metadata", {})
         metadata.update({
             "ingestion_duration": duration,
             "ingestor_context_length": len(ingestor_context) if ingestor_context else 0,
             "ingestion_success": True,
-            "ingestor_used": ingestor_url,
-            "cached": False
+            "ingestor_used": ingestor_url
         })
         
         return {"ingestor_context": ingestor_context, "metadata": metadata}
@@ -177,7 +122,6 @@ def ingest_node(state: GraphState) -> GraphState:
 def direct_output_node(state: GraphState) -> GraphState:
     """
     For files when direct output mode is enabled, return ingestor results directly.
-    This node is only reached on FIRST upload when DIRECT_OUTPUT=True.
     """
     file_type = state.get('file_type', 'unknown')
     logger.info(f"Direct output mode - returning ingestor results for {file_type} file")
@@ -384,8 +328,7 @@ async def generate_node_streaming(state: GraphState) -> Generator[GraphState, No
 def route_workflow(state: GraphState) -> str:
     """
     Conditional routing based on workflow type after ingestion.
-    Returns 'direct_output' for NEW files when DIRECT_OUTPUT=True,
-    'standard' for everything else (standard mode + cached direct output files).
+    Returns 'direct_output' when DIRECT_OUTPUT=True, 'standard' otherwise.
     """
     workflow_type = state.get("workflow_type", "standard")
     logger.info(f"Routing to: {workflow_type}")
@@ -527,11 +470,4 @@ async def process_query_streaming(
         if output_format == "structured":
             yield {"type": "error", "content": f"Error: {str(e)}"}
         else:
-            yield f"Error: {str(e)}"
-
-
-def clear_direct_output_cache():
-    """Utility function to clear the direct output cache"""
-    global _direct_output_cache
-    _direct_output_cache.clear()
-    logger.info("Direct output cache cleared")
+            yield f"Error: {str(e)}"