Update veryfinal.py

veryfinal.py

@@ -82,22 +82,10 @@ try:
 except ImportError:
     GROQ_AVAILABLE = False
 
-try:
-    from langchain_nvidia_ai_endpoints import ChatNVIDIA
-    NVIDIA_AVAILABLE = True
-except ImportError:
-    NVIDIA_AVAILABLE = False
-
-try:
-    import google.generativeai as genai
-    GEMINI_AVAILABLE = True
-except ImportError:
-    GEMINI_AVAILABLE = False
-
 import requests
 
 def deepseek_generate(prompt, api_key=None):
-    """Call DeepSeek API."""
+    """Call DeepSeek API directly."""
     if not api_key:
         return "DeepSeek API key not provided"
     
@@ -122,15 +110,28 @@ def deepseek_generate(prompt, api_key=None):
         return f"DeepSeek API error: {e}"
 
 def baidu_ernie_generate(prompt, api_key=None):
-    """Call Baidu ERNIE API (placeholder implementation)."""
+    """Call Baidu ERNIE API."""
     if not api_key:
         return "Baidu ERNIE API key not provided"
     
-    # Note: This is a placeholder. Replace with actual Baidu ERNIE API endpoint
+    # Baidu ERNIE API endpoint (replace with actual endpoint)
+    url = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+    data = {
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.1,
+        "top_p": 0.8
+    }
     try:
-        return f"Baidu ERNIE response for: {prompt[:50]}..."
+        resp = requests.post(url, headers=headers, json=data, timeout=30)
+        resp.raise_for_status()
+        result = resp.json().get("result", "")
+        return result if result else "No response from Baidu ERNIE"
     except Exception as e:
-        return f"ERNIE API error: {e}"
+        return f"Baidu ERNIE API error: {e}"
 
 # ---- Graph State ----
 class EnhancedAgentState(TypedDict):
@@ -151,38 +152,24 @@ class HybridLangGraphMultiLLMSystem:
         self.graph = self._build_graph()
 
     def _build_graph(self):
-        # Initialize LLMs with error handling
+        # Initialize Groq LLM with error handling
         groq_llm = None
-        nvidia_llm = None
         
         if GROQ_AVAILABLE and os.getenv("GROQ_API_KEY"):
             try:
+                # Use Groq for multiple model access
                 groq_llm = ChatGroq(
-                    model="llama3-70b-8192", 
+                    model="llama-3.1-70b-versatile",  # Updated to a current model
                     temperature=0, 
                     api_key=os.getenv("GROQ_API_KEY")
                 )
             except Exception as e:
                 print(f"Failed to initialize Groq: {e}")
-        
-        if NVIDIA_AVAILABLE and os.getenv("NVIDIA_API_KEY"):
-            try:
-                nvidia_llm = ChatNVIDIA(
-                    model="meta/llama3-70b-instruct", 
-                    temperature=0, 
-                    api_key=os.getenv("NVIDIA_API_KEY")
-                )
-            except Exception as e:
-                print(f"Failed to initialize NVIDIA: {e}")
 
         def router(st: EnhancedAgentState) -> EnhancedAgentState:
             q = st["query"].lower()
             if "groq" in q and groq_llm:      
                 t = "groq"
-            elif "nvidia" in q and nvidia_llm:  
-                t = "nvidia"
-            elif ("gemini" in q or "google" in q) and GEMINI_AVAILABLE: 
-                t = "gemini"
             elif "deepseek" in q: 
                 t = "deepseek"
             elif "ernie" in q or "baidu" in q: 
@@ -191,12 +178,10 @@ class HybridLangGraphMultiLLMSystem:
                 # Default to first available provider
                 if groq_llm:
                     t = "groq"
-                elif nvidia_llm:
-                    t = "nvidia"
-                elif GEMINI_AVAILABLE:
-                    t = "gemini"
-                else:
+                elif os.getenv("DEEPSEEK_API_KEY"):
                     t = "deepseek"
+                else:
+                    t = "baidu"
             return {**st, "agent_type": t}
 
         def groq_node(st: EnhancedAgentState) -> EnhancedAgentState:
@@ -205,45 +190,17 @@ class HybridLangGraphMultiLLMSystem:
             
             t0 = time.time()
             try:
-                sys = SystemMessage(content="You are a helpful AI assistant. Provide accurate and detailed answers.")
+                sys = SystemMessage(content="You are a helpful AI assistant. Provide accurate and detailed answers. Be concise but thorough.")
                 res = groq_llm.invoke([sys, HumanMessage(content=st["query"])])
                 return {**st, "final_answer": res.content, "perf": {"time": time.time() - t0, "prov": "Groq"}}
             except Exception as e:
                 return {**st, "final_answer": f"Groq error: {e}", "perf": {"error": str(e)}}
 
-        def nvidia_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            if not nvidia_llm:
-                return {**st, "final_answer": "NVIDIA not available", "perf": {"error": "No NVIDIA LLM"}}
-            
-            t0 = time.time()
-            try:
-                sys = SystemMessage(content="You are a helpful AI assistant. Provide accurate and detailed answers.")
-                res = nvidia_llm.invoke([sys, HumanMessage(content=st["query"])])
-                return {**st, "final_answer": res.content, "perf": {"time": time.time() - t0, "prov": "NVIDIA"}}
-            except Exception as e:
-                return {**st, "final_answer": f"NVIDIA error: {e}", "perf": {"error": str(e)}}
-
-        def gemini_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            if not GEMINI_AVAILABLE:
-                return {**st, "final_answer": "Gemini not available", "perf": {"error": "Gemini not installed"}}
-            
-            t0 = time.time()
-            try:
-                api_key = os.getenv("GEMINI_API_KEY")
-                if not api_key:
-                    return {**st, "final_answer": "Gemini API key not provided", "perf": {"error": "No API key"}}
-                
-                genai.configure(api_key=api_key)
-                model = genai.GenerativeModel("gemini-1.5-pro-latest")
-                res = model.generate_content(st["query"])
-                return {**st, "final_answer": res.text, "perf": {"time": time.time() - t0, "prov": "Gemini"}}
-            except Exception as e:
-                return {**st, "final_answer": f"Gemini error: {e}", "perf": {"error": str(e)}}
-
         def deepseek_node(st: EnhancedAgentState) -> EnhancedAgentState:
             t0 = time.time()
             try:
-                resp = deepseek_generate(st["query"], api_key=os.getenv("DEEPSEEK_API_KEY"))
+                prompt = f"You are a helpful AI assistant. Provide accurate and detailed answers. Be concise but thorough.\n\nUser question: {st['query']}"
+                resp = deepseek_generate(prompt, api_key=os.getenv("DEEPSEEK_API_KEY"))
                 return {**st, "final_answer": resp, "perf": {"time": time.time() - t0, "prov": "DeepSeek"}}
             except Exception as e:
                 return {**st, "final_answer": f"DeepSeek error: {e}", "perf": {"error": str(e)}}
@@ -251,10 +208,11 @@ class HybridLangGraphMultiLLMSystem:
         def baidu_node(st: EnhancedAgentState) -> EnhancedAgentState:
             t0 = time.time()
             try:
-                resp = baidu_ernie_generate(st["query"], api_key=os.getenv("BAIDU_API_KEY"))
-                return {**st, "final_answer": resp, "perf": {"time": time.time() - t0, "prov": "ERNIE"}}
+                prompt = f"You are a helpful AI assistant. Provide accurate and detailed answers. Be concise but thorough.\n\nUser question: {st['query']}"
+                resp = baidu_ernie_generate(prompt, api_key=os.getenv("BAIDU_API_KEY"))
+                return {**st, "final_answer": resp, "perf": {"time": time.time() - t0, "prov": "Baidu ERNIE"}}
             except Exception as e:
-                return {**st, "final_answer": f"ERNIE error: {e}", "perf": {"error": str(e)}}
+                return {**st, "final_answer": f"Baidu ERNIE error: {e}", "perf": {"error": str(e)}}
 
         def pick(st: EnhancedAgentState) -> str:
             return st["agent_type"]
@@ -262,19 +220,15 @@ class HybridLangGraphMultiLLMSystem:
         g = StateGraph(EnhancedAgentState)
         g.add_node("router", router)
         g.add_node("groq", groq_node)
-        g.add_node("nvidia", nvidia_node)
-        g.add_node("gemini", gemini_node)
         g.add_node("deepseek", deepseek_node)
         g.add_node("baidu", baidu_node)
         g.set_entry_point("router")
         g.add_conditional_edges("router", pick, {
             "groq": "groq",
-            "nvidia": "nvidia",
-            "gemini": "gemini",
-            "deepseek": "deepseek",
+            "deepseek": "deepseek", 
             "baidu": "baidu"
         })
-        for n in ["groq", "nvidia", "gemini", "deepseek", "baidu"]:
+        for n in ["groq", "deepseek", "baidu"]:
             g.add_edge(n, END)
         return g.compile(checkpointer=MemorySaver())
 
@@ -294,9 +248,7 @@ class HybridLangGraphMultiLLMSystem:
             
             # Clean up the answer
             if isinstance(raw_answer, str):
-                parts = raw_answer.split('\n\n')
-                answer_part = parts[1].strip() if len(parts) > 1 and len(parts[1].strip()) > 10 else raw_answer.strip()
-                return answer_part
+                return raw_answer.strip()
             return str(raw_answer)
         except Exception as e:
             return f"Error processing query: {e}"
@@ -308,7 +260,7 @@ def build_graph(provider="groq"):
     return system.graph
 
 if __name__ == "__main__":
-    query = "What are the names of the US presidents who were assassinated?"
+    query = "What are the main benefits of using multiple LLM providers?"
     system = HybridLangGraphMultiLLMSystem()
     result = system.process_query(query)
-    print("LangGraph Hybrid Result:", result)
+    print("LangGraph Multi-LLM Result:", result)