From 3289b1285656771487b59968b9071c996135fc41 Mon Sep 17 00:00:00 2001 From: Guillaume Vernade Date: Fri, 8 Aug 2025 14:10:21 +0000 Subject: [PATCH 1/8] Adding mentions of the grounding notebook and in particular url context --- README.md | 2 +- examples/Browser_as_a_tool.ipynb | 6 +- quickstarts/Search_Grounding.ipynb | 828 +++++++++-------------------- 3 files changed, 243 insertions(+), 593 deletions(-) diff --git a/README.md b/README.md index d9e0af4a9..57df92fd0 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ Then, explore the other quickstarts tutorials to learn about individual features ## 2. Examples (Practical Use Cases) These examples demonstrate how to combine multiple Gemini API features or 3rd-party tools to build more complex applications. -* [Browser as a tool](./examples/Browser_as_a_tool.ipynb): Use a web browser for live and internal (intranet) web interactions +* [Browser as a tool](./examples/Browser_as_a_tool.ipynb): Use a web browser for live and internal (intranet) web interactions * [Illustrate a book](./examples/Book_illustration.ipynb): Use Gemini and Imagen to create illustration for an open-source book * [Animated Story Generation](./examples/Animated_Story_Video_Generation_gemini.ipynb): Create animated videos by combining Gemini's story generation, Imagen, and audio synthesis * [Plotting and mapping Live](./examples/LiveAPI_plotting_and_mapping.ipynb): Mix *Live API* and *Code execution* to solve complex tasks live diff --git a/examples/Browser_as_a_tool.ipynb b/examples/Browser_as_a_tool.ipynb index 09ac544ad..4c8c369f6 100644 --- a/examples/Browser_as_a_tool.ipynb +++ b/examples/Browser_as_a_tool.ipynb @@ -54,7 +54,9 @@ "\n", "* Requesting live data using a browser tool with the Live API\n", "* Returning images of web pages from function calling\n", - "* Connecting to a local network/intranet using a browser tool\n" + "* Connecting to a local network/intranet using a browser tool\n", + "\n", + "**Note**: for most of the use-cases, you can use the tools directly by Gemini to get it to search content using Google Search, grab videos from YouTube or fetch context from URLs without having to set-up anything. Check out the [Grounding](https://colab.sandbox.google.com/quickstarts/Grounding.ipynb) notebook for more details.\n" ] }, { @@ -1193,7 +1195,7 @@ "source": [ "## Further reading\n", "\n", - "* To learn more about using the search tools, try the [Search grounding](../quickstarts/Search_Grounding.ipynb) cookbook recipe.\n", + "* To learn more about using the grounding tools (search grounding, youtube links and URL context), check out the [Grounding](../quickstarts/Grounding.ipynb) notebook or the one dedicated to [Seach grounding](../quickstarts/Search_Grounding.ipynb).\n", "* For more advanced examples of function calling in the Live API, try the [Plotting and Mapping](../examples/LiveAPI_plotting_and_mapping.ipynb) cookbook recipe.\n", "\n", "Or browse the [Gemini API cookbook](http://github.com/google-gemini/cookbook)." diff --git a/quickstarts/Search_Grounding.ipynb b/quickstarts/Search_Grounding.ipynb index e8ca34c05..eeae27132 100644 --- a/quickstarts/Search_Grounding.ipynb +++ b/quickstarts/Search_Grounding.ipynb @@ -66,9 +66,7 @@ "id": "vKu1tRBrQ7xj" }, "source": [ - "## Set up the SDK\n", - "\n", - "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini 2.0 models." + "## Set up the SDK and the client" ] }, { @@ -79,9 +77,9 @@ "source": [ "### Install SDK\n", "\n", - "The new **[Google Gen AI SDK](https://github.com/googleapis/python-genai)** provides programmatic access to Gemini 2 (and previous models) using both the [Google AI for Developers](https://ai.google.dev/gemini-api/docs/models/gemini-v2) and [Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/overview) APIs. With a few exceptions, code that runs on one platform will run on both. This means that you can prototype an application using the Developer API and then migrate the application to Vertex AI without rewriting your code.\n", + "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini 2.0 models.\n", "\n", - "More details about this new SDK on the [documentation](https://googleapis.github.io/python-genai/) or in the [Getting started](./Get_started.ipynb) notebook." + "You'll find more details about the SDK on the [documentation](https://googleapis.github.io/python-genai/) or in the [Getting started](./Get_started.ipynb) notebook." ] }, { @@ -90,7 +88,17 @@ "metadata": { "id": "6Fr84vJuPSHb" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.1/43.1 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m222.6/222.6 kB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], "source": [ "%pip install -q -U \"google-genai>=1.0.0\"" ] @@ -129,7 +137,6 @@ "### Select model and initialize SDK client\n", "\n", "The client will pick up your API key from the environment variable.\n", - "To use the live API you need to set the client version to `v1alpha` and use the Gemini 2.0 model.\n", "\n", "Now select the model you want to use in this guide, either by selecting one in the list or writing it down. Keep in mind that some models, like the 2.5 ones are thinking models and thus take slightly more time to respond (cf. [thinking notebook](./Get_started_thinking.ipynb) for more details and in particular learn how to switch the thiking off)." ] @@ -168,14 +175,7 @@ "outputs": [ { "data": { - "text/markdown": [ - "Response:\n", - " The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, which took place on June 3, 2025.\n", - "\n", - "Royal Challengers Bengaluru (RCB) won their maiden IPL title by defeating Punjab Kings (PBKS) by 6 runs in that final match. The match was held at the Narendra Modi Stadium in Ahmedabad.The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, played on June 3, 2025, at the Narendra Modi Stadium in Ahmedabad.\n", - "\n", - "Royal Challengers Bengaluru (RCB) emerged victorious, winning their first-ever IPL title by defeating Punjab Kings (PBKS) by 6 runs." - ], + "text/markdown": "Response:\n The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, which took place on June 3, 2025.\n\nThe Royal Challengers Bengaluru (RCB) won their maiden IPL title by defeating the Punjab Kings (PBKS) by 6 runs in a thrilling final held at the Narendra Modi Stadium in Ahmedabad. Virat Kohli of RCB was the top scorer for his team in the final with 43 runs. Krunal Pandya was named Man of the Match for his economical bowling.", "text/plain": [ "" ] @@ -187,8 +187,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Search Query: ['latest Indian Premier League match and winner', 'IPL 2025 latest match and winner']\n", - "Search Pages: olympics.com, wikipedia.org, yahoo.com, hindustantimes.com, indiatimes.com, aljazeera.com\n" + "Search Query: ['latest Indian Premier League match and winner', 'IPL 2025 final match and winner']\n", + "Search Pages: olympics.com, thehindu.com, economictimes.com, wikipedia.org, skysports.com, olympics.com, wikipedia.org\n" ] }, { @@ -315,8 +315,8 @@ "
\n", " \n", "
\n", - " latest Indian Premier League match and winner\n", - " IPL 2025 latest match and winner\n", + " IPL 2025 final match and winner\n", + " latest Indian Premier League match and winner\n", "
\n", "\n" ], @@ -367,14 +367,7 @@ "outputs": [ { "data": { - "text/markdown": [ - "The latest Indian Premier League (IPL) match played was the **final of the 2024 season.**\n", - "\n", - "* **Teams:** **Kolkata Knight Riders (KKR)** vs. **Sunrisers Hyderabad (SRH)**\n", - "* **Winner:** **Kolkata Knight Riders (KKR)** won the match.\n", - "\n", - "KKR defeated SRH by 8 wickets to clinch their third IPL title. The final was played on May 26, 2024, at the M. A. Chidambaram Stadium in Chennai." - ], + "text/markdown": "The latest Indian Premier League match was the **final of the IPL 2024 season**, played on **May 26, 2024**.\n\nIt was contested between:\n* **Kolkata Knight Riders (KKR)**\n* **Sunrisers Hyderabad (SRH)**\n\n**Kolkata Knight Riders (KKR) won the match by 8 wickets**, securing their third IPL title.", "text/plain": [ "" ] @@ -461,13 +454,7 @@ "outputs": [ { "data": { - "text/markdown": [ - "The most recent significant game between Australia and Chinese Taipei was in **Men's Football (Soccer)** as part of the FIFA World Cup 2026 AFC Qualifiers.\n", - "\n", - "**Australia won the match against Chinese Taipei 1-0.**\n", - "\n", - "This game took place on **November 21, 2023**." - ], + "text/markdown": "The most recent game between Australia and Chinese Taipei was in **basketball**.\n\n* **FIBA Asia Cup Qualifiers**\n* **Date:** February 25, 2024\n* **Result:** **Australia** defeated Chinese Taipei 90-58.\n\nThey also played recently in **soccer (football)**:\n\n* **FIFA World Cup Qualifier**\n* **Date:** October 12, 2023\n* **Result:** **Australia** defeated Chinese Taipei 5-0.", "text/plain": [ "" ] @@ -502,25 +489,7 @@ "outputs": [ { "data": { - "text/markdown": [ - "Australia and Chinese Taipei have recently competed in various sports. Here's a summary of the most recent winners:\n", - "\n", - "**Volleyball:**\n", - "In women's volleyball, Australia defeated Chinese Taipei 3-1 (23-25, 25-15, 25-19, 25-18) in Pool A of the 2024 AVC Challenge Cup for Women on May 22, 2024.\n", - "\n", - "**Basketball:**\n", - "* In women's basketball, Australia won against Chinese Taipei with a score of 91-45 in the FIBA Women's Asia Cup on June 27, 2023.\n", - "* In the FIBA U18 Asia Cup 2024, Australia's men's team overwhelmingly defeated Chinese Taipei 113-48 on September 4, 2024.\n", - "* Australia's U17 Women's basketball team also beat Chinese Taipei 89-45 in the Round of 16 at the FIBA U17 Women's Basketball World Cup 2024 on July 17, 2024.\n", - "\n", - "**Baseball:**\n", - "Chinese Taipei defeated Australia 11-3 in the WBSC Premier12 2024 on November 17, 2024, securing their spot in the Super Round.\n", - "\n", - "**Soccer:**\n", - "The most recent matches for the women's teams show Australia consistently winning against Chinese Taipei. Australia Women defeated Chinese Taipei Women 6-0 on December 7, 2024, and 3-1 on December 4, 2024, in international friendlies. Another recent match saw Australia Women beat Chinese Taipei Women 3-0 on November 1, 2023, during the AFC Women's Olympic Qualifying Tournament.\n", - "\n", - "Due to the general nature of the query and the frequent competitions between these two nations across multiple sports, \"most recent\" can refer to different games depending on the sport." - ], + "text/markdown": "The most recent games between Australia and Chinese Taipei have seen varying results across different sports.\n\nIn **women's futsal**, Chinese Taipei secured a 1-0 victory over Australia in their final game of the AFC Women's Futsal Asian Cup on May 10, 2025.\n\nIn **baseball**, Chinese Taipei defeated Australia with a score of 11-3 in the WBSC Premier12 on November 17, 2024.\n\nIn **women's soccer**, Australia triumphed over Chinese Taipei with a 3-1 win in an international friendly on December 4, 2024.\n\nIn **men's volleyball**, Australia defeated Chinese Taipei 3-1 in the AVC Men's Nations Cup on June 22, 2025.\n\nIn **women's volleyball**, Chinese Taipei won 3-0 against Australia in the AVC Nations Cup Women on June 7, 2025.\n\nIn **men's basketball**, Australia defeated Chinese Taipei 90-71 in a FIBA Asia Qualifier game on February 24, 2022.\n\nIn **women's U18 basketball**, Australia secured a 90-67 victory against Chinese Taipei in the FIBA U18 Women's Asia Cup on June 26, 2024.", "text/plain": [ "" ] @@ -652,10 +621,9 @@ "
\n", " \n", "
\n", - " most recent Australia vs Chinese Taipei basketball results\n", - " most recent Australia vs Chinese Taipei soccer results\n", - " most recent Australia vs Chinese Taipei baseball results\n", - " most recent Australia vs Chinese Taipei volleyball results\n", + " Australia vs Chinese Taipei basketball most recent results national team\n", + " most recent Australia vs Chinese Taipei men's volleyball game result\n", + " Australia vs Chinese Taipei baseball most recent results national team\n", "
\n", "\n" ], @@ -698,28 +666,7 @@ "outputs": [ { "data": { - "text/markdown": [ - "Here are the goal scorers for the most recent Australia vs. Chinese Taipei women's soccer matches:\n", - "\n", - "**December 7, 2024 (Australia 6-0 Chinese Taipei):**\n", - "* Leah Davidson (6')\n", - "* Tameka Yallop (11')\n", - "* Emily Gielnik (40')\n", - "* Michelle Heyman (56')\n", - "* Natasha Prior (73')\n", - "* Sharn Freier (78')\n", - "\n", - "**December 4, 2024 (Australia 3-1 Chinese Taipei):**\n", - "* Natasha Prior (10')\n", - "* Sharn Freier (12')\n", - "* Chen Jin-Wen (34') for Chinese Taipei\n", - "* Bryleeh Henry (78')\n", - "\n", - "**November 1, 2023 (Australia 3-0 Chinese Taipei):**\n", - "* Mary Fowler (62')\n", - "* Sam Kerr (68')\n", - "* Tameka Yallop (76')" - ], + "text/markdown": "In the most recent games between Australia and Chinese Taipei where goals were scored:\n\n**Women's Soccer - December 4, 2024 (Australia 3-1 Chinese Taipei):**\nFor Australia, the goals were scored by Tash Prior, Sharn Freier, and Bryleeh Henry.\nChinese Taipei's lone goal was scored by Chen Jin-Wen.\n\n**Women's Futsal - May 10, 2025 (Chinese Taipei 1-0 Australia):**\nThe sole goal for Chinese Taipei was scored by Liu Chih-Ling.", "text/plain": [ "" ] @@ -851,9 +798,8 @@ "
\n", " \n", "
\n", - " Australia Women vs Chinese Taipei Women November 1 2023 goal scorers\n", - " Australia Women vs Chinese Taipei Women December 7 2024 goal scorers\n", - " Australia Women vs Chinese Taipei Women December 4 2024 goal scorers\n", + " Australia vs Chinese Taipei women's futsal May 10 2025 goal scorers\n", + " Australia vs Chinese Taipei women's soccer December 4 2024 goal scorers\n", "
\n", "\n" ], @@ -898,23 +844,7 @@ "outputs": [ { "data": { - "text/markdown": [ - "To plot the runtimes of the 10 most recent Denis Villeneuve movies, you can use the following Python code. The data for the movies and their runtimes has been compiled from various sources.\n", - "\n", - "Here are the 10 most recent Denis Villeneuve movies with their runtimes in minutes, from newest to oldest:\n", - "\n", - "* **Dune: Part Two (2024)**: 166 minutes\n", - "* **Dune: Part One (2021)**: 155 minutes\n", - "* **Blade Runner 2049 (2017)**: 163 minutes\n", - "* **Arrival (2016)**: 116 minutes\n", - "* **Sicario (2015)**: 121 minutes\n", - "* **Enemy (2013)**: 90 minutes\n", - "* **Prisoners (2013)**: 153 minutes\n", - "* **Incendies (2010)**: 131 minutes\n", - "* **Polytechnique (2009)**: 77 minutes\n", - "* **Maelström (2000)**: 87 minutes\n", - "\n" - ], + "text/markdown": "Denis Villeneuve's filmography showcases a diverse range of cinematic works, with his more recent films tending towards longer runtimes, particularly within the science fiction genre. Here are the 10 most recent feature films directed by Denis Villeneuve, along with their runtimes:\n\n* **Dune: Part Two** (2024): 166 minutes\n* **Dune** (2021): 155 minutes\n* **Blade Runner 2049** (2017): 163 minutes\n* **Arrival** (2016): 116 minutes\n* **Sicario** (2015): 121 minutes\n* **Prisoners** (2013): 153 minutes\n* **Enemy** (2013): 91 minutes\n* **Incendies** (2010): 131 minutes\n* **Polytechnique** (2009): 77 minutes\n* **Maelström** (2000): 87 minutes\n\nHere's Python code to plot the runtimes of these movies:\n\n", "text/plain": [ "" ] @@ -924,50 +854,7 @@ }, { "data": { - "text/markdown": [ - "```python\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Data for Denis Villeneuve's 10 most recent movies (from newest to oldest)\n", - "movies = [\n", - " \"Dune: Part Two (2024)\",\n", - " \"Dune: Part One (2021)\",\n", - " \"Blade Runner 2049 (2017)\",\n", - " \"Arrival (2016)\",\n", - " \"Sicario (2015)\",\n", - " \"Enemy (2013)\",\n", - " \"Prisoners (2013)\",\n", - " \"Incendies (2010)\",\n", - " \"Polytechnique (2009)\",\n", - " \"Maelström (2000)\"\n", - "]\n", - "\n", - "runtimes = [166, 155, 163, 116, 121, 90, 153, 131, 77, 87]\n", - "\n", - "# Create a bar chart\n", - "plt.figure(figsize=(12, 7)) # Adjust figure size for better readability\n", - "bars = plt.barh(movies, runtimes, color='skyblue')\n", - "\n", - "# Add labels and title\n", - "plt.xlabel(\"Runtime (minutes)\")\n", - "plt.ylabel(\"Movie Title\")\n", - "plt.title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\")\n", - "\n", - "# Invert y-axis to have the most recent movie at the top\n", - "plt.gca().invert_yaxis()\n", - "\n", - "# Add runtime values on top of the bars\n", - "for bar in bars:\n", - " width = bar.get_width()\n", - " plt.text(width + 2, bar.get_y() + bar.get_height()/2, f'{width} min', va='center')\n", - "\n", - "plt.xlim(0, max(runtimes) + 30) # Adjust x-axis limit for text\n", - "\n", - "plt.tight_layout() # Adjust layout to prevent labels from overlapping\n", - "plt.show()\n", - "```" - ], + "text/markdown": "```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# Data for Denis Villeneuve's 10 most recent movies and their runtimes\nmovies = [\n \"Dune: Part Two (2024)\",\n \"Dune (2021)\",\n \"Blade Runner 2049 (2017)\",\n \"Arrival (2016)\",\n \"Sicario (2015)\",\n \"Prisoners (2013)\",\n \"Enemy (2013)\",\n \"Incendies (2010)\",\n \"Polytechnique (2009)\",\n \"Maelström (2000)\"\n]\n\nruntimes = [166, 155, 163, 116, 121, 153, 91, 131, 77, 87] # Runtimes in minutes\n\n# Create the bar chart\nfig, ax = plt.subplots(figsize=(12, 7)) # Adjust figure size for better readability\nbars = ax.bar(movies, runtimes, color='skyblue')\n\n# Add titles and labels\nax.set_xlabel(\"Movie Title (Release Year)\", fontsize=12)\nax.set_ylabel(\"Runtime (Minutes)\", fontsize=12)\nax.set_title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\", fontsize=14)\nplt.xticks(rotation=45, ha='right') # Rotate x-axis labels for better readability\n\n# Add the runtime values on top of the bars\nfor bar in bars:\n yval = bar.get_height()\n ax.text(bar.get_x() + bar.get_width()/2, yval + 2, round(yval), ha='center', va='bottom', fontsize=9)\n\n# Improve layout and display the plot\nplt.tight_layout()\nplt.show()\n```", "text/plain": [ "" ] @@ -1099,7 +986,13 @@ "
\n", " \n", "
\n", - " Maelström Denis Villeneuve runtime\n", + " runtime Polytechnique 2009\n", + " runtime Enemy 2013\n", + " runtime Sicario 2015\n", + " runtime Prisoners 2013\n", + " runtime Maelström 2000\n", + " runtime August 32nd on Earth 1998\n", + " runtime Incendies 2010\n", "
\n", "\n" ], @@ -1145,49 +1038,46 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "# Data for Denis Villeneuve's 10 most recent movies (from newest to oldest)\n", + "# Data for Denis Villeneuve's 10 most recent movies and their runtimes\n", "movies = [\n", " \"Dune: Part Two (2024)\",\n", - " \"Dune: Part One (2021)\",\n", + " \"Dune (2021)\",\n", " \"Blade Runner 2049 (2017)\",\n", " \"Arrival (2016)\",\n", " \"Sicario (2015)\",\n", - " \"Enemy (2013)\",\n", " \"Prisoners (2013)\",\n", + " \"Enemy (2013)\",\n", " \"Incendies (2010)\",\n", " \"Polytechnique (2009)\",\n", " \"Maelström (2000)\"\n", "]\n", "\n", - "runtimes = [166, 155, 163, 116, 121, 90, 153, 131, 77, 87]\n", - "\n", - "# Create a bar chart\n", - "plt.figure(figsize=(12, 7)) # Adjust figure size for better readability\n", - "bars = plt.barh(movies, runtimes, color='skyblue')\n", + "runtimes = [166, 155, 163, 116, 121, 153, 91, 131, 77, 87] # Runtimes in minutes\n", "\n", - "# Add labels and title\n", - "plt.xlabel(\"Runtime (minutes)\")\n", - "plt.ylabel(\"Movie Title\")\n", - "plt.title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\")\n", + "# Create the bar chart\n", + "fig, ax = plt.subplots(figsize=(12, 7)) # Adjust figure size for better readability\n", + "bars = ax.bar(movies, runtimes, color='skyblue')\n", "\n", - "# Invert y-axis to have the most recent movie at the top\n", - "plt.gca().invert_yaxis()\n", + "# Add titles and labels\n", + "ax.set_xlabel(\"Movie Title (Release Year)\", fontsize=12)\n", + "ax.set_ylabel(\"Runtime (Minutes)\", fontsize=12)\n", + "ax.set_title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\", fontsize=14)\n", + "plt.xticks(rotation=45, ha='right') # Rotate x-axis labels for better readability\n", "\n", - "# Add runtime values on top of the bars\n", + "# Add the runtime values on top of the bars\n", "for bar in bars:\n", - " width = bar.get_width()\n", - " plt.text(width + 2, bar.get_y() + bar.get_height()/2, f'{width} min', va='center')\n", + " yval = bar.get_height()\n", + " ax.text(bar.get_x() + bar.get_width()/2, yval + 2, round(yval), ha='center', va='bottom', fontsize=9)\n", "\n", - "plt.xlim(0, max(runtimes) + 30) # Adjust x-axis limit for text\n", - "\n", - "plt.tight_layout() # Adjust layout to prevent labels from overlapping\n", + "# Improve layout and display the plot\n", + "plt.tight_layout()\n", "plt.show()\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1217,21 +1107,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 13, "metadata": { "id": "K0vk3ol5WMvN" }, "outputs": [ { "data": { - "text/markdown": [ - "It appears there might be a persistent issue in displaying the dark theme on your end, as I have included the `plt.style.use('dark_background')` line in the previous responses, which is designed to apply a dark theme to the plot.\n", - "\n", - "If `plt.style.use('dark_background')` is not producing the desired effect, we can explicitly set the background color of the figure and axes, and the color of the text elements, to ensure a dark theme is applied.\n", - "\n", - "Here's the updated Python code that explicitly sets these colors for a dark theme:\n", - "\n" - ], + "text/markdown": "To give the chart a dark theme, we can utilize Matplotlib's built-in `dark_background` style. This style automatically adjusts the background, text, and other elements for a dark aesthetic.\n\nHere's the modified Python code:\n\n", "text/plain": [ "" ] @@ -1241,74 +1124,159 @@ }, { "data": { - "text/markdown": [ - "```python\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Data for Denis Villeneuve's 10 most recent movies (from newest to oldest)\n", - "movies = [\n", - " \"Dune: Part Two (2024)\",\n", - " \"Dune: Part One (2021)\",\n", - " \"Blade Runner 2049 (2017)\",\n", - " \"Arrival (2016)\",\n", - " \"Sicario (2015)\",\n", - " \"Enemy (2013)\",\n", - " \"Prisoners (2013)\",\n", - " \"Incendies (2010)\",\n", - " \"Polytechnique (2009)\",\n", - " \"Maelström (2000)\"\n", - "]\n", - "\n", - "runtimes = [166, 155, 163, 116, 121, 90, 153, 131, 77, 87]\n", - "\n", - "# Create a figure and an axes object\n", - "fig, ax = plt.subplots(figsize=(12, 7))\n", - "\n", - "# Set the background color of the figure and axes for a dark theme\n", - "fig.set_facecolor('#1a1a1a') # Dark gray for the figure background\n", - "ax.set_facecolor('#2a2a2a') # Slightly lighter dark gray for the plot area background\n", - "\n", - "# Create a bar chart\n", - "# Using a light color for bars to contrast with the dark background\n", - "bars = ax.barh(movies, runtimes, color='skyblue')\n", - "\n", - "# Set label and title colors to white for visibility\n", - "ax.set_xlabel(\"Runtime (minutes)\", color='white')\n", - "ax.set_ylabel(\"Movie Title\", color='white')\n", - "ax.set_title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\", color='white')\n", - "\n", - "# Set tick label colors to white\n", - "ax.tick_params(axis='x', colors='white')\n", - "ax.tick_params(axis='y', colors='white')\n", - "\n", - "# Set spine colors to white\n", - "ax.spines['bottom'].set_color('white')\n", - "ax.spines['top'].set_color('white')\n", - "ax.spines['left'].set_color('white')\n", - "ax.spines['right'].set_color('white')\n", - "\n", - "# Invert y-axis to have the most recent movie at the top\n", - "ax.invert_yaxis()\n", - "\n", - "# Add runtime values on top of the bars\n", - "# Ensure text color is visible against the dark background\n", - "for bar in bars:\n", - " width = bar.get_width()\n", - " ax.text(width + 2, bar.get_y() + bar.get_height()/2, f'{width} min', va='center', color='white')\n", - "\n", - "ax.set_xlim(0, max(runtimes) + 30) # Adjust x-axis limit for text\n", - "\n", - "plt.tight_layout() # Adjust layout to prevent labels from overlapping\n", - "plt.show()\n", - "```" - ], + "text/markdown": "```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# Data for Denis Villeneuve's 10 most recent movies and their runtimes\nmovies = [\n \"Dune: Part Two (2024)\",\n \"Dune (2021)\",\n \"Blade Runner 2049 (2017)\",\n \"Arrival (2016)\",\n \"Sicario (2015)\",\n \"Prisoners (2013)\",\n \"Enemy (2013)\",\n \"Incendies (2010)\",\n \"Polytechnique (2009)\",\n \"Maelström (2000)\"\n]\n\nruntimes = [166, 155, 163, 116, 121, 153, 91, 131, 77, 87] # Runtimes in minutes\n\n# Apply the dark background style\nplt.style.use('dark_background') # [2, 4, 5]\n\n# Create the bar chart\nfig, ax = plt.subplots(figsize=(12, 7)) # Adjust figure size for better readability\nbars = ax.bar(movies, runtimes, color='skyblue') # Skyblue works well against dark background\n\n# Add titles and labels\nax.set_xlabel(\"Movie Title (Release Year)\", fontsize=12, color='white')\nax.set_ylabel(\"Runtime (Minutes)\", fontsize=12, color='white')\nax.set_title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\", fontsize=14, color='white')\nplt.xticks(rotation=45, ha='right', color='white') # Rotate x-axis labels for better readability\nplt.yticks(color='white') # Set y-axis tick label color\n\n# Add the runtime values on top of the bars\nfor bar in bars:\n yval = bar.get_height()\n ax.text(bar.get_x() + bar.get_width()/2, yval + 2, round(yval), ha='center', va='bottom', fontsize=9, color='white')\n\n# Improve layout and display the plot\nplt.tight_layout()\nplt.show()\n```", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": "\n\nBy adding `plt.style.use('dark_background')`, the plot's background becomes dark, and the text and axes elements automatically adjust to a lighter color for better readability. I've also explicitly set the color of the labels and title to white for clarity, although `dark_background` often handles this default.", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + " matplotlib dark theme example\n", + " matplotlib dark_background style color changes\n", + "
\n", + "
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -1328,14 +1296,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 14, "metadata": { "id": "vtfTv4ieFjYt" }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1367,7 +1335,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 15, "metadata": { "id": "CUhcThmnK0mt" }, @@ -1395,7 +1363,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 16, "metadata": { "id": "YEAdoUV2dH1o" }, @@ -1503,7 +1471,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 17, "metadata": { "id": "0wXCugI3eOtS" }, @@ -1512,7 +1480,7 @@ "name": "stderr", "output_type": "stream", "text": [ - ":81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", + "/tmp/ipython-input-4150174230.py:81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n", " await strm.send(input=query, end_of_turn=True)\n" ] @@ -1593,7 +1561,6 @@ "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" ] }, @@ -1601,7 +1568,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "......." + "......" ] }, { @@ -1706,7 +1673,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" ] @@ -1715,7 +1681,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "....\n" + "...\n" ] }, { @@ -1723,7 +1689,7 @@ "text/html": [ "\n", " \n", " " @@ -1751,7 +1717,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 18, "metadata": { "id": "HYGEtdjupXM7" }, @@ -1760,7 +1726,7 @@ "name": "stderr", "output_type": "stream", "text": [ - ":81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", + "/tmp/ipython-input-4150174230.py:81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n", " await strm.send(input=query, end_of_turn=True)\n" ] @@ -1777,20 +1743,7 @@ "output_type": "stream", "text": [ "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['executable_code'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['code_execution_result'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] @@ -1799,7 +1752,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "." + ".." ] }, { @@ -1842,24 +1795,6 @@ "......." ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "....." - ] - }, { "name": "stderr", "output_type": "stream", @@ -1908,6 +1843,8 @@ "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", + "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", + "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" ] }, @@ -1915,7 +1852,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "....." + "......." ] }, { @@ -1945,7 +1882,6 @@ "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" ] }, @@ -1953,87 +1889,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "....." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "..........\n" + ".....\n" ] }, { @@ -2041,7 +1897,7 @@ "text/html": [ "\n", " \n", " " @@ -2069,7 +1925,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 22, "metadata": { "id": "_UUZ5V_Upzpm" }, @@ -2097,7 +1953,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 30, "metadata": { "id": "7-nQ1Sp9yM33" }, @@ -2106,7 +1962,7 @@ "name": "stderr", "output_type": "stream", "text": [ - ":81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", + "/tmp/ipython-input-4150174230.py:81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n", " await strm.send(input=query, end_of_turn=True)\n" ] @@ -2123,20 +1979,7 @@ "output_type": "stream", "text": [ "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['executable_code'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['code_execution_result'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] @@ -2145,200 +1988,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - ":55: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", - "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n", - " await stream.send(input=tool_response)\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ".....Tool call..." + ".." ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "....." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['executable_code'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", + "/tmp/ipython-input-4150174230.py:55: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", + "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n", + " await stream.send(input=tool_response)\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['code_execution_result'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] @@ -2347,7 +2008,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "......." + ".Tool call.." ] }, { @@ -2397,21 +2058,6 @@ "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "....." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" @@ -2421,7 +2067,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "....\n" + ".......\n" ] }, { @@ -2429,7 +2075,7 @@ "text/html": [ "\n", " \n", " " @@ -2475,7 +2121,7 @@ "\n", "tools = {'tools': [search_tool, set_climate_tool]}\n", "\n", - "responses = await run(\"Look up the weather in Paris using search and set my climate control appropriately.\", tools)" + "responses = await run(\"Look up the weather in Paris using search and set my climate control appropriately. I trust your judgement, so just do it.\", tools)" ] }, { @@ -2489,7 +2135,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 31, "metadata": { "id": "ZzZlE9IFnwpS" }, @@ -2498,7 +2144,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "set_climate(strength=3, mode=cold) # id=function-call-12389289546227236364\n" + "set_climate(mode=cold, strength=7) # id=function-call-8243969279664206973\n" ] } ], @@ -2520,6 +2166,8 @@ "\n", "\n", "\n", + "Search grounding is not the only way to ground your requests, you can also use Youtube links and URL context. Check the [Grounding](./Grounding.ipynb) guide for more info on those capabilities.\n", + "\n", "* For more demos showcasing multi-tool use in the Multimodal Live API, check out the [Plotting and Mapping cookbook](../examples/LiveAPI_plotting_and_mapping.ipynb).\n", "* To get started with the Live API with the Python SDK, check out the [starter guide](./Get_started_LiveAPI.ipynb).\n", "* To learn more about tool use in the Live API, check out the [Live API Tool Use cookbook](./Get_started_LiveAPI_tools.ipynb).\n", From 8ac11a06b42916574873102342a8e69977b776d8 Mon Sep 17 00:00:00 2001 From: Guillaume Vernade Date: Fri, 8 Aug 2025 14:11:47 +0000 Subject: [PATCH 2/8] Adding more URL context examples (pdf; images, search+url context) Also doing some cleanup. --- quickstarts/Grounding.ipynb | 564 +++++++++++++++++++++--------------- 1 file changed, 332 insertions(+), 232 deletions(-) diff --git a/quickstarts/Grounding.ipynb b/quickstarts/Grounding.ipynb index 890309806..6ba4fddad 100644 --- a/quickstarts/Grounding.ipynb +++ b/quickstarts/Grounding.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": { "cellView": "form", "id": "tuOe1ymfHZPu" @@ -60,9 +60,9 @@ "Information grounding is the process of connecting these models to specific, verifiable information sources to enhance the accuracy, relevance, and factual correctness of their responses. While LLMs are trained on vast amounts of data, this knowledge can be general, outdated, or lack specific context for particular tasks or domains. Grounding helps to bridge this gap by providing the LLM with access to curated, up-to-date information.\n", "\n", "Here you will experiment with:\n", - "- Grounding information using Google Search grounding\n", - "- Adding YouTube links to gather context information to your prompt\n", - "- Using URL context to include website URL as context to your prompt" + "- Grounding information using Google Search grounding\n", + "- Adding YouTube links to gather context information to your prompt\n", + "- Using URL context to include website, pdf or image URLs as context to your prompt" ] }, { @@ -71,9 +71,7 @@ "id": "vKu1tRBrQ7xj" }, "source": [ - "## Set up the SDK\n", - "\n", - "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini models." + "## Set up the SDK and the client" ] }, { @@ -84,14 +82,12 @@ "source": [ "### Install SDK\n", "\n", - "The **[Google Gen AI SDK](https://github.com/googleapis/python-genai)** provides programmatic access to Gemini models using both the [Google AI for Developers](https://ai.google.dev/gemini-api/docs/models/) and [Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/overview) APIs. With a few exceptions, code that runs on one platform will run on both. This means that you can prototype an application using the Developer API and then migrate the application to Vertex AI without rewriting your code.\n", - "\n", - "More details about this new SDK on the [documentation](https://googleapis.github.io/python-genai/) or in the [Getting started](./Get_started.ipynb) notebook." + "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini models." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": { "id": "6Fr84vJuPSHb" }, @@ -113,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 28, "metadata": { "id": "RjvgYmdLQd5s" }, @@ -137,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 29, "metadata": { "id": "C75s1LR9QmOz" }, @@ -148,7 +144,7 @@ "\n", "client = genai.Client(api_key=GOOGLE_API_KEY)\n", "\n", - "MODEL_ID = \"gemini-2.5-flash\" # @param [\"gemini-2.5-flash\", \"gemini-2.5-pro\", \"gemini-2.5-flash-lite\", \"gemini-2.0-flash\",] {\"allow-input\":true, isTemplate: true}" + "MODEL_ID = \"gemini-2.0-flash\" # @param [\"gemini-2.5-flash-lite\",\"gemini-2.0-flash\",\"gemini-2.5-pro\"] {\"allow-input\":true}" ] }, { @@ -158,24 +154,33 @@ }, "source": [ "## Use Google Search grounding\n", - "Google Search grounding is particularly useful for queries that require current information or external knowledge. Using Google Search, Gemini can access nearly real-time information and better responses." + "\n", + "\n", + "\n", + "Google Search grounding is particularly useful for queries that require current information or external knowledge. Using Google Search, Gemini can access nearly real-time information and better responses.\n", + "\n", + "To enable Google Search, simply add the `google_search` tool in the `generate_content`'s `config` that way:\n", + "```\n", + " config={\n", + " \"tools\": [\n", + " {\n", + " \"google_search\": {}\n", + " }\n", + " ]\n", + " },\n", + "```" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 30, "metadata": { "id": "FHIcazUO0-xU" }, "outputs": [ { "data": { - "text/markdown": [ - "Response:\n", - " The latest Indian Premier League (IPL) match, which was the final of the 2024 season, took place on May 26, 2024.\n", - "\n", - "In this match, the Kolkata Knight Riders (KKR) defeated the Sunrisers Hyderabad (SRH) by 8 wickets to win their third IPL title. The Sunrisers Hyderabad were bundled out for 113 runs, which was the lowest total in an IPL final." - ], + "text/markdown": "**Response**:\n The latest Indian Premier League (IPL) match was the final of the 2025 season, played on June 3, 2025, at the Narendra Modi Stadium in Ahmedabad. The Royal Challengers Bengaluru (RCB) won the match by 6 runs against the Punjab Kings (PBKS). This was the Royal Challengers Bengaluru's first IPL title.\n", "text/plain": [ "" ] @@ -187,8 +192,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Search Query: ['latest Indian Premier League match and winner', 'When did IPL 2024 end?']\n", - "Search Pages: wikipedia.org, jagranjosh.com, livemint.com, thehindu.com\n" + "Search Query: ['latest Indian Premier League match who won']\n", + "Search Pages: business-standard.com, iplt20.com, business-standard.com, wikipedia.org, thehindu.com\n" ] }, { @@ -315,8 +320,7 @@ "
\n", " \n", "
\n", - " latest Indian Premier League match and winner\n", - " When did IPL 2024 end?\n", + " latest Indian Premier League match who won\n", "
\n", "\n" ], @@ -338,7 +342,7 @@ ")\n", "\n", "# print the response\n", - "display(Markdown(f\"Response:\\n {response.text}\"))\n", + "display(Markdown(f\"**Response**:\\n {response.text}\"))\n", "# print the search details\n", "print(f\"Search Query: {response.candidates[0].grounding_metadata.web_search_queries}\")\n", "# urls used for grounding\n", @@ -358,19 +362,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 31, "metadata": { "id": "EdUkQ40cKaGX" }, "outputs": [ { "data": { - "text/markdown": [ - "The latest Indian Premier League match played was the **final of the 2024 season**, which took place on **May 26, 2024**.\n", - "\n", - "**Match:** Sunrisers Hyderabad (SRH) vs. Kolkata Knight Riders (KKR)\n", - "**Winner:** **Kolkata Knight Riders (KKR)** won by 8 wickets." - ], + "text/markdown": "As an AI, I am unable to provide you with real-time information, including live IPL match results. The information changes rapidly. \n\nTo find the latest IPL match result, I recommend checking these resources:\n\n* **Official IPL Website:** The official IPL website is the most reliable source.\n* **Reputable Sports News Websites/Apps:** Sites like ESPNcricinfo, and others will have up-to-the-minute scores and match reports.\n* **Sports Apps:** Many sports apps (e.g., ESPN, etc.) provide live scores and updates.\n\nThese sources will give you the accurate result of the most recent IPL match.", "text/plain": [ "" ] @@ -391,6 +390,15 @@ "display(Markdown(response.text))" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "fE6Ft1wxSxO_" + }, + "source": [ + "For more examples, please refer to the [dedicated notebook](./Search_Grounding.ipynb)." + ] + }, { "cell_type": "markdown", "metadata": { @@ -399,38 +407,30 @@ "source": [ "## Grounding with YouTube links\n", "\n", + "\n", + "\n", "you can directly include a public YouTube URL in your prompt. The Gemini models will then process the video content to perform tasks like summarization and answering questions about the content.\n", "\n", "This capability leverages Gemini's multimodal understanding, allowing it to analyze and interpret video data alongside any text prompts provided.\n", "\n", - "You do need to explicitly declare the video URL you want the model to process as part of the contents of the request. Here a simple interaction where you ask the model to summarize a YouTube video:" + "You do need to explicitly declare the video URL you want the model to process as part of the contents of the request using a `FileData` part. Here a simple interaction where you ask the model to summarize a YouTube video:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 32, "metadata": { "id": "akVTribOkgT2" }, "outputs": [ { "data": { - "text/markdown": [ - "This video introduces \"Gemma Chess,\" a new application of Google DeepMind's Gemma language model to the game of chess. The speaker, Ju-yeong Ji, explains that unlike traditional chess engines (like AlphaZero) which are \"super smart calculators\" focused on finding the best moves, Gemma aims to add a \"new dimension\" by leveraging its ability to understand and generate human-like text.\n", - "\n", - "Gemma's key applications in chess include:\n", - "\n", - "1. **Explaining Chess:** It can analyze complex games (like Kasparov vs. Deep Blue) and explain *why* specific moves are significant, detailing strategies, tactical opportunities, and potential dangers in plain language, rather than just technical move sequences or numbers.\n", - "2. **Storytelling:** Gemma can transform chess game data into engaging narratives, describing the flow of matches, the players involved, and the overall dramatic arc, making the games more accessible and relatable.\n", - "3. **Supporting Chess Learning:** It acts as a \"super helpful study buddy,\" explaining chess concepts (e.g., Sicilian Defense, passed pawn) in natural language, adapting to the user's skill level (beginner, intermediate, advanced), and even offering explanations in different languages. This provides a personalized, 24/7 \"chess coach.\"\n", - "\n", - "In summary, Gemma combines the computational power of chess AI with advanced linguistic understanding, offering a more intuitive and human-centric way to learn, analyze, and experience chess." - ], + "text/markdown": "Ju-yeong Ji, from Google Deepmind, discusses in this video some ways Gemma Chess can be applied to the world of Chess to add a new dimension to the game.\n\nHe says that Gemma, a language model, can be used to make Chess easier to understand by taking all the technical information and turning it into plain text.\nGemma can also tell stories about Chess games. \nAnd Gemma can act like a 24/7 Chess study buddy or personal Chess coach and answer questions in your native language.\nIt is also possible to combine the analytical strengths of Chess AI with Gemma's linguistic skills for a more intuitive approach to learning and analysis.", "text/plain": [ "" ] }, - "execution_count": 6, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -444,7 +444,9 @@ " parts=[\n", " types.Part(text=\"Summarize this video.\"),\n", " types.Part(\n", - " file_data=types.FileData(file_uri=yt_link)\n", + " file_data=types.FileData(\n", + " file_uri=yt_link\n", + " )\n", " )\n", " ]\n", " )\n", @@ -464,67 +466,34 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 33, "metadata": { - "id": "ZgNZ2ZCtzLU8" + "id": "UTH4DqBAzx3H" }, "outputs": [ { "data": { - "text/markdown": [ - "Gemma models, as Large Language Models (LLMs), don't play chess directly like dedicated chess engines (e.g., Stockfish, AlphaZero). They lack the internal game tree search, move validation, and evaluation functions that chess engines possess.\n", - "\n", - "However, Gemma's strengths lie in its ability to understand, generate, and process human language, which can be immensely helpful in various aspects of chess learning, analysis, and communication. Think of Gemma as a powerful analytical and educational *companion* rather than an opponent or a direct player.\n", - "\n", - "Here's how Gemma models can help in chess games:\n", - "\n", - "1. **Learning and Understanding Chess Concepts:**\n", - " * **Explaining Rules and Mechanics:** For beginners, Gemma can clearly explain how pieces move, special rules (castling, en passant), and basic objectives.\n", - " * **Defining Terminology:** Ask Gemma to explain terms like \"zugzwang,\" \"fork,\" \"skewer,\" \"pawn structure,\" \"tempo,\" \"initiative,\" \"desperado,\" etc.\n", - " * **Illustrating Concepts with Examples:** Gemma can describe positions or sequences of moves that demonstrate specific tactics or strategic ideas.\n", - " * **Opening and Endgame Theory:** While not an exhaustive database, Gemma can summarize the main ideas, common lines, and strategic goals behind various openings (e.g., \"Explain the ideas behind the Sicilian Defense\" or \"What are the basic principles of king and pawn vs. king endgames?\").\n", - "\n", - "2. **Post-Game Analysis and Improvement:**\n", - " * **Interpreting Engine Analysis:** If you have an engine's output (like a FEN string with an evaluation, or a recommended move sequence), Gemma can help translate that into human-understandable explanations. For example, \"Why does Stockfish recommend this move in this FEN?\" or \"Explain the tactical idea behind this engine line.\"\n", - " * **Summarizing Game Logs (PGNs):** You can feed a PGN (Portable Game Notation) to Gemma and ask it to summarize the key moments, critical mistakes, turning points, or strategic themes of the game.\n", - " * **Identifying Common Mistakes (with context):** If you describe your typical errors (e.g., \"I often blunder pawns in the middlegame\"), Gemma can offer general advice or common reasons why such mistakes occur, or suggest drills.\n", - " * **Explaining Tactical Puzzles:** If you describe a chess puzzle position (FEN or visual description), Gemma can explain the solution, the underlying tactical motif, and why other moves don't work.\n", - "\n", - "3. **Strategic Planning and Brainstorming:**\n", - " * **Developing Game Plans:** Given a specific opening or middlegame position, Gemma can brainstorm potential strategic plans for both sides, considering factors like pawn structures, piece activity, and king safety.\n", - " * **Opponent Analysis (with input):** If you provide information about an opponent's past games or playing style, Gemma could help summarize their tendencies or suggest counter-strategies (e.g., \"My opponent often plays the Caro-Kann; what are some aggressive lines to consider against it?\").\n", - " * **Generating Ideas:** For a complex position, Gemma can suggest different strategic approaches, even if it can't calculate the precise best move.\n", - "\n", - "4. **Content Creation and Communication:**\n", - " * **Generating Commentary:** Gemma can help write descriptive commentary for a chess game, explaining moves, player intentions, and the flow of the match.\n", - " * **Creating Study Material:** It can help generate questions, explanations, or summaries for chess lessons or study guides.\n", - " * **Translating Chess Content:** If you have chess articles, videos, or commentary in a foreign language, Gemma can assist with translation.\n", - "\n", - "**Important Limitations to Keep in Mind:**\n", - "\n", - "* **Gemma is NOT a Chess Engine:** It cannot play chess, calculate moves, validate moves, or perform the deep search required for optimal play. Its \"understanding\" of chess comes from text data, not a game engine's algorithms.\n", - "* **No Real-time Assistance (Ethical/Practical):** Using Gemma during a live game for move suggestions would be cheating. Its utility is primarily for learning, analysis, and preparation *outside* of live play.\n", - "* **Relies on Input:** Gemma needs clear and accurate input (FEN, PGN, detailed descriptions) to provide useful chess-related responses. It cannot \"see\" a chessboard.\n", - "* **Hallucinations/Inaccuracies:** Like any LLM, Gemma can sometimes generate plausible but incorrect information. Always cross-reference critical chess advice with dedicated chess engines or trusted human experts.\n", - "* **Knowledge Cutoff:** Gemma's training data has a cutoff, meaning it might not be aware of the absolute latest developments in opening theory or recent games.\n", - "\n", - "In summary, Gemma models are excellent linguistic tools that can demystify complex chess concepts, aid in post-game analysis by interpreting engine output, and assist in strategic planning and content creation. They serve as an intelligent assistant for learning and understanding the game, rather than a player or a direct tactical calculator." - ], + "text/markdown": "Okay, here's a summary of how the Gemma model can help with Chess games in 2 paragraphs:\n\nFirstly, Gemma can be used to make Chess analysis easier to understand. When traditional engines display results in numeric and abstract move sequences, Gemma can convert these results into a plain text explanation that describes strategic and tactical advantages. This could include why a move is good, dangers, or summaries of difficult portions of the game. \n\nSecondly, Gemma can help tell stories about Chess games. Gemma can analyze a game's moves, players, tournament and then describe the game in words that bring it to life. If you're trying to get better at Chess, Gemma could help you study your strategy, understand your ideas in real time or learn about chess defenses in different languages.", "text/plain": [ "" ] }, - "execution_count": 7, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "yt_link = \"https://www.youtube.com/watch?v=XV1kOFo1C8M\"\n", + "\n", "response = client.models.generate_content(\n", " model=MODEL_ID,\n", - " contents= types.Content(\n", + " contents=types.Content(\n", " parts=[\n", - " types.Part(text=\"How Gemma models can help on chess games?\"),\n", + " types.Part(text=\"In 2 paragraph, how Gemma models can help on chess games?\"),\n", + " types.Part(\n", + " file_data=types.FileData(file_uri=yt_link)\n", + " )\n", " ]\n", " )\n", ")\n", @@ -535,126 +504,157 @@ { "cell_type": "markdown", "metadata": { - "id": "whgRdJx4ztg0" + "id": "RHhdfKqLz_D6" }, "source": [ - "And then you can ask the same question, now having the YouTube video as context to be used by the model:" + "Now your answer is more insightful for the topic you want, using the knowledge shared on the video and not necessarily available on the model knowledge." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mKBPhxA-0RiT" + }, + "source": [ + "## Grounding information using URL context\n", + "\n", + "\n", + "\n", + "The URL Context tool empowers Gemini models to directly access and process content from specific web page URLs you provide within your API requests. This is incredibly interesting because it allows your applications to dynamically interact with live web information without needing you to manually pre-process and feed that content to the model.\n", + "\n", + "URL Context is effective because it allows the models to base its responses and analysis directly on the content of the designated web pages. Instead of relying solely on its general training data or broad web searches (which are also valuable grounding tools), URL Context anchors the model's understanding to the specific information present at those URLs." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Y7GrocBgYgrp" + }, + "source": [ + "### Process website URLs\n", + "\n", + "If you want Gemini to specifically ground its answers thanks to the content of a specific website, just add the urls in your prompt and enable the tool by adding it to your config:\n", + "```\n", + "config = {\n", + " \"tools\": [\n", + " {\n", + " \"url_context\": {}\n", + " }\n", + " ],\n", + "}\n", + "```\n", + "\n", + "You can add up to 20 links in your prompt." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 45, "metadata": { - "id": "UTH4DqBAzx3H" + "id": "eOXM1Fh2D9Ai" }, "outputs": [ { "data": { - "text/markdown": [ - "Gemma models, as large language models (LLMs), can significantly enhance the chess experience by leveraging their natural language understanding and generation capabilities, rather than directly calculating the best moves like traditional chess engines.\n", - "\n", - "Here's how Gemma can help in chess games, based on the video:\n", - "\n", - "1. **Enhanced Analysis and Explanation (The Explainer):**\n", - " * **Translating Complexity:** Traditional chess engines often provide numerical evaluations and complex move sequences (like \"Nf3 d5 2.g3 Bg4\"). Gemma can take this technical output and translate it into plain, human-understandable text.\n", - " * **Explaining \"Why\":** Instead of just showing a move, Gemma can explain the *strategic ideas* and *tactical reasons* behind a move. For example, it can explain why a pawn sacrifice is interesting due to disrupting the opponent's plans or its psychological impact.\n", - " * **Summarizing Key Moments:** For long or complicated games, Gemma can pick out the most important tactical and strategic moments, helping players quickly grasp the critical turning points.\n", - "\n", - "2. **Interactive Learning and Coaching (Supporting Chess Learning):**\n", - " * **Personalized Explanations:** Gemma can act as a \"study buddy\" or \"personal chess coach.\" You can ask it to explain chess concepts (like the \"Sicilian Defense\" or a \"passed pawn\") and it can tailor the explanation to your skill level (beginner, intermediate, advanced).\n", - " * **Multilingual Support:** As demonstrated in the video, Gemma can understand and explain concepts in various languages (e.g., Korean), making chess learning more accessible globally.\n", - " * **Targeted Feedback:** It can provide feedback on your understanding of chess ideas and even suggest areas where you might want to improve.\n", - "\n", - "3. **Storytelling and Narrative Generation (Storytellers):**\n", - " * **Bringing Games to Life:** Gemma can take the raw data of a chess game (like PGN notation, including player names and tournament info) and weave it into a compelling narrative or short story.\n", - " * **Adding Human Context:** It can describe the atmosphere of a match, infer hypothetical thoughts or emotions of the players, and highlight dramatic turns, making the game more engaging and relatable than just a sequence of moves. This is like getting a \"cool backstory\" for a puzzle, making it more interesting.\n", - "\n", - "4. **Combining Strengths (Hybrid Approach):**\n", - " * **Complementing Engines:** By integrating with traditional chess engines (which excel at calculation), Gemma can take the optimal moves identified by the engine and then *explain* the reasoning behind them in natural language. This blends the raw computational power of chess AI with the human-like understanding and communication of an LLM, offering a more intuitive and insightful analysis experience.\n", - "\n", - "In essence, Gemma models don't play chess themselves, but they act as an intelligent interpreter and communicator, making chess analysis, learning, and enjoyment more accessible and profound for human players." - ], + "text/markdown": "The Gemini API offers several model variants, each optimized for specific use cases and capabilities. Here's a comparison of key differences between Gemini 1.5, Gemini 2.0, and Gemini 2.5 models:\n\n| Feature | Gemini 1.5 Pro | Gemini 1.5 Flash | Gemini 2.0 Flash | Gemini 2.5 Pro | Gemini 2.5 Flash |\n| :---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------ |\n| **Optimization** | Mid-size multimodal model optimized for a wide range of reasoning tasks; processes large amounts of data (2 hours video, 19 hours audio, 60,000 lines code, 2,000 pages text). | Fast and versatile multimodal model for scaling across diverse tasks. | Delivers next-gen features, superior speed, native tool use, and a 1M token context window. | Our most powerful thinking model with maximum response accuracy and state-of-the-art performance. | Best in terms of price-performance, offering well-rounded capabilities. Optimized for low latency, high volume tasks that require thinking. |\n| **Input(s)** | Audio, images, video, and text. | Audio, images, video, and text. | Audio, images, video, and text. | Audio, images, video, text, and PDF. | Audio, images, video, and text. |\n| **Output(s)** | Text. | Text. | Text. | Text. | Text. |\n| **Token Limits** | Input: 2,097,152 tokens. Output: 8,192 tokens. | Input: 1,048,576 tokens. Output: 8,192 tokens. | Input: 1,048,576 tokens. Output: 8,192 tokens. | Input: 1,048,576 tokens. Output: 65,536 tokens. | Input: 1,048,576 tokens. Output: 65,536 tokens. |\n| **Capabilities** | System instructions, JSON mode, JSON schema, adjustable safety settings, caching, tuning, function calling, code execution. | System instructions, JSON mode, JSON schema, adjustable safety settings, caching, tuning, function calling, code execution. | Structured outputs, caching, function calling, code execution, search. Thinking is experimental. Live API supported. | Structured outputs, caching, function calling, code execution, search grounding, thinking. Batch Mode supported. | Structured outputs, caching, code execution, function calling, search grounding, thinking. Batch Mode supported. |\n| **Primary Use Case** | Complex reasoning tasks, analyzing large datasets, codebases, and documents. | Scaling across diverse tasks. | Next-gen features, speed, and real-time streaming. | Complex coding, reasoning, and multimodal understanding. | Large-scale processing, low-latency, high-volume tasks that require thinking, agentic use cases. |\n", "text/plain": [ "" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "yt_link = \"https://www.youtube.com/watch?v=XV1kOFo1C8M\"\n", + "prompt = \"\"\"\n", + " Based on https://ai.google.dev/gemini-api/docs/models, what are the key\n", + " differences between Gemini 1.5, Gemini 2.0 and Gemini 2.5 models?\n", + " Create a markdown table comparing the differences.\n", + "\"\"\"\n", + "\n", + "config = {\n", + " \"tools\": [{\"url_context\": {}}],\n", + "}\n", "\n", "response = client.models.generate_content(\n", + " contents=[prompt],\n", " model=MODEL_ID,\n", - " contents= types.Content(\n", - " parts=[\n", - " types.Part(text=\"How Gemma models can help on chess games?\"),\n", - " types.Part(\n", - " file_data=types.FileData(file_uri=yt_link)\n", - " )\n", - " ]\n", - " )\n", + " config=config\n", ")\n", "\n", - "Markdown(response.text)" + "display(Markdown(response.text))" ] }, { "cell_type": "markdown", "metadata": { - "id": "RHhdfKqLz_D6" + "id": "rS2xyoMPY8u-" }, "source": [ - "Now your answer is more insightful for the topic you want, using the knowledge shared on the video and not necessarily available on the model knowledge." + "### Add PDFs by URL\n", + "\n", + "Gemini can also process PDFs from an URL. Here's an example:" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 35, "metadata": { - "id": "mKBPhxA-0RiT" + "id": "SeMZX5C5sLe3" }, + "outputs": [ + { + "data": { + "text/markdown": "Alphabet Inc. announced its Q2 2025 financial results, reporting a 14% increase in consolidated revenues to \\$96.4 billion. Google Services revenues grew by 12% to \\$82.5 billion, driven by Google Search & other, YouTube ads, and Google subscriptions. Google Cloud revenues increased by 32% to \\$13.6 billion, fueled by growth in Google Cloud Platform. The total operating income increased by 14%, with an operating margin of 32.4%. Net income rose by 19%, and EPS increased by 22% to \\$2.31.\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## Grounding information using URL context\n", + "prompt = \"\"\"\n", + " Can you give me an overview of the content of this pdf?\n", + " https://abc.xyz/assets/cc/27/3ada14014efbadd7a58472f1f3f4/2025q2-alphabet-earnings-release.pdf\n", "\n", - "The URL Context tool empowers Gemini models to directly access and process content from specific web page URLs you provide within your API requests. This is incredibly interesting because it allows your applications to dynamically interact with live web information without needing you to manually pre-process and feed that content to the model.\n", + "\"\"\"\n", "\n", - "URL Context is effective because it allows the models to base its responses and analysis directly on the content of the designated web pages. Instead of relying solely on its general training data or broad web searches (which are also valuable grounding tools), URL Context anchors the model's understanding to the specific information present at those URLs." + "config = {\n", + " \"tools\": [{\"url_context\": {}}],\n", + "}\n", + "\n", + "response = client.models.generate_content(\n", + " contents=[prompt],\n", + " model=MODEL_ID,\n", + " config=config\n", + ")\n", + "\n", + "display(Markdown(response.text.replace('$','\\$')))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vAkMWXwAxiaT" + }, + "source": [ + "### Add images by URL\n", + "\n", + "Gemini can also process images from an URL. Here's an example:" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 47, "metadata": { - "id": "eOXM1Fh2D9Ai" + "id": "HPNxQYkx8WJN" }, "outputs": [ { "data": { - "text/markdown": [ - "Here's a comparison of key differences between Gemini 1.5, Gemini 2.0, and Gemini 2.5 models based on the provided documentation:\n", - "\n", - "| Feature | Gemini 1.5 Pro | Gemini 1.5 Flash | Gemini 2.0 Flash | Gemini 2.5 Pro (Preview) | Gemini 2.5 Flash (Preview) |\n", - "| :---------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n", - "| **Optimization/Purpose** | Mid-size multimodal model optimized for a wide range of reasoning tasks, capable of processing large amounts of data (e.g., 2 hours of video, 19 hours of audio, 60,000 lines of code, or 2,000 pages of text). | Fast and versatile performance across a diverse variety of tasks. | Newest multimodal model with next-generation features, improved capabilities, low latency, enhanced performance, built to power agentic experiences. | Our most powerful thinking model with maximum response accuracy and state-of-the-art performance, best for complex coding, reasoning, and multimodal understanding, and analyzing large databases. | Our best model in terms of price-performance, offering well-rounded capabilities, best for low latency, high volume tasks that require thinking. |\n", - "| **Input Modalities** | Audio, images, video, and text. | Audio, images, video, and text. | Audio, images, video, and text. | Audio, images, video, and text. | Audio, images, video, and text. |\n", - "| **Output Modalities** | Text. | Text. | Text. | Text. | Text. |\n", - "| **Input Token Limit** | 2,097,152. | 1,048,576. | 1,048,576. | 1,048,576. | 1,048,576. |\n", - "| **Output Token Limit** | 8,192. | 8,192. | 8,192. | 65,536. | 65,536. |\n", - "| **Key Capabilities** | Handles complex reasoning tasks, large datasets, and long context. | Fast and versatile performance. | Next-gen features, speed, thinking, real-time streaming, built for agentic experiences. | Enhanced thinking and reasoning, multimodal understanding, advanced coding. | Adaptive thinking, cost efficiency, with well-rounded capabilities. |\n", - "| **Latest Update** | September 2024. | September 2024. | February 2025. | May 2025. | May 2025. |\n", - "\n", - "**Summary of Key Differences:**\n", - "\n", - "* **Generational Advancements**: Gemini 2.0 and 2.5 represent newer generations with \"next-generation features\" and \"improved capabilities\" compared to 1.5.\n", - "* **Performance and Purpose**:\n", - " * **Pro models (1.5 Pro, 2.5 Pro)** are designed for complex reasoning, multimodal understanding, and handling large amounts of data. Gemini 2.5 Pro is presented as the most powerful thinking model with maximum accuracy.\n", - " * **Flash models (1.5 Flash, 2.0 Flash, 2.5 Flash)** prioritize speed, cost efficiency, and versatility. Gemini 2.5 Flash offers the best price-performance ratio for low-latency, high-volume tasks.\n", - "* **Output Token Limit**: A significant difference is the output token limit for Gemini 2.5 models (65,536 tokens) compared to Gemini 1.5 and 2.0 models (8,192 tokens).\n", - "* **Long Context Window**: Gemini 1.5 Pro stands out with a larger input token limit (2,097,152) than other models listed (1,048,576), indicating its superior capability for processing extensive inputs.\n", - "* **Experimental/Preview Status**: Gemini 2.5 models are currently in \"Preview\" status, meaning they may have more restrictive rate limits compared to stable models." - ], + "text/markdown": "I am unable to directly access the content of the image URL provided. Therefore, I cannot identify the numbered parts of the trombone and translate them into French. To assist you, I need a resource that provides the names of the trombone parts in either English or French. If you can provide a link to a webpage with this information, I can help you translate the English terms to French or identify the French terms directly.\n", "text/plain": [ "" ] @@ -665,22 +665,19 @@ ], "source": [ "prompt = \"\"\"\n", - "based on https://ai.google.dev/gemini-api/docs/models, what are the key\n", - "differences between Gemini 1.5, Gemini 2.0 and Gemini 2.5 models?\n", - "Create a markdown table comparing the differences.\n", - "\"\"\"\n", + " Can you help me name of the numbered parts of that instrument, in French?\n", + " https://upload.wikimedia.org/wikipedia/commons/thumb/4/40/Trombone.svg/960px-Trombone.svg.png\n", "\n", - "tools = []\n", - "tools.append(types.Tool(url_context=types.UrlContext))\n", + "\"\"\"\n", "\n", - "config = types.GenerateContentConfig(\n", - " tools=tools,\n", - ")\n", + "config = {\n", + " \"tools\": [{\"url_context\": {}}],\n", + "}\n", "\n", "response = client.models.generate_content(\n", - " contents=[prompt],\n", - " model=MODEL_ID,\n", - " config=config\n", + " contents=[prompt],\n", + " model=MODEL_ID,\n", + " config=config\n", ")\n", "\n", "display(Markdown(response.text))" @@ -689,86 +686,189 @@ { "cell_type": "markdown", "metadata": { - "id": "9cf0uIAhEhPH" + "id": "NHs8FDfSsjt2" }, "source": [ - "As a reference, you can see how the answer would be without the URL context, using the official models documentation as reference:" + "## Mix Search grounding and URL context\n", + "\n", + "The different tools can also be use in conjunction by adding both tools to the config:" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 42, "metadata": { - "id": "ktlFAiFTEnHS" + "id": "wEOpBpbssjbD" }, "outputs": [ { "data": { - "text/markdown": [ - "It's important to clarify that as of my last update, **Gemini 1.5 Pro** is the current major iteration of Google's flagship multimodal model, and it represents a significant leap from the initial **Gemini 1.0** series (which included Ultra, Pro, and Nano).\n", - "\n", - "There hasn't been a publicly announced, distinct model called \"Gemini 2.0\" or \"Gemini 2.5\" in the same way that 1.0 and 1.5 Pro were launched. It's possible you might be thinking of:\n", - "* The **Gemini 1.0 series** as the initial release.\n", - "* **Gemini 1.5 Pro** as the \"next generation\" (which includes the revolutionary long context window).\n", - "* **Future, unannounced versions** that would logically follow 1.5, which might eventually be named 2.0 or 2.x. Google often refers to underlying architectural shifts or future capabilities internally, but these don't always translate to immediate, distinct public model names.\n", - "\n", - "Therefore, the key comparison is primarily between the **Gemini 1.0 family** and **Gemini 1.5 Pro**. Any mention of \"2.0\" or \"2.5\" would refer to speculative future models or a misinterpretation of current naming conventions.\n", - "\n", - "Here's a table comparing Gemini 1.0 and Gemini 1.5 Pro, and addressing the \"2.0\" and \"2.5\" points:\n", - "\n", - "---\n", - "\n", - "## Comparison of Gemini Models\n", - "\n", - "| Feature | Gemini 1.0 (e.g., Ultra, Pro, Nano) | Gemini 1.5 Pro | Gemini 2.0 / 2.5 (Future/Speculative) |\n", - "| :---------------------- | :---------------------------------------------- | :-------------------------------------------------------- | :------------------------------------------------- |\n", - "| **Launch/Announcement** | December 2023 | February 2024 (private preview), April 2024 (public preview) | Not publicly announced as distinct models yet. |\n", - "| **Core Architecture** | Traditional Transformer-based | **Mixture-of-Experts (MoE)** architecture; highly efficient | Likely further advancements in MoE or novel architectures |\n", - "| **Context Window Size** | Up to **32K tokens** | Standard: **1 Million tokens**; Experimental: **2 Million tokens** | Expected to be even larger or more efficient in processing. |\n", - "| **Multimodality** | Native understanding of text, images, audio, video. | Enhanced native understanding across modalities, especially for long-form video/audio. | Deeper, more integrated multimodal reasoning; potentially new modalities. |\n", - "| **Performance** | State-of-the-art at launch; strong general reasoning. | Surpasses Gemini 1.0 Ultra on many benchmarks, especially in long-context tasks (e.g., summarization, code analysis). | Expected to significantly outperform 1.5 Pro across all metrics. |\n", - "| **Key Innovation** | First broadly available truly multimodal model from Google. | **Revolutionary long context window**; MoE efficiency for performance and cost. | Unknown, but likely breakthrough in reasoning, agency, or real-world interaction. |\n", - "| **Use Cases** | General chatbot, content generation, coding, image analysis. | Advanced long-document analysis, video summarization, large codebase understanding, complex problem-solving. | Future applications requiring even greater autonomy, complex reasoning over vast data, and real-time interaction. |\n", - "| **Current Status** | Generally Available (API, Gemini Advanced/Bard) | Public Preview / General Availability (API, select products) | Not a defined public model; refers to future generations of Gemini models. |\n", - "\n", - "---\n", - "\n", - "**In summary:**\n", - "\n", - "* **Gemini 1.0** was the groundbreaking initial release of Google's multimodal model family.\n", - "* **Gemini 1.5 Pro** is the current flagship, distinguished by its **massive context window** (1M+ tokens) and efficient **Mixture-of-Experts (MoE)** architecture, making it exceptionally powerful for complex, long-form tasks.\n", - "* \"**Gemini 2.0**\" and \"**Gemini 2.5**\" are not currently distinct, publicly launched models. If and when new major versions are released after 1.5 Pro, they would likely feature even more advanced capabilities, but their naming and specific features are yet to be announced by Google." - ], + "text/markdown": "Okay, I have browsed the Alphabet 2025 Q2 earnings release. Here's an overview of the content:\n\n**Key Highlights from the Earnings Release:**\n\n* **Revenue Growth:** Consolidated Alphabet revenues in Q2 2025 increased 14% year-over-year to \\$96.4 billion. Google Services revenues increased 12% to \\$82.5 billion, and Google Cloud revenues increased 32% to \\$13.6 billion.\n* **Operating Income:** Total operating income increased 14%, with an operating margin of 32.4%.\n* **Net Income and EPS:** Net income increased 19%, and EPS increased 22% to \\$2.31.\n* **CEO Statement:** Sundar Pichai highlighted the company's strong performance, particularly in AI, Search, YouTube, and Cloud. He also mentioned increased capital expenditures for 2025, expected to be approximately \\$85 billion.\n* **Segment Results:** The release provides a breakdown of revenues and operating income for Google Services, Google Cloud, and Other Bets.\n* **Financial Tables:** The document includes consolidated balance sheets, statements of income, and statements of cash flows.\n* **Non-GAAP Measures:** The release discusses and reconciles certain non-GAAP financial measures, such as free cash flow and constant currency revenues.\n* **Forward-Looking Statements:** Standard cautionary language regarding forward-looking statements and associated risks and uncertainties is included.\n\nTo provide information on financial analysts' reactions and trends, I will conduct a web search.\nBased on the search results, here's an overview of analyst reactions to Alphabet's Q2 2025 earnings:\n\n* **Positive Outlook:** Several analysts expected Alphabet to deliver strong Q2 2025 results, with double-digit growth in both EPS and revenue.\n* **Key Growth Drivers:** The integration of Generative AI (Gen AI) into the search engine and the robust growth of Google Cloud were expected to be key drivers of growth.\n* **Bullish Sentiment:** Some analysts remain bullish on Alphabet due to its diversified business, including Google Cloud Platform and Waymo self-driving cars. KeyBanc analyst Justin Patterson raised the price target on Alphabet's stock to \\$215.00, citing strong performance in Search, YouTube, and Cloud segments, as well as positive commentary on AI Mode, Waymo, and expense efficiencies. Tickeron's AI Trading Bots also reinforce strong bullish potential for GOOG.\n* **Increased Capex:** Alphabet is increasing its 2025 capital expenditure forecast to \\$85 billion to build out its AI infrastructure, which could concern some investors, despite the positive impact on results.\n* **Initial Market Reaction:** Despite the strong business performance, the initial market reaction to Alphabet's earnings report was slightly negative, with shares trading about 1% lower.\n* **Potential Risks:** Investors should be cautious about potential risks, such as Alphabet's shares underperforming the Zacks Internet Services industry and the Zacks Computer & Technology sector year-to-date, and its stretched valuation.\n\n**Overall Trend:**\n\nThe overall trend seems to be cautiously optimistic. Analysts generally anticipated strong earnings growth driven by AI and cloud services, but some express concerns regarding increased capital expenditure and valuation. The initial market reaction was slightly negative, possibly due to the capex increase.\n", "text/plain": [ "" ] }, - "execution_count": 10, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + " analyst reaction alphabet earnings 2025 q2\n", + "
\n", + "
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "prompt = \"\"\"\n", - "what are the key differences between Gemini 1.5, Gemini 2.0 and Gemini 2.5\n", - "models? Create a markdown table comparing the differences.\n", + " Can you give me an overview of the content of this pdf?\n", + " https://abc.xyz/assets/cc/27/3ada14014efbadd7a58472f1f3f4/2025q2-alphabet-earnings-release.pdf\n", + " Search on the web for the reaction of the main financial analysts, what's the trend?\n", "\"\"\"\n", "\n", + "config = {\n", + " \"tools\": [\n", + " {\"url_context\": {}},\n", + " {\"google_search\": {}}\n", + " ],\n", + "}\n", + "\n", "response = client.models.generate_content(\n", - " contents=[prompt],\n", - " model=MODEL_ID,\n", + " contents=[prompt],\n", + " model=MODEL_ID,\n", + " config=config\n", ")\n", "\n", - "Markdown(response.text)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "axxHawtkGQO9" - }, - "source": [ - "As you can see, using the model knowledge only, it does not know about the new Gemini 2.5 models family." + "display(Markdown(response.text.replace('$','\\$')))\n", + "display(HTML(response.candidates[0].grounding_metadata.search_entry_point.rendered_content))" ] }, { From 0ff012eb373172fe7263e878c411b26346229ddd Mon Sep 17 00:00:00 2001 From: Guillaume Vernade Date: Mon, 11 Aug 2025 07:30:56 +0000 Subject: [PATCH 3/8] Rerunning --- quickstarts/Grounding.ipynb | 252 +++++++++++++++++--- quickstarts/Search_Grounding.ipynb | 370 ++++------------------------- 2 files changed, 266 insertions(+), 356 deletions(-) diff --git a/quickstarts/Grounding.ipynb b/quickstarts/Grounding.ipynb index 6ba4fddad..409d24a91 100644 --- a/quickstarts/Grounding.ipynb +++ b/quickstarts/Grounding.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": { "cellView": "form", "id": "tuOe1ymfHZPu" @@ -87,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": { "id": "6Fr84vJuPSHb" }, @@ -109,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": { "id": "RjvgYmdLQd5s" }, @@ -133,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": { "id": "C75s1LR9QmOz" }, @@ -144,7 +144,7 @@ "\n", "client = genai.Client(api_key=GOOGLE_API_KEY)\n", "\n", - "MODEL_ID = \"gemini-2.0-flash\" # @param [\"gemini-2.5-flash-lite\",\"gemini-2.0-flash\",\"gemini-2.5-pro\"] {\"allow-input\":true}" + "MODEL_ID = \"gemini-2.5-flash\" # @param [\"gemini-2.5-flash-lite\",\"gemini-2.5-flash\",\"gemini-2.5-pro\"] {\"allow-input\":true}" ] }, { @@ -173,14 +173,14 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": { "id": "FHIcazUO0-xU" }, "outputs": [ { "data": { - "text/markdown": "**Response**:\n The latest Indian Premier League (IPL) match was the final of the 2025 season, played on June 3, 2025, at the Narendra Modi Stadium in Ahmedabad. The Royal Challengers Bengaluru (RCB) won the match by 6 runs against the Punjab Kings (PBKS). This was the Royal Challengers Bengaluru's first IPL title.\n", + "text/markdown": "**Response**:\n The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, which took place on June 3, 2025. In this match, Royal Challengers Bengaluru defeated Punjab Kings by 6 runs to win their maiden title.", "text/plain": [ "" ] @@ -192,8 +192,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Search Query: ['latest Indian Premier League match who won']\n", - "Search Pages: business-standard.com, iplt20.com, business-standard.com, wikipedia.org, thehindu.com\n" + "Search Query: ['latest Indian Premier League match and winner', 'when did IPL 2025 finish', 'IPL 2024 final match and winner']\n", + "Search Pages: olympics.com, wikipedia.org, thehindu.com, olympics.com, skysports.com, wikipedia.org, thehindu.com\n" ] }, { @@ -320,7 +320,9 @@ "
\n", " \n", "
\n", - " latest Indian Premier League match who won\n", + " when did IPL 2025 finish\n", + " latest Indian Premier League match and winner\n", + " IPL 2024 final match and winner\n", "
\n", "\n" ], @@ -362,14 +364,14 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": { "id": "EdUkQ40cKaGX" }, "outputs": [ { "data": { - "text/markdown": "As an AI, I am unable to provide you with real-time information, including live IPL match results. The information changes rapidly. \n\nTo find the latest IPL match result, I recommend checking these resources:\n\n* **Official IPL Website:** The official IPL website is the most reliable source.\n* **Reputable Sports News Websites/Apps:** Sites like ESPNcricinfo, and others will have up-to-the-minute scores and match reports.\n* **Sports Apps:** Many sports apps (e.g., ESPN, etc.) provide live scores and updates.\n\nThese sources will give you the accurate result of the most recent IPL match.", + "text/markdown": "The latest Indian Premier League (IPL) match was the **Final of the IPL 2024 season**.\n\n* **Match:** Kolkata Knight Riders (KKR) vs. Sunrisers Hyderabad (SRH)\n* **Date:** May 26, 2024\n* **Winner:** **Kolkata Knight Riders (KKR)** won by 8 wickets.", "text/plain": [ "" ] @@ -418,19 +420,19 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": { "id": "akVTribOkgT2" }, "outputs": [ { "data": { - "text/markdown": "Ju-yeong Ji, from Google Deepmind, discusses in this video some ways Gemma Chess can be applied to the world of Chess to add a new dimension to the game.\n\nHe says that Gemma, a language model, can be used to make Chess easier to understand by taking all the technical information and turning it into plain text.\nGemma can also tell stories about Chess games. \nAnd Gemma can act like a 24/7 Chess study buddy or personal Chess coach and answer questions in your native language.\nIt is also possible to combine the analytical strengths of Chess AI with Gemma's linguistic skills for a more intuitive approach to learning and analysis.", + "text/markdown": "This video introduces \"Gemma Chess,\" demonstrating how Google's large language model, Gemma, can enhance the game of chess by leveraging its linguistic abilities.\n\nThe speaker, Ju-yeong Ji from Google DeepMind, explains that Gemma isn't intended to replace powerful chess engines that excel at calculating moves. Instead, it aims to bring a \"new dimension\" to chess through understanding and creating text.\n\nThe video highlights three key applications:\n\n1. **Explainer:** Gemma can analyze chess games (e.g., Kasparov vs. Deep Blue) and explain the \"most interesting\" or strategically significant moves in plain language, detailing their impact, tactical considerations, and psychological aspects, making complex analyses more understandable.\n2. **Storytellers:** Gemma can generate narrative stories about chess games, transforming raw move data into engaging accounts that capture the tension, emotions, and key moments of a match, bringing the game to life beyond just the moves.\n3. **Supporting Chess Learning:** Gemma can act as a personalized chess tutor, explaining concepts like specific openings (e.g., Sicilian Defense) or tactics in an accessible way, even adapting to the user's language and skill level, effectively serving as an always-available, intelligent chess encyclopedia and coach.\n\nBy combining the computational strength of traditional chess AI with Gemma's advanced language capabilities, this approach offers a more intuitive and human-friendly way to learn, analyze, and engage with chess.", "text/plain": [ "" ] }, - "execution_count": 32, + "execution_count": 77, "metadata": {}, "output_type": "execute_result" } @@ -466,19 +468,19 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": { "id": "UTH4DqBAzx3H" }, "outputs": [ { "data": { - "text/markdown": "Okay, here's a summary of how the Gemma model can help with Chess games in 2 paragraphs:\n\nFirstly, Gemma can be used to make Chess analysis easier to understand. When traditional engines display results in numeric and abstract move sequences, Gemma can convert these results into a plain text explanation that describes strategic and tactical advantages. This could include why a move is good, dangers, or summaries of difficult portions of the game. \n\nSecondly, Gemma can help tell stories about Chess games. Gemma can analyze a game's moves, players, tournament and then describe the game in words that bring it to life. If you're trying to get better at Chess, Gemma could help you study your strategy, understand your ideas in real time or learn about chess defenses in different languages.", + "text/markdown": "Gemma models, as large language models (LLMs), can significantly enhance the chess experience by bridging the gap between raw computational power and human understanding. Unlike traditional chess engines that excel at brute-force calculation and generating optimal moves (often in cryptic notation or complex numerical evaluations), Gemma's strength lies in processing and generating human-like text. This allows it to translate intricate chess engine outputs into intuitive, prose-based explanations, elucidating the strategic and tactical rationale behind moves, clarifying complex game concepts like openings and endgames, and providing accessible insights for players of all skill levels, significantly enhancing understanding beyond mere data.\n\nFurthermore, Gemma can serve as an invaluable tool for personalized chess learning and engagement. It can act as a dynamic, interactive coach, offering tailored explanations of specific positions, identifying weaknesses in a player's understanding, or even detailing the historical and psychological context of famous matches. By summarizing complex game analyses, highlighting pivotal moments, and even crafting narrative descriptions of entire games, Gemma can make chess more approachable, immersive, and educational, transforming how players learn, analyze, and appreciate the strategic depth of the game.", "text/plain": [ "" ] }, - "execution_count": 33, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" } @@ -549,14 +551,14 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": { "id": "eOXM1Fh2D9Ai" }, "outputs": [ { "data": { - "text/markdown": "The Gemini API offers several model variants, each optimized for specific use cases and capabilities. Here's a comparison of key differences between Gemini 1.5, Gemini 2.0, and Gemini 2.5 models:\n\n| Feature | Gemini 1.5 Pro | Gemini 1.5 Flash | Gemini 2.0 Flash | Gemini 2.5 Pro | Gemini 2.5 Flash |\n| :---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------ |\n| **Optimization** | Mid-size multimodal model optimized for a wide range of reasoning tasks; processes large amounts of data (2 hours video, 19 hours audio, 60,000 lines code, 2,000 pages text). | Fast and versatile multimodal model for scaling across diverse tasks. | Delivers next-gen features, superior speed, native tool use, and a 1M token context window. | Our most powerful thinking model with maximum response accuracy and state-of-the-art performance. | Best in terms of price-performance, offering well-rounded capabilities. Optimized for low latency, high volume tasks that require thinking. |\n| **Input(s)** | Audio, images, video, and text. | Audio, images, video, and text. | Audio, images, video, and text. | Audio, images, video, text, and PDF. | Audio, images, video, and text. |\n| **Output(s)** | Text. | Text. | Text. | Text. | Text. |\n| **Token Limits** | Input: 2,097,152 tokens. Output: 8,192 tokens. | Input: 1,048,576 tokens. Output: 8,192 tokens. | Input: 1,048,576 tokens. Output: 8,192 tokens. | Input: 1,048,576 tokens. Output: 65,536 tokens. | Input: 1,048,576 tokens. Output: 65,536 tokens. |\n| **Capabilities** | System instructions, JSON mode, JSON schema, adjustable safety settings, caching, tuning, function calling, code execution. | System instructions, JSON mode, JSON schema, adjustable safety settings, caching, tuning, function calling, code execution. | Structured outputs, caching, function calling, code execution, search. Thinking is experimental. Live API supported. | Structured outputs, caching, function calling, code execution, search grounding, thinking. Batch Mode supported. | Structured outputs, caching, code execution, function calling, search grounding, thinking. Batch Mode supported. |\n| **Primary Use Case** | Complex reasoning tasks, analyzing large datasets, codebases, and documents. | Scaling across diverse tasks. | Next-gen features, speed, and real-time streaming. | Complex coding, reasoning, and multimodal understanding. | Large-scale processing, low-latency, high-volume tasks that require thinking, agentic use cases. |\n", + "text/markdown": "The provided document details various Gemini model variants, including Gemini 1.5, Gemini 2.0, and Gemini 2.5, each with different \"Flash,\" \"Pro,\" and \"Lite\" versions optimized for specific use cases.\n\nHere's a comparison of the key differences:\n\n| Feature | Gemini 1.5 Pro | Gemini 1.5 Flash | Gemini 2.0 Flash | Gemini 2.5 Pro | Gemini 2.5 Flash | Gemini 2.5 Flash-Lite |\n| :---------------- | :---------------------------------------------- | :------------------------------------------------ | :--------------------------------------------------- | :------------------------------------------------------------------------------ | :-------------------------------------------------------------------------- | :------------------------------------------------------------------------ |\n| **Description** | Mid-size multimodal model, optimized for reasoning tasks, can process large amounts of data. | Fast and versatile multimodal model for diverse tasks. | Next-gen features, improved capabilities, superior speed, and native tool use. | Most powerful thinking model, maximum accuracy, state-of-the-art performance. | Best model in terms of price-performance, well-rounded capabilities. | Optimized for cost-efficiency and high throughput. |\n| **Input(s)** | Audio, images, video, text. | Audio, images, video, text. | Audio, images, video, text. | Audio, images, video, text, and PDF. | Audio, images, video, and text. | Text, image, video, audio. |\n| **Output(s)** | Text. | Text. | Text. | Text. | Text. | Text. |\n| **Input Token Limit** | 2,097,152. | 1,048,576. | 1,048,576. | 1,048,576. | 1,048,576. | 1,048,576. |\n| **Output Token Limit** | 8,192. | 8,192. | 8,192. | 65,536. | 65,536. | 65,536. |\n| **Key Use Cases** | Complex reasoning tasks. | Scaling across diverse tasks. | Next generation features, speed, realtime streaming. | Complex coding, reasoning, multimodal understanding, analyzing large data. | Low latency, high volume tasks that require thinking. | Real time, low latency use cases. |\n| **Thinking** | Not explicitly mentioned as a core capability, but optimized for reasoning tasks. | Not explicitly mentioned. | Experimental. | Supported (default on). | Supported (default on, can configure thinking budget). | Supported. |\n| **Live API** | Not supported. | Not supported. | Supported. | Not supported. | Not explicitly mentioned for the base Flash model, but Live variants exist. | Not supported. |\n| **Knowledge Cutoff** | September 2024. | September 2024. | August 2024. | January 2025. | January 2025. | January 2025. |\n| **Deprecation** | September 2025. | September 2025. | Not deprecated. | Not deprecated. | Not deprecated. | Not deprecated. |\n", "text/plain": [ "" ] @@ -585,6 +587,38 @@ "display(Markdown(response.text))" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "bPPCD5f2MSIx" + }, + "source": [ + "You can see the status of the retrival using `url_context_metadata`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "V5kKeAX5MUsP" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "url_metadata=[UrlMetadata(\n", + " retrieved_url='https://ai.google.dev/gemini-api/docs/models',\n", + " url_retrieval_status=\n", + ")]\n" + ] + } + ], + "source": [ + "# get URLs retrieved for context\n", + "print(response.candidates[0].url_context_metadata)\n" + ] + }, { "cell_type": "markdown", "metadata": { @@ -598,14 +632,14 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": { "id": "SeMZX5C5sLe3" }, "outputs": [ { "data": { - "text/markdown": "Alphabet Inc. announced its Q2 2025 financial results, reporting a 14% increase in consolidated revenues to \\$96.4 billion. Google Services revenues grew by 12% to \\$82.5 billion, driven by Google Search & other, YouTube ads, and Google subscriptions. Google Cloud revenues increased by 32% to \\$13.6 billion, fueled by growth in Google Cloud Platform. The total operating income increased by 14%, with an operating margin of 32.4%. Net income rose by 19%, and EPS increased by 22% to \\$2.31.\n", + "text/markdown": "\n\nThe PDF is Alphabet Inc.'s Second Quarter 2025 Earnings Release. It details the company's financial performance for the quarter ended June 30, 2025.\n\nKey highlights include:\n* **Total Revenues:** Consolidated Alphabet revenues increased 14% year-over-year to \\$96.4 billion.\n* **Google Services:** Revenues grew 12% to \\$82.5 billion, driven by strong performance in Google Search & other, Google subscriptions, platforms, devices, and YouTube ads.\n* **Google Cloud:** Revenues increased 32% to \\$13.6 billion, with growth in Google Cloud Platform (GCP) across core GCP products, AI Infrastructure, and Generative AI Solutions. Google Cloud's annual revenue run-rate is now over \\$50 billion.\n* **Operating Income:** Total operating income rose 14%, and the operating margin was 32.4%.\n* **Net Income and EPS:** Net income increased 19%, and diluted EPS grew 22% to \\$2.31.\n* **AI Impact:** CEO Sundar Pichai highlighted that AI is positively impacting every part of the business, driving strong momentum, with new features like AI Overviews and AI Mode performing well in Search.\n* **Capital Expenditures:** Alphabet plans to increase capital expenditures to approximately \\$85 billion in 2025 due to strong demand for Cloud products and services.\n* **Issuance of Senior Unsecured Notes:** In May 2025, Alphabet issued \\$12.5 billion in fixed-rate senior unsecured notes.\n\nThe document also provides detailed financial tables, including consolidated balance sheets, statements of income, and statements of cash flows, as well as segment results for Google Services, Google Cloud, and Other Bets. It also includes reconciliations of GAAP to non-GAAP financial measures.", "text/plain": [ "" ] @@ -647,14 +681,14 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "metadata": { "id": "HPNxQYkx8WJN" }, "outputs": [ { "data": { - "text/markdown": "I am unable to directly access the content of the image URL provided. Therefore, I cannot identify the numbered parts of the trombone and translate them into French. To assist you, I need a resource that provides the names of the trombone parts in either English or French. If you can provide a link to a webpage with this information, I can help you translate the English terms to French or identify the French terms directly.\n", + "text/markdown": "I cannot directly interpret the numbered parts within the image you provided. However, I can give you the common names of trombone parts in French, which you can then match to the numbers on your image:\n\nHere are some common parts of a trombone in French:\n* **Embouchure** (Mouthpiece)\n* **Pavillon** (Bell)\n* **Coulisse** (Slide)\n* **Coulisse d'accord** or **Pompe d'accord** (Tuning slide)\n* **Clé d'eau** or **Barillet** (Water key or spit valve)\n* **Entretoise** (Brace/Cross-stay, often used for various connecting rods)\n* **Manchon** (Ferrule/Sleeve, connecting parts)\n\nPlease match these names to the numbered parts in your image.", "text/plain": [ "" ] @@ -683,6 +717,168 @@ "display(Markdown(response.text))" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "hYEN_Vr5D6Zs" + }, + "source": [ + "## Mix URL context and structured ouput\n", + "\n", + "All those tools are compatible with the other Gemini capabilities, like [structured output](./JSON_mode.ipynb). Here's an example on how you can use both together to get a quick overview of a webpage in a structured way:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-NyFLCB3FtLG" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[\n", + " {\n", + " \"name\": \"docs: fix typo 'speciefying' in qdrant guide\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/871\",\n", + " \"author\": \"WhiteHades\",\n", + " \"labels\": [\n", + " \"component:examples\",\n", + " \"Issues/PR referencing examples folder\",\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"2 days ago\"\n", + " },\n", + " {\n", + " \"name\": \"Fix form symbol bug\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/869\",\n", + " \"author\": \"Mwessc\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"4 days ago\"\n", + " },\n", + " {\n", + " \"name\": \"fixing prompt guide link for Get_started_Veo.ipynb\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/865\",\n", + " \"author\": \"lucianommartins\",\n", + " \"labels\": [\n", + " \"component:quickstarts\",\n", + " \"Issues/PR referencing quickstarts folder\",\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"last week\"\n", + " },\n", + " {\n", + " \"name\": \"Added Grounding notebook for JavaScript\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/862\",\n", + " \"author\": \"andycandy\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"last week\"\n", + " },\n", + " {\n", + " \"name\": \"Added File_API notebook for JS\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/861\",\n", + " \"author\": \"andycandy\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"last week\"\n", + " },\n", + " {\n", + " \"name\": \"Added LearnLM notebook for JS\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/860\",\n", + " \"author\": \"andycandy\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"last week\"\n", + " },\n", + " {\n", + " \"name\": \"Added Audio.js notebook for JS\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/859\",\n", + " \"author\": \"andycandy\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"last week\"\n", + " },\n", + " {\n", + " \"name\": \"Added Counting tokens notebook for JS\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/858\",\n", + " \"author\": \"andycandy\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"last week\"\n", + " },\n", + " {\n", + " \"name\": \"Added Get_started_thinking notebook for JS\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/857\",\n", + " \"author\": \"andycandy\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"last week\"\n", + " },\n", + " {\n", + " \"name\": \"Added \\\"JSON_mode\\\" notebook for javascript\",\n", + " \"url\": \"https://github.com/google-gemini/cookbook/pull/854\",\n", + " \"author\": \"andycandy\",\n", + " \"labels\": [\n", + " \"status:awaiting review\",\n", + " \"PR awaiting review from a maintainer\"\n", + " ],\n", + " \"last_update\": \"2 weeks ago\"\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "from datetime import date\n", + "import typing_extensions as typing\n", + "import json\n", + "\n", + "class PR(typing.TypedDict):\n", + " name: str\n", + " url: str\n", + " author: str\n", + " labels: list[str]\n", + " last_update: str\n", + "\n", + "prompt = \"\"\"\n", + " Check the 10 latest pull requests from the gemini cookbook on this page: https://github.com/google-gemini/cookbook/pulls\n", + "\"\"\"\n", + "\n", + "config = {\n", + " \"tools\": [{\"url_context\": {}}],\n", + " \"response_mime_type\": \"application/json\",\n", + " \"response_schema\": list[PR],\n", + "}\n", + "\n", + "response = client.models.generate_content(\n", + " contents=[prompt],\n", + " model=MODEL_ID,\n", + " config=config\n", + ")\n", + "\n", + "print(json.dumps(json.loads(response.text), indent=4))" + ] + }, { "cell_type": "markdown", "metadata": { @@ -691,19 +887,19 @@ "source": [ "## Mix Search grounding and URL context\n", "\n", - "The different tools can also be use in conjunction by adding both tools to the config:" + "The different tools can also be use in conjunction by adding them both to the config:" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": { "id": "wEOpBpbssjbD" }, "outputs": [ { "data": { - "text/markdown": "Okay, I have browsed the Alphabet 2025 Q2 earnings release. Here's an overview of the content:\n\n**Key Highlights from the Earnings Release:**\n\n* **Revenue Growth:** Consolidated Alphabet revenues in Q2 2025 increased 14% year-over-year to \\$96.4 billion. Google Services revenues increased 12% to \\$82.5 billion, and Google Cloud revenues increased 32% to \\$13.6 billion.\n* **Operating Income:** Total operating income increased 14%, with an operating margin of 32.4%.\n* **Net Income and EPS:** Net income increased 19%, and EPS increased 22% to \\$2.31.\n* **CEO Statement:** Sundar Pichai highlighted the company's strong performance, particularly in AI, Search, YouTube, and Cloud. He also mentioned increased capital expenditures for 2025, expected to be approximately \\$85 billion.\n* **Segment Results:** The release provides a breakdown of revenues and operating income for Google Services, Google Cloud, and Other Bets.\n* **Financial Tables:** The document includes consolidated balance sheets, statements of income, and statements of cash flows.\n* **Non-GAAP Measures:** The release discusses and reconciles certain non-GAAP financial measures, such as free cash flow and constant currency revenues.\n* **Forward-Looking Statements:** Standard cautionary language regarding forward-looking statements and associated risks and uncertainties is included.\n\nTo provide information on financial analysts' reactions and trends, I will conduct a web search.\nBased on the search results, here's an overview of analyst reactions to Alphabet's Q2 2025 earnings:\n\n* **Positive Outlook:** Several analysts expected Alphabet to deliver strong Q2 2025 results, with double-digit growth in both EPS and revenue.\n* **Key Growth Drivers:** The integration of Generative AI (Gen AI) into the search engine and the robust growth of Google Cloud were expected to be key drivers of growth.\n* **Bullish Sentiment:** Some analysts remain bullish on Alphabet due to its diversified business, including Google Cloud Platform and Waymo self-driving cars. KeyBanc analyst Justin Patterson raised the price target on Alphabet's stock to \\$215.00, citing strong performance in Search, YouTube, and Cloud segments, as well as positive commentary on AI Mode, Waymo, and expense efficiencies. Tickeron's AI Trading Bots also reinforce strong bullish potential for GOOG.\n* **Increased Capex:** Alphabet is increasing its 2025 capital expenditure forecast to \\$85 billion to build out its AI infrastructure, which could concern some investors, despite the positive impact on results.\n* **Initial Market Reaction:** Despite the strong business performance, the initial market reaction to Alphabet's earnings report was slightly negative, with shares trading about 1% lower.\n* **Potential Risks:** Investors should be cautious about potential risks, such as Alphabet's shares underperforming the Zacks Internet Services industry and the Zacks Computer & Technology sector year-to-date, and its stretched valuation.\n\n**Overall Trend:**\n\nThe overall trend seems to be cautiously optimistic. Analysts generally anticipated strong earnings growth driven by AI and cloud services, but some express concerns regarding increased capital expenditure and valuation. The initial market reaction was slightly negative, possibly due to the capex increase.\n", + "text/markdown": "Alphabet Inc. announced strong financial results for the second quarter of 2025, ending June 30, 2025. Consolidated revenues increased by 14% year-over-year to \\$96.4 billion, or 13% in constant currency, with double-digit growth seen across Google Search & other, YouTube ads, Google subscriptions, platforms, and devices, and Google Cloud.\n\nKey financial highlights include:\n* **Total revenues** of \\$96.428 billion, up from \\$84.742 billion in Q2 2024.\n* **Net income** increased by 19% to \\$28.196 billion.\n* **Diluted EPS** rose by 22% to \\$2.31.\n* **Operating income** increased by 14% to \\$31.271 billion, with an **operating margin** of 32.4%.\n* **Google Services revenues** increased by 12% to \\$82.5 billion.\n* **Google Cloud revenues** significantly increased by 32% to \\$13.6 billion, driven by growth in Google Cloud Platform (GCP), AI Infrastructure, and Generative AI Solutions. Its annual revenue run-rate now exceeds \\$50 billion.\n* The company announced an increase in **capital expenditures** to approximately \\$85 billion for 2025 due to strong demand for Cloud products and services.\n\nSundar Pichai, CEO of Alphabet, highlighted the company's \"standout quarter\" with robust growth, attributing success to leadership in AI and rapid shipping. He noted the positive impact of AI across the business, strong momentum in Search (including AI Overviews and AI Mode), and continued strong performance in YouTube and subscriptions.\n\n**Financial Analyst Reactions and Trends:**\n\nFinancial analysts generally maintain a positive outlook on Alphabet, with a majority (43 out of 55) recommending \"buy\" or \"strong buy\" ratings. However, the average target price has seen a slight decline from approximately \\$215 in March to \\$202.05, indicating increased uncertainty. Despite this, the current consensus suggests a potential upside of 11% from recent trading levels as of mid-July 2025.\n\nPrior to the earnings release, analysts expected a moderation in growth for Q2 2025, with projected revenue of \\$93.8 billion (+10.7% YoY) and net income of \\$26.5 billion (+12.2% YoY). Alphabet's actual Q2 2025 results surpassed these expectations, with EPS of \\$2.31 beating the forecasted \\$2.17 and revenue of \\$96.43 billion exceeding projections.\n\nDespite the positive earnings beat, Alphabet's stock experienced a modest increase of 0.57% in after-hours trading, and in some instances, a slight decline (around 1.5%) post-announcement. This dip was primarily attributed to the company's decision to raise its 2025 capital expenditures guidance by \\$10 billion to \\$85 billion, reflecting increased investments in AI and technology infrastructure, which raised some investor concerns about higher costs.\n\nThe key areas of focus for analysts include Alphabet's ability to expand its GenAI model's user base without impacting traditional Search revenue, and the continued growth of Google Cloud, which is seen as the company's largest growth opportunity. Analysts are closely monitoring AI developments, cloud growth, and regulatory challenges. The overall trend appears to be one of cautious optimism, with strong underlying business performance balanced by increased investment needs for future growth in AI and cloud services.", "text/plain": [ "" ] @@ -835,7 +1031,7 @@ "
\n", " \n", "
\n", - " analyst reaction alphabet earnings 2025 q2\n", + " financial analyst reaction Alphabet 2025 Q2 earnings\n", "
\n", "\n" ], diff --git a/quickstarts/Search_Grounding.ipynb b/quickstarts/Search_Grounding.ipynb index eeae27132..48cab5306 100644 --- a/quickstarts/Search_Grounding.ipynb +++ b/quickstarts/Search_Grounding.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "cellView": "form", "id": "tuOe1ymfHZPu" @@ -84,21 +84,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 32, "metadata": { "id": "6Fr84vJuPSHb" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.1/43.1 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m222.6/222.6 kB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h" - ] - } - ], + "outputs": [], "source": [ "%pip install -q -U \"google-genai>=1.0.0\"" ] @@ -116,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 33, "metadata": { "id": "RjvgYmdLQd5s" }, @@ -143,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 34, "metadata": { "id": "C75s1LR9QmOz" }, @@ -168,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "id": "FHIcazUO0-xU" }, @@ -360,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "id": "EdUkQ40cKaGX" }, @@ -401,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { "cellView": "form", "id": "LUTX1SsKS3CE" @@ -447,7 +437,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "id": "Qilzz3GKTdpl" }, @@ -482,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "id": "St4MxVo2Sl6I" }, @@ -659,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "id": "4L40g89mTyPs" }, @@ -837,7 +827,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "id": "n00CHfm0UKp1" }, @@ -1026,7 +1016,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "id": "42UTFDweVwNm" }, @@ -1107,7 +1097,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "id": "K0vk3ol5WMvN" }, @@ -1296,7 +1286,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "id": "vtfTv4ieFjYt" }, @@ -1335,17 +1325,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 50, "metadata": { "id": "CUhcThmnK0mt" }, "outputs": [], "source": [ - "# Live API only works with v1alpha API and with the gemini-2.0-flash-exp model at the moment\n", - "\n", - "client = genai.Client(http_options={'api_version': 'v1alpha'})\n", - "\n", - "LIVE_MODEL_ID = \"gemini-2.0-flash-exp\"" + "LIVE_MODEL_ID = \"gemini-2.5-flash-preview-native-audio-dialog\" # @param [\"gemini-2.0-flash-live-001\", \"gemini-live-2.5-flash-preview\",\"gemini-2.5-flash-preview-native-audio-dialog\"] {\"allow-input\":true, isTemplate: true}" ] }, { @@ -1363,8 +1349,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 46, "metadata": { + "cellView": "form", "id": "YEAdoUV2dH1o" }, "outputs": [], @@ -1401,9 +1388,7 @@ " async for msg in stream.receive():\n", " all_responses.append(msg)\n", "\n", - " if text:=msg.text:\n", - " print(text)\n", - " if audio_data := msg.data:\n", + " if audio_data := msg.data: # This is what triggers the warnings, we should use the full path to access the audio data\n", " turn_buf.write(audio_data)\n", " if m := re.search(\n", " 'rate=(?P\\d+)',\n", @@ -1471,7 +1456,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 51, "metadata": { "id": "0wXCugI3eOtS" }, @@ -1480,7 +1465,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipython-input-4150174230.py:81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", + "/tmp/ipython-input-1749242392.py:79: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n", " await strm.send(input=query, end_of_turn=True)\n" ] @@ -1489,199 +1474,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Buffering" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "....." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "...\n" + "Buffering......................................................................................................................................................................................................................................................................................\n" ] }, { @@ -1689,7 +1482,7 @@ "text/html": [ "\n", " \n", " " @@ -1717,7 +1510,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 52, "metadata": { "id": "HYGEtdjupXM7" }, @@ -1726,7 +1519,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipython-input-4150174230.py:81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", + "/tmp/ipython-input-1749242392.py:79: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n", "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n", " await strm.send(input=query, end_of_turn=True)\n" ] @@ -1742,9 +1535,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['executable_code'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['code_execution_result'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] }, @@ -1759,137 +1550,60 @@ "name": "stderr", "output_type": "stream", "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "......." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "......." + ".." ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "......." + ".." ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "......." + ".." ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n", - "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n" + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n", + "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - ".....\n" + "..............................................................................................................................................................................................................................................................................................................................................................................................\n" ] }, { @@ -1897,7 +1611,7 @@ "text/html": [ "\n", " \n", " " @@ -1925,7 +1639,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": { "id": "_UUZ5V_Upzpm" }, @@ -1953,7 +1667,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": { "id": "7-nQ1Sp9yM33" }, @@ -2135,7 +1849,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": { "id": "ZzZlE9IFnwpS" }, From c849745b784e8670a279c7e3bfe939b09e22f5da Mon Sep 17 00:00:00 2001 From: Guillaume Vernade Date: Mon, 11 Aug 2025 08:10:24 +0000 Subject: [PATCH 4/8] Highlighting the URL Context tool --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 57df92fd0..fc6cba3e2 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ Here are the recent additions and updates to the Gemini API and the Cookbook: * **Lyria and TTS**: Get started with podcast and music generation with the [TTS](./quickstarts/Get_started_TTS.ipynb) and [Lyria RealTime](./quickstarts/Get_started_LyriaRealTime.ipynb) models. * **LiveAPI**: Get started with the [multimodal Live API](./quickstarts/Get_started_LiveAPI.ipynb) and unlock new interactivity with Gemini. * **Recently Added Guides:** - * [Grounding](./quickstarts/Grounding.ipynb): Discover different ways to ground Gemini's answer using different tools, from Google Search to Youtube and the new url context tool. + * [Grounding](./quickstarts/Grounding.ipynb): Discover different ways to ground Gemini's answer using different tools, from Google Search to Youtube and the new **url context** tool. * [Batch-mode](./quickstarts/Batch_mode.ipynb): Use Batch-mode to send large volume of non-time-sensitive requests to the model and get a 50% discount. From 5e05b83a34165bf2434770bf8d89ec841f80bb70 Mon Sep 17 00:00:00 2001 From: Mark McDonald Date: Mon, 11 Aug 2025 17:06:05 +0800 Subject: [PATCH 5/8] Remove sandbox URL --- examples/Browser_as_a_tool.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/Browser_as_a_tool.ipynb b/examples/Browser_as_a_tool.ipynb index 4c8c369f6..b5ae27386 100644 --- a/examples/Browser_as_a_tool.ipynb +++ b/examples/Browser_as_a_tool.ipynb @@ -56,7 +56,7 @@ "* Returning images of web pages from function calling\n", "* Connecting to a local network/intranet using a browser tool\n", "\n", - "**Note**: for most of the use-cases, you can use the tools directly by Gemini to get it to search content using Google Search, grab videos from YouTube or fetch context from URLs without having to set-up anything. Check out the [Grounding](https://colab.sandbox.google.com/quickstarts/Grounding.ipynb) notebook for more details.\n" + "**Note**: for most of the use-cases, you can use the tools directly by Gemini to get it to search content using Google Search, grab videos from YouTube or fetch context from URLs without having to set-up anything. Check out the [Grounding](https://colab.research.google.com/quickstarts/Grounding.ipynb) notebook for more details.\n" ] }, { @@ -1195,7 +1195,7 @@ "source": [ "## Further reading\n", "\n", - "* To learn more about using the grounding tools (search grounding, youtube links and URL context), check out the [Grounding](../quickstarts/Grounding.ipynb) notebook or the one dedicated to [Seach grounding](../quickstarts/Search_Grounding.ipynb).\n", + "* To learn more about using the grounding tools (search grounding, YouTube links and URL context), check out the [Grounding](../quickstarts/Grounding.ipynb) notebook or the one dedicated to [Seach grounding](../quickstarts/Search_Grounding.ipynb).\n", "* For more advanced examples of function calling in the Live API, try the [Plotting and Mapping](../examples/LiveAPI_plotting_and_mapping.ipynb) cookbook recipe.\n", "\n", "Or browse the [Gemini API cookbook](http://github.com/google-gemini/cookbook)." From 4466470bc0e1cc53e85be3e622b60e891e197119 Mon Sep 17 00:00:00 2001 From: Mark McDonald Date: Mon, 11 Aug 2025 17:12:51 +0800 Subject: [PATCH 6/8] nblints --- quickstarts/Search_Grounding.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/quickstarts/Search_Grounding.ipynb b/quickstarts/Search_Grounding.ipynb index 48cab5306..e09913935 100644 --- a/quickstarts/Search_Grounding.ipynb +++ b/quickstarts/Search_Grounding.ipynb @@ -1104,7 +1104,7 @@ "outputs": [ { "data": { - "text/markdown": "To give the chart a dark theme, we can utilize Matplotlib's built-in `dark_background` style. This style automatically adjusts the background, text, and other elements for a dark aesthetic.\n\nHere's the modified Python code:\n\n", + "text/markdown": "To give the chart a dark theme, you can utilize Matplotlib's built-in `dark_background` style. This style automatically adjusts the background, text, and other elements for a dark aesthetic.\n\nHere's the modified Python code:\n\n", "text/plain": [ "" ] @@ -1388,7 +1388,7 @@ " async for msg in stream.receive():\n", " all_responses.append(msg)\n", "\n", - " if audio_data := msg.data: # This is what triggers the warnings, we should use the full path to access the audio data\n", + " if audio_data := msg.data: # This is what triggers the warnings, use the full path to access the audio data\n", " turn_buf.write(audio_data)\n", " if m := re.search(\n", " 'rate=(?P\\d+)',\n", From b67b2139906dd029c69c55e0e796a65afb6fd3a7 Mon Sep 17 00:00:00 2001 From: Guillaume Vernade Date: Wed, 13 Aug 2025 13:41:09 +0000 Subject: [PATCH 7/8] Removing url context+structured output --- quickstarts/Grounding.ipynb | 164 +----------------------------------- 1 file changed, 1 insertion(+), 163 deletions(-) diff --git a/quickstarts/Grounding.ipynb b/quickstarts/Grounding.ipynb index 409d24a91..0458eff2a 100644 --- a/quickstarts/Grounding.ipynb +++ b/quickstarts/Grounding.ipynb @@ -717,168 +717,6 @@ "display(Markdown(response.text))" ] }, - { - "cell_type": "markdown", - "metadata": { - "id": "hYEN_Vr5D6Zs" - }, - "source": [ - "## Mix URL context and structured ouput\n", - "\n", - "All those tools are compatible with the other Gemini capabilities, like [structured output](./JSON_mode.ipynb). Here's an example on how you can use both together to get a quick overview of a webpage in a structured way:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "-NyFLCB3FtLG" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[\n", - " {\n", - " \"name\": \"docs: fix typo 'speciefying' in qdrant guide\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/871\",\n", - " \"author\": \"WhiteHades\",\n", - " \"labels\": [\n", - " \"component:examples\",\n", - " \"Issues/PR referencing examples folder\",\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"2 days ago\"\n", - " },\n", - " {\n", - " \"name\": \"Fix form symbol bug\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/869\",\n", - " \"author\": \"Mwessc\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"4 days ago\"\n", - " },\n", - " {\n", - " \"name\": \"fixing prompt guide link for Get_started_Veo.ipynb\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/865\",\n", - " \"author\": \"lucianommartins\",\n", - " \"labels\": [\n", - " \"component:quickstarts\",\n", - " \"Issues/PR referencing quickstarts folder\",\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"last week\"\n", - " },\n", - " {\n", - " \"name\": \"Added Grounding notebook for JavaScript\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/862\",\n", - " \"author\": \"andycandy\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"last week\"\n", - " },\n", - " {\n", - " \"name\": \"Added File_API notebook for JS\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/861\",\n", - " \"author\": \"andycandy\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"last week\"\n", - " },\n", - " {\n", - " \"name\": \"Added LearnLM notebook for JS\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/860\",\n", - " \"author\": \"andycandy\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"last week\"\n", - " },\n", - " {\n", - " \"name\": \"Added Audio.js notebook for JS\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/859\",\n", - " \"author\": \"andycandy\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"last week\"\n", - " },\n", - " {\n", - " \"name\": \"Added Counting tokens notebook for JS\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/858\",\n", - " \"author\": \"andycandy\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"last week\"\n", - " },\n", - " {\n", - " \"name\": \"Added Get_started_thinking notebook for JS\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/857\",\n", - " \"author\": \"andycandy\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"last week\"\n", - " },\n", - " {\n", - " \"name\": \"Added \\\"JSON_mode\\\" notebook for javascript\",\n", - " \"url\": \"https://github.com/google-gemini/cookbook/pull/854\",\n", - " \"author\": \"andycandy\",\n", - " \"labels\": [\n", - " \"status:awaiting review\",\n", - " \"PR awaiting review from a maintainer\"\n", - " ],\n", - " \"last_update\": \"2 weeks ago\"\n", - " }\n", - "]\n" - ] - } - ], - "source": [ - "from datetime import date\n", - "import typing_extensions as typing\n", - "import json\n", - "\n", - "class PR(typing.TypedDict):\n", - " name: str\n", - " url: str\n", - " author: str\n", - " labels: list[str]\n", - " last_update: str\n", - "\n", - "prompt = \"\"\"\n", - " Check the 10 latest pull requests from the gemini cookbook on this page: https://github.com/google-gemini/cookbook/pulls\n", - "\"\"\"\n", - "\n", - "config = {\n", - " \"tools\": [{\"url_context\": {}}],\n", - " \"response_mime_type\": \"application/json\",\n", - " \"response_schema\": list[PR],\n", - "}\n", - "\n", - "response = client.models.generate_content(\n", - " contents=[prompt],\n", - " model=MODEL_ID,\n", - " config=config\n", - ")\n", - "\n", - "print(json.dumps(json.loads(response.text), indent=4))" - ] - }, { "cell_type": "markdown", "metadata": { @@ -887,7 +725,7 @@ "source": [ "## Mix Search grounding and URL context\n", "\n", - "The different tools can also be use in conjunction by adding them both to the config:" + "The different tools can also be use in conjunction by adding them both to the config. It's a good way to steer Gemini in the right direction and then let it do its magic using search grounding." ] }, { From a62e083498d4051abae429c560c9e2a1bb49a53f Mon Sep 17 00:00:00 2001 From: Guillaume Vernade Date: Mon, 18 Aug 2025 18:56:54 +0200 Subject: [PATCH 8/8] Adding isTemplate: true --- quickstarts/Grounding.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/quickstarts/Grounding.ipynb b/quickstarts/Grounding.ipynb index 0458eff2a..2147ff67a 100644 --- a/quickstarts/Grounding.ipynb +++ b/quickstarts/Grounding.ipynb @@ -144,7 +144,7 @@ "\n", "client = genai.Client(api_key=GOOGLE_API_KEY)\n", "\n", - "MODEL_ID = \"gemini-2.5-flash\" # @param [\"gemini-2.5-flash-lite\",\"gemini-2.5-flash\",\"gemini-2.5-pro\"] {\"allow-input\":true}" + "MODEL_ID = \"gemini-2.5-flash\" # @param [\"gemini-2.5-flash-lite\",\"gemini-2.5-flash\",\"gemini-2.5-pro\"] {\"allow-input\":true, isTemplate: true}" ] }, {