Update veryfinal.py

veryfinal.py

@@ -1,13 +1,13 @@
 """
-Enhanced Multi-LLM Agent System with Question-Answering Capabilities
-Supports Groq (Llama-3 8B/70B, DeepSeek), Google Gemini, NVIDIA NIM, and Agno-style agents
+Enhanced Multi-LLM Agent System - CORRECTED VERSION
+Fixes the issue where questions are returned as answers
 """
 
 import os
 import time
 import random
 import operator
-from typing import List, Dict, Any, TypedDict, Annotated, Optional
+from typing import List, Dict, Any, TypedDict, Annotated
 from dotenv import load_dotenv
 
 from langchain_core.tools import tool
@@ -18,106 +18,57 @@ from langgraph.checkpoint.memory import MemorySaver
 from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
 from langchain_groq import ChatGroq
 
-# Load environment variables
 load_dotenv()
 
-# Enhanced system prompt for question-answering tasks
+# Enhanced system prompt for proper question-answering
 ENHANCED_SYSTEM_PROMPT = (
-    '''You are a helpful assistant tasked with answering questions using a set of tools. 
-     You must provide accurate, comprehensive answers based on available information.
-     When answering questions, follow these guidelines:\n
-     1)You are a helpful assistant tasked with answering questions using a set of tools. 
-     2)Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER].
-     3)YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
-     4)Your answer should only start with "FINAL ANSWER: ", then follows with the answer.''' 
+    "You are a helpful assistant tasked with answering questions using available tools. "
+    "Follow these guidelines:\n"
+    "1. Read the question carefully and understand what is being asked\n"
+    "2. Use available tools when you need external information\n"
+    "3. Provide accurate, specific answers based on the information you find\n"
+    "4. For numbers: don't use commas or units unless specified\n"
+    "5. For strings: don't use articles or abbreviations, write digits in plain text\n"
+    "6. Always end with 'FINAL ANSWER: [YOUR ANSWER]' where [YOUR ANSWER] is concise\n"
+    "7. Never repeat the question as your answer\n"
+    "8. If you cannot find the answer, state 'Information not available'\n"
 )
 
-# ---- Tool Definitions with Enhanced Docstrings ----
+# ---- Tool Definitions ----
 @tool
-def multiply(a: int | float, b: int | float) -> int | float:
-    """Multiply two numbers.
-    
-    Args:
-        a: first int | float
-        b: second int | float
-    """
+def multiply(a: int, b: int) -> int:
+    """Multiply two integers and return the product."""
     return a * b
 
 @tool
-def add(a: int | float, b: int | float) -> int | float:
-    """
-    Adds two integers and returns the sum.
-    
-    Args:
-        a (int): First integer
-        b (int): Second integer
-        
-    Returns:
-        int: Sum of a and b
-    """
+def add(a: int, b: int) -> int:
+    """Add two integers and return the sum."""
     return a + b
 
 @tool
-def subtract(a: int | float, b: int | float) -> int | float:
-    """
-    Subtracts the second integer from the first and returns the difference.
-    
-    Args:
-        a (int): First integer (minuend)
-        b (int): Second integer (subtrahend)
-        
-    Returns:
-        int: Difference of a and b
-    """
+def subtract(a: int, b: int) -> int:
+    """Subtract the second integer from the first and return the difference."""
     return a - b
 
 @tool
-def divide(a: int | float, b: int | float) -> int | float:
-    """
-    Divides the first integer by the second and returns the quotient.
-    
-    Args:
-        a (int): Dividend
-        b (int): Divisor
-        
-    Returns:
-        float: Quotient of a divided by b
-        
-    Raises:
-        ValueError: If b is zero
-    """
-    if b == 0 or b==0.0:
+def divide(a: int, b: int) -> float:
+    """Divide the first integer by the second and return the quotient."""
+    if b == 0:
         raise ValueError("Cannot divide by zero.")
     return a / b
 
 @tool
-def modulus(a: int | float, b: int | float) -> int | float:
-    """
-    Returns the remainder when dividing the first integer by the second.
-    
-    Args:
-        a (int): Dividend
-        b (int): Divisor
-        
-    Returns:
-        int: Remainder of a divided by b
-    """
+def modulus(a: int, b: int) -> int:
+    """Return the remainder when dividing the first integer by the second."""
     return a % b
 
 @tool
 def optimized_web_search(query: str) -> str:
-    """
-    Performs an optimized web search using TavilySearchResults.
-    
-    Args:
-        query (str): Search query string
-        
-    Returns:
-        str: Concatenated search results with URLs and content snippets
-    """
+    """Perform web search using TavilySearchResults."""
     try:
         time.sleep(random.uniform(0.7, 1.5))
-        docs = TavilySearchResults(max_results=3).invoke(query=query)
+        search_tool = TavilySearchResults(max_results=3)
+        docs = search_tool.invoke({"query": query})
         return "\n\n---\n\n".join(
             f"<Doc url='{d.get('url','')}'>{d.get('content','')[:800]}</Doc>"
             for d in docs
@@ -127,15 +78,7 @@ def optimized_web_search(query: str) -> str:
 
 @tool
 def optimized_wiki_search(query: str) -> str:
-    """
-    Performs an optimized Wikipedia search and returns content snippets.
-    
-    Args:
-        query (str): Wikipedia search query
-        
-    Returns:
-        str: Wikipedia content with source attribution
-    """
+    """Perform Wikipedia search and return content."""
     try:
         time.sleep(random.uniform(0.3, 1))
         docs = WikipediaLoader(query=query, load_max_docs=2).load()
@@ -146,59 +89,22 @@ def optimized_wiki_search(query: str) -> str:
     except Exception as e:
         return f"Wikipedia search failed: {e}"
 
-# ---- LLM Provider Integrations ----
-try:
-    from langchain_nvidia_ai_endpoints import ChatNVIDIA
-    NVIDIA_AVAILABLE = True
-except ImportError:
-    NVIDIA_AVAILABLE = False
-
-try:
-    import google.generativeai as genai
-    from langchain_google_genai import ChatGoogleGenerativeAI
-    GOOGLE_AVAILABLE = True
-except ImportError:
-    GOOGLE_AVAILABLE = False
-
 # ---- Enhanced Agent State ----
 class EnhancedAgentState(TypedDict):
-    """
-    State structure for the enhanced multi-LLM agent system.
-    
-    Attributes:
-        messages: List of conversation messages
-        query: Current query string
-        agent_type: Selected agent/LLM type
-        final_answer: Generated response
-        perf: Performance metrics
-        agno_resp: Agno-style response metadata
-        tools_used: List of tools used in processing
-        reasoning: Step-by-step reasoning process
-    """
+    """State structure for the enhanced agent system."""
     messages: Annotated[List[HumanMessage | AIMessage], operator.add]
     query: str
     agent_type: str
     final_answer: str
     perf: Dict[str, Any]
     agno_resp: str
-    tools_used: List[str]
-    reasoning: str
 
 # ---- Enhanced Multi-LLM System ----
-class EnhancedQuestionAnsweringSystem:
-    """
-    Advanced question-answering system that routes queries to appropriate LLM providers
-    and uses tools to gather information for comprehensive answers.
-    
-    Features:
-    - Multi-LLM routing (Groq, Google, NVIDIA)
-    - Tool integration for web search and calculations
-    - Structured reasoning and answer formatting
-    - Performance monitoring
-    """
+class HybridLangGraphMultiLLMSystem:
+    """Enhanced question-answering system with proper response handling."""
     
     def __init__(self):
-        """Initialize the enhanced question-answering system."""
+        """Initialize the enhanced multi-LLM system."""
         self.tools = [
             multiply, add, subtract, divide, modulus,
             optimized_web_search, optimized_wiki_search
@@ -206,15 +112,7 @@ class EnhancedQuestionAnsweringSystem:
         self.graph = self._build_graph()
 
     def _llm(self, model_name: str) -> ChatGroq:
-        """
-        Create a Groq LLM instance.
-        
-        Args:
-            model_name (str): Model identifier
-            
-        Returns:
-            ChatGroq: Configured Groq LLM instance
-        """
+        """Create a Groq LLM instance."""
         return ChatGroq(
             model=model_name,
             temperature=0,
@@ -222,55 +120,53 @@ class EnhancedQuestionAnsweringSystem:
         )
 
     def _build_graph(self) -> StateGraph:
-        """
-        Build the LangGraph state machine with enhanced question-answering capabilities.
-        
-        Returns:
-            StateGraph: Compiled graph with routing logic
-        """
+        """Build the LangGraph state machine with proper response handling."""
         # Initialize LLMs
         llama8_llm = self._llm("llama3-8b-8192")
         llama70_llm = self._llm("llama3-70b-8192")
         deepseek_llm = self._llm("deepseek-chat")
 
         def router(st: EnhancedAgentState) -> EnhancedAgentState:
-            """
-            Route queries to appropriate LLM based on complexity and content.
-            
-            Args:
-                st (EnhancedAgentState): Current state
-                
-            Returns:
-                EnhancedAgentState: Updated state with agent selection
-            """
+            """Route queries to appropriate LLM based on content analysis."""
             q = st["query"].lower()
             
-            # Route based on query characteristics
-            if any(keyword in q for keyword in ["calculate", "compute", "math", "number"]):
+            # Enhanced routing logic
+            if any(keyword in q for keyword in ["calculate", "compute", "math", "multiply", "add", "subtract", "divide"]):
                 t = "llama70"  # Use more powerful model for calculations
-            elif any(keyword in q for keyword in ["search", "find", "lookup", "wikipedia"]):
+            elif any(keyword in q for keyword in ["search", "find", "lookup", "wikipedia", "information about"]):
                 t = "search_enhanced"  # Use search-enhanced processing
             elif "deepseek" in q or any(keyword in q for keyword in ["analyze", "reasoning", "complex"]):
                 t = "deepseek"
+            elif "llama-8" in q:
+                t = "llama8"
             elif len(q.split()) > 20:  # Complex queries
                 t = "llama70"
             else:
                 t = "llama8"  # Default for simple queries
                 
-            return {**st, "agent_type": t, "tools_used": [], "reasoning": ""}
+            return {**st, "agent_type": t}
 
         def llama8_node(st: EnhancedAgentState) -> EnhancedAgentState:
             """Process query with Llama-3 8B model."""
             t0 = time.time()
             try:
+                # Create enhanced prompt with context
+                enhanced_query = f"""
+                Question: {st["query"]}
+                
+                Please provide a direct, accurate answer to this question. Do not repeat the question.
+                """
+                
                 sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                res = llama8_llm.invoke([sys, HumanMessage(content=st["query"])])
+                res = llama8_llm.invoke([sys, HumanMessage(content=enhanced_query)])
                 
-                reasoning = "Used Llama-3 8B for efficient processing of straightforward query."
+                # Extract and clean the answer
+                answer = res.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
                 
                 return {**st,
-                        "final_answer": res.content,
-                        "reasoning": reasoning,
+                        "final_answer": answer,
                         "perf": {"time": time.time() - t0, "prov": "Groq-Llama3-8B"}}
             except Exception as e:
                 return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
@@ -279,14 +175,23 @@ class EnhancedQuestionAnsweringSystem:
             """Process query with Llama-3 70B model."""
             t0 = time.time()
             try:
+                # Create enhanced prompt with context
+                enhanced_query = f"""
+                Question: {st["query"]}
+                
+                Please provide a direct, accurate answer to this question. Do not repeat the question.
+                """
+                
                 sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                res = llama70_llm.invoke([sys, HumanMessage(content=st["query"])])
+                res = llama70_llm.invoke([sys, HumanMessage(content=enhanced_query)])
                 
-                reasoning = "Used Llama-3 70B for complex reasoning and detailed analysis."
+                # Extract and clean the answer
+                answer = res.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
                 
                 return {**st,
-                        "final_answer": res.content,
-                        "reasoning": reasoning,
+                        "final_answer": answer,
                         "perf": {"time": time.time() - t0, "prov": "Groq-Llama3-70B"}}
             except Exception as e:
                 return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
@@ -295,14 +200,23 @@ class EnhancedQuestionAnsweringSystem:
             """Process query with DeepSeek model."""
             t0 = time.time()
             try:
+                # Create enhanced prompt with context
+                enhanced_query = f"""
+                Question: {st["query"]}
+                
+                Please provide a direct, accurate answer to this question. Do not repeat the question.
+                """
+                
                 sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                res = deepseek_llm.invoke([sys, HumanMessage(content=st["query"])])
+                res = deepseek_llm.invoke([sys, HumanMessage(content=enhanced_query)])
                 
-                reasoning = "Used DeepSeek for advanced reasoning and analytical tasks."
+                # Extract and clean the answer
+                answer = res.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
                 
                 return {**st,
-                        "final_answer": res.content,
-                        "reasoning": reasoning,
+                        "final_answer": answer,
                         "perf": {"time": time.time() - t0, "prov": "Groq-DeepSeek"}}
             except Exception as e:
                 return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
@@ -310,43 +224,38 @@ class EnhancedQuestionAnsweringSystem:
         def search_enhanced_node(st: EnhancedAgentState) -> EnhancedAgentState:
             """Process query with search enhancement."""
             t0 = time.time()
-            tools_used = []
-            reasoning_steps = []
             
             try:
-                # Determine if we need web search or Wikipedia
+                # Determine search strategy
                 query = st["query"]
                 search_results = ""
                 
                 if any(keyword in query.lower() for keyword in ["wikipedia", "wiki"]):
                     search_results = optimized_wiki_search.invoke({"query": query})
-                    tools_used.append("wikipedia_search")
-                    reasoning_steps.append("Searched Wikipedia for relevant information")
                 else:
                     search_results = optimized_web_search.invoke({"query": query})
-                    tools_used.append("web_search")
-                    reasoning_steps.append("Performed web search for current information")
                 
-                # Enhance query with search results
+                # Create comprehensive prompt with search results
                 enhanced_query = f"""
-                Original Query: {query}
+                Original Question: {query}
                 
                 Search Results:
                 {search_results}
                 
-                Based on the search results above, please provide a comprehensive answer to the original query.
+                Based on the search results above, provide a direct answer to the original question.
+                Extract the specific information requested. Do not repeat the question.
                 """
                 
                 sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
                 res = llama70_llm.invoke([sys, HumanMessage(content=enhanced_query)])
                 
-                reasoning_steps.append("Used Llama-3 70B to analyze search results and generate comprehensive answer")
-                reasoning = " -> ".join(reasoning_steps)
+                # Extract and clean the answer
+                answer = res.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
                 
                 return {**st,
-                        "final_answer": res.content,
-                        "tools_used": tools_used,
-                        "reasoning": reasoning,
+                        "final_answer": answer,
                         "perf": {"time": time.time() - t0, "prov": "Search-Enhanced-Llama70"}}
             except Exception as e:
                 return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
@@ -373,24 +282,14 @@ class EnhancedQuestionAnsweringSystem:
         return g.compile(checkpointer=MemorySaver())
 
     def process_query(self, q: str) -> str:
-        """
-        Process a query through the enhanced question-answering system.
-        
-        Args:
-            q (str): Input query
-            
-        Returns:
-            str: Generated response with proper formatting
-        """
+        """Process a query and return the final answer."""
         state = {
             "messages": [HumanMessage(content=q)],
             "query": q,
             "agent_type": "",
             "final_answer": "",
             "perf": {},
-            "agno_resp": "",
-            "tools_used": [],
-            "reasoning": ""
+            "agno_resp": ""
         }
         cfg = {"configurable": {"thread_id": f"qa_{hash(q)}"}}
         
@@ -398,73 +297,30 @@ class EnhancedQuestionAnsweringSystem:
             out = self.graph.invoke(state, cfg)
             answer = out.get("final_answer", "").strip()
             
-            # Ensure proper formatting
-            if not answer.startswith("FINAL ANSWER:"):
-                # Extract the actual answer if it's buried in explanation
-                if "FINAL ANSWER:" in answer:
-                    answer = answer.split("FINAL ANSWER:")[-1].strip()
-                    answer = f"FINAL ANSWER: {answer}"
-                else:
-                    # Add FINAL ANSWER prefix if missing
-                    answer = f"FINAL ANSWER: {answer}"
+            # Ensure we don't return the question as the answer
+            if answer == q or answer.startswith(q):
+                return "Information not available"
             
-            return answer
+            return answer if answer else "No answer generated"
         except Exception as e:
-            return f"FINAL ANSWER: Error processing query: {e}"
+            return f"Error processing query: {e}"
 
 def build_graph(provider: str | None = None) -> StateGraph:
-    """
-    Build and return the graph for the enhanced question-answering system.
-    
-    Args:
-        provider (str | None): Provider preference (optional)
-        
-    Returns:
-        StateGraph: Compiled graph instance
-    """
-    return EnhancedQuestionAnsweringSystem().graph
-
-# ---- Main Question-Answering Interface ----
-class QuestionAnsweringAgent:
-    """
-    Main interface for the question-answering agent system.
-    """
-    
-    def __init__(self):
-        """Initialize the question-answering agent."""
-        self.system = EnhancedQuestionAnsweringSystem()
-        
-    def answer_question(self, question: str) -> str:
-        """
-        Answer a question using the enhanced multi-LLM system.
-        
-        Args:
-            question (str): The question to answer
-            
-        Returns:
-            str: Formatted answer with FINAL ANSWER prefix
-        """
-        return self.system.process_query(question)
+    """Build and return the graph for the enhanced agent system."""
+    return HybridLangGraphMultiLLMSystem().graph
 
 if __name__ == "__main__":
-    # Initialize the question-answering system
-    qa_agent = QuestionAnsweringAgent()
+    # Test the system
+    qa_system = HybridLangGraphMultiLLMSystem()
     
-    # Test with sample questions
     test_questions = [
-        "How many studio albums were published by Mercedes Sosa between 2000 and 2009?",
         "What is 25 multiplied by 17?",
-        "Find information about the capital of France on Wikipedia",
-        "What is the population of Tokyo according to recent data?"
+        "Who was the first president of the United States?",
+        "Find information about artificial intelligence on Wikipedia"
     ]
     
-    print("=" * 80)
-    print("Enhanced Question-Answering Agent System")
-    print("=" * 80)
-    
-    for i, question in enumerate(test_questions, 1):
-        print(f"\nQuestion {i}: {question}")
-        print("-" * 60)
-        answer = qa_agent.answer_question(question)
-        print(answer)
-        print()
+    for question in test_questions:
+        print(f"Question: {question}")
+        answer = qa_system.process_query(question)
+        print(f"Answer: {answer}")
+        print("-" * 50)