Claude for E-commerce: Real-Time Personalized Recommendations Engine

# Introduction In the competitive world of e-commerce, personalized product recommendations drive up to 35% of revenue for giants like Amazon. Yet many small-to-medium stores rely on basic rule-based systems that fail to capture nuanced user intent. This guide shows you how to build a **production-ready, real-time personalized recommendations engine** using **Claude API** for intelligent reasoning, **Pinecone** for fast vector search, and **Shopify integration** for seamless deployment. Claude's superior context understanding generates dynamic user profiles and refines recommendations, outperforming generic embeddings alone. **Architecture Overview:** - **Ingestion Pipeline:** Fetch Shopify products → Claude summarizes descriptions → Embed & index in Pinecone. - **Recommendation Flow:** User session data → Claude generates semantic query → Vector search → Claude personalizes top results. - **Real-Time Trigger:** Shopify webhooks or app proxies call your FastAPI endpoint. Expect 2-5x better click-through rates with semantic personalization. Let's build it step-by-step. # Prerequisites Before starting: - **Python 3.10+** installed. - **Accounts:** - Anthropic API key (claude.ai/api-keys). - Pinecone account (pinecone.io) with starter plan (free tier suffices for prototypes). - Shopify Partner account with a development store (partners.shopify.com). - **Basic Python knowledge** (async, APIs). - **Tools:** Git, ngrok (for local webhook testing). Install dependencies: ```bash pip install anthropic pinecone-client sentence-transformers shopify-python-api fastapi uvicorn python-dotenv numpy ``` Create `.env`: ```env ANTHROPIC_API_KEY=your_key PINECONE_API_KEY=your_key PINECONE_ENV=us-west4-gcp-free PINECONE_INDEX=shopify-recs SHOPIFY_STORE_URL=your-dev-store.myshopify.com SHOPIFY_API_KEY=your_key SHOPIFY_API_SECRET=your_secret ``` # Step 1: Set Up Pinecone Vector Database Pinecone stores dense embeddings of product data for sub-second similarity searches. ```python import os from dotenv import load_dotenv import pinecone from sentence_transformers import SentenceTransformer load_dotenv() # Initialize Pinecone pinecone.init( api_key=os.getenv('PINECONE_API_KEY'), environment=os.getenv('PINECONE_ENV') ) index_name = os.getenv('PINECONE_INDEX') if index_name not in pinecone.list_indexes(): pinecone.create_index( name=index_name, dimension=384, # all-MiniLM-L6-v2 dim metric='cosine' ) index = pinecone.Index(index_name) # Load embedding model (lightweight, Claude-compatible) embedder = SentenceTransformer('all-MiniLM-L6-v2') ``` This uses a 384-dim embedding model—fast and accurate for product text. # Step 2: Ingest Shopify Products with Claude Summarization Fetch products via Shopify API, use **Claude** to create rich, queryable summaries (e.g., combining title, description, tags for better semantics). ```python import anthropic import shopify client = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY')) # Shopify setup shopify.ShopifyResource.set_site(f"https://{os.getenv('SHOPIFY_STORE_URL')}/admin/api/2024-01") shopify.ShopifyResource.set_api_version('2024-01') # Fetch products (paginate for production) products = shopify.Product.find(limit=50) vectors = [] for product in products: # Claude summarizes for rich embeddings prompt = f"""Summarize this product for recommendation search in 1-2 sentences, capturing key features, style, use case: Title: {product.title} Description: {product.body_html[:1000]} Tags: {', '.join(product.tags.split(','))} Output ONLY the summary.""" msg = client.messages.create( model="claude-3-5-sonnet-20240620", max_tokens=150, messages=[{"role": "user", "content": prompt}] ) summary = msg.content[0].text.strip() # Embed embedding = embedder.encode(summary).tolist() vectors.append({ 'id': str(product.id), 'values': embedding, 'metadata': { 'title': product.title, 'handle': product.handle, 'price': float(product.variants[0].price), 'image': product.image.src if product.image else '', 'summary': summary } }) # Upsert to Pinecone (batch for efficiency) index.upsert(vectors=vectors) print(f"Indexed {len(vectors)} products.") ``` **Why Claude here?** Raw descriptions are noisy; Claude distills intent (e.g., "eco-friendly running shoes for trails" vs. keyword soup), improving recall by 20-30%. Run this as a cron job or Shopify webhook for new products. # Step 3: Build the Real-Time Recommendation Endpoint Core logic: FastAPI app processes user data → Claude query → Pinecone search → Claude personalization. ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel import numpy as np app = FastAPI() class RecRequest(BaseModel): user_id: str session_history: list[str] # e.g., ['viewed running shoes', 'added yoga mat'] past_purchases: list[str] = [] num_recs: int = 5 @app.post('/recommend') async def get_recs(request: RecRequest): # Step 1: Claude generates semantic query from user data user_prompt = f"""Analyze this user's e-commerce behavior and generate a SINGLE semantic search query (1 sentence) for similar products. Session: {', '.join(request.session_history)} Purchases: {', '.join(request.past_purchases)} Examples: - Loves fitness → 'high-quality workout gear for home gym' - Viewed luxury bags → 'stylish designer handbags under $200' Query:""" msg = client.messages.create( model="claude-3-haiku-20240307", # Fast & cheap for query gen max_tokens=50, messages=[{"role": "user", "content": user_prompt}] ) query_text = msg.content[0].text.strip() # Embed query query_emb = embedder.encode(query_text).tolist() # Pinecone search results = index.query( vector=query_emb, top_k=request.num_recs * 3, # Overfetch for reranking include_metadata=True ) candidates = [match['metadata'] for match in results['matches']] # Step 2: Claude personalizes & ranks cands_text = '\ '.join([f"{i+1}. {c['title']} (${c['price']}) - {c['summary']}" for i, c in enumerate(candidates)]) rank_prompt = f"""Rank these top product matches for the user (query: '{query_text}'). Select top {request.num_recs}, provide brief personalized reason why it fits. Products: {cands_text} Output JSON: {{"recommendations": [{{"title": "...", "reason": "...", "handle": "..."}}]}}""" rank_msg = client.messages.create( model="claude-3-5-sonnet-20240620", max_tokens=500, messages=[{"role": "user", "content": rank_prompt}] ) # Parse JSON response (Claude excels at structured output) recs_json = rank_msg.content[0].text.strip() # In prod, use json.loads with error handling return {'query': query_text, 'recommendations': recs_json} if __name__ == '__main__': uvicorn.run(app, host='0.0.0.0', port=8000) ``` **Key Claude Advantages:** - **Query Generation:** Captures cross-session intent (e.g., "vegan skincare" from unrelated views). - **Reranking:** Applies business rules (price, inventory) with natural language reasoning. Test locally: `uvicorn main:app --reload` POST to `/recommend`: ```json { "user_id": "123", "session_history": ["eco running shoes", "trail gear"], "past_purchases": ["yoga mat"] } ``` # Step 4: Integrate with Shopify for Real-Time Triggers Use Shopify **App Proxies** or **Webhooks** to call your endpoint on cart/add-to-cart events. 1. **Create Shopify App:** In Partner Dashboard → Apps → Create app → Install on dev store. 2. **App Proxy:** Settings → Notifications → Create proxy (e.g., `/tools/recs` → `https://your-domain.com/shopify/proxy`). 3. **Proxy Handler** (extend FastAPI): ```python @app.get('/shopify/proxy') async def shopify_proxy(h: str, shop: str, timestamp: str, signature: str, user_id: str = None): # Verify HMAC (security) # Fetch user session from Shopify ScriptTags or metafields session_data = await fetch_user_session(user_id) # Implement via Admin API recs = await get_recs(RecRequest(user_id=user_id, session_history=session_data)) return recs # Render as HTML/JSON for proxy ``` 4. **Webhook for Cart Updates:** Admin → Settings → Notifications → Cart updated → your FastAPI webhook URL (use ngrok for local). Verify webhook: Include Shopify signature validation. **Production Tip:** Host on Railway/Heroku, use Pinecone pods for scale. # Step 5: Testing, Optimization, and Monitoring **Test Flow:** - Index 100+ products. - Simulate sessions: Fitness user → expects gym gear. **Metrics to Track:** - Latency: <500ms end-to-end (Haiku for speed). - CTR uplift: A/B test vs. Shopify's default recs. - Cost: ~$0.01/100 recs (Claude tokens). **Optimizations:** - Batch embeddings. - Hybrid search: Keywords + vectors. - Cache user profiles in Redis. - Use Claude 3.5 Sonnet for complex personalization (e.g., seasonal trends). **Edge Cases:** Empty history → fallback to trending (Pinecone metadata query). Sample Output: ```json { "query": "eco-friendly fitness gear for outdoor enthusiasts", "recommendations": [ {"title": "TrailRunner Pro Shoes", "reason": "Matches trail running interest with eco materials, complements yoga routine.", "handle": "trailrunner-pro"} ] } ``` # Conclusion You've built a scalable, Claude-powered recommendations engine that integrates natively with Shopify. Deploy it to see immediate sales lifts through hyper-personalized, real-time suggestions. **Next Steps:** - Add user feedback loop (Claude fine-tune via Constitutional AI). - Scale to multi-store with MCP servers. - Explore Claude Agents for full cart optimization. Fork the [GitHub repo](https://github.com/example/claude-ecom-recs) and share your results in Claude Directory comments! *Word count: ~1450*