BoutiqueAI Assistant using ADK+MCP

BoutiqueAI Shopping Assistant is personalized shopping concierge. Instead of scrolling endlessly, users get curated product recommendations in real time using ADK and MCP

Comment

AI Boutique Assistant MCP - GKE Turns 10 Hackathon Submission

Inspiration

For the GKE Hackathon, I wanted to build a conversational shopping assistant that demonstrates the power of Agent Development Kit (ADK) and Model Context Protocol (MCP) for connecting AI agents to complex microservices architectures.

Inspiration

My inspiration came from three key observations:

  • Shopping should feel like talking to a knowledgeable store assistant - natural, helpful, and personalized
  • AI agents need standardized ways to communicate with microservices - MCP provides this protocol layer
  • Complex architectures should be simple to orchestrate - ADK makes agent development straightforward while handling sophisticated microservice integration

I wanted to showcase how Google Kubernetes Engine could orchestrate complex microservices architectures using Google ADK, Model Context Protocol, and Gemini 2.0 Flash with a clean, scalable architecture that maintains separation of concerns.

The key insight: Instead of building monolithic AI applications, we can use MCP to create modular, reusable components where AI agents communicate with specialized servers that handle domain-specific functionality.

What it does

AI Boutique Assistant MCP Client is an ADK-powered shopping assistant that uses Model Context Protocol to communicate with a dedicated MCP server for microservice orchestration. Users can:

  • Search products naturally: "Find me some sunglasses" triggers MCP tool calls to product catalog services
  • Manage their cart through conversation: "Add 2 mugs to my cart" uses MCP to coordinate cart and product services
  • Complete purchases seamlessly: Checkout flows orchestrated through MCP server calls to payment, shipping, and email services
  • Get personalized recommendations: AI-powered suggestions via MCP recommendation service integration
  • Handle multi-currency transactions: Currency conversion through MCP currency service tools
  • Receive order confirmations: Email notifications sent via MCP email service integration

Key Innovation: The AI agent never directly calls microservices. Instead, it communicates with an MCP server that acts as a translation layer, exposing microservice functions as standardized MCP tools.

How we built it

Model Context Protocol (MCP) Architecture

The core innovation is the MCP server (ai-boutique-assit-mcp) that I built, which:

  1. Exposes microservice functions as MCP tools
  2. Handles gRPC communication with all 9 Online Boutique services
  3. Provides type-safe function calling through MCP protocol
  4. Manages service discovery and error handling
  5. Runs in stdio mode for seamless ADK integration
# MCP Server invocation in ADK agent
McpToolset(
    connection_params=StdioConnectionParams(
        server_params=StdioServerParameters(
            command="boutique-mcp-server",
            args=["--stdio"]
        ),
        timeout=180
    )
)

Agent Development Kit (ADK) Integration

Built using Google's Agent Development Kit with Gemini 2.0 Flash:

  • Natural language processing for shopping queries
  • Function calling orchestration via MCP tools
  • Web interface for user interactions
  • Context-aware conversation management
  • Tool selection logic for appropriate microservice calls

MCP Server Development

Created a comprehensive MCP server that exposes 18+ microservice functions:

Product Catalog Tools:

  • list_products, search_products, get_product_with_image
  • filter_products_by_price for price-based filtering

Shopping Cart Tools:

  • add_item_to_cart, get_cart, empty_cart

Order Processing Tools:

  • place_order, get_shipping_quote, charge_card
  • send_order_confirmation via email service

Recommendation & Ad Tools:

  • list_recommendations, get_ads for personalized experience

Kubernetes Native Deployment

Deployed on Google Kubernetes Engine with:

  • Containerized ADK agent with MCP server integration
  • Separate ingress controller (ingress-nginx-mcp) for dedicated routing
  • Service discovery for microservice communication
  • Secrets management for API keys and credentials
  • Rolling deployments with zero downtime updates

Technology Stack

  • AI Framework: Google ADK + Gemini 2.0 Flash
  • Protocol Layer: Model Context Protocol (MCP)
  • Backend: Python + gRPC + Protocol Buffers
  • Infrastructure: Google Kubernetes Engine (GKE)
  • Container Platform: Docker with AMD64 builds

Challenges I ran into

1. MCP Protocol Implementation Complexity

Building an MCP server that properly exposes 9 different gRPC services with correct type mapping and error handling required deep understanding of both protocols.

Solution: Created a comprehensive mapping layer that converts gRPC protobuf messages to JSON-serializable dictionaries for MCP transport, with proper error handling and type safety.

2. ADK Integration with Stdio Mode

Getting the ADK agent to properly communicate with the MCP server via stdio required careful subprocess management and JSON-RPC protocol handling.

Solution: Implemented proper stdio buffering and JSON-RPC message framing in the MCP server, ensuring reliable communication between ADK and MCP components.

3. Microservices Orchestration via MCP

Coordinating 9 different microservices through MCP tool calls while maintaining conversation context and proper error propagation.

Solution: Built intelligent function chaining in the ADK agent that knows when to call multiple MCP tools in sequence (e.g., search product → get details → add to cart → show recommendations).

4. GKE Service Discovery & MCP Integration

Ensuring the MCP server could properly connect to all microservices in the Kubernetes cluster while maintaining development/production configuration flexibility.

Solution: Implemented environment-based service endpoint configuration with proper Kubernetes DNS resolution and health checking.

Accomplishments that I am proud of

Production-Ready MCP Server

Successfully created and published a complete MCP server package to PyPI (ai-boutique-assit-mcp) that can be reused by any ADK agent needing Online Boutique integration.

Clean Protocol Separation

Achieved clean separation between:

  • ADK Agent: Handles conversation, reasoning, and user interaction
  • MCP Server: Manages microservice communication and data transformation
  • Microservices: Remain completely unchanged, no modifications needed

Seamless GKE Integration

Deployed a multi-component architecture on GKE that demonstrates:

  • Container orchestration for AI agents
  • Service mesh communication between agent and microservices
  • Ingress management with dedicated controllers
  • Secrets management for API keys

Real Microservice Integration

Connected to 9 real microservices running on GKE - not mock APIs. Each service handles specific e-commerce functions with proper error handling and type safety through MCP.

What I learned

Model Context Protocol Benefits

  • Standardized communication: MCP provides a universal way for AI agents to communicate with external tools
  • Type safety: Strong typing through MCP tool definitions prevents runtime errors
  • Reusability: MCP servers can be shared across multiple AI agents and applications
  • Modularity: Clear separation between agent reasoning and tool implementation

Agent Development Kit Power

  • Rapid agent development: ADK handles complex LLM integration, allowing focus on business logic
  • Built-in web interface: Zero-effort UI for agent interactions
  • Tool management: Automatic discovery and integration of MCP tools
  • Production deployment: Built-in patterns for containerized agent deployment

AI-Native Microservices Architecture

  • Protocol layering: How MCP acts as a bridge between AI reasoning and microservice APIs
  • Function orchestration: Teaching AI agents to intelligently combine multiple microservice calls
  • Context preservation: Maintaining conversation state across complex service interactions
  • Error handling: Graceful degradation when microservices are unavailable

Kubernetes for AI Workloads

  • Agent deployment patterns: Best practices for running AI agents in containers
  • Service discovery: How AI components find and communicate with microservices
  • Resource management: Balancing AI computation with microservice communication needs
  • Ingress strategies: Exposing AI agents through separate ingress controllers

What's next for BoutiqueAI Assistant using ADK+MCP

Enhanced MCP Capabilities

  • Multi-agent orchestration: Use Agent2Agent (A2A) protocol for complex workflows
  • Streaming support: Real-time updates via MCP streaming protocols
  • Tool composition: Chain multiple MCP tools for complex business logic
  • Cross-service transactions: Implement distributed transaction patterns via AP2

Built With

  • adk
  • docker
  • fastapi
  • gcp
  • gke
  • grpc
  • json-grpc
  • mcp
  • protobuf
Share this project:

Updates