test

app.py

@@ -1,64 +1,418 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
-import datetime
+#!/usr/bin/env python3
+"""
+Personal Productivity Assistant Agent
+Built using smolagents framework following HuggingFace Agents Course
+
+USAGE:
+1. pip install -r requirements.txt
+2. export HF_TOKEN=your_huggingface_token
+3. python app.py
+
+OR deploy to HuggingFace Spaces directly!
+"""
+
+import os
+import json
 import requests
-import pytz
-import yaml
-from tools.final_answer import FinalAnswerTool
+import datetime
+from typing import List, Dict, Optional
+import gradio as gr
+from dataclasses import dataclass
+
+# smolagents imports
+from smolagents import (
+    CodeAgent, 
+    DuckDuckGoSearchTool, 
+    InferenceClientModel, 
+    tool,
+    Tool
+)
+
+# Set your HuggingFace token here
+HF_TOKEN = os.getenv("HF_TOKEN", "your_hf_token_here")
+
+@dataclass
+class Task:
+    """Simple task representation"""
+    id: str
+    title: str
+    description: str
+    due_date: Optional[str] = None
+    completed: bool = False
 
-from Gradio_UI import GradioUI
+class TaskManager:
+    """Simple in-memory task management"""
+    def __init__(self):
+        self.tasks = []
+        self.next_id = 1
+    
+    def add_task(self, title: str, description: str, due_date: str = None) -> str:
+        task = Task(
+            id=str(self.next_id),
+            title=title,
+            description=description,
+            due_date=due_date
+        )
+        self.tasks.append(task)
+        self.next_id += 1
+        return f"Task '{title}' added with ID {task.id}"
+    
+    def list_tasks(self) -> str:
+        if not self.tasks:
+            return "No tasks found."
+        
+        result = "Current Tasks:\n"
+        for task in self.tasks:
+            status = "✅" if task.completed else "⏳"
+            due_info = f" (Due: {task.due_date})" if task.due_date else ""
+            result += f"{status} [{task.id}] {task.title}{due_info}\n"
+        return result
+    
+    def complete_task(self, task_id: str) -> str:
+        for task in self.tasks:
+            if task.id == task_id:
+                task.completed = True
+                return f"Task '{task.title}' marked as completed!"
+        return f"Task with ID {task_id} not found."
+
+# Global task manager instance
+task_manager = TaskManager()
 
 @tool
-def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
-    #Keep this format for the description / args / args description but feel free to modify the tool
-    """A tool that does nothing yet 
+def add_task(title: str, description: str, due_date: str = None) -> str:
+    """
+    Add a new task to the task list.
+    
     Args:
-        arg1: the first argument
-        arg2: the second argument
+        title: Task title
+        description: Task description  
+        due_date: Optional due date in YYYY-MM-DD format
+    
+    Returns:
+        Confirmation message
     """
-    return "What magic will you build ?"
+    return task_manager.add_task(title, description, due_date)
 
 @tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
+def list_tasks() -> str:
+    """
+    List all current tasks with their status.
+    
+    Returns:
+        Formatted list of tasks
+    """
+    return task_manager.list_tasks()
+
+@tool
+def complete_task(task_id: str) -> str:
+    """
+    Mark a task as completed.
+    
     Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+        task_id: ID of the task to complete
+    
+    Returns:
+        Confirmation message
+    """
+    return task_manager.complete_task(task_id)
+
+@tool
+def get_current_time() -> str:
+    """
+    Get the current date and time.
+    
+    Returns:
+        Current date and time formatted string
+    """
+    now = datetime.datetime.now()
+    return f"Current time: {now.strftime('%Y-%m-%d %H:%M:%S')}"
+
+@tool
+def calculate_days_until(target_date: str) -> str:
+    """
+    Calculate days between today and a target date.
+    
+    Args:
+        target_date: Date in YYYY-MM-DD format
+    
+    Returns:
+        Number of days until target date
+    """
+    try:
+        today = datetime.date.today()
+        target = datetime.datetime.strptime(target_date, '%Y-%m-%d').date()
+        days_diff = (target - today).days
+        
+        if days_diff > 0:
+            return f"{days_diff} days until {target_date}"
+        elif days_diff == 0:
+            return f"{target_date} is today!"
+        else:
+            return f"{target_date} was {abs(days_diff)} days ago"
+    except ValueError:
+        return "Invalid date format. Please use YYYY-MM-DD."
+
+@tool
+def get_weather_info(city: str) -> str:
+    """
+    Get weather information for a city using a free weather API.
+    
+    Args:
+        city: City name
+    
+    Returns:
+        Weather information string
     """
     try:
-        # Create timezone object
-        tz = pytz.timezone(timezone)
-        # Get current time in that timezone
-        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return f"The current local time in {timezone} is: {local_time}"
+        # Using OpenWeatherMap API (you'd need to sign up for a free API key)
+        # For demo purposes, returning mock data
+        mock_weather = {
+            "london": "London: 15°C, Cloudy, 60% humidity",
+            "new york": "New York: 22°C, Sunny, 45% humidity", 
+            "paris": "Paris: 18°C, Light rain, 70% humidity",
+            "tokyo": "Tokyo: 25°C, Partly cloudy, 55% humidity"
+        }
+        
+        city_lower = city.lower()
+        if city_lower in mock_weather:
+            return mock_weather[city_lower]
+        else:
+            return f"Weather data for {city}: 20°C, Clear skies, 50% humidity (Mock data)"
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+        return f"Could not fetch weather for {city}: {str(e)}"
 
+@tool
+def send_mock_email(recipient: str, subject: str, body: str) -> str:
+    """
+    Send a mock email (simulation only).
+    
+    Args:
+        recipient: Email recipient
+        subject: Email subject
+        body: Email body content
+    
+    Returns:
+        Confirmation message
+    """
+    return f"Mock email sent to {recipient}\nSubject: {subject}\nBody preview: {body[:50]}..."
 
-final_answer = FinalAnswerTool()
-model = HfApiModel(
-max_tokens=2096,
-temperature=0.5,
-model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-custom_role_conversions=None,
-)
+@tool
+def create_meeting_summary(attendees: str, topic: str, duration_minutes: int) -> str:
+    """
+    Create a meeting summary template.
+    
+    Args:
+        attendees: Comma-separated list of attendees
+        topic: Meeting topic
+        duration_minutes: Meeting duration in minutes
+    
+    Returns:
+        Meeting summary template
+    """
+    now = datetime.datetime.now()
+    end_time = now + datetime.timedelta(minutes=duration_minutes)
+    
+    summary = f"""
+    MEETING SUMMARY TEMPLATE
+    ========================
+    Date: {now.strftime('%Y-%m-%d')}
+    Time: {now.strftime('%H:%M')} - {end_time.strftime('%H:%M')}
+    Duration: {duration_minutes} minutes
+    Topic: {topic}
+    Attendees: {attendees}
+    
+    AGENDA:
+    - [ ] Welcome and introductions
+    - [ ] Main topic discussion
+    - [ ] Action items
+    - [ ] Next steps
+    
+    NOTES:
+    [Add meeting notes here]
+    
+    ACTION ITEMS:
+    - [ ] [Action item 1 - Assignee]
+    - [ ] [Action item 2 - Assignee]
+    
+    NEXT MEETING: [Date/Time]
+    """
+    return summary
 
+class PersonalProductivityAgent:
+    """Main productivity agent class"""
+    
+    def __init__(self):
+        # Initialize the model
+        self.model = InferenceClientModel(
+            model="Qwen/Qwen2.5-Coder-32B-Instruct",
+            token=HF_TOKEN
+        )
+        
+        # Initialize tools
+        self.search_tool = DuckDuckGoSearchTool()
+        
+        # Create custom tools list
+        self.custom_tools = [
+            add_task,
+            list_tasks, 
+            complete_task,
+            get_current_time,
+            calculate_days_until,
+            get_weather_info,
+            send_mock_email,
+            create_meeting_summary
+        ]
+        
+        # Initialize the CodeAgent
+        self.agent = CodeAgent(
+            tools=[self.search_tool] + self.custom_tools,
+            model=self.model,
+            add_base_tools=True,  # Adds basic tools like Python execution
+            planning_interval=3   # Plan every 3 steps
+        )
+        
+        # System prompt customization
+        self.agent.system_prompt = """You are an advanced Personal Productivity Assistant named Alfred. 
+        
+        You help users manage their daily tasks, schedule, communications, and information needs.
+        
+        Key capabilities:
+        - Task management (add, list, complete tasks)
+        - Time and date calculations
+        - Weather information
+        - Web search and research
+        - Email composition (mock)
+        - Meeting planning and templates
+        - General calculations and code execution
+        
+        Always be helpful, concise, and proactive in suggesting productivity improvements.
+        When users ask for help, offer multiple options and explain your reasoning.
+        """
+    
+    def run(self, query: str, reset_memory: bool = False) -> str:
+        """Run the agent with a user query"""
+        try:
+            response = self.agent.run(query, reset=reset_memory)
+            return str(response)
+        except Exception as e:
+            return f"I apologize, but I encountered an error: {str(e)}"
 
-# Import tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+# Initialize the global agent
+productivity_agent = PersonalProductivityAgent()
 
-with open("prompts.yaml", 'r') as stream:
-    prompt_templates = yaml.safe_load(stream)
+def chat_interface(message, history, reset_conversation):
+    """Gradio chat interface function"""
+    if reset_conversation:
+        # Reset the conversation memory
+        response = productivity_agent.run(message, reset_memory=True)
+    else:
+        response = productivity_agent.run(message, reset_memory=False)
     
-agent = CodeAgent(
-    model=model,
-    tools=[image_generation_tool,get_current_time_in_timezone,final_answer,DuckDuckGoSearchTool()], ## add or remove tools here
-    max_steps=6,
-    verbosity_level=1,
-    grammar=None,
-    planning_interval=None,
-    name=None,
-    description=None,
-    prompt_templates=prompt_templates
-)
+    history.append([message, response])
+    return history, ""
+
+def demo_queries():
+    """Return a list of demo queries users can try"""
+    return [
+        "Add a task to review the quarterly report by 2025-07-15",
+        "What's the weather like in London today?",
+        "List all my current tasks", 
+        "How many days until Christmas 2025?",
+        "Search for the latest AI agent research papers",
+        "Create a meeting summary for a 1-hour team standup with John, Sarah, and Mike",
+        "Calculate 15% of 50000 and explain the tax implications",
+        "Complete task 1",
+        "Send a mock email to manager@company.com about project status"
+    ]
 
+# Gradio Interface
+def create_gradio_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(title="Personal Productivity Assistant", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🤖 Personal Productivity Assistant (Alfred)
+        
+        Your AI-powered productivity companion built with smolagents framework.
+        
+        **Capabilities:**
+        - 📋 Task Management (add, list, complete)
+        - 🌤️ Weather Information  
+        - 📅 Date/Time Calculations
+        - 🔍 Web Search & Research
+        - 📧 Email Composition (mock)
+        - 📊 Meeting Templates
+        - 🧮 Code Execution & Calculations
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(
+                    label="Chat with Alfred",
+                    height=500,
+                    show_label=True
+                )
+                
+                with gr.Row():
+                    msg = gr.Textbox(
+                        label="Message",
+                        placeholder="Ask me anything about productivity, tasks, weather, or research...",
+                        scale=4
+                    )
+                    submit_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                reset_btn = gr.Button("Reset Conversation", variant="secondary")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### 💡 Try These Examples:")
+                
+                example_queries = demo_queries()
+                for query in example_queries:
+                    gr.Button(
+                        query,
+                        size="sm"
+                    ).click(
+                        lambda q=query: (q, ""),
+                        outputs=[msg, msg]
+                    )
+        
+        # Event handlers
+        submit_btn.click(
+            chat_interface,
+            inputs=[msg, chatbot, gr.State(False)],
+            outputs=[chatbot, msg]
+        )
+        
+        msg.submit(
+            chat_interface,
+            inputs=[msg, chatbot, gr.State(False)], 
+            outputs=[chatbot, msg]
+        )
+        
+        reset_btn.click(
+            lambda: ([], ""),
+            outputs=[chatbot, msg]
+        )
+        
+        gr.Markdown("""
+        ---
+        **Built with:** smolagents • HuggingFace • Qwen2.5-Coder-32B-Instruct
+        
+        **Features Demonstrated:**
+        - CodeAgent with custom tools
+        - Multi-tool orchestration  
+        - Memory management
+        - Real-world productivity use cases
+        """)
+    
+    return demo
 
-GradioUI(agent).launch()
+if __name__ == "__main__":
+    # Create and launch the interface
+    demo = create_gradio_interface()
+    demo.launch(
+        share=True,
+        debug=True,
+        server_name="0.0.0.0",
+        server_port=7860
+    )

requirements.txt

@@ -1,5 +1,7 @@
-markdownify
-smolagents==1.13.0
-requests
-duckduckgo_search
-pandas
+smolagents>=0.4.0
+gradio>=4.0.0
+huggingface_hub>=0.19.0
+transformers>=4.35.0
+torch>=2.0.0
+requests>=2.31.0
+python-dateutil>=2.8.2