Practical AI and eCommerce insights — recommendation engines, LLMs, EU AI Act compliance, and retail AI strategy for Irish businesses.
LLM Implementation | eCommerce AI | Ireland
Meta Description: LLM applications in eCommerce explained practically by Michael English (IMPT.io CTO). From product descriptions to chatbots, search, and customer service — real implementations for Irish businesses.
Target Keywords: LLM eCommerce Ireland, large language models retail Ireland, ChatGPT eCommerce applications, GPT-4 retail Ireland, Claude eCommerce applications, Michael English LLM eCommerce
The debate about whether large language models (LLMs) have a role in eCommerce is over. ChatGPT's emergence in November 2022 and the subsequent release of GPT-4, Claude 3 Opus, and Gemini 1.5 Pro have transformed what small teams can build. An Irish eCommerce company with two engineers can now deploy AI capabilities that would have required a 20-person ML team three years ago.
The question is no longer "should we use LLMs?" but "which LLM applications deliver the best return for our specific business?" This article provides a practical, implementation-focused guide.
Claude 3.5 Sonnet / Claude 4 (Anthropic):
GPT-4o (OpenAI):
Gemini 1.5 Pro (Google):
Open-source models (Llama 3, Mistral, Qwen):
The #1 LLM application for Irish eCommerce — product descriptions — is also the simplest to implement.
An Irish fashion retailer managing 50,000 SKUs:
import anthropic
import json
import time
from typing import Optional
client = anthropic.Anthropic()
def generate_product_description(
product_data: dict,
brand_voice: str,
target_market: str = "Irish adult consumers",
seo_keywords: list = None
) -> dict:
"""
Generate SEO-optimised product description with quality scoring.
Args:
product_data: Dict with name, category, specs, materials, etc.
brand_voice: Tone guidance (e.g., "premium outdoor lifestyle brand")
target_market: Target customer description
seo_keywords: Keywords to incorporate naturally
Returns:
Dict with description, seo_title, meta_description, quality_score
"""
keywords_section = ""
if seo_keywords:
keywords_section = f"\nNaturally incorporate these SEO keywords (don't force them): {', '.join(seo_keywords)}"
prompt = f"""You are an expert eCommerce copywriter for a {brand_voice} targeting {target_market}.
Write the following components for this product:
Product information:
{json.dumps(product_data, indent=2)}
{keywords_section}
Generate:
1. PRODUCT_DESCRIPTION: 120-160 words, benefit-led, specific details, no buzzwords. Conversational but professional. End with a natural call to action.
2. SEO_TITLE: 50-60 chars, include primary keyword, brand name if space allows.
3. META_DESCRIPTION: 145-155 chars, benefit-focused, includes primary keyword.
Format your response as JSON with keys: product_description, seo_title, meta_description"""
message = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=800,
messages=[{"role": "user", "content": prompt}]
)
try:
result = json.loads(message.content[0].text)
result['quality_score'] = score_description(result['product_description'])
return result
except json.JSONDecodeError:
# Handle non-JSON response
return {"raw_response": message.content[0].text}
def score_description(description: str) -> float:
"""Simple quality scoring for generated descriptions."""
score = 1.0
# Penalise generic superlatives
bad_phrases = ['amazing', 'incredible', 'fantastic', 'revolutionary', 'game-changing']
for phrase in bad_phrases:
if phrase.lower() in description.lower():
score -= 0.1
# Reward specific details (numbers, materials, measurements)
import re
if re.search(r'\d+', description): # Contains numbers
score += 0.1
if len(description.split()) >= 100: # Adequate length
score += 0.1
return min(1.0, max(0.0, score))
import asyncio
import aiohttp
from typing import List
async def process_catalogue_batch(products: List[dict], batch_size: int = 20):
"""Process product catalogue in parallel batches."""
results = []
for i in range(0, len(products), batch_size):
batch = products[i:i+batch_size]
# Process batch concurrently (respect API rate limits)
tasks = [generate_product_description_async(p) for p in batch]
batch_results = await asyncio.gather(*tasks, return_exceptions=True)
results.extend(batch_results)
# Rate limiting: 1 second between batches
await asyncio.sleep(1)
print(f"Processed {min(i+batch_size, len(products))}/{len(products)} products")
return results
Customer service is a major cost centre for Irish eCommerce, with average handling times of 8-15 minutes for complex queries and agent costs of €25-35/hour.
The most effective approach is not full automation but intelligent triage:
Customer message
→ LLM Classification (intent + urgency + sentiment)
→ High confidence, standard query → LLM responds (with human review option)
→ Complex/sensitive/unhappy customer → Route to human agent with AI-generated context
→ Fraud indicators → Escalate to fraud team
def classify_customer_query(message: str, order_context: dict = None) -> dict:
"""Classify customer query intent and suggested action."""
context = ""
if order_context:
context = f"\nOrder context: {json.dumps(order_context)}"
response = client.messages.create(
model="claude-haiku-4-5", # Fast, cheap model for classification
max_tokens=200,
messages=[{
"role": "user",
"content": f"""Classify this customer service message:
Message: "{message}"
{context}
Return JSON with:
- intent: one of [order_status, return_request, product_query, complaint, payment_issue, other]
- urgency: [high, medium, low]
- sentiment: [positive, neutral, negative, very_negative]
- can_auto_respond: boolean (true only if standard policy response is sufficient)
- suggested_action: brief note on how to respond"""
}]
)
return json.loads(response.content[0].text)
def generate_customer_response(
query: str,
intent: str,
order_data: dict,
policy_context: str
) -> str:
"""Generate customer-ready response for standard queries."""
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=500,
messages=[{
"role": "user",
"content": f"""You are a helpful customer service agent for an Irish eCommerce retailer.
Customer query: {query}
Query intent: {intent}
Order details: {json.dumps(order_data)}
Relevant policies:
{policy_context}
Write a helpful, warm, professional response that:
- Directly addresses their query
- Gives specific information from their order where relevant
- Uses a friendly but professional Irish tone (not American-corporate)
- Is 80-120 words
- Does not use phrases like "I hope this message finds you well"
- Ends with an offer to help further
Response:"""
}]
)
return response.content[0].text
Cost comparison:
Traditional keyword search fails when customers use natural language ("warm jacket for wet weather") instead of product terminology ("waterproof insulated jacket").
from openai import OpenAI
import numpy as np
import json
openai_client = OpenAI()
def create_product_embeddings(products: list) -> list:
"""Create semantic embeddings for all products."""
# Create rich text representation for each product
product_texts = []
for p in products:
text = f"{p['name']}. {p['description']}. Category: {p['category']}. "
text += f"Material: {p.get('material', '')}. "
text += f"Use case: {p.get('use_case', '')}. "
text += f"Colour: {p.get('colour', '')}."
product_texts.append(text)
# Batch embed (OpenAI text-embedding-3-small, €0.02/1M tokens)
response = openai_client.embeddings.create(
model="text-embedding-3-small",
input=product_texts
)
return [r.embedding for r in response.data]
def semantic_search(
query: str,
product_embeddings: np.ndarray,
products: list,
top_k: int = 10
) -> list:
"""Search products using semantic similarity."""
# Embed the search query
query_response = openai_client.embeddings.create(
model="text-embedding-3-small",
input=[query]
)
query_embedding = np.array(query_response.data[0].embedding)
# Cosine similarity
similarities = np.dot(product_embeddings, query_embedding) / (
np.linalg.norm(product_embeddings, axis=1) * np.linalg.norm(query_embedding)
)
# Get top-K indices
top_indices = np.argsort(similarities)[::-1][:top_k]
return [
{**products[i], 'relevance_score': float(similarities[i])}
for i in top_indices
]
Real-world impact: Algolia reports that retailers switching from keyword to neural/semantic search see:
Instead of relying on customers to read full product descriptions and specifications, LLMs can answer specific product questions in real-time:
def answer_product_question(
question: str,
product_data: dict,
reviews: list = None
) -> str:
"""Answer a specific customer question about a product."""
review_summary = ""
if reviews and len(reviews) > 0:
review_texts = "\n".join(reviews[:10])
review_summary = f"\nRelevant customer reviews:\n{review_texts}"
response = client.messages.create(
model="claude-haiku-4-5",
max_tokens=300,
messages=[{
"role": "user",
"content": f"""Answer this customer question about a product.
Be specific, helpful, and honest. If you don't know, say so.
Product: {json.dumps(product_data)}
{review_summary}
Customer question: {question}
Answer in 50-100 words:"""
}]
)
return response.content[0].text
Beyond customer-facing applications, LLMs can dramatically accelerate merchandising decisions:
def analyse_category_trends(
category: str,
reviews: list,
search_queries: list,
period: str = "last 90 days"
) -> dict:
"""Analyse category trends from reviews and search data."""
top_queries = "\n".join(search_queries[:50])
recent_reviews = "\n".join(reviews[:100])
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1000,
messages=[{
"role": "user",
"content": f"""Analyse these signals from our {category} category ({period}):
TOP SEARCH QUERIES:
{top_queries}
RECENT REVIEWS:
{recent_reviews}
Identify:
1. Emerging demand signals (what are customers looking for that we may not have?)
2. Quality/fit issues flagged in reviews
3. Gap in product range (queries with no or poor results)
4. Price sensitivity signals
5. Recommended buying priorities for next season
Format as JSON with keys: emerging_demands, quality_issues, range_gaps, pricing_signals, buying_recommendations"""
}]
)
return json.loads(response.content[0].text)
Irish retailers deploying LLMs must comply with the EU AI Act (enforcement from 2025):
| Application | Monthly API Cost | Engineering (one-time) | Ongoing Maintenance |
|---|---|---|---|
| Product descriptions (50K SKUs) | €500-€1,000 (one-time batch) | €5K-€15K | €500-€1K/quarter |
| Search enhancement (semantic) | €200-€800/month | €10K-€25K | €1K-€2K/month |
| Customer service (1K tickets/day) | €300-€1,500/month | €20K-€50K | €2K-€5K/month |
| Chatbot + Q&A | €200-€1,000/month | €15K-€40K | €1K-€3K/month |
| Merchandising intelligence | €100-€300/month | €10K-€20K | €500-€1K/month |
LLMs are not a distant future technology for Irish eCommerce — they're available today through simple APIs, with reasonable costs, production-ready implementations, and measurable returns. The question isn't whether to deploy them but how fast and in what priority order.
Start with product descriptions (highest immediate ROI, lowest risk) and customer service classification (significant cost reduction, quick implementation). Build from there as your team learns what works in your specific catalogue and customer context.
The retailers who integrate LLMs into their operations in 2024-2025 will have both the technical capability and, critically, the institutional knowledge from operating these systems — a compounding advantage over those who wait.
Michael English is Co-Founder & CTO of IMPT.io. He writes on AI implementation for Irish and EU businesses. Based in Clonmel, Co. Tipperary, Ireland.
Keywords: LLM eCommerce Ireland, large language models retail applications, ChatGPT eCommerce Irish businesses, GPT-4 retail Ireland practical guide, AI customer service Ireland, product descriptions AI Ireland, Michael English LLM eCommerce