OpenAIAgent_LLamaIndex.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyON45bjNAAKdvNcdL3raal+",
      "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/Jkanishkha0305/AI-Agents/blob/main/OpenAIAgent_LLamaIndex.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Building Financial Agent using OpenAIAgent from LlamaIndex along with yfinance API\n",
        "\n",
        "\n",
        "LlamaIndex has developed interesting tools that streamline the creation of agents through seamless integration with various other tools.      \n",
        "\n",
        "  \n",
        "👉 Tested with various questions regarding NVIDIA:\n",
        "- What is the last price of NVIDIA?\n",
        "- What is the current capitalization of NVDIA\n",
        "- From which source did you get this information?\n",
        "- By analysing the closing price of NVIDIA during the last 2 weeks, was it on an uptrend or a downtrend\n",
        "- What was the last esitmated vs reported earnings?\n",
        "....\n",
        "\n",
        "\n",
        "👉 By using these tools, a single agent consolidates various pieces of information by calling different underlying functions to provide the appropriate answer."
      ],
      "metadata": {
        "id": "m6mRrsZJW5wn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Open AI Agnet using LLamaIndex"
      ],
      "metadata": {
        "id": "dl2hR0_fXedn"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "GjvcOe4SW2pT"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!pip install llama-index"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Agent form LLamaIndex Agent"
      ],
      "metadata": {
        "id": "NybRn2klXwfT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from llama_index.agent.openai import OpenAIAgent"
      ],
      "metadata": {
        "id": "z8rz3FfDXtic"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import userdata\n",
        "openai_api_key = userdata.get('OPENAI_API_KEY')\n",
        "\n",
        "import openai\n",
        "openai.api_key = openai_api_key\n",
        "\n",
        "from llama_index.llms.openai import OpenAI\n",
        "llm = OpenAI(model=\"gpt-4-1106-preview\",api_key=openai_api_key)"
      ],
      "metadata": {
        "id": "72NqJIeEX1o_"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Importing yfinance in parallel to check the LLM's answer in some questions\n",
        "import yfinance as yf\n",
        "\n",
        "ticker = 'NVDA'\n",
        "stock = yf.Ticker(ticker)"
      ],
      "metadata": {
        "id": "XYup6eQFX4ev"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1.1 Loading Functions Call"
      ],
      "metadata": {
        "id": "qzVoTjKfYJgt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 1.1.1 Loading base.py module with different functions to call:"
      ],
      "metadata": {
        "id": "4RPXWJ3gYYSn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %load_ext autoreload\n",
        "# %autoreload 2"
      ],
      "metadata": {
        "id": "-XfaWCpWYEW9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "sys.path.append('local_path')\n",
        "\n",
        "# from base import YahooFinanceToolSpec\n",
        "# from llama_index.tools.yahoo_finance import YahooFinanceToolSpec\n",
        "\n",
        "# import YahooFinanceToolSpec\n",
        "#imports didnt work so loading YahooFinanceToolSpec() form base.py in section 2"
      ],
      "metadata": {
        "id": "wnfdk2CdO13a"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 1.1.2 Different functions included in YahooFinanceToolSpec (in base.py)"
      ],
      "metadata": {
        "id": "u3bxmDp4CVTd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "finance_tool = YahooFinanceToolSpec() #loaded from section 2\n",
        "\n",
        "finance_tool_list = finance_tool.to_tool_list()\n",
        "for tool in finance_tool_list:\n",
        "    print(tool.metadata.name)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XjhnRGZSCG8s",
        "outputId": "28d6cc9c-276a-42ac-8814-e5ee6baf56ca"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "balance_sheet\n",
            "income_statement\n",
            "cash_flow\n",
            "quarterly_financials\n",
            "stock_basic_info\n",
            "stock_analyst_recommendations\n",
            "stock_news\n",
            "stock_prices\n",
            "stock_earnings\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 1.1.3 Example"
      ],
      "metadata": {
        "id": "5qPE_hqACRGA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(finance_tool.stock_earnings(\"NVDA\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LVvxuydICPE3",
        "outputId": "c682f3f7-18ec-42cb-9106-42b57a6a7901"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                           EPS Estimate  Reported EPS  Surprise(%)\n",
            "Earnings Date                                                     \n",
            "2025-02-19 16:00:00-05:00           NaN           NaN          NaN\n",
            "2024-11-19 16:00:00-05:00           NaN           NaN          NaN\n",
            "2024-08-21 06:00:00-04:00           NaN           NaN          NaN\n",
            "2024-06-21 14:00:00-04:00          5.55           NaN          NaN\n",
            "2024-05-22 17:00:00-04:00          5.55           NaN          NaN\n",
            "2024-05-22 16:00:00-04:00          5.55           NaN          NaN\n",
            "2024-03-19 11:00:00-04:00          4.63          5.16       0.1145\n",
            "2024-03-18 06:00:00-04:00          4.63          5.16       0.1145\n",
            "2024-03-05 09:00:00-05:00          4.63          5.16       0.1145\n",
            "2024-03-04 13:00:00-05:00          4.63          5.16       0.1145\n",
            "2024-02-28 21:00:00-05:00          4.63          5.16       0.1145\n",
            "2024-02-28 12:00:00-05:00          4.63          5.16       0.1145\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1.2 Instanciating the Agent from OpenAI - LLamaIndex:"
      ],
      "metadata": {
        "id": "yNGdwAyUCf83"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from llama_index.agent.openai import OpenAIAgent\n",
        "agent = OpenAIAgent.from_tools(finance_tool_list, llm=llm)"
      ],
      "metadata": {
        "id": "p0mRoWfeC3bl"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1.3 Chatting with the Agent"
      ],
      "metadata": {
        "id": "ZIij_TI-C784"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"What is the last price of NVIDIA?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VsYI8dNUC7VF",
        "outputId": "94d94ccc-f992-48bc-ccfe-7b270bcf8421"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The last price of NVIDIA (NVDA) is $902.48.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"From which date did you get this price?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JJ8US8qNDNLC",
        "outputId": "87adff3c-7a33-489b-8e6f-fd785f2a9940"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price information provided does not include a specific date, but it is typically the most recent closing price from the last trading session. If you need the exact date and time for the price, I can fetch the latest stock prices for NVIDIA, which will include the date and time. Would you like me to do that?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"Yes please do\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T__v7TYpDPsh",
        "outputId": "a93d0315-7c78-4f7e-9947-7a83df749f91"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The last price of NVIDIA (NVDA) at $902.979980 was recorded on May 13, 2024.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"What is the current capitalization of NVDIA\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "szgGYAbIDR8R",
        "outputId": "895609e3-e11d-4d99-f251-85e9e7bf9c90"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The current market capitalization of NVIDIA (NVDA) is approximately $2.256 trillion.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"From which source did you get this information?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rz1L2jhVDT1H",
        "outputId": "886f84c3-65aa-4818-db79-7a1d3cbc5037"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The market capitalization information for NVIDIA (NVDA) was obtained from the stock basic info provided by the yfinance API, which is a reliable source for financial data.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"Give me the min, max of the closing price of NVIDIA during the last 2 weeks?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WwaSTKsKDWPi",
        "outputId": "80b0a0b9-5647-40c0-b9ca-0373c001bb12"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "During the last two weeks, the minimum closing price of NVIDIA (NVDA) was $762.00 on April 19, 2024, and the maximum closing price was $921.40 on May 6, 2024.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"By analysing the closing price of NVIDIA during the last 2 weeks, was it on an uptrend or a downtrend\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tXuddvtwDZxm",
        "outputId": "ab2b5106-a5ca-4993-c1ac-e5b04a5de11a"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "To determine whether NVIDIA (NVDA) was on an uptrend or a downtrend during the last two weeks, we can compare the closing prices at the beginning and end of the period.\n",
            "\n",
            "- The closing price on April 30, 2024, was $864.02.\n",
            "- The closing price on May 13, 2024, was $902.825012.\n",
            "\n",
            "Since the closing price increased from $864.02 to $902.825012 over the last two weeks, NVIDIA was on an uptrend during this period.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"What was the last esitmated vs reported earnings?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2yyEpADhDfWI",
        "outputId": "3979b8d5-5552-4f74-90de-b43c6656aef4"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The last reported earnings for NVIDIA (NVDA) were for the date of March 19, 2024. The EPS estimate was $4.63, and the reported EPS was $5.16, resulting in a surprise of 11.45%.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#TO CHECK\n",
        "print(finance_tool.stock_earnings(\"NVDA\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YIGMDIEaDgi9",
        "outputId": "1148b5de-217a-4eb1-e38c-4aa07a6783d4"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                           EPS Estimate  Reported EPS  Surprise(%)\n",
            "Earnings Date                                                     \n",
            "2025-02-19 16:00:00-05:00           NaN           NaN          NaN\n",
            "2024-11-19 16:00:00-05:00           NaN           NaN          NaN\n",
            "2024-08-21 06:00:00-04:00           NaN           NaN          NaN\n",
            "2024-06-21 14:00:00-04:00          5.55           NaN          NaN\n",
            "2024-05-22 17:00:00-04:00          5.55           NaN          NaN\n",
            "2024-05-22 16:00:00-04:00          5.55           NaN          NaN\n",
            "2024-03-19 11:00:00-04:00          4.63          5.16       0.1145\n",
            "2024-03-18 06:00:00-04:00          4.63          5.16       0.1145\n",
            "2024-03-05 09:00:00-05:00          4.63          5.16       0.1145\n",
            "2024-03-04 13:00:00-05:00          4.63          5.16       0.1145\n",
            "2024-02-28 21:00:00-05:00          4.63          5.16       0.1145\n",
            "2024-02-28 12:00:00-05:00          4.63          5.16       0.1145\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"from which source did you get this info?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8IGAhiM5Di72",
        "outputId": "b93dbdf5-1321-4090-bc6d-495df0665437"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The information regarding NVIDIA's (NVDA) last estimated vs reported earnings was obtained from the yfinance API, which provides financial data including earnings estimates and actual reported earnings for publicly traded companies.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"I think that February 21, 2024 was not the last reported earnings. Could you check again?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HTIEs-snDlJA",
        "outputId": "59c6d2f8-0b29-4f0a-9ae3-473cea225e81"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Upon rechecking the data, the last reported earnings for NVIDIA (NVDA) were indeed for the date of March 19, 2024. The EPS estimate was $4.63, and the reported EPS was $5.16, resulting in a surprise of 11.45%. There are no reported earnings after this date, as the subsequent dates show estimated EPS without reported values.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(agent.chat(\"What will be the next estimated value?\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R8OpQlxhDqj4",
        "outputId": "ec3369b5-4e90-41f6-a250-eb87177eb74c"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The next estimated EPS for NVIDIA (NVDA) is $5.55, as shown in the data for the upcoming earnings dates. However, the exact date for this estimate has not been reported yet.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Base.py Module\n",
        "\n",
        "\n",
        "```from llama_index.tools.yahoo_finance import YahooFinanceToolSpec```\n",
        "\n",
        "didnt work therfore loading base.py from : https://github.com/run-llama/llama_index/blob/main/llama-index-integrations/tools/llama-index-tools-yahoo-finance/llama_index/tools/yahoo_finance/base.py"
      ],
      "metadata": {
        "id": "q5SwRIvutVWv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from llama_index.core.tools.tool_spec.base import BaseToolSpec\n",
        "import yfinance as yf\n",
        "import pandas as pd\n",
        "\n",
        "class YahooFinanceToolSpec(BaseToolSpec):\n",
        "    \"\"\"Yahoo Finance tool spec.\"\"\"\n",
        "\n",
        "    spec_functions = [\n",
        "        \"balance_sheet\",\n",
        "        \"income_statement\",\n",
        "        \"cash_flow\",\n",
        "        \"quarterly_financials\",\n",
        "        \"stock_basic_info\",\n",
        "        \"stock_analyst_recommendations\",\n",
        "        \"stock_news\",\n",
        "        \"stock_prices\",\n",
        "        \"stock_earnings\"\n",
        "    ]\n",
        "\n",
        "    def __init__(self) -> None:\n",
        "      \"\"\"Initialize the Yahoo Finance tool spec.\"\"\"\n",
        "\n",
        "    def balance_sheet(self, ticker: str) -> str:\n",
        "      \"\"\"\n",
        "      Return the balance sheet of the stock.\n",
        "      Args:\n",
        "        ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "\n",
        "      stock = yf.Ticker(ticker)\n",
        "      balance_sheet = pd.DataFrame(stock.balance_sheet)\n",
        "      return \"Balance Sheet: \\n\" + balance_sheet.to_string()\n",
        "\n",
        "\n",
        "    def income_statement(self, ticker: str) -> str:\n",
        "      \"\"\"\n",
        "      Return the income statement of the stock.\n",
        "      Args:\n",
        "        ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      income_statement = pd.DataFrame(stock.income_stmt)\n",
        "      return \"Income Statement: \\n\" + income_statement.to_string()\n",
        "\n",
        "    def cash_flow(self, ticker: str) -> str:\n",
        "      \"\"\"\n",
        "      Return the cash flow of the stock.\n",
        "      Args:\n",
        "        ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      cash_flow = stock.cashflow\n",
        "      return \"Cash Flow: \\n\" + cash_flow.to_string()\n",
        "\n",
        "\n",
        "    def quarterly_financials(self, ticker: str) -> pd.DataFrame:\n",
        "      \"\"\"\n",
        "      Return the quarterly financials of the stock.\n",
        "      Args:\n",
        "        ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      quarterly_financials = stock.quarterly_financials\n",
        "      return quarterly_financials\n",
        "\n",
        "    def stock_basic_info(self, ticker: str) -> str:\n",
        "      \"\"\"\n",
        "      Return the basic info of the stock. Ex: price, description, name.\n",
        "      Args:\n",
        "        ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      return \"Info: \\n\" + str(stock.info)\n",
        "\n",
        "    def stock_analyst_recommendations(self, ticker: str) -> str:\n",
        "      \"\"\"\n",
        "      Get the analyst recommendations for a stock.\n",
        "      Args:\n",
        "        ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      return \"Recommendations: \\n\" + str(stock.recommendations)\n",
        "\n",
        "    def stock_news(self, ticker: str) -> str:\n",
        "      \"\"\"\n",
        "        Get the most recent news titles of a stock.\n",
        "        Args:\n",
        "          ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      news = stock.news\n",
        "      out = \"News: \\n\"\n",
        "      for i in news:\n",
        "        out += i[\"title\"] + \"\\n\"\n",
        "      return out\n",
        "\n",
        "    def stock_prices(self, ticker: str) -> pd.DataFrame:\n",
        "      \"\"\"\n",
        "        Get the historical prices and volume for a stock.\n",
        "        Args:\n",
        "          ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      df = stock.history()\n",
        "      return df\n",
        "\n",
        "    def stock_earnings(self, ticker: str) -> pd.DataFrame:\n",
        "      \"\"\"\n",
        "      Get the earnings estimated vs reported and percentage surpise per date (past and future dates).\n",
        "      Args:\n",
        "        ticker (str): the stock ticker to be given to yfinance\n",
        "      \"\"\"\n",
        "      stock = yf.Ticker(ticker)\n",
        "      earnings = stock.earnings_dates\n",
        "      return earnings"
      ],
      "metadata": {
        "id": "z6oi4AJOO5rF"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HsILu7wfvIMs"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}