app.py

from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool

from Gradio_UI import GradioUI

# Below is an example of a tool that does nothing. Amaze us with your creativity !
@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 
    Args:
        arg1: the first argument
        arg2: the second argument
    """
    return "What magic will you build ?"

@tool
def get_current_time_in_timezone(timezone: str) -> str:
    """
    Retrieve the current local date and time for a specified timezone.

    This tool should be used whenever the user asks about:
    - The current time in a city, country, or region.
    - Timezone conversions.
    - Scheduling meetings across different regions.
    - Determining local time before performing an action.

    Accepted timezone format:
    - Asia/Kolkata
    - America/New_York
    - Europe/London
    - Asia/Tokyo
    - Australia/Sydney

    Args:
        timezone: A valid IANA timezone identifier.

    Returns:
        A formatted string containing the current local date and time
        in the requested timezone.

    Example:
        get_current_time_in_timezone("Asia/Kolkata")

    Expected Output:
        Current date and time in Asia/Kolkata:
        2026-06-22 14:35:10
    """
    try:
        tz = pytz.timezone(timezone)

        current_time = datetime.datetime.now(tz)

        return (
            f"Current date and time in {timezone}:\n"
            f"{current_time.strftime('%Y-%m-%d %H:%M:%S')}"
        )

    except Exception as e:
        return f"Error: {str(e)}"
        
@tool
def web_search(query: str) -> str:
    """
    Search the public internet using DuckDuckGo and return relevant search results.

    This tool should be used whenever up-to-date or real-time information is needed,
    including current events, recent news, company information, software releases,
    technical documentation, API references, research topics, tutorials, market trends,
    product information, or facts that may have changed after the model's training cutoff.

    The tool performs a DuckDuckGo web search and returns the most relevant results,
    including the page title, summary snippet, and source URL.

    Use this tool when:
    - The user asks for recent or current information.
    - The user asks about news, events, announcements, or updates.
    - The user requests information about websites, companies, products, or services.
    - Additional verification is needed before answering.
    - The user explicitly asks to search the web.

    Do NOT use this tool when:
    - The answer can be provided from general knowledge alone.
    - The user requests creative writing, brainstorming, or opinion generation.
    - The information is already available in the conversation context.

    Args:
        query: A clear and specific search query describing the information
            to retrieve. Examples:
            - "Latest OpenAI announcements"
            - "Python 3.14 release features"
            - "Current weather in Kochi"
            - "SmolAgents documentation"

    Returns:
        A formatted string containing the most relevant search results.
        Each result includes:
        - Title
        - Short description/snippet
        - Source URL

    Examples:
        >>> web_search("Latest AI agent frameworks")
        Returns a list of recent web results about AI agent frameworks.

        >>> web_search("Qwen3 model release")
        Returns search results related to the Qwen3 model release.

        >>> web_search("FastAPI documentation")
        Returns links and summaries for FastAPI documentation.
    """
    try:
        results = []

        with DDGS() as ddgs:
            for r in ddgs.text(query, max_results=5):
                results.append(
                    f"Title: {r['title']}\n"
                    f"Body: {r['body']}\n"
                    f"URL: {r['href']}\n"
                )

        return "\n\n".join(results)

    except Exception as e:
        return f"Search Error: {e}"


@tool
def get_weather(city: str) -> str:
    """
    Get the current weather for a city.

    Use this tool whenever the user asks:
    - Weather information
    - Temperature
    - Rain forecasts
    - Climate conditions
    - Outdoor planning questions

    Args:
        city: Name of a city.

    Returns:
        Current weather conditions and temperature.

    Example:
        get_weather("Kochi")

    Example Questions:
        - What's the weather in Kochi?
        - Is it raining in London?
        - Current temperature in Tokyo
    """
    try:
        url = f"https://wttr.in/{city}?format=3"

        response = requests.get(url)

        return response.text

    except Exception as e:
        return f"Weather lookup failed: {str(e)}"


final_answer = FinalAnswerTool()

# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 

model = HfApiModel(
max_tokens=2096,
temperature=0.5,
model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
custom_role_conversions=None,
)


# Import tool from Hub
image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)

search_tool = DuckDuckGoSearchTool()

with open("prompts.yaml", 'r') as stream:
    prompt_templates = yaml.safe_load(stream)
    
agent = CodeAgent(
    model=model,
    tools=[
        final_answer,
        search_tool,
        get_current_time_in_timezone,
        get_weather,
        image_generation_tool
    ],
    max_steps=10,
    verbosity_level=2,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)


GradioUI(agent).launch()