Céleste - The AI Shopping Assistant

Celeste - a multi-agent conversational shopping assistant that enhances Google's Online Boutique by orchestrating a search analysis agent, inventory monitoring and personalised recommendation system.

Comment

About Céleste AI Shopping Assistant

Céleste is an autonomous, multi-agent AI system built on Google's Kubernetes Engine, with Gemini to enhance Google's Online Boutique. Happy 10th Birthday GKE !

It's a dynamic conversational assistant powered by Google's agent frameworks, leveraging the Agent Development Kit to build its specialised agents and the Model Context Protocol to securely connect them to the existing Online Boutique APIs. gent-to-agent protocols are implemented to communicate and coordinate with one another to create a seamless service where a search agent analyses customer intent, an inventory agent monitors stock patterns, and a recommendation agent generates personalised suggestions. So the project really is about adding advanced functionality to the typical AI chatbot. Célestes's agentic AI can autonomously enhance existing microservice architectures without modifying the core application's code. Play about with it and have fun !

Demo: http://34.54.94.175/home

Github: https://github.com/TechAngelX/Celeste-AI-Agent

Inspiration

The hackathon challenge focused on enhancing existing microservice applications with agentic AI capabilities. This presented an opportunity to address a common pain point in e-commerce: the gap between customer intent and product discovery. Traditional search interfaces require users to translate their needs into specific keywords, often leading to frustration when seeking items that are difficult to describe.

The concept for Céleste emerged from recognising that conversational AI could bridge this gap by enabling natural language interactions within existing e-commerce architectures. Rather than building an entirely new platform, the goal was to demonstrate seamless integration with Google's Online Boutique whilst preserving the existing system's stability and functionality.

What I Learned

This project provided valuable experience across several key areas:

  • Microservice Architecture: Understanding how to extend existing systems without modifying core application logic or disrupting established service boundaries
  • Kubernetes Orchestration: Implementing proper container deployment, resource management, and service discovery patterns on Google Kubernetes Engine
  • AI Integration: Working with Google's Gemini models to create responsive, context-aware conversational interfaces
  • Cloud-Native Development: Implementing security best practices including secrets management, health monitoring, and scalable deployment strategies

The project highlighted how modern cloud platforms enable rapid development by abstracting infrastructure complexity whilst maintaining production-ready capabilities.

How I Built It

Céleste is implemented as a Go microservice that integrates with Google's Gemini AI models through REST APIs. The service exposes endpoints for conversational interactions and is designed to integrate with the existing Online Boutique product catalogue and cart services.

Technical Stack:

  • Backend Service: Go with Gorilla Mux for HTTP routing and request handling
  • AI Integration: Google Gemini 2.5 Flash for natural language processing and response generation
  • Containerisation: Docker with multi-stage builds for optimised image size
  • Orchestration: Google Kubernetes Engine Autopilot for managed deployment and scaling
  • Registry: Google Artifact Registry for secure container image storage

API Endpoints I Built

  • /home: The primary conversational interface that accepts user queries and orchestrates the three-agent workflow to return intelligent shopping responses.

  • /health: A comprehensive health check endpoint that returns the status of all three agents and system metrics. This endpoint is essential for Kubernetes liveness and readiness probes.

  • /agents: An administrative endpoint that lists all registered agents and their current count. It is useful for monitoring the multi-agent system's operational state.

  • /api-comparison: An interactive demonstration tool showcasing the difference between basic product search and Céleste's multi-agent processing in real-time, ideal for technical demonstrations.

My Kubernetes deployment includes health checks, resource limits, and horizontal scaling to ensure production readiness within the broader microservices ecosystem. The endpoint design enables easy monitoring, debugging, and demonstration of system capabilities while maintaining a clear separation of concerns between operational and user-facing functionality.

Implementation Process:

  1. Developed the core Go service with structured error handling and environment-based configuration
  2. Integrated Gemini API with proper authentication and response parsing
  3. Created comprehensive Kubernetes manifests including deployments, services, and secrets
  4. Implemented Docker containerisation with appropriate security and efficiency measures
  5. Deployed to GKE with proper resource allocation and monitoring capabilities

Challenges Faced

Authentication Configuration: Configuring the GKE authentication plugin required understanding the transition from legacy authentication methods to the newer gke-gcloud-auth-plugin system for kubectl cluster access.

Secrets Management: Implementing secure API key handling in Kubernetes whilst ensuring service reliability across pod restarts and scaling events required careful consideration of secret lifecycle management.

Build Environment Compatibility: Managing Go version compatibility between local development environment (Go 1.25) and container build environment initially caused compilation failures, requiring Dockerfile optimisation.

Resource Planning: Balancing cost efficiency with performance requirements whilst ensuring the service could handle expected load patterns within the hackathon's resource constraints.

Technical Implementation

The service architecture follows cloud-native best practices with structured logging, comprehensive error handling, and proper resource management. The API design enables future integration with Online Boutique's existing product catalogue and cart services without requiring modifications to the base application.

The Kubernetes deployment includes appropriate health checks, resource limits, and horizontal scaling capabilities to ensure production readiness within the broader microservices ecosystem.

Future Development

The current implementation provides a solid foundation for advanced features including real-time product catalogue integration, personalised recommendation engines, and enhanced conversational capabilities. The modular architecture supports these enhancements without requiring significant refactoring of the core service logic.

Built With

Share this project:

Updates