Introduction

I've always been interested in how AI applications work beyond just asking questions to a chatbot.

So, while working through the Google AI Cloud Academy, I decided to build something small but practical — a virtual coffee shop assistant.

I named it Coffee Barista ☕.

The idea was simple:

Instead of searching through a menu manually, what if I could just ask an AI barista what I want?

For example:

• "What drinks are available?"

• "Tell me about the Matcha Green Tea Latte."

• "What would you recommend for someone who likes matcha?"

• "Do you have Dragon Fruit Espresso?"

• "What dairy-free options do you have?"

This project gave me hands-on experience with AI agents, RAG, vector search, Gemini, Firestore, Streamlit and Cloud Run.

💡 What I Built

Coffee Barista is a customer-facing AI application that understands questions about a coffee shop menu and responds with relevant information.

Instead of making the AI simply generate an answer from its own knowledge, I wanted the responses to be connected to the actual menu data.

That's where Retrieval-Augmented Generation (RAG) comes in.

The basic idea is:

User Question
      ↓
AI Agent
      ↓
Retrieve Relevant Menu Information
      ↓
Gemini
      ↓
AI Response

So the application can answer questions using the information available in the coffee shop's menu.

🏗️ How the Application Works

The architecture of my application looks roughly like this:

             👤 Customer
                  |
                  ↓
          ┌───────────────┐
          │   Streamlit   │
          │      UI       │
          └───────┬───────┘
                  |
                  ↓
          ┌───────────────┐
          │   ADK Agent   │
          └───────┬───────┘
                  |
                  ↓
          ┌───────────────┐
          │ Gemini /      │
          │ Vertex AI     │
          └───────┬───────┘
                  |
                  ↓
          ┌───────────────┐
          │   Firestore   │
          │ Vector Search │
          └───────┬───────┘
                  |
                  ↓
          📋 Menu Information
                  |
                  ↓
             🤖 Response

The application is hosted on Google Cloud Run, so the final application can be accessed through a web browser.

☕ Creating the Coffee Menu

I started with a simple mock menu stored in menu.json.

Some of the items included:

• Oat Milk Honey Latte

• Matcha Green Tea Latte

• Vegan Blueberry Muffin

• Cold Brew Coffee

• Nitro Cold Brew

• Iced Caramel Macchiato

Each menu item contains information such as its name, description and price.

For example:

Matcha Green Tea Latte

Price: $5.50

Description:
Creamy steamed oat milk infused with premium
Japanese matcha powder.

This gave the AI agent a small knowledge base to work with.

🔎 Adding Vector Embeddings

This was one of the parts I found most interesting.

Instead of searching the menu only by exact words, I used text embeddings to represent menu information as vectors.

For example, the text:

Matcha Green Tea Latte:
Creamy steamed oat milk infused with premium
Japanese matcha powder.

can be converted into a numerical vector representation.

That vector can then be stored in Firestore.

This allows the application to perform semantic retrieval.

For example, a customer might ask:

"What would you recommend if I enjoy earthy and green tea flavors?"

The question doesn't have to exactly match the menu description. The vector representation can help find information that is semantically related.

🤖 Building the AI Agent

I used Google's Agent Development Kit (ADK) to build the agent logic.

The agent acts as the bridge between the customer and the menu information.

The basic flow is:

Customer asks a question
          ↓
Agent understands the request
          ↓
Relevant information is retrieved
          ↓
Gemini generates the response
          ↓
Customer receives the answer

This makes the interaction feel much more natural than simply displaying a static menu.

🎨 Building the Interface with Streamlit

For the frontend, I used Streamlit.

I wanted to keep the interface simple so that the main focus was the interaction with the AI barista.

The application contains:

• Coffee shop branding

• Menu information

• Chat interface

• User questions

• AI-generated responses

• Personalized recommendations

The final interface looks like a small virtual coffee shop assistant.

☁️ Deploying to Cloud Run

Once the application was working locally, I deployed it to Google Cloud Run.

This was an important step for me because the project went from being something running in Cloud Shell to an actual publicly accessible application.

My deployed application is available here:

🚀 Live Demo

https://coffee-barista-176896011523.us-west1.run.app/

Anyone with the link can open the application and interact with the Coffee Barista.

🔐 Using a Service Account

For the Cloud Run deployment, I created a dedicated service account for the application:

barista-agent-sa

The application uses this service account to access the required Google Cloud services.

This also helped me understand an important cloud security concept:

Least privilege.

Instead of giving an application unnecessary permissions, the goal is to provide only the permissions required for it to work.

🧪 Testing the AI Barista

After deployment, I tested the application with different questions.

Test 1 — Checking the menu

I asked:

"What drinks are available?"

The agent returned the available drinks from the menu.

Test 2 — Asking about a specific drink

I asked:

"Tell me about the Matcha Green Tea Latte."

The agent provided information about the drink, including its ingredients and characteristics.

Test 3 — Getting a recommendation

I asked:

"What would you recommend for someone who likes matcha?"

The agent recommended the Matcha Green Tea Latte and also suggested a suitable pastry.

Test 4 — Asking about something that isn't available

I also tested:

"Do you have Dragon Fruit Espresso?"

The agent correctly responded that it wasn't available on the menu and suggested alternatives.

This was a useful test because an AI application shouldn't simply invent a product when it doesn't exist in the available menu information.

📂 Project Structure

The project is kept relatively simple:

coffee-barista-agent/
│
├── agent.py
├── app.py
├── menu.json
├── requirements.txt
├── seed.py
└── README.md

agent.py

Contains the agent-related logic.

app.py

Contains the Streamlit application.

menu.json

Contains the coffee shop menu data.

seed.py

Used for preparing/storing the menu data.

requirements.txt

Contains the Python dependencies.

README.md

Contains the project documentation.

🛠️ Technologies I Used

The main technologies I worked with in this project were:

• Python

• Google Gemini / Vertex AI

• Google ADK

• Firestore

• Firestore Vector Search

• Text Embeddings

• Streamlit

• Google Cloud Run

• Google Cloud IAM

• Git

• GitHub

  What I Learned

  This project was more than just following a codelab for me.

  I got to see how different pieces of a modern AI application fit together.

  Some of the things I learned were:

  1. AI agents are more than just chatbots

  An agent can interact with tools and external data instead of relying only on the model's generated knowledge.

  1. RAG is useful for grounding AI

  If an application needs to answer questions about a specific dataset, retrieving relevant information first can make the responses much more useful.

  1. Vector search is pretty powerful

  I found the idea of searching based on meaning rather than exact keywords especially interesting.

  1. Cloud deployment is a different experience from local development

  Getting the application running locally is one thing.

  Getting it deployed, configuring permissions, handling environment variables and making it publicly accessible is another.

  1. Security matters

  Working with service accounts and IAM made me understand why applications shouldn't simply be given broad permissions.

  🚀 What's Next?

  This Coffee Barista application is currently a simple prototype, but there are many ways I could extend it.

  Some ideas I'd like to explore are:

  🛒 Add a shopping cart 📦 Add order placement 💳 Add payment integration 📍 Add store/location information 👤 Remember customer preferences 🌐 Add multiple languages 🎙️ Add voice interaction 📊 Add analytics 📦 Connect the menu to real-time inventory

  The same basic architecture could also be adapted for other use cases such as restaurant assistants, customer support agents, product recommendation systems and internal business assistants.

  🔗 Project Links 🚀 Live Application

  https://coffee-barista-176896011523.us-west1.run.app/

  💻 Source Code

  https://github.com/mageshsugumaran2123/coffee-barista-rag-agent

  ❤️ Final Thoughts

  Building Coffee Barista was a really good introduction to putting together a complete Generative AI application.

  What started as a simple coffee menu became an application involving:

  Menu Data ↓ Embeddings ↓ Vector Search ↓ RAG ↓ AI Agent ↓ Streamlit ↓ Cloud Run ↓ 🚀 Live AI Application

  The biggest takeaway for me was that building an AI application isn't just about getting an AI model to generate text.

  It's about connecting the model to real data, tools, interfaces and cloud infrastructure to solve an actual problem.

  And honestly, turning a coffee shop menu into my first deployed AI agent was a pretty fun way to learn it. ☕🤖