Update app.py

app.py

@@ -1,196 +1,425 @@
+"""
+LangChain Agent with Tools Workflow, Search, and Llama Models
+This application demonstrates a sophisticated agent using LangChain with:
+- Llama models via Ollama
+- Multiple tools (calculator, search, Wikipedia, etc.)
+- Tool workflow and reasoning
+- Gradio interface for interaction
+"""
+
 import os
 import gradio as gr
-import requests
-import inspect
-import pandas as pd
-
-# (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,
-    and displays the results.
-    """
-    # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
-
-    if profile:
-        username= f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
-
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
-
-    # 1. Instantiate Agent ( modify this part to create your agent)
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import math
+
+# LangChain imports
+from langchain.agents import AgentExecutor, create_tool_calling_agent, Tool
+from langchain.tools import StructuredTool
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.memory import ConversationBufferMemory
+from langchain_community.llms import Ollama
+from langchain_community.tools import DuckDuckGoSearchRun, WikipediaQueryRun
+from langchain_community.utilities import WikipediaAPIWrapper
+
+# --- Configuration ---
+DEFAULT_MODEL = "llama2"  # Can be changed to llama3, mistral, etc.
+DEFAULT_TEMPERATURE = 0.7
+DEFAULT_MAX_TOKENS = 2000
+
+# --- Calculator Tools ---
+def calculator_add(a: float, b: float) -> str:
+    """Add two numbers together."""
+    result = a + b
+    return f"The sum of {a} and {b} is {result}"
+
+def calculator_subtract(a: float, b: float) -> str:
+    """Subtract second number from first."""
+    result = a - b
+    return f"The difference between {a} and {b} is {result}"
+
+def calculator_multiply(a: float, b: float) -> str:
+    """Multiply two numbers."""
+    result = a * b
+    return f"The product of {a} and {b} is {result}"
+
+def calculator_divide(a: float, b: float) -> str:
+    """Divide first number by second."""
+    if b == 0:
+        return "Error: Cannot divide by zero"
+    result = a / b
+    return f"{a} divided by {b} is {result}"
+
+def calculator_power(a: float, b: float) -> str:
+    """Calculate a to the power of b."""
+    result = a ** b
+    return f"{a} to the power of {b} is {result}"
+
+def calculator_sqrt(x: float) -> str:
+    """Calculate square root of a number."""
+    if x < 0:
+        return "Error: Cannot calculate square root of negative number"
+    result = math.sqrt(x)
+    return f"The square root of {x} is {result}"
+
+def calculator_average(numbers: str) -> str:
+    """Calculate average of comma-separated numbers."""
+    try:
+        nums = [float(n.strip()) for n in numbers.split(',')]
+        if not nums:
+            return "Error: No numbers provided"
+        result = sum(nums) / len(nums)
+        return f"The average of {nums} is {result}"
+    except ValueError:
+        return "Error: Invalid number format. Use comma-separated numbers like '1, 2, 3, 4'"
+
+# --- String Tools ---
+def text_uppercase(text: str) -> str:
+    """Convert text to uppercase."""
+    return text.upper()
+
+def text_lowercase(text: str) -> str:
+    """Convert text to lowercase."""
+    return text.lower()
+
+def text_reverse(text: str) -> str:
+    """Reverse a string."""
+    return text[::-1]
+
+def text_word_count(text: str) -> str:
+    """Count words in text."""
+    words = text.split()
+    return f"The text contains {len(words)} words"
+
+def text_char_count(text: str) -> str:
+    """Count characters in text."""
+    return f"The text contains {len(text)} characters"
+
+# --- Utility Tools ---
+def get_current_time() -> str:
+    """Get current date and time."""
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+def get_current_date() -> str:
+    """Get current date."""
+    return datetime.now().strftime("%Y-%m-%d")
+
+# --- Initialize Tools ---
+def initialize_tools() -> List[Tool]:
+    """Initialize all available tools for the agent."""
+    
+    # Calculator tools
+    tools = [
+        Tool(
+            name="add",
+            func=calculator_add,
+            description="Add two numbers together. Input: two numbers separated by space or comma."
+        ),
+        Tool(
+            name="subtract",
+            func=calculator_subtract,
+            description="Subtract second number from first. Input: two numbers separated by space or comma."
+        ),
+        Tool(
+            name="multiply",
+            func=calculator_multiply,
+            description="Multiply two numbers together. Input: two numbers separated by space or comma."
+        ),
+        Tool(
+            name="divide",
+            func=calculator_divide,
+            description="Divide first number by second. Input: two numbers separated by space or comma."
+        ),
+        Tool(
+            name="power",
+            func=calculator_power,
+            description="Calculate a to the power of b. Input: two numbers separated by space or comma."
+        ),
+        Tool(
+            name="sqrt",
+            func=calculator_sqrt,
+            description="Calculate square root of a number. Input: a single number."
+        ),
+        Tool(
+            name="average",
+            func=calculator_average,
+            description="Calculate average of multiple numbers. Input: comma-separated numbers like '1, 2, 3, 4'."
+        ),
+        
+        # String tools
+        Tool(
+            name="uppercase",
+            func=text_uppercase,
+            description="Convert text to uppercase. Input: the text to convert."
+        ),
+        Tool(
+            name="lowercase",
+            func=text_lowercase,
+            description="Convert text to lowercase. Input: the text to convert."
+        ),
+        Tool(
+            name="reverse",
+            func=text_reverse,
+            description="Reverse a string. Input: the text to reverse."
+        ),
+        Tool(
+            name="word_count",
+            func=text_word_count,
+            description="Count words in text. Input: the text to analyze."
+        ),
+        Tool(
+            name="char_count",
+            func=text_char_count,
+            description="Count characters in text. Input: the text to analyze."
+        ),
+        
+        # Utility tools
+        Tool(
+            name="current_time",
+            func=get_current_time,
+            description="Get current date and time. No input needed."
+        ),
+        Tool(
+            name="current_date",
+            func=get_current_date,
+            description="Get current date. No input needed."
+        ),
+    ]
+    
+    # Search tools
     try:
-        agent = BasicAgent()
+        search = DuckDuckGoSearchRun()
+        tools.append(
+            Tool(
+                name="search",
+                func=search.run,
+                description="Search the web for current information using DuckDuckGo. Input: search query."
+            )
+        )
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
-        return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
-
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
+        print(f"Warning: Could not initialize DuckDuckGo search: {e}")
+    
+    # Wikipedia tool
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
-        if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
-        print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-    except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
+        tools.append(
+            Tool(
+                name="wikipedia",
+                func=wikipedia.run,
+                description="Search Wikipedia for encyclopedic information. Input: search query."
+            )
+        )
     except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
-
-    # 3. Run your Agent
-    results_log = []
-    answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
-            continue
-        try:
-            submitted_answer = 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:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
-
-    if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-
-    # 4. Prepare Submission 
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
-
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+        print(f"Warning: Could not initialize Wikipedia search: {e}")
+    
+    return tools
+
+# --- Agent Initialization ---
+def create_agent(model_name: str = DEFAULT_MODEL, temperature: float = DEFAULT_TEMPERATURE):
+    """Create a LangChain agent with tools."""
+    
+    # Initialize LLM with Ollama (Llama models)
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Message: {result_data.get('message', 'No message received.')}"
+        llm = Ollama(
+            model=model_name,
+            temperature=temperature,
+            num_predict=DEFAULT_MAX_TOKENS
         )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        print(f"✅ Successfully initialized Ollama with model: {model_name}")
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-
-
-# --- Build Gradio Interface using Blocks ---
-with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
-    gr.Markdown(
-        """
-        **Instructions:**
-
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
-        ---
-        **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
-        """
-    )
+        print(f"❌ Error initializing Ollama: {e}")
+        print("Make sure Ollama is installed and running. Visit: https://ollama.ai")
+        raise
+    
+    # Initialize tools
+    tools = initialize_tools()
+    print(f"✅ Initialized {len(tools)} tools")
+    
+    # Create prompt template
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", """You are a helpful AI assistant with access to various tools. 
+You can perform calculations, search the web, look up information on Wikipedia, and manipulate text.
 
-    gr.LoginButton()
+When answering questions:
+1. Think about which tool(s) you need to use
+2. Use the tools to gather information
+3. Provide a clear, helpful response based on the tool results
+4. If you don't have enough information, ask for clarification
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
+Available tools:
+{tools}
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+Tool names: {tool_names}
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
+Remember to be helpful, accurate, and concise in your responses."""),
+        MessagesPlaceholder(variable_name="chat_history", optional=True),
+        ("human", "{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad"),
+    ])
+    
+    # Create agent
+    agent = create_tool_calling_agent(llm, tools, prompt)
+    
+    # Create agent executor
+    agent_executor = AgentExecutor(
+        agent=agent,
+        tools=tools,
+        verbose=True,
+        handle_parsing_errors=True,
+        max_iterations=10,
+        early_stopping_method="generate"
     )
+    
+    return agent_executor
+
+# --- Global Agent Instance ---
+agent_executor = None
+
+def initialize_global_agent(model_name: str = DEFAULT_MODEL):
+    """Initialize the global agent instance."""
+    global agent_executor
+    try:
+        agent_executor = create_agent(model_name)
+        return True, f"✅ Agent initialized successfully with model: {model_name}"
+    except Exception as e:
+        return False, f"❌ Error initializing agent: {str(e)}"
+
+# --- Query Function ---
+def query_agent(question: str, model_name: str = DEFAULT_MODEL) -> str:
+    """Query the agent with a question."""
+    global agent_executor
+    
+    # Reinitialize if model changed or agent not initialized
+    if agent_executor is None:
+        success, message = initialize_global_agent(model_name)
+        if not success:
+            return message
+    
+    try:
+        print(f"\n{'='*60}")
+        print(f"Query: {question}")
+        print(f"{'='*60}\n")
+        
+        result = agent_executor.invoke({"input": question})
+        response = result.get("output", "No response generated")
+        
+        print(f"\n{'='*60}")
+        print(f"Response: {response}")
+        print(f"{'='*60}\n")
+        
+        return response
+    except Exception as e:
+        error_msg = f"Error processing query: {str(e)}"
+        print(f"❌ {error_msg}")
+        return error_msg
 
+# --- Gradio Interface ---
+def create_interface():
+    """Create the Gradio interface."""
+    
+    with gr.Blocks(title="LangChain Agent with Llama Models") as demo:
+        gr.Markdown("# 🤖 LangChain Agent with Llama Models")
+        gr.Markdown("""
+        This agent uses **LangChain** with **Llama models** (via Ollama) and a comprehensive set of tools.
+        
+        ## Features:
+        - **Calculator Tools**: Add, subtract, multiply, divide, power, square root, average
+        - **String Tools**: Uppercase, lowercase, reverse, word count, character count
+        - **Search Tools**: DuckDuckGo web search, Wikipedia lookup
+        - **Utility Tools**: Current time, current date
+        
+        ## Requirements:
+        - Install Ollama from [ollama.ai](https://ollama.ai)
+        - Pull a Llama model: `ollama pull llama2` or `ollama pull llama3`
+        - Make sure Ollama is running: `ollama serve`
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                model_input = gr.Dropdown(
+                    choices=["llama2", "llama3", "llama3:8b", "mistral", "codellama"],
+                    value="llama2",
+                    label="Select Model",
+                    info="Choose the Llama model to use"
+                )
+                init_btn = gr.Button("Initialize Agent", variant="primary")
+                status_output = gr.Textbox(label="Status", interactive=False)
+            
+            with gr.Column(scale=2):
+                question_input = gr.Textbox(
+                    label="Your Question",
+                    placeholder="Ask me anything... e.g., 'What is 25 * 4?' or 'Search for information about Python'",
+                    lines=3
+                )
+                submit_btn = gr.Button("Ask Agent", variant="primary")
+                response_output = gr.Textbox(
+                    label="Agent Response",
+                    lines=10,
+                    interactive=False
+                )
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                ["What is 15 * 7?"],
+                ["Calculate the square root of 144"],
+                ["What is the average of 10, 20, 30, 40, 50?"],
+                ["Convert 'hello world' to uppercase"],
+                ["How many words are in this sentence?"],
+                ["What is the current time?"],
+                ["Search for information about artificial intelligence"],
+                ["Look up Python programming on Wikipedia"],
+                ["What is 2 to the power of 10?"],
+                ["Reverse the string 'LangChain'"],
+            ],
+            inputs=question_input,
+            label="Example Questions"
+        )
+        
+        # Event handlers
+        init_btn.click(
+            fn=initialize_global_agent,
+            inputs=[model_input],
+            outputs=[status_output]
+        )
+        
+        submit_btn.click(
+            fn=query_agent,
+            inputs=[question_input, model_input],
+            outputs=[response_output]
+        )
+        
+        question_input.submit(
+            fn=query_agent,
+            inputs=[question_input, model_input],
+            outputs=[response_output]
+        )
+    
+    return demo
+
+# --- Main ---
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
-    # Check for SPACE_HOST and SPACE_ID at startup for information
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
-
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-    else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-
-    print("-"*(60 + len(" App Starting ")) + "\n")
-
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    print("\n" + "="*60)
+    print("LangChain Agent with Llama Models")
+    print("="*60 + "\n")
+    
+    # Check if Ollama is available
+    try:
+        import ollama
+        models = ollama.list()
+        print(f"✅ Ollama is running")
+        print(f"Available models: {[m['name'] for m in models.get('models', [])]}")
+    except Exception as e:
+        print(f"⚠️  Warning: Could not connect to Ollama: {e}")
+        print("Please make sure Ollama is installed and running:")
+        print("  1. Install from https://ollama.ai")
+        print("  2. Run: ollama pull llama2")
+        print("  3. Run: ollama serve")
+    
+    print("\nInitializing agent...")
+    success, message = initialize_global_agent()
+    print(message)
+    
+    print("\nLaunching Gradio interface...")
+    demo = create_interface()
+    demo.launch(share=False, debug=True)