Update langgraph_nodes.py

langgraph_nodes.py

@@ -1,7 +1,6 @@
 """
-LangGraph Nodes
-All node functions for the review processing graph
-Implements parallel execution where possible
+LangGraph Nodes - FIXED VERSION
+Better error handling and debugging for API calls
 """
 
 import os
@@ -19,9 +18,17 @@ warnings.filterwarnings('ignore')
 from langgraph_state import ReviewState, BatchState
 from database_enhanced import EnhancedDatabase
 
-# Initialize HF client (singleton)
+# FIXED: Initialize HF client with better error handling
 HF_TOKEN = os.getenv("HUGGINGFACE_API_KEY")
-hf_client = InferenceClient(token=HF_TOKEN) if HF_TOKEN else None
+
+# Check if token exists
+if not HF_TOKEN or HF_TOKEN.strip() == "":
+    print("❌ WARNING: HUGGINGFACE_API_KEY not set!")
+    print("   API calls will fail. Please set your API key.")
+    hf_client = None
+else:
+    print(f"✅ HF Token found: {HF_TOKEN[:8]}...")
+    hf_client = InferenceClient(token=HF_TOKEN)
 
 # Initialize sentiment models (singleton) - load once
 _sentiment_models_loaded = False
@@ -59,6 +66,20 @@ def load_sentiment_models():
 
 def llm1_classify(review: Dict[str, Any]) -> Dict[str, Any]:
     """LLM1: Type, Department, Priority classification"""
+    
+    # FIXED: Check if client exists
+    if hf_client is None:
+        print("❌ ERROR: HuggingFace client not initialized!")
+        print("   Make sure HUGGINGFACE_API_KEY environment variable is set")
+        return {
+            'type': 'unknown',
+            'department': 'unknown',
+            'priority': 'medium',
+            'confidence': 0.0,
+            'reasoning': 'HuggingFace API key not set',
+            'model': 'Qwen/Qwen2.5-72B-Instruct'
+        }
+    
     review_text = review.get('review_text', '')
     rating = review.get('rating', 3)
     
@@ -103,6 +124,9 @@ Respond ONLY in valid JSON format:
 }}"""
 
     try:
+        # FIXED: Better error logging
+        print(f"   🔍 Calling Qwen API...")
+        
         response = hf_client.text_generation(
             prompt,
             model="Qwen/Qwen2.5-72B-Instruct",
@@ -110,6 +134,8 @@ Respond ONLY in valid JSON format:
             temperature=0.1
         )
         
+        print(f"   ✅ Got response ({len(response)} chars)")
+        
         # Clean and parse JSON
         response_clean = response.strip()
         if response_clean.startswith('```'):
@@ -120,21 +146,41 @@ Respond ONLY in valid JSON format:
         
         result = json.loads(response_clean)
         result['model'] = 'Qwen/Qwen2.5-72B-Instruct'
+        
+        print(f"   ✅ Parsed: {result['type']} → {result['department']}")
         return result
         
     except Exception as e:
+        # FIXED: Show the actual error
+        print(f"❌ LLM1 ERROR: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        
         return {
             'type': 'unknown',
             'department': 'unknown',
             'priority': 'medium',
             'confidence': 0.0,
-            'reasoning': f'Error: {str(e)}',
+            'reasoning': f'API Error: {str(e)}',
             'model': 'Qwen/Qwen2.5-72B-Instruct'
         }
 
 
 def llm2_analyze(review: Dict[str, Any]) -> Dict[str, Any]:
     """LLM2: User type, Emotion, Context analysis"""
+    
+    # FIXED: Check if client exists
+    if hf_client is None:
+        print("❌ ERROR: HuggingFace client not initialized!")
+        return {
+            'user_type': 'unknown',
+            'emotion': 'unknown',
+            'context': 'unknown',
+            'confidence': 0.0,
+            'reasoning': 'HuggingFace API key not set',
+            'model': 'mistralai/Mistral-7B-Instruct-v0.3'
+        }
+    
     review_text = review.get('review_text', '')
     rating = review.get('rating', 3)
     
@@ -176,6 +222,9 @@ Respond ONLY in valid JSON format:
 }}"""
 
     try:
+        # FIXED: Better error logging
+        print(f"   🔍 Calling Mistral API...")
+        
         response = hf_client.text_generation(
             prompt,
             model="mistralai/Mistral-7B-Instruct-v0.3",
@@ -183,6 +232,8 @@ Respond ONLY in valid JSON format:
             temperature=0.1
         )
         
+        print(f"   ✅ Got response ({len(response)} chars)")
+        
         # Clean and parse JSON
         response_clean = response.strip()
         if response_clean.startswith('```'):
@@ -193,21 +244,40 @@ Respond ONLY in valid JSON format:
         
         result = json.loads(response_clean)
         result['model'] = 'mistralai/Mistral-7B-Instruct-v0.3'
+        
+        print(f"   ✅ Parsed: {result['user_type']}, {result['emotion']}")
         return result
         
     except Exception as e:
+        # FIXED: Show the actual error
+        print(f"❌ LLM2 ERROR: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        
         return {
             'user_type': 'unknown',
             'emotion': 'unknown',
             'context': 'unknown',
             'confidence': 0.0,
-            'reasoning': f'Error: {str(e)}',
+            'reasoning': f'API Error: {str(e)}',
             'model': 'mistralai/Mistral-7B-Instruct-v0.3'
         }
 
 
 def manager_synthesize(llm1_result: Dict, llm2_result: Dict, review: Dict) -> Dict[str, Any]:
     """Manager: Synthesize LLM1 and LLM2 results"""
+    
+    # FIXED: Check if client exists
+    if hf_client is None:
+        print("❌ ERROR: HuggingFace client not initialized!")
+        return {
+            'final_type': llm1_result.get('type', 'unknown'),
+            'final_department': llm1_result.get('department', 'unknown'),
+            'final_priority': llm1_result.get('priority', 'medium'),
+            'synthesis_reasoning': 'HuggingFace API key not set',
+            'model': 'meta-llama/Llama-3.3-70B-Instruct'
+        }
+    
     review_text = review.get('review_text', '')
     rating = review.get('rating', 3)
     
@@ -234,22 +304,22 @@ Respond ONLY in valid JSON format:
   "final_type": "from llm1 or adjusted",
   "final_department": "from llm1 or adjusted",
   "final_priority": "from llm1 or adjusted",
-  "final_user_type": "from llm2 or adjusted",
-  "final_emotion": "from llm2 or adjusted",
-  "confidence": 0.0-1.0,
-  "reasoning": "synthesis explanation",
-  "conflicts_found": "any conflicts or 'none'"
+  "synthesis_reasoning": "brief explanation of synthesis"
 }}"""
 
     try:
+        # FIXED: Better error logging
+        print(f"   🔍 Calling Llama Manager API...")
+        
         response = hf_client.text_generation(
             prompt,
-            model="meta-llama/Llama-3.1-8B-Instruct",
-            max_new_tokens=250,
+            model="meta-llama/Llama-3.3-70B-Instruct",
+            max_new_tokens=200,
             temperature=0.1
         )
         
-        # Clean and parse JSON
+        print(f"   ✅ Got response ({len(response)} chars)")
+        
         response_clean = response.strip()
         if response_clean.startswith('```'):
             response_clean = response_clean.split('```')[1]
@@ -258,21 +328,21 @@ Respond ONLY in valid JSON format:
         response_clean = response_clean.strip()
         
         result = json.loads(response_clean)
-        result['model'] = 'meta-llama/Llama-3.1-8B-Instruct'
+        result['model'] = 'meta-llama/Llama-3.3-70B-Instruct'
+        
+        print(f"   ✅ Manager decision: {result['final_type']} → {result['final_department']}")
         return result
         
     except Exception as e:
-        # Fallback to LLM1 results
+        # FIXED: Show the actual error
+        print(f"❌ MANAGER ERROR: {type(e).__name__}: {str(e)}")
+        
         return {
             'final_type': llm1_result.get('type', 'unknown'),
             'final_department': llm1_result.get('department', 'unknown'),
             'final_priority': llm1_result.get('priority', 'medium'),
-            'final_user_type': llm2_result.get('user_type', 'unknown'),
-            'final_emotion': llm2_result.get('emotion', 'unknown'),
-            'confidence': 0.5,
-            'reasoning': f'Manager error, used LLM1 results: {str(e)}',
-            'conflicts_found': 'error',
-            'model': 'meta-llama/Llama-3.1-8B-Instruct'
+            'synthesis_reasoning': f'Manager error: {str(e)}',
+            'model': 'meta-llama/Llama-3.3-70B-Instruct'
         }
 
 
@@ -285,35 +355,42 @@ def stage1_classification_node(state: ReviewState) -> Dict[str, Any]:
     print(f"      ⏳ STAGE 1: Classification (Parallel LLM1 + LLM2)...")
     
     start_time = time.time()
+    review_dict = dict(state)
     
     # PARALLEL EXECUTION: LLM1 and LLM2 run simultaneously
     with ThreadPoolExecutor(max_workers=2) as executor:
-        future1 = executor.submit(llm1_classify, state['review'])
-        future2 = executor.submit(llm2_analyze, state['review'])
+        future_llm1 = executor.submit(llm1_classify, review_dict)
+        future_llm2 = executor.submit(llm2_analyze, review_dict)
         
-        llm1_result = future1.result()
-        llm2_result = future2.result()
+        llm1_result = future_llm1.result()
+        llm2_result = future_llm2.result()
     
-    print(f"         ✅ LLM1: {llm1_result.get('type')} → {llm1_result.get('department')} (Priority: {llm1_result.get('priority')})")
-    print(f"         ✅ LLM2: {llm2_result.get('user_type')}, {llm2_result.get('emotion')}")
+    print(f"         ✅ LLM1: {llm1_result['type']} → {llm1_result['department']} (Priority: {llm1_result['priority']})")
+    print(f"         ✅ LLM2: {llm2_result['user_type']}, {llm2_result['emotion']}")
     
-    # Manager synthesizes sequentially (needs both results)
+    # Manager synthesizes results
     print(f"         🤖 Manager synthesizing...")
-    manager_result = manager_synthesize(llm1_result, llm2_result, state['review'])
+    manager_result = manager_synthesize(llm1_result, llm2_result, review_dict)
     
     stage1_time = time.time() - start_time
     print(f"      ✅ Stage 1 complete ({stage1_time:.2f}s)")
     
-    # Update state
+    # Save to database
+    db = EnhancedDatabase()
+    db.connect()
+    db.save_stage1_results(state['review_id'], llm1_result, llm2_result, manager_result)
+    db.close()
+    
     return {
         "llm1_result": llm1_result,
         "llm2_result": llm2_result,
         "manager_result": manager_result,
-        "classification_type": manager_result.get('final_type'),
-        "department": manager_result.get('final_department'),
-        "priority": manager_result.get('final_priority'),
-        "user_type": manager_result.get('final_user_type'),
-        "emotion": manager_result.get('final_emotion'),
+        "classification_type": manager_result['final_type'],
+        "department": manager_result['final_department'],
+        "priority": manager_result['final_priority'],
+        "user_type": llm2_result['user_type'],
+        "emotion": llm2_result['emotion'],
+        "context": llm2_result.get('context', ''),
         "stage1_completed": True,
         "stage1_time": stage1_time,
         "errors": state.get('errors', [])
@@ -321,11 +398,11 @@ def stage1_classification_node(state: ReviewState) -> Dict[str, Any]:
 
 
 # ============================================================================
-# STAGE 2: SENTIMENT NODE (Parallel Best + Alternate)
+# STAGE 2: SENTIMENT ANALYSIS
 # ============================================================================
 
 def analyze_best_sentiment(text: str) -> Dict[str, Any]:
-    """Best Model: Twitter-RoBERTa"""
+    """Best Model: Twitter-BERT"""
     load_sentiment_models()
     
     try:
@@ -348,6 +425,7 @@ def analyze_best_sentiment(text: str) -> Dict[str, Any]:
             'model': 'twitter-roberta-base-sentiment-latest'
         }
     except Exception as e:
+        print(f"❌ Best sentiment ERROR: {e}")
         return {
             'sentiment': 'NEUTRAL',
             'confidence': 0.0,
@@ -383,6 +461,7 @@ def analyze_alt_sentiment(text: str) -> Dict[str, Any]:
             'model': 'bertweet-base-sentiment-analysis'
         }
     except Exception as e:
+        print(f"❌ Alt sentiment ERROR: {e}")
         return {
             'sentiment': 'NEUTRAL',
             'confidence': 0.0,
@@ -455,6 +534,12 @@ def stage2_sentiment_node(state: ReviewState) -> Dict[str, Any]:
     stage2_time = time.time() - start_time
     print(f"      ✅ Stage 2 complete ({stage2_time:.2f}s)")
     
+    # Save to database
+    db = EnhancedDatabase()
+    db.connect()
+    db.save_stage2_results(state['review_id'], best_result, alt_result, layer_result)
+    db.close()
+    
     return {
         "best_sentiment_result": best_result,
         "alt_sentiment_result": alt_result,
@@ -480,6 +565,43 @@ def stage3_finalization_node(state: ReviewState) -> Dict[str, Any]:
     
     start_time = time.time()
     
+    # FIXED: Check if client exists
+    if hf_client is None:
+        print("❌ ERROR: HuggingFace client not initialized!")
+        print("   Skipping Stage 3 (requires API key)")
+        
+        result = {
+            'final_sentiment': state.get('sentiment', 'NEUTRAL'),
+            'confidence': state.get('sentiment_confidence', 0.0),
+            'reasoning': 'Stage 3 skipped - HuggingFace API key not set',
+            'validation_notes': 'API key missing',
+            'conflicts_found': 'none',
+            'action_recommendation': f"Route to {state.get('department', 'support')}",
+            'needs_human_review': True,
+            'model': 'meta-llama/Llama-3.1-70B-Instruct'
+        }
+        
+        stage3_time = 0.00
+        print(f"         ✅ Final: {result['final_sentiment']} ({result.get('confidence', 0):.3f})")
+        print(f"         📋 Needs Review: {result.get('needs_human_review', False)}")
+        print(f"      ✅ Stage 3 complete ({stage3_time:.2f}s)")
+        
+        return {
+            "final_result": result,
+            "final_sentiment": result['final_sentiment'],
+            "final_confidence": result['confidence'],
+            "reasoning": result['reasoning'],
+            "action_recommendation": result['action_recommendation'],
+            "conflicts_found": result['conflicts_found'],
+            "validation_notes": result['validation_notes'],
+            "needs_human_review": result['needs_human_review'],
+            "stage3_completed": True,
+            "stage3_time": stage3_time,
+            "total_time": state.get('stage1_time', 0) + state.get('stage2_time', 0),
+            "processing_completed_at": datetime.now().isoformat(),
+            "errors": state.get('errors', [])
+        }
+    
     review_text = state['review_text']
     rating = state['rating']
     
@@ -520,6 +642,9 @@ Respond ONLY in valid JSON format:
 }}"""
 
     try:
+        # FIXED: Better error logging
+        print(f"   🔍 Calling Llama 70B API...")
+        
         response = hf_client.text_generation(
             prompt,
             model="meta-llama/Llama-3.1-70B-Instruct",
@@ -527,6 +652,8 @@ Respond ONLY in valid JSON format:
             temperature=0.1
         )
         
+        print(f"   ✅ Got response ({len(response)} chars)")
+        
         response_clean = response.strip()
         if response_clean.startswith('```'):
             response_clean = response_clean.split('```')[1]
@@ -538,6 +665,11 @@ Respond ONLY in valid JSON format:
         result['model'] = 'meta-llama/Llama-3.1-70B-Instruct'
         
     except Exception as e:
+        # FIXED: Show the actual error
+        print(f"❌ STAGE 3 ERROR: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        
         result = {
             'final_sentiment': state.get('sentiment', 'NEUTRAL'),
             'confidence': state.get('sentiment_confidence', 0.5),
@@ -558,6 +690,12 @@ Respond ONLY in valid JSON format:
     # Calculate total time
     total_time = state.get('stage1_time', 0) + state.get('stage2_time', 0) + stage3_time
     
+    # Save to database
+    db = EnhancedDatabase()
+    db.connect()
+    db.save_stage3_results(state['review_id'], result)
+    db.close()
+    
     return {
         "final_result": result,
         "final_sentiment": result['final_sentiment'],
@@ -580,4 +718,4 @@ if __name__ == "__main__":
     print("   Nodes available:")
     print("   - stage1_classification_node (parallel LLM1+LLM2)")
     print("   - stage2_sentiment_node (parallel Best+Alt)")
-    print("   - stage3_finalization_node (LLM3)")
+    print("   - stage3_finalization_node (LLM3)")