diff --git a/cookbook/report_maistro.ipynb b/cookbook/report_maistro.ipynb new file mode 100644 index 00000000..43a01318 --- /dev/null +++ b/cookbook/report_maistro.ipynb @@ -0,0 +1,1194 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "# Report mAIstro\n", + "\n", + "Use this notebook for testing [report mAIstro](https://github.com/langchain-ai/report-mAIstro) with Nvidia NIM.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "%pip install --quiet -U langgraph langchain_community langchain_core tavily-python langchain_nvidia_ai_endpoints" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NVDA tool models:\n", + "[Model(id='meta/llama-3.1-8b-instruct', model_type='chat', client='ChatNVIDIA', endpoint=None, aliases=None, supports_tools=True, supports_structured_output=True, base_model=None), Model(id='meta/llama-3.1-70b-instruct', model_type='chat', client='ChatNVIDIA', endpoint=None, aliases=None, supports_tools=True, supports_structured_output=True, base_model=None), Model(id='meta/llama-3.1-405b-instruct', model_type='chat', client='ChatNVIDIA', endpoint=None, aliases=None, supports_tools=True, supports_structured_output=True, base_model=None), Model(id='mistralai/mistral-large-2-instruct', model_type='chat', client='ChatNVIDIA', endpoint=None, aliases=None, supports_tools=True, supports_structured_output=True, base_model=None), Model(id='nv-mistralai/mistral-nemo-12b-instruct', model_type='chat', client='ChatNVIDIA', endpoint=None, aliases=None, supports_tools=True, supports_structured_output=True, base_model=None), Model(id='meta/llama-3.2-3b-instruct', model_type='chat', client='ChatNVIDIA', endpoint=None, aliases=None, supports_tools=True, supports_structured_output=True, base_model=None)]\n" + ] + } + ], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "if not os.environ.get(\"NVIDIA_API_KEY\", \"\").startswith(\"nvapi-\"):\n", + " nvapi_key = getpass.getpass(\"Enter your NVIDIA API key: \")\n", + " assert nvapi_key.startswith(\"nvapi-\"), f\"{nvapi_key[:5]}... is not a valid key\"\n", + " os.environ[\"NVIDIA_API_KEY\"] = nvapi_key\n", + "\n", + "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n", + "tool_models = [model for model in ChatNVIDIA.get_available_models() if model.supports_tools]\n", + "print(\"NVDA tool models:\")\n", + "print(tool_models)\n", + "model_id = \"meta/llama-3.1-8b-instruct\"\n", + "model_id = \"meta/llama-3.1-70b-instruct\"\n", + "llm = ChatNVIDIA(model=model_id, temperature=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll use [Tavily API](https://tavily.com/) web search tool." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "_set_env(\"TAVILY_API_KEY\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from tavily import TavilyClient, AsyncTavilyClient\n", + "tavily_client = TavilyClient()\n", + "tavily_async_client = AsyncTavilyClient()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "We'll use [LangSmith](https://docs.smith.langchain.com/) for [tracing](https://docs.smith.langchain.com/concepts/tracing)." + ] + }, + { + "cell_type": "code", + "execution_count": 473, + "metadata": {}, + "outputs": [], + "source": [ + "_set_env(\"LANGCHAIN_API_KEY\")\n", + "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n", + "os.environ[\"LANGCHAIN_PROJECT\"] = \"report-mAIstro\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Utils\n", + "\n", + "Utility functions that we'll use for web research." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import asyncio\n", + "from langsmith import traceable\n", + "\n", + "def deduplicate_and_format_sources(search_response, max_tokens_per_source, include_raw_content=True):\n", + " \"\"\"\n", + " Takes either a single search response or list of responses from Tavily API and formats them.\n", + " Limits the raw_content to approximately max_tokens_per_source.\n", + " include_raw_content specifies whether to include the raw_content from Tavily in the formatted string.\n", + " \n", + " Args:\n", + " search_response: Either:\n", + " - A dict with a 'results' key containing a list of search results\n", + " - A list of dicts, each containing search results\n", + " \n", + " Returns:\n", + " str: Formatted string with deduplicated sources\n", + " \"\"\"\n", + " # Convert input to list of results\n", + " if isinstance(search_response, dict):\n", + " sources_list = search_response['results']\n", + " elif isinstance(search_response, list):\n", + " sources_list = []\n", + " for response in search_response:\n", + " if isinstance(response, dict) and 'results' in response:\n", + " sources_list.extend(response['results'])\n", + " else:\n", + " sources_list.extend(response)\n", + " else:\n", + " raise ValueError(\"Input must be either a dict with 'results' or a list of search results\")\n", + " \n", + " # Deduplicate by URL\n", + " unique_sources = {}\n", + " for source in sources_list:\n", + " if source['url'] not in unique_sources:\n", + " unique_sources[source['url']] = source\n", + " \n", + " # Format output\n", + " formatted_text = \"Sources:\\n\\n\"\n", + " for i, source in enumerate(unique_sources.values(), 1):\n", + " formatted_text += f\"Source {source['title']}:\\n===\\n\"\n", + " formatted_text += f\"URL: {source['url']}\\n===\\n\"\n", + " formatted_text += f\"Most relevant content from source: {source['content']}\\n===\\n\"\n", + " if include_raw_content:\n", + " # Using rough estimate of 4 characters per token\n", + " char_limit = max_tokens_per_source * 4\n", + " # Handle None raw_content\n", + " raw_content = source.get('raw_content', '')\n", + " if raw_content is None:\n", + " raw_content = ''\n", + " print(f\"Warning: No raw_content found for source {source['url']}\")\n", + " if len(raw_content) > char_limit:\n", + " raw_content = raw_content[:char_limit] + \"... [truncated]\"\n", + " formatted_text += f\"Full source content limited to {max_tokens_per_source} tokens: {raw_content}\\n\\n\"\n", + " \n", + " return formatted_text.strip()\n", + "\n", + "def format_sections(sections: list[Section]) -> str:\n", + " \"\"\" Format a list of sections into a string \"\"\"\n", + " formatted_str = \"\"\n", + " for idx, section in enumerate(sections, 1):\n", + " formatted_str += f\"\"\"\n", + "{'='*60}\n", + "Section {idx}: {section.name}\n", + "{'='*60}\n", + "Description:\n", + "{section.description}\n", + "Requires Research: \n", + "{section.research}\n", + "\n", + "Content:\n", + "{section.content if section.content else '[Not yet written]'}\n", + "\n", + "\"\"\"\n", + " return formatted_str\n", + "\n", + "@traceable\n", + "def tavily_search(query):\n", + " \"\"\" Search the web using the Tavily API.\n", + " \n", + " Args:\n", + " query (str): The search query to execute\n", + " \n", + " Returns:\n", + " dict: Tavily search response containing:\n", + " - results (list): List of search result dictionaries, each containing:\n", + " - title (str): Title of the search result\n", + " - url (str): URL of the search result\n", + " - content (str): Snippet/summary of the content\n", + " - raw_content (str): Full content of the page if available\"\"\"\n", + " \n", + " return tavily_client.search(query, \n", + " max_results=5, \n", + " include_raw_content=True)\n", + "\n", + "@traceable\n", + "async def tavily_search_async(search_queries, tavily_topic, tavily_days):\n", + " \"\"\"\n", + " Performs concurrent web searches using the Tavily API.\n", + "\n", + " Args:\n", + " search_queries (List[SearchQuery]): List of search queries to process\n", + " tavily_topic (str): Type of search to perform ('news' or 'general')\n", + " tavily_days (int): Number of days to look back for news articles (only used when tavily_topic='news')\n", + "\n", + " Returns:\n", + " List[dict]: List of search results from Tavily API, one per query\n", + "\n", + " Note:\n", + " For news searches, each result will include articles from the last `tavily_days` days.\n", + " For general searches, the time range is unrestricted.\n", + " \"\"\"\n", + " \n", + " search_tasks = []\n", + " for query in search_queries:\n", + " if tavily_topic == \"news\":\n", + " search_tasks.append(\n", + " tavily_async_client.search(\n", + " query,\n", + " max_results=5,\n", + " include_raw_content=True,\n", + " topic=\"news\",\n", + " days=tavily_days\n", + " )\n", + " )\n", + " else:\n", + " search_tasks.append(\n", + " tavily_async_client.search(\n", + " query,\n", + " max_results=5,\n", + " include_raw_content=True,\n", + " topic=\"general\"\n", + " )\n", + " )\n", + "\n", + " # Execute all searches concurrently\n", + " search_docs = await asyncio.gather(*search_tasks)\n", + "\n", + " return search_docs" + ] + }, + { + "attachments": { + "c1425cfd-d268-43da-9cce-ed2367bc1286.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flow\n", + "\n", + "![report_mAIstro.png](attachment:c1425cfd-d268-43da-9cce-ed2367bc1286.png)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Planning\n", + "\n", + "Schema for report sections:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from typing_extensions import TypedDict\n", + "from typing import Annotated, List, Optional, Literal\n", + "from pydantic import BaseModel, Field\n", + "\n", + "class Section(BaseModel):\n", + " name: str = Field(\n", + " description=\"Name for this section of the report.\",\n", + " )\n", + " description: str = Field(\n", + " description=\"Brief overview of the main topics and concepts to be covered in this section.\",\n", + " )\n", + " research: bool = Field(\n", + " description=\"Whether to perform web research for this section of the report.\"\n", + " )\n", + " content: str = Field(\n", + " description=\"The content of the section.\"\n", + " ) \n", + "class Sections(BaseModel):\n", + " sections: List[Section] = Field(\n", + " description=\"Sections of the report.\",\n", + " )\n", + "class SearchQuery(BaseModel):\n", + " search_query: str = Field(\n", + " None, description=\"Query for web search.\"\n", + " )\n", + "class Queries(BaseModel):\n", + " queries: List[SearchQuery] = Field(\n", + " description=\"List of search queries.\",\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "LangGraph state: " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import operator\n", + "\n", + "class ReportState(TypedDict):\n", + " topic: str # Report topic\n", + " tavily_topic: Literal[\"general\", \"news\"] # Tavily search topic\n", + " tavily_days: Optional[int] # Only applicable for news topic\n", + " report_structure: str # Report structure\n", + " number_of_queries: int # Number web search queries to perform per section \n", + " sections: list[Section] # List of report sections \n", + " completed_sections: Annotated[list, operator.add] # Send() API key\n", + " report_sections_from_research: str # String of any completed sections from research to write final sections\n", + " final_report: str # Final report" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generate report sections:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from langchain_core.messages import HumanMessage, SystemMessage\n", + "\n", + "# Prompt to generate a search query to help with planning the report outline\n", + "report_planner_query_writer_instructions=\"\"\"You are an expert technical writer, helping to plan a report. \n", + "\n", + "The report will be focused on the following topic:\n", + "\n", + "{topic}\n", + "\n", + "The report structure will follow these guidelines:\n", + "\n", + "{report_organization}\n", + "\n", + "Your goal is to generate {number_of_queries} search queries that will help gather comprehensive information for planning the report sections. \n", + "\n", + "The query should:\n", + "\n", + "1. Be related to the topic \n", + "2. Help satisfy the requirements specified in the report organization\n", + "\n", + "Make the query specific enough to find high-quality, relevant sources while covering the breadth needed for the report structure.\"\"\"\n", + "\n", + "# Prompt generating the report outline\n", + "report_planner_instructions=\"\"\"You are an expert technical writer, helping to plan a report.\n", + "\n", + "Your goal is to generate the outline of the sections of the report. \n", + "\n", + "The overall topic of the report is:\n", + "\n", + "{topic}\n", + "\n", + "The report should follow this organization: \n", + "\n", + "{report_organization}\n", + "\n", + "You should reflect on this information to plan the sections of the report: \n", + "\n", + "{context}\n", + "\n", + "Now, generate the sections of the report. Each section should have the following fields:\n", + "\n", + "- Name - Name for this section of the report.\n", + "- Description - Brief overview of the main topics and concepts to be covered in this section.\n", + "- Research - Whether to perform web research for this section of the report.\n", + "- Content - The content of the section, which you will leave blank for now.\n", + "\n", + "Consider which sections require web research. For example, introduction and conclusion will not require research because they will distill information from other parts of the report.\"\"\"\n", + "\n", + "async def generate_report_plan(state: ReportState):\n", + "\n", + " # Inputs\n", + " topic = state[\"topic\"]\n", + " report_structure = state[\"report_structure\"]\n", + " number_of_queries = state[\"number_of_queries\"]\n", + " tavily_topic = state[\"tavily_topic\"]\n", + " tavily_days = state.get(\"tavily_days\", None)\n", + "\n", + " # Convert JSON object to string if necessary\n", + " if isinstance(report_structure, dict):\n", + " report_structure = str(report_structure)\n", + "\n", + " # Generate search query\n", + " structured_llm = llm.with_structured_output(Queries)\n", + "\n", + " # Format system instructions\n", + " system_instructions_query = report_planner_query_writer_instructions.format(topic=topic, report_organization=report_structure, number_of_queries=number_of_queries)\n", + "\n", + " # Generate queries \n", + " results = structured_llm.invoke([SystemMessage(content=system_instructions_query)]+[HumanMessage(content=\"Generate search queries that will help with planning the sections of the report.\")])\n", + "\n", + " # Web search\n", + " query_list = [query.search_query for query in results.queries]\n", + " search_docs = await tavily_search_async(query_list, tavily_topic, tavily_days)\n", + "\n", + " # Deduplicate and format sources\n", + " source_str = deduplicate_and_format_sources(search_docs, max_tokens_per_source=1000, include_raw_content=True)\n", + "\n", + " # Format system instructions\n", + " system_instructions_sections = report_planner_instructions.format(topic=topic, report_organization=report_structure, context=source_str)\n", + "\n", + " # Generate sections \n", + " structured_llm = llm.with_structured_output(Sections)\n", + " report_sections = structured_llm.invoke([SystemMessage(content=system_instructions_sections)]+[HumanMessage(content=\"Generate the sections of the report. Your response must include a 'sections' field containing a list of sections. Each section must have: name, description, plan, research, and content fields.\")])\n", + "\n", + " return {\"sections\": report_sections.sections}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Structure\n", + "report_structure = \"\"\"This report type focuses on comparative analysis.\n", + "\n", + "The report structure should include:\n", + "1. Introduction (no research needed)\n", + " - Brief overview of the topic area\n", + " - Context for the comparison\n", + "\n", + "2. Main Body Sections:\n", + " - One dedicated section for EACH offering being compared in the user-provided list\n", + " - Each section should examine:\n", + " - Core Features (bulleted list)\n", + " - Architecture & Implementation (2-3 sentences)\n", + " - One example use case (2-3 sentences)\n", + " \n", + "3. No Main Body Sections other than the ones dedicated to each offering in the user-provided list\n", + "\n", + "4. Conclusion with Comparison Table (no research needed)\n", + " - Structured comparison table that:\n", + " * Compares all offerings from the user-provided list across key dimensions\n", + " * Highlights relative strengths and weaknesses\n", + " - Final recommendations\"\"\"\n", + "\n", + "# Topic \n", + "report_topic = \"Give an overview of capabilities and specific use case examples for these AI Agent Frameworks: LangGraph, CrewAI.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================================\n", + "Name: Introduction\n", + "Description: Provide a brief overview of the topic area and context for the comparison of LangGraph and CrewAI AI Agent Frameworks.\n", + "Research: False\n", + "==================================================\n", + "Name: LangGraph\n", + "Description: Examine the core features, architecture and implementation, and provide an example use case for LangGraph.\n", + "Research: True\n", + "==================================================\n", + "Name: CrewAI\n", + "Description: Examine the core features, architecture and implementation, and provide an example use case for CrewAI.\n", + "Research: True\n", + "==================================================\n", + "Name: Conclusion with Comparison Table\n", + "Description: Present a structured comparison table highlighting the relative strengths and weaknesses of LangGraph and CrewAI, and provide final recommendations.\n", + "Research: False\n" + ] + } + ], + "source": [ + "# Tavily search parameters\n", + "tavily_topic = \"general\"\n", + "tavily_days = None # Only applicable for news topic\n", + "\n", + "# Generate report plan\n", + "sections = await generate_report_plan({\"topic\": report_topic, \"report_structure\": report_structure, \"number_of_queries\": 2, \"tavily_topic\": tavily_topic, \"tavily_days\": tavily_days})\n", + "\n", + "# Print sections\n", + "for section in sections['sections']:\n", + " print(f\"{'='*50}\")\n", + " print(f\"Name: {section.name}\")\n", + " print(f\"Description: {section.description}\")\n", + " print(f\"Research: {section.research}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Research + Writing\n", + "\n", + "### Test one section\n", + "\n", + "LangGraph state:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "class SectionState(TypedDict):\n", + " tavily_topic: Literal[\"general\", \"news\"] # Tavily search topic\n", + " tavily_days: Optional[int] # Only applicable for news topic\n", + " number_of_queries: int # Number web search queries to perform per section \n", + " section: Section # Report section \n", + " search_queries: list[SearchQuery] # List of search queries\n", + " source_str: str # String of formatted source content from web search\n", + " report_sections_from_research: str # String of any completed sections from research to write final sections\n", + " completed_sections: list[Section] # Final key we duplicate in outer state for Send() API\n", + "\n", + "class SectionOutputState(TypedDict):\n", + " completed_sections: list[Section] # Final key we duplicate in outer state for Send() API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Section writing:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Image, display\n", + "from langgraph.graph import START, END, StateGraph\n", + "\n", + "# Query writer instructions\n", + "query_writer_instructions=\"\"\"Your goal is to generate targeted web search queries that will gather comprehensive information for writing a technical report section.\n", + "\n", + "Topic for this section:\n", + "{section_topic}\n", + "\n", + "When generating {number_of_queries} search queries, ensure they:\n", + "1. Cover different aspects of the topic (e.g., core features, real-world applications, technical architecture)\n", + "2. Include specific technical terms related to the topic\n", + "3. Target recent information by including year markers where relevant (e.g., \"2024\")\n", + "4. Look for comparisons or differentiators from similar technologies/approaches\n", + "5. Search for both official documentation and practical implementation examples\n", + "\n", + "Your queries should be:\n", + "- Specific enough to avoid generic results\n", + "- Technical enough to capture detailed implementation information\n", + "- Diverse enough to cover all aspects of the section plan\n", + "- Focused on authoritative sources (documentation, technical blogs, academic papers)\"\"\"\n", + "\n", + "# Section writer instructions\n", + "section_writer_instructions = \"\"\"You are an expert technical writer crafting one section of a technical report.\n", + "\n", + "Topic for this section:\n", + "{section_topic}\n", + "\n", + "Guidelines for writing:\n", + "\n", + "1. Technical Accuracy:\n", + "- Include specific version numbers\n", + "- Reference concrete metrics/benchmarks\n", + "- Cite official documentation\n", + "- Use technical terminology precisely\n", + "\n", + "2. Length and Style:\n", + "- Strict 150-200 word limit\n", + "- No marketing language\n", + "- Technical focus\n", + "- Write in simple, clear language\n", + "- Start with your most important insight in **bold**\n", + "- Use short paragraphs (2-3 sentences max)\n", + "\n", + "3. Structure:\n", + "- Use ## for section title (Markdown format)\n", + "- Only use ONE structural element IF it helps clarify your point:\n", + " * Either a focused table comparing 2-3 key items (using Markdown table syntax)\n", + " * Or a short list (3-5 items) using proper Markdown list syntax:\n", + " - Use `*` or `-` for unordered lists\n", + " - Use `1.` for ordered lists\n", + " - Ensure proper indentation and spacing\n", + "- End with ### Sources that references the below source material formatted as:\n", + " * List each source with title, date, and URL\n", + " * Format: `- Title : URL`\n", + "\n", + "3. Writing Approach:\n", + "- Include at least one specific example or case study\n", + "- Use concrete details over general statements\n", + "- Make every word count\n", + "- No preamble prior to creating the section content\n", + "- Focus on your single most important point\n", + "\n", + "4. Use this source material to help write the section:\n", + "{context}\n", + "\n", + "5. Quality Checks:\n", + "- Exactly 150-200 words (excluding title and sources)\n", + "- Careful use of only ONE structural element (table or list) and only if it helps clarify your point\n", + "- One specific example / case study\n", + "- Starts with bold insight\n", + "- No preamble prior to creating the section content\n", + "- Sources cited at end\"\"\"\n", + "\n", + "def generate_queries(state: SectionState):\n", + " \"\"\" Generate search queries for a section \"\"\"\n", + "\n", + " # Get state \n", + " number_of_queries = state[\"number_of_queries\"]\n", + " section = state[\"section\"]\n", + "\n", + " # Generate queries \n", + " structured_llm = llm.with_structured_output(Queries)\n", + "\n", + " # Format system instructions\n", + " system_instructions = query_writer_instructions.format(section_topic=section.description, number_of_queries=number_of_queries)\n", + "\n", + " # Generate queries \n", + " queries = structured_llm.invoke([SystemMessage(content=system_instructions)]+[HumanMessage(content=\"Generate search queries on the provided topic.\")])\n", + "\n", + " return {\"search_queries\": queries.queries}\n", + "\n", + "async def search_web(state: SectionState):\n", + " \"\"\" Search the web for each query, then return a list of raw sources and a formatted string of sources.\"\"\"\n", + " \n", + " # Get state \n", + " search_queries = state[\"search_queries\"]\n", + " tavily_topic = state[\"tavily_topic\"]\n", + " tavily_days = state.get(\"tavily_days\", None)\n", + "\n", + " # Web search\n", + " query_list = [query.search_query for query in search_queries]\n", + " search_docs = await tavily_search_async(query_list, tavily_topic, tavily_days)\n", + "\n", + " # Deduplicate and format sources\n", + " source_str = deduplicate_and_format_sources(search_docs, max_tokens_per_source=5000, include_raw_content=True)\n", + "\n", + " return {\"source_str\": source_str}\n", + "\n", + "def write_section(state: SectionState):\n", + " \"\"\" Write a section of the report \"\"\"\n", + "\n", + " # Get state \n", + " section = state[\"section\"]\n", + " source_str = state[\"source_str\"]\n", + "\n", + " # Format system instructions\n", + " system_instructions = section_writer_instructions.format(section_title=section.name, section_topic=section.description, context=source_str)\n", + "\n", + " # Generate section \n", + " section_content = llm.invoke([SystemMessage(content=system_instructions)]+[HumanMessage(content=\"Generate a report section based on the provided sources.\")])\n", + " \n", + " # Write content to the section object \n", + " section.content = section_content.content\n", + "\n", + " # Write the updated section to completed sections\n", + " return {\"completed_sections\": [section]}\n", + "\n", + "# Add nodes and edges \n", + "section_builder = StateGraph(SectionState, output=SectionOutputState)\n", + "section_builder.add_node(\"generate_queries\", generate_queries)\n", + "section_builder.add_node(\"search_web\", search_web)\n", + "section_builder.add_node(\"write_section\", write_section)\n", + "\n", + "section_builder.add_edge(START, \"generate_queries\")\n", + "section_builder.add_edge(\"generate_queries\", \"search_web\")\n", + "section_builder.add_edge(\"search_web\", \"write_section\")\n", + "section_builder.add_edge(\"write_section\", END)\n", + "\n", + "# Compile\n", + "section_builder_graph = section_builder.compile()\n", + "\n", + "# View\n", + "display(Image(section_builder_graph.get_graph(xray=1).draw_mermaid_png()))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================================\n", + "Name: LangGraph Overview\n", + "Description: Detailed exploration of LangGraph, its core features, and how it enables the development of production-ready AI agents\n", + "Research: True\n" + ] + } + ], + "source": [ + "# Test with one section\n", + "sections = sections['sections'] \n", + "test_section = sections[1]\n", + "print(f\"{'='*50}\")\n", + "print(f\"Name: {test_section.name}\")\n", + "print(f\"Description: {test_section.description}\")\n", + "print(f\"Research: {test_section.research}\")\n", + "\n", + "# Run\n", + "report_section = await section_builder_graph.ainvoke({\"section\": test_section, \"number_of_queries\": 2, \"tavily_topic\": tavily_topic, \"tavily_days\": tavily_days})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Markdown\n", + "section = report_section['completed_sections'][0]\n", + "Markdown(section.content)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### All sections" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "class ReportStateOutput(TypedDict):\n", + " final_report: str # Final report" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from langgraph.constants import Send\n", + "\n", + "final_section_writer_instructions=\"\"\"You are an expert technical writer crafting a section that synthesizes information from the rest of the report.\n", + "\n", + "Section to write: \n", + "{section_topic}\n", + "\n", + "Available report content:\n", + "{context}\n", + "\n", + "1. Section-Specific Approach:\n", + "\n", + "For Introduction:\n", + "- Use # for report title (Markdown format)\n", + "- 50-100 word limit\n", + "- Write in simple and clear language\n", + "- Focus on the core motivation for the report in 1-2 paragraphs\n", + "- Use a clear narrative arc to introduce the report\n", + "- Include NO structural elements (no lists or tables)\n", + "- No sources section needed\n", + "\n", + "For Conclusion/Summary:\n", + "- Use ## for section title (Markdown format)\n", + "- 100-150 word limit\n", + "- For comparative reports:\n", + " * Must include a focused comparison table using Markdown table syntax\n", + " * Table should distill insights from the report\n", + " * Keep table entries clear and concise\n", + "- For non-comparative reports: \n", + " * Only use ONE structural element IF it helps distill the points made in the report:\n", + " * Either a focused table comparing items present in the report (using Markdown table syntax)\n", + " * Or a short list using proper Markdown list syntax:\n", + " - Use `*` or `-` for unordered lists\n", + " - Use `1.` for ordered lists\n", + " - Ensure proper indentation and spacing\n", + "- End with specific next steps or implications\n", + "- No sources section needed\n", + "\n", + "3. Writing Approach:\n", + "- Use concrete details over general statements\n", + "- Make every word count\n", + "- Focus on your single most important point\n", + "\n", + "4. Quality Checks:\n", + "- For introduction: 50-100 word limit, # for report title, no structural elements, no sources section\n", + "- For conclusion: 100-150 word limit, ## for section title, only ONE structural element at most, no sources section\n", + "- Markdown format\n", + "- Do not include word count or any preamble in your response\"\"\"\n", + "\n", + "def initiate_section_writing(state: ReportState):\n", + " \"\"\" This is the \"map\" step when we kick off web research for some sections of the report \"\"\" \n", + " \n", + " # Kick off section writing in parallel via Send() API for any sections that require research\n", + " return [\n", + " Send(\"build_section_with_web_research\", {\"section\": s, \n", + " \"number_of_queries\": state[\"number_of_queries\"], \n", + " \"tavily_topic\": state[\"tavily_topic\"], \n", + " \"tavily_days\": state.get(\"tavily_days\", None)}) \n", + " for s in state[\"sections\"] \n", + " if s.research\n", + " ]\n", + "\n", + "def write_final_sections(state: SectionState):\n", + " \"\"\" Write final sections of the report, which do not require web search and use the completed sections as context \"\"\"\n", + "\n", + " # Get state \n", + " section = state[\"section\"]\n", + " completed_report_sections = state[\"report_sections_from_research\"]\n", + " \n", + " # Format system instructions\n", + " system_instructions = final_section_writer_instructions.format(section_title=section.name, section_topic=section.description, context=completed_report_sections)\n", + "\n", + " # Generate section \n", + " section_content = llm.invoke([SystemMessage(content=system_instructions)]+[HumanMessage(content=\"Generate a report section based on the provided sources.\")])\n", + " \n", + " # Write content to section \n", + " section.content = section_content.content\n", + "\n", + " # Write the updated section to completed sections\n", + " return {\"completed_sections\": [section]}\n", + "\n", + "def gather_completed_sections(state: ReportState):\n", + " \"\"\" Gather completed sections from research \"\"\" \n", + "\n", + " # List of completed sections\n", + " completed_sections = state[\"completed_sections\"]\n", + "\n", + " # Format completed section to str to use as context for final sections\n", + " completed_report_sections = format_sections(completed_sections)\n", + "\n", + " return {\"report_sections_from_research\": completed_report_sections}\n", + "\n", + "def initiate_final_section_writing(state: ReportState):\n", + " \"\"\" This is the \"map\" step when we kick off research on any sections that require it using the Send API \"\"\" \n", + "\n", + " # Kick off section writing in parallel via Send() API for any sections that do not require research\n", + " return [\n", + " Send(\"write_final_sections\", {\"section\": s, \"report_sections_from_research\": state[\"report_sections_from_research\"]}) \n", + " for s in state[\"sections\"] \n", + " if not s.research\n", + " ]\n", + "\n", + "def compile_final_report(state: ReportState):\n", + " \"\"\" Compile the final report \"\"\" \n", + "\n", + " # Get sections\n", + " sections = state[\"sections\"]\n", + " completed_sections = {s.name: s.content for s in state[\"completed_sections\"]}\n", + "\n", + " # Update sections with completed content while maintaining original order\n", + " for section in sections:\n", + " section.content = completed_sections[section.name]\n", + "\n", + " # Compile final report\n", + " all_sections = \"\\n\\n\".join([s.content for s in sections])\n", + "\n", + " return {\"final_report\": all_sections}\n", + "\n", + "# Add nodes and edges \n", + "builder = StateGraph(ReportState, output=ReportStateOutput)\n", + "builder.add_node(\"generate_report_plan\", generate_report_plan)\n", + "builder.add_node(\"build_section_with_web_research\", section_builder.compile())\n", + "builder.add_node(\"gather_completed_sections\", gather_completed_sections)\n", + "builder.add_node(\"write_final_sections\", write_final_sections)\n", + "builder.add_node(\"compile_final_report\", compile_final_report)\n", + "builder.add_edge(START, \"generate_report_plan\")\n", + "builder.add_conditional_edges(\"generate_report_plan\", initiate_section_writing, [\"build_section_with_web_research\"])\n", + "builder.add_edge(\"build_section_with_web_research\", \"gather_completed_sections\")\n", + "builder.add_conditional_edges(\"gather_completed_sections\", initiate_final_section_writing, [\"write_final_sections\"])\n", + "builder.add_edge(\"write_final_sections\", \"compile_final_report\")\n", + "builder.add_edge(\"compile_final_report\", END)\n", + "\n", + "graph = builder.compile()\n", + "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Structure\n", + "report_structure = \"\"\"This report type focuses on comparative analysis.\n", + "\n", + "The report structure should include:\n", + "1. Introduction (no research needed)\n", + " - Brief overview of the topic area\n", + " - Context for the comparison\n", + "\n", + "2. Main Body Sections:\n", + " - One dedicated section for EACH offering being compared in the user-provided list\n", + " - Each section should examine:\n", + " - Core Features (bulleted list)\n", + " - Architecture & Implementation (2-3 sentences)\n", + " - One example use case (2-3 sentences)\n", + " \n", + "3. No Main Body Sections other than the ones dedicated to each offering in the user-provided list\n", + "\n", + "4. Conclusion with Comparison Table (no research needed)\n", + " - Structured comparison table that:\n", + " * Compares all offerings from the user-provided list across key dimensions\n", + " * Highlights relative strengths and weaknesses\n", + " - Final recommendations\"\"\"\n", + "\n", + "# Topic \n", + "report_topic = \"Give an overview of capabilities and specific use case examples for these AI Agent Frameworks: LangGraph, CrewAI.\"\n", + "\n", + "# Tavily search parameters\n", + "tavily_topic = \"general\"\n", + "tavily_days = None # Only applicable for news topic" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "ename": "Exception", + "evalue": "[500] Internal Server Error\nInternal error while making inference request", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[25], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m report \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m graph\u001b[38;5;241m.\u001b[39mainvoke({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtopic\u001b[39m\u001b[38;5;124m\"\u001b[39m: report_topic, \n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreport_structure\u001b[39m\u001b[38;5;124m\"\u001b[39m: report_structure, \n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnumber_of_queries\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m2\u001b[39m, \n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtavily_topic\u001b[39m\u001b[38;5;124m\"\u001b[39m: tavily_topic, \n\u001b[1;32m 5\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtavily_days\u001b[39m\u001b[38;5;124m\"\u001b[39m: tavily_days})\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/__init__.py:1982\u001b[0m, in \u001b[0;36mPregel.ainvoke\u001b[0;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, **kwargs)\u001b[0m\n\u001b[1;32m 1980\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1981\u001b[0m chunks \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m-> 1982\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mfor\u001b[39;00m chunk \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mastream(\n\u001b[1;32m 1983\u001b[0m \u001b[38;5;28minput\u001b[39m,\n\u001b[1;32m 1984\u001b[0m config,\n\u001b[1;32m 1985\u001b[0m stream_mode\u001b[38;5;241m=\u001b[39mstream_mode,\n\u001b[1;32m 1986\u001b[0m output_keys\u001b[38;5;241m=\u001b[39moutput_keys,\n\u001b[1;32m 1987\u001b[0m interrupt_before\u001b[38;5;241m=\u001b[39minterrupt_before,\n\u001b[1;32m 1988\u001b[0m interrupt_after\u001b[38;5;241m=\u001b[39minterrupt_after,\n\u001b[1;32m 1989\u001b[0m debug\u001b[38;5;241m=\u001b[39mdebug,\n\u001b[1;32m 1990\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 1991\u001b[0m ):\n\u001b[1;32m 1992\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m stream_mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalues\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 1993\u001b[0m latest \u001b[38;5;241m=\u001b[39m chunk\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/__init__.py:1867\u001b[0m, in \u001b[0;36mPregel.astream\u001b[0;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, subgraphs)\u001b[0m\n\u001b[1;32m 1861\u001b[0m \u001b[38;5;66;03m# Similarly to Bulk Synchronous Parallel / Pregel model\u001b[39;00m\n\u001b[1;32m 1862\u001b[0m \u001b[38;5;66;03m# computation proceeds in steps, while there are channel updates\u001b[39;00m\n\u001b[1;32m 1863\u001b[0m \u001b[38;5;66;03m# channel updates from step N are only visible in step N+1\u001b[39;00m\n\u001b[1;32m 1864\u001b[0m \u001b[38;5;66;03m# channels are guaranteed to be immutable for the duration of the step,\u001b[39;00m\n\u001b[1;32m 1865\u001b[0m \u001b[38;5;66;03m# with channel updates applied only at the transition between steps\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m loop\u001b[38;5;241m.\u001b[39mtick(input_keys\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_channels):\n\u001b[0;32m-> 1867\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m runner\u001b[38;5;241m.\u001b[39matick(\n\u001b[1;32m 1868\u001b[0m loop\u001b[38;5;241m.\u001b[39mtasks\u001b[38;5;241m.\u001b[39mvalues(),\n\u001b[1;32m 1869\u001b[0m timeout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstep_timeout,\n\u001b[1;32m 1870\u001b[0m retry_policy\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mretry_policy,\n\u001b[1;32m 1871\u001b[0m get_waiter\u001b[38;5;241m=\u001b[39mget_waiter,\n\u001b[1;32m 1872\u001b[0m ):\n\u001b[1;32m 1873\u001b[0m \u001b[38;5;66;03m# emit output\u001b[39;00m\n\u001b[1;32m 1874\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m output():\n\u001b[1;32m 1875\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m o\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/runner.py:288\u001b[0m, in \u001b[0;36mPregelRunner.atick\u001b[0;34m(self, tasks, reraise, timeout, retry_policy, get_waiter)\u001b[0m\n\u001b[1;32m 286\u001b[0m fut\u001b[38;5;241m.\u001b[39mcancel()\n\u001b[1;32m 287\u001b[0m \u001b[38;5;66;03m# panic on failure or timeout\u001b[39;00m\n\u001b[0;32m--> 288\u001b[0m \u001b[43m_panic_or_proceed\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 289\u001b[0m \u001b[43m \u001b[49m\u001b[43mdone_futures\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munion\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mfutures\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 290\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout_exc_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43masyncio\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTimeoutError\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 291\u001b[0m \u001b[43m \u001b[49m\u001b[43mpanic\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreraise\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 292\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/runner.py:370\u001b[0m, in \u001b[0;36m_panic_or_proceed\u001b[0;34m(futs, timeout_exc_cls, panic)\u001b[0m\n\u001b[1;32m 368\u001b[0m \u001b[38;5;66;03m# raise the exception\u001b[39;00m\n\u001b[1;32m 369\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m panic:\n\u001b[0;32m--> 370\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[1;32m 371\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 372\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/retry.py:138\u001b[0m, in \u001b[0;36marun_with_retry\u001b[0;34m(task, retry_policy, stream, writer)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 138\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m task\u001b[38;5;241m.\u001b[39mproc\u001b[38;5;241m.\u001b[39mainvoke(task\u001b[38;5;241m.\u001b[39minput, config)\n\u001b[1;32m 139\u001b[0m \u001b[38;5;66;03m# if successful, end\u001b[39;00m\n\u001b[1;32m 140\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/utils/runnable.py:453\u001b[0m, in \u001b[0;36mRunnableSeq.ainvoke\u001b[0;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[1;32m 451\u001b[0m coro \u001b[38;5;241m=\u001b[39m step\u001b[38;5;241m.\u001b[39mainvoke(\u001b[38;5;28minput\u001b[39m, config)\n\u001b[1;32m 452\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ASYNCIO_ACCEPTS_CONTEXT:\n\u001b[0;32m--> 453\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mcreate_task(coro, context\u001b[38;5;241m=\u001b[39mcontext)\n\u001b[1;32m 454\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 455\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mcreate_task(coro)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/__init__.py:1982\u001b[0m, in \u001b[0;36mPregel.ainvoke\u001b[0;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, **kwargs)\u001b[0m\n\u001b[1;32m 1980\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1981\u001b[0m chunks \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m-> 1982\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mfor\u001b[39;00m chunk \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mastream(\n\u001b[1;32m 1983\u001b[0m \u001b[38;5;28minput\u001b[39m,\n\u001b[1;32m 1984\u001b[0m config,\n\u001b[1;32m 1985\u001b[0m stream_mode\u001b[38;5;241m=\u001b[39mstream_mode,\n\u001b[1;32m 1986\u001b[0m output_keys\u001b[38;5;241m=\u001b[39moutput_keys,\n\u001b[1;32m 1987\u001b[0m interrupt_before\u001b[38;5;241m=\u001b[39minterrupt_before,\n\u001b[1;32m 1988\u001b[0m interrupt_after\u001b[38;5;241m=\u001b[39minterrupt_after,\n\u001b[1;32m 1989\u001b[0m debug\u001b[38;5;241m=\u001b[39mdebug,\n\u001b[1;32m 1990\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 1991\u001b[0m ):\n\u001b[1;32m 1992\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m stream_mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalues\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 1993\u001b[0m latest \u001b[38;5;241m=\u001b[39m chunk\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/__init__.py:1867\u001b[0m, in \u001b[0;36mPregel.astream\u001b[0;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, subgraphs)\u001b[0m\n\u001b[1;32m 1861\u001b[0m \u001b[38;5;66;03m# Similarly to Bulk Synchronous Parallel / Pregel model\u001b[39;00m\n\u001b[1;32m 1862\u001b[0m \u001b[38;5;66;03m# computation proceeds in steps, while there are channel updates\u001b[39;00m\n\u001b[1;32m 1863\u001b[0m \u001b[38;5;66;03m# channel updates from step N are only visible in step N+1\u001b[39;00m\n\u001b[1;32m 1864\u001b[0m \u001b[38;5;66;03m# channels are guaranteed to be immutable for the duration of the step,\u001b[39;00m\n\u001b[1;32m 1865\u001b[0m \u001b[38;5;66;03m# with channel updates applied only at the transition between steps\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m loop\u001b[38;5;241m.\u001b[39mtick(input_keys\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_channels):\n\u001b[0;32m-> 1867\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m runner\u001b[38;5;241m.\u001b[39matick(\n\u001b[1;32m 1868\u001b[0m loop\u001b[38;5;241m.\u001b[39mtasks\u001b[38;5;241m.\u001b[39mvalues(),\n\u001b[1;32m 1869\u001b[0m timeout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstep_timeout,\n\u001b[1;32m 1870\u001b[0m retry_policy\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mretry_policy,\n\u001b[1;32m 1871\u001b[0m get_waiter\u001b[38;5;241m=\u001b[39mget_waiter,\n\u001b[1;32m 1872\u001b[0m ):\n\u001b[1;32m 1873\u001b[0m \u001b[38;5;66;03m# emit output\u001b[39;00m\n\u001b[1;32m 1874\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m output():\n\u001b[1;32m 1875\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m o\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/runner.py:222\u001b[0m, in \u001b[0;36mPregelRunner.atick\u001b[0;34m(self, tasks, reraise, timeout, retry_policy, get_waiter)\u001b[0m\n\u001b[1;32m 220\u001b[0m t \u001b[38;5;241m=\u001b[39m tasks[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 221\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 222\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m arun_with_retry(\n\u001b[1;32m 223\u001b[0m t, retry_policy, stream\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39muse_astream, writer\u001b[38;5;241m=\u001b[39mwriter\n\u001b[1;32m 224\u001b[0m )\n\u001b[1;32m 225\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommit(t, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 226\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/pregel/retry.py:138\u001b[0m, in \u001b[0;36marun_with_retry\u001b[0;34m(task, retry_policy, stream, writer)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 138\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m task\u001b[38;5;241m.\u001b[39mproc\u001b[38;5;241m.\u001b[39mainvoke(task\u001b[38;5;241m.\u001b[39minput, config)\n\u001b[1;32m 139\u001b[0m \u001b[38;5;66;03m# if successful, end\u001b[39;00m\n\u001b[1;32m 140\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/utils/runnable.py:453\u001b[0m, in \u001b[0;36mRunnableSeq.ainvoke\u001b[0;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[1;32m 451\u001b[0m coro \u001b[38;5;241m=\u001b[39m step\u001b[38;5;241m.\u001b[39mainvoke(\u001b[38;5;28minput\u001b[39m, config)\n\u001b[1;32m 452\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ASYNCIO_ACCEPTS_CONTEXT:\n\u001b[0;32m--> 453\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mcreate_task(coro, context\u001b[38;5;241m=\u001b[39mcontext)\n\u001b[1;32m 454\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 455\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mcreate_task(coro)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langgraph/utils/runnable.py:236\u001b[0m, in \u001b[0;36mRunnableCallable.ainvoke\u001b[0;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[1;32m 234\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ASYNCIO_ACCEPTS_CONTEXT:\n\u001b[1;32m 235\u001b[0m coro \u001b[38;5;241m=\u001b[39m cast(Coroutine[\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m, Any], \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mafunc(\u001b[38;5;28minput\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs))\n\u001b[0;32m--> 236\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mcreate_task(coro, context\u001b[38;5;241m=\u001b[39mcontext)\n\u001b[1;32m 237\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 238\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mafunc(\u001b[38;5;28minput\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/runnables/config.py:588\u001b[0m, in \u001b[0;36mrun_in_executor\u001b[0;34m(executor_or_config, func, *args, **kwargs)\u001b[0m\n\u001b[1;32m 584\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mexc\u001b[39;00m\n\u001b[1;32m 586\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m executor_or_config \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(executor_or_config, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 587\u001b[0m \u001b[38;5;66;03m# Use default executor with context copied from current context\u001b[39;00m\n\u001b[0;32m--> 588\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mget_running_loop()\u001b[38;5;241m.\u001b[39mrun_in_executor(\n\u001b[1;32m 589\u001b[0m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 590\u001b[0m cast(Callable[\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m, T], partial(copy_context()\u001b[38;5;241m.\u001b[39mrun, wrapper)),\n\u001b[1;32m 591\u001b[0m )\n\u001b[1;32m 593\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mget_running_loop()\u001b[38;5;241m.\u001b[39mrun_in_executor(executor_or_config, wrapper)\n", + "File \u001b[0;32m/opt/homebrew/Cellar/python@3.13/3.13.0_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/concurrent/futures/thread.py:58\u001b[0m, in \u001b[0;36m_WorkItem.run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[1;32m 57\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 58\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mBaseException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfuture\u001b[38;5;241m.\u001b[39mset_exception(exc)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/runnables/config.py:579\u001b[0m, in \u001b[0;36mrun_in_executor..wrapper\u001b[0;34m()\u001b[0m\n\u001b[1;32m 577\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m() \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[1;32m 578\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 579\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 580\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[1;32m 581\u001b[0m \u001b[38;5;66;03m# StopIteration can't be set on an asyncio.Future\u001b[39;00m\n\u001b[1;32m 582\u001b[0m \u001b[38;5;66;03m# it raises a TypeError and leaves the Future pending forever\u001b[39;00m\n\u001b[1;32m 583\u001b[0m \u001b[38;5;66;03m# so we need to convert it to a RuntimeError\u001b[39;00m\n\u001b[1;32m 584\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mexc\u001b[39;00m\n", + "Cell \u001b[0;32mIn[19], line 89\u001b[0m, in \u001b[0;36mgenerate_queries\u001b[0;34m(state)\u001b[0m\n\u001b[1;32m 86\u001b[0m system_instructions \u001b[38;5;241m=\u001b[39m query_writer_instructions\u001b[38;5;241m.\u001b[39mformat(section_topic\u001b[38;5;241m=\u001b[39msection\u001b[38;5;241m.\u001b[39mdescription, number_of_queries\u001b[38;5;241m=\u001b[39mnumber_of_queries)\n\u001b[1;32m 88\u001b[0m \u001b[38;5;66;03m# Generate queries \u001b[39;00m\n\u001b[0;32m---> 89\u001b[0m queries \u001b[38;5;241m=\u001b[39m \u001b[43mstructured_llm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mSystemMessage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcontent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msystem_instructions\u001b[49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mHumanMessage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcontent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mGenerate search queries on the provided topic.\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msearch_queries\u001b[39m\u001b[38;5;124m\"\u001b[39m: queries\u001b[38;5;241m.\u001b[39mqueries}\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/runnables/base.py:3022\u001b[0m, in \u001b[0;36mRunnableSequence.invoke\u001b[0;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[1;32m 3020\u001b[0m context\u001b[38;5;241m.\u001b[39mrun(_set_config_context, config)\n\u001b[1;32m 3021\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m-> 3022\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mcontext\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3023\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 3024\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m context\u001b[38;5;241m.\u001b[39mrun(step\u001b[38;5;241m.\u001b[39minvoke, \u001b[38;5;28minput\u001b[39m, config)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/runnables/base.py:5354\u001b[0m, in \u001b[0;36mRunnableBindingBase.invoke\u001b[0;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[1;32m 5348\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minvoke\u001b[39m(\n\u001b[1;32m 5349\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 5350\u001b[0m \u001b[38;5;28minput\u001b[39m: Input,\n\u001b[1;32m 5351\u001b[0m config: Optional[RunnableConfig] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 5352\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Optional[Any],\n\u001b[1;32m 5353\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Output:\n\u001b[0;32m-> 5354\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbound\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 5355\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5356\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_merge_configs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5357\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5358\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/language_models/chat_models.py:286\u001b[0m, in \u001b[0;36mBaseChatModel.invoke\u001b[0;34m(self, input, config, stop, **kwargs)\u001b[0m\n\u001b[1;32m 275\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minvoke\u001b[39m(\n\u001b[1;32m 276\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 277\u001b[0m \u001b[38;5;28minput\u001b[39m: LanguageModelInput,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any,\n\u001b[1;32m 282\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m BaseMessage:\n\u001b[1;32m 283\u001b[0m config \u001b[38;5;241m=\u001b[39m ensure_config(config)\n\u001b[1;32m 284\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(\n\u001b[1;32m 285\u001b[0m ChatGeneration,\n\u001b[0;32m--> 286\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_prompt\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 287\u001b[0m \u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_convert_input\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 288\u001b[0m \u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 289\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcallbacks\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 290\u001b[0m \u001b[43m \u001b[49m\u001b[43mtags\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtags\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 291\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmetadata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 292\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrun_name\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpop\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrun_id\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 294\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mgenerations[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m],\n\u001b[1;32m 296\u001b[0m )\u001b[38;5;241m.\u001b[39mmessage\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/language_models/chat_models.py:786\u001b[0m, in \u001b[0;36mBaseChatModel.generate_prompt\u001b[0;34m(self, prompts, stop, callbacks, **kwargs)\u001b[0m\n\u001b[1;32m 778\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mgenerate_prompt\u001b[39m(\n\u001b[1;32m 779\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 780\u001b[0m prompts: \u001b[38;5;28mlist\u001b[39m[PromptValue],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 783\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any,\n\u001b[1;32m 784\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m LLMResult:\n\u001b[1;32m 785\u001b[0m prompt_messages \u001b[38;5;241m=\u001b[39m [p\u001b[38;5;241m.\u001b[39mto_messages() \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m prompts]\n\u001b[0;32m--> 786\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprompt_messages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/language_models/chat_models.py:643\u001b[0m, in \u001b[0;36mBaseChatModel.generate\u001b[0;34m(self, messages, stop, callbacks, tags, metadata, run_name, run_id, **kwargs)\u001b[0m\n\u001b[1;32m 641\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m run_managers:\n\u001b[1;32m 642\u001b[0m run_managers[i]\u001b[38;5;241m.\u001b[39mon_llm_error(e, response\u001b[38;5;241m=\u001b[39mLLMResult(generations\u001b[38;5;241m=\u001b[39m[]))\n\u001b[0;32m--> 643\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\n\u001b[1;32m 644\u001b[0m flattened_outputs \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 645\u001b[0m LLMResult(generations\u001b[38;5;241m=\u001b[39m[res\u001b[38;5;241m.\u001b[39mgenerations], llm_output\u001b[38;5;241m=\u001b[39mres\u001b[38;5;241m.\u001b[39mllm_output) \u001b[38;5;66;03m# type: ignore[list-item]\u001b[39;00m\n\u001b[1;32m 646\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m res \u001b[38;5;129;01min\u001b[39;00m results\n\u001b[1;32m 647\u001b[0m ]\n\u001b[1;32m 648\u001b[0m llm_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_combine_llm_outputs([res\u001b[38;5;241m.\u001b[39mllm_output \u001b[38;5;28;01mfor\u001b[39;00m res \u001b[38;5;129;01min\u001b[39;00m results])\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/language_models/chat_models.py:633\u001b[0m, in \u001b[0;36mBaseChatModel.generate\u001b[0;34m(self, messages, stop, callbacks, tags, metadata, run_name, run_id, **kwargs)\u001b[0m\n\u001b[1;32m 630\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(messages):\n\u001b[1;32m 631\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 632\u001b[0m results\u001b[38;5;241m.\u001b[39mappend(\n\u001b[0;32m--> 633\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate_with_cache\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 634\u001b[0m \u001b[43m \u001b[49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 635\u001b[0m \u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 636\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_managers\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrun_managers\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 637\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 638\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 639\u001b[0m )\n\u001b[1;32m 640\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mBaseException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 641\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m run_managers:\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_core/language_models/chat_models.py:851\u001b[0m, in \u001b[0;36mBaseChatModel._generate_with_cache\u001b[0;34m(self, messages, stop, run_manager, **kwargs)\u001b[0m\n\u001b[1;32m 849\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 850\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m inspect\u001b[38;5;241m.\u001b[39msignature(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_generate)\u001b[38;5;241m.\u001b[39mparameters\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_manager\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 851\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 852\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrun_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_manager\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 853\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 854\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 855\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_generate(messages, stop\u001b[38;5;241m=\u001b[39mstop, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:382\u001b[0m, in \u001b[0;36mChatNVIDIA._generate\u001b[0;34m(self, messages, stop, run_manager, **kwargs)\u001b[0m\n\u001b[1;32m 380\u001b[0m inputs, extra_headers \u001b[38;5;241m=\u001b[39m _process_for_vlm(inputs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_client\u001b[38;5;241m.\u001b[39mmodel)\n\u001b[1;32m 381\u001b[0m payload \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_payload(inputs\u001b[38;5;241m=\u001b[39minputs, stop\u001b[38;5;241m=\u001b[39mstop, stream\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 382\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_client\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_req\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpayload\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpayload\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_headers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_headers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 383\u001b[0m responses, _ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_client\u001b[38;5;241m.\u001b[39mpostprocess(response)\n\u001b[1;32m 384\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_callback_out(responses, run_manager)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/_common.py:473\u001b[0m, in \u001b[0;36m_NVIDIAClient.get_req\u001b[0;34m(self, payload, extra_headers)\u001b[0m\n\u001b[1;32m 467\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_req\u001b[39m(\n\u001b[1;32m 468\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 469\u001b[0m payload: \u001b[38;5;28mdict\u001b[39m \u001b[38;5;241m=\u001b[39m {},\n\u001b[1;32m 470\u001b[0m extra_headers: \u001b[38;5;28mdict\u001b[39m \u001b[38;5;241m=\u001b[39m {},\n\u001b[1;32m 471\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Response:\n\u001b[1;32m 472\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Post to the API.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 473\u001b[0m response, session \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_post\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 474\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minfer_url\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpayload\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_headers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_headers\u001b[49m\n\u001b[1;32m 475\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 476\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_wait(response, session)\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/_common.py:369\u001b[0m, in \u001b[0;36m_NVIDIAClient._post\u001b[0;34m(self, invoke_url, payload, extra_headers)\u001b[0m\n\u001b[1;32m 365\u001b[0m session \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_session_fn()\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlast_response \u001b[38;5;241m=\u001b[39m response \u001b[38;5;241m=\u001b[39m session\u001b[38;5;241m.\u001b[39mpost(\n\u001b[1;32m 367\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__add_authorization(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlast_inputs)\n\u001b[1;32m 368\u001b[0m )\n\u001b[0;32m--> 369\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_try_raise\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresponse\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 370\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response, session\n", + "File \u001b[0;32m~/Desktop/Code/report_mAIstro/report_maistro/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/_common.py:462\u001b[0m, in \u001b[0;36m_NVIDIAClient._try_raise\u001b[0;34m(self, response)\u001b[0m\n\u001b[1;32m 460\u001b[0m body \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mPlease check or regenerate your API key.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 461\u001b[0m \u001b[38;5;66;03m# todo: raise as an HTTPError\u001b[39;00m\n\u001b[0;32m--> 462\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mheader\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;132;01m{\u001b[39;00mbody\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[0;31mException\u001b[0m: [500] Internal Server Error\nInternal error while making inference request", + "\u001b[0mDuring task with name 'generate_queries' and id '8e2cab54-f602-ac4c-d0d3-5ebdb431ab72'", + "\u001b[0mDuring task with name 'build_section_with_web_research' and id '3d4a8728-5ad0-c39a-2078-6e5199f9994c'" + ] + } + ], + "source": [ + "report = await graph.ainvoke({\"topic\": report_topic, \n", + " \"report_structure\": report_structure, \n", + " \"number_of_queries\": 2, \n", + " \"tavily_topic\": tavily_topic, \n", + " \"tavily_days\": tavily_days})" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "# AI Agent Frameworks: Enabling Complex Workflows and Collaboration\n", + "\n", + "AI agent frameworks are revolutionizing the development of advanced artificial intelligence applications. These frameworks provide structured approaches for creating multi-agent systems, enabling AI components to work together on complex tasks. By offering different paradigms for agent interaction and workflow management, frameworks like LangGraph, CrewAI, OpenAI Swarm, and LlamaIndex Workflows are empowering developers to build more sophisticated, flexible, and efficient AI solutions. These tools are critical in addressing the growing demand for AI systems capable of handling intricate, multi-step processes and collaborative problem-solving scenarios in various domains.\n", + "\n", + "## LangGraph: Enabling Complex AI Workflows\n", + "\n", + "**LangGraph's graph-based architecture enables more flexible and controllable AI agent workflows compared to linear frameworks.** Unlike LangChain's sequential chains, LangGraph represents tasks as interconnected nodes in a graph, allowing for non-linear execution paths, cycles, and complex branching logic. This structure is ideal for building multi-agent systems where different AI agents collaborate on tasks.\n", + "\n", + "LangGraph's key components include:\n", + "- Nodes: Represent individual tasks or agents\n", + "- Edges: Define information flow between nodes\n", + "- State: Tracks the current status as data moves through the graph\n", + "- Conditional logic: Controls workflow progression\n", + "\n", + "A notable use case is GPT-Newspaper, which leverages LangGraph to coordinate six specialized AI agents in creating personalized news content. The graph structure enables a writer-critique feedback loop, improving output quality.\n", + "\n", + "LangGraph also excels at error handling, allowing failed tasks to be retried or rerouted without restarting the entire workflow. This granular control makes LangGraph well-suited for complex enterprise applications requiring sophisticated decision-making, parallel processing, and human-in-the-loop interactions.\n", + "\n", + "### Sources\n", + "- LangGraph: Multi-Agent Workflows - LangChain Blog : https://blog.langchain.dev/langgraph-multi-agent-workflows/\n", + "- LangGraph - LangChain : https://www.langchain.com/langgraph\n", + "- LangGraph and Research Agents | Pinecone : https://www.pinecone.io/learn/langgraph/\n", + "\n", + "## CrewAI: Orchestrating AI Agent Collaboration\n", + "\n", + "**CrewAI enables structured teamwork between AI agents, enhancing efficiency in complex tasks.** This open-source framework assigns specialized roles to agents, allowing them to work together like a well-coordinated crew. CrewAI's design emphasizes production-readiness and reliability over flexibility, making it ideal for real-world applications.\n", + "\n", + "Key features include:\n", + "\n", + "- Role-based agents with defined expertise\n", + "- Sequential task orchestration (with plans for consensual and hierarchical strategies)\n", + "- Seamless integration with LangChain for expanded tooling\n", + "\n", + "A practical example demonstrates CrewAI's capabilities in stock analysis:\n", + "\n", + "1. Researcher agent gathers market data\n", + "2. Writer agent crafts analysis report\n", + "\n", + "This approach streamlines complex workflows by breaking them into manageable pieces, with each agent contributing its unique skills.\n", + "\n", + "CrewAI's focus on structured collaboration sets it apart from frameworks like AutoGen, which offer more flexibility but potentially less predictability. For developers already familiar with LangChain, CrewAI provides an accessible entry point into multi-agent systems.\n", + "\n", + "While powerful, CrewAI can be resource-intensive. In testing, a simple two-agent interaction consumed $0.18 in API costs, highlighting the need for efficient design in production environments.\n", + "\n", + "### Sources\n", + "- Understanding CrewAI: A Deep Dive into Multi-Agent AI Systems : https://medium.com/accredian/understanding-crewai-a-deep-dive-into-multi-agent-ai-systems-110d04703454\n", + "- CrewAI: Unlocking Collaborative Intelligence in AI Systems : https://insights.codegpt.co/crewai-guide\n", + "- Introduction - CrewAI : https://docs.crewai.com/introduction\n", + "- AutoGen Vs CrewAI: A Comprehensive Comparison Of Multi-Agent AI Frameworks : https://dataguy.in/autogen-vs-crewai-multi-agent-ai-framework-comparison/\n", + "- I Tested AI Agents Team Using the CrewAI Framework : https://medium.com/timurai/i-tested-ai-agents-team-using-the-crewai-framework-cf02912b84b1\n", + "\n", + "## OpenAI Swarm: A Framework for Multi-Agent Collaboration\n", + "\n", + "**OpenAI Swarm introduces a lightweight, experimental approach to building multi-agent AI systems.** The framework enables developers to create specialized agents that can seamlessly coordinate and hand off tasks. At its core, Swarm utilizes two key concepts: routines, which define an agent's instructions and capabilities, and handoffs, allowing agents to transfer control to others as needed.\n", + "\n", + "A practical example of Swarm in action is an airline customer support system. Multiple agents, including a Triage Agent, Flight Modification Agent, and Lost Baggage Agent, work together to handle diverse customer inquiries. The system routes requests through the Triage Agent, which then transfers control to specialized agents based on the nature of the query.\n", + "\n", + "Swarm's design emphasizes simplicity and transparency, with stateless architecture and direct Python function calls for tool implementation. This approach offers developers fine-grained control over agent behaviors without the overhead of maintaining persistent states. While Swarm is primarily intended for educational purposes, it provides valuable insights into the fundamentals of multi-agent systems and points towards future developments in collaborative AI architectures.\n", + "\n", + "### Sources\n", + "- OpenAI Releases Swarm: An Experimental AI Framework for Multi-Agent Systems : https://medium.com/cool-devs/openai-releases-swarm-an-experimental-ai-framework-for-multi-agent-systems-2e2d9372f839\n", + "- Swarm: OpenAI's Experimental Approach to Multi-Agent Systems - Arize AI : https://arize.com/blog/swarm-openai-experimental-approach-to-multi-agent-systems/\n", + "\n", + "## LlamaIndex Workflows: Streamlining Complex AI Processes\n", + "\n", + "**LlamaIndex Workflows provide an event-driven abstraction for chaining together multiple AI processes, offering greater flexibility than traditional DAG-based approaches.** This framework allows developers to create sophisticated AI applications by defining steps as Python functions decorated with @step. Each step handles specific event types and can emit new events, enabling dynamic and adaptive processing.\n", + "\n", + "A key advantage is the ability to implement self-correction mechanisms and loops, which are challenging in acyclic graph models. For example, a workflow could include a step that evaluates the quality of an AI-generated response and triggers a refinement process if needed.\n", + "\n", + "LlamaIndex Workflows excel in:\n", + "\n", + "- Multi-stage prompt chaining\n", + "- Conditional retrieval based on user input\n", + "- Building conversational agents with reinforcement learning\n", + "\n", + "The framework also offers built-in instrumentation for observability, allowing developers to monitor each step's performance using tools like Arize Phoenix. This feature is particularly valuable for debugging complex AI pipelines and optimizing system performance in production environments.\n", + "\n", + "### Sources\n", + "- Introducing workflows beta: a new way to create complex AI applications with LlamaIndex : https://www.llamaindex.ai/blog/introducing-workflows-beta\n", + "- Understanding LlamaIndex Workflows: Streamlining Complex ... - Medium: https://medium.com/@pankaj_pandey/understanding-llamaindex-workflows-streamlining-complex-processes-easily-ba4c0809a704\n", + "\n", + "## Summary and Recommendations\n", + "\n", + "LangGraph, CrewAI, OpenAI Swarm, and LlamaIndex Workflows each offer unique approaches to multi-agent AI systems. LangGraph's graph-based architecture excels in complex, non-linear workflows, while CrewAI focuses on structured, role-based collaboration. OpenAI Swarm provides a lightweight, experimental framework ideal for educational purposes, and LlamaIndex Workflows offers event-driven flexibility with built-in observability.\n", + "\n", + "| Framework | Key Strength | Best Use Case |\n", + "|-----------|--------------|----------------|\n", + "| LangGraph | Complex, non-linear workflows | Enterprise applications requiring sophisticated decision-making |\n", + "| CrewAI | Structured, role-based collaboration | Production-ready systems with defined agent roles |\n", + "| OpenAI Swarm | Simplicity and transparency | Educational projects and prototyping |\n", + "| LlamaIndex Workflows | Event-driven flexibility | Applications requiring adaptive processing and self-correction |\n", + "\n", + "For enterprise-level applications with complex decision trees, LangGraph is recommended. CrewAI is ideal for production systems with clearly defined agent roles. Developers exploring multi-agent concepts should consider OpenAI Swarm, while those needing adaptive workflows with strong observability should opt for LlamaIndex Workflows." + ], + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Markdown\n", + "Markdown(report['final_report'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 532, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 508, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}