Introduction

Ever wished you could shop online as naturally as talking to a store assistant? That's exactly what we built with TransactAI for the GKE Turns 10 Hackathon. In this blog post, I'll share how we combined Google Cloud's microservices architecture with AI agents to create a conversational e-commerce experience.

The Vision

Imagine typing "I need a stylish but affordable gift for my mom" and having an AI understand your intent, suggest relevant products, and handle the entire purchase process seamlessly. That's TransactAI - a bridge between natural human communication and e-commerce infrastructure.

Technical Architecture

The Building Blocks

1. Orchestrator AI Agent

   • Built with Google's Gemini Pro

   • Handles natural language understanding

   • Coordinates between services

   • Provides a Streamlit-based UI

2. Order Agent (MCP Protocol)

   • Manages product catalog

   • Handles order placement

   • Integrates with Google's Online Boutique

   • Implements Model Context Protocol for service discovery

3. Payment AI Agent (A2A Protocol)

   • Processes payments naturally

   • Implements Agent-to-Agent communication

   • Validates transactions

   • Provides secure payment handling

4. Google Cloud Infrastructure

   • Online Boutique running on GKE

   • Kubernetes for scalability

   • Microservices architecture

   • Real-time inventory management

The Innovation: AI Agent Protocols

One of our key innovations was implementing two different AI agent communication protocols:

Model Context Protocol (MCP)

@app.get("/.well-known/mcp")
async def get_mcp_manifest():
    return {
        "tools": [
            {
                "name": "listProducts",
                "description": "List available products",
                "parameters": {}
            },
            {
                "name": "placeOrder",
                "description": "Place an order for a product",
                "parameters": {
                    "product_id": "string",
                    "quantity": "integer"
                }
            }
        ]
    }

Agent-to-Agent (A2A) Protocol

class AgentMessage(BaseModel):
    sender: str
    intent: str
    payload: dict
    conversation_id: Optional[str]

Challenges and Solutions

1. HTML Parsing vs. REST APIs

The Online Boutique doesn't expose a traditional REST API. Instead of giving up, we built a robust HTML parser:

async def get_products():
    async with aiohttp.ClientSession() as session:
        # Fetch and parse product listings
        response = await session.get(f"{BOUTIQUE_API_URL}/")
        soup = BeautifulSoup(await response.text(), 'html.parser')

        # Extract product details
        products = []
        for product in soup.find_all('h2'):
            if "You May Also Like" not in product.text:
                # Extract price and description
                price = extract_price(product)
                desc = extract_description(product)
                products.append({
                    "name": product.text.strip(),
                    "price": price,
                    "description": desc
                })

2. Session Management

E-commerce requires maintaining state. We implemented a robust session management system:

async def place_order(order: Dict):
    async with await get_session() as session:
        # Add to cart with session cookie
        cart_response = await session.post(
            f"{BOUTIQUE_API_URL}/cart",
            data={"product_id": order["product_id"]},
            headers={"Content-Type": "application/x-www-form-urlencoded"}
        )

        # Extract and use session cookie
        session_cookie = extract_session_cookie(cart_response)

3. AI Safety and Reliability

Working with AI models requires careful error handling:

async def ask_gemini(prompt: str, retries: int = 3):
    for attempt in range(retries):
        try:
            response = await model.generate_content_async(
                prompt,
                safety_settings={
                    "HARASSMENT": "block_none",
                    "HATE_SPEECH": "block_none",
                    "SEXUALLY_EXPLICIT": "block_none",
                    "DANGEROUS_CONTENT": "block_none"
                }
            )
            return parse_gemini_response(response)
        except Exception as e:
            if attempt == retries - 1:
                raise Exception(f"All {retries} attempts failed")
            continue

Results and Impact

The final system demonstrates:

1. Natural language understanding for e-commerce

2. Seamless integration with existing infrastructure

3. Robust error handling and user feedback

4. Scalable microservices architecture

Key Learnings

1. AI Integration

   • Prompt engineering is crucial

   • Error handling must be robust

   • Safety settings need careful tuning

2. Microservices

   • Service discovery is essential

   • State management requires careful design

   • Protocol design affects scalability

3. User Experience

   • Natural language requires context

   • Feedback must be immediate

   • Error messages should be helpful

Future Directions

1. Enhanced AI Capabilities

   • Product recommendations

   • Price negotiation

   • Multi-language support

2. Technical Improvements

   • Kubernetes auto-scaling

   • Enhanced caching

   • More payment methods

3. User Experience

   • Voice interface

   • Mobile app

   • Analytics dashboard

Conclusion

TransactAI demonstrates how modern cloud infrastructure and AI can transform e-commerce. By combining Google Cloud's robust services with innovative AI agents, we've created a system that makes online shopping more natural and accessible.

The code is open source and available on GitHub. We welcome contributions and feedback from the community!

Resources

• GitHub Repository

• Demo Video

• GKE Turns 10 Hackathon

• Google Online Boutique

• Google Gemini AI