From Zero to Production:
Master Prompt Engineering by Building a Real Ad Bot

pip install groq python-dotenv  # install groq SDK and env manager

import os
from groq import Groq  # import the official Groq SDK

client = Groq(api_key="YOUR_GROQ_API_KEY")  # initialise with your key

response = client.chat.completions.create(
    model="llama-3.3-70b-versatile",  # fast, free, powerful model
    messages=[
        {"role": "user", "content": "Write a one-line ad for fresh cow milk."}
    ]
)

print(response.choices[0].message.content)  # print the AI response

baseline_prompts = [
    "Write an ad for milk.",  # Prompt 1: vague, no context
    "Write a Facebook ad for a dairy company.",  # Prompt 2: slightly better, but still generic
    "Create an advertisement for PureFarm Dairy's fresh milk products.",  # Prompt 3: has brand name
]

for i, prompt in enumerate(baseline_prompts):
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[{"role": "user", "content": prompt}]
    )
    print(f"\n=== Baseline {i+1} ===")
    print(response.choices[0].message.content)

def evaluate_ad_basic(ad_text):
    """Rule-based evaluation — fast, deterministic, cheap."""
    scores = {}
    
    # 1. Relevance: Check for brand/product mentions
    brand_keywords = ["purefarm", "milk", "dairy", "a2", "paneer", "ghee", "dahi"]
    mentions = sum(1 for kw in brand_keywords if kw.lower() in ad_text.lower())
    scores["relevance"] = min(20, mentions * 5)  # cap at 20
    
    # 2. Specificity: Look for numbers, percentages, time references
    import re
    specifics = re.findall(r'\b\d+[\.\d]*\s?(%|km|days?|hours?|mins?|years?|mg|g|ml)\b', ad_text)
    scores["specificity"] = min(20, len(specifics) * 7)  # each number = 7 pts
    
    # 3. CTA Clarity: Look for action verbs
    cta_words = ["order", "subscribe", "try", "buy", "get", "visit", "book", "download", "click"]
    has_cta = any(w.lower() in ad_text.lower() for w in cta_words)
    scores["cta_clarity"] = 20 if has_cta else 0
    
    # 4. Uniqueness: Penalise clichés
    cliche_words = ["pure", "fresh", "natural", "healthy", "goodness", "creamy", "wholesome", "delicious"]
    cliche_count = sum(1 for w in cliche_words if w.lower() in ad_text.lower())
    scores["uniqueness"] = max(0, 20 - (cliche_count * 5))  # deduct per cliché
    
    scores["total_basic"] = sum(scores.values())
    return scores

import json, datetime, os

def log_ad_generation(prompt_name, prompt_text, ad_output, scores, model="llama-3.3-70b-versatile"):
    """Append one generation record to a JSON-lines log file."""
    
    record = {
        "timestamp": datetime.datetime.utcnow().isoformat(),  # when it was generated
        "model": model,  # which model produced it
        "prompt_name": prompt_name,  # e.g. "zero_shot_v1", "few_shot_v2"
        "prompt_text": prompt_text,  # full prompt for reproducibility
        "ad_output": ad_output,  # the generated ad
        "scores": scores,  # evaluation scores dict
    }
    
    os.makedirs("logs", exist_ok=True)
    with open("logs/ad_generations.jsonl", "a") as f:
        f.write(json.dumps(record) + "\n")  # JSON-lines: one record per line
    
    print(f"✅ Logged: {prompt_name} | Score: {scores.get('total_basic', 'N/A')}")

# Usage example:
log_ad_generation(
    prompt_name="chain_of_thought_v1",
    prompt_text=prompt_cot,
    ad_output="Every morning at 4 AM, Ramesh milks the same 12 cows...",
    scores={"relevance": 20, "specificity": 14, "cta_clarity": 20, "uniqueness": 20, "total_basic": 74}
)

def llm_judge_evaluate(ad_text, context="Milk products company, Indian market"):
    """Use an LLM to evaluate an ad on qualitative dimensions."""
    
    judge_prompt = f"""
You are an expert advertising effectiveness evaluator with 15+ years of experience
in FMCG marketing for Indian markets. You evaluate ads objectively using the framework below.

AD TO EVALUATE:
{ad_text}

CONTEXT: {context}

EVALUATION FRAMEWORK — score each dimension from 0 to 20:
1. EMOTIONAL IMPACT (0-20): Does it trigger genuine emotion in under 5 seconds?
   - 0-5: No emotional resonance whatsoever
   - 6-10: Mild, generic emotion (e.g. "feels warm")
   - 11-15: Clear, specific emotion tied to a real human experience
   - 16-20: Visceral, memorable — the reader will think about this later

2. BRAND DIFFERENTIATION (0-20): Would you know this is NOT a competitor's ad?
   - 0-5: Could be any dairy brand
   - 6-15: Has some brand-specific elements
   - 16-20: Impossible to confuse with any other brand

3. PERSUASION STRENGTH (0-20): Does it actually move someone toward purchase?
   - 0-5: No compelling reason to act
   - 6-15: Some reason, but easily ignored
   - 16-20: Creates genuine urgency or desire

Respond ONLY with a valid JSON object:
{{"emotional_impact": <0-20>, "brand_differentiation": <0-20>, "persuasion_strength": <0-20>,
  "judge_reasoning": "<1-2 sentences explaining the overall score>",
  "standout_phrase": ""}}
"""
    
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",  # same free model, different role
        messages=[{"role": "user", "content": judge_prompt}],
        temperature=0.1  # low temp = consistent, deterministic judgement
    )
    
    import json
    scores = json.loads(response.choices[0].message.content)
    scores["llm_judge_total"] = scores["emotional_impact"] + scores["brand_differentiation"] + scores["persuasion_strength"]
    return scores

# Run the judge on the best ad from each strategy
ads_to_judge = {
    "baseline_1": "Milk: It does a body good! Enjoy the creamy taste of fresh milk every day.",
    "zero_shot": "You want the best for your child — so do we. 🥛 PureFarm A2 milk...",
    "chain_of_thought": "Every morning at 4 AM, Ramesh milks the same 12 cows. By 7 AM, that milk is at your door. PureFarm Delivery — subscribe today, know your farmer tomorrow.",
    "constraint": "82% of packaged milk sold in Delhi fails basic safety tests..."
}

results = {}
for name, ad in ads_to_judge.items():
    results[name] = llm_judge_evaluate(ad)
    print(f"{name}: Judge Score = {results[name]['llm_judge_total']}/60")

PERSONA_STOREHOUSE = {
    "priya_delhi_mother": {
        "name": "Priya", "age": 34, "city": "Delhi",
        "role": "Mother of 2 young children",
        "primary_pain": "Fear of adulteration and chemicals in packaged milk",
        "emotional_trigger": "Her children's health is non-negotiable",
        "tone_preference": "Reassuring, evidence-backed, maternal solidarity",
        "decision_driver": "Trust and verified quality, not price",
        "channel": "Facebook",
    },
    "arjun_startup": {
        "name": "Arjun", "age": 28, "city": "Mumbai",
        "role": "Startup founder, fitness-conscious",
        "primary_pain": "No time to research milk quality; needs certainty fast",
        "emotional_trigger": "Performance optimisation — everything is a system",
        "tone_preference": "Direct, data-driven, respects his intelligence",
        "decision_driver": "Protein content, convenience, subscription reliability",
        "channel": "Instagram",
    },
    "ramesh_pune_retired": {
        "name": "Ramesh", "age": 58, "city": "Pune",
        "role": "Retired teacher, grandfather",
        "primary_pain": "Modern milk doesn't taste like real milk anymore",
        "emotional_trigger": "Nostalgia — the taste of childhood and authenticity",
        "tone_preference": "Warm, unhurried, rooted in tradition",
        "decision_driver": "Taste, authenticity, farm connection",
        "channel": "WhatsApp forward-style content",
    },
    "kavya_home_baker": {
        "name": "Kavya", "age": 31, "city": "Bengaluru",
        "role": "Professional home baker",
        "primary_pain": "Batch inconsistency ruins her products and reputation",
        "emotional_trigger": "Professional pride — her business depends on ingredient quality",
        "tone_preference": "B2B-lite: practical, specific, consistent",
        "decision_driver": "Consistency, predictable fat content, reliable delivery",
        "channel": "Instagram, WhatsApp Business",
    },
}

def generate_persona_ad(persona_key, product="PureFarm A2 Milk", strategies=None):
    """Generate a personalised ad for a specific persona using combined prompt strategies."""
    
    persona = PERSONA_STOREHOUSE[persona_key]
    
    prompt = f"""
You are an expert advertising copywriter for PureFarm Dairy.

TARGET PERSONA:
- Name: {persona['name']}, Age: {persona['age']}, City: {persona['city']}
- Role: {persona['role']}
- Primary Pain: {persona['primary_pain']}
- Emotional Trigger: {persona['emotional_trigger']}
- Tone Preference: {persona['tone_preference']}
- Decision Driver: {persona['decision_driver']}
- Channel: {persona['channel']}

TASK:
Write a {persona['channel']} ad for {product}.
The ad must DIRECTLY ADDRESS {persona['name']}'s specific pain ({persona['primary_pain']}).
Do NOT write a generic milk ad. Write an ad that {persona['name']} would stop scrolling for.
Length: 60–80 words.
"""  # Persona-injected prompt: each ad is unique to the person
    
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

EXPERT_FRAMEWORK = {
    "rory_sutherland": {
        "name": "Rory Sutherland",
        "philosophy": """
You think like Rory Sutherland, VP of Ogilvy and behavioural economist.
Your core belief: people don't make rational decisions — they make 'psycho-logical' decisions.
You always ask: what is the PERCEIVED value here, not the objective value?
You look for the 'reframe' — how can we make the same thing feel completely different
by changing the story around it, not the thing itself?
You are suspicious of features. You love meanings, signals, and context.
You would rather write an ad about the ABSENCE of something bad than the PRESENCE of something good.
        """,
        "signature_moves": [
            "Reframe inconveniences as features (e.g., a slower delivery = freshness)",
            "Use the absence of something bad as the key message",
            "Find the unexpected psychological reason people actually buy",
            "Make the familiar feel strange and the strange feel familiar",
        ]
    }
}

def generate_expert_persona_ad(persona_key, expert_key, product="PureFarm A2 Milk"):
    """Combine customer persona with expert copywriter philosophy."""
    
    persona = PERSONA_STOREHOUSE[persona_key]
    expert = EXPERT_FRAMEWORK[expert_key]
    
    prompt = f"""
EXPERT IDENTITY:
{expert['philosophy']}

YOUR SIGNATURE MOVES:
{chr(10).join('- ' + m for m in expert['signature_moves'])}

TARGET PERSONA:
Name: {persona['name']}, Pain: {persona['primary_pain']}
Emotional Trigger: {persona['emotional_trigger']}

PRODUCT: {product}

Apply your expert philosophy to write a {persona['channel']} ad for {persona['name']}.
Use one of your signature moves. The ad must feel like it was written by {expert['name']},
not a generic AI. 60-80 words.
Show which signature move you chose before the ad.
"""  # Expert philosophy stacks on top of persona for deeper insight
    
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# Step 1: Your curated "Ad DNA" library — built from your best logged outputs
AD_DNA_LIBRARY = [
    {
        "id": "ad_001",
        "text": "Every morning at 4 AM, Ramesh milks the same 12 cows. By 7 AM, that milk is at your door. PureFarm Delivery — subscribe today, know your farmer tomorrow.",
        "emotion": "trust",
        "audience_tags": ["parents", "health_conscious", "urban"],
        "score": 128,
        "source": "chain_of_thought_v1"
    },
    {
        "id": "ad_002", 
        "text": "Most milk cartons list what's in the milk. PureFarm's certificate lists what isn't. No oxytocin. No hormones. No added water. The most important ingredient is what's not there.",
        "emotion": "fear_relief",
        "audience_tags": ["mothers", "children_safety"],
        "score": 134,
        "source": "rory_framework_priya"
    },
    {
        "id": "ad_003",
        "text": "Your croissant deserves better than milk that varies batch to batch. PureFarm: 4.2% fat ± 0.1%. Consistent. Every order. Every Monday.",
        "emotion": "professional_pride",
        "audience_tags": ["professionals", "food_business", "consistency"],
        "score": 122,
        "source": "persona_kavya_v1"
    },
]

def retrieve_relevant_ads(persona_key, n=2):
    """Retrieve the n most relevant golden ads for a given persona."""
    persona = PERSONA_STOREHOUSE[persona_key]
    
    # Simple tag-matching retrieval (in production, use vector similarity)
    relevant = []
    for ad in AD_DNA_LIBRARY:
        match_score = 0
        if "fear" in persona["primary_pain"].lower() and "fear" in ad.get("emotion",""):
            match_score += 2
        if "mother" in persona["role"].lower() and "mothers" in ad.get("audience_tags",[]):
            match_score += 2
        if "professional" in persona["role"].lower() and "professionals" in ad.get("audience_tags",[]):
            match_score += 2
        relevant.append((match_score, ad))
    
    relevant.sort(key=lambda x: (-x[0], -x[1]["score"]))  # sort by relevance, then score
    return [ad for _, ad in relevant[:n]]

def generate_rag_ad(persona_key, expert_key=None, product="PureFarm A2 Milk"):
    """Generate an ad using retrieved golden examples as context (RAG-style)."""
    
    persona = PERSONA_STOREHOUSE[persona_key]
    golden_ads = retrieve_relevant_ads(persona_key)  # retrieve best examples
    
    examples_text = "\n\n".join([
        f"GOLDEN EXAMPLE (Score: {ad['score']}/140, Emotion: {ad['emotion']}):\n{ad['text']}"
        for ad in golden_ads
    ])
    
    expert_context = ""
    if expert_key:
        expert_context = f"\nAPPLY THIS PHILOSOPHY:\n{EXPERT_FRAMEWORK[expert_key]['philosophy']}"
    
    prompt = f"""
You are writing a high-performing ad for PureFarm Dairy.
Study these golden examples — they have been proven to score 120+/140 on our benchmark.
Your output must match or exceed their quality.

{examples_text}

TARGET PERSONA: {persona['name']}, {persona['age']} — Pain: {persona['primary_pain']}
CHANNEL: {persona['channel']}
PRODUCT: {product}
{expert_context}

Now write ONE new ad that:
1. Matches the voice and psychological depth of the golden examples
2. Directly addresses {persona['name']}'s specific pain
3. Uses the emotion pattern that worked in the retrieved examples
4. Is original — do NOT copy the examples
"""
    
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

def full_pipeline(persona_key, expert_key=None, product="PureFarm A2 Milk"):
    """Complete generation + evaluation + logging pipeline for the Ad Bot."""
    
    print(f"\n{'='*60}")
    print(f"🚀 Generating ad for persona: {persona_key}")
    
    # 1. Generate
    ad = generate_rag_ad(persona_key, expert_key, product)  # RAG + persona + expert
    
    # 2. Rule-based evaluation
    basic_scores = evaluate_ad_basic(ad)
    
    # 3. LLM Judge evaluation
    judge_scores = llm_judge_evaluate(ad, context=f"Milk products, targeting {persona_key}")
    
    # 4. Persona fit score — does the ad address the persona's specific pain?
    persona = PERSONA_STOREHOUSE[persona_key]
    persona_fit_prompt = f"""
Score 0-20: Does this ad directly and specifically address the pain point '{persona['primary_pain']}'?
AD: {ad}
Respond with only a JSON: {{"persona_fit_score": <0-20>, "reasoning": "<1 sentence>"}}
"""
    fit_response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[{"role": "user", "content": persona_fit_prompt}],
        temperature=0.1
    )
    import json
    fit_data = json.loads(fit_response.choices[0].message.content)
    
    # 5. Compute total score (max 160: 80 rule + 60 judge + 20 persona fit)
    total = basic_scores["total_basic"] + judge_scores["llm_judge_total"] + fit_data["persona_fit_score"]
    
    # 6. Launch decision gate
    LAUNCH_THRESHOLD = 120  # only launch ads scoring 120+ out of 160
    decision = "✅ APPROVED FOR LAUNCH" if total >= LAUNCH_THRESHOLD else "❌ NEEDS REVISION"
    
    print(f"📊 Total Score: {total}/160 → {decision}")
    print(f"📝 Ad Preview:\n{ad[:100]}...")
    
    # 7. Log everything
    log_ad_generation(
        prompt_name=f"rag_{persona_key}_{expert_key or 'no_expert'}",
        prompt_text="[RAG pipeline — see logs for full prompt]",
        ad_output=ad,
        scores={**basic_scores, **judge_scores, "persona_fit": fit_data["persona_fit_score"], "total": total, "decision": decision}
    )
    
    return ad, total, decision

# Run the full campaign:
campaign_personas = ["priya_delhi_mother", "arjun_startup", "ramesh_pune_retired", "kavya_home_baker"]
campaign_results = []

for persona in campaign_personas:
    ad, score, decision = full_pipeline(persona, expert_key="rory_sutherland")
    campaign_results.append({"persona": persona, "score": score, "decision": decision})