30% managed

agent.py

@@ -28,13 +28,17 @@ try:
     from llama_index.core.agent.workflow import (
         ToolCall,
         ToolCallResult,
+        FunctionAgent,
         AgentStream,
     )
     from llama_index.llms.huggingface import HuggingFaceLLM
     from llama_index.core.tools import FunctionTool
     from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
     from llama_index.tools.wikipedia import WikipediaToolSpec
-    from llama_index.tools.requests import RequestsToolSpec
+    from llama_index.tools.tavily_research.base import TavilyToolSpec
+    #from llama_index.llms.ollama import Ollama
+    from llama_index.llms.bedrock_converse import BedrockConverse
+    #from llama_index.llms.openai import OpenAI
     LLAMA_INDEX_AVAILABLE = True
 except ImportError as e:
     print(f"LlamaIndex imports not available: {e}")
@@ -105,7 +109,6 @@ class BasicAgent:
         
         # Get Hugging Face token
         self.hf_token = os.getenv("HUGGINGFACE_TOKEN")
-        print(self.hf_token)
         if not self.hf_token:
             print("Warning: HUGGINGFACE_TOKEN not found. Using default model.")
         
@@ -116,7 +119,7 @@ class BasicAgent:
         self._initialize_tools()
         
         # Initialize code executor
-        self._initialize_code_executor()
+        #self._initialize_code_executor()
         
         # Initialize CodeAct Agent
         self._initialize_agent()
@@ -131,28 +134,17 @@ class BasicAgent:
             return
             
         try:
-            # Using a capable model for reasoning and code generation
-            # Note: For production, consider using models like meta-llama/Llama-2-7b-chat-hf or similar
-            model_kwargs = {"temperature": 0.1, "max_length": 512}
-            generate_kwargs = {"temperature": 0.1, "do_sample": True}
+            #self.llm = OpenAI(model="gpt-4o", api_key=os.getenv("OPENAI_API_KEY"))
+            #self.llm = Ollama(model="llama3.1:latest", base_url="http://localhost:11434")
+            self.llm = BedrockConverse(
+                model="amazon.nova-pro-v1:0",
+                temperature=0.5,
+                aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+                aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+                region_name=os.getenv("AWS_REGION"),
+
+            )
             
-            if self.hf_token:
-                # Use token if available
-                self.llm = HuggingFaceLLM(
-                    model_name=MODEL,
-                    tokenizer_name=MODEL,  # Explicitly use the same model for tokenizer
-                    model_kwargs=model_kwargs,
-                    generate_kwargs=generate_kwargs,
-                    tokenizer_kwargs={"token": self.hf_token},
-                )
-            else:
-                # Try without token for public models
-                self.llm = HuggingFaceLLM(
-                    model_name=MODEL,
-                    tokenizer_name=MODEL,  # Explicitly use the same model for tokenizer
-                    model_kwargs=model_kwargs,
-                    generate_kwargs=generate_kwargs,
-                )
             print("✅ LLM initialized successfully")
         except Exception as e:
             print(f"Error initializing LLM: {e}")
@@ -203,16 +195,21 @@ class BasicAgent:
         def calculate_percentage(value: float, percentage: float) -> float:
             """Calculate percentage of a value."""
             return (value * percentage) / 100
+
+        def get_modulus(a: float, b: float) -> float:
+            """Get the modulus of two numbers."""
+            return a % b
             
         # Create function tools
         try:
             math_tools = [
-                FunctionTool.from_defaults(fn=add_numbers),
-                FunctionTool.from_defaults(fn=subtract_numbers),
-                FunctionTool.from_defaults(fn=multiply_numbers),
-                FunctionTool.from_defaults(fn=divide_numbers),
-                FunctionTool.from_defaults(fn=power_numbers),
-                FunctionTool.from_defaults(fn=calculate_percentage),
+                FunctionTool.from_defaults(fn=add_numbers, name="add_numbers", description="Add two numbers together"),
+                FunctionTool.from_defaults(fn=subtract_numbers, name="subtract_numbers", description="Subtract second number from first number"),
+                FunctionTool.from_defaults(fn=multiply_numbers, name="multiply_numbers", description="Multiply two numbers"),
+                FunctionTool.from_defaults(fn=divide_numbers, name="divide_numbers", description="Divide first number by second number"),
+                FunctionTool.from_defaults(fn=power_numbers, name="power_numbers", description="Raise first number to the power of second number"),
+                FunctionTool.from_defaults(fn=calculate_percentage, name="calculate_percentage", description="Calculate percentage of a value"),
+                FunctionTool.from_defaults(fn=get_modulus, name="get_modulus", description="Get the modulus of two numbers"),
             ]
             self.tools.extend(math_tools)
             print("✅ Math tools initialized")
@@ -221,31 +218,33 @@ class BasicAgent:
         
         # Initialize search tools
         try:
-            # DuckDuckGo search
-            ddg_spec = DuckDuckGoSearchToolSpec()
-            ddg_tools = ddg_spec.to_tool_list()
-            self.tools.extend(ddg_tools)
+            # web search
+            search_spec = TavilyToolSpec(
+                api_key=os.getenv("TAVILY_API_KEY"),
+            )
+            search_tool = search_spec.to_tool_list()
+            self.tools.extend(search_tool)
             print("✅ DuckDuckGo search tool initialized")
         except Exception as e:
             print(f"Warning: Could not initialize DuckDuckGo tool: {e}")
             
-        try:
+        """ try:
             # Wikipedia search
             wiki_spec = WikipediaToolSpec()
-            wiki_tools = wiki_spec.to_tool_list()
+            wiki_tools = FunctionTool.from_defaults(wiki_spec.wikipedia_search, name="wikipedia_search", description="Search Wikipedia for information")
             self.tools.extend(wiki_tools)
             print("✅ Wikipedia tool initialized")
         except Exception as e:
-            print(f"Warning: Could not initialize Wikipedia tool: {e}")
+            print(f"Warning: Could not initialize Wikipedia tool: {e}") """
             
-        try:
+        """ try:
             # Web requests tool
             requests_spec = RequestsToolSpec()
             requests_tools = requests_spec.to_tool_list()
             self.tools.extend(requests_tools)
             print("✅ Web requests tool initialized")
         except Exception as e:
-            print(f"Warning: Could not initialize requests tool: {e}")
+            print(f"Warning: Could not initialize requests tool: {e}") """
             
         print(f"✅ Total {len(self.tools)} tools initialized")
         
@@ -295,7 +294,7 @@ class BasicAgent:
         
         # Store initialization parameters for deferred initialization
         self._agent_params = {
-            'code_execute_fn': self.code_executor.execute,
+            #'code_execute_fn': self.code_executor.execute,
             'llm': self.llm,
             'tools': self.tools
         }
@@ -316,7 +315,21 @@ class BasicAgent:
                         pass
                 
                 # Create the CodeAct Agent without assuming event loop state
-                self.agent = CodeActAgent(**self._agent_params)
+                #self.agent = CodeActAgent(**self._agent_params)
+                # Enhanced prompt with specific formatting requirements
+                enhanced_prompt = f"""
+            You are a helpful assistant tasked with answering questions using a set of tools. 
+            Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: 
+            FINAL ANSWER: [YOUR FINAL ANSWER]. 
+            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.
+            Your answer should only start with "FINAL ANSWER: ", then follows with the answer. 
+                """
+                
+                self.agent = FunctionAgent(
+                    tools=self.tools,
+                    llm=self.llm,
+                    system_prompt=enhanced_prompt,
+                )
                 print("✅ CodeAct Agent initialized (deferred)")
                 
             except Exception as e:
@@ -334,29 +347,11 @@ class BasicAgent:
         # Ensure agent is initialized (for deferred initialization)
         self._ensure_agent_initialized()
         
-        # Enhanced prompt with specific formatting requirements
-        enhanced_prompt = f"""
-You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. 
-
-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.
-
-Available tools and capabilities:
-- Mathematical calculations (addition, subtraction, multiplication, division, powers, percentages)
-- Web search using DuckDuckGo
-- Wikipedia search for factual information
-- Web requests for API calls
-- Code execution for complex calculations and data processing
-- Python libraries: math, datetime, json, re, numpy (if available), pandas (if available)
-
-Question: {question}
-
-Think step by step, use the available tools when necessary, and provide your final answer in the specified format.
-        """
-        
+       
         if self.agent:
             try:
                 # Use the CodeAct agent for advanced reasoning
-                response = await self._async_agent_run(enhanced_prompt)
+                response = await self._async_agent_run(question)
                 return response
             except Exception as e:
                 print(f"Error with CodeAct agent: {e}")
@@ -365,24 +360,32 @@ Think step by step, use the available tools when necessary, and provide your fin
             return "FINAL ANSWER: Agent not properly initialized"
     
     
-    async def _async_agent_run(self, prompt: str) -> str:
+    async def _async_agent_run(self, question: str) -> str:
         """Run the agent asynchronously."""
         try:
             # Create a fresh context for this run to avoid loop conflicts
-            context = Context(self.agent)
-            handler = self.agent.run(prompt, ctx=context)
-            
+            #context = Context(self.agent)
+            print("Agent running...")
+            print(self.agent)
+            handler = self.agent.run(question)
+            #return str(handler)
+            iterationsNumber = 0
             async for event in handler.stream_events():
-                if isinstance(event, ToolCallResult):
-                    print(
-                        f"\n-----------\nCode execution result:\n{event.tool_output}"
-                    )
-                elif isinstance(event, ToolCall):
-                    print(f"\n-----------\nParsed code:\n{event.tool_kwargs['code']}")
+                iterationsNumber += 1
+                # if isinstance(event, ToolCallResult):
+                #     print(
+                #         f"\n-----------\nCode execution result:\n{event.tool_output}"
+                #     )
+                if isinstance(event, ToolCall):
+                    print(f"\n-----------\nevent:\n{event}")
                 elif isinstance(event, AgentStream):
                     print(f"{event.delta}", end="", flush=True)
-
-            return await handler
+                """ if iterationsNumber > 5:
+                    print("Too many iterations, stopping...")
+                    break """
+            response = await handler
+            print(f'response.response: {response.response.content}')
+            return response.response.content.split("FINAL ANSWER: ")[1]
         except Exception as e:
             print(f"Async agent error: {e}")
             return f"FINAL ANSWER: Error in agent processing - {str(e)}"

app.py

@@ -75,15 +75,19 @@ async def run_and_submit_all(profile: Optional[gr.OAuthProfile]):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    questions_data = questions_data[:1]
+    #questions_data = questions_data[:5]
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
+        print(f"Running agent on question: {item}")
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = await agent(question_text)
+            if(item.get("file_name") != ""):
+                submitted_answer = "N.D."
+            else:
+                submitted_answer = await agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e: