Add initial implementation of AgentRunner and agent graph; include .gitignore and update requirements

.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.pytest_cache
+.venv

agent.py

@@ -0,0 +1,41 @@
+import os
+import logging
+from graph import agent_graph
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)  # Default to INFO level
+logger = logging.getLogger(__name__)
+
+# Enable LiteLLM debug logging only if environment variable is set
+import litellm
+if os.getenv('LITELLM_DEBUG', 'false').lower() == 'true':
+    litellm.set_verbose = True
+    logger.setLevel(logging.DEBUG)
+else:
+    litellm.set_verbose = False
+    logger.setLevel(logging.INFO)
+
+class AgentRunner:
+    def __init__(self):
+        logger.debug("Initializing AgentRunner")
+        logger.info("AgentRunner initialized.")
+
+    def __call__(self, question: str) -> str:
+        logger.debug(f"Processing question: {question[:50]}...")
+        logger.info(f"Agent received question (first 50 chars): {question[:50]}...")
+        try:
+            # Run the graph with the question
+            result = agent_graph.invoke({
+                "messages": [],
+                "question": question,
+                "answer": None
+            })
+            
+            # Extract and return the answer
+            answer = result["answer"]
+            logger.debug(f"Successfully generated answer: {answer}")
+            logger.info(f"Agent returning answer: {answer}")
+            return answer
+        except Exception as e:
+            logger.error(f"Error in agent execution: {str(e)}", exc_info=True)
+            raise

app.py

@@ -1,27 +1,16 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
+from agent import AgentRunner
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
-
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    Fetches all questions, runs the AgentRunner on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
@@ -40,7 +29,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = AgentRunner()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None

graph.py

@@ -0,0 +1,92 @@
+import logging
+from typing import TypedDict
+from langgraph.graph import StateGraph, END
+from smolagents import ToolCallingAgent, LiteLLMModel
+from tools import tools
+import yaml
+import importlib.resources
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Define the state for our agent graph
+class AgentState(TypedDict):
+    messages: list
+    question: str
+    answer: str | None
+
+class AgentNode:
+    def __init__(self):
+        # Load default prompt templates
+        prompt_templates = yaml.safe_load(
+            importlib.resources.files("smolagents.prompts").joinpath("toolcalling_agent.yaml").read_text()
+        )
+        
+        # Log the default system prompt
+        logger.info("Default system prompt:")
+        logger.info("-" * 80)
+        logger.info(prompt_templates["system_prompt"])
+        logger.info("-" * 80)
+        
+#         # Define our custom system prompt
+#         custom_system_prompt = "..."
+
+#         # Update the system prompt in the loaded templates
+#         prompt_templates["system_prompt"] = custom_system_prompt
+        
+        # Log our custom system prompt
+        # logger.info("Custom system prompt:")
+        # logger.info("-" * 80)
+        # logger.info(custom_system_prompt)
+        # logger.info("-" * 80)
+
+        # In"itialize the model and agent
+        self.model = LiteLLMModel(
+            model="ollama/codellama",
+            temperature=0.0,
+            max_tokens=4096,
+            top_p=0.9,
+            frequency_penalty=0.0,
+            presence_penalty=0.0,
+            stop=["Observation:"],
+        )
+        
+        self.agent = ToolCallingAgent(
+            model=self.model,
+            prompt_templates=prompt_templates,
+            tools=tools
+        )
+
+    def __call__(self, state: AgentState) -> AgentState:
+        try:
+            # Process the question through the agent
+            result = self.agent.run(state["question"])
+            
+            # Update the state with the answer
+            state["answer"] = result
+            return state
+            
+        except Exception as e:
+            logger.error(f"Error in agent node: {str(e)}", exc_info=True)
+            state["answer"] = f"Error: {str(e)}"
+            return state
+
+def build_agent_graph():
+    # Create the graph
+    graph = StateGraph(AgentState)
+    
+    # Add the agent node
+    graph.add_node("agent", AgentNode())
+    
+    # Add edges
+    graph.add_edge("agent", END)
+    
+    # Set the entry point
+    graph.set_entry_point("agent")
+    
+    # Compile the graph
+    return graph.compile()
+
+# Create an instance of the compiled graph
+agent_graph = build_agent_graph() 

requirements.txt

@@ -1,2 +1,8 @@
-gradio
-requests
+duckduckgo-search>=8.0.1
+gradio[oauth]>=5.26.0
+langgraph>=0.3.34
+pytest>=8.3.5
+pytest-cov>=6.1.1
+requests>=2.32.3
+smolagents[litellm]>=0.1.3
+wikipedia-api>=0.8.1

tools.py

@@ -0,0 +1,50 @@
+import logging
+from smolagents import DuckDuckGoSearchTool, WikipediaSearchTool, Tool
+
+logger = logging.getLogger(__name__)
+
+class GeneralSearchTool(Tool):
+    name = "search"
+    description = """Performs a general web search using both DuckDuckGo and Wikipedia, then returns the combined search results."""
+    inputs = {"query": {"type": "string", "description": "The search query to perform."}}
+    output_type = "string"
+
+    def __init__(self, max_results=10, **kwargs):
+        super().__init__()
+        self.max_results = max_results
+        self.ddg_tool = DuckDuckGoSearchTool()
+        self.wiki_tool = WikipediaSearchTool()
+
+    def forward(self, query: str) -> str:
+        # Get DuckDuckGo results
+        try:
+            ddg_results = self.ddg_tool.forward(query)
+        except Exception as e:
+            ddg_results = "No DuckDuckGo results found."
+            logger.warning(f"DuckDuckGo search failed: {str(e)}")
+        
+        # Get Wikipedia results
+        try:
+            wiki_results = self.wiki_tool.forward(query)
+        except Exception as e:
+            wiki_results = "No Wikipedia results found."
+            logger.warning(f"Wikipedia search failed: {str(e)}")
+        
+        # Combine and format results
+        output = []
+        if ddg_results and ddg_results != "No DuckDuckGo results found.":
+            output.append("## DuckDuckGo Search Results\n\n" + ddg_results)
+        if wiki_results and wiki_results != "No Wikipedia results found.":
+            output.append("## Wikipedia Results\n\n" + wiki_results)
+        
+        if not output:
+            raise Exception("No results found! Try a less restrictive/shorter query.")
+            
+        return "\n\n---\n\n".join(output)
+
+# Export all tools
+tools = [
+    # DuckDuckGoSearchTool(),
+    GeneralSearchTool(),
+    # WikipediaSearchTool(),
+]