updates

app.py

@@ -9,7 +9,17 @@ from langgraph.graph import START, StateGraph
 from langgraph.prebuilt import ToolNode, tools_condition
 from langgraph.graph.message import add_messages
 from typing import TypedDict, Annotated
-from tools import image_recognition_tool, download_file_tool, reverse_text_tool, hub_stats_tool, web_search_tool
+from tools import (
+    image_recognition_tool,
+    download_file_tool,
+    reverse_text_tool,
+    hub_stats_tool,
+    web_search_tool,
+    python_execution_tool,
+    video_analysis_tool,
+    audio_processing_tool,
+    file_type_detection_tool
+)
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -17,8 +27,17 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # Setting up the llm
 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
-tools = [web_search_tool, hub_stats_tool, download_file_tool,
-         image_recognition_tool, reverse_text_tool]
+tools = [
+    web_search_tool,
+    hub_stats_tool,
+    download_file_tool,
+    image_recognition_tool,
+    reverse_text_tool,
+    python_execution_tool,
+    video_analysis_tool,
+    audio_processing_tool,
+    file_type_detection_tool
+]
 chat_with_tools = llm.bind_tools(tools)
 
 # Defining my agent

requirements.txt

@@ -14,4 +14,7 @@ python-dotenv
 duckduckgo-search
 pandas
 datasets
-langchain-huggingface
+langchain-huggingface
+pathlib
+SpeechRecognition
+librosa

tools.py

@@ -24,6 +24,14 @@ from dotenv import load_dotenv
 import os
 import torch
 import base64
+import subprocess
+import tempfile
+import json
+import re
+from pathlib import Path
+
+# Load environment variables
+load_dotenv()
 
 # DEFINE HUB STAT TOOLS
 
@@ -67,7 +75,11 @@ print(pp.pprint(results))
 
 # REVERSE TOOLS
 def ReverseTextTool(text: str) -> str:
-    return text[::-1]
+    """Reverses the order of characters in a given text string."""
+    try:
+        return text[::-1]
+    except Exception as e:
+        return f"Error reversing text: {str(e)}"
 
 
 reverse_text_tool = Tool(
@@ -84,6 +96,7 @@ print(pp.pprint(results))
 
 
 def download_file(url: str) -> str:
+    """Downloads a file from a given URL and returns the local file path."""
     try:
         response = requests.get(url, timeout=30)
         response.raise_for_status()
@@ -95,7 +108,7 @@ def download_file(url: str) -> str:
 
         with open(save_path, "wb") as f:
             f.write(response.content)
-        return save_path  # Return the file path instead of success message
+        return save_path
     except Exception as e:
         return f"Failed to download: {e}"
 
@@ -103,20 +116,132 @@ def download_file(url: str) -> str:
 download_file_tool = Tool(
     name="download_file_tool",
     func=download_file,
-    description="Downloads a file from a given URL."
+    description="Downloads a file from a given URL and returns the local file path."
 )
 
 results = download_file_tool.invoke("https://www.google.com")
 print(results)
 
-# DEFINE IMAGE RECOGNITION TOOLS
-vision_llm = ChatOpenAI(model="gpt-4o")
+# PYTHON CODE EXECUTION TOOL
 
 
-def image_recognition(img_path: str) -> str:
+def execute_python_code(code: str) -> str:
+    """Executes Python code and returns the output."""
+    try:
+        # Create a temporary file to execute the code
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write(code)
+            temp_file = f.name
+
+        # Execute the code
+        result = subprocess.run(['python', temp_file],
+                                capture_output=True, text=True, timeout=30)
+
+        # Clean up
+        os.unlink(temp_file)
+
+        if result.returncode == 0:
+            return f"Output: {result.stdout.strip()}"
+        else:
+            return f"Error: {result.stderr.strip()}"
+    except subprocess.TimeoutExpired:
+        return "Error: Code execution timed out"
+    except Exception as e:
+        return f"Error executing Python code: {str(e)}"
+
+
+python_execution_tool = Tool(
+    name="python_execution_tool",
+    func=execute_python_code,
+    description="Executes Python code and returns the output. Use this when you need to run Python scripts or calculate values."
+)
 
-    all_text = ""
+# VIDEO ANALYSIS TOOL
+
+
+def analyze_video(video_url: str) -> str:
+    """Analyzes video content from YouTube or other video URLs."""
+    try:
+        # Extract video ID from YouTube URL
+        if 'youtube.com' in video_url or 'youtu.be' in video_url:
+            # For YouTube videos, we can extract some basic info
+            video_id = None
+            if 'youtube.com/watch?v=' in video_url:
+                video_id = video_url.split('watch?v=')[1].split('&')[0]
+            elif 'youtu.be/' in video_url:
+                video_id = video_url.split('youtu.be/')[1].split('?')[0]
+
+            if video_id:
+                # Use web search to get video information
+                search_result = web_search_tool.func(
+                    f"youtube video {video_id} title description")
+                return f"Video analysis for {video_id}: {search_result}"
+            else:
+                return "Could not extract video ID from URL"
+        else:
+            return "Video analysis currently supports YouTube videos only"
+    except Exception as e:
+        return f"Error analyzing video: {str(e)}"
+
+
+video_analysis_tool = Tool(
+    name="video_analysis_tool",
+    func=analyze_video,
+    description="Analyzes video content from URLs. Use this when questions involve video content or YouTube links."
+)
+
+# AUDIO PROCESSING TOOL
+
+
+def process_audio(audio_file_path: str) -> str:
+    """Processes audio files to extract information."""
     try:
+        if not os.path.exists(audio_file_path):
+            return f"Audio file not found: {audio_file_path}"
+
+        # For now, return basic file info
+        file_size = os.path.getsize(audio_file_path)
+        file_extension = Path(audio_file_path).suffix
+
+        return f"Audio file: {audio_file_path}, Size: {file_size} bytes, Type: {file_extension}. Audio processing requires additional libraries like speech_recognition or librosa."
+    except Exception as e:
+        return f"Error processing audio: {str(e)}"
+
+
+audio_processing_tool = Tool(
+    name="audio_processing_tool",
+    func=process_audio,
+    description="Processes audio files to extract information. Use this when questions involve audio files or MP3 content."
+)
+
+# ENHANCED IMAGE RECOGNITION TOOLS
+
+
+def create_vision_llm():
+    """Creates a vision-capable LLM with proper error handling."""
+    try:
+        # Check if OpenAI API key is available
+        if not os.getenv("OPENAI_API_KEY"):
+            return None, "OpenAI API key not found. Please set OPENAI_API_KEY in your environment variables."
+
+        vision_llm = ChatOpenAI(model="gpt-4o")
+        return vision_llm, None
+    except Exception as e:
+        return None, f"Error creating vision LLM: {str(e)}"
+
+
+def image_recognition(img_path: str) -> str:
+    """Analyzes and describes the content of images using AI vision."""
+    try:
+        # Check if file exists
+        if not os.path.exists(img_path):
+            return f"Error: Image file not found at {img_path}"
+
+        # Create vision LLM
+        vision_llm, error = create_vision_llm()
+        if error:
+            return error
+
         # Read image and encode as base64
         with open(img_path, "rb") as image_file:
             image_bytes = image_file.read()
@@ -131,7 +256,7 @@ def image_recognition(img_path: str) -> str:
                         "type": "text",
                         "text": (
                             "Describe the image or extract all the text from this image. "
-                            "Return only the description orextracted text, no explanations."
+                            "Return only the description or extracted text, no explanations."
                         ),
                     },
                     {
@@ -146,16 +271,10 @@ def image_recognition(img_path: str) -> str:
 
         # Call the vision-capable model
         response = vision_llm.invoke(message)
+        return response.content.strip()
 
-        # Append extracted text
-        all_text += response.content + "\n\n"
-
-        return all_text.strip()
     except Exception as e:
-        # A butler should handle errors gracefully
-        error_msg = f"Error extracting text: {str(e)}"
-        print(error_msg)
-        return ""
+        return f"Error analyzing image: {str(e)}"
 
 
 image_recognition_tool = Tool(
@@ -163,9 +282,42 @@ image_recognition_tool = Tool(
     func=image_recognition,
     description="Analyzes and describes the content of images using AI vision. Use this when you need to understand what's in an image."
 )
-test_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
 
-results = image_recognition_tool.invoke(download_file_tool.invoke(test_url))
-print(results)
+# FILE TYPE DETECTION TOOL
+
+
+def detect_file_type(file_path: str) -> str:
+    """Detects the type of file and provides appropriate handling suggestions."""
+    try:
+        if not os.path.exists(file_path):
+            return f"File not found: {file_path}"
+
+        file_extension = Path(file_path).suffix.lower()
+        file_size = os.path.getsize(file_path)
+
+        file_types = {
+            '.py': 'Python script',
+            '.mp3': 'Audio file',
+            '.mp4': 'Video file',
+            '.jpg': 'Image file',
+            '.jpeg': 'Image file',
+            '.png': 'Image file',
+            '.txt': 'Text file',
+            '.pdf': 'PDF document',
+            '.doc': 'Word document',
+            '.docx': 'Word document',
+            '.xls': 'Excel spreadsheet',
+            '.xlsx': 'Excel spreadsheet'
+        }
+
+        file_type = file_types.get(file_extension, 'Unknown file type')
+        return f"File: {file_path}, Type: {file_type}, Size: {file_size} bytes"
+    except Exception as e:
+        return f"Error detecting file type: {str(e)}"
 
 
+file_type_detection_tool = Tool(
+    name="file_type_detection_tool",
+    func=detect_file_type,
+    description="Detects file types and provides information about files. Use this when you need to understand what type of file you're working with."
+)