<?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 Rodrigo Oliva on Medium]]></title>
        <description><![CDATA[Stories by Rodrigo Oliva on Medium]]></description>
        <link>https://medium.com/@rolivagon?source=rss-ca435cdd6c3e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*B_9flYxshi0rizAG</url>
            <title>Stories by Rodrigo Oliva on Medium</title>
            <link>https://medium.com/@rolivagon?source=rss-ca435cdd6c3e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:57:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rolivagon/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[AI Agents Didn’t Change How I Code. They Changed How I Think.]]></title>
            <link>https://medium.com/enviame-engineering/ai-agents-didnt-change-how-i-code-they-changed-how-i-think-0fa7aa94a3ad?source=rss-ca435cdd6c3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/0fa7aa94a3ad</guid>
            <category><![CDATA[harness-engineering]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Rodrigo Oliva]]></dc:creator>
            <pubDate>Fri, 05 Jun 2026 15:13:42 GMT</pubDate>
            <atom:updated>2026-06-05T15:13:42.473Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TqeVKVmcAJ2oaEu5BQleOQ.png" /></figure><p>A few months ago, I cautiously started experimenting with what many people were calling <em>vibecoding</em>.</p><p>Like many developers, my first reaction was amazement. It’s hard not to be impressed when an AI can generate in seconds something that would have taken you minutes — or even hours — to build yourself.</p><p>I started trying different coding assistants: Gemini CLI, Claude Code, OpenCode, and several others that appeared along the way.</p><p>At first, the game was simple.</p><p>Try prompts.</p><p>Iterate.</p><p>Figure out where the AI was useful and where it started to fall apart.</p><p>And like many others, I went through that phase where every conversation seemed to revolve around a single question:</p><blockquote><strong><em>Are developers becoming obsolete?</em></strong></blockquote><p>Or the more common version:</p><blockquote><strong><em>Why should I learn to code if AI is going to do it for me?</em></strong></blockquote><p>After spending months working with agents every day, I’ve come to a very different conclusion.</p><p>I don’t think the revolution is about AI writing code.</p><p>I think it’s about something much deeper.</p><h3>Code Was Never the Bottleneck</h3><p>For a long time, I thought the key was finding the best model.</p><p>The best agent.</p><p>The best prompt.</p><p>The best workflow.</p><p>That mythical one-shot prompt where you describe a requirement and a perfect solution magically appears.</p><p>I tried countless times.</p><p>Sometimes it worked.</p><p>Most of the time it didn’t.</p><p>The funny thing is that whenever it failed, my first reaction was always to blame the model.</p><p>“Opus would have understood this better.”</p><p>“Gemini probably would have handled it differently.”</p><p>“Maybe I just need to try another tool.”</p><p>Eventually, I realized I was asking the wrong question.</p><p>The difference was rarely the model.</p><p>The difference was the context.</p><p>Because the reality is surprisingly simple:</p><p>AI can look incredibly intelligent when it has all the information it needs.</p><p>And it can look incredibly stupid when it doesn’t.</p><h3>AI Doesn’t Replace Judgment</h3><p>A few weeks ago, I came across the concept of <em>Harness Engineering</em> for the first time.</p><p>Regardless of the formal definition, one idea immediately clicked for me.</p><p>Models matter.</p><p>But the real value lies in the system you build around them.</p><p>The context.</p><p>The rules.</p><p>The boundaries.</p><p>The conventions.</p><p>The workflows.</p><p>The responsibilities.</p><p>Suddenly, a lot of things started making sense.</p><p>Skills made sense.</p><p>Custom commands made sense.</p><p>Subagents made sense.</p><p>Because I was no longer trying to find a smarter AI.</p><p>I was trying to build an environment where AI could make better decisions.</p><h3>The Story That Changed My Mind</h3><p>Some time ago, I decided to build a subagent to help me track technical decisions.</p><p>Nothing particularly sophisticated.</p><p>The idea was simple.</p><p>Whenever I was working on an important feature, the agent would help document key decisions so they wouldn’t get lost across conversations, new work sessions, evolving requirements, or future iterations.</p><p>The first version was bad.</p><p>The second one wasn’t much better.</p><p>The third probably wasn’t either.</p><p>But after several iterations, I started noticing something interesting.</p><p>The problem wasn’t the agent.</p><p>The problem was that I had never explicitly defined how I made those decisions in the first place.</p><p>So I started adding rules.</p><p>Context.</p><p>Criteria.</p><p>Examples.</p><p>Edge cases.</p><p>And while doing that, something unexpected happened.</p><p>I wasn’t teaching the agent how to think.</p><p>I was discovering how I think.</p><h3>The Discovery I Didn’t Expect</h3><p>When I first heard about subagents, I thought of them as specialists.</p><p>One for testing.</p><p>One for architecture.</p><p>One for documentation.</p><p>One for code reviews.</p><p>But after months of using them, I reached a different conclusion.</p><p>The best subagents don’t represent skills.</p><p>They represent ways of thinking.</p><p>Because I don’t think the same way when reviewing an architecture as I do when debugging.</p><p>I don’t think the same way when evaluating a technical decision as I do when building an MVP.</p><p>I don’t think the same way when reviewing standards as I do when exploring a new idea.</p><p>And yet, it’s always me.</p><p>I’m simply operating from different mental contexts.</p><p>What agents allowed me to do was something that previously felt impossible:</p><p>Externalize those contexts.</p><h3>Inside Out for Developers</h3><p>The best analogy I’ve found is Pixar’s <em>Inside Out</em>.</p><p>There isn’t just one voice inside our heads.</p><p>There are multiple perspectives.</p><p>The architect.</p><p>The pragmatist.</p><p>The perfectionist.</p><p>The one who wants to ship fast.</p><p>The one thinking about scalability.</p><p>The one thinking about maintainability.</p><p>For years, we’ve learned how to coordinate all of those voices internally.</p><p>Now we can transform parts of them into reusable systems.</p><p>And that fundamentally changes how we work.</p><h3>Retrospectives Have Changed Too</h3><p>There’s another practice I’ve started adopting that turned out to be just as interesting.</p><p>Every so often, I run retrospectives on my own agents.</p><p>What worked?</p><p>What didn’t?</p><p>What tasks am I still repeating manually?</p><p>What decisions am I making over and over again?</p><p>And quite often, I discover opportunities to create new workflows.</p><p>New rules.</p><p>New commands.</p><p>New subagents.</p><p>It’s a continuous cycle.</p><p>It’s no longer just about developing software.</p><p>It’s about developing your own operating system for work.</p><h3>So Do We Still Need to Learn?</h3><p>My experience has been exactly the opposite of what many people claim.</p><p>The more knowledge you have, the more useful AI becomes.</p><p>Because the quality of an agent is directly tied to the quality of the judgment you can transfer to it.</p><p>Without judgment, you get text generation.</p><p>With judgment, you get amplification.</p><p>That’s why I’ve never fully bought into the idea that architecture, software design, or programming fundamentals are becoming irrelevant.</p><p>If anything, I suspect they’re becoming more important than ever.</p><p>Because those experiences are exactly what end up feeding the agents.</p><h3>There’s No Going Back</h3><p>Not because the models are perfect.</p><p>Not because the agents are autonomous.</p><p>Not because AI has solved every problem.</p><p>It still makes mistakes.</p><p>It still hallucinates.</p><p>It still makes absurd decisions.</p><p>But something fundamental has changed.</p><p>For the first time in my career, I feel like parts of my experience can become reusable.</p><p>Not just stored in my memory.</p><p>Not just buried inside forgotten documents.</p><p>But embedded in systems that can work alongside me.</p><p>Maybe a year from now we’ll all be using completely different tools.</p><p>Maybe Gemini, Claude, OpenCode, or whatever comes next will be replaced by something better.</p><p>But the idea that stays with me is different.</p><p>The real revolution isn’t that AI can write code.</p><p>The real revolution is that we’re learning how to capture knowledge, judgment, and ways of thinking.</p><p>And once you see that, it’s difficult to go back to working the way you used to.</p><p>The next generation of developers probably won’t be remembered for writing more code.</p><p>They’ll be remembered for learning how to capture knowledge in ways that once seemed impossible.</p><p>And perhaps that’s the most fascinating part of this entire revolution.</p><p>We’re not teaching machines how to think.</p><p>We’re discovering how we think ourselves.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0fa7aa94a3ad" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/ai-agents-didnt-change-how-i-code-they-changed-how-i-think-0fa7aa94a3ad">AI Agents Didn’t Change How I Code. They Changed How I Think.</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Laptop to Cloud: Deploying an AI Agent with ADK on Cloud Run and Cloud SQL]]></title>
            <link>https://medium.com/enviame-engineering/from-laptop-to-cloud-deploying-an-ai-agent-with-adk-on-cloud-run-and-cloud-sql-e7ffef30636b?source=rss-ca435cdd6c3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7ffef30636b</guid>
            <category><![CDATA[google-cloud-run]]></category>
            <category><![CDATA[google-adk]]></category>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Rodrigo Oliva]]></dc:creator>
            <pubDate>Mon, 25 Aug 2025 16:59:40 GMT</pubDate>
            <atom:updated>2025-08-25T16:59:40.543Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LFdh4Cv6_k5ICnHZ1voBYA.jpeg" /></figure><h3>TL;DR</h3><ul><li>🚀 How to deploy a Google ADK agent on Cloud Run with a Cloud SQL database.</li><li>💥 The real friction of using the Cloud SQL Auth Proxy and classic username/password authentication.</li><li>✅ A journey through IAM permissions, secret management, and the mysteries of PostgreSQL.</li><li>💡 A practical guide with a cloudbuild.yaml file so you can replicate it immediately.</li></ul><h3>My journey deploying my first AI agent to production 🚀</h3><p>My goal was simple but ambitious: to take an AI agent built with the Google ADK to production. This was my personal “guinea pig,” a project to experience firsthand the entire lifecycle of a solution like this, from the code on my laptop to a service in the cloud. I knew this would involve setting up a deployment environment from scratch, applying best practices, and facing real-world problems.</p><p>For the backend, the choice was clear: <strong>Cloud Run</strong>, since the ADK documentation recommends it for serverless and scalable workloads. For the session database, the choice was <strong>Cloud SQL</strong>, as it’s the service we use today at Enviame.</p><p>My initial plan was to reuse what I had already learned: connecting to the database with IAM. But that’s where I hit the first wall. Despite my attempts and those of my colleague, Gemini CLI, we couldn’t get the ADK to play nice with IAM authentication in its SQLAlchemy implementation. After a while of struggling, I decided to pivot. I abandoned the idea of IAM and returned to the classic: username and password, but this time, managed securely. And just like that, what I thought would be a simple deployment turned into a valuable lesson about the reality of development.</p><h3>My working stack (quick context)</h3><p>Here is the combination of technologies I used to solve the problem:</p><ul><li><strong>Agent</strong>: Google ADK with Python and FastAPI</li><li><strong>Deployment Service</strong>: Cloud Run</li><li><strong>DB</strong>: Cloud SQL for PostgreSQL</li><li><strong>CI/CD Pipeline</strong>: Cloud Build</li><li><strong>Secret Management</strong>: Secret Manager</li></ul><h3>Real friction I encountered</h3><p>As I mentioned, the path wasn’t so direct. I faced several issues that made me doubt, but each one was an opportunity to learn.</p><ol><li><strong>The battle against IAM Authentication</strong>: My first attempt, of course, was to replicate the configuration from my previous article. I wanted my Cloud Run agent to authenticate to Cloud SQL using IAM. For some reason, the ADK’s SQLAlchemy implementation didn’t support it and gave me connection errors. I gave up, but I’m still curious why. In the end, I opted for the classic method, but with best practices: using a username and password managed by Secret Manager.</li><li><strong>Permissions and APIs in GCP</strong>: The second major friction was the classic trial-and-error mix when configuring permissions. The permission denied error became my constant companion. Every component, from Cloud Run to the Cloud SQL Auth Proxy and Secret Manager, needs its own set of permissions and enabled APIs on the service account. It was a process of trial and error, adjusting roles and bindings until everything clicked.</li><li><strong>PostgreSQL vs. MySQL Users</strong>: Since my previous experience with manually managed databases was more focused on MySQL, I was surprised by user management in PostgreSQL. In MySQL, the default user can do almost anything, but in PostgreSQL it’s different. I had to learn that even after creating the user, I needed to give it specific GRANTs to the corresponding database so it could read and write.</li><li><strong>When the code doesn’t read secrets</strong>: The last major hurdle. While I used <strong>SQLite</strong> locally to save sessions, for production I decided to use PostgreSQL. I had configured Secret Manager, and the cloudbuild.yaml injected the DB_PASS variable, but my code didn&#39;t read it. I realized my code was still expecting the password from a file or hardcoded, not from an environment variable. I had to adjust the code to look for credentials in os.environ to connect to PostgreSQL in the cloud, a common but easily forgotten adjustment.</li></ol><h3>Deployment guide: ADK Agent on Cloud Run with Cloud SQL</h3><p>This is the final configuration that worked for me. Follow these steps to deploy a Google ADK-based application on Cloud Run, using Cloud SQL for PostgreSQL as the database.</p><h4>Step 1: Enable APIs and Permissions</h4><p>First, make sure your GCP project has all the necessary APIs enabled and that the service accounts (cloudbuild and cloud run) have the correct permissions.</p><p><strong>1.1 Enable necessary APIs</strong></p><p>Run these commands to enable all the APIs we will use in the deployment process.</p><pre>gcloud services enable run.googleapis.com<br>gcloud services enable cloudbuild.googleapis.com<br>gcloud services enable artifactregistry.googleapis.com<br>gcloud services enable secretmanager.googleapis.com<br>gcloud services enable sqladmin.googleapis.com</pre><p><strong>1.2 Assign IAM Roles</strong></p><p>Your <strong>Cloud Build service account</strong> ([PROJECT_NUMBER]@cloudbuild.gserviceaccount.com) needs roles to build and push the image. Your <strong>Cloud Run service account</strong> ([PROJECT_ID]@appspot.gserviceaccount.com) needs roles to connect to the DB and access secrets.</p><pre># Assign roles to the Cloud Build account<br>gcloud projects add-iam-policy-binding [PROJECT_ID] \<br>  --member=&quot;serviceAccount:[PROJECT_NUMBER]@cloudbuild.gserviceaccount.com&quot; \<br>  --role=&quot;roles/artifactregistry.writer&quot;<br><br># Assign roles to the Cloud Run account<br>gcloud projects add-iam-policy-binding [PROJECT_ID] \<br>    --member=&quot;serviceAccount:[SERVICE_ACCOUNT_EMAIL]&quot; \<br>    --role=&quot;roles/cloudsql.client&quot;<br>gcloud projects add-iam-policy-binding [PROJECT_ID] \<br>    --member=&quot;serviceAccount:[SERVICE_ACCOUNT_EMAIL]&quot; \<br>    --role=&quot;roles/secretmanager.secretAccessor&quot;</pre><h4>Step 2: Credential and Secret Management</h4><p>This section prepares the database and the secure storage of the password.</p><p>2.1 Create the Database User</p><p>The Cloud SQL Auth Proxy requires a standard database user.</p><pre># Replace [DB_USER], [INSTANCE_NAME] and [DB_PASS]<br>gcloud sql users create [DB_USER] \<br>  --instance=[INSTANCE_NAME] \<br>  --password=&quot;[DB_PASS]&quot;</pre><p><strong>2.2 Store the Password in Secret Manager</strong></p><p>Never write passwords directly in code or configuration files. For simplicity, you can do it from the GCP interface or use the CLI.</p><pre># a. Create the secret (replace [SECRET_NAME])<br>gcloud secrets create [SECRET_NAME]<br><br># b. Add the password as a version of the secret<br>echo -n &quot;[DB_PASS]&quot; | gcloud secrets versions add [SECRET_NAME] --data-file=-</pre><h4>Step 3: Adjusting the code to read secrets</h4><p>This was the step that made me lose time. Your application code must be prepared to read the password from an environment variable.</p><pre>import os<br>from sqlalchemy import create_engine<br><br># Assuming that environment variables are injected into Cloud Run<br>db_user = os.getenv(&quot;DB_USER&quot;)<br>db_pass = os.getenv(&quot;DB_PASS&quot;)<br>db_host = os.getenv(&quot;DB_HOST&quot;)<br>db_port = os.getenv(&quot;DB_PORT&quot;)<br>db_name = os.getenv(&quot;DB_NAME&quot;)<br><br>db_url = f&quot;postgresql+psycopg2://{db_user}:{db_pass}@{db_host}:{db_port}/{db_name}&quot;<br><br>engine = create_engine(db_url)</pre><h4>Step 4: The deployment with cloudbuild.yaml</h4><p>The cloudbuild.yaml file orchestrates the entire deployment process.</p><p><strong>4.1 Deployment command structure</strong></p><p>The --update-secrets flag tells Cloud Run to connect a secret from Secret Manager to an environment variable in your container.</p><pre># ... (steps for &#39;docker build&#39; and &#39;docker push&#39;) ...<br>- name: &#39;gcr.io/google.com/cloudsdktool/cloud-sdk&#39;<br>  entrypoint: &#39;bash&#39;<br>  args:<br>    - &#39;-c&#39;<br>    - |<br>      gcloud run deploy &quot;${_SERVICE_NAME}&quot; \<br>        --image &quot;${_REGION}-docker.pkg.dev/$PROJECT_ID/${_REPOSITORY}/${_SERVICE_NAME}:latest&quot; \<br>        --region &quot;${_REGION}&quot; \<br>        --service-account &quot;${_SERVICE_ACCOUNT_EMAIL}&quot; \<br>        # 1. Activates the Cloud SQL Auth Proxy sidecar<br>        --add-cloudsql-instances &quot;${_DB_INSTANCE_CONNECTION_NAME}&quot; \<br>        # 2. Configures the app to connect to localhost<br>        --update-env-vars &quot;DB_HOST=127.0.0.1,DB_USER=${_DB_USER},DB_NAME=${_DB_NAME},DB_PORT=5432&quot; \<br>        # 3. Injects the DB password from Secret Manager<br>        --update-secrets &quot;DB_PASS=[SECRET_NAME]:latest&quot;</pre><p><strong>4.2 Substitution variables</strong></p><p>Variables like ${_SERVICE_NAME} are defined in the substitutions section of the cloudbuild.yaml to keep the command clean.</p><pre>substitutions:<br>  _SERVICE_NAME: &#39;kairos-agent&#39;<br>  _REGION: &#39;us-central1&#39;<br>  _SERVICE_ACCOUNT_EMAIL: &#39;...&#39;<br>  _DB_INSTANCE_CONNECTION_NAME: &#39;[PROJECT_ID]:[REGION]:[INSTANCE_NAME]&#39;<br>  _DB_USER: &#39;[DB_USER]&#39; # The user created in step 1.1<br>  _DB_NAME: &#39;adk_session_kairos_app_db&#39;</pre><h4>Step 5: Execute the deployment</h4><p>With all components configured, the deployment is initiated with a single command from the root directory of the project.</p><pre>gcloud builds submit --config cloudbuild.yaml .</pre><h3>A concluding reflection</h3><p>The path to production is rarely straightforward. The real learning didn’t come from memorizing commands, but from understanding that there will always be surprises. Sometimes, the friction isn’t technical, but about how components connect. Remembering and validating these blind spots is what makes a deployment successful.</p><p>Fortunately, my friend Gemini CLI was there to make the “vibe coding” much easier, helping me debug every error until everything worked. This has been the first step for my application, and the next, without a doubt, will be to migrate everything to Terraform to automate the infrastructure and avoid this manual permissions configuration. For now, this stack is the solid foundation I’ll continue building on.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7ffef30636b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/from-laptop-to-cloud-deploying-an-ai-agent-with-adk-on-cloud-run-and-cloud-sql-e7ffef30636b">From Laptop to Cloud: Deploying an AI Agent with ADK on Cloud Run and Cloud SQL</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Goodbye, Passwords: The IAM Trick for Connecting Your Local App to Cloud SQL Friction-Free]]></title>
            <link>https://medium.com/enviame-engineering/goodbye-passwords-the-iam-trick-for-connecting-your-local-app-to-cloud-sql-friction-free-f4683e942935?source=rss-ca435cdd6c3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4683e942935</guid>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[gcp-iam]]></category>
            <category><![CDATA[google-adk]]></category>
            <category><![CDATA[cloud-sql]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <dc:creator><![CDATA[Rodrigo Oliva]]></dc:creator>
            <pubDate>Tue, 12 Aug 2025 01:39:26 GMT</pubDate>
            <atom:updated>2025-08-12T01:43:49.821Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Goodbye, Passwords: The IAM trick for Connecting your local app to Cloud SQL Friction-Free</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8TULlaoND19BFzznkhNh4A.jpeg" /></figure><h3><strong>TL;DR</strong></h3><p>🚪 Connect a local app to Cloud SQL for PostgreSQL without passwords using IAM.</p><p>🚀 Use the <strong>Cloud SQL Auth Proxy</strong> in a Docker container with auto-iam-authn.</p><p>✅ <strong>IAM simplifies access management</strong> and enhances security.</p><p>💥 Avoid common errors like the proxy’s loopback issue and user permissions.</p><p>💡 A practical guide with code snippets so you can replicate it immediately.</p><h3>The frustration of passwords in my local environment 😩</h3><p>A while back, I was setting up a prototype: an AI agent using Python and Google’s ADK. One of its key functions was to store chat sessions, and for that, I chose Cloud SQL for PostgreSQL. It’s a robust and familiar database. The dilemma came when I needed to connect my local development environment, based on Docker, to the Cloud SQL instance in GCP.</p><p>Initially, I did what many of us do: I created a database user with a password and put it in my .env file. It all worked. But I immediately felt the friction of management: that password needed to be rotated, stored securely, and kept up-to-date. Although I knew about the IAM option in Cloud SQL, I hadn&#39;t pushed myself to explore it; I was just used to the traditional way. The situation was unsustainable in the long run because, despite being a method I knew, it made me uncomfortable knowing there was a more secure and efficient way to do things. This was just the start of the project, and I knew it was the perfect time to try something new.</p><p>So I challenged myself: connect my local environment to Cloud SQL <strong>without a single password</strong>, using only IAM. The answer to my question, after a few tries and errors, was a resounding yes. I found out how to do it, and I want to tell you how.</p><h3>My working stack (quick context)</h3><p>Here is the combination of technologies I used to solve the problem:</p><ul><li><strong>DB</strong>: Cloud SQL for PostgreSQL 17</li><li><strong>Local</strong>: macOS Sequoia 15.5</li><li><strong>Proxy</strong>: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.8.0</li><li><strong>GUI Client</strong>: TablePlus 6.6.8 (632)</li><li><strong>App/Agent</strong>: Python + Google ADK (uses DatabaseSessionService, creates tables automatically)</li></ul><h3>Why I’m sticking with IAM</h3><p>After trying both methods, I have no doubt. The IAM connection is superior. Here are my top 3 reasons:</p><ol><li><strong>Centralized Permissions in IAM:</strong> User and access management moves from the database to Google Cloud. You can grant or revoke access for a developer or a service account simply by assigning or removing an IAM role. This reduces operational friction and eliminates the need to connect to the database just to create a user.</li><li><strong>No Passwords:</strong> This is the main benefit of this setup. Forget about rotating passwords, having to store them in .env files, or worrying about leaks. The Cloud SQL Auth Proxy automatically handles ephemeral tokens. This improves security and simplifies credential management at the code level.</li><li><strong>Unified Auditing:</strong> When you connect with a service account, all operations it performs are logged in Cloud Audit Logs. This gives you complete visibility into who accessed the database and when, which is much more complicated to achieve with local PostgreSQL users.</li></ol><h3>Real friction I encountered along the way</h3><p>It wasn’t as simple as it seemed. I faced two issues that cost me a few hours of debugging.</p><ol><li><strong>The </strong><strong>postgres User Is Your Friend:</strong> Even though IAM authenticates the service account, the database itself doesn&#39;t know what permissions that user has. The IAM user john-doe@text-gcp-project.iam.gserviceaccount.com exists for GCP, but not for PostgreSQL. The first time I tried to connect, the database rejected me due to a lack of permissions. The solution was to connect once as the default postgres user to grant the necessary permissions to my service account.</li><li><strong>The Proxy’s Loopback:</strong> My initial docker-compose.yml used the proxy listening on 127.0.0.1. This worked inside the container, but my local application couldn&#39;t connect to the exposed port. The proxy was listening only on the container&#39;s internal loopback, not on the Docker network. The solution was simple, but it took me a while to figure out: add the --address=0.0.0.0 flag so the proxy would listen on all network interfaces.</li></ol><h3>The minimal, functional setup</h3><p>Here’s the docker-compose.yml and .env that saved me. The secret lies in the proxy flags and using a GCP service account.</p><p>docker-compose.yml</p><pre>services:<br>  cloud-sql-proxy:<br>    image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.8.0<br>    command:<br>      - &quot;--structured-logs&quot;<br>      - &quot;--auto-iam-authn&quot;<br>      - &quot;--address=0.0.0.0&quot;<br>      - &quot;--port=5432&quot;<br>      - &quot;${CLOUD_SQL_CONNECTION_NAME}&quot;<br>    ports:<br>      - &quot;${DB_PORT}:5432&quot;<br>    volumes:<br>      - ${GCP_SA_KEY}:/credentials.json:ro<br>    environment:<br>      - GOOGLE_APPLICATION_CREDENTIALS=/credentials.json</pre><p>.env.example</p><pre>CLOUD_SQL_CONNECTION_NAME=your-project:us-central1:your-instance<br>DB_HOST=127.0.0.1<br>DB_PORT=5432<br>DB_USER=john-doe@text-gcp-project.iam.gserviceaccount.com<br>DB_PASS=<br>DB_NAME=adk_session_db<br>GCP_SA_KEY=./credentials.json</pre><p><strong>Important:</strong> In your .env file, you must leave <strong>DB_PASS empty</strong>. If you&#39;re using a GUI client like TablePlus, also leave the Password field blank and make sure <strong>SSL Mode</strong> is set to disabled, as the proxy handles the TLS connection.</p><p><strong>Connecting from my Python app (ADK):</strong></p><pre>db_url = f&quot;postgresql+psycopg2://{db_user}:{db_pass}@{db_host}:{db_port}/{db_name}&quot;<br>logger.info(f&quot;✅ Attempting to connect to PostgreSQL: {db_name} at {db_host}:{db_port}&quot;)<br><br>session_service = DatabaseSessionService(db_url=db_url)<br>runner = Runner(agent=root_agent, session_service=session_service, app_name=root_agent.name)</pre><h3>Troubleshooting common errors</h3><p>Here is a list of the errors I encountered and how I solved them, in case you run into them.</p><ul><li><strong>server closed the connection unexpectedly and the proxy &quot;doesn&#39;t react&quot;</strong>: The proxy wasn&#39;t listening on the correct address. <strong>Cause</strong>: The proxy defaults to binding to 127.0.0.1. <strong>Fix</strong>: Add --address=0.0.0.0 to the proxy command to expose it to the Docker network.</li><li><strong>googleapi: Error 403 ... cloudsql.instances.connect</strong>: The service account doesn&#39;t have permission to use the proxy. <strong>Cause</strong>: It was missing the roles/cloudsql.client role. <strong>Fix</strong>: Assign the role to your service account in IAM.</li><li><strong>FATAL: database &quot;&lt;user&gt;&quot; does not exist</strong>: The database client isn&#39;t specifying a database to connect to. <strong>Cause</strong>: The DB_NAME was empty or misconfigured. <strong>Fix</strong>: Make sure DB_NAME is correctly set.</li><li><strong>permission denied for schema public</strong>: The IAM user can connect, but doesn&#39;t have permissions to create or modify objects in the database. <strong>Cause</strong>: The service account doesn&#39;t have the necessary GRANTs in PostgreSQL. <strong>Fix</strong>: Connect as postgres and run the GRANT commands to give permissions to the IAM user.</li></ul><h4>The GRANTs in PostgreSQL</h4><p>This step is crucial so the service account can interact with the database once authenticated. Use the full email of the service account as if it were a PostgreSQL user.</p><p>You can verify the username of your service account with this command: gcloud sql users list --instance=your-instance.</p><pre>GRANT USAGE, CREATE ON SCHEMA public TO &quot;john-doe@text-gcp-project.iam.gserviceaccount.com&quot;;<br><br>GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public<br>TO &quot;john-doe@text-gcp-project.iam.gserviceaccount.com&quot;;<br><br>ALTER DEFAULT PRIVILEGES IN SCHEMA public<br>GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES<br>TO &quot;john-doe@text-gcp-project.iam.gserviceaccount.com&quot;;</pre><h3>Quick guide: from start to finish</h3><p>Follow these steps to replicate the setup:</p><ol><li><strong>Enable IAM Auth</strong>: In your Cloud SQL instance settings in GCP, check the box for cloudsql.iam_authentication=Enabled.</li><li><strong>Assign IAM roles</strong>: Run these commands in your terminal.</li></ol><pre>PROJECT_ID=your-gcp-project<br>SA_EMAIL=your-sa@your-gcp-project.iam.gserviceaccount.com<br><br>gcloud projects add-iam-policy-binding &quot;$PROJECT_ID&quot; \<br>  --member=&quot;serviceAccount:$SA_EMAIL&quot; \<br>  --role=&quot;roles/cloudsql.client&quot;<br><br>gcloud projects add-iam-policy-binding &quot;$PROJECT_ID&quot; \<br>  --member=&quot;serviceAccount:$SA_EMAIL&quot; \<br>  --role=&quot;roles/cloudsql.instanceUser&quot;</pre><p><strong>3. Create IAM user in Cloud SQL</strong>:</p><pre>INSTANCE=your-instance-name<br>gcloud sql users create &quot;$SA_EMAIL&quot; --instance=&quot;$INSTANCE&quot; --type=cloud_iam_service_account<br>gcloud sql users list --instance=&quot;$INSTANCE&quot;</pre><p><strong>4. Spin up the proxy</strong>: Place the docker-compose.yml and .env I gave you in a folder and run docker-compose up.</p><p><strong>5. Connect</strong>: From your GUI or code, use Host: 127.0.0.1, Port: ${DB_PORT}, User: SA_EMAIL, Password: (empty), DB: DB_NAME, and SSL: disabled.</p><p><strong>6. Run GRANTs</strong>: Connect as postgres and run the GRANT commands once to give the necessary permissions to your IAM user.</p><h3>Verification checklist</h3><p>[ ] Did you enable IAM authentication on your Cloud SQL instance?</p><p>[ ] Did you assign the cloudsql.client and cloudsql.instanceUser roles to the service account?</p><p>[ ] Did you create the IAM user in the database using gcloud sql users create?</p><p>[ ] Did you correctly configure the .env with the CLOUD_SQL_CONNECTION_NAME and DB_USER?</p><p>[ ] Did you use the --auto-iam-authn flag in the proxy command in your docker-compose.yml?</p><p>[ ] Are you leaving the password field blank in your database client?</p><h3>The future without passwords</h3><p>There’s no going back. Once you experience the simplicity and security of using IAM to connect to your database, passwords feel like a relic of the past. Friction is reduced, security is enhanced, and access management is centralized.</p><p>The next step, without a doubt, would be to automate the execution of the PostgreSQL GRANTs. Perhaps through a bootstrap migration or an initialization script. And, of course, I&#39;d avoid even having to manage the service account key on disk by using Workload Identity Federation. But that&#39;s a topic for another post. For now, enjoy this freedom without passwords.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4683e942935" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/goodbye-passwords-the-iam-trick-for-connecting-your-local-app-to-cloud-sql-friction-free-f4683e942935">Goodbye, Passwords: The IAM Trick for Connecting Your Local App to Cloud SQL Friction-Free</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Google Cloud Next ’25: Experiencing the Future of AI in Development (Beyond the Screen)]]></title>
            <link>https://medium.com/enviame-engineering/google-cloud-next-25-experiencing-the-future-of-ai-in-development-beyond-the-screen-60ada5abc5e9?source=rss-ca435cdd6c3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/60ada5abc5e9</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[google-cloud]]></category>
            <category><![CDATA[googlecloudnext25]]></category>
            <category><![CDATA[las-vegas]]></category>
            <dc:creator><![CDATA[Rodrigo Oliva]]></dc:creator>
            <pubDate>Wed, 16 Apr 2025 20:29:07 GMT</pubDate>
            <atom:updated>2025-04-16T20:45:49.080Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j0svE34dmX0HRwoaMTzYrw.jpeg" /></figure><p>Last week, I had the incredible opportunity to attend Google Cloud Next 2025 in Las Vegas. An event I had previously followed on YouTube became an immersive experience, sharing the same space with the key players driving innovation at Google.</p><p>Beyond the specific announcements, the atmosphere of the event conveyed an undeniable reality: <strong>artificial intelligence and agents are setting the pace for the next technological revolution.</strong></p><h3>The new momentum of Gemini Code Assist in Development</h3><p>What truly resonated from the presentations on <strong>Gemini Code Assist</strong> was the <strong>extension of its integration throughout the entire software development lifecycle.</strong> While some of its capabilities were already known, Next ’25 placed a strong emphasis on how it <strong>now spans from the initial concept in a document to code review in a Pull Request.</strong></p><p>Witnessing the demonstration of how Gemini Code Assist could <strong>interpret a natural language requirement from Google Docs and, from there, suggest the initial code structure and even generate outlines for unit tests</strong>, was impressive. This goes beyond simple autocompletion; it’s about <strong>intelligent contextual assistance that understands the development goal from the outset.</strong></p><p>The <strong>integration with collaboration platforms like GitHub</strong> was also presented as a significant evolution. The idea of having an AI assistant that can <strong>analyze changes in a PR, point out potential problems or areas for improvement, and facilitate conversation between developers</strong>, promises to <strong>reduce review times and significantly improve code quality.</strong></p><p>Although Gemini Code Assist already offered code assistance and natural language chat, the <strong>new focus on full lifecycle integration and its presence in the early stages of development</strong> was what stood out at the event.</p><h3>The rise of intelligent agents: ADK and A2A</h3><p>Beyond individual tools, Google presented a vision of the future where <strong>AI agents collaborate in a more sophisticated manner.</strong> The announcement of the <strong>Agent Development Kit (ADK)</strong> as an open-source framework underscores the commitment to facilitating the creation of <strong>complex and scalable multi-agent systems.</strong> This opens the door to building applications where multiple specialized agents work together to solve problems.</p><p>In this context, the <strong>Agent2Agent (A2A) Protocol</strong> emerges as a key component. The ability for <strong>agents of different technologies to communicate fluidly with each other</strong> is fundamental to unlocking the true potential of AI collaboration.</p><h3>The in-person experience: An invaluable difference</h3><p>While online broadcasts are valuable, <strong>experiencing Google Cloud Next in person offers a completely different dimension.</strong> Being surrounded by professionals with similar interests, <strong>seeking answers and sharing concerns</strong>, generates a unique energy. The <strong>informal conversations and direct access to experts in live demos</strong> are experiences that enrich understanding and open new perspectives.</p><h3>The transformative impact of agents</h3><p>The central conversation revolved around the <strong>impact of agents on our daily work.</strong> The prevailing vision is not one of replacement, but of a <strong>powerful “super tool.”</strong> These intelligent assistants have the potential to <strong>automate repetitive tasks and enhance our skills</strong>, allowing us to focus on more complex and innovative challenges.</p><p>In my opinion, the analogy with <strong>knowing how to use Excel today</strong> is very apt. In its time, Excel revolutionized how we worked with data. In the future, <strong>fluid interaction with AI and agents will become an essential skill</strong> for any technology professional.</p><h3>Recommendations for adoption</h3><p>My main advice for the developer community and tech folks reading this is to <strong>proactively integrate AI into your daily workflows.</strong> Don’t limit it to just answering quick questions; <strong>request tasks, delegate processes, and consider it another member of your team.</strong> Your role will be crucial in validating the usefulness and accuracy of the proposed solutions.</p><p>At a product level, I believe it’s fundamental to explore how to <strong>transform our platforms into agents or enhance them with their capabilities.</strong> This will open new opportunities to offer <strong>more personalized, efficient, and valuable user experiences.</strong></p><p>Google Cloud Next ’25 was an immersion into the future of technology. <strong>AI and agents are a present reality with enormous potential.</strong> The key lies in <strong>understanding how to strategically integrate them into our work to drive productivity, innovation, and professional growth.</strong> The invitation is open: let’s start exploring and delivering extraordinary experiences!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60ada5abc5e9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/google-cloud-next-25-experiencing-the-future-of-ai-in-development-beyond-the-screen-60ada5abc5e9">Google Cloud Next ’25: Experiencing the Future of AI in Development (Beyond the Screen)</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploring Vertex AI and function calling]]></title>
            <link>https://medium.com/enviame-engineering/exploring-vertex-ai-and-function-calling-af136a7a41f6?source=rss-ca435cdd6c3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/af136a7a41f6</guid>
            <category><![CDATA[calling-function]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[vertex-ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Rodrigo Oliva]]></dc:creator>
            <pubDate>Fri, 31 Jan 2025 19:17:20 GMT</pubDate>
            <atom:updated>2025-01-31T19:17:20.344Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IdFDQH_9eZyb7hHET6YHVw.png" /></figure><p>2024 marked a turning point for generative AI. In this context, I’ve been exploring how these technologies can transform processes at Envíame, our multi-courier solution for e-commerce.</p><p>At Envíame, we use Google Cloud Platform (GCP) as our cloud provider, where I discovered Vertex AI. According to GCP:</p><blockquote>Vertex AI is a machine learning (ML) platform that lets you train and deploy ML models and AI applications, and customize large language models (LLMs) for use in your AI-powered applications.</blockquote><p>While exploring Vertex AI, I came across <strong>Function Calling</strong>,<strong> </strong>a feature that allows language models to leverage external tools such as APIs, databases, and custom functions.</p><h3><strong>What does it mean for Envíame?</strong></h3><p>One of the most frecuent questions we hear from customers is: “<strong>Where is my package ?</strong>” This seemingly simple inquiry highlights a major challenge in the e-commerce and logistics industry: real-time tracking and updates.<br>Customers often experience frustration due to the lack of immediate responses, leaving them in the dark. While LLMs are powerful, their static knowledge limits their ability to provide real-time answers. This is where Function Calling comes in: it enables the model to execute specific functions within the code to access dynamic data and respond accurately.</p><p>In the logistics industry, providing accurate, up-to-date information quickly is crucial for improving both customer experience and operational efficiency.</p><h3>Show me the code!</h3><p>In the next steps, we’ll build a basic example based on the <a href="https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/function-calling#python-dictionary">official documentation</a> from GCP to answer the common question, “Where is my package?” using the Vertex AI library and Function Calling feature.</p><p>This example will demostrate how to set up the necessary components, call custom functions inside the code, and provide real-time answers, transforming the way we interact with AI in practical, everyday use cases like package tracking. Let’s dive into the code and see how it all works!</p><h4><strong>Step 1: Setup our enviroment</strong></h4><pre>import vertexai<br>from vertexai.generative_models import (<br>    Content,<br>    FunctionDeclaration,<br>    GenerationConfig,<br>    GenerativeModel,<br>    Part,<br>    Tool,<br>    ToolConfig<br>)<br># Initialize Vertex AI<br># TODO(developer): Update and un-comment below lines<br>PROJECT_ID = &#39;medium-example&#39;<br>vertexai.init(project=PROJECT_ID, location=&quot;us-central1&quot;)<br><br># Initialize Gemini model<br>model = GenerativeModel(model_name=&quot;gemini-1.5-flash-002&quot;)</pre><h4>Step 2: Declare a set of functions</h4><p>For function calling to work effectively, it’s important to define a set of functions that provide additional information to the prompt. To achieve this, you should use FunctionDeclaration, which follows a format compatible with the OpenAPI schema.</p><p>The get_delivery_info function calls Enviame’s API to retrieve the delivery details.</p><pre>function_name = &quot;get_delivery_info&quot;<br>get_delivery_info_func = FunctionDeclaration(<br>    name=function_name,<br>    description=&quot;Retrieve the complete details and tracking history of a delivery by its delivery ID, including information such as customer details, product description, delivery deadline, origin address, and destination address.&quot;,<br>    # Function parameters are specified in JSON schema format<br>    parameters={<br>        &quot;type&quot;: &quot;object&quot;,<br>        &quot;properties&quot;: {<br>            &quot;delivery_id&quot;: {<br>                &quot;type&quot;: &quot;string&quot;,<br>                &quot;description&quot;: &quot;The unique identifier of the delivery/order/shipping.&quot;<br>            }<br>        },<br>        &quot;required&quot;: [&quot;delivery_id&quot;]<br>    },<br>)</pre><h4>Step 3: Submit the prompt and function declarations to the model</h4><p>With the prompt and function declarations, you can now instantiate the model to generate content. You can specify whether the model should only find answers using tools (function declarations), natural language, or both. For this example, we restrict the responses to function declaration only.</p><pre>question = &quot;Where is my package 124985027 ?&quot;<br># Define the user&#39;s prompt in a Content object that we can reuse in model calls<br>user_prompt_content = Content(<br>    role=&quot;user&quot;,<br>    parts=[<br>        Part.from_text(question),<br>    ],<br>)<br><br># Define a tool that includes some of the functions that we declared earlier<br>tool = Tool(<br>    function_declarations=[get_delivery_info_func],<br>)<br><br># Send the prompt and instruct the model to generate content using the Tool object that you just created<br>response = model.generate_content(<br>    user_prompt_content,<br>    generation_config=GenerationConfig(temperature=0),<br>    tools=[tool],<br>    tool_config=ToolConfig(<br>        function_calling_config=ToolConfig.FunctionCallingConfig(<br>            # ANY mode forces the model to predict only function calls<br>            mode=ToolConfig.FunctionCallingConfig.Mode.ANY,<br>            # Allowed function calls to predict when the mode is ANY. If empty, any  of<br>            # the provided function calls will be predicted.<br>            allowed_function_names=[&quot;get_delivery_info&quot;],<br>        )<br>    )<br>)</pre><p>When we execute the code and the model processes the prompt with the function declaration, the output contains information about the function and the parameters required to call it.</p><pre>Text: where is my package 124985027 ?<br>candidates {<br>  content {<br>    role: &quot;model&quot;<br>    parts {<br>      function_call {<br>        name: &quot;get_delivery_info&quot;<br>        args {<br>          fields {<br>            key: &quot;delivery_id&quot;<br>            value {<br>              string_value: &quot;124985027&quot;<br>            }<br>          }<br>        }<br>      }<br>    }<br>  }<br>  finish_reason: STOP<br>  avg_logprobs: -4.9450058106552152e-05<br>}<br>usage_metadata {<br>  prompt_token_count: 72<br>  candidates_token_count: 17<br>  total_token_count: 89<br>}</pre><h4>Step 4: Invoke an external API</h4><p>With the information and parameters for the function, it’s time to call the function within your code and use the response again in the model.</p><pre>function_handlers = {<br>    &quot;get_delivery_info&quot;: get_delivery_info<br>}<br><br>for function_call in response.candidates[0].function_calls:<br>    function_name = function_call.name<br>    args = {key: value for key, value in function_call.args.items()}<br>    if function_name in function_handlers:<br>        # Call the appropriate function with the extracted arguments<br>        api_response = function_handlers[function_name](args)<br>        # Return the dummy API response to Gemini so it can generate a model response or request another function call<br>        response = model.generate_content(<br>            [<br>                user_prompt_content,  # User prompt<br>                response.candidates[0].content,  # Function call response<br>                Content(<br>                    parts=[<br>                        Part.from_function_response(<br>                            name=function_call.name,<br>                            response={&quot;content&quot;: api_response},  # Return the function response to Gemini<br>                        ),<br>                    ],<br>                ),<br>            ],<br>            tools=[tool],<br>        )<br>        print(response.text)</pre><pre><br>root@28ed93521c61:/app# python exploring-calling-function-medium.py &quot;where is my package 124985027 ?&quot;<br>Your package 124985027, with tracking number 7970788922, was delivered on January 29, 2025 at 12:04:18 PM to Chillán, CL.  A family member accepted the delivery.  The delivery was made by Courier Private.</pre><h3>Conclusion</h3><p>Discovering this has been a real eye-opener for me. I now see how AI can evolve into a true agent that provides real-time information and interaction, transforming the way our system works. When I looked back, I realized that instead of relying on complex filters, we could simplify the user experience to make it feel like a natural conversation with an agent. Imagine if Envíame’s platform became that agent — you could simply ask for what you need, like ‘Show me the latest shipment’ or ‘Generate a manifest for orders placed today.’ Right now, you can do this, but it requires multiple clicks and navigating through several steps.</p><p>What if we could eliminate all that complexity and let the AI handle it directly with just a few commands? How much more efficient would our processes be if users could interact with the system using plain language? Could this change the way we engage with the platform, creating a smoother and faster experience for everyone?</p><p>Would this redefine how we build and design user interfaces in the future? And more importantly, could it allow us to unlock new possibilities for automation and decision-making that we hadn’t considered before?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af136a7a41f6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/exploring-vertex-ai-and-function-calling-af136a7a41f6">Exploring Vertex AI and function calling</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>