""" Persona bank for the IfixKart customer swarm. The local LLM is used offline to create a diverse bank of shopper personas. Each of the 10k agents then gets a persona sampled (with jitter) from that bank, so the LLM is never in the per-request hot path. """ from __future__ import annotations import json import random import re from dataclasses import asdict, dataclass, field from typing import Any import httpx DEFAULT_OLLAMA = "http://127.0.0.1:11434" DEFAULT_MODEL = "qwen3.5:4b" CATEGORY_KEYWORDS = [ "display", "touch screen", "battery", "back panel", "screen guard", "charger", "camera", "speaker", "motorola", "samsung", "redmi", "realme", "vivo", "oppo", "iphone", ] INDIAN_CITIES = [ ("Bengaluru", "Karnataka", "560001"), ("Mysuru", "Karnataka", "570001"), ("Hyderabad", "Telangana", "500001"), ("Chennai", "Tamil Nadu", "600001"), ("Coimbatore", "Tamil Nadu", "641001"), ("Mumbai", "Maharashtra", "400001"), ("Pune", "Maharashtra", "411001"), ("Delhi", "Delhi", "110001"), ("Noida", "Uttar Pradesh", "201301"), ("Jaipur", "Rajasthan", "302001"), ("Ahmedabad", "Gujarat", "380001"), ("Kochi", "Kerala", "682001"), ("Kolkata", "West Bengal", "700001"), ("Visakhapatnam", "Andhra Pradesh", "530001"), ("Indore", "Madhya Pradesh", "452001"), ("Chandigarh", "Chandigarh", "160001"), ] @dataclass class Persona: persona_id: str name: str age: int city: str state: str pincode: str budget_max: float browse_depth: int conversion_prob: float cart_abandon_prob: float payment_fail_prob: float preferred_keywords: list[str] = field(default_factory=list) quantity_pref: int = 1 device: str = "mobile" notes: str = "" def to_dict(self) -> dict[str, Any]: return asdict(self) @classmethod def from_dict(cls, data: dict[str, Any]) -> "Persona": def num(key: str, default: float) -> float: # Use an explicit None check: a legitimate 0.0 must not fall back # to the default (e.g. zero cart-abandonment for verification runs). value = data.get(key) return default if value is None else float(value) return cls( persona_id=str(data.get("persona_id") or "p"), name=str(data.get("name") or "Shopper"), age=int(num("age", 30)), city=str(data.get("city") or "Bengaluru"), state=str(data.get("state") or "Karnataka"), pincode=str(data.get("pincode") or "560001"), budget_max=num("budget_max", 15000), browse_depth=max(1, min(8, int(num("browse_depth", 3)))), conversion_prob=max(0.005, min(0.6, num("conversion_prob", 0.06))), cart_abandon_prob=max(0.0, min(0.95, num("cart_abandon_prob", 0.55))), payment_fail_prob=max(0.0, min(0.5, num("payment_fail_prob", 0.05))), preferred_keywords=[ str(k).lower() for k in (data.get("preferred_keywords") or []) if str(k).strip() ][:5], quantity_pref=max(1, min(3, int(num("quantity_pref", 1)))), device=str(data.get("device") or "mobile"), notes=str(data.get("notes") or "")[:400], ) def _extract_json(text: str) -> Any: text = text.strip() text = re.sub(r"^```(?:json)?\s*", "", text) text = re.sub(r"\s*```$", "", text) start = text.find("[") end = text.rfind("]") if start >= 0 and end > start: candidate = text[start:end + 1] try: return json.loads(candidate) except json.JSONDecodeError: # Small local models emit slightly malformed JSON; salvage objects # one by one and keep whatever parses cleanly. objects = [] for m in re.finditer(r"\{", candidate): depth = 0 in_str = False esc = False for idx in range(m.start(), len(candidate)): ch = candidate[idx] if in_str: if esc: esc = False elif ch == "\\": esc = True elif ch == '"': in_str = False continue if ch == '"': in_str = True elif ch == "{": depth += 1 elif ch == "}": depth -= 1 if depth == 0: try: objects.append(json.loads(candidate[m.start():idx + 1])) except json.JSONDecodeError: pass break if objects: return objects start = text.find("{") end = text.rfind("}") if start >= 0 and end > start: return json.loads(text[start:end + 1]) raise ValueError("no JSON found") def llm_personas( count: int = 30, model: str = DEFAULT_MODEL, ollama_url: str = DEFAULT_OLLAMA, timeout: int = 180, seed: int = 42, ) -> list[Persona]: """Ask the local Ollama model for a diverse bank of shopper personas.""" prompt = f"""You are generating synthetic but realistic Indian e-commerce shoppers for a mobile-parts store (displays, batteries, back panels, screen guards). Return ONLY a JSON array of {count} objects. No markdown, no commentary. Each object must have exactly these fields: persona_id (string p01...), name (Indian name), age (18-55), city, state, pincode (valid 6 digits), budget_max (number between 1500 and 30000), browse_depth (1-6), conversion_prob (0.01-0.20), cart_abandon_prob (0.35-0.85), payment_fail_prob (0.01-0.15), preferred_keywords (array of 1-3 from: display, touch screen, battery, back panel, screen guard, motorola, samsung, redmi, realme, vivo, oppo, iphone), quantity_pref (1-2), device (mobile/tablet/laptop), notes (short sentence about their shopping style). Make the personas diverse in age, city, budget, patience, device type and intent. Vary conversion_prob realistically (low for browsers, higher for repair-shop owners).""" payload = { "model": model, "prompt": prompt, "stream": False, "options": {"temperature": 0.9, "num_predict": 4096, "seed": seed}, } with httpx.Client(timeout=timeout) as client: r = client.post(f"{ollama_url.rstrip('/')}/api/generate", json=payload) r.raise_for_status() body = r.json() raw = body.get("response", "") data = _extract_json(raw) if isinstance(data, dict): data = data.get("personas") or [data] personas = [Persona.from_dict(item) for item in data if isinstance(item, dict)] if not personas: raise ValueError("LLM returned no personas") return personas[:count] def fallback_personas(seed: int = 42) -> list[Persona]: """Deterministic diverse bank used when Ollama is unavailable.""" rng = random.Random(seed) templates = [ ("repair-shop owner", 0.18, 0.35, ["display", "touch screen", "battery"], 2, 26000), ("budget student", 0.05, 0.70, ["battery", "screen guard"], 1, 4500), ("working professional", 0.08, 0.55, ["display", "back panel"], 1, 18000), ("small reseller", 0.22, 0.30, ["display", "battery", "motorola"], 2, 30000), ("careful comparer", 0.04, 0.78, ["screen guard", "battery"], 1, 9000), ("urgent repair", 0.25, 0.20, ["display", "touch screen"], 1, 15000), ("gift buyer", 0.06, 0.65, ["screen guard", "back panel"], 1, 7000), ("loyal Samsung user", 0.10, 0.50, ["samsung", "display"], 1, 22000), ("Xiaomi enthusiast", 0.09, 0.52, ["redmi", "battery"], 1, 12000), ("tablet owner", 0.07, 0.60, ["display", "touch screen"], 1, 20000), ("laptop gamer", 0.05, 0.72, ["battery", "screen guard"], 1, 10000), ("impulse buyer", 0.16, 0.40, ["screen guard", "back panel"], 2, 6000), ] out: list[Persona] = [] for i in range(40): label, conv, abandon, keys, qty, budget = templates[i % len(templates)] city, state, pin = rng.choice(INDIAN_CITIES) out.append( Persona( persona_id=f"p{i + 1:03d}", name=f"Shopper {i + 1}", age=rng.randint(18, 55), city=city, state=state, pincode=pin, budget_max=round(budget * rng.uniform(0.75, 1.2), 2), browse_depth=rng.randint(1, 6), conversion_prob=max(0.01, conv * rng.uniform(0.7, 1.35)), cart_abandon_prob=min(0.9, abandon * rng.uniform(0.85, 1.15)), payment_fail_prob=rng.uniform(0.01, 0.10), preferred_keywords=keys, quantity_pref=qty, device=rng.choice(["mobile", "mobile", "mobile", "tablet", "laptop"]), notes=label, ) ) return out def build_personas( count: int, *, model: str | None = DEFAULT_MODEL, ollama_url: str = DEFAULT_OLLAMA, seed: int = 42, ) -> list[Persona]: """Create a base bank, using the local LLM when possible and falling back.""" if model: try: base = llm_personas(count=count, model=model, ollama_url=ollama_url, seed=seed) print(f"[personas] generated {len(base)} personas with {model}") return base except Exception as exc: print(f"[personas] LLM unavailable ({exc}); using deterministic bank") return fallback_personas(seed=seed) def persona_for_agent(base: list[Persona], index: int, rng: random.Random) -> Persona: """Sample one base persona and jitter it so 10k agents are not clones.""" p = rng.choice(base) city, state, pin = rng.choice(INDIAN_CITIES) return Persona( persona_id=f"{p.persona_id}-{index:06d}", name=p.name, age=max(18, min(60, p.age + rng.randint(-4, 4))), city=city, state=state, pincode=pin, budget_max=round(p.budget_max * rng.uniform(0.85, 1.15), 2), browse_depth=max(1, min(7, p.browse_depth + rng.choice([-1, 0, 0, 1]))), conversion_prob=max(0.005, min(0.5, p.conversion_prob * rng.uniform(0.7, 1.4))), cart_abandon_prob=max(0.0, min(0.95, p.cart_abandon_prob * rng.uniform(0.85, 1.15))), payment_fail_prob=max(0.0, min(0.4, p.payment_fail_prob * rng.uniform(0.7, 1.3))), preferred_keywords=list(p.preferred_keywords), quantity_pref=p.quantity_pref, device=p.device, notes=p.notes, )