Upload 9 files

agent/agent.py

@@ -0,0 +1,87 @@
+from openai import OpenAI
+from .tools import tools
+from .utils import system_prompt, handle_tool_calls
+
+# okay now we have app file I got it from smola agent its a taste file I have agent use that agent and add that agent in app in such a way that api come with questions and this agent give answers check how app file is made you will undertand dont change structure and way and logis ogf app file
+
+# Initialize OpenAI client
+client = OpenAI(
+    api_key="sk-60c49cf5d82a4d4bb0a6c111eeafe941",
+    base_url="https://api.deepseek.com"
+)
+
+def chat_with_agent(user_message):
+    """Main function to chat with the agent - gives short, concise responses"""
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_message}
+    ]
+    
+    while True:
+        # Get response from LLM with token limits
+        response = client.chat.completions.create(
+            model="deepseek-chat",
+            messages=messages,
+            tools=tools,
+        )
+        
+        # Add the assistant's response to messages
+        messages.append(response.choices[0].message)
+        
+        # Handle tool calls if any
+        tool_results = handle_tool_calls(response)
+        
+        if tool_results:
+            # Add tool results to messages
+            messages.extend(tool_results)
+            
+            # Add a reminder for the final response to be short
+            messages.append({
+                "role": "system", 
+                "content": "Remember: Give a SHORT summary (2-3 lines max) of the tool results. Focus on key points only."
+            })
+            
+            # Continue the conversation (the LLM will respond to the tool results)
+            continue
+        else:
+            # No tool calls, return the final response
+            return response.choices[0].message.content
+
+# def interactive_chat():
+#     """Interactive chat interface with short responses"""
+#     print("🤖 Welcome to the AI Agent!")
+#     print("I'll give you short, concise answers.")
+#     print("Type 'quit' to exit.")
+#     print("-" * 50)
+    
+#     while True:
+#         user_input = input("\n👤 You: ").strip()
+        
+#         if user_input.lower() in ['quit', 'exit', 'bye', 'q']:
+#             print("🤖 Goodbye!")
+#             break
+        
+#         if not user_input:
+#             continue
+        
+#         try:
+#             print("🤖 Thinking...")
+#             response = chat_with_agent(user_input)
+#             print(f"🤖 Assistant: {response}")
+            
+#         except Exception as e:
+#             print(f"🤖 Error: {str(e)}")
+
+# Example usage
+# if __name__ == "__main__":
+#     # Interactive mode
+#     interactive_chat()
+    
+    # Uncomment for testing with specific questions
+    # user_question = "What's the weather like in Mumbai?"
+    # print(f"User: {user_question}")
+    # answer = chat_with_agent(user_question)
+    # print(f"Assistant: {answer}")
+
+print(chat_with_agent("tech news today"))

agent/handlers.py

@@ -0,0 +1,273 @@
+import requests
+from bs4 import BeautifulSoup
+import re
+from datetime import datetime
+import pytz
+from PIL import Image
+from io import BytesIO
+import tempfile
+import os
+import speech_recognition as sr
+from ddgs import DDGS
+from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+from transformers import BlipProcessor, BlipForConditionalGeneration
+import torch
+# Lazy import pydub to avoid ffmpeg warning when not needed
+# from pydub import AudioSegment
+# handlers for tools
+
+# 1. get_weather
+def get_weather(latitude : str, longitude : str) -> str:
+    """Get current temperature for a given location using latitude and longitude coordinates."""
+    api = f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m"
+    response = requests.get(api)
+    return response.json()["current"]["temperature_2m"]
+
+# 2. web_search
+def web_search(query: str, max_results: int = 5) -> str:
+    """Enhanced web search with better error handling"""
+    try:
+        results_text = []
+        with DDGS() as ddgs:
+            # Add more specific search parameters
+            results = ddgs.text(
+                query, 
+                max_results=max_results,
+                region='us-en',
+                safesearch='off'
+            )
+            
+            for i, result in enumerate(results):
+                title = result.get("title", "")
+                snippet = result.get("body", "")
+                link = result.get("href", "")
+                
+                # Clean up the text
+                title = title.strip() if title else ""
+                snippet = snippet.strip() if snippet else ""
+                
+                if title or snippet:
+                    results_text.append(f"{i+1}. {title}\n🔗 {link}\n📝 {snippet}\n")
+        
+        if results_text:
+            return "\n".join(results_text)
+        else:
+            # Try alternative search approach
+            return f"No results found for: {query}. Try rephrasing your search query."
+            
+    except Exception as e:
+        return f"Search error: {str(e)}. Please try a different search query."
+
+
+# 3. get_time_in_location
+def get_current_time(timezone: str = "Asia/Kolkata") -> str:
+    """Get current time in specified timezone."""
+    try:
+        # Convert timezone string to pytz timezone object
+        tz = pytz.timezone(timezone)
+        current_time = datetime.now(tz)
+        
+        # Format the time nicely
+        formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S %Z")
+        
+        return f"Current time in {timezone}: {formatted_time}"
+        
+    except Exception as e:
+        return f"Error getting time: {str(e)}"
+
+def get_time_in_location(location: str) -> str:
+    """Get current time for a specific location."""
+    # Map common locations to timezones
+    location_timezones = {
+        "gujarat": "Asia/Kolkata",
+        "india": "Asia/Kolkata", 
+        "mumbai": "Asia/Kolkata",
+        "delhi": "Asia/Kolkata",
+        "paris": "Europe/Paris",
+        "london": "Europe/London",
+        "new york": "America/New_York",
+        "tokyo": "Asia/Tokyo",
+        "sydney": "Australia/Sydney",
+        "utc": "UTC"
+    }
+    
+    location_lower = location.lower()
+    
+    if location_lower in location_timezones:
+        timezone = location_timezones[location_lower]
+        return get_current_time(timezone)
+    else:
+        return f"I don't have timezone information for '{location}'. Try: Gujarat, India, Mumbai, Delhi, Paris, London, New York, Tokyo, Sydney, or UTC."
+    
+# 4. analyze_image
+def analyze_image(image_url: str, question: str = None) -> str:
+    """Analyze an image and optionally answer a visual question about it."""
+    try:
+        # Download the image
+        headers = {"User-Agent": "Mozilla/5.0"}
+        response = requests.get(image_url, headers=headers, timeout=30)
+        response.raise_for_status()
+        
+        # Open image
+        image = Image.open(BytesIO(response.content)).convert('RGB')
+        
+        # Load BLIP model for visual QA or captioning
+        processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
+        model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-vqa-base")
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        model.to(device)
+
+        if question:
+            inputs = processor(image, question, return_tensors="pt").to(device)
+            out = model.generate(**inputs)
+            answer = processor.decode(out[0], skip_special_tokens=True)
+            return f"❓ Question: {question}\n🧠 Answer: {answer}"
+        else:
+            # If no question, generate a caption
+            processor_caption = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+            model_caption = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+            model_caption.to(device)
+
+            inputs = processor_caption(image, return_tensors="pt").to(device)
+            out = model_caption.generate(**inputs)
+            caption = processor_caption.decode(out[0], skip_special_tokens=True)
+            return f"🖼️ Image Caption: {caption}"
+
+    except Exception as e:
+        return f"Error analyzing image: {e}"
+
+# 5. analyze_video
+def analyze_video(video_url: str) -> str:
+    """Analyze YouTube video metadata and attempt to fetch subtitles/transcript."""
+    try:
+        # Validate YouTube URL and extract video ID
+        video_id_match = re.search(r'(?:youtube\.com\/(?:watch\?v=|shorts\/)|youtu\.be\/)([^&\n?#\/]+)', video_url)
+        if not video_id_match:
+            return "Invalid YouTube URL format. Please provide a valid YouTube or Shorts URL."
+        
+        video_id = video_id_match.group(1)
+        headers = {
+            "User-Agent": "Mozilla/5.0"
+        }
+
+        response = requests.get(video_url, headers=headers, timeout=20)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Extract title
+        title = None
+        for selector in ['meta[property="og:title"]', 'meta[name="title"]', 'title']:
+            el = soup.select_one(selector)
+            if el:
+                title = el.get('content') or el.text
+                break
+        title_text = title.strip() if title else "Unknown title"
+
+        # Extract description
+        description = None
+        for selector in ['meta[property="og:description"]', 'meta[name="description"]']:
+            el = soup.select_one(selector)
+            if el:
+                description = el.get('content') or el.text
+                break
+        desc_text = description.strip() if description else "No description available"
+
+        # Extract channel
+        channel = None
+        for selector in ['link[itemprop="name"]', 'meta[itemprop="channelId"]', 'a[href*="/@"]']:
+            el = soup.select_one(selector)
+            if el:
+                channel = el.get('content') or el.text or el.get('title')
+                break
+        channel_text = channel.strip() if channel else "Unknown channel"
+
+        # Attempt to fetch transcript using YouTubeTranscriptApi
+        transcript_text = "Transcript not available."
+        try:
+            transcript = YouTubeTranscriptApi.get_transcript(video_id)
+            transcript_text = "\n".join([f"{line['text']}" for line in transcript[:5]]) + "\n..."
+        except (TranscriptsDisabled, NoTranscriptFound):
+            transcript_text = "No transcript available for this video."
+        except Exception as e:
+            transcript_text = f"Transcript fetch failed: {e}"
+
+        # Final analysis summary
+        result = f"📺 Video Analysis\n"
+        result += f"Title: {title_text}\n"
+        result += f"Channel: {channel_text}\n"
+        result += f"Description: {desc_text[:300]}...\n"
+        result += f"Transcript Preview:\n{transcript_text}"
+
+        return result
+
+    except Exception as e:
+        return f"Error analyzing video: {e}"
+
+# 6. transcribe_audio
+def transcribe_audio(audio_url: str) -> str:
+    """Transcribe audio content from an audio file URL using speech recognition."""
+    try:
+        # Download the audio file
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
+        response = requests.get(audio_url, headers=headers, timeout=30)
+        response.raise_for_status()
+        
+        # Create a temporary file to store the audio
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as temp_audio:
+            temp_audio.write(response.content)
+            temp_audio_path = temp_audio.name
+        
+        try:
+            # Try to convert audio to WAV format (speech_recognition works better with WAV)
+            try:
+                # Lazy import pydub only when needed
+                from pydub import AudioSegment
+                audio = AudioSegment.from_file(temp_audio_path)
+                
+                # Create temporary WAV file
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_wav:
+                    audio.export(temp_wav.name, format="wav")
+                    wav_path = temp_wav.name
+                    
+            except Exception as e:
+                # If conversion fails, try using the original file directly
+                print(f"Audio conversion warning: {e}")
+                wav_path = temp_audio_path
+            
+            # Initialize speech recognizer
+            recognizer = sr.Recognizer()
+            
+            # Load the audio file
+            with sr.AudioFile(wav_path) as source:
+                # Adjust for ambient noise
+                recognizer.adjust_for_ambient_noise(source, duration=0.5)
+                # Record the audio
+                audio_data = recognizer.record(source)
+                
+                # Try to recognize speech
+                try:
+                    # Use Google Speech Recognition (free, requires internet)
+                    text = recognizer.recognize_google(audio_data)
+                    return f"Audio Transcription:\n{text}"
+                    
+                except sr.UnknownValueError:
+                    return "Audio Transcription: Could not understand the audio. The speech may be unclear, too quiet, or in a language not supported."
+                    
+                except sr.RequestError as e:
+                    return f"Audio Transcription: Error with speech recognition service: {str(e)}"
+                    
+        finally:
+            # Clean up temporary files
+            try:
+                os.unlink(temp_audio_path)
+                if wav_path != temp_audio_path:  # Only delete wav file if it's different
+                    os.unlink(wav_path)
+            except:
+                pass
+                
+    except ImportError:
+        return "Audio Transcription: Speech recognition library not available. Please install 'SpeechRecognition' package."
+        
+    except Exception as e:
+        return f"Audio Transcription Error: {str(e)}"

agent/tempCodeRunnerFile.py

@@ -0,0 +1 @@
+handle_tool_calls

agent/tools.py

@@ -0,0 +1,115 @@
+tools = [{
+    "type": "function",
+    "function": {
+        "name": "get_weather",
+        "description": "Get current temperature for a given location using latitude and longitude coordinates.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "latitude": {
+                    "type": "string",
+                    "description": "Latitude coordinate (e.g., '23.0225')"
+                },
+                "longitude": {
+                    "type": "string", 
+                    "description": "Longitude coordinate (e.g., '72.5714')"
+                }
+            },
+            "required": [
+                "latitude",
+                "longitude"
+            ],
+            "additionalProperties": False
+        }
+    }
+}, 
+{
+    "type": "function",
+    "function": {
+        "name": "web_search",
+        "description": "Go to web and take information regarding the user query. always return the up to date real time information.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "Search query for web search"
+                }
+            },
+            "required": [
+                "query"
+            ],
+            "additionalProperties": False
+        }
+    }
+},
+{
+    "type": "function",
+    "function": {
+        "name": "get_time_in_location",
+        "description": "Get current time for a specific location or city.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "Location name (e.g., 'Gujarat', 'Mumbai', 'Paris', 'New York')"
+                }
+            },
+            "required": ["location"],
+            "additionalProperties": False
+        }
+    }
+},
+    {
+        "type": "function",
+        "function": {
+            "name": "analyze_image",
+            "description": "Describe what is visible in an image - people, objects, animals, scenes, actions, and what is happening. Focus on content description rather than technical properties. Use this when users ask about what they see in an image or provide image URLs.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "image_url": {
+                        "type": "string",
+                        "description": "URL of the image to analyze (supports common formats like JPG, PNG, etc.)"
+                    }
+                },
+                "required": ["image_url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "analyze_video",
+            "description": "Use this when users ask about video content and provide YouTube URLs or just youtube video url. give the title, description, channel, and transcript of the video or if ask something than just give strightforward answer of that question",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "video_url": {
+                        "type": "string",
+                        "description": "YouTube URL of the video to analyze (e.g., https://www.youtube.com/watch?v=..., https://youtu.be/..., or https://www.youtube.com/shorts/...)"
+                    }
+                },
+                "required": ["video_url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "transcribe_audio",
+            "description": "Transcribe audio content from an audio file URL. Extract spoken words and convert them to text. Use this when users provide audio files (.mp3, .wav, .m4a, etc.) or ask about audio content.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "audio_url": {
+                        "type": "string",
+                        "description": "URL of the audio file to transcribe (supports common formats like MP3, WAV, M4A, etc.)"
+                    }
+                },
+                "required": ["audio_url"]
+            }
+        }
+    }
+]

agent/utils.py

@@ -0,0 +1,99 @@
+import json
+from .handlers import get_weather, web_search, get_time_in_location, analyze_image, analyze_video, transcribe_audio
+
+# loop for tool calls
+def handle_tool_calls(response):
+    """Handle tool calls from the LLM response"""
+    message = response.choices[0].message
+    
+    # If the LLM wants to use tools
+    if message.tool_calls:
+        # Create a list to store tool results
+        tool_results = []
+        
+        for tool_call in message.tool_calls:
+            function_name = tool_call.function.name
+            function_args = json.loads(tool_call.function.arguments)
+            
+            # print(f"🔧 Calling function: {function_name}")
+            # print(f"📝 With arguments: {function_args}")
+            
+            # Call the appropriate function based on the tool name
+            if function_name == "get_weather":
+                result = get_weather(
+                    function_args["latitude"], 
+                    function_args["longitude"]
+                )
+            elif function_name == "web_search":
+                result = web_search(function_args["query"])
+            elif function_name == "get_time_in_location":
+                result = get_time_in_location(function_args["location"])
+            elif function_name == "analyze_image":
+                result = analyze_image(function_args["image_url"])
+            elif function_name == "analyze_video":
+                result = analyze_video(function_args["video_url"])
+            elif function_name == "transcribe_audio":
+                result = transcribe_audio(function_args["audio_url"])
+            else:
+                result = f"Unknown function: {function_name}"
+            
+            # Add the result to our list
+            tool_results.append({
+                "tool_call_id": tool_call.id,
+                "role": "tool",
+                "content": str(result)
+            })
+        
+        return tool_results
+    
+    return None
+
+# Enhanced system prompt for short responses
+# system_prompt = """You are a powerful and well knowledgeable AI assistant with access to weather, time, web search, video analysis, and audio transcription tools. If someone asks you about anything you can answer it with or without the help of tools. You are also a good and friendly assistant. There is nothing you don't know - always give answers, never say you don't know.
+
+# IMPORTANT RESPONSE RULES:
+# - Keep responses SHORT and CONCISE (2-3 lines maximum)
+# - Focus only on the MOST IMPORTANT information
+# - Use bullet points or short sentences
+# - Avoid long explanations and paragraphs
+# - Be direct and to the point
+# - If using tools, summarize the key findings briefly
+
+# For VIDEO ANALYSIS:
+# - When given a YouTube URL, use the analyze_video tool to extract video information
+# - Summarize the video content based on title, description, and channel info
+# - Focus on what the video is about, not generic YouTube Shorts descriptions
+
+# For AUDIO TRANSCRIPTION:
+# - When given an audio file URL (.mp3, .wav, etc.), use the transcribe_audio tool
+# - Extract the spoken content and provide a clear summary
+# - Focus on the key information requested from the audio
+
+# Example good response:
+# "Current temperature in Mumbai: 28°C. Weather is sunny with light winds."
+
+# Example bad response:
+# "The weather in Mumbai is currently quite pleasant with a temperature of 28 degrees Celsius. The conditions are sunny with some light winds blowing through the city, making it a perfect day for outdoor activities..."
+
+# When using web search results, extract only the key points and present them concisely.
+# """
+
+# ... existing code ...
+system_prompt = """You are a powerful AI assistant with access to specialized tools for:
+- YouTube video analysis (extract title, description, channel, transcripts)
+- Image analysis (describe images and answer visual questions)
+- Web search (get real-time information)
+- Audio transcription (convert speech to text)
+- Weather data (get current temperature)
+- Time information (get time for different locations)
+
+IMPORTANT: When users ask about videos, images, audio, or need current information, USE THE APPROPRIATE TOOLS to provide accurate, up-to-date answers.
+
+For video analysis: Use analyze_video tool for YouTube URLs
+For image analysis: Use analyze_image tool for image URLs  
+For web search: Use web_search tool for current information
+For audio: Use transcribe_audio tool for audio files
+
+Always provide helpful, detailed responses using your tools when appropriate. If you need to use tools, do so and then provide a comprehensive answer based on the results.
+
+FINAL ANSWER: [Your final answer based on tool results or knowledge]"""