all_agents_tutorials/news_tldr_langgraph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# News TL;DR using Langgraph (Too Long Didn't Read)\n",
    "\n",
    "## Overview\n",
    "This project demonstrates the creation of a news summarization agent uses large language models (LLMs) for decision making and summarization as well as a news API calls. The integration of LangGraph to coordinate sequential and cyclical processes, open-ai to choose and condense articles, newsAPI to retrieve relevant article metadata, and BeautifulSoup for web scraping allows for the generation of relevant current event article TL;DRs from a single query.\n",
    "\n",
    "## Motivation\n",
    "Although LLMs demonstrate excellent conversational and educational ability, they lack access to knowledge of current events. This project allow users to ask about a news topic they are interested and receive a TL;DR of relevant articles. The goal is to allow users to conveniently follow their interest and stay current with their connection to world events.\n",
    "\n",
    "## Key Components\n",
    "1. **LangGraph**: Orchestrates the overall workflow, managing the flow of data between different stages of the process.\n",
    "2. **GPT-4o-mini (via LangChain)**: Generates search terms, selects relevant articles, parses html, provides article summaries\n",
    "3. **NewsAPI**: Retrieves article metadata from keyword search\n",
    "4. **BeautifulSoup**: Retrieves html from page\n",
    "5. **Asyncio**: Allows separate LLM calls to be made concurrently for speed efficiency.\n",
    "\n",
    "## Method\n",
    "The news research follows these high-level steps:\n",
    "\n",
    "1. **NewsAPI Parameter Creation (LLM 1)**: Given a user query, the model generates a formatted parameter dict for the news search.\n",
    "\n",
    "2. **Article Metadata Retrieval**: An API call to NewsAPI retrieves relevant article metadata.\n",
    "\n",
    "3. **Article Text Retrieval**: Beautiful Soup scrapes the full article text from the urls to ensure validity.\n",
    "\n",
    "4. **Conditional Logic**: Conditional logic either: repeats 1-3 if article threshold not reached, proceeds to step 5, end with no articles found.\n",
    "\n",
    "5. **Relevant Article Selection (LLM 2)**: The model selects urls from the most relevant n-articles for the user query based on the short synopsis provided by the API.\n",
    "\n",
    "6. **Generate TL;DR (LLM 3+)**: A summarized set of bullet points for each article is generated concurrently with Asyncio.\n",
    "\n",
    "This workflow is managed by LangGraph to make sure that the appropriate prompt is fed to the each LLM call.\n",
    "\n",
    "## Conclusion\n",
    "This news TL;DR agent highlights the utility of coordinating successive LLM generations in order to\n",
    "achieve a higher level goal.\n",
    "\n",
    "Although the current implementation only retrieves bulleted summaries, it could be elaborated to start\n",
    "a dialogue with the user that could allow them to ask questions about the article and get \n",
    "more information or to collectively generate a coherent opinion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup and Imports\n",
    "\n",
    "Install and import necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install langgraph -q\n",
    "!pip install langchain-openai -q\n",
    "!pip install langchain-core -q\n",
    "!pip install pydantic -q\n",
    "!pip install python-dotenv -q\n",
    "!pip install newsapi-python -q\n",
    "!pip install beautifulsoup4 -q\n",
    "!pip install ipython -q\n",
    "!pip install nest_asyncio -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import TypedDict, Annotated, List\n",
    "from langgraph.graph import Graph, END\n",
    "from langchain_openai import ChatOpenAI\n",
    "from langchain_core.prompts import PromptTemplate\n",
    "from pydantic import BaseModel, Field\n",
    "from langchain_core.output_parsers import JsonOutputParser\n",
    "from langchain_core.runnables.graph import MermaidDrawMethod\n",
    "from datetime import datetime\n",
    "import re\n",
    "\n",
    "from getpass import getpass\n",
    "from dotenv import load_dotenv\n",
    "\n",
    "from newsapi import NewsApiClient\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "from IPython.display import display, Image as IPImage\n",
    "import asyncio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get an NewsAPI Key\n",
    "* create a free developer account at https://newsapi.org/\n",
    "* 100 requests per day\n",
    "* articles between 1 day and 1 month old"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup LLM Model\n",
    "* create an account and register a credit card at https://platform.openai.com/chat-completions\n",
    "* create an API key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Your Environmental Variables (Optional)\n",
    "Create a file named `.env` in the same directory as this notebook with the following\n",
    "```\n",
    "OPENAI_API_KEY = 'your-api-key'\n",
    "NEWSAPI_KEY = 'your-api-key'\n",
    "```\n",
    "\n",
    "If you skip this step, you will be asked to input all API keys once each time you start this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize Model and Environmental Variables\n",
    "\n",
    "If you're not running a local model with Ollama, the next cell will ask for your OPENAI_API_KEY and\n",
    "securely add it as an environmental variable. It will not persist in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check for .env file\n",
    "if os.path.exists(\"../.env\"):\n",
    "    load_dotenv()\n",
    "else:\n",
    "    # ask for API keys\n",
    "    os.environ[\"NEWSAPI_KEY\"] = getpass(\"Enter your News API key: \")\n",
    "    os.environ[\"OPENAI_API_KEY\"] = getpass(\"Enter your OpenAI API key: \")\n",
    "\n",
    "# sets the OpenAI model to use and initialize model\n",
    "model = \"gpt-4o-mini\"\n",
    "llm = ChatOpenAI(model=model,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NEWSAPI_KEY successfully loaded from .env.\n"
     ]
    }
   ],
   "source": [
    "newsapi_key = os.getenv(\"NEWSAPI_KEY\")\n",
    "if newsapi_key:\n",
    "        print(\"NEWSAPI_KEY successfully loaded from .env.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test APIs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"The sky appears blue primarily due to a phenomenon known as Rayleigh scattering. This occurs when sunlight enters the Earth's atmosphere and interacts with air molecules. \\n\\nSunlight, or white light, is made up of different colors, each with varying wavelengths. Blue light has a shorter wavelength than other colors, such as red or yellow. When sunlight passes through the atmosphere, the shorter wavelengths (blue and violet) are scattered in all directions by the gases and particles in the air. \\n\\nAlthough violet light is scattered even more than blue light, our eyes are more sensitive to blue light, and some of the violet light is absorbed by the ozone layer. As a result, we perceive the sky as blue during the day. \\n\\nAt sunrise and sunset, the sun's light has to pass through more of the Earth's atmosphere, which scatters the shorter blue wavelengths out of our line of sight, allowing the longer wavelengths (reds and oranges) to dominate the sky's colors during those times.\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "llm.invoke(\"Why is the sky blue?\").content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "newsapi = NewsApiClient(api_key=os.getenv('NEWSAPI_KEY'))\n",
    "\n",
    "query = 'ai news of the day'\n",
    "\n",
    "all_articles = newsapi.get_everything(q=query,\n",
    "                                      sources='google-news,bbc-news,techcrunch',\n",
    "                                      domains='techcrunch.com, bbc.co.uk',\n",
    "                                      language='en',\n",
    "                                      sort_by='relevancy',)\n",
    "\n",
    "\n",
    "all_articles['articles'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Data Structures\n",
    "\n",
    "Define the GraphState class. Each user query will be added to a new instance of this class, which will be passed\n",
    "through the LangGraph structure while collect outputs from each step. When it reaches the END node, it's final\n",
    "result will be returned to the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GraphState(TypedDict):\n",
    "    news_query: Annotated[str, \"Input query to extract news search parameters from.\"]\n",
    "    num_searches_remaining: Annotated[int, \"Number of articles to search for.\"]\n",
    "    newsapi_params: Annotated[dict, \"Structured argument for the News API.\"]\n",
    "    past_searches: Annotated[List[dict], \"List of search params already used.\"]\n",
    "    articles_metadata: Annotated[list[dict], \"Article metadata response from the News API\"]\n",
    "    scraped_urls: Annotated[List[str], \"List of urls already scraped.\"]\n",
    "    num_articles_tldr: Annotated[int, \"Number of articles to create TL;DR for.\"]\n",
    "    potential_articles: Annotated[List[dict[str, str, str]], \"Article with full text to consider summarizing.\"]\n",
    "    tldr_articles: Annotated[List[dict[str, str, str]], \"Selected article TL;DRs.\"]\n",
    "    formatted_results: Annotated[str, \"Formatted results to display.\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define NewsAPI argument data structure with Pydantic\n",
    "* the model will create a formatted dictionary of params for the NewsAPI call\n",
    "* the NewsApiParams class inherits from the Pydantic BaseModel\n",
    "* Langchain will parse and feed paramd descriptions to the LLM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NewsApiParams(BaseModel):\n",
    "    q: str = Field(description=\"1-3 concise keyword search terms that are not too specific\")\n",
    "    sources: str =Field(description=\"comma-separated list of sources from: 'abc-news,abc-news-au,associated-press,australian-financial-review,axios,bbc-news,bbc-sport,bloomberg,business-insider,cbc-news,cbs-news,cnn,financial-post,fortune'\")\n",
    "    from_param: str = Field(description=\"date in format 'YYYY-MM-DD' Two days ago minimum. Extend up to 30 days on second and subsequent requests.\")\n",
    "    to: str = Field(description=\"date in format 'YYYY-MM-DD' today's date unless specified\")\n",
    "    language: str = Field(description=\"language of articles 'en' unless specified one of ['ar', 'de', 'en', 'es', 'fr', 'he', 'it', 'nl', 'no', 'pt', 'ru', 'se', 'ud', 'zh']\")\n",
    "    sort_by: str = Field(description=\"sort by 'relevancy', 'popularity', or 'publishedAt'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Graph Functions\n",
    "\n",
    "Define the functions (nodes) that will be used in the LangGraph workflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_newsapi_params(state: GraphState) -> GraphState:\n",
    "    \"\"\"Based on the query, generate News API params.\"\"\"\n",
    "    # initialize parser to define the structure of the response\n",
    "    parser = JsonOutputParser(pydantic_object=NewsApiParams)\n",
    "\n",
    "    # retrieve today's date\n",
    "    today_date = datetime.now().strftime(\"%Y-%m-%d\")\n",
    "\n",
    "    # retrieve list of past search params\n",
    "    past_searches = state[\"past_searches\"]\n",
    "\n",
    "    # retrieve number of searches remaining\n",
    "    num_searches_remaining = state[\"num_searches_remaining\"]\n",
    "\n",
    "    # retrieve the user's query\n",
    "    news_query = state[\"news_query\"]\n",
    "\n",
    "    template = \"\"\"\n",
    "    Today is {today_date}.\n",
    "\n",
    "    Create a param dict for the News API based on the user query:\n",
    "    {query}\n",
    "\n",
    "    These searches have already been made. Loosen the search terms to get more results.\n",
    "    {past_searches}\n",
    "    \n",
    "    Following these formatting instructions:\n",
    "    {format_instructions}\n",
    "\n",
    "    Including this one, you have {num_searches_remaining} searches remaining.\n",
    "    If this is your last search, use all news sources and a 30 days search range.\n",
    "    \"\"\"\n",
    "\n",
    "    # create a prompt template to merge the query, today's date, and the format instructions\n",
    "    prompt_template = PromptTemplate(\n",
    "        template=template,\n",
    "        variables={\"today\": today_date, \"query\": news_query, \"past_searches\": past_searches, \"num_searches_remaining\": num_searches_remaining},\n",
    "        partial_variables={\"format_instructions\": parser.get_format_instructions()}\n",
    "    )\n",
    "\n",
    "    # create prompt chain template\n",
    "    chain = prompt_template | llm | parser\n",
    "\n",
    "    # invoke the chain with the news api query\n",
    "    result = chain.invoke({\"query\": news_query, \"today_date\": today_date, \"past_searches\": past_searches, \"num_searches_remaining\": num_searches_remaining})\n",
    "\n",
    "    # update the state\n",
    "    state[\"newsapi_params\"] = result\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrieve_articles_metadata(state: GraphState) -> GraphState:\n",
    "    \"\"\"Using the NewsAPI params, perform api call.\"\"\"\n",
    "    # parameters generated for the News API\n",
    "    newsapi_params = state[\"newsapi_params\"]\n",
    "\n",
    "    # decrement the number of searches remaining\n",
    "    state['num_searches_remaining'] -= 1\n",
    "\n",
    "    try:\n",
    "        # create a NewsApiClient object\n",
    "        newsapi = NewsApiClient(api_key=os.getenv('NEWSAPI_KEY'))\n",
    "        \n",
    "        # retreive the metadata of the new articles\n",
    "        articles = newsapi.get_everything(**newsapi_params)\n",
    "\n",
    "        # append this search term to the past searches to avoid duplicates\n",
    "        state['past_searches'].append(newsapi_params)\n",
    "\n",
    "        # load urls that have already been returned and scraped\n",
    "        scraped_urls = state[\"scraped_urls\"]\n",
    "\n",
    "        # filter out articles that have already been scraped\n",
    "        new_articles = []\n",
    "        for article in articles['articles']:\n",
    "            if article['url'] not in scraped_urls and len(state['potential_articles']) + len(new_articles) < 10:\n",
    "                new_articles.append(article)\n",
    "\n",
    "        # reassign new articles to the state\n",
    "        state[\"articles_metadata\"] = new_articles\n",
    "\n",
    "    # handle exceptions\n",
    "    except Exception as e:\n",
    "        print(f\"Error: {e}\")\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrieve_articles_text(state: GraphState) -> GraphState:\n",
    "    \"\"\"Web scrapes to retrieve article text.\"\"\"\n",
    "    # load retrieved article metadata\n",
    "    articles_metadata = state[\"articles_metadata\"]\n",
    "    # Add headers to simulate a browser\n",
    "    headers = {\n",
    "        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36'\n",
    "    }\n",
    "\n",
    "    # create list to store valid article dicts\n",
    "    potential_articles = []\n",
    "\n",
    "    # iterate over the urls\n",
    "    for article in articles_metadata:\n",
    "        # extract the url\n",
    "        url = article['url']\n",
    "\n",
    "        # use beautiful soup to extract the article content\n",
    "        response = requests.get(url, headers=headers)\n",
    "        \n",
    "        # check if the request was successful\n",
    "        if response.status_code == 200:\n",
    "            # parse the HTML content\n",
    "            soup = BeautifulSoup(response.content, 'html.parser')\n",
    "\n",
    "            # find the article content\n",
    "            text = soup.get_text(strip=True)\n",
    "\n",
    "            # append article dict to list\n",
    "            potential_articles.append({\"title\": article[\"title\"], \"url\": url, \"description\": article[\"description\"], \"text\": text})\n",
    "\n",
    "            # append the url to the processed urls\n",
    "            state[\"scraped_urls\"].append(url)\n",
    "\n",
    "    # append the processed articles to the state\n",
    "    state[\"potential_articles\"].extend(potential_articles)\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_top_urls(state: GraphState) -> GraphState:\n",
    "    \"\"\"Based on the article synoses, choose the top-n articles to summarize.\"\"\"\n",
    "    news_query = state[\"news_query\"]\n",
    "    num_articles_tldr = state[\"num_articles_tldr\"]\n",
    "    \n",
    "    # load all processed articles with full text but no summaries\n",
    "    potential_articles = state[\"potential_articles\"]\n",
    "\n",
    "    # format the metadata\n",
    "    formatted_metadata = \"\\n\".join([f\"{article['url']}\\n{article['description']}\\n\" for article in potential_articles])\n",
    "\n",
    "    prompt = f\"\"\"\n",
    "    Based on the user news query:\n",
    "    {news_query}\n",
    "\n",
    "    Reply with a list of strings of up to {num_articles_tldr} relevant urls.\n",
    "    Don't add any urls that are not relevant or aren't listed specifically.\n",
    "    {formatted_metadata}\n",
    "    \"\"\"\n",
    "    result = llm.invoke(prompt).content\n",
    "\n",
    "    # use regex to extract the urls as a list\n",
    "    url_pattern = r'(https?://[^\\s\",]+)'\n",
    "\n",
    "    # Find all URLs in the text\n",
    "    urls = re.findall(url_pattern, result)\n",
    "\n",
    "    # add the selected article metadata to the state\n",
    "    tldr_articles = [article for article in potential_articles if article['url'] in urls]\n",
    "\n",
    "    # tldr_articles = [article for article in potential_articles if article['url'] in urls]\n",
    "    state[\"tldr_articles\"] = tldr_articles\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def summarize_articles_parallel(state: GraphState) -> GraphState:\n",
    "    \"\"\"Summarize the articles based on full text.\"\"\"\n",
    "    tldr_articles = state[\"tldr_articles\"]\n",
    "\n",
    "    # prompt = \"\"\"\n",
    "    # Summarize the article text in a bulleted tl;dr. Each line should start with a hyphen -\n",
    "    # {article_text}\n",
    "    # \"\"\"\n",
    "\n",
    "    prompt = \"\"\"\n",
    "    Create a * bulleted summarizing tldr for the article:\n",
    "    {text}\n",
    "      \n",
    "    Be sure to follow the following format exaxtly with nothing else:\n",
    "    {title}\n",
    "    {url}\n",
    "    * tl;dr bulleted summary\n",
    "    * use bullet points for each sentence\n",
    "    \"\"\"\n",
    "\n",
    "    # iterate over the selected articles and collect summaries synchronously\n",
    "    for i in range(len(tldr_articles)):\n",
    "        text = tldr_articles[i][\"text\"]\n",
    "        title = tldr_articles[i][\"title\"]\n",
    "        url = tldr_articles[i][\"url\"]\n",
    "        # invoke the llm synchronously\n",
    "        result = llm.invoke(prompt.format(title=title, url=url, text=text))\n",
    "        tldr_articles[i][\"summary\"] = result.content\n",
    "\n",
    "    state[\"tldr_articles\"] = tldr_articles\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def format_results(state: GraphState) -> GraphState:\n",
    "    \"\"\"Format the results for display.\"\"\"\n",
    "    # load a list of past search queries\n",
    "    q = [newsapi_params[\"q\"] for newsapi_params in state[\"past_searches\"]]\n",
    "    formatted_results = f\"Here are the top {len(state['tldr_articles'])} articles based on search terms:\\n{', '.join(q)}\\n\\n\"\n",
    "\n",
    "    # load the summarized articles\n",
    "    tldr_articles = state[\"tldr_articles\"]\n",
    "\n",
    "    # format article tl;dr summaries\n",
    "    tldr_articles = \"\\n\\n\".join([f\"{article['summary']}\" for article in tldr_articles])\n",
    "\n",
    "    # concatenate summaries to the formatted results\n",
    "    formatted_results += tldr_articles\n",
    "\n",
    "    state[\"formatted_results\"] = formatted_results\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Up LangGraph Workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set up decision logic to try to retrieve `num_searches_remaining` articles, while limiting attempts to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def articles_text_decision(state: GraphState) -> str:\n",
    "    \"\"\"Check results of retrieve_articles_text to determine next step.\"\"\"\n",
    "    if state[\"num_searches_remaining\"] == 0:\n",
    "        # if no articles with text were found return END\n",
    "        if len(state[\"potential_articles\"]) == 0:\n",
    "            state[\"formatted_results\"] = \"No articles with text found.\"\n",
    "            return \"END\"\n",
    "        # if some articles were found, move on to selecting the top urls\n",
    "        else:\n",
    "            return \"select_top_urls\"\n",
    "    else:\n",
    "        # if the number of articles found is less than the number of articles to summarize, continue searching\n",
    "        if len(state[\"potential_articles\"]) < state[\"num_articles_tldr\"]:\n",
    "            return \"generate_newsapi_params\"\n",
    "        # otherwise move on to selecting the top urls\n",
    "        else:\n",
    "            return \"select_top_urls\"\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the LangGraph workflow by adding nodes and edges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "workflow = Graph()\n",
    "\n",
    "workflow.set_entry_point(\"generate_newsapi_params\")\n",
    "\n",
    "workflow.add_node(\"generate_newsapi_params\", generate_newsapi_params)\n",
    "workflow.add_node(\"retrieve_articles_metadata\", retrieve_articles_metadata)\n",
    "workflow.add_node(\"retrieve_articles_text\", retrieve_articles_text)\n",
    "workflow.add_node(\"select_top_urls\", select_top_urls)\n",
    "workflow.add_node(\"summarize_articles_parallel\", summarize_articles_parallel)\n",
    "workflow.add_node(\"format_results\", format_results)\n",
    "# workflow.add_node(\"add_commentary\", add_commentary)\n",
    "\n",
    "workflow.add_edge(\"generate_newsapi_params\", \"retrieve_articles_metadata\")\n",
    "workflow.add_edge(\"retrieve_articles_metadata\", \"retrieve_articles_text\")\n",
    "# # if the number of articles with parseable text is less than number requested, then search for more articles\n",
    "workflow.add_conditional_edges(\n",
    "    \"retrieve_articles_text\",\n",
    "    articles_text_decision,\n",
    "    {\n",
    "        \"generate_newsapi_params\": \"generate_newsapi_params\",\n",
    "        \"select_top_urls\": \"select_top_urls\",\n",
    "        \"END\": END\n",
    "    }\n",
    "    )\n",
    "workflow.add_edge(\"select_top_urls\", \"summarize_articles_parallel\")\n",
    "workflow.add_conditional_edges(\n",
    "    \"summarize_articles_parallel\",\n",
    "    lambda state: \"format_results\" if len(state[\"tldr_articles\"]) > 0 else \"END\",\n",
    "    {\n",
    "        \"format_results\": \"format_results\",\n",
    "        \"END\": END\n",
    "    }\n",
    "    )\n",
    "workflow.add_edge(\"format_results\", END)\n",
    "\n",
    "app = workflow.compile()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display Graph Structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(\n",
    "    IPImage(\n",
    "        app.get_graph().draw_mermaid_png(\n",
    "            draw_method=MermaidDrawMethod.API,\n",
    "        )\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Workflow Function\n",
    "\n",
    "Define a function to run the workflow and display results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def run_workflow(query: str, num_searches_remaining: int = 10, num_articles_tldr: int = 3):\n",
    "    \"\"\"Run the LangGraph workflow and display results.\"\"\"\n",
    "    initial_state = {\n",
    "        \"news_query\": query,\n",
    "        \"num_searches_remaining\": num_searches_remaining,\n",
    "        \"newsapi_params\": {},\n",
    "        \"past_searches\": [],\n",
    "        \"articles_metadata\": [],\n",
    "        \"scraped_urls\": [],\n",
    "        \"num_articles_tldr\": num_articles_tldr,\n",
    "        \"potential_articles\": [],\n",
    "        \"tldr_articles\": [],\n",
    "        \"formatted_results\": \"No articles with text found.\"\n",
    "    }\n",
    "    try:\n",
    "        result = await app.ainvoke(initial_state)\n",
    "        \n",
    "        return result[\"formatted_results\"]\n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred: {str(e)}\")\n",
    "        return None\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Execute Workflow\n",
    "\n",
    "Run the workflow with a sample query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here are the top 2 articles based on search terms:\n",
      "genai news\n",
      "\n",
      "NIQ Releases 2025 CMO Outlook Report  \n",
      "https://financialpost.com/pmn/business-wire-news-releases-pmn/niq-releases-2025-cmo-outlook-report  \n",
      "* NIQ's annual CMO Outlook report highlights evolving priorities for senior marketing leaders.  \n",
      "* The report emphasizes the role of AI, marketing measurement tools, and collaboration in driving growth for 2025.  \n",
      "* Economic challenges, such as rising costs and potential downturns, are affecting consumer spending patterns.  \n",
      "* Despite economic headwinds, 78% of marketers remain optimistic about their future position.  \n",
      "* Over half (56%) of marketers still view marketing as key for immediate sales, shifting focus towards long-term brand building.  \n",
      "* AI is increasingly being integrated into marketing strategies, with 72% utilizing it for content generation.  \n",
      "* Data-driven insights are crucial, with 81% of marketers relying on them for performance monitoring.  \n",
      "* The CMO Outlook Index shows slight improvement in marketing health, particularly in Europe.  \n",
      "* Marketers plan to enhance collaboration across departments to maximize AI potential.  \n",
      "* The report is based on a survey of nearly 600 senior marketing leaders from 18 countries.\n",
      "\n",
      "FPT Leverages AI to Optimize Legacy Systems for Enterprises  \n",
      "https://financialpost.com/pmn/business-wire-news-releases-pmn/fpt-leverages-ai-to-optimize-legacy-systems-for-enterprises  \n",
      "* FPT Corporation emphasizes the need for legacy system modernization at the FPT Techday 2024 event.  \n",
      "* Many of FPT's over 1,000 global clients still rely on outdated legacy systems that require significant maintenance.  \n",
      "* These legacy systems are costly, prone to errors, and hinder business agility in a rapidly changing tech landscape.  \n",
      "* FPT offers end-to-end services for legacy system management, including maintenance and cloud services.  \n",
      "* AI is central to FPT's strategy for modernizing legacy systems, enhancing efficiency and accuracy.  \n",
      "* The company utilizes tools like EMT, xMainframe, and CodeVista to facilitate modernization and onboarding.  \n",
      "* xMainframe reduces project onboarding time by 30% while maintaining 90% accuracy.  \n",
      "* CodeVista has generated 1.5 million lines of code, saving approximately 6,000 man-months in development time.  \n",
      "* FPT aims to help businesses navigate legacy system challenges and align with market demands for future success.  \n",
      "* FPT Corporation is a leading technology provider based in Vietnam, with a focus on sustainable growth and innovative solutions.  \n"
     ]
    }
   ],
   "source": [
    "query = \"what are the top genai news of today?\"\n",
    "print(await run_workflow(query, num_articles_tldr=3))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}