Gemma 4 LLM Integration for E-Commerce Workflows: A Practical Guide

1# Install Ollama (Linux/macOS)
2curl -fsSL https://ollama.com/install.sh | sh
3
4# Verify installation
5ollama --version
6# Expected output: ollama version 0.9.x
7
8# Pull Gemma 4 12B instruction-tuned model
9ollama pull gemma4:12b
10
11# Verify the model is available
12ollama list
13# Expected output:
14# NAME              ID            SIZE     MODIFIED
15# gemma4:12b        a1b2c3d4e5f6  8.1 GB   Just now

1ollama run gemma4:12b "A customer asks: Does this ship to Indonesia? Our policy is we ship to ID, MY, SG, PH, TW, AU. Reply in one sentence."
2
3# Expected output:
4# Yes, we ship to Indonesia — your order will be dispatched to your ID address
5# once payment is confirmed.

1# Dockerfile.gemma4
2FROM ollama/ollama:latest
3
4# Pre-pull the model during build
5RUN ollama serve & sleep 5 && ollama pull gemma4:12b && pkill ollama
6
7EXPOSE 11434
8CMD ["ollama", "serve"]

1docker build -t gemma4-ecommerce -f Dockerfile.gemma4 .
2docker run -d --gpus all -p 11434:11434 --name gemma4 gemma4-ecommerce
3
4# Verify container is running
5curl http://localhost:11434/api/tags
6# Expected: JSON listing gemma4:12b

1# context_service.py
2import requests
3from datetime import datetime
4
5class EcommerceContext:
6    def __init__(self, platform="shopify", base_url="", api_token=""):
7        self.platform = platform
8        self.base_url = base_url.rstrip("/")
9        self.headers = {
10            "X-Shopify-Access-Token": api_token,
11            "Content-Type": "application/json"
12        }
13    
14    def get_order(self, order_id: str) -> dict:
15        """Fetch order details from Shopify Plus Admin API."""
16        resp = requests.get(
17            f"{self.base_url}/admin/api/2025-01/orders/{order_id}.json",
18            headers=self.headers
19        )
20        resp.raise_for_status()
21        order = resp.json()["order"]
22        return {
23            "order_id": order["name"],
24            "status": order["financial_status"],
25            "fulfillment": order.get("fulfillment_status", "unfulfilled"),
26            "total": f"{order['currency']} {order['total_price']}",
27            "items": [li["title"] for li in order["line_items"]],
28            "created": order["created_at"],
29            "shipping_country": order.get("shipping_address", {}).get("country", "N/A")
30        }
31    
32    def get_product_info(self, product_id: str) -> dict:
33        """Fetch product details for recommendation context."""
34        resp = requests.get(
35            f"{self.base_url}/admin/api/2025-01/products/{product_id}.json",
36            headers=self.headers
37        )
38        resp.raise_for_status()
39        product = resp.json()["product"]
40        return {
41            "title": product["title"],
42            "description": product["body_html"][:500],
43            "variants": [{"sku": v["sku"], "price": v["price"], 
44                          "inventory": v["inventory_quantity"]} 
45                         for v in product["variants"]],
46            "tags": product["tags"]
47        }
48
49    def get_shipping_policy(self, country_code: str) -> str:
50        """Return shipping policy snippet for a destination country."""
51        # In production, pull this from a CMS or policy database
52        policies = {
53            "SG": "Free shipping over SGD 80. Delivery 2-4 business days.",
54            "HK": "Free shipping over HKD 500. Same-day delivery available.",
55            "TW": "Flat rate TWD 120. Delivery 3-5 business days.",
56            "AU": "Flat rate AUD 15. Delivery 5-10 business days.",
57            "ID": "Flat rate IDR 75,000. Delivery 7-12 business days. Import duties may apply.",
58        }
59        return policies.get(country_code, "Contact support for shipping to your region.")

1# Test it
2python -c "from context_service import EcommerceContext; print('Context service loaded')"
3# Expected output: Context service loaded

1# support_agent.py
2import requests
3import json
4from context_service import EcommerceContext
5
6OLLAMA_URL = "http://localhost:11434/api/generate"
7MODEL = "gemma4:12b"
8
9def build_system_prompt(store_name: str) -> str:
10    return f"""You are a customer support agent for {store_name}.
11Rules:
12- Answer ONLY based on the provided context. Never invent order details.
13- If you cannot answer from context, say: "Let me connect you with a specialist."
14- Be concise: max 3 sentences per response.
15- Support languages: English, Traditional Chinese, Bahasa Indonesia.
16- Format prices with the correct currency symbol.
17- Never disclose internal system IDs or API details."""
18
19def handle_customer_query(query: str, order_id: str = None, 
20                          country: str = None) -> str:
21    ctx = EcommerceContext(
22        platform="shopify",
23        base_url="https://your-store.myshopify.com",
24        api_token="shpat_xxxxxxxxxxxxx"
25    )
26    
27    context_parts = []
28    
29    if order_id:
30        order_data = ctx.get_order(order_id)
31        context_parts.append(f"Order info: {json.dumps(order_data)}")
32    
33    if country:
34        shipping = ctx.get_shipping_policy(country)
35        context_parts.append(f"Shipping policy: {shipping}")
36    
37    context_block = "\n".join(context_parts)
38    system = build_system_prompt("YourStore")
39    
40    prompt = f"""{system}
41
42--- CONTEXT ---
43{context_block}
44--- END CONTEXT ---
45
46Customer question: {query}
47Your response:"""
48    
49    response = requests.post(OLLAMA_URL, json={
50        "model": MODEL,
51        "prompt": prompt,
52        "stream": False,
53        "options": {
54            "temperature": 0.3,
55            "num_predict": 256
56        }
57    })
58    
59    return response.json()["response"]
60
61# Test
62if __name__ == "__main__":
63    answer = handle_customer_query(
64        query="Where is my order?",
65        order_id="5123456789",
66        country="SG"
67    )
68    print(answer)
69    # Expected output: A concise status update based on actual order data

1python support_agent.py
2# Expected: "Your order #1042 is currently unfulfilled and being prepared for
3# shipment. Delivery to Singapore typically takes 2-4 business days once shipped.
4# You'll receive a tracking number by email."

1// webhook-receiver.js
2const express = require('express');
3const crypto = require('crypto');
4const axios = require('axios');
5
6const app = express();
7const SHOPIFY_WEBHOOK_SECRET = process.env.SHOPIFY_WEBHOOK_SECRET;
8const OLLAMA_URL = 'http://localhost:11434/api/generate';
9
10app.use('/webhooks', express.raw({ type: 'application/json' }));
11
12function verifyWebhook(req) {
13  const hmac = crypto.createHmac('sha256', SHOPIFY_WEBHOOK_SECRET)
14    .update(req.body)
15    .digest('base64');
16  return hmac === req.headers['x-shopify-hmac-sha256'];
17}
18
19async function generateStatusMessage(orderData) {
20  const prompt = `You are an e-commerce notification writer.
21Generate a friendly, 2-sentence order status update for this customer.
22Order: ${orderData.name}
23Status: ${orderData.fulfillment_status || 'processing'}
24Items: ${orderData.line_items.map(li => li.title).join(', ')}
25Destination: ${orderData.shipping_address?.country || 'N/A'}
26Language: Match the customer's locale (${orderData.customer_locale || 'en'})
27
28Status message:`;
29
30  const resp = await axios.post(OLLAMA_URL, {
31    model: 'gemma4:12b',
32    prompt,
33    stream: false,
34    options: { temperature: 0.4, num_predict: 128 }
35  });
36
37  return resp.data.response;
38}
39
40app.post('/webhooks/orders/updated', async (req, res) => {
41  if (!verifyWebhook(req)) {
42    return res.status(401).send('Unauthorized');
43  }
44
45  const order = JSON.parse(req.body);
46  console.log(`Order ${order.name} updated: ${order.fulfillment_status}`);
47
48  const message = await generateStatusMessage(order);
49  console.log('Generated message:', message);
50
51  // Forward to your notification service (email, WhatsApp, LINE, etc.)
52  // await sendNotification(order.customer.email, message);
53
54  res.status(200).send('OK');
55});
56
57app.listen(3000, () => console.log('Webhook receiver on port 3000'));

1node webhook-receiver.js
2# Expected output: Webhook receiver on port 3000
3
4# Test with curl
5curl -X POST http://localhost:3000/webhooks/orders/updated \
6  -H "Content-Type: application/json" \
7  -H "X-Shopify-Hmac-Sha256: test" \
8  -d '{"name":"#1042","fulfillment_status":"shipped","line_items":[{"title":"Jade Bangle"}],"shipping_address":{"country":"Singapore"},"customer_locale":"en"}'
9# Expected: 200 OK with generated status message in console

1# recommendation_enricher.py
2import requests
3import json
4
5OLLAMA_URL = "http://localhost:11434/api/generate"
6
7def enrich_recommendation(viewed_product: dict, 
8                          recommended_products: list[dict],
9                          customer_locale: str = "en") -> list[dict]:
10    """
11    Takes a viewed product and a list of algorithmically recommended products,
12    returns the same list with LLM-generated 'reason' fields.
13    """
14    prompt = f"""You are a product recommendation copywriter for a premium
15e-commerce store serving customers in Asia-Pacific.
16
17The customer is viewing:
18{json.dumps(viewed_product, indent=2)}
19
20We recommend these products (from our recommendation engine):
21{json.dumps(recommended_products, indent=2)}
22
23For each recommended product, write ONE sentence (max 20 words) explaining 
24why it pairs well with the viewed product. Be specific to the product 
25attributes, not generic.
26
27Language: {customer_locale}
28
29Return ONLY valid JSON array with objects having 'product_id' and 'reason' keys."""
30
31    resp = requests.post(OLLAMA_URL, json={
32        "model": "gemma4:12b",
33        "prompt": prompt,
34        "stream": False,
35        "options": {"temperature": 0.6, "num_predict": 512}
36    })
37    
38    raw = resp.json()["response"]
39    # Parse the JSON from model output
40    try:
41        reasons = json.loads(raw)
42        for rec in recommended_products:
43            match = next((r for r in reasons 
44                         if str(r["product_id"]) == str(rec["product_id"])), None)
45            if match:
46                rec["reason"] = match["reason"]
47    except json.JSONDecodeError:
48        # Fallback: don't enrich rather than show broken text
49        pass
50    
51    return recommended_products
52
53# Test
54if __name__ == "__main__":
55    viewed = {"product_id": "101", "title": "18K Gold Chain Necklace", 
56              "tags": "gold, necklace, formal"}
57    recs = [
58        {"product_id": "205", "title": "Pearl Drop Earrings", 
59         "tags": "pearl, earrings, formal"},
60        {"product_id": "310", "title": "Gold Bracelet Set", 
61         "tags": "gold, bracelet, everyday"}
62    ]
63    enriched = enrich_recommendation(viewed, recs, "en")
64    for r in enriched:
65        print(f"{r['title']}: {r.get('reason', 'No reason generated')}")

1python recommendation_enricher.py
2# Expected output:
3# Pearl Drop Earrings: The pearl tones complement your gold chain for a refined formal look.
4# Gold Bracelet Set: Matches your 18K gold necklace for a coordinated everyday-to-evening set.

1# monitoring.py
2import time
3import json
4import logging
5from functools import wraps
6
7logging.basicConfig(
8    filename='gemma4_ecommerce.log',
9    level=logging.INFO,
10    format='%(asctime)s | %(message)s'
11)
12
13def monitor_llm_call(workflow_name: str):
14    def decorator(func):
15        @wraps(func)
16        def wrapper(*args, **kwargs):
17            start = time.time()
18            try:
19                result = func(*args, **kwargs)
20                latency = time.time() - start
21                logging.info(json.dumps({
22                    "workflow": workflow_name,
23                    "latency_ms": round(latency * 1000),
24                    "status": "success",
25                    "response_length": len(result) if isinstance(result, str) else 0
26                }))
27                return result
28            except Exception as e:
29                latency = time.time() - start
30                logging.error(json.dumps({
31                    "workflow": workflow_name,
32                    "latency_ms": round(latency * 1000),
33                    "status": "error",
34                    "error": str(e)
35                }))
36                raise
37        return wrapper
38    return decorator
39
40# Usage: decorate your handler
41# @monitor_llm_call("customer_support")
42# def handle_customer_query(query, order_id=None, country=None): ...

1# After running monitored calls, check the log
2tail -5 gemma4_ecommerce.log
3# Expected output:
4# 2025-07-11 14:32:01 | {"workflow": "customer_support", "latency_ms": 1842, "status": "success", "response_length": 187}

1# context_adobe.py
2import requests
3
4class AdobeCommerceContext:
5    def __init__(self, base_url: str, bearer_token: str):
6        self.base_url = base_url.rstrip("/")
7        self.headers = {
8            "Authorization": f"Bearer {bearer_token}",
9            "Content-Type": "application/json"
10        }
11    
12    def get_order(self, increment_id: str) -> dict:
13        resp = requests.get(
14            f"{self.base_url}/rest/V1/orders",
15            headers=self.headers,
16            params={"searchCriteria[filter_groups][0][filters][0][field]": "increment_id",
17                    "searchCriteria[filter_groups][0][filters][0][value]": increment_id}
18        )
19        resp.raise_for_status()
20        order = resp.json()["items"][0]
21        return {
22            "order_id": order["increment_id"],
23            "status": order["status"],
24            "total": f"{order['order_currency_code']} {order['grand_total']}",
25            "items": [item["name"] for item in order["items"]],
26            "created": order["created_at"]
27        }

1# context_shopline.py
2import requests
3
4class SHOPLINEContext:
5    def __init__(self, base_url: str, api_token: str):
6        self.base_url = base_url.rstrip("/")
7        self.headers = {
8            "Authorization": f"Bearer {api_token}",
9            "Content-Type": "application/json"
10        }
11    
12    def get_order(self, order_id: str) -> dict:
13        resp = requests.get(
14            f"{self.base_url}/v1/orders/{order_id}",
15            headers=self.headers
16        )
17        resp.raise_for_status()
18        order = resp.json()
19        return {
20            "order_id": order["order_number"],
21            "status": order["order_status"],
22            "total": f"{order['currency']} {order['total_price']}",
23            "items": [item["product_name"] for item in order["order_items"]],
24            "created": order["created_at"]
25        }