<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Philip Obiorah on Medium]]></title>
        <description><![CDATA[Stories by Philip Obiorah on Medium]]></description>
        <link>https://medium.com/@philipsatimor2?source=rss-47371eec1dc6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*_Vbe4MmwlTnXyGRh7EcOGg.jpeg</url>
            <title>Stories by Philip Obiorah on Medium</title>
            <link>https://medium.com/@philipsatimor2?source=rss-47371eec1dc6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 03:59:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@philipsatimor2/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[No API Costs: Building a Local Multi-Agent AI System with Gemma 4, Ollama, and Google ADK]]></title>
            <link>https://medium.com/@philipsatimor2/no-api-costs-building-a-local-multi-agent-ai-system-with-gemma-4-ollama-and-google-adk-4ecfd0db9610?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ecfd0db9610</guid>
            <category><![CDATA[gemma-4]]></category>
            <category><![CDATA[ollama]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[google-adk]]></category>
            <category><![CDATA[local-ai-deployment]]></category>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 21:03:19 GMT</pubDate>
            <atom:updated>2026-08-20T21:03:19.654Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How to build a private, locally hosted planning-and-writing agent on an Apple Silicon Mac without paying per API request</em></p><p>Large language models are increasingly moving beyond question-and-answer systems. Modern AI applications can interpret goals, create plans, use tools, evaluate results, and coordinate specialist agents.</p><p>These systems are generally described as <strong>AI agents</strong>.</p><p>Many agent tutorials rely on paid cloud APIs. That approach is convenient, but it introduces usage charges, API-key management, rate limits, and potential data-governance concerns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yn4GvJ80WhubmzhvjWFQ8g.jpeg" /><figcaption>zero-cost multi-agent AI system built using Gemma 4, Ollama, and Google ADK.</figcaption></figure><p>“No API costs” does not mean that computing is completely free: the application still uses your computer’s memory, processor, storage, and electricity. However, it does remove token-based cloud-model charges.</p><h3>What We Are Building</h3><p>In this tutorial, we will build a local multi-agent system that plans, writes and reviews technical blog articles. The project demonstrates two fundamental elements of agentic AI: <strong>reasoning and acting</strong>. Given a topic, the system determines the steps required, produces a structured outline, writes the article and evaluates the completed draft.</p><p>The system comprises five components:</p><ul><li>A <strong>Planner Agent</strong>, which creates a structured article outline</li><li>An <strong>Outline Validator</strong>, which checks whether the plan meets the specified requirements</li><li>A <strong>Writer Agent</strong>, which develops the approved outline into a complete article</li><li>An <strong>Article Validator</strong>, which reviews the structure and technical clarity of the draft</li><li>A <strong>Root Blogger Agent</strong>, which orchestrates the entire workflow</li></ul><p>The original Google implementation uses a cloud-hosted Gemini model. In this adaptation, the complete workflow runs <strong>locally on an Apple Silicon Mac</strong>, with Gemma 4 hosted through Ollama. Google ADK manages the agents and their interactions, while LiteLLM provides the connection between ADK and the locally hosted model.</p><p>Running the model locally allows us to explore reasoning, tool use, shared state, orchestration and validation without incurring per-request model API charges. However, the system still uses the computer’s memory, processing power, storage and electricity.</p><p>This tutorial adapts the architecture and implementation presented in Google’s <a href="https://codelabs.developers.google.com/build-ai-agent-google-adk#0"><em>Build an AI Agent with Google ADK</em></a> Codelab, replacing the hosted Gemini model with a locally running Gemma 4 model.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/332/1*xKTTflWonJE-QIPD0aGZ3w.png" /><figcaption>Blog Article Generation Workflow</figcaption></figure><h3>Why Gemma 4 E4B?</h3><p>Gemma 4 is Google DeepMind’s newer family of open models. It supports multimodal input, reasoning, tool use, coding, and agentic workflows.</p><p>For this tutorial, we will use:</p><pre>gemma4:e4b</pre><p>The E4B designation refers to the model’s effective activated parameter size. It is designed to provide stronger capabilities without requiring all the model’s parameters to be active for every input.</p><p>The Ollama version of gemma4:e4b is approximately 9.6 GB. It should run on an Apple Silicon Mac with 16 GB of unified memory, although there will be less spare memory for other applications.</p><p>If your computer struggles with E4B, use the smaller model:</p><pre>gemma4:e2b</pre><p>You will sacrifice some reasoning quality, but the application should run faster and use less memory.</p><h3>Hardware used</h3><p>This tutorial was developed for the following system:</p><ul><li>Apple M1 Pro</li><li>10-core processor</li><li>16 GB unified memory</li><li>macOS</li><li>Python 3.13</li><li>Homebrew</li><li>Ollama</li></ul><p>The same general process should work on other systems supported by Ollama, although installation commands and performance will vary.</p><h3>Step 1: Install Ollama</h3><p>Ollama provides a straightforward way to download and run open models locally.</p><p>On macOS with Homebrew, install it using:</p><pre>brew install ollama</pre><p>If Ollama is already installed, update it:</p><pre>brew update<br>brew upgrade ollama</pre><p>Confirm the installation:</p><pre>ollama --version</pre><p>You can also install the macOS application from the official Ollama website.</p><h3>Step 2: Download Gemma 4</h3><p>Download Gemma 4 E4B:</p><pre>ollama pull gemma4:e4b</pre><p>This may take several minutes because the model is several gigabytes in size.</p><p>After the download, confirm that the model is available:</p><pre>ollama list</pre><p>You should see an entry similar to:</p><pre>NAME            ID              SIZE<br>gemma4:e4b      ...             9.6 GB</pre><h3>Step 3: Test Gemma directly</h3><p>Before introducing Google ADK, verify that Gemma works through Ollama:</p><pre>ollama run gemma4:e4b</pre><p>Try a simple prompt:</p><pre>Create an outline for an article explaining AI agents to beginners.</pre><p>If Gemma produces an answer, the local model is working.</p><p>Exit the interactive session with:</p><pre>/bye</pre><p>This direct test is useful because it separates Ollama problems from ADK problems. If the model does not work here, there is little value in debugging the agent framework yet.</p><h3>Step 4: Check whether Ollama is already running</h3><p>Ollama normally listens on:</p><pre>http://127.0.0.1:11434</pre><p>You might try:</p><pre>ollama serve</pre><p>and receive:</p><pre>Error: listen tcp 127.0.0.1:11434: bind: address already in use</pre><p>This does not necessarily indicate a problem. It usually means that Ollama is already running.</p><p>Test the server:</p><pre>curl http://127.0.0.1:11434/api/tags</pre><p>If Ollama is running, the command returns JSON containing the locally installed models.</p><p>You can also check loaded models with:</p><pre>ollama ps</pre><p>Do not attempt to start a second Ollama server on the same port.</p><h3>Step 5: Create the ADK project</h3><p>Create a project in your preferred location:</p><pre>cd /Users/yourusername<br>mkdir bloggeragent<br>cd bloggeragent</pre><p>Create the required files:</p><pre>touch requirements.txt .env .gitignore __init__.py agent.py</pre><p>The project should look like this:</p><pre>bloggeragent/<br>├── .env<br>├── .gitignore<br>├── __init__.py<br>├── agent.py<br>└── requirements.txt</pre><h3>Step 6: Create a virtual environment</h3><p>A Python virtual environment isolates the project’s dependencies from the rest of your computer.</p><p>Create it:</p><pre>python3 -m venv .venv</pre><p>Activate it:</p><pre>source .venv/bin/activate</pre><p>Your Terminal prompt should now begin with:</p><pre>(.venv)</pre><p>Confirm that the correct Python interpreter is active:</p><pre>which python</pre><p>The result should point to the project environment:</p><pre>/Users/philipobiorah/bloggeragent/.venv/bin/python</pre><h3>Step 7: Install Google ADK with local-model support</h3><p>Add the following to requirements.txt:</p><pre>google-adk[extensions]==2.2.0<br>python-dotenv<br>litellm&gt;=1.84</pre><p>Install the dependencies:</p><pre>python -m pip install --upgrade pip<br>python -m pip install -r requirements.txt</pre><p>The [extensions] part is important.</p><p>A basic ADK installation may not contain the optional packages required by LiteLlm. Without them, the application can fail with:</p><pre>ImportError: LiteLLM support requires:<br>pip install google-adk[extensions]</pre><p>If you encounter that error, install the extensions explicitly:</p><pre>python -m pip install --upgrade &quot;google-adk[extensions]==2.2.0&quot;<br>python -m pip install --upgrade &quot;litellm&gt;=1.84&quot;</pre><p>The quotation marks prevent shells such as Zsh from interpreting the square brackets.</p><p>Verify the integration:</p><pre>python -c &quot;from google.adk.models.lite_llm import LiteLlm; print(&#39;LiteLLM connection ready&#39;)&quot;</pre><p>Expected result:</p><pre>LiteLLM connection ready</pre><h3>Step 8: Configure the local Ollama connection</h3><p>Add this to .env:</p><pre>OLLAMA_API_BASE=http://127.0.0.1:11434</pre><p>Unlike the hosted Gemini version of the project, the local configuration does not require:</p><pre>GOOGLE_API_KEY</pre><p>Protect local configuration by adding the following to .gitignore:</p><pre>.env<br>.venv/<br>__pycache__/<br>*.pyc</pre><p>Even when the current .env file contains no API key, excluding it from version control remains a useful security practice.</p><h3>Step 9: Configure the Python package</h3><p>Add the following to __init__.py:</p><pre>from . import agent</pre><p>This allows Google ADK to import the agent definition from the package.</p><h3>Step 10: Define the local Gemma model</h3><p>Open agent.py and add the imports:</p><pre>import datetime</pre><pre>from dotenv import load_dotenv<br>from google.adk.agents import Agent, LoopAgent<br>from google.adk.models.lite_llm import LiteLlm<br>from google.adk.tools import agent_tool</pre><p>Load the environment configuration:</p><pre>load_dotenv()</pre><p>Create the local model connector:</p><pre>MODEL = LiteLlm(<br>    model=&quot;ollama_chat/gemma4:e4b&quot;<br>)</pre><p>Google recommends using the ollama_chat provider rather than simply ollama. The chat-specific interface helps preserve conversational context and reduces the chance of inappropriate repeated tool calls.</p><p>If you choose the smaller model, change the model string:</p><pre>MODEL = LiteLlm(<br>    model=&quot;ollama_chat/gemma4:e2b&quot;<br>)</pre><h3>Step 11: Build the multi-agent workflow</h3><p>Rather than reproducing the entire multi-agent implementation here, we will use the official Google Codelab as the foundation for the project.</p><p>Open <a href="https://codelabs.developers.google.com/build-ai-agent-google-adk#5">Step 6: Build the Multi-Agent Blog Writer</a> and copy the supplied code into your agent.py file.</p><p>The official implementation defines:</p><ul><li>BlogPlanner, which generates the article outline</li><li>OutlineValidationChecker, which checks the outline</li><li>RobustBlogPlanner, which places planning and validation inside a bounded loop</li><li>BlogWriter, which writes the article from the outline</li><li>BlogPostValidationChecker, which checks the completed article</li><li>RobustBlogWriter, which coordinates writing and validation</li><li>planner_tool and writer_tool, which expose both workflows as tools</li><li>root_agent, which orchestrates the complete process</li></ul><p>The original codelab connects these agents to a hosted Gemini model. We will retain the agent architecture but replace the cloud-model configuration with our locally hosted Gemma 4 model.</p><h3>Configure __init__.py</h3><p>As shown in the codelab, add the following to __init__.py:</p><pre>from . import agent</pre><p>This exposes the agent workflow to the ADK runner.</p><h3>Modify the imports for local Gemma</h3><p>In the codelab’s agent.py, add:</p><pre>from google.adk.models.lite_llm import LiteLlm</pre><p>You may remove these imports because the supplied implementation does not currently use them:</p><pre>import sys<br>from pathlib import Path</pre><p>Retain:</p><pre>import datetime<br>from dotenv import load_dotenv<br>from google.adk.agents import Agent, LoopAgent<br>from google.adk.tools import agent_tool</pre><h3>Replace the hosted Gemini model</h3><p>The codelab uses:</p><pre>MODEL = os.getenv(&quot;MODEL&quot;, &quot;gemini-flash-latest&quot;)</pre><p>Replace that line with:</p><pre>MODEL = LiteLlm(<br>    model=&quot;ollama_chat/gemma4:e4b&quot;<br>)</pre><p>The beginning of agent.py should therefore look like this:</p><pre>import datetime</pre><pre>from dotenv import load_dotenv<br>from google.adk.agents import Agent, LoopAgent<br>from google.adk.models.lite_llm import LiteLlm<br>from google.adk.tools import agent_tool</pre><pre>load_dotenv()</pre><pre>MODEL = LiteLlm(<br>    model=&quot;ollama_chat/gemma4:e4b&quot;<br>)</pre><p>Leave the remaining Planner, Writer, Validator, LoopAgent, AgentTool, and root_agent definitions as presented in the <a href="https://codelabs.developers.google.com/build-ai-agent-google-adk#5">official codelab</a>.</p><p>Each agent already uses:</p><pre>model=MODEL</pre><p>Consequently, changing the shared MODEL variable redirects the complete multi-agent system from the hosted Gemini API to the Gemma 4 model running through Ollama.</p><p>The official implementation and its detailed architectural explanation are available in <a href="https://codelabs.developers.google.com/build-ai-agent-google-adk#5">Google Codelabs: Build the Multi-Agent Blog Writer</a>.</p><h3>What This Project Demonstrates</h3><p>This project brings several important AI-agent concepts together:</p><ul><li><strong>Reasoning:</strong> Gemma interprets the goal and determines how to approach it.</li><li><strong>Planning:</strong> The Planner Agent creates the article outline.</li><li><strong>Acting:</strong> The Root Blogger Agent invokes specialist workflows.</li><li><strong>Tool use:</strong> Planning and writing workflows are exposed as agent tools.</li><li><strong>Shared state:</strong> Outputs move between the Planner, Writer and Validators.</li><li><strong>Validation:</strong> Specialist agents inspect intermediate results.</li><li><strong>Orchestration:</strong> The Root Blogger Agent coordinates the workflow.</li><li><strong>Iteration:</strong> Bounded loops support revision.</li><li><strong>Local inference:</strong> Ollama runs Gemma 4 on the Mac.</li></ul><p>The result is a practical demonstration of how a locally hosted language model can become the reasoning engine inside a wider agentic system.</p><h3>Full Project Implementation</h3><p>The complete implementation used in this tutorial including the Planner, Writer, validation agents, local Gemma 4 configuration and Root Blogger Agent is available in the following GitHub repository:</p><p><a href="https://github.com/philipobiorah/bloggeragent"><strong>philipobiorah/bloggeragent — GitHub</strong></a></p><p>You can clone the project using:</p><pre>git clone https://github.com/philipobiorah/bloggeragent.git<br>cd bloggeragent</pre><p>Then create and activate a virtual environment:</p><pre>python3 -m venv .venv<br>source .venv/bin/activate</pre><p>Install the dependencies:</p><pre>python -m pip install -r requirements.txt</pre><p>This repository provides the complete local adaptation of Google’s ADK blog-writing example, configured to use Gemma 4 through Ollama and LiteLLM instead of the hosted Gemini API.</p><h3>Conclusion</h3><p>Building an AI agent does not always require a paid model API.</p><p>By combining Gemma 4, Ollama, LiteLLM and Google ADK, we can create a multi-agent application that runs locally on an Apple Silicon Mac.</p><p>The system plans an article, validates the plan, produces a draft, reviews the completed article and returns the final result without incurring per-request model API charges.</p><p>Local deployment also creates a valuable opportunity to examine how agent systems work beneath their conversational interfaces.</p><p>The most important lesson is that an AI agent is more than its language model.</p><p>A capable agent emerges from the combination of:</p><blockquote><strong><em>Model + instructions + tools + state + orchestration + validation + safeguards</em></strong></blockquote><p>Running the model locally provides greater control over the model infrastructure. The design of the surrounding system determines whether that control results in a useful, reliable and responsible application.</p><h3>References</h3><p>Google (2026) <em>Build an AI Agent with Google ADK</em>. Google Codelabs. Available at: <a href="https://codelabs.developers.google.com/build-ai-agent-google-adk">https://codelabs.developers.google.com/build-ai-agent-google-adk</a> (Accessed: 20 August 2026).</p><p>Google (2026) <em>Gemma 4 model overview</em>. Google AI for Developers. Available at: https://ai.google.dev/gemma/docs/core (Accessed: 20 August 2026).</p><p>Google (2026) <em>Ollama model host for ADK agents</em>. Agent Development Kit documentation. Available at: <a href="https://adk.dev/agents/models/ollama/">https://adk.dev/agents/models/ollama/</a> (Accessed: 20 August 2026).</p><p>Ollama (2026) <em>Gemma 4</em>. Available at: <a href="https://ollama.com/library/gemma4">https://ollama.com/library/gemma4</a> (Accessed: 20 August 2026).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ecfd0db9610" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Multimodal RAG Systems with Gemini]]></title>
            <link>https://medium.com/@philipsatimor2/building-multimodal-rag-systems-with-gemini-a6ff515c2d02?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/a6ff515c2d02</guid>
            <category><![CDATA[gemini]]></category>
            <category><![CDATA[multimodal-rag]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[vertex-ai]]></category>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Sat, 01 Aug 2026 16:19:19 GMT</pubDate>
            <atom:updated>2026-08-01T16:19:19.447Z</atom:updated>
            <content:encoded><![CDATA[<p>Modern documents contain far more than plain text. Reports, research papers, manuals and policy documents often include tables, charts, diagrams, images and layouts that carry information which may be lost during conventional text extraction.</p><p>In this tutorial, we will build a multimodal Retrieval-Augmented Generation system using Gemini. The system can retrieve information from both document text and page images before using the retrieved evidence to generate a grounded answer</p><p>The tutorial is supported by a practical Google Colab notebook: <a href="https://github.com/philipobiorah/Multimodal_Retrieval_Augmented_Generation_using_Gemini/blob/main/v2_colab_intro_multimodal_rag_colab.ipynb"><strong>Open the Multimodal RAG Colab notebook</strong></a><br>This implementation was developed and adapted from the Google Skills lab: <strong>Inspect Rich Documents with Gemini Multimodality and Multimodal RAG: </strong><a href="https://www.skills.google/course_templates/981/labs/629204">https://www.skills.google/course_templates/981/labs/629204</a></p><p>The Google Skills lab provides the foundation for the workflow. The accompanying Colab restructures it for teaching by explaining each stage, displaying intermediate results, commenting the code and making the multimodal RAG process explicit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/336/1*Ti9dKZBCH2DZRO2vbUxw5A.png" /></figure><p><em>Figure 1. Multimodal RAG pipeline showing document ingestion, text and image metadata creation, multimodal retrieval, context augmentation, and grounded answer generation with Gemini and source citations.</em></p><h3>What You Will Learn</h3><p>This implementation was developed and adapted from the Google Skills lab: <a href="https://www.skills.google/course_templates/981/labs/629204"><strong>Inspect Rich Documents with Gemini Multimodality and Multimodal RAG</strong></a></p><h3>What you will learn</h3><p>By working through the notebook, you will learn how to:</p><p>1. Explain the Retrieval–Augmentation–Generation pattern.</p><p>2. Extract text and images from rich PDF documents.</p><p>3. Generate Gemini descriptions for document images.</p><p>4. Store text and image metadata with embeddings and source references.</p><p>5. Perform text-to-text retrieval.</p><p>6. Perform text-to-image retrieval using image-description embeddings.</p><p>7. Perform image-to-image retrieval using image embeddings.</p><p>8. Compare retrieved images with Gemini.</p><p>9. Build text and image context for a final multimodal RAG prompt.</p><p>10. Produce grounded answers with text and image citations.</p><h3>What is Retrieval-Augmented Generation?</h3><p>A language model can generate a fluent response, but it may not know the contents of a private document collection. Retrieval-Augmented Generation addresses this by retrieving relevant evidence before generation.</p><p>The process contains three stages:</p><p>· <strong>Retrieval</strong>: find relevant evidence.</p><p>· <strong>Augmentation</strong>: add the retrieved evidence to the prompt.</p><p>· <strong>Generation</strong>: ask the model to answer from that evidence.</p><p>A multimodal RAG system extends the evidence beyond text. It can retrieve paragraphs, tables, charts, diagrams and other images.</p><h3>Multimodal RAG is not simply PDF inspection</h3><p>Sending an entire PDF to Gemini is document inspection. A RAG system first builds searchable metadata, retrieves only the most relevant evidence for a question, and then passes that evidence to the model.</p><p>The workflow therefore has two broad phases:</p><p>1. <strong>Indexing</strong>: extract text and images, create descriptions and embeddings, and store source metadata.</p><p>2. <strong>Question answering</strong>: retrieve relevant text and images, construct context, generate an answer, and print citations.</p><h3>Building text and image metadata</h3><p>The `get_document_metadata()` function processes PDF documents and returns two DataFrames:</p><pre>text_metadata_df</pre><pre>image_metadata_df</pre><p>The text metadata contains the original page text, text chunks, text embeddings, page numbers and file references.</p><p>The image metadata contains extracted images, Gemini-generated descriptions, image paths or objects, text embeddings created from image descriptions, image embeddings, page numbers and source information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/444/1*UqtQM5e3myQDPNOHKOcORQ.png" /><figcaption>Figure 2. Metadata creation workflow: PDF documents are processed through separate text and image pathways before being stored in searchable text and image metadata DataFrames.</figcaption></figure><p>The image pathway does not store only a picture. Gemini creates a description of the picture. If the image is a table, the prompt asks Gemini to extract its elements. If it is a graph, Gemini explains its findings. This description becomes searchable.</p><h3>Why the image-description prompt matters</h3><p>The image-description step uses an instruction similar to:</p><pre>image_description_prompt = &quot;&quot;&quot;Explain what is going on in the image.<br>If it&#39;s a table, extract all elements of the table.<br>If it&#39;s a graph, explain the findings in the graph.<br>Do not include any numbers that are not mentioned in the image.<br>&quot;&quot;&quot;</pre><p>This prompt affects retrieval quality. A vague description such as “a financial chart” is less useful than a description that identifies the title, values, labels, years and relationships shown.</p><h3>Retrieval modes implemented in the workflow</h3><p>The workflow explores retrieval methods individually before combining them into the final RAG pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*1tsRtM6jhr_Cy7hszhUzcg.png" /><figcaption><em>Figure 3. The three retrieval patterns demonstrated: text-to-text, text-to-image, and image-to-image retrieval.</em></figcaption></figure><h3>Text-to-text retrieval</h3><p>A text query is compared with stored text embeddings:</p><pre>matching_results_text = get_similar_text_from_query(<br>    query,<br>    text_metadata_df,<br>    column_name=&quot;text_embedding_chunk&quot;,<br>    top_n=3,<br>    chunk_text=True,<br>)</pre><p>The function retrieves the text chunks most similar to the question.</p><h3>Text-to-image retrieval</h3><p>A text query is compared with embeddings created from Gemini image descriptions:</p><pre>matching_results_image = get_similar_image_from_query(<br>    text_metadata_df,<br>    image_metadata_df,<br>    query=query,<br>    column_name=&quot;text_embedding_from_image_description&quot;,<br>    image_emb=False,<br>    top_n=3,<br>    embedding_size=1408,<br>)</pre><p>The input is text, but the returned evidence is an image. This is cross-modal retrieval.</p><h3>Image-to-image retrieval</h3><p>The notebook also uses an image as the search query:</p><pre>matching_results_image = get_similar_image_from_query(<br>    text_metadata_df,<br>    image_metadata_df,<br>    query=query,<br>    column_name=&quot;mm_embedding_from_img_only&quot;,<br>    image_emb=True,<br>    image_query_path=image_query_path,<br>    top_n=3,<br>    embedding_size=1408,<br>)</pre><p>The input image is embedded and compared with stored image embeddings to retrieve visually or semantically similar images.</p><h3>Comparative reasoning over retrieved images</h3><p>After image retrieval, multiple graphs can be retrieved and compared with Gemini.</p><p>The comparison prompt includes:</p><p>· the retrieved images;</p><p>· Gemini-generated descriptions of those images;</p><p>· questions about similarities, differences, trends and index performance.</p><p>This separates two tasks:</p><p>· <strong>Retrieval</strong>: identify the relevant images.</p><p>· <strong>Reasoning</strong>: analyse the retrieved images together.</p><p>The approach can be adapted to compare annual reports, before-and-after charts, research figures, technical diagrams or product specifications.</p><h3>Bringing everything together: Multimodal RAG</h3><p>The final stage combines the earlier techniques into one end-to-end process.</p><h4>Step 1: User query</h4><p>The user submits several questions as a text query.</p><h4>Step 2: Retrieve relevant text chunks</h4><p>The top text chunks are retrieved from <em>`text_metadata_df`</em> using <em>`text_embedding_chunk`</em>.</p><h4>Step 3: Retrieve relevant images</h4><p>It retrieves the top images from <em>`image_metadata_df`</em> using <em>`text_embedding_from_image_description`</em>.</p><h4>Step 4: Build multimodal context</h4><p>The selected text chunks are joined into:</p><pre>final_context_text</pre><p>The selected images and their Gemini descriptions are added to:</p><pre>context_images</pre><h4>Step 5: Pass context to Gemini</h4><p>The grounding prompt includes both text and image context and instructs Gemini to answer the questions, explain the reasoning and return “Not enough context to answer” when the evidence is insufficient.</p><h4>Step 6: Print citations and references</h4><p>The retrieved images are displayed alongside:</p><p>· <em>image citations;</em></p><p>· <em>text citations</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/502/1*KjvByK_HiHxzTZ9sdUJHmg.png" /><figcaption>Figure 5. Final multimodal RAG assembly: retrieved text chunks and retrieved images with descriptions are combined into context, passed to Gemini, and linked to text and image citations.</figcaption></figure><h3>Where Retrieval, Augmentation and Generation appear</h3><h3>Retrieval</h3><pre>matching_results_chunks_data = get_similar_text_from_query(…)<br>matching_results_image_fromdescription_data = get_similar_image_from_query(…)</pre><h3>Augmentation</h3><pre>final_context_text = &quot;\n&quot;.join(context_text)<br> context_images.extend(<br> [&quot;Image: &quot;, value[&quot;image_object&quot;],<br> &quot;Caption: &quot;, value[&quot;image_description&quot;]]<br> )</pre><h3>Generation</h3><pre>get_gemini_response(<br> model,<br> model_input=[prompt],<br> stream=True,<br> )</pre><p>The pipeline is therefore not simply a Gemini prompt containing a PDF. Evidence is retrieved first, a multimodal context is constructed, and Gemini then reasons over the selected evidence.</p><h3>Metadata and citations</h3><p>Source metadata is essential because the final answer should be verifiable.</p><p>The retained metadata includes:</p><p>· document name;</p><p>· page number;</p><p>· chunk text;</p><p>· image path;</p><p>· image description;</p><p>· embedding;</p><p>· similarity score.</p><p>The citation functions expose the source evidence used during retrieval. This helps with debugging, trust and auditability.</p><h3>Evaluation questions</h3><p>A useful multimodal RAG evaluation should examine three areas.</p><h4>Retrieval quality</h4><p>· Was the correct text chunk retrieved?</p><p>· Was the relevant table, chart or image returned?</p><p>· Did the correct evidence appear in the top results?</p><p>· Were irrelevant items ranked too highly?</p><h4>Answer quality</h4><p>· Is the answer supported by the retrieved context?</p><p>· Does it correctly interpret visual relationships?</p><p>· Does it avoid inventing missing values?</p><p>· Does it state when the context is insufficient?</p><h4>Citation quality</h4><p>· Does each citation point to the correct page or image?</p><p>· Does the cited evidence support the corresponding claim?</p><p>· Can the reader verify the answer quickly?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a6ff515c2d02" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Open Models, Real Agents: How Gemma 4 Brings Reasoning and Multimodal AI to Local Devices]]></title>
            <link>https://medium.com/@philipsatimor2/open-models-real-agents-how-gemma-4-brings-reasoning-and-multimodal-ai-to-local-devices-9f2472451d4c?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f2472451d4c</guid>
            <category><![CDATA[gemma]]></category>
            <category><![CDATA[gemma-4]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[open-model]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Sat, 11 Jul 2026 14:58:43 GMT</pubDate>
            <atom:updated>2026-07-11T14:58:43.303Z</atom:updated>
            <content:encoded><![CDATA[<p>Google’s latest Gemma family is not simply a smaller alternative to a cloud model. It is an attempt to make capable, multimodal and agentic AI practical on phones, laptops and developer workstations.</p><p>At Google I/O Connect Berlin, one of the sessions that stood out to me was <strong>“Gemma: Open models in the agentic era,”</strong> delivered by <strong>Gus Martins, Product Manager at Google DeepMind, and Ian Ballantyne, Developer Relations Engineer for AI</strong>.</p><p>The session explored the Gemma family of open models and the tools developers can use to move from model discovery to deployment. It also showed how developers can experiment with Gemma using familiar tools and scale AI experiences directly to users across cloud, desktop and mobile environments.</p><p>The session explored how the Gemma family has evolved from efficient text and vision models into a set of open models designed for reasoning, tool use, multimodal understanding and local agentic workflows.</p><blockquote><em>The future of AI agents will not exist exclusively inside large cloud platforms. Some agents will run directly on the devices where their users, applications and data already live.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HDYTjfFrXHQ2ebT5C0zvtw.jpeg" /><figcaption><em>Gemma 4 introduces reasoning, function calling, longer context windows and an expanded range of multimodal models</em></figcaption></figure><h3>Gemma is no longer just about building smaller models</h3><p>The Gemma family has always focused heavily on efficiency: delivering as much capability as possible within a relatively small number of parameters.</p><p>That objective remains, but Gemma 4 expands the definition of efficiency.</p><p>It is no longer simply:</p><blockquote><em>How accurately can a smaller model generate text?</em></blockquote><p>The more useful engineering question is now:</p><blockquote><em>How much of a complete AI application can run locally without depending on a continuous connection to a remote model endpoint?</em></blockquote><p>An agent must do more than generate a response. It may need to interpret an image, understand speech, maintain context, reason through a task, select a tool, produce structured arguments and continue once the application returns the tool’s result.</p><p>Gemma 4 was presented as a family designed around these wider requirements.</p><p>Google describes the models as supporting configurable reasoning, multimodal inputs, long-context processing, coding and native function calling. The family includes <strong>E2B, E4B, 12B, 26B A4B and 31B</strong> variants, spanning devices from high-end phones to laptops, workstations and servers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TtLQhQm7j2FXmBYnX9Voiw.jpeg" /><figcaption><em>The session positioned Gemma around four connected capabilities: vision, agentic reasoning, audio and text understanding.</em></figcaption></figure><h3>What changed with Gemma 4?</h3><p>The comparison presented during the session highlighted several important changes from Gemma 3 and Gemma 3n.</p><h3>Reasoning becomes part of the model family</h3><p>Gemma 4 models support configurable “thinking” behaviour for tasks that require several stages of analysis.</p><p>That is particularly relevant for:</p><ul><li>planning a sequence of actions;</li><li>analysing documents and visual information;</li><li>debugging code;</li><li>decomposing a user request;</li><li>deciding whether a tool is required;</li><li>interpreting a tool’s result before continuing.</li></ul><p>This does not make the model automatically reliable. It does, however, provide a stronger foundation for applications that require more than one-shot text generation.</p><h3>Function calling becomes a first-class capability</h3><p>Earlier local-model workflows often depended on carefully engineered prompts that instructed the model to imitate JSON.</p><p>That approach is fragile. A slightly malformed response can break the parser or trigger the wrong application behaviour.</p><p>Gemma 4 introduces native function-calling support. Developers can describe a tool using a schema, allow the model to select the appropriate function and then validate the generated arguments before execution.</p><p>The distinction between <strong>selecting a tool</strong> and <strong>executing a tool</strong> is important. Gemma generates the proposed function call; the surrounding application remains responsible for validating and executing it safely.</p><p>This creates a more practical architecture:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TrCDPgXQwOArG-wGADnyJQ.png" /><figcaption>The Gemma system workflow : a seven step process from user request to final response, showing reasoning, function selection, execution, and result delivery.</figcaption></figure><h3>Multimodality is becoming a local capability</h3><p>Gemma 4 supports text and image inputs across the family, while the E2B, E4B and 12B variants also support audio. The models can process video through sequences of frames and, depending on the model, support context windows of up to 256,000 tokens.</p><p>That means a locally running application could potentially:</p><ul><li>analyse a screenshot and explain an interface problem;</li><li>inspect a chart and produce a written interpretation;</li><li>transcribe and translate recorded speech;</li><li>process a collection of documents;</li><li>review code alongside related technical diagrams;</li><li>understand frames and audio extracted from a video;</li><li>accept natural-language instructions and call an approved local tool.</li></ul><p>These capabilities matter because they reduce the need to divide every modality across a separate cloud service.</p><p>An application may still use specialist services when they are appropriate, but local multimodal processing gives developers another architectural option especially where privacy, latency, offline operation or predictable cost matters.</p><h3>Different models for different deployment environments</h3><p>A particularly useful part of the presentation was the explanation that Gemma 4 is not one model reduced into several arbitrary sizes.</p><p>The family contains different architectural choices optimised for different deployment conditions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qRlRfANeSHIOPokPLFKniA.jpeg" /><figcaption><em>Gemma 4 uses different architectural strategies across edge, laptop, workstation and server deployments.</em></figcaption></figure><h3>E2B and E4B: efficient models for edge devices</h3><p>The “E” refers to effective parameters.</p><p>These models use <strong>per-layer embeddings</strong>, allowing the decoder to achieve stronger capability without requiring the same active computation as a conventionally dense model of similar total size.</p><p>They are intended for constrained environments such as phones, embedded systems and lightweight local applications.</p><p>Potential use cases include:</p><ul><li>offline assistants;</li><li>mobile document analysis;</li><li>image-based accessibility features;</li><li>local speech translation;</li><li>personal productivity tools;</li><li>device-based agents that interact with approved app functions.</li></ul><h3>Gemma 4 12B: unified multimodal processing</h3><p>The 12B model is especially interesting because it uses a unified, encoder-free multimodal architecture.</p><p>Traditional multimodal systems frequently process images and audio through separate encoders before passing their representations to a language model. Gemma 4 12B instead brings the modalities more directly into a shared model architecture, reducing fragmentation and potentially simplifying fine-tuning.</p><p>Google describes it as the first medium-sized Gemma model capable of natively ingesting audio, while remaining small enough to run on suitably equipped consumer laptops.</p><p>For developers, this could make the 12B model a practical middle ground:</p><ul><li>substantially more capable than a small mobile model;</li><li>deployable without a large inference cluster;</li><li>suitable for multimodal local applications;</li><li>easier to integrate into private or offline workflows.</li></ul><h3>Gemma 4 31B: dense capability for workstations</h3><p>The 31B model is designed for environments where developers have more compute and need stronger reasoning, coding and long-context performance.</p><p>It could be appropriate for:</p><ul><li>local coding assistants;</li><li>research tools;</li><li>document intelligence;</li><li>enterprise workstations;</li><li>controlled private inference;</li><li>local agent servers shared across an internal network.</li></ul><h3>Gemma 4 26B A4B: Mixture of Experts</h3><p>The 26B A4B version uses a <strong>Mixture-of-Experts</strong> architecture.</p><p>Although the model contains approximately 26 billion parameters, only a subset — around four billion active parameters — is used for each token. The model must still be loaded into memory, but the active computation can be more efficient than a fully dense model of comparable total size.</p><p>This makes it particularly interesting for developers balancing model capability, inference speed and hardware utilisation.</p><h3>Local AI is an architectural decision, not merely a cost-saving technique</h3><p>Running a model locally is sometimes described only as a way to avoid API charges. That is too narrow. Local inference changes the architecture of the entire application.</p><h3>Privacy</h3><p>Sensitive text, images, audio or organisational data may remain on the device or within a controlled environment.</p><h3>Latency</h3><p>The application does not need to wait for a round trip to a remote endpoint for every model interaction.</p><h3>Offline resilience</h3><p>Selected functionality can continue when connectivity is unavailable or unreliable.</p><h3>Predictable operation</h3><p>Applications can avoid unexpected variation caused by network conditions, rate limits or external service availability.</p><h3>Customisation and control</h3><p>Developers can choose the model, quantisation level, runtime, prompt structure, tool permissions and deployment environment.</p><p>Google’s AI Edge stack is intended to support Gemma across mobile, desktop, web and embedded hardware, with runtimes such as LiteRT-LM providing quantisation, constrained decoding, session handling and hardware acceleration.</p><h3>Benchmarks matter, but deployment fit matters more</h3><p>The session included comparisons across reasoning, coding, multilingual understanding and agent-focused benchmarks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XdVWKksMABc0YOxVFuWKAg.jpeg" /><figcaption><em>Gemma 4 variants were compared across reasoning, coding, knowledge and agentic benchmarks.</em></figcaption></figure><p>These benchmark improvements are important, especially because smaller models must work within stricter memory and compute limits.</p><p>However, the most capable benchmark model is not automatically the best model for an application.</p><p>Developers still need to evaluate:</p><ul><li>response quality on their own data;</li><li>available RAM or VRAM;</li><li>prompt and context length;</li><li>acceptable latency;</li><li>quantisation effects;</li><li>energy consumption;</li><li>tool-selection accuracy;</li><li>structured-output reliability;</li><li>privacy requirements;</li><li>expected concurrent users.</li></ul><p>A smaller model that responds quickly, operates privately and calls tools reliably may be more valuable than a larger model that achieves a higher general benchmark score but cannot meet the application’s operational constraints.</p><h3>Multilingual AI should also work outside the cloud</h3><p>Another focus of the presentation was Gemma’s expanded multilingual capability.</p><p>The official Gemma 4 model card states support for more than 140 languages, while the session highlighted results across several European languages and Japanese.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w6e8zW1EdbYmq9M7ZEJ3DA.jpeg" /><figcaption><em>The presentation highlighted expanded language support across European and Asian language benchmarks.</em></figcaption></figure><p>This is significant for local AI.</p><p>A multilingual assistant that runs on-device can support:</p><ul><li>offline translation;</li><li>local-language educational tools;</li><li>accessibility applications;</li><li>fieldwork in areas with limited connectivity;</li><li>community-specific fine-tuning;</li><li>language technology for underrepresented groups.</li></ul><p>Open models also allow researchers and developer communities to study weaknesses, adapt models and build domain-specific versions for languages that may not receive sufficient attention in general-purpose commercial systems.</p><h3>From open models to an open agent ecosystem</h3><p>One slide reported more than <strong>200 million Gemma downloads</strong> and significant adoption through Google AI Edge Gallery within the early weeks of the release.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBM5EqYrLEoyGCux8Jx_Cg.jpeg" /><figcaption><em>The session highlighted rapid developer adoption across Hugging Face, local runtimes and Google AI Edge Gallery.</em></figcaption></figure><p>The important part of that adoption is not only the download count.</p><p>An open model becomes useful when a wider ecosystem forms around it:</p><ul><li>quantised checkpoints;</li><li>inference runtimes;</li><li>fine-tuning libraries;</li><li>mobile integrations;</li><li>agent frameworks;</li><li>evaluation tools;</li><li>community examples;</li><li>model adaptations;</li><li>safety research;</li><li>hardware-specific optimisation.</li></ul><p>Gemma 4 is available under the <strong>Apache 2.0 licence</strong>, which gives developers significantly more flexibility to integrate, modify and distribute model-based applications than was available under earlier Gemma-specific terms.</p><p>That could encourage Gemma to become not simply a model people experiment with, but a foundation for applications that developers can adapt and operate within their own environments.</p><h3>What this means for developers</h3><p>Developers can now ask more nuanced questions:</p><ul><li>Which interactions should remain on the device?</li><li>Which tasks require a larger cloud model?</li><li>Can a local model act as an intelligent router?</li><li>Can sensitive information be processed before anything leaves the device?</li><li>Can a local agent use tools while remaining inside a controlled sandbox?</li><li>Can a smaller model provide enough capability for the actual user requirement?</li><li>Can the application continue functioning when the network is unavailable?</li></ul><p>Gemma 4 gives developers more credible options for answering those questions</p><h3>Final thoughts</h3><p>Gemma 4 represents a shift from open models that can generate content to open models that can participate in agentic systems.</p><p>Reasoning, multimodality, long context and function calling are increasingly becoming available outside the largest proprietary cloud endpoints.</p><p>That creates an opportunity to build AI systems that are:</p><ul><li>more private;</li><li>more responsive;</li><li>easier to customise;</li><li>resilient to connectivity problems;</li><li>deployable across a wider range of devices;</li><li>better aligned with specific organisational or community needs.</li></ul><p>The agentic era will not be powered by one model size, one runtime or one deployment platform. It will require a spectrum of models — from small edge models executing focused skills to larger systems coordinating complex workflows.</p><p>Gemma 4 is Google DeepMind’s attempt to make that spectrum available to developers in an open and deployable form.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f2472451d4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The ABCs of Agent Building: Why Google’s ADK Is More Than Another LLM Framework]]></title>
            <link>https://medium.com/@philipsatimor2/the-abcs-of-agent-building-why-googles-adk-is-more-than-another-llm-framework-0ac046109edd?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/0ac046109edd</guid>
            <category><![CDATA[agent-development-kit]]></category>
            <category><![CDATA[google-gemini]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[google-ioconnet-berlin]]></category>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Wed, 08 Jul 2026 12:14:03 GMT</pubDate>
            <atom:updated>2026-07-08T12:17:12.553Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most practical sessions at Google I/O Connect Berlin was <strong>“The ABCs of Agent Building: ADK and Beyond,”</strong> delivered by <strong>Elia Secchi, Developer Advocate for Cloud AI, and Polong Lin, Developer Relations Manager for Cloud AI</strong>. The session explored how developers can use coding agents with the <strong>Agents CLI</strong> to manage the full lifecycle of Agent Development Kit applications, from local development to production deployment on Google Cloud</p><p>From state management and tool calling to evaluation, deployment and multi-agent orchestration, Google is turning agent development into an engineering discipline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YCpIdQjDTrzD22rAHktDsg.jpeg" /><figcaption>The session “The ABCs of agent building: ADK and beyond” at Google I/O Connect Berlin.</figcaption></figure><p>For much of the recent generative-AI boom, building an “AI application” often meant connecting a user interface to a large language model, writing a detailed system prompt and displaying the response.</p><p>That approach works well for demonstrations.</p><p>It becomes much less convincing when the application must maintain context, invoke external tools, coordinate several specialised agents, recover from errors, support real-time interactions and operate reliably in production.</p><p>The central message was that the industry is moving beyond conversational wrappers and towards systems that can make decisions, use tools and complete real-world tasks.</p><p>Google’s Agent Development Kit (ADK ) is designed to provide the engineering structure needed to build those systems. The most important takeaway was not that agents are becoming easier to prototype. It was that agent development is beginning to resemble a complete software-engineering discipline.</p><h3>The transition from chatbots to systems that act</h3><p>One of the opening slides captured how quickly the definition of an AI application is changing.</p><p>A year ago, the dominant experience was the interactive chatbot: a user sends a message, the model generates a response and the interaction ends.</p><p>The emerging agent landscape is broader.</p><p>It includes:</p><ul><li>interactive agents that communicate with users;</li><li>background agents that process information without continuous human interaction;</li><li>real-time audio and video agents;</li><li>systems that coordinate tools and services;</li><li>and multi-agent applications in which specialised agents collaborate.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eV8EJwbuTBn1GysW1M2GPw.jpeg" /><figcaption><em>The agent landscape is expanding from interactive chat towards background processing and real-time audio and video systems.</em></figcaption></figure><p>The key transition is therefore not simply from one model generation to a better model generation.</p><p>It is the transition from <strong>generating an answer</strong> to <strong>executing a process</strong>.</p><p>A chatbot may tell a customer how to resolve a problem. An agent could inspect the customer’s account, search internal documentation, call an approved service, update a record and request human authorisation when necessary.</p><p>That difference introduces a much larger engineering surface. Once a model can act, developers must consider permissions, state, tool contracts, validation, observability, recovery and governance. The intelligence of the underlying model is only one part of the system.</p><h3>What is an AI agent?</h3><p>The session offered a useful definition:</p><blockquote><em>An AI agent is an application that uses models to make decisions and act independently in order to achieve a user-specified goal.</em></blockquote><p>The accompanying architecture separated an agent into two foundational capabilities:</p><p><strong>Models</strong>, which provide interpretation, reasoning and decision-making.</p><p><strong>Skills and tools</strong>, which allow the application to interact with software systems and the external world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fwxA8EfSAKN3TL80pBjmeA.jpeg" /><figcaption>Definition of an agent</figcaption></figure><p><em>An agent combines model intelligence with the skills and tools required to pursue a user-specified goal.</em></p><p>This distinction matters because a capable model is not automatically a capable agent.</p><p>A model may understand that a user wants to reschedule a meeting. The agent still needs access to the calendar, permission to read existing events, a method for identifying available times, validation before making changes and a clear policy governing when it should ask for confirmation.</p><p>The agent is therefore not the model alone. It is the complete application around the model.</p><p>That application needs:</p><ul><li>instructions and goals;</li><li>access to relevant context;</li><li>tools with well-defined interfaces;</li><li>state and memory;</li><li>an execution loop;</li><li>safeguards and permissions;</li><li>evaluation;</li><li>deployment infrastructure;</li><li>and monitoring.</li></ul><p>This is why frameworks such as ADK are becoming important.</p><h3>Why agent development needs a framework</h3><p>It is possible to create a basic agent loop manually.</p><p>A developer can send a request to a model, inspect whether the model wants to use a tool, execute the tool, send the result back and continue until a final answer is produced.</p><p>The difficulty is that this simple loop becomes complicated very quickly.</p><p>The session identified four areas that frameworks must help manage.</p><h3>State management</h3><p>How is conversation history stored? How does information move between turns? What happens when a session is interrupted or transferred to another component?</p><h3>Tool calling and parsing</h3><p>How does the application distinguish between a final answer and a tool request? How are tool names, parameters and outputs validated? What happens when the model generates incomplete or incorrect arguments?</p><h3>Orchestration</h3><p>What happens when one agent needs assistance from another? How are sequential, parallel and conditional workflows represented without creating an unmanageable network of custom control logic?</p><h3>Boilerplate</h3><p>Without a framework, each team repeatedly implements the same execution loops, error handling, schemas, logging and session management.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BPnG4Uy3Pa5v-LBVh6g3Ww.jpeg" /><figcaption>Why agent development needs a framework</figcaption></figure><p><em>Agent frameworks absorb recurring complexity around state, tools, orchestration and boilerplate.</em></p><p>This is a familiar pattern in software engineering.</p><p>Web developers could manually manage socket connections, route every request and build templating systems from scratch. In practice, they use frameworks because standardising common infrastructure leaves more time for application-specific work.</p><p>Agent frameworks are beginning to perform a similar role for AI systems.</p><h3>Why ADK?</h3><p>Google positioned ADK around five characteristics:</p><ul><li>an easy-to-use interface;</li><li>a modular and flexible design;</li><li>instant local testing;</li><li>native multimodal support;</li><li>and deployment readiness without restricting the developer to one deployment target.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ATM_2pMk66nUlCcVSEb2JA.jpeg" /><figcaption>Why ADK</figcaption></figure><p><em>Google positioned ADK as modular, locally testable, multimodal and deployment-ready.</em></p><p>The <strong>modular</strong> part is especially important.</p><p>Agent applications are unlikely to share one universal architecture. A customer-support agent, a research assistant, a coding agent and an industrial monitoring system have different requirements.</p><p>Developers therefore need to change models, tools, storage, orchestration strategies and deployment environments without redesigning the entire system.</p><p>ADK’s value is not that it supplies one pre-built agent. Its value is that it provides reusable components for assembling different types of agent systems.</p><p>Local testing is equally significant. Agent behaviour is probabilistic and tool-dependent, which makes rapid inspection essential. Developers need to observe how an agent interprets a request, why it selected a particular tool, what arguments it generated and how each step influenced the final output.</p><p>A framework that shortens that feedback loop can make experimentation considerably more productive.</p><h3>ADK is trying to cover the complete agent lifecycle</h3><p>One of the most detailed slides presented ADK as more than a small wrapper around a model API.</p><p>Its capabilities were organised across the agent lifecycle:</p><ul><li>agents;</li><li>tools;</li><li>orchestration;</li><li>callbacks;</li><li>bidirectional streaming;</li><li>session management;</li><li>evaluation;</li><li>deployment;</li><li>artifact management;</li><li>memory;</li><li>code execution;</li><li>planning;</li><li>debugging;</li><li>tracing;</li><li>and model integration.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ghdW1Hg0-9ngklrr413UOA.jpeg" /><figcaption>ADK Capabilities</figcaption></figure><p><em>ADK brings agent definition, tools, memory, planning, evaluation, debugging and deployment into one development model.</em></p><p>The inclusion of debugging and tracing beneath the higher-level components is revealing.</p><p>As agent applications become more autonomous, developers need visibility into the path between input and outcome. A final answer alone is not enough for diagnosing failures.</p><p>Consider an agent that gives an incorrect travel recommendation. The underlying cause could be:</p><ul><li>an unclear user request;</li><li>unsuitable instructions;</li><li>the wrong tool being selected;</li><li>incorrect arguments;</li><li>outdated retrieved data;</li><li>a failed API call;</li><li>a memory issue;</li><li>or a flawed hand-off between agents.</li></ul><p>Traditional application logs may show that a request completed successfully while revealing very little about the agent’s decision process.</p><p>Tracing must therefore capture the sequence of model calls, tool invocations, state changes and agent transfers that produced the result.</p><h3>Writing the agent is becoming the easy part</h3><p>One of the strongest statements from the session was:</p><blockquote><em>With ADK, writing the agent code is the easy part.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FtkBKKVf76Qz1-qB2CdtUA.jpeg" /><figcaption>Writing the agent code is the easy part</figcaption></figure><p><em>The difficult work begins after the initial agent has been defined.</em></p><p>This is both encouraging and cautionary.</p><p>ADK can reduce the amount of code required to define an agent’s model, name, instructions and available tools. It can also provide structure for sessions, memory and orchestration.</p><p>But reducing the code required to define an agent does not eliminate the complexity of building a dependable product.</p><p>Developers still need to answer questions such as:</p><ul><li>Is the agent solving a task that should be automated?</li><li>What authority should it have?</li><li>Which actions require human approval?</li><li>How will its performance be measured?</li><li>How does it behave when a tool becomes unavailable?</li><li>How are sensitive data and credentials protected?</li><li>How are failures investigated?</li><li>Can the system be reproduced and tested consistently?</li></ul><p>The agent declaration may be small. The surrounding engineering is not.</p><p>This is comparable to defining a machine-learning model in a few lines of code. The model definition is often the easiest part. Data quality, experimentation, deployment, monitoring and maintenance determine whether it becomes a reliable system.</p><h3>Production exposes a fragmented ecosystem</h3><p>The session then highlighted a major problem: deploying agent applications often requires developers to assemble several disconnected products and services.</p><p>The agent code sits at the centre, but production systems also need:</p><ul><li>security;</li><li>data and vector databases;</li><li>integration protocols such as MCP and A2A;</li><li>continuous integration and deployment;</li><li>evaluation;</li><li>observability;</li><li>runtime infrastructure;</li><li>and publishing channels.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LWj_muUneosV9Awy3N5jBA.jpeg" /><figcaption>The fragmented agent ecosystem</figcaption></figure><p><em>Agent code is only one component within a wider production ecosystem.</em></p><p>This fragmentation can slow development because each integration has its own configuration, identity model, logging format and deployment process.</p><p>A prototype may work on a developer’s laptop while depending on hidden assumptions:</p><ul><li>locally stored credentials;</li><li>manually created resources;</li><li>unversioned prompts;</li><li>test data that does not reflect production;</li><li>tool access that is broader than necessary;</li><li>and no evaluation gate before release.</li></ul><p>Moving that system into production requires more than placing the code in a container.</p><p>It requires a reproducible lifecycle.</p><p>This is where Google’s wider platform strategy becomes visible. ADK provides a developer framework, while the surrounding cloud platform provides runtime, security, observability, evaluation and governance.</p><h3>From a framework to an enterprise agent platform</h3><p>The session presented the Gemini Enterprise Agent Platform through four layers: <strong>Build, Scale, Govern and Optimize</strong>.</p><p>The build layer included ADK, third-party frameworks, models, grounding, search, RAG, APIs, connectors and agent communication protocols.</p><p>The scale layer included agent runtimes, sessions, sandboxing and memory.</p><p>The governance layer included identity, policy, registry, security, compliance and anomaly detection.</p><p>The optimisation layer included evaluation, simulation and observability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7oxzXhiSwDFcR5GxvY4vlQ.jpeg" /><figcaption>Gemini Enterprise Agent Platform</figcaption></figure><p><em>The platform view expands agent development into building, scaling, governing and optimising.</em></p><p>This layered view is useful even for teams that do not adopt every Google Cloud component. It provides a practical checklist for evaluating an agent architecture.</p><h3>Build</h3><p>Can developers define the agent, connect models, access data and integrate tools?</p><h3>Scale</h3><p>Can the system manage concurrent users, long-running sessions, memory and isolated execution environments?</p><h3>Govern</h3><p>Can the organisation control identities, permissions, policies, registered agents and compliance requirements?</p><h3>Optimize</h3><p>Can teams evaluate behaviour, simulate scenarios, inspect traces and improve performance over time?</p><p>Many early agent projects concentrate almost entirely on the build layer. Production readiness depends just as heavily on the other three.</p><h3>Multi-agent systems introduce organisational questions</h3><p>ADK also supports multi-agent applications.</p><p>This does not mean every task should be divided among several agents. Introducing more agents creates new communication, coordination and debugging costs.</p><p>However, multi-agent architectures can be useful when a workflow contains clearly separated responsibilities.</p><p>For example, a data-analysis system might contain:</p><ul><li>a planning agent that interprets the business question;</li><li>a data agent that retrieves approved datasets;</li><li>an analysis agent that executes statistical or analytical tasks;</li><li>a validation agent that checks assumptions and calculations;</li><li>and a reporting agent that prepares the result for the user.</li></ul><p>The value comes from separation of responsibility rather than from simply increasing the number of agents.</p><p>Each specialist can have its own instructions, tools and permissions. The data-retrieval agent may have read-only database access, while the reporting agent may have no database credentials at all.</p><p>This can make a system easier to control, but only when the boundaries are explicit.</p><p>Without clear contracts, a multi-agent application can become a distributed collection of prompts passing ambiguous text to one another.</p><p>The same principles that govern distributed software systems still apply: define interfaces, minimise unnecessary dependencies, validate messages and make failures observable.</p><h3>The lifecycle cannot remain a manual process</h3><p>Another part of the session introduced <strong>Agents CLI</strong> as a way of automating the agent development lifecycle.</p><p>The lifecycle shown included:</p><ol><li>defining the persona and scope;</li><li>exploring capabilities and tools;</li><li>designing the cognitive architecture;</li><li>implementing tools;</li><li>engineering context;</li><li>evaluating the agent;</li><li>performing user-acceptance testing;</li><li>deploying infrastructure;</li><li>moving through CI/CD into production;</li><li>observing the deployed system;</li><li>and iterating on the approach.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SS4Lutmm2JmAQC_QAXI7ew.jpeg" /><figcaption><em>The agent lifecycle extends from local development through evaluation, deployment, observation and iteration</em></figcaption></figure><p><em>The agent lifecycle extends from local development through evaluation, deployment, observation and iteration.</em></p><p>This is an important shift.</p><p>Agent applications should not be deployed through a sequence of informal notebook experiments and manual configuration changes. Their instructions, tool definitions, evaluations and deployment configuration should be versioned and repeatable.</p><p>A disciplined agent workflow should make it possible to answer:</p><ul><li>Which version of the instructions produced this behaviour?</li><li>Which model was used?</li><li>Which tools were available?</li><li>What evaluation results were required before deployment?</li><li>What changed between releases?</li><li>Can an earlier version be restored?</li></ul><p>These questions are standard in modern software and machine-learning operations. Agent engineering will need the same maturity.</p><h3>Evaluation must test behaviour, not just answers</h3><p>Evaluating agents is more complicated than checking whether a generated response sounds reasonable.</p><p>An agent may produce a correct final answer through an unsafe or unnecessarily expensive sequence of actions. It may select the wrong tool but recover accidentally. It may expose sensitive information in an intermediate step even when the final response appears harmless.</p><p>Evaluation therefore needs to cover both outcomes and trajectories.</p><p>Useful evaluation dimensions include:</p><ul><li>whether the user’s goal was achieved;</li><li>whether the correct tools were selected;</li><li>whether tool arguments were valid;</li><li>whether unnecessary actions were avoided;</li><li>whether policies and permissions were respected;</li><li>how long the task took;</li><li>how much it cost;</li><li>how the system handled unavailable tools;</li><li>and whether a human could understand the resulting trace.</li></ul><p>An agent that succeeds 90% of the time may still be unsuitable for a workflow where the remaining 10% can create irreversible changes.</p><p>The required standard depends on the task, the available safeguards and the consequences of failure.</p><h3>What developers should take away from ADK</h3><p>The session reinforced several practical lessons.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KB8-TBL2I5dPiQPGg5wKzQ.png" /><figcaption>Collaborating with Francis and connecting with the developer community at the Google I/O Connect Berlin conference.</figcaption></figure><h3>Start with a workflow, not with the word “agent”</h3><p>Identify the user’s goal, the decisions involved and the systems that must be accessed. Do not introduce autonomy where a deterministic workflow would be safer and simpler.</p><h3>Keep tools narrow and explicit</h3><p>A tool should have a clear purpose, validated parameters and limited permissions. Broad tools increase the number of ways an agent can behave unexpectedly.</p><h3>Separate reasoning from authority</h3><p>A model may recommend an action without being authorised to execute it. High-impact operations should include approval or policy checks.</p><h3>Treat prompts and instructions as versioned application assets</h3><p>They influence system behaviour and should be reviewed, tested and tracked like source code.</p><h3>Design for observability from the beginning</h3><p>Do not wait for production failures before adding tracing. Record the model calls, tools, state transitions and hand-offs required to explain agent behaviour.</p><h3>Evaluate the complete trajectory</h3><p>A good final answer does not prove that the underlying process was correct, efficient or safe.</p><h3>Build for failure</h3><p>Tools will time out. APIs will change. Models will occasionally produce malformed requests. Production systems require retries, fallbacks, validation and clear escalation paths.</p><h3>ADK’s real significance</h3><p>It would be easy to describe ADK as another framework in an already crowded agent ecosystem.</p><p>That description misses the wider significance.</p><p>ADK reflects a change in how Google expects developers to build AI applications. The model is no longer treated as the complete product. It becomes one component inside a larger system of tools, sessions, memory, orchestration, evaluation, runtime infrastructure and governance.</p><p>The direction is clear:</p><ul><li>prototypes must become reproducible;</li><li>model outputs must become traceable;</li><li>tools must become governed interfaces;</li><li>agent behaviour must become measurable;</li><li>and deployment must become part of an automated lifecycle.</li></ul><p>The competitive advantage will not come only from choosing the most capable model.</p><p>It will come from building the most dependable system around that model.</p><h3>Final thoughts</h3><p>The session’s title referred to the “ABCs” of agent building, but the content extended well beyond an introduction.</p><p>It presented a view of agent development in which local experimentation, multimodal interaction, tool use, memory, multi-agent coordination, deployment, security, evaluation and observability are parts of one connected discipline.</p><p>ADK attempts to make the first stage defining and testing an agent simpler.</p><p>The wider Google Cloud agent platform addresses the harder question: how that agent becomes a scalable, governed and continuously improving production system.</p><p>The future of AI development is not simply about writing better prompts.</p><p>It is about engineering systems that can reason, act and be trusted.</p><p>And that is where the real work of agent building begins.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0ac046109edd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inside the Google DeepMind AI Stack for Developers: Models, Multimodality and the New Creative…]]></title>
            <link>https://medium.com/@philipsatimor2/inside-the-google-deepmind-ai-stack-for-developers-models-multimodality-and-the-new-creative-22d579115c3a?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/22d579115c3a</guid>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[gemini]]></category>
            <category><![CDATA[google-deepmind]]></category>
            <category><![CDATA[multimodal-ai]]></category>
            <category><![CDATA[connectio]]></category>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 14:25:38 GMT</pubDate>
            <atom:updated>2026-07-06T14:25:38.361Z</atom:updated>
            <content:encoded><![CDATA[<h3>Inside the Google DeepMind AI Stack for Developers: Models, Multimodality and the New Creative Layer</h3><p><em>The Google DeepMind AI stack is no longer organised around a single model answering a single prompt. At Google I/O Connect Berlin 2026, the more important story was the emergence of a programmable, multimodal platform that can understand different forms of input, generate different forms of output, call tools and support complete application workflows.</em></p><p><em>The Gemini API was presented as a multimodal interface that can accept text, code, images, audio, video, speech, API information and URLs, while returning text, media, code and function calls.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YEIVDN2bJniiINaaYdsQ7w.png" /><figcaption>The Gemini API was presented as a multimodal interface that can accept text, code, images, audio, video, speech, API information and URLs, while returning text, media, code and function calls.</figcaption></figure><p>For much of the generative-AI era, developers have interacted with models through a familiar pattern:</p><blockquote><em>Send text in. Receive text out.</em></blockquote><p>That pattern was useful, but it also encouraged a narrow view of what an AI model could become inside a software system.</p><p>The session <strong>“Google DeepMind AI Stack for Developers”</strong> at Google I/O Connect Berlin 2026 presented a much broader direction. The model is becoming part of an application runtime: one that can process several modalities, use external tools, maintain structured interactions and produce media as well as language.</p><p>The most important shift is therefore not simply that Gemini models are becoming more capable.</p><p>It is that the surrounding developer stack is becoming more coherent.</p><p>Models, APIs, tools, application builders, media-generation systems and agent workflows are being connected into a platform that developers can program as a whole.</p><h3>The model is becoming a multimodal runtime</h3><p>One of the most useful slides in the session showed the Gemini API as the centre of a many-to-many system.</p><p>On the input side, developers could provide:</p><p>system instructions, text, code, images, audio, video, speech ,API information, and URLs.</p><p>On the output side, the system could return:</p><ul><li>text, images. audio, video; ,function calls; and code.</li></ul><p>This is more significant than adding a few extra file types to an API.</p><p>A traditional language-model integration usually requires developers to transform everything into text before the model can use it. An image might need OCR. Audio might need a separate speech-to-text pipeline. A video might have to be divided into frames and transcripts. The application then has to combine those intermediate results before sending them to the model.</p><p>A natively multimodal interface reduces that fragmentation.</p><p>The application can pass the original artefacts to the model and ask it to reason across them together. A maintenance assistant could inspect an equipment photograph, listen to an engineer’s spoken description and read a service manual. A learning application could combine lecture video, slides and student questions. A data-analysis assistant could interpret a chart alongside the code and dataset that produced it.</p><p>The model is no longer only generating a response. It is coordinating meaning across different representations of the same problem.</p><h3>Multimodality changes application architecture</h3><p>Multimodal systems require developers to think beyond the chat box.</p><p>Each modality introduces different engineering concerns:</p><ul><li>Images require decisions about resolution, compression and visual grounding.</li><li>Audio introduces sampling, latency, transcription quality and speaker behaviour.</li><li>Video creates larger payloads, temporal context and processing-cost considerations.</li><li>Generated media requires storage, delivery and content-safety controls.</li><li>Tool calls require permissions, validation and reliable execution.</li><li>Long-context documents require retrieval strategies and careful evaluation.</li></ul><p>This means that a multimodal API does not remove architecture. It changes where architecture is needed.</p><p>The key design question becomes:</p><blockquote><em>Which information should the model receive directly, which information should be retrieved through tools, and which operations should remain deterministic application code?</em></blockquote><p>A strong application does not send everything to the model simply because the interface accepts it. It uses the model where interpretation and reasoning add value, while keeping predictable operations in normal software components.</p><p>That boundary is where much of the real engineering work now sits.</p><h3>The creative layer is becoming programmable</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i_MOhPLMK2yFvDLdYYZitg.jpeg" /><figcaption>The session presented an expanding portfolio of generative-media and audio models rather than treating creative generation as a single capability.</figcaption></figure><p>Another major theme was the rapid expansion of Google’s generative-media layer.</p><p>The session timeline showed a growing family of image, video, music and speech systems. The important developer takeaway was not any single model name. It was the move towards a portfolio of specialised capabilities that can be invoked within an application workflow.</p><p>This turns media generation from a standalone creative experiment into a programmable software component.</p><p>An application might generate an image, evaluate the result, request a revision and then combine it with generated narration. A marketing workflow might create several visual concepts from product data. A learning platform might transform written material into illustrations and spoken explanations. A design tool might let users refine generated media conversationally instead of restarting from a new prompt.</p><p>The creative layer therefore becomes part of application logic.</p><p>Developers must now consider:</p><ul><li>model selection;</li><li>output format;</li><li>latency;</li><li>cost;</li><li>aspect ratio and resolution;</li><li>consistency across multiple generations;</li><li>provenance and labelling;</li><li>storage and delivery; and</li><li>evaluation of subjective outputs.</li></ul><p>Generating an image or audio clip is easy to demonstrate. Building a dependable product around generated media is a systems problem.</p><h3>Google AI Studio is moving closer to an application environment</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SPPaYe1QvBb_fcTicENYQg.jpeg" /><figcaption><em>Google AI Studio was shown supporting full-stack Node.js applications, including server-side runtime setup, npm packages and secrets management.</em></figcaption></figure><p>One of the clearest signals from the session was the expanding role of Google AI Studio.</p><p>AI Studio began as an accessible environment for experimenting with prompts and model parameters. The session showed it moving closer to a complete application-building environment.</p><p>The full-stack Node.js demonstration was especially important. It highlighted the ability to:</p><ul><li>build more than a front-end prototype;</li><li>use an automated server-side runtime;</li><li>access the npm package ecosystem; and</li><li>manage server-side API secrets.</li></ul><p>That changes the nature of the tool.</p><p>A prompt playground helps a developer test whether a model can perform a task. A full-stack environment helps the developer place that task inside an application with state, dependencies, server logic and deployment requirements.</p><p>The distinction matters because many AI demonstrations fail at the point where the model must connect to the rest of the system.</p><p>A production application needs authentication, databases, third-party packages, environment variables, error handling and deployment. Bringing those concerns into the same workflow shortens the journey from model experiment to usable software.</p><p>It also raises the standard for generated applications. Once the system can create full-stack code, developers must review far more than the user interface. They must inspect package choices, server routes, secret handling, validation logic and data access.</p><p>AI Studio may accelerate implementation, but engineering responsibility remains with the developer.</p><h3>The Interactions API introduces a better execution model</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MImbwuqhrFZ6KNF8Te7j7A.jpeg" /><figcaption><em>The Steps data model represents an interaction as a typed timeline of model outputs, tool calls and other execution events.</em></figcaption></figure><p>The session also introduced a more structured way to work with model activity through the Gemini Interactions API.</p><p>The older request-response pattern is simple: send content and receive a generated result. That works well for basic generation, but it becomes limiting when an application includes tools, agents, multiple modalities and long-running tasks.</p><p>An agentic workflow may need to:</p><ol><li>interpret a goal;</li><li>search for information;</li><li>call a function;</li><li>inspect the returned data;</li><li>generate another artefact;</li><li>wait for an external event; and</li><li>continue from the previous state.</li></ol><p>A single unstructured response is not enough to represent that process.</p><p>The Steps data model addresses this by treating an interaction as a typed sequence of events. Instead of forcing the application to infer what happened from one large output, the developer can handle recognised event types such as model output, function calls or search activity.</p><p>This provides a cleaner foundation for:</p><ul><li>debugging;</li><li>user-interface updates;</li><li>retries;</li><li>streaming;</li><li>observability;</li><li>approval checkpoints; and</li><li>long-running workflows.</li></ul><p>It also creates a better separation between raw media content and structured execution metadata.</p><p>For developers, this is a major architectural improvement. Agent applications become easier to inspect because the workflow is represented as data rather than hidden inside a block of generated text.</p><h3>Tools turn model capability into application capability</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eDien6RK_SOPyGTkT3YgsQ.jpeg" /><figcaption>A tool-use demonstration combined model reasoning with Google Search, URL context and a custom function.</figcaption></figure><p><em>A tool-use demonstration combined model reasoning with search, URL context and a custom function.</em></p><p>A model can explain what should happen. A tool-enabled application can make it happen.</p><p>Function calling allows the model to decide when an external capability is needed and produce structured arguments for that capability. The application then validates the request, executes the function and returns the result to the model.</p><p>This is the bridge between language and action.</p><p>For example, a security assistant might:</p><ul><li>search for a newly reported vulnerability;</li><li>open and analyse the advisory;</li><li>determine which internal systems are affected; and</li><li>call a controlled function to create an incident record.</li></ul><p>The model contributes interpretation and planning. The application contributes trusted execution.</p><p>That division is essential.</p><p>Models should not receive unlimited authority simply because they can call tools. Every tool needs a clearly defined schema, constrained permissions, input validation, error handling and an audit trail.</p><p>The quality of an agent is therefore determined not only by the intelligence of the model, but also by the design of its tools.</p><p>Poorly designed tools make agents unpredictable. Well-designed tools make model behaviour easier to control, test and reuse.</p><h3>The command line is becoming an agent interface</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DVFcMNfZFZd4veDs-TIi_A.jpeg" /><figcaption><em>The Gemini API CLI was presented as a way to run prompts, generate media and scaffold, test and deploy agents from the command line.</em></figcaption></figure><p>The session also demonstrated a Gemini API command-line interface designed for structured, agent-friendly workflows.</p><p>This matters because professional development does not happen only in browser-based interfaces.</p><p>Developers need AI capabilities inside scripts, terminals, CI/CD pipelines and repeatable automation. A command-line interface makes it easier to:</p><ul><li>test a prompt consistently;</li><li>generate media as part of a workflow;</li><li>initialise an agent project;</li><li>run agent tests;</li><li>deploy a managed agent; and</li><li>invoke a deployed agent from automation.</li></ul><p>The deeper significance is reproducibility.</p><p>A useful AI workflow should not depend entirely on a developer manually clicking through an interface. It should be expressible as commands, configuration and version-controlled artefacts.</p><p>That makes the workflow easier to review, share and integrate into existing engineering practice.</p><h3>Model choice is now an architectural decision</h3><p>The expanding stack also makes one point very clear: there is no single model for every task.</p><p>Different applications optimise for different constraints:</p><ul><li>reasoning quality;</li><li>response latency;</li><li>context length;</li><li>supported modalities;</li><li>media-generation quality;</li><li>tool use;</li><li>throughput;</li><li>deployment environment; and</li><li>cost.</li></ul><p>A real-time voice interface and a long-document analysis system may both use Gemini, but they should not be designed in the same way.</p><p>The voice application needs low latency, interruption handling and streaming. The document system needs reliable long-context processing, citations and retrieval. An image-generation feature needs output controls and media evaluation. An agent needs tools, state and traceability.</p><p>Choosing a model is therefore similar to choosing a database or cloud service. The decision shapes the application’s performance, limits and operating cost.</p><p>The best model is not necessarily the largest model. It is the model whose capabilities match the workload.</p><h3>Evaluation must become multimodal too</h3><p>As applications become multimodal, evaluation must move beyond checking whether a text answer sounds correct.</p><p>Developers may need to evaluate:</p><ul><li>whether an image reflects the requested objects and relationships;</li><li>whether generated speech is intelligible and appropriately paced;</li><li>whether a video remains consistent across frames;</li><li>whether a function call selected the correct tool and arguments;</li><li>whether an agent completed the task without unnecessary actions;</li><li>whether outputs remain safe across different input combinations; and</li><li>whether the system behaves reliably under latency, quota or tool failures.</li></ul><p>Some of these checks can be automated. Others require human judgement.</p><p>The important point is that evaluation must be designed alongside the application, not added after the demo works.</p><p>A multimodal system that performs impressively in one carefully selected example may still fail when users provide noisy audio, ambiguous images, conflicting instructions or incomplete data.</p><p>Production confidence comes from testing those difficult cases deliberately.</p><h3>What developers should learn from this stack</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nWJ2gF9R-3Feu0X3Z8vTlA.jpeg" /><figcaption>Some Developers form Sub-Saharan Africa (SSA) Community</figcaption></figure><p>The core message of the session was that developers must stop viewing generative AI as a simple API call.</p><p>The emerging Google DeepMind stack has several layers:</p><ol><li><strong>Models</strong> provide reasoning, understanding and generation.</li><li><strong>Multimodal APIs</strong> allow applications to exchange different forms of information.</li><li><strong>Tools and function calls</strong> connect the model to external capabilities.</li><li><strong>Interactions and state</strong> organise multi-step workflows.</li><li><strong>AI Studio and CLI tooling</strong> support development and deployment.</li><li><strong>Creative models</strong> add programmable image, audio and video generation.</li><li><strong>Evaluation and observability</strong> make the system understandable and operable.</li></ol><p>The developer’s job is to decide how these layers should work together.</p><p>That requires more than prompt-writing. It requires software architecture, interface design, security, evaluation and operational thinking.</p><h3>The new creative layer is software</h3><p>The most important lesson from the Google DeepMind AI stack is that multimodal generation is moving into the normal software-development lifecycle.</p><p>Images, audio, video, tools and agent actions are becoming outputs that developers can request, combine, evaluate and deliver through applications.</p><p>The opportunity is much larger than creating impressive demonstrations.</p><p>Developers can now build systems that understand the world through several modalities, take controlled action through tools and create new forms of output within the same workflow.</p><p>But the engineering challenge grows with the capability.</p><p>The more the model can see, generate and do, the more carefully developers must design context, permissions, state, evaluation and human oversight.</p><p>The next generation of AI applications will not be defined by the model alone.</p><p>They will be defined by how well developers assemble the entire stack around it.</p><h3>l</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22d579115c3a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Prompts to Production: How Google Is Rebuilding the Developer Stack Around Gemini and AI…]]></title>
            <link>https://medium.com/@philipsatimor2/from-prompts-to-production-how-google-is-rebuilding-the-developer-stack-around-gemini-and-ai-190772a06205?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/190772a06205</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[gemini]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 10:48:01 GMT</pubDate>
            <atom:updated>2026-07-06T10:48:01.966Z</atom:updated>
            <content:encoded><![CDATA[<h3>From Prompts to Production: How Google Is Rebuilding the Developer Stack Around Gemini and AI Agents</h3><p>The opening session at Google I/O Connect Berlin 2026 showed that the next stage of AI development is not simply better code completion. It is a new software workflow in which Gemini helps developers move from an idea to a working, connected and deployable application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J5NC6M1slFFXAocgxTB_Tw.jpeg" /><figcaption>Opening session at Google I/O Connect Berlin 2026</figcaption></figure><p>For the last two years, much of the conversation around generative AI and software development has focused on one question:</p><p><strong>How much code can an AI model generate?</strong></p><p>At Google I/O Connect Berlin 2026, the opening session suggested that this is already becoming the wrong question.</p><p>The more important question is now:</p><p>“<strong><em>How much of the software-development lifecycle can an AI-enabled platform help a developer coordinate?</em></strong></p><blockquote><strong><em>How much of the software-development lifecycle can an AI-enabled platform help a developer coordinate?</em></strong></blockquote><p>The session, featuring Tim Messerschmidt, Jason Titus and Ali B., presented a developer experience built around Gemini, Google AI Studio and a growing collection of connected tools and services.</p><p>The emphasis was not on replacing developers or turning software engineering into a single prompt. It was on reducing the distance between an idea and a production-ready system.</p><p>That distinction matters.</p><p>A prompt can produce code, but a product requires architecture, context, integrations, testing, security, deployment and continuous improvement.</p><p>Google’s emerging developer stack is increasingly being designed around that full journey.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gq9WeJdZqoUbjJqcSaBA2w.jpeg" /><figcaption>Tim Messerschmidt during the opening session.</figcaption></figure><p><strong>A prompt is not a product</strong></p><p>Generating a code snippet is useful, but it represents only a small part of software delivery.</p><p>A real application must understand its environment. It needs access to project files, APIs, databases and user requirements. It must handle authentication, permissions, state, errors and changing data. It must also be testable, observable and maintainable after deployment.</p><p>This is where the conversation is shifting from <strong>AI-assisted coding</strong> to <strong>AI-native development</strong>.</p><p>In an AI-assisted workflow, the model sits beside the developer and suggests code.</p><p>In an AI-native workflow, the model becomes part of a wider execution environment. It can help interpret the goal, generate an initial structure, modify multiple files, connect external services, invoke tools and support the developer through testing and deployment</p><p>The developer remains responsible for the system, but the interface to that system becomes more goal-oriented.</p><p>Instead of beginning with a blank repository and manually assembling every component, the workflow can begin with an outcome:</p><blockquote>Build an application that understands this requirement, uses these services, follows these constraints and produces this experience.</blockquote><p>The platform can then help translate that outcome into code and infrastructure that the developer can inspect, refine and approve.</p><h3>Google AI Studio is becoming more than a prompt playground</h3><p>One of the strongest signals from the opening session was the expanding role of Google AI Studio.</p><p>The demonstrations showed an environment where a developer could describe an application, generate an initial implementation and continue refining it through conversation.</p><p>The generated experience was not presented as a static prototype. It could be connected to services such as Gemini models, Firebase, Google Maps and generative-media capabilities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*An_9xOpoOQwjYMwgOW95kw.jpeg" /><figcaption>Google AI Studio being used to move from an application idea towards an implementation.</figcaption></figure><p>This points towards a broader role for AI Studio: a front door into Google’s AI development ecosystem.</p><p>The emerging workflow looks something like this:</p><ul><li>Describe the product or feature in natural language.</li><li>Generate an initial application structure.</li><li>Inspect and modify the underlying code.</li><li>Connect models, data and platform services.</li><li>Test the behaviour against real scenarios.</li><li>Deploy, observe and improve the application.</li></ul><p>The important point is that the prompt is only the starting interface. The result still needs to be treated as software.</p><p>Developers must understand what was generated, verify the dependencies, review the security implications and test the behaviour under conditions the model may not have anticipated.</p><p>This is not “no-code”.</p><p>It is <strong>accelerated code with a conversational control layer</strong>.</p><h3><strong>Agents are the bridge between intent and execution</strong></h3><p>Code-generation tools respond to a request. An agentic system can work towards a goal.</p><p>That difference is central to the direction presented during the event.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rtn25N3RQ8oTyWVp1aGG-Q.jpeg" /><figcaption>AI agents took centre stage at Google I/O Connect Berlin 2026, reflecting the shift from isolated model interactions to complete, goal-driven developer workflows</figcaption></figure><p>An AI agent combines a model with instructions, tools and access to an execution environment. Rather than returning only text, it can decide which action is required, call a service, inspect the result and continue through a multi-step process.</p><p>For software development, that could mean an agent that can:</p><ul><li>examine an existing repository;</li><li>identify the files affected by a requested change;</li><li>generate or edit code across those files;</li><li>call documentation and development tools;</li><li>run tests and interpret failures;</li><li>propose a correction;</li><li>prepare an application for deployment.</li></ul><p>The value is not that every decision is delegated to AI. The value is that repetitive coordination can be automated while important architectural and product decisions remain visible to the developer.</p><p>This is also why the developer stack must expand beyond the model itself.</p><p>A capable model without reliable tools, permissions, state management and evaluation is still only one component.</p><p>The production system is the combination of the model and the engineering around it.</p><h3><strong>The developer role is moving up the abstraction stack</strong></h3><p>Every major improvement in developer tooling changes what engineers spend their time doing.</p><p>High-level programming languages reduced the need to work directly with machine instructions. Frameworks reduced the need to rebuild common application structures. Cloud platforms reduced the need to manage every physical infrastructure component.</p><p>AI-enabled development is another step in that progression.</p><p>The developer’s work does not disappear. It moves towards higher-level responsibilities:</p><ul><li>defining the problem precisely;</li><li>choosing the right architecture;</li><li>setting technical and ethical constraints;</li><li>deciding what an agent is allowed to access;</li><li>reviewing generated changes;</li><li>designing tests and evaluation criteria;</li><li>monitoring the system in production;</li><li>taking responsibility for the final outcome.</li></ul><p>This makes engineering judgement more important, not less.</p><p>When code is easier to generate, the bottleneck moves to deciding what should be built, how the parts should interact and whether the result is trustworthy.</p><p>A developer who can write a clear specification, reason about system boundaries and review AI-generated work will be far more effective than someone who treats the model as an unquestionable source of code.</p><h3>From coding speed to production confidence</h3><p>The opening session demonstrated impressive speed, but speed alone is not the goal.</p><p>A prototype generated in minutes can still create weeks of technical debt if its architecture is poor, its dependencies are insecure or its behaviour has not been properly tested.</p><p>The real opportunity is to combine fast generation with stronger production discipline.</p><p>Teams adopting this style of development should think about four important layers.</p><h3>1. Context</h3><p>The model needs the right information: repository structure, coding standards, product requirements, API contracts and relevant documentation.</p><p>Better context usually produces better implementation decisions.</p><h3>2. Control</h3><p>Agents should operate within explicit boundaries.</p><p>Tool access, credentials, file permissions and deployment rights should be limited to what is necessary. High-impact actions should require appropriate human approval.</p><h3>3. Evaluation</h3><p>Generated code and agent behaviour must be tested.</p><p>Traditional unit, integration and security testing remain essential. Agentic systems may also require task-level evaluations that determine whether a goal was completed correctly, consistently and safely.</p><h3>4. Observability</h3><p>When an AI-enabled workflow makes multiple decisions or tool calls, developers need a clear record of what happened.</p><p>Logs, traces and human-readable explanations are critical for debugging, accountability and continuous improvement.</p><p>Without these layers, “prompt to production” can quickly become “prompt to unpredictable behaviour”.</p><h3>What this means for developers today</h3><p>The direction shown in Berlin does not require developers to abandon their existing tools.</p><p>It suggests that AI will increasingly operate across those tools.</p><p>The practical response is to begin developing skills in three areas.</p><p>First, learn to design systems for agent use. This includes clear tool interfaces, structured outputs, robust API contracts and workflows that can pause for human approval.</p><p>Second, strengthen software-review skills. Developers will need to assess generated code for correctness, maintainability, security and alignment with the wider architecture.</p><p>Third, think beyond the model.</p><p>The most successful AI applications will not be defined only by which model they use. They will be defined by how effectively the model is connected to data, tools, users and operational controls.</p><h3>The new unit of development is the workflow</h3><p>My main takeaway from the opening session was that the unit of software development is beginning to change.</p><p>For years, developers have thought primarily in terms of functions, classes, services and applications.</p><p>In the agentic era, we must also think in terms of <strong>goal-oriented workflows</strong>: sequences in which models reason, tools act, systems return evidence and humans retain control.</p><p>Gemini is becoming part of that execution layer.</p><p>Google AI Studio is becoming an environment for turning intent into implementation. Google’s wider platform provides the services required to connect, deploy and operate what is built.</p><p>The future described in Berlin is not one where developers stop coding.</p><p>It is one where developers spend less time assembling routine components and more time designing reliable systems.</p><p>The question is no longer whether AI can write code.</p><p>The question is whether we can build the engineering practices needed to take AI-generated work safely and confidently <strong>from prompts to production</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=190772a06205" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fixing “Workload evicted, storage limit exceeded (50G)” on Hugging Face Spaces — Here’s What Worked]]></title>
            <link>https://medium.com/@philipsatimor2/fixing-workload-evicted-storage-limit-exceeded-50g-on-hugging-face-spaces-heres-what-worked-e46b833c4547?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/e46b833c4547</guid>
            <category><![CDATA[nlp]]></category>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[hugging-face-spaces]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Thu, 13 Nov 2025 15:11:56 GMT</pubDate>
            <atom:updated>2025-11-13T15:18:02.925Z</atom:updated>
            <content:encoded><![CDATA[<h3>Fixing “Workload evicted, storage limit exceeded (50G)” on Hugging Face Spaces -Here’s What Worked</h3><p>Recently, while working on my <a href="https://huggingface.co/spaces/philipobiorah/bert-sentiment-analysis">Hugging Face Space <strong>bert-sentiment-analysis application</strong></a>, I suddenly ran into one of the most confusing errors I’ve seen on the platform:</p><blockquote>runtime error</blockquote><blockquote>Workload evicted, storage limit exceeded (50G)</blockquote><blockquote>Container logs:</blockquote><blockquote>===== Application Startup at 2025–10–03 07:16:55 =====</blockquote><blockquote>No logs available</blockquote><p>No matter how many times I restarted, rebuilt, or redeployed the Space, nothing changed. Worse, the logs were completely empty. This was happening on my Hugging Face Space here: <a href="https://huggingface.co/spaces/philipobiorah/bert-sentiment-analysis"><strong>https://huggingface.co/spaces/philipobiorah/bert-sentiment-analysis</strong></a></p><p>It’s a <strong>BERT-based sentiment classifier</strong> trained on the IMDb movie reviews dataset to classify text as either <strong>positive</strong> or <strong>negative.</strong></p><p>The Space exposes this model through a clean Python interface that allows users to input any text, have it automatically tokenized by the BERT tokenizer, and then processed by my fine-tuned BERT IMDb sentiment model to produce a predicted label along with a confidence score. Behind the scenes, this requires the application to download and load several large components, including the BERT model weights, tokenizer files, configuration files, and any dataset-related preprocessing artifacts. These assets are substantial in size, and the accumulation of these cached files is ultimately what caused my Space to exceed the 50GB root storage limit and crash.</p><p><strong>The Problem: My Space Filled Up Its 50GB Root Storage</strong></p><p>Every Hugging Face Space has two main storage areas: 1. Root filesystem (limited to ~50GB). This is where the OS, Python environment, and default Hugging Face caches live. 2. 2. /data persistent storage (much larger). This does <strong>not</strong> count toward the 50GB limit. By default, Hugging Face Transformers caches everything — model weights, tokenizer files, dataset artifacts — to:</p><pre>/root/.cache/huggingface</pre><p>As I continued updating and interacting with the app, these cached files quietly built up. Eventually they exceeded the 50GB root limit. Once that happened, my container was <strong>evicted before it could even start</strong>, which explains why the logs showed nothing. It wasn’t a Python failure.<br> It wasn’t a dependency conflict. It wasn’t my code. It was storage exhaustion.</p><p>This is extremely common for any app using: Transformers, PyTorch, Tokenizers, Hugging Face Datasets…because these tools store files automatically without telling you.</p><h3>The Solution: Move Hugging Face Caches to /data</h3><p>Hugging Face allows developers to control cache locations using environment variables such as:</p><pre>HF_HOME<br>HF_DATASETS_CACHE<br>TRANSFORMERS_CACHE</pre><p>So instead of leaving heavy model files under:</p><pre>/root/.cache</pre><p>I redirected them to:</p><pre>/data</pre><p>This area is designed for large, persistent storage and does <strong>not</strong> count toward the 50GB cap. This change alone prevents the root filesystem from ever filling up again.</p><h3>The Exact Dockerfile Fix That Solved Everything</h3><p>Here is the updated Dockerfile that finally made my app stable:</p><pre># Use Python 3.10 for compatibility<br>FROM python:3.10-slim<br><br># Set working directory<br>WORKDIR /app<br><br># Install system dependencies<br>RUN apt-get update &amp;&amp; apt-get install -y \<br>    build-essential \<br>    libopenblas-dev \<br>    libomp-dev \<br>    &amp;&amp; rm -rf /var/lib/apt/lists/*<br><br># Create cache directories on /data and matplotlib config dir<br>RUN mkdir -p \<br>    /data/.huggingface \<br>    /data/.cache/huggingface/datasets \<br>    /data/.cache/huggingface/transformers \<br>    /tmp/matplotlib \<br>    &amp;&amp; chmod -R 777 /data /tmp/matplotlib<br><br># Clean any old Hugging Face caches (defensive)<br>RUN rm -rf \<br>    /root/.cache/huggingface \<br>    /root/.cache/huggingface_hub \<br>    /root/.cache/huggingface/datasets || true<br><br># Set cache environment variables to point at /data<br>ENV HF_HOME=/data/.huggingface<br>ENV HF_HUB_CACHE=/data/.cache/huggingface/hub<br>ENV HF_DATASETS_CACHE=/data/.cache/huggingface/datasets<br>ENV TRANSFORMERS_CACHE=/data/.cache/huggingface/transformers<br>ENV MPLCONFIGDIR=/tmp/matplotlib<br><br># Copy requirements file<br>COPY requirements.txt /app/requirements.txt<br><br># Install dependencies<br>RUN pip install --upgrade pip &amp;&amp; pip install --no-cache-dir -r requirements.txt<br><br># Install PyTorch separately for compatibility<br>RUN pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu<br><br># Copy application files<br>COPY . /app<br><br># Expose port<br>EXPOSE 7860<br><br># Run the application<br>CMD [&quot;python&quot;, &quot;main.py&quot;]</pre><h3>Copy-Paste Fix Template</h3><p>Add this to any Hugging Face Docker Space:</p><pre>RUN mkdir -p /data/.cache/huggingface /data/.huggingface<br>ENV HF_HOME=/data/.huggingface<br>ENV HF_DATASETS_CACHE=/data/.cache/huggingface/datasets<br>ENV TRANSFORMERS_CACHE=/data/.cache/huggingface/transformers</pre><h3><strong>The Result</strong>, <strong>Takeaways</strong>, and <strong>Final Thoughts</strong></h3><p>After applying the fix and redirecting all Hugging Face caches to /data, my application immediately came back to life—the Space booted normally, the model loaded without errors, and the stability issues completely disappeared. This experience reinforced a few important lessons: empty logs usually mean the container never started, Hugging Face model caches can silently consume huge amounts of storage, and it’s essential to move these caches off the root filesystem when deploying transformer-based applications. In the end, the solution was simple but powerful—a small Dockerfile adjustment that permanently solved the problem and made my Space production-ready. If you’re deploying any model-heavy application on Hugging Face Spaces, implementing this storage fix early will save you hours of frustration and prevent unexpected downtime.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e46b833c4547" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Install and Configure Google Cloud SDK on macOS Using Homebrew]]></title>
            <link>https://medium.com/@philipsatimor2/how-to-install-and-configure-google-cloud-sdk-on-macos-using-homebrew-cc41f36dc592?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc41f36dc592</guid>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Sat, 21 Sep 2024 19:52:53 GMT</pubDate>
            <atom:updated>2025-10-29T02:02:01.443Z</atom:updated>
            <content:encoded><![CDATA[<p>The command line tools and libraries required to communicate with Google Cloud services are provided via the Google Cloud SDK. One of the most important things to do while working on a project that uses Google Cloud is to install the SDK. I’ll show you how to use Homebrew, a macOS package manager, to install and set up the Google Cloud SDK in this tutorial.</p><p>Before starting, ensure that you are working on a machine with macOS and have a stable internet connection. Let’s dive in!</p><h3>Installing Google Cloud SDK on macOS</h3><p>Before we begin, ensure that you have the Google Cloud SDK loaded on the machine you’re using. Follow these steps to get setup.</p><p>Step 1: Install Homebrew (if not already installed)</p><p>If you haven’t installed Homebrew, run this command in your Terminal:</p><pre>/bin/bash -c &quot;$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)&quot;<br></pre><p>After installation, verify Homebrew by running:</p><p>brew — version</p><p>Step 2: Install Google Cloud SDK using Homebrew</p><p>Now that Homebrew is installed, you can install the Google Cloud SDK by running:</p><pre>brew install --cask google-cloud-sdk</pre><p>Step 3: Initialize Google Cloud SDK</p><p>Once installed, initialize the SDK with the following command:</p><pre>gcloud init</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P5QSjyrab7XndDcLHVmp1g.png" /><figcaption>The image shows the Google Cloud SDK configuration process where you are being prompted to either re-initialize the current configuration or create a new one</figcaption></figure><ul><li><strong>Option 1 (Re-initialize this configuration)</strong>: Choose this option if you want to use the same account and project (qwiklabs-gcp-00-dcf04281eb58) but modify details like the region, zone, or authentication settings.</li><li><strong>Option 2 (Create a new configuration)</strong>: Choose this option if you want to create a separate configuration, perhaps for a different project or user account. This will allow you to switch between different configurations as needed.</li></ul><p>Here we choose (option 1)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2h4yGBSwjpwcxIP6uWd6wQ.png" /><figcaption>The image shows the next step in the gcloud init configuration process, where the system is asking you to select the account for this configuration</figcaption></figure><p><strong>Sign in to Google Cloud</strong></p><p>We want to login to a different Google account so we choose Option 2 [Sign in with a new Google Account]. The would take use to the Google Cloud SDK Sign in form.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K66Klma0oM9b6BYqkAIfTw.png" /><figcaption>The image shows the Google sign-in page where the user is prompted to log in to the Google Cloud SDK using the Qwiklabs account email: student-02-cf6c913d36ae@qwiklabs.net. The next step is to click &quot;Next&quot; to proceed with the login process.</figcaption></figure><p>Now go through the authentication process until “You are now authenticated with the gcloud CLI!”. On your terminal you would get:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F8Wlqk5FfEghMKuyKWDpEg.png" /><figcaption>The image shows the prompt in the Google Cloud SDK setup where the user is signed in as student-02-cf6c913d36ae@qwiklabs.net and is asked to select a cloud project to use.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m-Gg4dDnhTxWdAN00VfvGA.png" /><figcaption>The image shows the final setup confirmation for the Google Cloud CLI. The project qwiklabs-gcp-04-fd8797af5004 has been selected, and the default Compute Engine region and zone have been set to us-east4 and us-east4-b, respectively. The CLI configuration is complete, and authentication is linked to the student-02-cf6c913d36ae@qwiklabs.net account</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JEfT3iQDVvAL64GqoJphHQ.png" /><figcaption>To ensure everything is works well authenticate and configure project.</figcaption></figure><h3>Conclusion</h3><p>That’s it! You’ve successfully installed and configured the Google Cloud SDK on your macOS machine using Homebrew. You can now interact with your Google Cloud resources directly from the terminal. Whether you’re managing projects, deploying applications, or exploring Google Cloud features, the CLI is a powerful tool in your workflow.</p><p>Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc41f36dc592" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Managing Google Cloud Storage with gsutil: A Practical Guide]]></title>
            <link>https://medium.com/@philipsatimor2/managing-google-cloud-storage-with-gsutil-a-practical-guide-c06049da1da4?source=rss-47371eec1dc6------2</link>
            <guid isPermaLink="false">https://medium.com/p/c06049da1da4</guid>
            <dc:creator><![CDATA[Philip Obiorah]]></dc:creator>
            <pubDate>Sat, 21 Sep 2024 19:38:00 GMT</pubDate>
            <atom:updated>2024-09-21T19:46:28.963Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*MaSQVoVkfAKERI098g2XxQ.png" /></figure><p>In this article, I’ll walk you through my experience using Google Cloud Platform (GCP) and gsutil to create and manage storage buckets, upload images, and set access controls—all via the command line. If you&#39;re looking to interact with GCP storage efficiently, these steps will help you get started.</p><p><strong>Authenticating with GCP</strong></p><p>To begin, I logged into my GCP account via the command line using the gcloud command. This initiated an authentication process where my default browser opened to the Google login page</p><pre>gcloud auth login<br></pre><figure><img alt="Figure 1. After authenticating, I was logged in as [student-04–1fcfece83ef9@qwiklabs.net]" src="https://cdn-images-1.medium.com/max/1024/1*WEiD3vup1z2YuZcq34yvBA.png" /><figcaption>Figure 1. After authenticating, I was logged in as [student-04-1fcfece83ef9@qwiklabs.net]</figcaption></figure><p><strong>Configuring the Active Project</strong></p><p>Next, I switched to the project I needed to work on, using the following command :</p><pre>gcloud config set project qwiklabs-gcp-04-6010cadf17d0</pre><p>Running this command updates the active project in GCP, and I verified it by listing the active configuration:</p><pre>gcloud config list project</pre><figure><img alt="Figure 2. Output of the gcloud config list project command showing the current active project qwiklabs-gcp-04–6010cadf17d0 and the configuration set to [default]." src="https://cdn-images-1.medium.com/max/616/1*tiOsH05KbPcHvFHjhQUM0g.png" /><figcaption>Figure 2. Output of the gcloud config list project command showing the current active project qwiklabs-gcp-04-6010cadf17d0 and the configuration set to [default].</figcaption></figure><p><strong>Creating a Cloud Storage Bucket</strong></p><p>Now, with the project set, I created a new storage bucket using this command:</p><pre>gsutil mb gs://&lt;YOUR-BUCKET-NAME&gt;</pre><pre>gsutil mb gs://my_bucket_f17d0<br>Creating gs://my_bucket_f17d0/...</pre><p><strong>Uploading Files to the Bucket</strong></p><p>Next, I downloaded an image of Ada Lovelace using curl</p><pre>curl https://upload.wikimedia.org/wikipedia/commons/thumb/a/a4/Ada_Lovelace_portrait.jpg/800px-Ada_Lovelace_portrait.jpg --output ada.jpg</pre><pre>  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current<br>                                 Dload  Upload   Total   Spent    Left  Speed<br>100  361k  100  361k    0     0  2615k      0 --:--:-- --:--:-- --:--:-- 2736k</pre><p>Once downloaded, I uploaded the image to my newly created bucket using the gsutil cp command:</p><pre>gsutil cp ada.jpg gs://my_bucket_f17d0</pre><figure><img alt="gsutil command successfully uploading the file ada.jpg (361.2 KiB) to a Google Cloud Storage bucket, confirming that the operation completed for 1 object." src="https://cdn-images-1.medium.com/max/830/1*jlSM_osoCKBvL8NYJpqrZQ.png" /><figcaption>Figure 3: gsutil command successfully uploading the file ada.jpg (361.2 KiB) to a Google Cloud Storage bucket, confirming that the operation completed for 1 object.</figcaption></figure><p><strong>Organizing Files in Folders</strong></p><p>You can create a new folder inside the bucket and move the moved the image into a new folder</p><pre>gsutil cp gs://my_bucket_f17d0/ada.jpg gs://my_bucket_f17d0/image-folder/</pre><pre>Copying gs://my_bucket_f17d0/ada.jpg [Content-Type=image/jpeg]...<br>/ [1 files][361.2 KiB/361.2 KiB]                                                <br>Operation completed over 1 objects/361.2 KiB.  </pre><p>After moving the file, I listed the contents of the folder to ensure everything was in place</p><pre>gsutil ls gs://my_bucket_f17d0/image-folder/</pre><pre>gs://my_bucket_f17d0/image-folder/ada.jpg</pre><p><strong>Download an object from your bucket</strong></p><p>Use the gsutil cp command to download the image you stored in your bucket to your current directory:</p><pre>gsutil cp -r gs://YOUR-BUCKET-NAME/ada.jpg .</pre><pre>gsutil cp -r gs://my_bucket_f17d0 .</pre><figure><img alt="gsutil command successfully copying the file ada.jpg (361.2 KiB) from the bucket my_bucket_f17d0 in Google Cloud Storage, confirming that the operation completed for 1 object." src="https://cdn-images-1.medium.com/max/934/1*bi4K4jLLFW5vrWwDu9GLQw.png" /><figcaption>Figure 4. gsutil command successfully copying the file ada.jpg (361.2 KiB) from the bucket my_bucket_f17d0 in Google Cloud Storage, confirming that the operation completed for 1 object.</figcaption></figure><p><strong>Setting Public Access</strong></p><p>To make the image publicly accessible for anyone to view the image, updated the Access Control List (ACL) using this command:</p><pre>gsutil acl ch -u AllUsers:R gs://my_bucket_f17d0/ada.jpg</pre><pre>Updated ACL on gs://my_bucket_f17d0/ada.jpg</pre><p>You can revoke public access by removing the entry for all users using this command:</p><pre>gsutil acl ch -d AllUsers gs://my_bucket_f17d0/ada.jpg</pre><p><strong>Deleting Files from the Bucket</strong></p><p>You can delete unwanted files form you bucket</p><pre>gsutil rm gs://my_bucket_f17d0/ada.jpg</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*KlI6s1Of6EHBC9Ni4hmDpg.png" /><figcaption>Figure 5. Showing that the command successfully removed the image from the bucket.</figcaption></figure><p><strong>Conclusion</strong></p><p>The article highlights how versatile and powerful gsutil is for managing Google Cloud Storage. Whether you’re creating buckets, uploading files, managing access control, or organizing your data, these simple commands make it easy to manage your resources directly from the command line. By following this guide, you can handle similar tasks with ease, streamlining your workflow on Google Cloud Platform.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c06049da1da4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>