From cf1c18f3d289c197b8a2bdc6dd0191c14e677c9d Mon Sep 17 00:00:00 2001 From: kirtisodhi Date: Wed, 5 Nov 2025 10:39:00 -0500 Subject: [PATCH 1/4] add agentic rag notebook --- .../agent_rag_news_assistant.ipynb | 807 ++++++++++++++++++ 1 file changed, 807 insertions(+) create mode 100644 supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb diff --git a/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb new file mode 100644 index 00000000..906e1133 --- /dev/null +++ b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb @@ -0,0 +1,807 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2b4b1e0f08209f34", + "metadata": {}, + "source": [ + "### Prerequisites:\n", + "\n", + "This AgenticRAG example uses GPT-4.1 via AzureChatOpenAI, which requires certain environment variables to be configured.\n", + "You can substitute any other LLM if preferred.\n", + "\n", + "Create a .env file in the same directory as your project and define the following variables:\n", + "- AZURE_OPENAI_ENDPOINT\n", + "- AZURE_OPENAI_KEY\n", + "- AZURE_OPENAI_DEPLOYMENT\n", + "- AZURE_OPENAI_API_VERSION\n", + "\n", + "You'll also need to set Elasticsearch environment variables as `ES_URL`, `ES_USERNAME` and `ES_PASSWORD` to set up connection with Elasticsearch vectorstore" + ] + }, + { + "cell_type": "code", + "id": "bce7dd63093dd6e0", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:50:06.920121Z", + "start_time": "2025-10-29T13:50:06.914925Z" + } + }, + "source": [ + "import os\n", + "import time\n", + "\n", + "from langchain_core.prompts import ChatPromptTemplate\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "from langchain_core.runnables import RunnableSequence\n", + "from langchain_openai import AzureChatOpenAI\n", + "from langchain.chains import LLMChain, SequentialChain\n", + "from datasets import load_dataset\n", + "from langchain.schema import Document\n", + "from langchain_elasticsearch import ElasticsearchStore, SparseVectorStrategy\n", + "from dotenv import load_dotenv\n", + "from langchain_community.tools import DuckDuckGoSearchRun\n", + "from langgraph.graph import StateGraph, END, START\n", + "from typing import TypedDict, List, Literal\n", + "from loguru import logger\n", + "from pydantic import BaseModel, Field\n", + "from elasticsearch import Elasticsearch, NotFoundError, BadRequestError\n", + "from elasticsearch.exceptions import AuthenticationException\n", + "from IPython.display import Image\n", + "\n", + "load_dotenv()" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 23 + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f10b7273007fe477", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-27T16:07:42.075072Z", + "start_time": "2025-10-27T16:07:42.073032Z" + } + }, + "outputs": [], + "source": [ + "#!pip3 install langchain langgraph langchain-openai langchain-elasticsearch langchain-community datasets python-dotenv loguru elasticsearch \"pydantic>=2.0\"" + ] + }, + { + "cell_type": "markdown", + "id": "9223ae18-d05e-4aa1-9bce-456deae748bc", + "metadata": {}, + "source": [ + "### Install ELSER" + ] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:50:35.509786Z", + "start_time": "2025-10-29T13:50:35.506054Z" + } + }, + "cell_type": "code", + "source": [ + "def get_elastic_credentials():\n", + " try:\n", + " es_url = os.environ[\"ES_URL\"]\n", + " except KeyError:\n", + " raise Exception(\n", + " \"Environment variable ES_URL (Elasticsearch URL) is not set. Please set it.\"\n", + " )\n", + " try:\n", + " es_username = os.environ[\"ES_USERNAME\"]\n", + " except KeyError:\n", + " raise Exception(\n", + " \"Environment variable ES_USERNAME (Elasticsearch username) is not set. Please set it.\"\n", + " )\n", + " try:\n", + " es_password = os.environ[\"ES_PASSWORD\"]\n", + " except KeyError:\n", + " raise Exception(\n", + " \"Environment variable ES_PASSWORD (Elasticsearch password) is not set. Please set it.\"\n", + " )\n", + " return es_url, es_username, es_password\n", + "\n", + "def get_elastic_client(es_url: str, username: str, password: str):\n", + " try:\n", + " es_args = {\n", + " \"hosts\": [es_url],\n", + " \"basic_auth\": (username, password),\n", + " \"request_timeout\": 100,\n", + " \"max_retries\": 3,\n", + " \"retry_on_timeout\": True,\n", + " }\n", + "\n", + " client = Elasticsearch(**es_args)\n", + " return client\n", + " except AuthenticationException as ae:\n", + " raise Exception(\n", + " f\"Elasticsearch connection failed due to authentication error: {ae}. Please check your Elasticsearch URL and credentials\"\n", + " )\n", + " except Exception as e:\n", + " raise Exception(f\"Elasticsearch connection failed: {e}.\")" + ], + "id": "f663626a3628b8a7", + "outputs": [], + "execution_count": 26 + }, + { + "cell_type": "code", + "id": "7f722ca314787202", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:50:39.064431Z", + "start_time": "2025-10-29T13:50:39.057548Z" + } + }, + "source": [ + "url, username, password = get_elastic_credentials()\n", + "es=get_elastic_client(url, username, password)" + ], + "outputs": [], + "execution_count": 27 + }, + { + "cell_type": "code", + "id": "4533e737a820eac", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:47:24.858738Z", + "start_time": "2025-10-29T13:47:24.854346Z" + } + }, + "source": [ + "def install_elser(es: Elasticsearch, model_id: str):\n", + " try:\n", + " es.ml.get_trained_models(model_id=model_id)\n", + " except NotFoundError:\n", + " logger.info(f'\"{model_id}\" not found. Installing...')\n", + " es.ml.put_trained_model(model_id=model_id, input={\"field_names\": [\"text_field\"]})\n", + "\n", + " while True:\n", + " status = es.ml.get_trained_models(model_id=model_id, include=\"definition_status\")\n", + " if status[\"trained_model_configs\"][0][\"fully_defined\"]:\n", + " break\n", + " time.sleep(1)\n", + "\n", + " stats = es.ml.get_trained_models_stats(model_id=model_id)\n", + " allocation_state = stats[\"trained_model_stats\"][0].get(\"deployment_stats\", {}).get(\"allocation_status\", {}).get(\"state\")\n", + " if allocation_state != \"fully_allocated\":\n", + " try:\n", + " es.ml.start_trained_model_deployment(model_id=model_id, wait_for=\"fully_allocated\")\n", + " except BadRequestError:\n", + " pass\n", + "\n", + " logger.info(f'\"{model_id}\" model is ready')" + ], + "outputs": [], + "execution_count": 15 + }, + { + "cell_type": "code", + "id": "e008bd7c76211926", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-28T13:41:24.525016Z", + "start_time": "2025-10-28T13:41:06.443289Z" + } + }, + "source": [ + "install_elser(es, \".elser_model_2\")" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001B[32m2025-10-28 09:41:24.521\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36minstall_elser\u001B[0m:\u001B[36m22\u001B[0m - \u001B[1m\".elser_model_2\" model is ready\u001B[0m\n" + ] + } + ], + "execution_count": 8 + }, + { + "cell_type": "markdown", + "id": "5b249dda2266361c", + "metadata": {}, + "source": [ + "### Define your LLM" + ] + }, + { + "cell_type": "code", + "id": "b2978186bbc9b333", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:47:29.579297Z", + "start_time": "2025-10-29T13:47:29.422893Z" + } + }, + "source": [ + "llm = AzureChatOpenAI(\n", + " azure_deployment=os.environ.get('AZURE_OPENAI_DEPLOYMENT'),\n", + " azure_endpoint=os.environ.get('AZURE_OPENAI_ENDPOINT'),\n", + " api_version=os.environ.get('AZURE_OPENAI_API_VERSION'),\n", + " api_key=os.environ.get('AZURE_OPENAI_KEY')\n", + ")" + ], + "outputs": [], + "execution_count": 16 + }, + { + "cell_type": "markdown", + "id": "941ea7193b81b224", + "metadata": {}, + "source": [ + "#### Load AG news dataset" + ] + }, + { + "cell_type": "code", + "id": "2d1526b3a04fdae", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:47:32.948724Z", + "start_time": "2025-10-29T13:47:31.451833Z" + } + }, + "source": [ + "dataset = load_dataset(\"ag_news\", split=\"train[:1000]\")\n", + "docs = [\n", + " Document(\n", + " page_content=sample[\"text\"],\n", + " metadata={\"category\": sample[\"label\"]}\n", + " )\n", + " for sample in dataset\n", + " ]\n" + ], + "outputs": [], + "execution_count": 17 + }, + { + "cell_type": "markdown", + "id": "c83d573c1e63a5c7", + "metadata": {}, + "source": [ + "#### Add documents to Elasticsearch vector store" + ] + }, + { + "cell_type": "code", + "id": "d78b4e82ff95374d", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T14:27:18.437609Z", + "start_time": "2025-10-29T14:27:10.616426Z" + } + }, + "source": [ + "index_name=\"news_docs\"\n", + "elastic_vectorstore = ElasticsearchStore.from_documents(\n", + " docs,\n", + " es_url=os.environ[\"ES_URL\"],\n", + " es_user=os.environ[\"ES_USERNAME\"],\n", + " es_password=os.environ[\"ES_PASSWORD\"],\n", + " index_name=index_name,\n", + " strategy=SparseVectorStrategy(model_id=\".elser_model_2\"),\n", + ")\n", + "\n", + "elastic_vectorstore.client.indices.refresh(index=index_name)" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "ObjectApiResponse({'_shards': {'total': 2, 'successful': 2, 'failed': 0}})" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 28 + }, + { + "cell_type": "markdown", + "id": "3d3e09d4ad4a3cf4", + "metadata": {}, + "source": [ + "### Define your data retrieval options" + ] + }, + { + "cell_type": "code", + "id": "da8d9fe9f790020d", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:48:13.512923Z", + "start_time": "2025-10-29T13:48:13.473286Z" + } + }, + "source": [ + "def vectorstore_retriever(query, k=5):\n", + " results = elastic_vectorstore.similarity_search_with_score(query, k=k)\n", + " docs = [doc for doc, score in results]\n", + " related_docs = \"\\n\".join([d.page_content for d in docs])\n", + " return related_docs\n", + "\n", + "duckduckgo = DuckDuckGoSearchRun(description= \"A custom DuckDuckGo search tool for finding latest news stories.\", verbose=True)\n", + "def websearch_retriever(query):\n", + " results = duckduckgo.run(f\"{query}\")\n", + " return results\n", + "\n", + "def hybrid_retriever(query):\n", + " related_docs = vectorstore_retriever(query)\n", + " related_docs += websearch_retriever(query)\n", + " return related_docs" + ], + "outputs": [], + "execution_count": 19 + }, + { + "cell_type": "markdown", + "id": "8bb186748e2c93af", + "metadata": {}, + "source": [ + "### Define your LLM Chains" + ] + }, + { + "cell_type": "code", + "id": "d232c7529e549b8a", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:48:16.522270Z", + "start_time": "2025-10-29T13:48:16.512865Z" + } + }, + "source": [ + "class RouteQuery(BaseModel):\n", + " datasource: Literal[\"vectorstore\", \"websearch\", \"hybrid\"] = Field(\n", + " ...,\n", + " description=\"Choose to route the query to web search, vectorstore or hybrid.\"\n", + " )\n", + "\n", + "router_prompt = ChatPromptTemplate.from_template(\"\"\"You are an assistant that decides the best data source for news articles based questions.\n", + "\n", + "Choose one of the following options:\n", + "- 'vectorstore': for general, background, or historical news articles.\n", + "- 'websearch': for recent discoveries, 'latest', 'current', or '2025' type queries.\n", + "- 'hybrid': when the question needs both historical and current knowledge on news articles.\n", + "\n", + "Question: {query}\n", + "\n", + "Return one word: 'vectorstore', 'websearch', or 'hybrid'.\n", + "\"\"\")\n", + "router_structured = llm.with_structured_output(RouteQuery)\n", + "router_chain: RunnableSequence = router_prompt | router_structured\n", + "\n", + "class GradeRetrievedDocs(BaseModel):\n", + " binary_score: bool = Field(\n", + " description=\"True if retrieved documents match the query intent, False otherwise.\"\n", + " )\n", + "\n", + "grade_retrieved_docs_prompt = ChatPromptTemplate.from_template(\"\"\"\n", + "You are an evaluator that determines whether the retrieved documents are relevant to the given user query.\n", + "\n", + "Instructions:\n", + "- Compare the intent and information need of the query against the retrieved documents.\n", + "- Answer only 'True' or 'False'.\n", + "- 'True' means the retrieved documents align with the query’s intent and can likely answer it.\n", + "- 'False' means the retrieved documents do not address the main topic or intent of the query.\n", + "\n", + "Return only one word: 'True' or 'False'.\n", + "\n", + "Query:\n", + "{query}\n", + "\n", + "Retrieved Documents:\n", + "{docs}\n", + "\"\"\")\n", + "\n", + "retrieved_docs_structured = llm.with_structured_output(GradeRetrievedDocs)\n", + "grade_docs_chain: RunnableSequence = grade_retrieved_docs_prompt | retrieved_docs_structured\n", + "\n", + "class RewrittenQuery(BaseModel):\n", + " query: str\n", + "\n", + "rewrite_query_prompt = ChatPromptTemplate.from_template(\"\"\"\n", + "The grader returned that the retrieved documents do not answer the query. Reformulate the query to better capture the user's intent and retrieve relevant information. Return ONLY the rewritten query, concise and clear. Just the string i.e. the rewritten query.\n", + "\n", + "Original Query:\n", + "{query}\n", + "\"\"\")\n", + "rewritten_query_structured = llm.with_structured_output(RewrittenQuery)\n", + "rewrite_query_chain: RunnableSequence = rewrite_query_prompt | rewritten_query_structured\n", + "\n", + "summarize_prompt = ChatPromptTemplate.from_template( \"\"\"You are a helpful news assistant. Your task is to summarize the retrieved news articles in a concise and accurate way that directly answers the user's query.\n", + "User Query:\n", + "{query}\n", + "\n", + "Retrieved Articles:\n", + "{docs}\n", + "\n", + "Instructions:\n", + "- Focus on the most relevant information that answers the query.\n", + "- Do not include unrelated details.\n", + "- Present the summary in clear, coherent sentences.\n", + "- If multiple articles provide overlapping information, combine them without repetition.\n", + "\n", + "Summary:\"\"\"\n", + ")\n", + "summarize_chain = LLMChain(llm=llm, prompt=summarize_prompt, output_parser=StrOutputParser())\n" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/mb/g20y910n51gdd16_2c0vflr00000gn/T/ipykernel_19273/691602315.py:74: LangChainDeprecationWarning: The class `LLMChain` was deprecated in LangChain 0.1.17 and will be removed in 1.0. Use :meth:`~RunnableSequence, e.g., `prompt | llm`` instead.\n", + " summarize_chain = LLMChain(llm=llm, prompt=summarize_prompt, output_parser=StrOutputParser())\n" + ] + } + ], + "execution_count": 20 + }, + { + "cell_type": "markdown", + "id": "4cfeb8887f95122d", + "metadata": {}, + "source": [ + "### Start building the StateGraph" + ] + }, + { + "cell_type": "code", + "id": "9db64c1fe48f0f0", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:48:21.116359Z", + "start_time": "2025-10-29T13:48:21.111527Z" + } + }, + "source": [ + "class RAGState(TypedDict):\n", + " query: str\n", + " docs: List[Document]\n", + " router: str\n", + " summary: str\n", + " self_reflection: bool\n", + " retry_count: int = 0\n", + "\n", + "def router(state: RAGState):\n", + " router = router_chain.invoke({'query': state[\"query\"]})\n", + " logger.info(f\"Router selected the datasource: {router.datasource}\")\n", + " logger.info(f\"User query: {state['query']}\")\n", + " return {\"router\": router.datasource}\n", + "\n", + "def vectorstore(state: RAGState):\n", + " return {\"docs\": vectorstore_retriever(state[\"query\"])}\n", + "\n", + "def websearch(state: RAGState):\n", + " return {\"docs\": websearch_retriever(state[\"query\"])}\n", + "\n", + "def hybrid(state: RAGState):\n", + " return {\"docs\": hybrid_retriever(state[\"query\"])}\n", + "\n", + "def self_reflection(state: RAGState):\n", + " evaluation = grade_docs_chain.invoke(\n", + " {\"query\": state[\"query\"], \"docs\": state[\"docs\"]}\n", + " )\n", + " if evaluation.binary_score:\n", + " logger.info(f\"Self-reflection passed — binary_score={evaluation.binary_score}\")\n", + " else:\n", + " logger.info(f\"Self-reflection failed — binary_score={evaluation.binary_score}\")\n", + "\n", + " return {\n", + " \"self_reflection\": evaluation.binary_score,\n", + " }\n", + "\n", + "def query_rewriter(state: RAGState):\n", + " retry_count = state.get(\"retry_count\", 0) + 1\n", + " new_query = rewrite_query_chain.invoke({\"query\": state[\"query\"]})\n", + " logger.info(f\"Query rewritten: {new_query}, retry_count: {retry_count}\")\n", + " return {\n", + " \"query\": new_query,\n", + " \"retry_count\": retry_count,\n", + " }\n", + "\n", + "def summarize(state: RAGState):\n", + " summary = summarize_chain.run(\n", + " query=state[\"query\"],\n", + " docs=state[\"docs\"],\n", + " )\n", + " return {\"summary\": summary}" + ], + "outputs": [], + "execution_count": 21 + }, + { + "cell_type": "markdown", + "id": "5b4d7a4121b7593b", + "metadata": {}, + "source": [ + "### Build Graph with LangChain" + ] + }, + { + "cell_type": "code", + "id": "16c2b13c6e782184", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-29T13:48:26.005534Z", + "start_time": "2025-10-29T13:48:25.828175Z" + } + }, + "source": [ + "graph = StateGraph(RAGState)\n", + "\n", + "graph.add_node(\"router\", router)\n", + "graph.add_node(\"vectorstore\", vectorstore)\n", + "graph.add_node(\"websearch\", websearch)\n", + "graph.add_node(\"hybrid\", hybrid)\n", + "graph.add_node(\"self_reflection\", self_reflection)\n", + "graph.add_node(\"query_rewriter\", query_rewriter)\n", + "graph.add_node(\"summarize\", summarize)\n", + "\n", + "graph.add_edge(START, \"router\")\n", + "\n", + "def after_router(state: RAGState):\n", + " route = state.get(\"router\", None)\n", + " if route == \"vectorstore\":\n", + " return \"vectorstore\"\n", + " elif route == \"websearch\":\n", + " return \"websearch\"\n", + " else:\n", + " return \"hybrid\"\n", + "\n", + "def after_self_reflection(state: RAGState):\n", + " if state[\"self_reflection\"]:\n", + " return \"summarize\"\n", + " return \"query_rewriter\"\n", + "\n", + "def after_query_rewriter(state: RAGState):\n", + " while state['retry_count'] <= 3:\n", + " return \"router\"\n", + " raise RuntimeError(\"Maximum retries (3) reached — evaluation failed.\")\n", + "\n", + "graph.add_conditional_edges(\n", + " \"router\",\n", + " after_router,\n", + " {\n", + " \"vectorstore\": \"vectorstore\",\n", + " \"websearch\": \"websearch\",\n", + " \"hybrid\": \"hybrid\"\n", + " }\n", + ")\n", + "\n", + "graph.add_edge(\"vectorstore\", \"self_reflection\")\n", + "graph.add_edge(\"websearch\", \"self_reflection\")\n", + "graph.add_edge(\"hybrid\", \"self_reflection\")\n", + "graph.add_conditional_edges(\n", + " \"self_reflection\",\n", + " after_self_reflection,\n", + " {\n", + " \"summarize\": \"summarize\",\n", + " \"query_rewriter\": \"query_rewriter\"\n", + " }\n", + ")\n", + "graph.add_conditional_edges(\"query_rewriter\", after_query_rewriter, {\"router\": \"router\"})\n", + "graph.add_edge(\"summarize\", END)\n", + "agent=graph.compile()\n", + "agent.get_graph().draw_mermaid_png(output_file_path='graph.png')\n", + "Image('graph.png')" + ], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 22 + }, + { + "cell_type": "markdown", + "id": "4c64b15457ddd328", + "metadata": {}, + "source": [ + "### Start testing" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5c787b2428e926ca", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-26T02:10:17.312233Z", + "start_time": "2025-10-26T02:10:17.309859Z" + } + }, + "outputs": [], + "source": [ + "query1=\"What are the latest AI models released this month?\"\n", + "query2=\"What technological innovations are discussed in Sci/Tech news?\"\n", + "query3=\"Compare a Sci/Tech article from the dataset with a current web article about AI trends.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "3c48705d7c0d237c", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-26T02:13:17.180661Z", + "start_time": "2025-10-26T02:13:13.737383Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001B[32m2025-10-27 12:21:40.530\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: websearch\u001B[0m\n", + "\u001B[32m2025-10-27 12:21:40.532\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: What are the latest AI models released this month?\u001B[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001B[32;1m\u001B[1;3mMarch 31, 2025 - It also gives users control over how long the model can think for, per Anthropic. Sonnet 3.7 is available to all Claude users, but heavier users will need a $20-per-month Pro plan. Grok 3 is the latest flagship model from Elon Musk-founded startup ... October 30, 2024 - What's particularly noteworthy is that the Llama 3.1 -Nemotron-70B-Instruct model has shown outstanding results in automatic benchmarks, outperforming even some of the most advanced models in the field, including Claude 3.5 Sonnet and GPT-4. ... March 26, 2025 - Grok 3: DeepSearch can significantly enhance developers’ ability to conduct research, find relevant resources, and stay informed about the latest advancements in their field. The upcoming release of the Grok 3 API will further empower developers ... September 10, 2025 - We had an AI Mode in Search expansion, ... round out the month — including a new image editing release in the Gemini app (Nano Banana) and Google DeepMind’s first real-time interactive general-purpose world AI model, Genie 3. We’ve made ... July 2, 2025 - We released Imagen 4 for developers in the Gemini API and Google AI Studio. Imagen 4 , our best text-to-image model yet, is now available for paid preview in the Gemini API and for limited free testing in Google AI Studio.\u001B[0m" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001B[32m2025-10-27 12:21:41.999\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m31\u001B[0m - \u001B[1mSelf-reflection failed — binary_score=False\u001B[0m\n", + "\u001B[32m2025-10-27 12:21:42.626\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mquery_rewriter\u001B[0m:\u001B[36m40\u001B[0m - \u001B[1mQuery rewritten: query='Which AI models have been launched or published in June 2024?', retry_count: 1\u001B[0m\n", + "\u001B[32m2025-10-27 12:21:43.194\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: websearch\u001B[0m\n", + "\u001B[32m2025-10-27 12:21:43.195\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: query='Which AI models have been launched or published in June 2024?'\u001B[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001B[32;1m\u001B[1;3mJul 2, 2024 · Discover the top AI news of June 2024 , including Apple Intelligence Figma's AI feature controversy, Runway's Gen-3 Alpha launch , and more. Jun 26, 2024 · Today, we delve into the latest rankings of AI models , highlighting the most powerful generative language models as of June 2024 . Jun 4, 2025 · We saw the release of a range of platform models , from Claude 4 by Anthropic, to Google’s Veo 3, a model that generates synchronized audio and video content. In the open source ecosystem, Mistral released the Devstral model, and Alibaba released the Qwen3 series of models . Feb 28, 2025 · With new AI models launched in the market in 2025 and 2024 , it can be overwhelming to keep track of them all. We have compiled a listed guide to the newest and most advanced AI models , what they do, and how to use them. Our public database, the largest of its kind, tracks over 3100 machine learning models from 1950 to today. Explore data and graphs showing the trajectory of AI .\u001B[0m" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001B[32m2025-10-27 12:21:45.407\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", + "\u001B[32m2025-10-27 12:21:46.972\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", + "Final Summary:\n", + ": In June 2024, several notable AI models were launched or published, including Runway's Gen-3 Alpha, Anthropic's Claude 4, Google's Veo 3 (which generates synchronized audio and video), Mistral's open-source Devstral model, and Alibaba's Qwen3 series.\u001B[0m\n" + ] + } + ], + "source": [ + "result = agent.invoke({\"query\": query1})\n", + "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "a63de923-ca7b-42fb-9a80-7f261cb92d74", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001B[32m2025-10-27 12:22:25.073\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: vectorstore\u001B[0m\n", + "\u001B[32m2025-10-27 12:22:25.075\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: What technological innovations are discussed in Sci/Tech news?\u001B[0m\n", + "/Users/kirtisodhi/agentic-rag/path/to/venv/lib/python3.13/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", + " hits = self._store.search(\n", + "\u001B[32m2025-10-27 12:22:25.998\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", + "\u001B[32m2025-10-27 12:22:27.416\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", + "Final Summary:\n", + ": Recent Sci/Tech news highlights several technological innovations: NASA is collaborating with Silicon Valley firms to build a powerful Linux-based supercomputer for theoretical research and shuttle engineering; Genetic Savings & Clone has developed chromatin transfer technology to clone cats; Princeton scientists report that existing technologies could immediately help stabilize global warming; and a set of micro-games for GameBoy was recognized for its innovation at a gaming festival. Additionally, cybersecurity advances are featured in The Washington Post's special report.\u001B[0m\n" + ] + } + ], + "source": [ + "result = agent.invoke({\"query\": query2})\n", + "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "24c342fa-8220-42b6-adf3-b48fcd164104", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001B[32m2025-10-27 12:22:37.566\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: hybrid\u001B[0m\n", + "\u001B[32m2025-10-27 12:22:37.568\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: Compare a Sci/Tech article from the dataset with a current web article about AI trends.\u001B[0m\n", + "/Users/kirtisodhi/agentic-rag/path/to/venv/lib/python3.13/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", + " hits = self._store.search(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001B[32;1m\u001B[1;3m19 hours ago - In the late 2010s, graphics processing ... large-scale (commercial and academic) machine learning models' training. Specialized programming languages such as Prolog were used in early AI research, but general-purpose programming languages like Python have become predominant. The transistor density in integrated circuits has been observed to roughly double every 18 months—a trend known as Moore's ... Mar 4, 2025 · This article aims to equip readers with a deep understanding of AI ’ s current state and future trajectory, providing actionable insights and practical advice to navigate this transformative era. 3 weeks ago - North America, which includes the U.S. and Canada, is the market leader . In 2023, it captured 38.9% of the global AI market, which was about $97.25 billion in revenue. ... China has a much higher active adoption rate. March 12, 2025 - This article is a collaborative effort by Alex Singla, Alexander Sukharevsky, Lareina Yee, and Michael Chui, with Bryce Hall, representing views from QuantumBlack, AI by McKinsey. Our survey analyses show that a CEO’s oversight of AI governance—that is, the policies, processes, and technology necessary to develop and deploy AI systems responsibly—is one element most correlated with higher self-reported bottom-line impact from an organization’s gen AI use.1The correlation analyses considered 25 attributes and the reported effect of gen AI use on organizations’ EBIT, and using the Johnson’s Relative Weights regression analysis yielded an R-squared of 0.20. May 1, 2025 - Models with advanced reasoning capabilities, like OpenAI o1, can already solve complex problems with logical steps that are similar to how humans think before responding to difficult questions. These capabilities will continue to be useful in fields like science, coding, math, law and medicine, allowing models to compare contracts, generate code and execute multistep workflows.\u001B[0m" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001B[32m2025-10-27 12:22:39.279\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", + "\u001B[32m2025-10-27 12:22:41.650\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", + "Final Summary:\n", + ": A Sci/Tech article from the dataset highlights how NASA is developing advanced artificial intelligence (AI) software for planetary rovers, enabling them to become more autonomous and make critical decisions during missions. In comparison, a current web article about AI trends discusses the rapid evolution of AI technologies, such as large-scale models with advanced reasoning capabilities (like OpenAI o1), the widespread adoption of AI in various sectors, and the importance of responsible AI governance in organizations to maximize business impact. Both articles emphasize the increasing sophistication and self-reliance of AI systems, but while the NASA article focuses on specialized applications for space exploration, the current web article covers broader AI trends, advancements in reasoning, market growth, and practical impacts across industries.\u001B[0m\n" + ] + } + ], + "source": [ + "result = agent.invoke({\"query\": query3})\n", + "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e291cc77-e511-42cf-8386-90646dd2ad69", + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 12cc7f4ea9c36ff9da0da37eca01fddb0fd82e33 Mon Sep 17 00:00:00 2001 From: kirtisodhi Date: Thu, 6 Nov 2025 11:44:54 -0500 Subject: [PATCH 2/4] format with black --- .../agent_rag_news_assistant.ipynb | 510 +++++++++--------- 1 file changed, 251 insertions(+), 259 deletions(-) diff --git a/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb index 906e1133..6445d5fe 100644 --- a/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb +++ b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb @@ -1,36 +1,54 @@ { "cells": [ { + "metadata": {}, "cell_type": "markdown", - "id": "2b4b1e0f08209f34", + "source": "This notebook demonstrates a simple Agentic RAG workflow that uses Elasticsearch as the vector store and LangChain for orchestration. It accompanies the article \"Developing Adaptive Retrieval Workflows Using Elasticsearch and LangChain\" and showcases the core ideas discussed there. For a deeper explanation, please refer to the article.", + "id": "6652455987a6d84d" + }, + { "metadata": {}, + "cell_type": "markdown", "source": [ "### Prerequisites:\n", "\n", "This AgenticRAG example uses GPT-4.1 via AzureChatOpenAI, which requires certain environment variables to be configured.\n", "You can substitute any other LLM if preferred.\n", "\n", - "Create a .env file in the same directory as your project and define the following variables:\n", + "You will be asked to set up the following environment variables:\n", "- AZURE_OPENAI_ENDPOINT\n", "- AZURE_OPENAI_KEY\n", "- AZURE_OPENAI_DEPLOYMENT\n", "- AZURE_OPENAI_API_VERSION\n", - "\n", - "You'll also need to set Elasticsearch environment variables as `ES_URL`, `ES_USERNAME` and `ES_PASSWORD` to set up connection with Elasticsearch vectorstore" - ] + "- ES_ENDPOINT\n", + "- ES_API_KEY" + ], + "id": "50dbf3b98f86609d" }, { "cell_type": "code", - "id": "bce7dd63093dd6e0", + "execution_count": 4, + "id": "f10b7273007fe477", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-27T16:07:42.075072Z", + "start_time": "2025-10-27T16:07:42.073032Z" + } + }, + "outputs": [], + "source": "!pip3 install langchain langgraph langchain-openai langchain-elasticsearch langchain-community datasets python-dotenv loguru elasticsearch \"pydantic>=2.0\" duckduckgo-search" + }, + { "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:50:06.920121Z", - "start_time": "2025-10-29T13:50:06.914925Z" + "end_time": "2025-11-06T16:31:43.953367Z", + "start_time": "2025-11-06T16:31:43.949856Z" } }, + "cell_type": "code", "source": [ - "import os\n", "import time\n", + "import getpass\n", "\n", "from langchain_core.prompts import ChatPromptTemplate\n", "from langchain_core.output_parsers import StrOutputParser\n", @@ -40,131 +58,88 @@ "from datasets import load_dataset\n", "from langchain.schema import Document\n", "from langchain_elasticsearch import ElasticsearchStore, SparseVectorStrategy\n", - "from dotenv import load_dotenv\n", "from langchain_community.tools import DuckDuckGoSearchRun\n", "from langgraph.graph import StateGraph, END, START\n", "from typing import TypedDict, List, Literal\n", "from loguru import logger\n", "from pydantic import BaseModel, Field\n", "from elasticsearch import Elasticsearch, NotFoundError, BadRequestError\n", - "from elasticsearch.exceptions import AuthenticationException\n", - "from IPython.display import Image\n", - "\n", - "load_dotenv()" + "from IPython.display import Image" ], - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 23 + "id": "4965bea2b7d42736", + "outputs": [], + "execution_count": 64 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Set the environment variables", + "id": "ae94daa7a83a719c" }, { - "cell_type": "code", - "execution_count": 4, - "id": "f10b7273007fe477", "metadata": { "ExecuteTime": { - "end_time": "2025-10-27T16:07:42.075072Z", - "start_time": "2025-10-27T16:07:42.073032Z" + "end_time": "2025-11-06T15:00:47.680922Z", + "start_time": "2025-11-06T14:58:07.539524Z" } }, - "outputs": [], - "source": [ - "#!pip3 install langchain langgraph langchain-openai langchain-elasticsearch langchain-community datasets python-dotenv loguru elasticsearch \"pydantic>=2.0\"" - ] - }, - { - "cell_type": "markdown", - "id": "9223ae18-d05e-4aa1-9bce-456deae748bc", - "metadata": {}, + "cell_type": "code", "source": [ - "### Install ELSER" - ] + "ES_ENDPOINT = getpass.getpass(\"Enter Elastic Endpoint: \")\n", + "ES_API_KEY = getpass.getpass(\"Enter Elastic API Key: \")" + ], + "id": "c7f50e08aa8339fc", + "outputs": [], + "execution_count": 32 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:50:35.509786Z", - "start_time": "2025-10-29T13:50:35.506054Z" + "end_time": "2025-11-06T15:03:01.414459Z", + "start_time": "2025-11-06T15:02:35.251370Z" } }, "cell_type": "code", "source": [ - "def get_elastic_credentials():\n", - " try:\n", - " es_url = os.environ[\"ES_URL\"]\n", - " except KeyError:\n", - " raise Exception(\n", - " \"Environment variable ES_URL (Elasticsearch URL) is not set. Please set it.\"\n", - " )\n", - " try:\n", - " es_username = os.environ[\"ES_USERNAME\"]\n", - " except KeyError:\n", - " raise Exception(\n", - " \"Environment variable ES_USERNAME (Elasticsearch username) is not set. Please set it.\"\n", - " )\n", - " try:\n", - " es_password = os.environ[\"ES_PASSWORD\"]\n", - " except KeyError:\n", - " raise Exception(\n", - " \"Environment variable ES_PASSWORD (Elasticsearch password) is not set. Please set it.\"\n", - " )\n", - " return es_url, es_username, es_password\n", - "\n", - "def get_elastic_client(es_url: str, username: str, password: str):\n", - " try:\n", - " es_args = {\n", - " \"hosts\": [es_url],\n", - " \"basic_auth\": (username, password),\n", - " \"request_timeout\": 100,\n", - " \"max_retries\": 3,\n", - " \"retry_on_timeout\": True,\n", - " }\n", - "\n", - " client = Elasticsearch(**es_args)\n", - " return client\n", - " except AuthenticationException as ae:\n", - " raise Exception(\n", - " f\"Elasticsearch connection failed due to authentication error: {ae}. Please check your Elasticsearch URL and credentials\"\n", - " )\n", - " except Exception as e:\n", - " raise Exception(f\"Elasticsearch connection failed: {e}.\")" + "AZURE_OPENAI_ENDPOINT = getpass.getpass(\"Enter Azure OpenAI Endpoint: \")\n", + "AZURE_OPENAI_KEY = getpass.getpass(\"Enter Azure OpenAI Key: \")\n", + "AZURE_OPENAI_DEPLOYMENT = getpass.getpass(\"Enter Azure OpenAI Deployment: \")\n", + "AZURE_OPENAI_API_VERSION = getpass.getpass(\"Enter Azure OpenAI API Version: \")" ], - "id": "f663626a3628b8a7", + "id": "4a3aae6e2f03bce5", "outputs": [], - "execution_count": 26 + "execution_count": 33 + }, + { + "cell_type": "markdown", + "id": "9223ae18-d05e-4aa1-9bce-456deae748bc", + "metadata": {}, + "source": [ + "### Install ELSER" + ] }, { "cell_type": "code", "id": "7f722ca314787202", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:50:39.064431Z", - "start_time": "2025-10-29T13:50:39.057548Z" + "end_time": "2025-11-06T15:10:14.749049Z", + "start_time": "2025-11-06T15:10:14.742933Z" } }, "source": [ - "url, username, password = get_elastic_credentials()\n", - "es=get_elastic_client(url, username, password)" + "es = Elasticsearch(hosts=[ES_ENDPOINT], api_key=ES_API_KEY, request_timeout=3600)" ], "outputs": [], - "execution_count": 27 + "execution_count": 44 }, { "cell_type": "code", "id": "4533e737a820eac", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:47:24.858738Z", - "start_time": "2025-10-29T13:47:24.854346Z" + "end_time": "2025-11-06T15:05:28.989252Z", + "start_time": "2025-11-06T15:05:28.981178Z" } }, "source": [ @@ -173,34 +148,45 @@ " es.ml.get_trained_models(model_id=model_id)\n", " except NotFoundError:\n", " logger.info(f'\"{model_id}\" not found. Installing...')\n", - " es.ml.put_trained_model(model_id=model_id, input={\"field_names\": [\"text_field\"]})\n", + " es.ml.put_trained_model(\n", + " model_id=model_id, input={\"field_names\": [\"text_field\"]}\n", + " )\n", "\n", " while True:\n", - " status = es.ml.get_trained_models(model_id=model_id, include=\"definition_status\")\n", + " status = es.ml.get_trained_models(\n", + " model_id=model_id, include=\"definition_status\"\n", + " )\n", " if status[\"trained_model_configs\"][0][\"fully_defined\"]:\n", " break\n", " time.sleep(1)\n", "\n", " stats = es.ml.get_trained_models_stats(model_id=model_id)\n", - " allocation_state = stats[\"trained_model_stats\"][0].get(\"deployment_stats\", {}).get(\"allocation_status\", {}).get(\"state\")\n", + " allocation_state = (\n", + " stats[\"trained_model_stats\"][0]\n", + " .get(\"deployment_stats\", {})\n", + " .get(\"allocation_status\", {})\n", + " .get(\"state\")\n", + " )\n", " if allocation_state != \"fully_allocated\":\n", " try:\n", - " es.ml.start_trained_model_deployment(model_id=model_id, wait_for=\"fully_allocated\")\n", + " es.ml.start_trained_model_deployment(\n", + " model_id=model_id, wait_for=\"fully_allocated\"\n", + " )\n", " except BadRequestError:\n", " pass\n", "\n", " logger.info(f'\"{model_id}\" model is ready')" ], "outputs": [], - "execution_count": 15 + "execution_count": 37 }, { "cell_type": "code", "id": "e008bd7c76211926", "metadata": { "ExecuteTime": { - "end_time": "2025-10-28T13:41:24.525016Z", - "start_time": "2025-10-28T13:41:06.443289Z" + "end_time": "2025-11-06T15:05:52.481140Z", + "start_time": "2025-11-06T15:05:31.120714Z" } }, "source": [ @@ -211,11 +197,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001B[32m2025-10-28 09:41:24.521\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36minstall_elser\u001B[0m:\u001B[36m22\u001B[0m - \u001B[1m\".elser_model_2\" model is ready\u001B[0m\n" + "\u001b[32m2025-11-06 10:05:52.472\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36minstall_elser\u001b[0m:\u001b[36m22\u001b[0m - \u001b[1m\".elser_model_2\" model is ready\u001b[0m\n" ] } ], - "execution_count": 8 + "execution_count": 38 }, { "cell_type": "markdown", @@ -230,20 +216,20 @@ "id": "b2978186bbc9b333", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:47:29.579297Z", - "start_time": "2025-10-29T13:47:29.422893Z" + "end_time": "2025-11-06T15:30:35.343351Z", + "start_time": "2025-11-06T15:30:35.333574Z" } }, "source": [ "llm = AzureChatOpenAI(\n", - " azure_deployment=os.environ.get('AZURE_OPENAI_DEPLOYMENT'),\n", - " azure_endpoint=os.environ.get('AZURE_OPENAI_ENDPOINT'),\n", - " api_version=os.environ.get('AZURE_OPENAI_API_VERSION'),\n", - " api_key=os.environ.get('AZURE_OPENAI_KEY')\n", + " azure_deployment=AZURE_OPENAI_DEPLOYMENT,\n", + " azure_endpoint=AZURE_OPENAI_ENDPOINT,\n", + " api_version=AZURE_OPENAI_API_VERSION,\n", + " api_key=AZURE_OPENAI_KEY,\n", ")" ], "outputs": [], - "execution_count": 16 + "execution_count": 58 }, { "cell_type": "markdown", @@ -258,22 +244,19 @@ "id": "2d1526b3a04fdae", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:47:32.948724Z", - "start_time": "2025-10-29T13:47:31.451833Z" + "end_time": "2025-11-06T15:06:27.518833Z", + "start_time": "2025-11-06T15:06:26.485649Z" } }, "source": [ "dataset = load_dataset(\"ag_news\", split=\"train[:1000]\")\n", "docs = [\n", - " Document(\n", - " page_content=sample[\"text\"],\n", - " metadata={\"category\": sample[\"label\"]}\n", - " )\n", - " for sample in dataset\n", - " ]\n" + " Document(page_content=sample[\"text\"], metadata={\"category\": sample[\"label\"]})\n", + " for sample in dataset\n", + "]" ], "outputs": [], - "execution_count": 17 + "execution_count": 40 }, { "cell_type": "markdown", @@ -288,17 +271,16 @@ "id": "d78b4e82ff95374d", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T14:27:18.437609Z", - "start_time": "2025-10-29T14:27:10.616426Z" + "end_time": "2025-11-06T15:07:58.647936Z", + "start_time": "2025-11-06T15:07:53.046956Z" } }, "source": [ - "index_name=\"news_docs\"\n", + "index_name = \"news_docs\"\n", "elastic_vectorstore = ElasticsearchStore.from_documents(\n", " docs,\n", - " es_url=os.environ[\"ES_URL\"],\n", - " es_user=os.environ[\"ES_USERNAME\"],\n", - " es_password=os.environ[\"ES_PASSWORD\"],\n", + " es_url=ES_ENDPOINT,\n", + " es_api_key=ES_API_KEY,\n", " index_name=index_name,\n", " strategy=SparseVectorStrategy(model_id=\".elser_model_2\"),\n", ")\n", @@ -312,12 +294,12 @@ "ObjectApiResponse({'_shards': {'total': 2, 'successful': 2, 'failed': 0}})" ] }, - "execution_count": 28, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 28 + "execution_count": 41 }, { "cell_type": "markdown", @@ -332,8 +314,8 @@ "id": "da8d9fe9f790020d", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:48:13.512923Z", - "start_time": "2025-10-29T13:48:13.473286Z" + "end_time": "2025-11-06T15:25:29.026797Z", + "start_time": "2025-11-06T15:25:29.022842Z" } }, "source": [ @@ -343,18 +325,25 @@ " related_docs = \"\\n\".join([d.page_content for d in docs])\n", " return related_docs\n", "\n", - "duckduckgo = DuckDuckGoSearchRun(description= \"A custom DuckDuckGo search tool for finding latest news stories.\", verbose=True)\n", + "\n", + "duckduckgo = DuckDuckGoSearchRun(\n", + " description=\"A custom DuckDuckGo search tool for finding latest news stories.\",\n", + " verbose=True,\n", + ")\n", + "\n", + "\n", "def websearch_retriever(query):\n", " results = duckduckgo.run(f\"{query}\")\n", " return results\n", "\n", - "def hybrid_retriever(query):\n", + "\n", + "def composite_retriever(query):\n", " related_docs = vectorstore_retriever(query)\n", " related_docs += websearch_retriever(query)\n", " return related_docs" ], "outputs": [], - "execution_count": 19 + "execution_count": 46 }, { "cell_type": "markdown", @@ -369,37 +358,42 @@ "id": "d232c7529e549b8a", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:48:16.522270Z", - "start_time": "2025-10-29T13:48:16.512865Z" + "end_time": "2025-11-06T15:30:40.787403Z", + "start_time": "2025-11-06T15:30:40.779749Z" } }, "source": [ "class RouteQuery(BaseModel):\n", - " datasource: Literal[\"vectorstore\", \"websearch\", \"hybrid\"] = Field(\n", + " datasource: Literal[\"vectorstore\", \"websearch\", \"composite\"] = Field(\n", " ...,\n", - " description=\"Choose to route the query to web search, vectorstore or hybrid.\"\n", + " description=\"Choose to route the query to web search, vectorstore or composite.\",\n", " )\n", "\n", - "router_prompt = ChatPromptTemplate.from_template(\"\"\"You are an assistant that decides the best data source for news articles based questions.\n", "\n", + "router_prompt = ChatPromptTemplate.from_template(\n", + " \"\"\"You are an assistant that decides the best data source for questions based on news articles.\n", "Choose one of the following options:\n", "- 'vectorstore': for general, background, or historical news articles.\n", "- 'websearch': for recent discoveries, 'latest', 'current', or '2025' type queries.\n", - "- 'hybrid': when the question needs both historical and current knowledge on news articles.\n", + "- 'composite': when the question needs both historical and current knowledge on news articles.\n", "\n", "Question: {query}\n", "\n", - "Return one word: 'vectorstore', 'websearch', or 'hybrid'.\n", - "\"\"\")\n", + "Return one word: 'vectorstore', 'websearch', or 'composite'.\n", + "\"\"\"\n", + ")\n", "router_structured = llm.with_structured_output(RouteQuery)\n", "router_chain: RunnableSequence = router_prompt | router_structured\n", "\n", + "\n", "class GradeRetrievedDocs(BaseModel):\n", " binary_score: bool = Field(\n", " description=\"True if retrieved documents match the query intent, False otherwise.\"\n", " )\n", "\n", - "grade_retrieved_docs_prompt = ChatPromptTemplate.from_template(\"\"\"\n", + "\n", + "grade_retrieved_docs_prompt = ChatPromptTemplate.from_template(\n", + " \"\"\"\n", "You are an evaluator that determines whether the retrieved documents are relevant to the given user query.\n", "\n", "Instructions:\n", @@ -415,24 +409,34 @@ "\n", "Retrieved Documents:\n", "{docs}\n", - "\"\"\")\n", + "\"\"\"\n", + ")\n", "\n", "retrieved_docs_structured = llm.with_structured_output(GradeRetrievedDocs)\n", - "grade_docs_chain: RunnableSequence = grade_retrieved_docs_prompt | retrieved_docs_structured\n", + "grade_docs_chain: RunnableSequence = (\n", + " grade_retrieved_docs_prompt | retrieved_docs_structured\n", + ")\n", + "\n", "\n", "class RewrittenQuery(BaseModel):\n", " query: str\n", "\n", - "rewrite_query_prompt = ChatPromptTemplate.from_template(\"\"\"\n", + "\n", + "rewrite_query_prompt = ChatPromptTemplate.from_template(\n", + " \"\"\"\n", "The grader returned that the retrieved documents do not answer the query. Reformulate the query to better capture the user's intent and retrieve relevant information. Return ONLY the rewritten query, concise and clear. Just the string i.e. the rewritten query.\n", "\n", "Original Query:\n", "{query}\n", - "\"\"\")\n", + "\"\"\"\n", + ")\n", "rewritten_query_structured = llm.with_structured_output(RewrittenQuery)\n", - "rewrite_query_chain: RunnableSequence = rewrite_query_prompt | rewritten_query_structured\n", + "rewrite_query_chain: RunnableSequence = (\n", + " rewrite_query_prompt | rewritten_query_structured\n", + ")\n", "\n", - "summarize_prompt = ChatPromptTemplate.from_template( \"\"\"You are a helpful news assistant. Your task is to summarize the retrieved news articles in a concise and accurate way that directly answers the user's query.\n", + "summarize_prompt = ChatPromptTemplate.from_template(\n", + " \"\"\"You are a helpful news assistant. Your task is to summarize the retrieved news articles in a concise and accurate way that directly answers the user's query.\n", "User Query:\n", "{query}\n", "\n", @@ -447,19 +451,12 @@ "\n", "Summary:\"\"\"\n", ")\n", - "summarize_chain = LLMChain(llm=llm, prompt=summarize_prompt, output_parser=StrOutputParser())\n" - ], - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/mb/g20y910n51gdd16_2c0vflr00000gn/T/ipykernel_19273/691602315.py:74: LangChainDeprecationWarning: The class `LLMChain` was deprecated in LangChain 0.1.17 and will be removed in 1.0. Use :meth:`~RunnableSequence, e.g., `prompt | llm`` instead.\n", - " summarize_chain = LLMChain(llm=llm, prompt=summarize_prompt, output_parser=StrOutputParser())\n" - ] - } + "summarize_chain = LLMChain(\n", + " llm=llm, prompt=summarize_prompt, output_parser=StrOutputParser()\n", + ")" ], - "execution_count": 20 + "outputs": [], + "execution_count": 59 }, { "cell_type": "markdown", @@ -474,8 +471,8 @@ "id": "9db64c1fe48f0f0", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:48:21.116359Z", - "start_time": "2025-10-29T13:48:21.111527Z" + "end_time": "2025-11-06T15:30:45.063493Z", + "start_time": "2025-11-06T15:30:45.056921Z" } }, "source": [ @@ -487,20 +484,25 @@ " self_reflection: bool\n", " retry_count: int = 0\n", "\n", + "\n", "def router(state: RAGState):\n", - " router = router_chain.invoke({'query': state[\"query\"]})\n", + " router = router_chain.invoke({\"query\": state[\"query\"]})\n", " logger.info(f\"Router selected the datasource: {router.datasource}\")\n", " logger.info(f\"User query: {state['query']}\")\n", " return {\"router\": router.datasource}\n", "\n", + "\n", "def vectorstore(state: RAGState):\n", " return {\"docs\": vectorstore_retriever(state[\"query\"])}\n", "\n", + "\n", "def websearch(state: RAGState):\n", " return {\"docs\": websearch_retriever(state[\"query\"])}\n", "\n", - "def hybrid(state: RAGState):\n", - " return {\"docs\": hybrid_retriever(state[\"query\"])}\n", + "\n", + "def composite(state: RAGState):\n", + " return {\"docs\": composite_retriever(state[\"query\"])}\n", + "\n", "\n", "def self_reflection(state: RAGState):\n", " evaluation = grade_docs_chain.invoke(\n", @@ -515,6 +517,7 @@ " \"self_reflection\": evaluation.binary_score,\n", " }\n", "\n", + "\n", "def query_rewriter(state: RAGState):\n", " retry_count = state.get(\"retry_count\", 0) + 1\n", " new_query = rewrite_query_chain.invoke({\"query\": state[\"query\"]})\n", @@ -524,6 +527,7 @@ " \"retry_count\": retry_count,\n", " }\n", "\n", + "\n", "def summarize(state: RAGState):\n", " summary = summarize_chain.run(\n", " query=state[\"query\"],\n", @@ -532,7 +536,7 @@ " return {\"summary\": summary}" ], "outputs": [], - "execution_count": 21 + "execution_count": 60 }, { "cell_type": "markdown", @@ -547,8 +551,8 @@ "id": "16c2b13c6e782184", "metadata": { "ExecuteTime": { - "end_time": "2025-10-29T13:48:26.005534Z", - "start_time": "2025-10-29T13:48:25.828175Z" + "end_time": "2025-11-06T15:30:47.573930Z", + "start_time": "2025-11-06T15:30:47.492874Z" } }, "source": [ @@ -557,13 +561,14 @@ "graph.add_node(\"router\", router)\n", "graph.add_node(\"vectorstore\", vectorstore)\n", "graph.add_node(\"websearch\", websearch)\n", - "graph.add_node(\"hybrid\", hybrid)\n", + "graph.add_node(\"composite\", composite)\n", "graph.add_node(\"self_reflection\", self_reflection)\n", "graph.add_node(\"query_rewriter\", query_rewriter)\n", "graph.add_node(\"summarize\", summarize)\n", "\n", "graph.add_edge(START, \"router\")\n", "\n", + "\n", "def after_router(state: RAGState):\n", " route = state.get(\"router\", None)\n", " if route == \"vectorstore\":\n", @@ -571,59 +576,57 @@ " elif route == \"websearch\":\n", " return \"websearch\"\n", " else:\n", - " return \"hybrid\"\n", + " return \"composite\"\n", + "\n", "\n", "def after_self_reflection(state: RAGState):\n", " if state[\"self_reflection\"]:\n", - " return \"summarize\"\n", + " return \"summarize\"\n", " return \"query_rewriter\"\n", "\n", + "\n", "def after_query_rewriter(state: RAGState):\n", - " while state['retry_count'] <= 3:\n", - " return \"router\"\n", + " while state[\"retry_count\"] <= 3:\n", + " return \"router\"\n", " raise RuntimeError(\"Maximum retries (3) reached — evaluation failed.\")\n", "\n", + "\n", "graph.add_conditional_edges(\n", " \"router\",\n", " after_router,\n", - " {\n", - " \"vectorstore\": \"vectorstore\",\n", - " \"websearch\": \"websearch\",\n", - " \"hybrid\": \"hybrid\"\n", - " }\n", + " {\"vectorstore\": \"vectorstore\", \"websearch\": \"websearch\", \"composite\": \"composite\"},\n", ")\n", "\n", "graph.add_edge(\"vectorstore\", \"self_reflection\")\n", "graph.add_edge(\"websearch\", \"self_reflection\")\n", - "graph.add_edge(\"hybrid\", \"self_reflection\")\n", + "graph.add_edge(\"composite\", \"self_reflection\")\n", "graph.add_conditional_edges(\n", " \"self_reflection\",\n", " after_self_reflection,\n", - " {\n", - " \"summarize\": \"summarize\",\n", - " \"query_rewriter\": \"query_rewriter\"\n", - " }\n", + " {\"summarize\": \"summarize\", \"query_rewriter\": \"query_rewriter\"},\n", + ")\n", + "graph.add_conditional_edges(\n", + " \"query_rewriter\", after_query_rewriter, {\"router\": \"router\"}\n", ")\n", - "graph.add_conditional_edges(\"query_rewriter\", after_query_rewriter, {\"router\": \"router\"})\n", "graph.add_edge(\"summarize\", END)\n", - "agent=graph.compile()\n", - "agent.get_graph().draw_mermaid_png(output_file_path='graph.png')\n", - "Image('graph.png')" + "agent = graph.compile()\n", + "agent.get_graph().draw_mermaid_png(output_file_path=\"graph.png\")\n", + "Image(\"graph.png\")" ], "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] }, - "execution_count": 22, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 22 + "execution_count": 61 }, { "cell_type": "markdown", @@ -635,119 +638,115 @@ }, { "cell_type": "code", - "execution_count": 24, "id": "5c787b2428e926ca", "metadata": { "ExecuteTime": { - "end_time": "2025-10-26T02:10:17.312233Z", - "start_time": "2025-10-26T02:10:17.309859Z" + "end_time": "2025-11-06T15:30:51.624639Z", + "start_time": "2025-11-06T15:30:51.622118Z" } }, - "outputs": [], "source": [ - "query1=\"What are the latest AI models released this month?\"\n", - "query2=\"What technological innovations are discussed in Sci/Tech news?\"\n", - "query3=\"Compare a Sci/Tech article from the dataset with a current web article about AI trends.\"" - ] + "query1 = \"What are the latest AI models released this month?\"\n", + "query2 = \"What technological innovations are discussed in Sci/Tech news?\"\n", + "query3 = \"Compare a Sci/Tech article from the dataset with a current web article about AI trends.\"" + ], + "outputs": [], + "execution_count": 62 }, { "cell_type": "code", - "execution_count": 26, "id": "3c48705d7c0d237c", "metadata": { "ExecuteTime": { - "end_time": "2025-10-26T02:13:17.180661Z", - "start_time": "2025-10-26T02:13:13.737383Z" + "end_time": "2025-11-06T15:31:00.392467Z", + "start_time": "2025-11-06T15:30:52.982336Z" } }, + "source": [ + "result = agent.invoke({\"query\": query1})\n", + "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" + ], "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001B[32m2025-10-27 12:21:40.530\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: websearch\u001B[0m\n", - "\u001B[32m2025-10-27 12:21:40.532\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: What are the latest AI models released this month?\u001B[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001B[32;1m\u001B[1;3mMarch 31, 2025 - It also gives users control over how long the model can think for, per Anthropic. Sonnet 3.7 is available to all Claude users, but heavier users will need a $20-per-month Pro plan. Grok 3 is the latest flagship model from Elon Musk-founded startup ... October 30, 2024 - What's particularly noteworthy is that the Llama 3.1 -Nemotron-70B-Instruct model has shown outstanding results in automatic benchmarks, outperforming even some of the most advanced models in the field, including Claude 3.5 Sonnet and GPT-4. ... March 26, 2025 - Grok 3: DeepSearch can significantly enhance developers’ ability to conduct research, find relevant resources, and stay informed about the latest advancements in their field. The upcoming release of the Grok 3 API will further empower developers ... September 10, 2025 - We had an AI Mode in Search expansion, ... round out the month — including a new image editing release in the Gemini app (Nano Banana) and Google DeepMind’s first real-time interactive general-purpose world AI model, Genie 3. We’ve made ... July 2, 2025 - We released Imagen 4 for developers in the Gemini API and Google AI Studio. Imagen 4 , our best text-to-image model yet, is now available for paid preview in the Gemini API and for limited free testing in Google AI Studio.\u001B[0m" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001B[32m2025-10-27 12:21:41.999\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m31\u001B[0m - \u001B[1mSelf-reflection failed — binary_score=False\u001B[0m\n", - "\u001B[32m2025-10-27 12:21:42.626\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mquery_rewriter\u001B[0m:\u001B[36m40\u001B[0m - \u001B[1mQuery rewritten: query='Which AI models have been launched or published in June 2024?', retry_count: 1\u001B[0m\n", - "\u001B[32m2025-10-27 12:21:43.194\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: websearch\u001B[0m\n", - "\u001B[32m2025-10-27 12:21:43.195\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: query='Which AI models have been launched or published in June 2024?'\u001B[0m\n" + "\u001b[32m2025-11-06 10:30:53.873\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m11\u001b[0m - \u001b[1mRouter selected the datasource: websearch\u001b[0m\n", + "\u001b[32m2025-11-06 10:30:53.874\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m12\u001b[0m - \u001b[1mUser query: What are the latest AI models released this month?\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[32;1m\u001B[1;3mJul 2, 2024 · Discover the top AI news of June 2024 , including Apple Intelligence Figma's AI feature controversy, Runway's Gen-3 Alpha launch , and more. Jun 26, 2024 · Today, we delve into the latest rankings of AI models , highlighting the most powerful generative language models as of June 2024 . Jun 4, 2025 · We saw the release of a range of platform models , from Claude 4 by Anthropic, to Google’s Veo 3, a model that generates synchronized audio and video content. In the open source ecosystem, Mistral released the Devstral model, and Alibaba released the Qwen3 series of models . Feb 28, 2025 · With new AI models launched in the market in 2025 and 2024 , it can be overwhelming to keep track of them all. We have compiled a listed guide to the newest and most advanced AI models , what they do, and how to use them. Our public database, the largest of its kind, tracks over 3100 machine learning models from 1950 to today. Explore data and graphs showing the trajectory of AI .\u001B[0m" + "\u001b[32;1m\u001b[1;3mWhat Is The Best AI Model In September 2025? Ultimate Comparison The five most powerful AI companies have now unveiled their flagship models , creating what might be the most intense competition we've seen in artificial intelligence development. OpenAI dropped GPT-5 in early August 2025, while Anthropic released Claude Opus 4.1 just days earlier. Here's what I've learned after testing every major AI release this month : The real question isn't about keeping up with every shiny new model . It's about how to use AI tools responsibly while they rapidly evolve around us. Missed the latest AI news? From ChatGPT upgrades to Google's new tools, here are 7 big AI updates you need to know about this week. To fully meet our goals, MAI requires purpose-built models . Today, we're excited to preview the first steps to making this a reality. First, we're releasing MAI-Voice-1, our first highly expressive and natural speech generation model , which is available in Copilot Daily and Podcasts, and as a brand new Copilot Labs experience to try out here. Anthropic has unveiled its latest AI models , Claude Opus 4 and Claude Sonnet 4, marking a significant advancement in the field of artificial intelligence. Claude Opus 4 stands out as Anthropic's most powerful model to date, excelling in complex coding tasks and long-duration problem-solving.\u001b[0m" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\u001B[32m2025-10-27 12:21:45.407\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", - "\u001B[32m2025-10-27 12:21:46.972\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", + "\u001b[32m2025-11-06 10:30:58.545\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mself_reflection\u001b[0m:\u001b[36m29\u001b[0m - \u001b[1mSelf-reflection passed — binary_score=True\u001b[0m\n", + "\u001b[32m2025-11-06 10:31:00.390\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m2\u001b[0m - \u001b[1m\n", "Final Summary:\n", - ": In June 2024, several notable AI models were launched or published, including Runway's Gen-3 Alpha, Anthropic's Claude 4, Google's Veo 3 (which generates synchronized audio and video), Mistral's open-source Devstral model, and Alibaba's Qwen3 series.\u001B[0m\n" + ": The latest AI models released this month include OpenAI's GPT-5, launched in early August 2025, and Anthropic's Claude Opus 4.1, alongside Claude Opus 4 and Claude Sonnet 4, which feature advanced capabilities in coding and long-duration problem-solving. Additionally, MAI unveiled MAI-Voice-1, a highly expressive speech generation model, now available in Copilot applications. These releases mark significant advancements from leading AI companies.\u001b[0m\n" ] } ], - "source": [ - "result = agent.invoke({\"query\": query1})\n", - "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" - ] + "execution_count": 63 }, { "cell_type": "code", - "execution_count": 27, "id": "a63de923-ca7b-42fb-9a80-7f261cb92d74", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-06T15:29:16.249050Z", + "start_time": "2025-11-06T15:29:13.321002Z" + } + }, + "source": [ + "result = agent.invoke({\"query\": query2})\n", + "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" + ], "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001B[32m2025-10-27 12:22:25.073\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: vectorstore\u001B[0m\n", - "\u001B[32m2025-10-27 12:22:25.075\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: What technological innovations are discussed in Sci/Tech news?\u001B[0m\n", - "/Users/kirtisodhi/agentic-rag/path/to/venv/lib/python3.13/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", + "\u001b[32m2025-11-06 10:29:14.260\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m11\u001b[0m - \u001b[1mRouter selected the datasource: vectorstore\u001b[0m\n", + "\u001b[32m2025-11-06 10:29:14.261\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m12\u001b[0m - \u001b[1mUser query: What technological innovations are discussed in Sci/Tech news?\u001b[0m\n", + "/Users/kirtisodhi/Library/Python/3.9/lib/python/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", " hits = self._store.search(\n", - "\u001B[32m2025-10-27 12:22:25.998\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", - "\u001B[32m2025-10-27 12:22:27.416\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", + "\u001b[32m2025-11-06 10:29:14.771\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mself_reflection\u001b[0m:\u001b[36m29\u001b[0m - \u001b[1mSelf-reflection passed — binary_score=True\u001b[0m\n", + "\u001b[32m2025-11-06 10:29:16.247\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m2\u001b[0m - \u001b[1m\n", "Final Summary:\n", - ": Recent Sci/Tech news highlights several technological innovations: NASA is collaborating with Silicon Valley firms to build a powerful Linux-based supercomputer for theoretical research and shuttle engineering; Genetic Savings & Clone has developed chromatin transfer technology to clone cats; Princeton scientists report that existing technologies could immediately help stabilize global warming; and a set of micro-games for GameBoy was recognized for its innovation at a gaming festival. Additionally, cybersecurity advances are featured in The Washington Post's special report.\u001B[0m\n" + ": Recent Sci/Tech news highlights several technological innovations: NASA is developing a cutting-edge Linux-based supercomputer to support researchers and shuttle engineers; a company has achieved cat cloning through chromatin transfer technology; Princeton University scientists report that current technologies can be implemented immediately to stabilize global warming for the next 50 years; and a set of innovative GameBoy mini-games has won a prize for game design.\u001b[0m\n" ] } ], - "source": [ - "result = agent.invoke({\"query\": query2})\n", - "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" - ] + "execution_count": 54 }, { "cell_type": "code", - "execution_count": 28, "id": "24c342fa-8220-42b6-adf3-b48fcd164104", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-06T15:29:42.898171Z", + "start_time": "2025-11-06T15:29:37.639301Z" + } + }, + "source": [ + "result = agent.invoke({\"query\": query3})\n", + "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" + ], "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001B[32m2025-10-27 12:22:37.566\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: hybrid\u001B[0m\n", - "\u001B[32m2025-10-27 12:22:37.568\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: Compare a Sci/Tech article from the dataset with a current web article about AI trends.\u001B[0m\n", - "/Users/kirtisodhi/agentic-rag/path/to/venv/lib/python3.13/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", + "\u001b[32m2025-11-06 10:29:38.534\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m11\u001b[0m - \u001b[1mRouter selected the datasource: composite\u001b[0m\n", + "\u001b[32m2025-11-06 10:29:38.535\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m12\u001b[0m - \u001b[1mUser query: Compare a Sci/Tech article from the dataset with a current web article about AI trends.\u001b[0m\n", + "/Users/kirtisodhi/Library/Python/3.9/lib/python/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", " hits = self._store.search(\n" ] }, @@ -755,32 +754,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001B[32;1m\u001B[1;3m19 hours ago - In the late 2010s, graphics processing ... large-scale (commercial and academic) machine learning models' training. Specialized programming languages such as Prolog were used in early AI research, but general-purpose programming languages like Python have become predominant. The transistor density in integrated circuits has been observed to roughly double every 18 months—a trend known as Moore's ... Mar 4, 2025 · This article aims to equip readers with a deep understanding of AI ’ s current state and future trajectory, providing actionable insights and practical advice to navigate this transformative era. 3 weeks ago - North America, which includes the U.S. and Canada, is the market leader . In 2023, it captured 38.9% of the global AI market, which was about $97.25 billion in revenue. ... China has a much higher active adoption rate. March 12, 2025 - This article is a collaborative effort by Alex Singla, Alexander Sukharevsky, Lareina Yee, and Michael Chui, with Bryce Hall, representing views from QuantumBlack, AI by McKinsey. Our survey analyses show that a CEO’s oversight of AI governance—that is, the policies, processes, and technology necessary to develop and deploy AI systems responsibly—is one element most correlated with higher self-reported bottom-line impact from an organization’s gen AI use.1The correlation analyses considered 25 attributes and the reported effect of gen AI use on organizations’ EBIT, and using the Johnson’s Relative Weights regression analysis yielded an R-squared of 0.20. May 1, 2025 - Models with advanced reasoning capabilities, like OpenAI o1, can already solve complex problems with logical steps that are similar to how humans think before responding to difficult questions. These capabilities will continue to be useful in fields like science, coding, math, law and medicine, allowing models to compare contracts, generate code and execute multistep workflows.\u001B[0m" + "\u001b[32;1m\u001b[1;3m3 days ago - In the late 2010s, graphics processing ... large-scale (commercial and academic) machine learning models' training. Specialized programming languages such as Prolog were used in early AI research, but general-purpose programming languages like Python have become predominant. The transistor density in integrated circuits has been observed to roughly double every 18 months—a trend known as Moore's ... May 1, 2025 - Models with advanced reasoning capabilities, like OpenAI o1, can already solve complex problems with logical steps that are similar to how humans think before responding to difficult questions. These capabilities will continue to be useful in fields like science, coding, math, law and medicine, allowing models to compare contracts, generate code and execute multistep workflows. 2 days ago - In any given business function, no more than 10 percent of respondents say their organizations are scaling AI agents (Exhibit 2). Looking at individual business functions, agent use is most commonly reported in IT and knowledge management, where agentic use cases such as service-desk management in IT and deep research in knowledge management have quickly developed. By industry, the use of AI agents is most widely reported in the technology, media and telecommunications, and healthcare sectors (Exhibit 3). 1 month ago - North America, which includes the U.S. and Canada, is the market leader . In 2023, it captured 38.9% of the global AI market, which was about $97.25 billion in revenue. ... China has a much higher active adoption rate. March 4, 2025 - AI Statistics explores the latest trends in artificial intelligence (AI). Gain insights into adoption rates, AI jobs, and applications.\u001b[0m" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\u001B[32m2025-10-27 12:22:39.279\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", - "\u001B[32m2025-10-27 12:22:41.650\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", + "\u001b[32m2025-11-06 10:29:40.618\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mself_reflection\u001b[0m:\u001b[36m29\u001b[0m - \u001b[1mSelf-reflection passed — binary_score=True\u001b[0m\n", + "\u001b[32m2025-11-06 10:29:42.894\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m2\u001b[0m - \u001b[1m\n", "Final Summary:\n", - ": A Sci/Tech article from the dataset highlights how NASA is developing advanced artificial intelligence (AI) software for planetary rovers, enabling them to become more autonomous and make critical decisions during missions. In comparison, a current web article about AI trends discusses the rapid evolution of AI technologies, such as large-scale models with advanced reasoning capabilities (like OpenAI o1), the widespread adoption of AI in various sectors, and the importance of responsible AI governance in organizations to maximize business impact. Both articles emphasize the increasing sophistication and self-reliance of AI systems, but while the NASA article focuses on specialized applications for space exploration, the current web article covers broader AI trends, advancements in reasoning, market growth, and practical impacts across industries.\u001B[0m\n" + ": The Sci/Tech article from the dataset highlights NASA's development of advanced AI for planetary rovers, aiming to make them more autonomous and capable of making mission-critical decisions independently. This reflects a trend towards specialized AI applications in science and exploration.\n", + "\n", + "Compared to current web articles on AI trends, the broader industry focus is on scaling AI models and agents across various sectors, especially in IT, healthcare, and knowledge management. Recent models like OpenAI o1 showcase advanced reasoning, supporting complex tasks in coding, law, and medicine. While organizations are experimenting with AI agents, widespread deployment is still limited. The global AI market continues to grow, with North America as a leader and China rapidly adopting AI solutions.\n", + "\n", + "In summary, while NASA’s AI efforts demonstrate specialized, mission-focused intelligence in robotics, current AI trends emphasize the expansion of advanced, general-purpose AI agents across industries to boost productivity and handle complex workflows. Both reflect ongoing technical progress and increasing real-world impact of artificial intelligence.\u001b[0m\n" ] } ], - "source": [ - "result = agent.invoke({\"query\": query3})\n", - "logger.info(f\"\\nFinal Summary:\\n: {result['summary']}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e291cc77-e511-42cf-8386-90646dd2ad69", - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 56 } ], "metadata": { From 73cf730c7152c9521413dc2161be59c78d430112 Mon Sep 17 00:00:00 2001 From: kirtisodhi Date: Thu, 6 Nov 2025 13:08:04 -0500 Subject: [PATCH 3/4] add timeout and retry for vectorstore --- .../agentic-rag/agent_rag_news_assistant.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb index 6445d5fe..a8d5d7c3 100644 --- a/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb +++ b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb @@ -281,6 +281,7 @@ " docs,\n", " es_url=ES_ENDPOINT,\n", " es_api_key=ES_API_KEY,\n", + " es_params={\"request_timeout\": 60, \"max_retries\": 3, \"retry_on_timeout\": True},\n", " index_name=index_name,\n", " strategy=SparseVectorStrategy(model_id=\".elser_model_2\"),\n", ")\n", From 3bc447188a475427960c0695314e69c6093c3323 Mon Sep 17 00:00:00 2001 From: kirtisodhi Date: Thu, 6 Nov 2025 13:19:08 -0500 Subject: [PATCH 4/4] add title to the notebook --- .../agent_rag_news_assistant.ipynb | 44 +++++++++++-------- 1 file changed, 25 insertions(+), 19 deletions(-) diff --git a/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb index a8d5d7c3..5b64e99b 100644 --- a/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb +++ b/supporting-blog-content/agentic-rag/agent_rag_news_assistant.ipynb @@ -1,10 +1,16 @@ { "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Building an Agentic RAG Workflow using Elasticsearch and LangChain", + "id": "4f931c74dd212130" + }, { "metadata": {}, "cell_type": "markdown", "source": "This notebook demonstrates a simple Agentic RAG workflow that uses Elasticsearch as the vector store and LangChain for orchestration. It accompanies the article \"Developing Adaptive Retrieval Workflows Using Elasticsearch and LangChain\" and showcases the core ideas discussed there. For a deeper explanation, please refer to the article.", - "id": "6652455987a6d84d" + "id": "a01126d74984e99d" }, { "metadata": {}, @@ -197,7 +203,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2025-11-06 10:05:52.472\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36minstall_elser\u001b[0m:\u001b[36m22\u001b[0m - \u001b[1m\".elser_model_2\" model is ready\u001b[0m\n" + "\u001B[32m2025-11-06 10:05:52.472\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36minstall_elser\u001B[0m:\u001B[36m22\u001B[0m - \u001B[1m\".elser_model_2\" model is ready\u001B[0m\n" ] } ], @@ -672,25 +678,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2025-11-06 10:30:53.873\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m11\u001b[0m - \u001b[1mRouter selected the datasource: websearch\u001b[0m\n", - "\u001b[32m2025-11-06 10:30:53.874\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m12\u001b[0m - \u001b[1mUser query: What are the latest AI models released this month?\u001b[0m\n" + "\u001B[32m2025-11-06 10:30:53.873\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: websearch\u001B[0m\n", + "\u001B[32m2025-11-06 10:30:53.874\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: What are the latest AI models released this month?\u001B[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[32;1m\u001b[1;3mWhat Is The Best AI Model In September 2025? Ultimate Comparison The five most powerful AI companies have now unveiled their flagship models , creating what might be the most intense competition we've seen in artificial intelligence development. OpenAI dropped GPT-5 in early August 2025, while Anthropic released Claude Opus 4.1 just days earlier. Here's what I've learned after testing every major AI release this month : The real question isn't about keeping up with every shiny new model . It's about how to use AI tools responsibly while they rapidly evolve around us. Missed the latest AI news? From ChatGPT upgrades to Google's new tools, here are 7 big AI updates you need to know about this week. To fully meet our goals, MAI requires purpose-built models . Today, we're excited to preview the first steps to making this a reality. First, we're releasing MAI-Voice-1, our first highly expressive and natural speech generation model , which is available in Copilot Daily and Podcasts, and as a brand new Copilot Labs experience to try out here. Anthropic has unveiled its latest AI models , Claude Opus 4 and Claude Sonnet 4, marking a significant advancement in the field of artificial intelligence. Claude Opus 4 stands out as Anthropic's most powerful model to date, excelling in complex coding tasks and long-duration problem-solving.\u001b[0m" + "\u001B[32;1m\u001B[1;3mWhat Is The Best AI Model In September 2025? Ultimate Comparison The five most powerful AI companies have now unveiled their flagship models , creating what might be the most intense competition we've seen in artificial intelligence development. OpenAI dropped GPT-5 in early August 2025, while Anthropic released Claude Opus 4.1 just days earlier. Here's what I've learned after testing every major AI release this month : The real question isn't about keeping up with every shiny new model . It's about how to use AI tools responsibly while they rapidly evolve around us. Missed the latest AI news? From ChatGPT upgrades to Google's new tools, here are 7 big AI updates you need to know about this week. To fully meet our goals, MAI requires purpose-built models . Today, we're excited to preview the first steps to making this a reality. First, we're releasing MAI-Voice-1, our first highly expressive and natural speech generation model , which is available in Copilot Daily and Podcasts, and as a brand new Copilot Labs experience to try out here. Anthropic has unveiled its latest AI models , Claude Opus 4 and Claude Sonnet 4, marking a significant advancement in the field of artificial intelligence. Claude Opus 4 stands out as Anthropic's most powerful model to date, excelling in complex coding tasks and long-duration problem-solving.\u001B[0m" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2025-11-06 10:30:58.545\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mself_reflection\u001b[0m:\u001b[36m29\u001b[0m - \u001b[1mSelf-reflection passed — binary_score=True\u001b[0m\n", - "\u001b[32m2025-11-06 10:31:00.390\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m2\u001b[0m - \u001b[1m\n", + "\u001B[32m2025-11-06 10:30:58.545\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", + "\u001B[32m2025-11-06 10:31:00.390\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", "Final Summary:\n", - ": The latest AI models released this month include OpenAI's GPT-5, launched in early August 2025, and Anthropic's Claude Opus 4.1, alongside Claude Opus 4 and Claude Sonnet 4, which feature advanced capabilities in coding and long-duration problem-solving. Additionally, MAI unveiled MAI-Voice-1, a highly expressive speech generation model, now available in Copilot applications. These releases mark significant advancements from leading AI companies.\u001b[0m\n" + ": The latest AI models released this month include OpenAI's GPT-5, launched in early August 2025, and Anthropic's Claude Opus 4.1, alongside Claude Opus 4 and Claude Sonnet 4, which feature advanced capabilities in coding and long-duration problem-solving. Additionally, MAI unveiled MAI-Voice-1, a highly expressive speech generation model, now available in Copilot applications. These releases mark significant advancements from leading AI companies.\u001B[0m\n" ] } ], @@ -714,14 +720,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2025-11-06 10:29:14.260\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m11\u001b[0m - \u001b[1mRouter selected the datasource: vectorstore\u001b[0m\n", - "\u001b[32m2025-11-06 10:29:14.261\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m12\u001b[0m - \u001b[1mUser query: What technological innovations are discussed in Sci/Tech news?\u001b[0m\n", + "\u001B[32m2025-11-06 10:29:14.260\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: vectorstore\u001B[0m\n", + "\u001B[32m2025-11-06 10:29:14.261\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: What technological innovations are discussed in Sci/Tech news?\u001B[0m\n", "/Users/kirtisodhi/Library/Python/3.9/lib/python/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", " hits = self._store.search(\n", - "\u001b[32m2025-11-06 10:29:14.771\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mself_reflection\u001b[0m:\u001b[36m29\u001b[0m - \u001b[1mSelf-reflection passed — binary_score=True\u001b[0m\n", - "\u001b[32m2025-11-06 10:29:16.247\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m2\u001b[0m - \u001b[1m\n", + "\u001B[32m2025-11-06 10:29:14.771\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", + "\u001B[32m2025-11-06 10:29:16.247\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", "Final Summary:\n", - ": Recent Sci/Tech news highlights several technological innovations: NASA is developing a cutting-edge Linux-based supercomputer to support researchers and shuttle engineers; a company has achieved cat cloning through chromatin transfer technology; Princeton University scientists report that current technologies can be implemented immediately to stabilize global warming for the next 50 years; and a set of innovative GameBoy mini-games has won a prize for game design.\u001b[0m\n" + ": Recent Sci/Tech news highlights several technological innovations: NASA is developing a cutting-edge Linux-based supercomputer to support researchers and shuttle engineers; a company has achieved cat cloning through chromatin transfer technology; Princeton University scientists report that current technologies can be implemented immediately to stabilize global warming for the next 50 years; and a set of innovative GameBoy mini-games has won a prize for game design.\u001B[0m\n" ] } ], @@ -745,8 +751,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2025-11-06 10:29:38.534\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m11\u001b[0m - \u001b[1mRouter selected the datasource: composite\u001b[0m\n", - "\u001b[32m2025-11-06 10:29:38.535\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mrouter\u001b[0m:\u001b[36m12\u001b[0m - \u001b[1mUser query: Compare a Sci/Tech article from the dataset with a current web article about AI trends.\u001b[0m\n", + "\u001B[32m2025-11-06 10:29:38.534\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m11\u001B[0m - \u001B[1mRouter selected the datasource: composite\u001B[0m\n", + "\u001B[32m2025-11-06 10:29:38.535\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mrouter\u001B[0m:\u001B[36m12\u001B[0m - \u001B[1mUser query: Compare a Sci/Tech article from the dataset with a current web article about AI trends.\u001B[0m\n", "/Users/kirtisodhi/Library/Python/3.9/lib/python/site-packages/langchain_elasticsearch/_sync/vectorstores.py:530: ElasticsearchWarning: text_expansion is deprecated. Use sparse_vector instead.\n", " hits = self._store.search(\n" ] @@ -755,21 +761,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[32;1m\u001b[1;3m3 days ago - In the late 2010s, graphics processing ... large-scale (commercial and academic) machine learning models' training. Specialized programming languages such as Prolog were used in early AI research, but general-purpose programming languages like Python have become predominant. The transistor density in integrated circuits has been observed to roughly double every 18 months—a trend known as Moore's ... May 1, 2025 - Models with advanced reasoning capabilities, like OpenAI o1, can already solve complex problems with logical steps that are similar to how humans think before responding to difficult questions. These capabilities will continue to be useful in fields like science, coding, math, law and medicine, allowing models to compare contracts, generate code and execute multistep workflows. 2 days ago - In any given business function, no more than 10 percent of respondents say their organizations are scaling AI agents (Exhibit 2). Looking at individual business functions, agent use is most commonly reported in IT and knowledge management, where agentic use cases such as service-desk management in IT and deep research in knowledge management have quickly developed. By industry, the use of AI agents is most widely reported in the technology, media and telecommunications, and healthcare sectors (Exhibit 3). 1 month ago - North America, which includes the U.S. and Canada, is the market leader . In 2023, it captured 38.9% of the global AI market, which was about $97.25 billion in revenue. ... China has a much higher active adoption rate. March 4, 2025 - AI Statistics explores the latest trends in artificial intelligence (AI). Gain insights into adoption rates, AI jobs, and applications.\u001b[0m" + "\u001B[32;1m\u001B[1;3m3 days ago - In the late 2010s, graphics processing ... large-scale (commercial and academic) machine learning models' training. Specialized programming languages such as Prolog were used in early AI research, but general-purpose programming languages like Python have become predominant. The transistor density in integrated circuits has been observed to roughly double every 18 months—a trend known as Moore's ... May 1, 2025 - Models with advanced reasoning capabilities, like OpenAI o1, can already solve complex problems with logical steps that are similar to how humans think before responding to difficult questions. These capabilities will continue to be useful in fields like science, coding, math, law and medicine, allowing models to compare contracts, generate code and execute multistep workflows. 2 days ago - In any given business function, no more than 10 percent of respondents say their organizations are scaling AI agents (Exhibit 2). Looking at individual business functions, agent use is most commonly reported in IT and knowledge management, where agentic use cases such as service-desk management in IT and deep research in knowledge management have quickly developed. By industry, the use of AI agents is most widely reported in the technology, media and telecommunications, and healthcare sectors (Exhibit 3). 1 month ago - North America, which includes the U.S. and Canada, is the market leader . In 2023, it captured 38.9% of the global AI market, which was about $97.25 billion in revenue. ... China has a much higher active adoption rate. March 4, 2025 - AI Statistics explores the latest trends in artificial intelligence (AI). Gain insights into adoption rates, AI jobs, and applications.\u001B[0m" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2025-11-06 10:29:40.618\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mself_reflection\u001b[0m:\u001b[36m29\u001b[0m - \u001b[1mSelf-reflection passed — binary_score=True\u001b[0m\n", - "\u001b[32m2025-11-06 10:29:42.894\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m2\u001b[0m - \u001b[1m\n", + "\u001B[32m2025-11-06 10:29:40.618\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36mself_reflection\u001B[0m:\u001B[36m29\u001B[0m - \u001B[1mSelf-reflection passed — binary_score=True\u001B[0m\n", + "\u001B[32m2025-11-06 10:29:42.894\u001B[0m | \u001B[1mINFO \u001B[0m | \u001B[36m__main__\u001B[0m:\u001B[36m\u001B[0m:\u001B[36m2\u001B[0m - \u001B[1m\n", "Final Summary:\n", ": The Sci/Tech article from the dataset highlights NASA's development of advanced AI for planetary rovers, aiming to make them more autonomous and capable of making mission-critical decisions independently. This reflects a trend towards specialized AI applications in science and exploration.\n", "\n", "Compared to current web articles on AI trends, the broader industry focus is on scaling AI models and agents across various sectors, especially in IT, healthcare, and knowledge management. Recent models like OpenAI o1 showcase advanced reasoning, supporting complex tasks in coding, law, and medicine. While organizations are experimenting with AI agents, widespread deployment is still limited. The global AI market continues to grow, with North America as a leader and China rapidly adopting AI solutions.\n", "\n", - "In summary, while NASA’s AI efforts demonstrate specialized, mission-focused intelligence in robotics, current AI trends emphasize the expansion of advanced, general-purpose AI agents across industries to boost productivity and handle complex workflows. Both reflect ongoing technical progress and increasing real-world impact of artificial intelligence.\u001b[0m\n" + "In summary, while NASA’s AI efforts demonstrate specialized, mission-focused intelligence in robotics, current AI trends emphasize the expansion of advanced, general-purpose AI agents across industries to boost productivity and handle complex workflows. Both reflect ongoing technical progress and increasing real-world impact of artificial intelligence.\u001B[0m\n" ] } ],