Tool_Calling_with_Gemini_2_0.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO8wCAzeP8Dk6rs0AILBxfl",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/KhurramDevOps/Quarter-02/blob/master/Tool_Calling_with_Gemini_2_0.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## ***Here's my STREAMLIT APP Click down below to checkt it out!***\n",
        "# [AI-Powered Tool Assistant 🤖](https://khurramdevops-gemini-2-0-tool-calling-app-5rn8iw.streamlit.app)\n"
      ],
      "metadata": {
        "id": "7Zln7LYMJZaM"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "collapsed": true,
        "id": "ZrxXOhoukW1e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2778f987-20cb-402f-da25-7397600c9a37"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/41.5 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.5/41.5 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ],
      "source": [
        "!pip install langchain google-generativeai langchain_google_genai -q"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import userdata\n",
        "GENAI_KEY = userdata.get('GOOGLE_API_KEY_1')"
      ],
      "metadata": {
        "id": "_sdkmaG6kom4"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain_core.tools import tool"
      ],
      "metadata": {
        "id": "QlFlavsbmY7R"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Creating Multiple TOOLS**"
      ],
      "metadata": {
        "id": "jcSmtzplKGb2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "@tool\n",
        "def calculator(expression: str) -> float:\n",
        "    \"\"\"\n",
        "    Evaluates a given mathematical expression.\n",
        "\n",
        "    This function takes a mathematical expression as a string, evaluates it, and returns the result.\n",
        "    It handles basic arithmetic, parentheses, and more complex mathematical calculations.\n",
        "\n",
        "    Args:\n",
        "        expression (str): A mathematical expression to evaluate, e.g., \"3 + 5 * (2 - 8)\".\n",
        "\n",
        "    Returns:\n",
        "        Union[float, str]: The result of the evaluated expression, or an error message if invalid.\n",
        "\n",
        "    Example:\n",
        "        >>> evaluate_expression(\"3 + 5 * 2\")\n",
        "        13.0\n",
        "        >>> evaluate_expression(\"2 / 0\")\n",
        "        'Error: Division by zero.'\n",
        "        >>> evaluate_expression(\"invalid + expression\")\n",
        "        'Error: Invalid input.'\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Use eval to compute the result securely\n",
        "        result = eval(expression, {\"__builtins__\": None}, {})\n",
        "        if isinstance(result, (int, float)):  # Ensure result is a number\n",
        "            return result\n",
        "        else:\n",
        "            return \"Error: Invalid mathematical expression.\"\n",
        "    except ZeroDivisionError:\n",
        "        return \"Error: Division by zero.\"\n",
        "    except Exception:\n",
        "        return \"Error: Invalid input.\"\n"
      ],
      "metadata": {
        "id": "YyNQ5VZCwm2a"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import requests\n",
        "@tool\n",
        "def latest_news(api_key: str = \"c75303be293245a88968d6383fe4e32e\", country: str = \"us\", category: str = \"general\", limit: int = 5):\n",
        "    \"\"\"\n",
        "    Fetch the latest news headlines using the NewsAPI.\n",
        "\n",
        "    Args:\n",
        "        api_key (str): Your NewsAPI key.\n",
        "        country (str): The country for news headlines (default is \"us\").\n",
        "        category (str): The category of news (default is \"general\").\n",
        "        limit (int): Number of headlines to fetch (default is 5).\n",
        "\n",
        "    Returns:\n",
        "        list: A list of the latest news headlines.\n",
        "\n",
        "    Example:\n",
        "        >>> fetch_latest_news(api_key=\"your_api_key_here\", country=\"Pakistan\", category=\"technology\", limit=3)\n",
        "        ['Headline 1', 'Headline 2', 'Headline 3']\n",
        "    \"\"\"\n",
        "    base_url = \"https://newsapi.org/v2/top-headlines\"\n",
        "    params = {\n",
        "        \"apiKey\": api_key,\n",
        "        \"country\": country,\n",
        "        \"category\": category,\n",
        "        \"pageSize\": limit,\n",
        "    }\n",
        "\n",
        "    try:\n",
        "        response = requests.get(base_url, params=params)\n",
        "        response.raise_for_status()\n",
        "        data = response.json()\n",
        "        return [article[\"title\"] for article in data.get(\"articles\", [])]\n",
        "    except requests.exceptions.RequestException as e:\n",
        "        return [f\"Error fetching news: {e}\"]\n",
        "    except KeyError:\n",
        "        return [\"Error: Unexpected response structure.\"]\n",
        "\n",
        "\n",
        "# # Example Usage\n",
        "# if __name__ == \"__main__\":\n",
        "#     # Replace 'your_api_key_here' with your actual NewsAPI key\n",
        "#     API_KEY = \"c75303be293245a88968d6383fe4e32e\"\n",
        "\n",
        "#     print(\"Fetching the latest news...\")\n",
        "#     news_headlines = fetch_latest_news(api_key=API_KEY, country=\"us\", category=\"technology\", limit=5)\n",
        "\n",
        "#     print(\"\\nLatest News Headlines:\")\n",
        "#     for idx, headline in enumerate(news_headlines, start=1):\n",
        "#         print(f\"{idx}. {headline}\")\n"
      ],
      "metadata": {
        "id": "ZbXXeUDLytx7"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "@tool\n",
        "def get_stock_price(symbol: str) -> str:\n",
        "    \"\"\"Fetches the current stock price of a company based on its stock symbol using the Polygon API.\n",
        "\n",
        "    Args:\n",
        "        symbol (str): The stock symbol of the company (e.g., 'AAPL' for Apple, 'GOOGL' for Google).\n",
        "\n",
        "    Returns:\n",
        "        str: A message containing the current stock price of the company.\n",
        "\n",
        "    Raises:\n",
        "        HTTPError: If the HTTP request to the stock API fails (e.g., 404 or 500 status).\n",
        "        RequestException: If there is an issue with the request itself (e.g., connection error).\n",
        "        Exception: For any other unexpected errors during the execution of the function.\n",
        "\n",
        "    \"\"\"\n",
        "    api_key = \"bgXWqWwosch5iZV76iQUagp8KkaINWka\"  # Replace this with your actual secret API key from Polygon\n",
        "    url = f\"https://api.polygon.io/v2/aggs/ticker/{symbol}/prev\"  # Polygon endpoint for previous close price\n",
        "\n",
        "    try:\n",
        "        # Send a GET request with the API key\n",
        "        response = requests.get(url, params={'apiKey': api_key})\n",
        "        response.raise_for_status()  # Raise HTTPError for bad responses (4xx, 5xx)\n",
        "\n",
        "        # Assuming the data contains 'close' in the response for the last closing price\n",
        "        data = response.json()\n",
        "        price = data.get('results', [{}])[0].get('c')  # 'c' is the closing price\n",
        "\n",
        "        if price:\n",
        "            return f\"Tool used: get_stock_price\\n get_stock_price tool is used to find The current price of {symbol} is ${price}\"\n",
        "        else:\n",
        "            return f\"Error: Could not retrieve stock data for {symbol}.\\nTool used: get_stock_price\"\n",
        "\n",
        "    except requests.exceptions.HTTPError as http_err:\n",
        "        return f\"HTTP error occurred: {http_err}\\nTool used: get_stock_price\"\n",
        "    except requests.exceptions.RequestException as req_err:\n",
        "        return f\"Request error occurred: {req_err}\\nTool used: get_stock_price\"\n",
        "    except Exception as err:\n",
        "        return f\"An unexpected error occurred: {err}\\nTool used: get_stock_price\"\n"
      ],
      "metadata": {
        "id": "ALtHuMEz1XMx"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@tool\n",
        "def get_weather(city: str) -> str:\n",
        "    \"\"\"\n",
        "    Fetches the current weather for a given city using the OpenWeatherMap API.\n",
        "\n",
        "    Args:\n",
        "        city (str): Name of the city to get weather for.\n",
        "\n",
        "    Returns:\n",
        "        str: Weather information or error message.\n",
        "    \"\"\"\n",
        "    api_key = \"32443eadd3962154515f22cfe08c11d6\"\n",
        "    base_url = \"https://api.openweathermap.org/data/2.5/weather\"\n",
        "    params = {\n",
        "        \"q\": city,\n",
        "        \"appid\": api_key,\n",
        "        \"units\": \"metric\"  # Use \"imperial\" for Fahrenheit\n",
        "    }\n",
        "\n",
        "    try:\n",
        "        response = requests.get(base_url, params=params)\n",
        "        response.raise_for_status()  # Raise an exception for HTTP errors\n",
        "        data = response.json()\n",
        "\n",
        "        # Extract weather details\n",
        "        city_name = data[\"name\"]\n",
        "        temp = data[\"main\"][\"temp\"]\n",
        "        weather_description = data[\"weather\"][0][\"description\"]\n",
        "        humidity = data[\"main\"][\"humidity\"]\n",
        "        wind_speed = data[\"wind\"][\"speed\"]\n",
        "\n",
        "        # Format the result\n",
        "        return (\n",
        "            f\"Weather in {city_name}:\\n\"\n",
        "            f\"Temperature: {temp}°C\\n\"\n",
        "            f\"Condition: {weather_description.capitalize()}\\n\"\n",
        "            f\"Humidity: {humidity}%\\n\"\n",
        "            f\"Wind Speed: {wind_speed} m/s\"\n",
        "        )\n",
        "\n",
        "    except requests.exceptions.HTTPError:\n",
        "        return \"City not found. Please check the city name.\"\n",
        "    except Exception as e:\n",
        "        return f\"An error occurred: {e}\"\n",
        "\n"
      ],
      "metadata": {
        "id": "gsHBGnVRxaAS"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from googlesearch import search\n",
        "@tool\n",
        "def google_search_tool(query: str, num_results: int = 5):\n",
        "    \"\"\"\n",
        "    Perform a Google search for a given query and return the top results.\n",
        "\n",
        "    Args:\n",
        "        query (str): The search query.\n",
        "        num_results (int): Number of search results to return. Default is 5.\n",
        "\n",
        "    Returns:\n",
        "        list: A list of URLs for the top search results.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Perform the search\n",
        "        results = search(query, num_results=num_results)\n",
        "        return list(results)\n",
        "    except Exception as e:\n",
        "        return f\"An error occurred during the search: {e}\""
      ],
      "metadata": {
        "id": "wwdFc8alyiKv"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@tool\n",
        "def get_distance(location1: str, location2: str) -> str:\n",
        "    \"\"\"\n",
        "    Calculates the distance between two locations using the OpenCage Geocoder API.\n",
        "\n",
        "    This function uses the OpenCage Geocoder API to get the geographic coordinates (latitude and longitude)\n",
        "    of the provided locations, then computes the distance between the two points using the Haversine formula.\n",
        "\n",
        "    Args:\n",
        "        location1 (str): The first location (e.g., \"New York\").\n",
        "        location2 (str): The second location (e.g., \"Los Angeles\").\n",
        "\n",
        "    Returns:\n",
        "        str: A message containing the calculated distance in kilometers between the two locations.\n",
        "\n",
        "    Raises:\n",
        "        Exception: If either location is invalid or the API requests fail.\n",
        "    \"\"\"\n",
        "\n",
        "    api_key = \"289a5737aafd44809b61ef6667394dc5\"  # Replace with your OpenCage API key\n",
        "\n",
        "    # Geocode the origin location\n",
        "    url1 = f\"https://api.opencagedata.com/geocode/v1/json?q={location1}&key={api_key}\"\n",
        "    response1 = requests.get(url1)\n",
        "\n",
        "    # Geocode the destination location\n",
        "    url2 = f\"https://api.opencagedata.com/geocode/v1/json?q={location2}&key={api_key}\"\n",
        "    response2 = requests.get(url2)\n",
        "\n",
        "    # Check if both responses are successful\n",
        "    if response1.status_code == 200 and response2.status_code == 200:\n",
        "        data1 = response1.json()\n",
        "        data2 = response2.json()\n",
        "\n",
        "        # Extract latitude and longitude for both locations\n",
        "        lat1, lon1 = data1['results'][0]['geometry']['lat'], data1['results'][0]['geometry']['lng']\n",
        "        lat2, lon2 = data2['results'][0]['geometry']['lat'], data2['results'][0]['geometry']['lng']\n",
        "\n",
        "        # Calculate the distance using the Haversine formula\n",
        "        from math import radians, sin, cos, sqrt, atan2\n",
        "\n",
        "        # Convert latitude and longitude from degrees to radians\n",
        "        lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])\n",
        "\n",
        "        # Haversine formula\n",
        "        dlon = lon2 - lon1\n",
        "        dlat = lat2 - lat1\n",
        "        a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2\n",
        "        c = 2 * atan2(sqrt(a), sqrt(1 - a))\n",
        "\n",
        "        # Radius of the Earth in kilometers\n",
        "        radius = 6371.0\n",
        "\n",
        "        # Calculate the distance\n",
        "        distance = radius * c\n",
        "\n",
        "        return f\"Tool used: get_distance\\n get_distance tool is used to find The distance between {location1} and {location2} is {distance:.2f} km.\"\n",
        "\n",
        "    else:\n",
        "        return f\"Error: Could not calculate the distance. Check if both locations are valid.\\nTool used: get_distance\""
      ],
      "metadata": {
        "id": "LBvipvBkzO8J"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Adding Multiple Tools**"
      ],
      "metadata": {
        "id": "7FzwRW8WKfok"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tools = [calculator,latest_news,get_stock_price,get_weather,google_search_tool,get_distance]"
      ],
      "metadata": {
        "id": "uuS9k60DtQg4"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
        "\n",
        "llm = ChatGoogleGenerativeAI(model = \"gemini-2.0-flash-exp\", api_key=GENAI_KEY)"
      ],
      "metadata": {
        "id": "LkNLIS_qtVdf"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain.agents import initialize_agent, AgentType"
      ],
      "metadata": {
        "id": "lpORkOk7t1Ho"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "agent = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=False)"
      ],
      "metadata": {
        "id": "vIBobbQmuRxY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "426a49df-f59e-4ffa-efe8-2f82df5bf63e"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-18-b9b4063e039f>:1: LangChainDeprecationWarning: LangChain agents will continue to be supported, but it is recommended for new use cases to be built with LangGraph. LangGraph offers a more flexible and full-featured framework for building agents, including support for tool-calling, persistence of state, and human-in-the-loop workflows. For details, refer to the `LangGraph documentation <https://langchain-ai.github.io/langgraph/>`_ as well as guides for `Migrating from AgentExecutor <https://python.langchain.com/docs/how_to/migrate_agent/>`_ and LangGraph's `Pre-built ReAct agent <https://langchain-ai.github.io/langgraph/how-tos/create-react-agent/>`_.\n",
            "  agent = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=False)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Getting Responses from Multiple Tools**"
      ],
      "metadata": {
        "id": "GHTZbPSPKmO0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Using weather Tool**"
      ],
      "metadata": {
        "id": "vjKhrgmCBE6t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "response = agent({\"input\": \"What is the weather in lahore\"}) # Pass the input as a dictionary with the 'input' key\n",
        "print(response[\"output\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fKTMlUlIAVC1",
        "outputId": "933280ca-9f28-4273-dcc2-02df3760061a"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The weather in Lahore is: Temperature: 11.99°C, Condition: Smoke, Humidity: 76%, Wind Speed: 0 m/s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Using distance Tool**"
      ],
      "metadata": {
        "id": "ngrAMMCfBN-q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "response = agent({\"input\": \"What is the distance between lahore to islamabad\"}) # Pass the input as a dictionary with the 'input' key\n",
        "print(response[\"output\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u9qIxkHVAbrD",
        "outputId": "83023976-e957-41a9-8208-3ebdb5c78253"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The distance between Lahore and Islamabad is 263.96 km.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Using News Tool**"
      ],
      "metadata": {
        "id": "BppuR9rSBTx_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "response = agent({\"input\": \"What is the latest news \"}) # Pass the input as a dictionary with the 'input' key\n",
        "print(response[\"output\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0SYIG7FBAeVZ",
        "outputId": "41cb11c1-9f82-4cd8-c933-598b2c6f57bc"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Here are the latest news headlines: [Removed], Denver Broncos vs. Buffalo Bills AFC Wild Card game: How to watch, kickoff time and more - Yahoo Sports, Ice core may hold answers to mysteries of Earth’s past - CNN, Police Arrest 2 Suspected Burglars At Kamala Harris’ Brentwood Home Amid Fires - Deadline, JD Vance says there's \"a deal to be made in Greenland\" - Axios\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Using STokes Tool**"
      ],
      "metadata": {
        "id": "xwRt9xoWBY3J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "response = agent({\"input\": \"What is the price of google stock\"}) # Pass the input as a dictionary with the 'input' key\n",
        "print(response[\"output\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PAzli7_9AiYI",
        "outputId": "03629c11-276d-4615-fe14-adf852daa601"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The current price of Google (GOOGL) stock is $192.04.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Using Google_Search Tool**"
      ],
      "metadata": {
        "id": "CrYko5pzBeHw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "response = agent({\"input\": \"What is api?\"}) # Pass the input as a dictionary with the 'input' key\n",
        "print(response[\"output\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-ehtDpuaAxEW",
        "outputId": "c294f995-3829-4aa6-9017-62adb72469d2"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "An API (Application Programming Interface) is a set of rules and specifications that software programs can follow to communicate with each other. It allows different applications to interact and share information, without needing to know the underlying details of how each other are implemented. Think of it as a messenger that takes requests from one application and delivers them to another.\n"
          ]
        }
      ]
    }
  ]
}