Added ADs Module

app/ads/descriptions_service.py

@@ -0,0 +1,146 @@
+# app/services/descriptions_service.py
+import os
+import json
+import logging
+import time
+from typing import List
+
+import google.generativeai as genai
+
+from app.ads.schemas import DescriptionsRequest, Persona
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+# Ensure genai configured (harmless if already configured elsewhere)
+API_KEY = os.getenv("GEMINI_API_KEY")
+if API_KEY:
+    try:
+        genai.configure(api_key=API_KEY)
+        logger.debug("Configured google.generativeai in descriptions service")
+    except Exception:
+        logger.exception("Failed to configure google.generativeai in descriptions service")
+
+
+def _extract_json_array(raw: str) -> str:
+    start = raw.find('[')
+    end = raw.rfind(']')
+    if start != -1 and end != -1 and end > start:
+        return raw[start:end + 1]
+    return raw
+
+
+def _build_descriptions_prompt(req: DescriptionsRequest) -> str:
+    """
+    Build prompt asking Gemini to return ONLY a JSON array of strings (ad descriptions).
+    """
+    try:
+        personas_json = json.dumps([p.dict() for p in req.selected_personas], indent=2)
+    except Exception:
+        personas_json = json.dumps(req.selected_personas, indent=2)
+
+    main_goal_value = req.main_goal.value
+    main_goal_desc = getattr(req.main_goal, "description", "")
+
+    prompt = f"""
+You are an expert ad copywriter specialized in short, high-converting ad descriptions for digital ads.
+
+Task:
+Produce exactly {req.num_descriptions} ad descriptions (each 1-2 short sentences) tailored to the business and the selected persona(s). RETURN ONLY a JSON array of strings (e.g. ["Desc 1", "Desc 2", ...]) and nothing else.
+
+Requirements:
+- Each description should be concise (max ~140 characters preferred), benefit-focused, and aligned with the business value and main goal.
+- Vary tone across descriptions (e.g., urgent, aspirational, trust-building, practical).
+- Include the main value or offer where appropriate (e.g., "MVP development", "AI integration", "fast time-to-market", "trusted SaaS partner").
+- If the selected personas have different priorities, generate descriptions that address those priorities.
+- Goal: "{main_goal_value}" — {main_goal_desc}
+
+Business inputs:
+- Business name: {req.business_name}
+- Business category: {req.business_category}
+- Business description: {req.business_description}
+- Promotion type: {req.promotion_type}
+- Offer description: {req.offer_description}
+- Value proposition: {req.value}
+- Main goal: {main_goal_value} — {main_goal_desc}
+- Serving clients info: {req.serving_clients_info}
+- Serving clients location: {req.serving_clients_location}
+
+Selected persona(s) (use these to shape descriptions):
+{personas_json}
+
+Now generate exactly {req.num_descriptions} unique ad descriptions as a JSON array of strings. No explanation, no extra text.
+"""
+    logger.debug("Built descriptions prompt (len=%d) for business '%s'", len(prompt), req.business_name)
+    return prompt.strip()
+
+
+def generate_descriptions(req: DescriptionsRequest) -> List[str]:
+    prompt = _build_descriptions_prompt(req)
+
+    model_name = "gemini-2.5-pro"
+    logger.info("Generating %d descriptions for business '%s' using model %s",
+                req.num_descriptions, req.business_name, model_name)
+
+    try:
+        model = genai.GenerativeModel(model_name)
+    except Exception as e:
+        logger.exception("Failed to init Gemini model for descriptions: %s", e)
+        raise RuntimeError(f"Gemini model init failed: {e}")
+
+    try:
+        start = time.perf_counter()
+        response = model.generate_content(prompt)
+        duration = time.perf_counter() - start
+        logger.info("Gemini generate_content (descriptions) completed in %.2fs", duration)
+    except Exception as e:
+        logger.exception("Gemini generate_content failed for descriptions")
+        raise RuntimeError(f"Gemini request failed: {e}")
+
+    # extract raw text
+    raw = None
+    try:
+        if response and hasattr(response, "text") and response.text:
+            raw = response.text
+            logger.debug("Received response.text (len=%d) for descriptions", len(raw))
+        elif response and getattr(response, "candidates", None):
+            first = response.candidates[0]
+            if getattr(first, "finish_reason", "").upper() == "SAFETY":
+                msg = "Gemini descriptions generation blocked by safety filter"
+                logger.error(msg)
+                raise RuntimeError(msg)
+            raw = getattr(first, "content", None) or getattr(first, "text", None) or str(response)
+            logger.debug("Received candidate response for descriptions (len=%d)", len(raw) if raw else 0)
+        else:
+            raw = str(response)
+            logger.debug("Converted descriptions response to string (len=%d)", len(raw))
+    except Exception as e:
+        logger.exception("Failed to extract raw text from Gemini descriptions response")
+        raise RuntimeError(f"Failed to extract Gemini response text: {e}")
+
+    if not raw:
+        logger.error("Empty response from Gemini when generating descriptions")
+        raise RuntimeError("Empty response from Gemini")
+
+    snippet = _extract_json_array(raw)
+    try:
+        parsed = json.loads(snippet)
+    except json.JSONDecodeError:
+        logger.exception("Failed to parse JSON from descriptions response. Raw response: %s", raw)
+        raise RuntimeError(f"Failed to parse Gemini response as JSON array of strings.\nRaw: {raw}")
+
+    if not isinstance(parsed, list) or not all(isinstance(i, str) for i in parsed):
+        logger.error("Parsed descriptions JSON is not a list of strings. Parsed type: %s", type(parsed))
+        raise RuntimeError("Gemini did not return a JSON array of strings as expected.")
+
+    descriptions = parsed
+    if len(descriptions) < req.num_descriptions:
+        logger.warning("Gemini returned %d descriptions; expected %d. Returning what we have.",
+                       len(descriptions), req.num_descriptions)
+    elif len(descriptions) > req.num_descriptions:
+        descriptions = descriptions[: req.num_descriptions]
+        logger.debug("Trimmed descriptions to requested num_descriptions=%d", req.num_descriptions)
+
+    descriptions = [d.strip() for d in descriptions]
+    logger.info("Generated %d descriptions for business '%s'", len(descriptions), req.business_name)
+    return descriptions

app/ads/headings_service.py

@@ -0,0 +1,157 @@
+# app/services/headings_service.py
+import os
+import json
+import logging
+import time
+from typing import List
+
+import google.generativeai as genai
+
+from app.ads.schemas import HeadingsRequest, Persona
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+# Ensure Gemini SDK is configured (harmless if already configured elsewhere)
+API_KEY = os.getenv("GEMINI_API_KEY")
+if not API_KEY:
+    logger.error("GEMINI_API_KEY not set; headings generation will fail if called without configuration.")
+else:
+    try:
+        genai.configure(api_key=API_KEY)
+        logger.debug("Configured google.generativeai in headings service")
+    except Exception as e:
+        logger.exception("Failed to configure google.generativeai in headings service: %s", e)
+
+
+def _extract_json_array(raw: str) -> str:
+    """
+    Return the first JSON array substring from raw (from '[' to ']') to be robust
+    against extra commentary in model output.
+    """
+    start = raw.find('[')
+    end = raw.rfind(']')
+    if start != -1 and end != -1 and end > start:
+        return raw[start:end + 1]
+    return raw
+
+
+def _build_headings_prompt(req: HeadingsRequest) -> str:
+    """
+    Build a clear prompt asking Gemini to return ONLY a JSON array of strings (headings).
+    """
+    # Convert selected_personas to compact JSON for context
+    personas_json = json.dumps([p.dict() for p in req.selected_personas], indent=2)
+
+    main_goal_value = req.main_goal.value
+    main_goal_desc = getattr(req.main_goal, "description", "")
+
+    prompt = f"""
+You are an expert copywriter specialized in short, high-converting ad headlines for digital ads.
+
+Task:
+Produce exactly {req.num_headings} short, punchy ad headings (strings) for a paid ad campaign that target the selected personas and align with the business goal. RETURN ONLY a JSON array of strings (e.g. ["Heading 1", "Heading 2", ...]) and nothing else.
+
+Requirements:
+- Each heading should be concise (max ~60 characters), benefit-focused, and tailored to the provided personas and business goal.
+- Use active language and mention the key value when appropriate (e.g., "scale", "AI", "launch", "MVP", "secure funding", "reduce time-to-market").
+- Vary the tone across the 4 headings (e.g., urgent, aspirational, trust-building, and practical).
+- Avoid punctuation-only headlines, and do not include numbering in text.
+- If the main goal is "{main_goal_value}", use that intention as a primary framing. Goal description: {main_goal_desc}
+
+Business Inputs:
+- Business name: {req.business_name}
+- Business category: {req.business_category}
+- Business description: {req.business_description}
+- Promotion type: {req.promotion_type}
+- Offer description: {req.offer_description}
+- Value proposition: {req.value}
+- Main goal: {main_goal_value} — {main_goal_desc}
+- Serving clients info: {req.serving_clients_info}
+- Serving clients location: {req.serving_clients_location}
+
+Selected persona(s) (use these to shape headings):
+{personas_json}
+
+Now generate exactly {req.num_headings} unique ad headings as a JSON array of strings. No explanation, no extra text.
+"""
+    logger.debug("Built headings prompt (len=%d) for business '%s'", len(prompt), req.business_name)
+    return prompt.strip()
+
+
+def generate_headings(req: HeadingsRequest) -> List[str]:
+    """
+    Call Gemini to generate ad headings and return list[str].
+    """
+    prompt = _build_headings_prompt(req)
+
+    model_name = "gemini-2.5-pro"
+    logger.info("Generating %d headings for business '%s' using model %s",
+                req.num_headings, req.business_name, model_name)
+
+    try:
+        model = genai.GenerativeModel(model_name)
+    except Exception as e:
+        logger.exception("Failed to create GenerativeModel: %s", e)
+        raise RuntimeError(f"Gemini model init failed: {e}")
+
+    try:
+        start = time.perf_counter()
+        response = model.generate_content(prompt)
+        duration = time.perf_counter() - start
+        logger.info("Gemini generate_content (headings) completed in %.2fs", duration)
+    except Exception as e:
+        logger.exception("Gemini generate_content failed for headings")
+        raise RuntimeError(f"Gemini request failed: {e}")
+
+    # Extract raw text from response
+    raw = None
+    try:
+        if response and hasattr(response, "text") and response.text:
+            raw = response.text
+            logger.debug("Received response.text (len=%d) for headings", len(raw))
+        elif response and getattr(response, "candidates", None):
+            first = response.candidates[0]
+            if getattr(first, "finish_reason", "").upper() == "SAFETY":
+                msg = "Gemini headings generation blocked by safety filter"
+                logger.error(msg)
+                raise RuntimeError(msg)
+            raw = getattr(first, "content", None) or getattr(first, "text", None) or str(response)
+            logger.debug("Received candidate response for headings (len=%d)", len(raw) if raw else 0)
+        else:
+            raw = str(response)
+            logger.debug("Converted headings response to string (len=%d)", len(raw))
+    except Exception as e:
+        logger.exception("Failed to extract raw text from Gemini headings response")
+        raise RuntimeError(f"Failed to extract Gemini response text: {e}")
+
+    if not raw:
+        logger.error("Empty response from Gemini when generating headings")
+        raise RuntimeError("Empty response from Gemini")
+
+    # Robust JSON extraction & parsing
+    snippet = _extract_json_array(raw)
+    try:
+        parsed = json.loads(snippet)
+    except json.JSONDecodeError:
+        logger.exception("Failed to parse JSON from headings response. Raw response: %s", raw)
+        raise RuntimeError(f"Failed to parse Gemini response as JSON array of strings.\nRaw: {raw}")
+
+    if not isinstance(parsed, list) or not all(isinstance(i, str) for i in parsed):
+        logger.error("Parsed headings JSON is not a list of strings. Parsed type: %s", type(parsed))
+        raise RuntimeError("Gemini did not return a JSON array of strings as expected.")
+
+    # Normalize: ensure exactly num_headings items
+    headings = parsed
+    if len(headings) < req.num_headings:
+        logger.warning("Gemini returned %d headings; expected %d. Returning what we have.",
+                       len(headings), req.num_headings)
+    elif len(headings) > req.num_headings:
+        headings = headings[: req.num_headings]
+        logger.debug("Trimmed headings to requested num_headings=%d", req.num_headings)
+
+    # Final basic cleanup (strip whitespace)
+    headings = [h.strip() for h in headings]
+
+    logger.info("Generated %d headings for business '%s'", len(headings), req.business_name)
+    return headings

app/ads/image_service.py

@@ -0,0 +1,70 @@
+import io
+import logging
+from typing import Tuple
+from google import genai
+from google.genai import types
+
+from app.ads.schemas import ImageRequest, Persona
+
+logger = logging.getLogger(__name__)
+
+def _persona_to_text(persona: Persona) -> str:
+    """Return a one-line description for a Persona model."""
+    interests = ", ".join(persona.interests) if persona.interests else "no listed interests"
+    return f"{persona.name} (age: {persona.age_range}, location: {persona.location}, interests: {interests})"
+
+def generate_image(req: ImageRequest) -> Tuple[bytes, str]:
+    """
+    Generate an Ad image using Gemini 2.0 flash experimental image model.
+    Falls back to returning text prompts if Gemini returns only text.
+    """
+    # Safely convert Persona objects into strings
+    if req.selected_personas and len(req.selected_personas) > 0:
+        personas_text = "; ".join(_persona_to_text(p) for p in req.selected_personas)
+    else:
+        personas_text = "general target audience"
+
+    prompt = (
+        f"Create a professional advertisement image for the business '{req.business_name}'. "
+        f"Category: {req.business_category}. "
+        f"Description: {req.business_description}. "
+        f"Promotion type: {req.promotion_type}. "
+        f"Offer details: {req.offer_description}. "
+        f"Value proposition: {req.value}. "
+        f"Main goal: {req.main_goal.value}. "
+        f"Serving clients info: {req.serving_clients_info}. "
+        f"Location: {req.serving_clients_location}. "
+        f"Target persona(s): {personas_text}. "
+        "The image should be modern, vibrant, and suitable for a social media advertisement."
+    )
+
+    logger.info("Requesting Gemini image generation for business '%s'", req.business_name)
+
+    try:
+        client = genai.Client()
+        response = client.models.generate_content(
+            model="gemini-2.0-flash-exp",
+            contents=(prompt
+            ),
+            config=types.GenerateContentConfig(
+                response_modalities=["text", "Image"]
+            ),
+        )
+
+        # Parse Gemini response for images
+        for part in response.candidates[0].content.parts:
+            if getattr(part, "inline_data", None) and part.inline_data.data:
+                image_bytes = part.inline_data.data
+                return image_bytes, "image/png"
+
+        # Fallback: Gemini returned text (prompt or explanation)
+        for part in response.candidates[0].content.parts:
+            if getattr(part, "text", None):
+                logger.warning("Gemini returned text instead of image: %s", part.text[:300])
+                raise RuntimeError("Gemini returned text only, no image data found.")
+
+        raise RuntimeError("No image data found in Gemini response.")
+
+    except Exception as e:
+        logger.exception("Gemini image generation failed: %s", e)
+        raise RuntimeError(f"Gemini image generation failed: {e}")

app/ads/persona_routes.py

@@ -0,0 +1,63 @@
+# app/routes/persona_routes.py
+from fastapi import APIRouter, HTTPException
+from typing import List
+from fastapi.responses import StreamingResponse
+
+from app.ads.schemas import BusinessInput, Persona, RegenerateRequest, HeadingsRequest, DescriptionsRequest, ImageRequest
+import io
+import app.ads.image_service as image_service
+import app.ads.headings_service as headings_service
+import app.ads.descriptions_service as descriptions_service
+from app.ads.persona_service import generate_personas , regenerate_personas
+
+router = APIRouter(prefix="/Ads", tags=["Ads"])
+
+@router.post("/create", response_model=List[Persona])
+def create_personas(payload: BusinessInput):
+    try:
+        personas = generate_personas(payload)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    return personas
+
+@router.post("/regenerate", response_model=List[Persona])
+def regenerate_personas_endpoint(payload: RegenerateRequest):
+    """
+    Regenerate personas given all business inputs AND a list of previous personas.
+    The endpoint returns a new list of personas (same schema).
+    """
+    try:
+        personas = regenerate_personas(payload, payload.previous_personas)
+    except Exception as e:
+        # return the error message to the client for quick debugging
+        raise HTTPException(status_code=500, detail=str(e))
+    return personas
+
+@router.post("/Headings", response_model=List[str])
+def create_headings(payload: HeadingsRequest):
+    """
+    Generate ad headings (returns list[str]).
+    """
+    try:
+        return headings_service.generate_headings(payload)
+    except Exception as e:
+        # Log error server-side; return HTTP 500 with message for debugging
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.post("/Descriptions", response_model=List[str])
+def create_descriptions(payload: DescriptionsRequest):
+    try:
+        return descriptions_service.generate_descriptions(payload)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.post("/Image", response_class=StreamingResponse)
+def create_image(payload: ImageRequest):
+    """
+    Generate a marketing image for an ad using Gemini.
+    """
+    try:
+        img_bytes, mime = image_service.generate_image(payload)
+        return StreamingResponse(io.BytesIO(img_bytes), media_type=mime)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/ads/persona_service.py

@@ -0,0 +1,345 @@
+# app/services/persona_service.py
+import os
+import json
+import logging
+import time
+from typing import List
+import google.generativeai as genai
+from pydantic import ValidationError
+
+from app.ads.schemas import Persona, BusinessInput
+
+# module logger
+logger = logging.getLogger(__name__)
+# Avoid configuring global logging here; app-level config should set handlers/levels.
+# But ensure we have at least a NullHandler to avoid "No handler" warnings in some apps.
+logger.addHandler(logging.NullHandler())
+
+
+# initialize client (reads GEMINI_API_KEY from environment)
+API_KEY = os.getenv("GEMINI_API_KEY")
+if not API_KEY:
+    logger.error("GEMINI_API_KEY environment variable not set")
+    raise RuntimeError("Please set the GEMINI_API_KEY environment variable")
+
+# Configure the genai SDK (reference pattern)
+try:
+    genai.configure(api_key=API_KEY)
+    logger.info("Configured google.generativeai with provided API key")
+except Exception as e:
+    logger.exception("Failed to configure google.generativeai: %s", e)
+    raise
+
+
+def _build_prompt(b: BusinessInput) -> str:
+
+    examples_json = [
+        {
+            "name": "Startup Founders",
+            "headline": "Entrepreneurs launching new businesses",
+            "age_range": "25-40",
+            "location": "United Kingdom",
+            "interests": [
+                "Entrepreneurship",
+                "Startups",
+                "Business coaching",
+                "Tech tools"
+            ],
+            "description": "Likely to need professional websites to establish credibility; motivated by investor/customer trust and fast go-to-market. Prefer outreach via LinkedIn, Twitter, and startup meetups."
+        },
+        {
+            "name": "Local Shop Owners",
+            "headline": "Owners of brick-and-mortar retail shops",
+            "age_range": "35-55",
+            "location": "London and Midlands",
+            "interests": [
+                "Small business",
+                "Retail management",
+                "Local advertising"
+            ],
+            "description": "They want affordable websites to attract local customers and show store hours/offers. Respond well to local ads, Facebook community groups, and in-store flyers."
+        },
+        {
+            "name": "Freelancers & Consultants",
+            "headline": "Independent professionals offering services online",
+            "age_range": "22-45",
+            "location": "United Kingdom",
+            "interests": [
+                "Personal branding",
+                "Online marketing",
+                "Networking",
+                "LinkedIn"
+            ],
+            "description": "Need personal websites to showcase expertise, attract clients and build credibility; motivated by lead generation and portfolio presentation. Prefer LinkedIn, industry communities, and content marketing."
+        }
+    ]
+
+    # Use both the enum value and the associated description
+    main_goal_value = b.main_goal.value
+    main_goal_desc = getattr(b.main_goal, "description", "")
+
+    prompt = f'''
+You are a senior marketing strategist specialized in creating *ideal-customer / target-audience personas* for businesses. Produce exactly {b.num_personas} distinct IDEAL-CUSTOMER personas tailored to the business described below.
+
+**Output format (required):** Return ONLY a JSON array of objects. Each object must contain these properties in this exact order:
+  1. name (string)
+  2. headline (string; 3-6 words)
+  3. age_range (string; numeric range like "25-40")
+  4. location (string)
+  5. interests (array of short strings; 3-6 items)
+  6. description (string; 1-3 sentences)
+
+**Description field requirements:** The `description` must summarize the persona as an *ideal customer*:
+- who they are (role / brief demographic),
+- top 1–2 pain points or needs,
+- primary buying trigger or motivation,
+- preferred channels to reach them (e.g., Instagram, LinkedIn, email, local events),
+- why they would choose this business / how the offer solves their need.
+
+**Do NOT include any extra top-level keys, comments, or explanation text. JSON array only.**
+
+Below are three example personas showing the exact style and level of detail I want your output to match. Use them as format examples — but produce personas specific to the business inputs that follow.
+
+EXAMPLE PERSONAS (format example):
+{json.dumps(examples_json, indent=2)}
+
+Business inputs:
+- Business name: {b.business_name}
+- Business category: {b.business_category}
+- Business description: {b.business_description}
+- Promotion type: {b.promotion_type}
+- Offer description: {b.offer_description}
+- Value proposition: {b.value}
+- Main goal: {main_goal_value} — {main_goal_desc}
+- Serving clients info: {b.serving_clients_info}
+- Serving clients location: {b.serving_clients_location}
+
+Generate the {b.num_personas} personas now as a JSON array that exactly matches the schema and style shown above.
+'''
+    built = prompt.strip()
+    logger.debug("Built persona prompt (goal=%s): %s", main_goal_value, built[:400] + ("…" if len(built) > 400 else ""))
+    return built
+
+
+def _extract_json_array(raw: str) -> str:
+    """
+    Find and return the first JSON array substring in raw text (from '[' to ']').
+    If not found, return raw as-is (parsing will attempt).
+    """
+    start = raw.find('[')
+    end = raw.rfind(']')
+    if start != -1 and end != -1 and end > start:
+        snippet = raw[start:end + 1]
+        logger.debug("Extracted JSON array snippet from raw response (length=%d)", len(snippet))
+        return snippet
+    logger.debug("No JSON array brackets found in raw response; returning full raw text for parsing")
+    return raw
+
+
+def generate_personas(b: BusinessInput) -> List[Persona]:
+    """
+    Generate personas using Gemini. Returns a list of Persona Pydantic models.
+    Logs important steps and errors for easier debugging.
+    """
+    prompt = _build_prompt(b)
+
+    try:
+        model_name = "gemini-2.5-pro"
+        logger.info("Initializing Gemini model: %s", model_name)
+        model = genai.GenerativeModel(model_name)
+
+        logger.info("Sending generation request to Gemini for business '%s'", b.business_name)
+        start_ts = time.perf_counter()
+        response = model.generate_content(prompt)
+        duration = time.perf_counter() - start_ts
+        logger.info("Gemini generate_content completed in %.2fs", duration)
+
+    except Exception as e:
+        # surface Gemini initialization / network errors with stack trace
+        logger.exception("Gemini request failed for business '%s': %s", b.business_name, e)
+        raise RuntimeError(f"Gemini request failed: {e}")
+
+    # Inspect response for text or safety block
+    raw = None
+    try:
+        if response and hasattr(response, "text") and response.text:
+            raw = response.text
+            logger.debug("Received response.text (length=%d)", len(raw))
+        elif response and getattr(response, "candidates", None):
+            first = response.candidates[0]
+            if getattr(first, "finish_reason", "").upper() == "SAFETY":
+                msg = "Gemini generation blocked by safety filter"
+                logger.error(msg)
+                raise RuntimeError(msg)
+            raw = getattr(first, "content", None) or getattr(first, "text", None) or str(response)
+            logger.debug("Received candidate-based response (length=%d)", len(raw) if raw else 0)
+        else:
+            raw = str(response)
+            logger.debug("Converted response object to string (length=%d)", len(raw))
+    except Exception as e:
+        logger.exception("Failed to extract raw text from Gemini response for business '%s'", b.business_name)
+        raise RuntimeError(f"Failed to extract Gemini response text: {e}")
+
+    if not raw:
+        logger.error("Empty response received from Gemini for business '%s'", b.business_name)
+        raise RuntimeError("Empty response received from Gemini")
+
+    # Extract JSON array substring (robust for extra commentary)
+    json_snippet = _extract_json_array(raw)
+    logger.info("Attempting to parse JSON snippet for business '%s' (snippet length=%d)", b.business_name, len(json_snippet))
+
+    # Attempt to parse JSON and validate against Persona schema
+    try:
+        parsed = json.loads(json_snippet)
+
+        # If model returned a dict wrapper, attempt to find the list inside
+        if isinstance(parsed, dict):
+            # common wrapper keys to check
+            for key in ("items", "personas", "data", "results"):
+                if key in parsed and isinstance(parsed[key], list):
+                    parsed = parsed[key]
+                    logger.debug("Found persona list inside wrapper key '%s'", key)
+                    break
+
+        if not isinstance(parsed, list):
+            logger.error("Parsed JSON is not a list for business '%s' (type=%s)", b.business_name, type(parsed))
+            raise ValueError("Expected top-level JSON array of persona objects")
+
+        personas: List[Persona] = []
+        for idx, obj in enumerate(parsed):
+            try:
+                persona = Persona.parse_obj(obj)
+                personas.append(persona)
+                logger.debug("Validated persona %d: %s", idx, persona.name)
+            except ValidationError as ve:
+                # include which item failed for better debugging
+                logger.error("Persona validation failed for item %s: %s\nRaw item: %s", idx, ve, obj)
+                raise
+
+        logger.info("Successfully generated and validated %d personas for business '%s'", len(personas), b.business_name)
+        return personas
+
+    except (json.JSONDecodeError, ValidationError, ValueError) as e:
+        # Provide helpful debug output including raw Gemini text
+        logger.exception("Failed to parse/validate Gemini JSON output for business '%s'", b.business_name)
+        raise RuntimeError(
+            f"Failed to parse Gemini response as JSON Personas: {e}\n\nRaw Gemini response:\n{raw}"
+        )
+
+def regenerate_personas(b: BusinessInput, previous_personas: List[Persona]) -> List[Persona]:
+    """
+    Generate a new set of personas given the business input AND a list of
+    previously generated personas. The model is instructed to avoid duplicating
+    the previous personas and produce distinct/improved target-audience personas.
+    """
+    # Build base prompt from existing function
+    base_prompt = _build_prompt(b)
+
+    # Convert previous_personas to simple dicts (Pydantic models -> plain dicts)
+    try:
+        prev_list = [p.dict() if hasattr(p, "dict") else p for p in previous_personas]
+    except Exception:
+        # Defensive: if previous_personas are plain dicts already
+        prev_list = previous_personas
+
+    prev_json = json.dumps(prev_list, indent=2)
+
+    # Append clear instructions about previous personas and uniqueness requirement
+    extra_instructions = f"""
+Previous personas provided (do NOT repeat these exactly):
+{prev_json}
+
+Instructions:
+- Produce exactly {b.num_personas} personas tailored to the same business inputs above.
+- **Do not duplicate** persona names or core audience segments included in the previous list.
+- If a previous persona should be refined, produce a refined version but change the name slightly
+  and mention in the description what was improved.
+- Aim for personas that are distinct, actionable, and aligned with the business's main goal:
+  "{getattr(b, 'main_goal', '')}".
+- Output MUST be ONLY a JSON array of persona objects matching the schema:
+  name, headline, age_range, location, interests, description (in that order).
+"""
+    prompt = base_prompt + "\n\n" + extra_instructions
+
+    logger.info("Regenerating personas for business '%s' with %d previous personas",
+                b.business_name, len(prev_list))
+
+    # call model (same pattern as generate_personas)
+    try:
+        model_name = "gemini-2.5-pro"
+        logger.info("Initializing Gemini model for regeneration: %s", model_name)
+        model = genai.GenerativeModel(model_name)
+
+        start_ts = time.perf_counter()
+        response = model.generate_content(prompt)
+        duration = time.perf_counter() - start_ts
+        logger.info("Gemini regenerate_content completed in %.2fs", duration)
+
+    except Exception as e:
+        logger.exception("Gemini regenerate request failed for business '%s': %s", b.business_name, e)
+        raise RuntimeError(f"Gemini regenerate request failed: {e}")
+
+    # Extract raw text (same robust logic)
+    raw = None
+    try:
+        if response and hasattr(response, "text") and response.text:
+            raw = response.text
+            logger.debug("Regenerate response.text length=%d", len(raw))
+        elif response and getattr(response, "candidates", None):
+            first = response.candidates[0]
+            if getattr(first, "finish_reason", "").upper() == "SAFETY":
+                msg = "Gemini regeneration blocked by safety filter"
+                logger.error(msg)
+                raise RuntimeError(msg)
+            raw = getattr(first, "content", None) or getattr(first, "text", None) or str(response)
+            logger.debug("Regenerate candidate response length=%d", len(raw) if raw else 0)
+        else:
+            raw = str(response)
+            logger.debug("Regenerate response converted to string length=%d", len(raw))
+    except Exception as e:
+        logger.exception("Failed to extract raw text from Gemini regenerate response")
+        raise RuntimeError(f"Failed to extract Gemini response text: {e}")
+
+    if not raw:
+        logger.error("Empty regenerate response from Gemini for business '%s'", b.business_name)
+        raise RuntimeError("Empty response received from Gemini")
+
+    # Extract JSON and validate (reuse helper)
+    json_snippet = _extract_json_array(raw)
+    logger.info("Attempting to parse regenerated JSON snippet for business '%s' (len=%d)",
+                b.business_name, len(json_snippet))
+
+    try:
+        parsed = json.loads(json_snippet)
+
+        # If wrapper -> find list
+        if isinstance(parsed, dict):
+            for key in ("items", "personas", "data", "results"):
+                if key in parsed and isinstance(parsed[key], list):
+                    parsed = parsed[key]
+                    logger.debug("Found regenerated persona list inside wrapper key '%s'", key)
+                    break
+
+        if not isinstance(parsed, list):
+            logger.error("Parsed regenerated JSON is not a list (type=%s)", type(parsed))
+            raise ValueError("Expected top-level JSON array of persona objects (regenerate)")
+
+        personas: List[Persona] = []
+        for idx, obj in enumerate(parsed):
+            try:
+                persona = Persona.parse_obj(obj)
+                personas.append(persona)
+                logger.debug("Validated regenerated persona %d: %s", idx, persona.name)
+            except ValidationError as ve:
+                logger.error("Regenerated persona validation failed for index %d: %s\nRaw item: %s",
+                             idx, ve, obj)
+                raise
+
+        logger.info("Successfully regenerated %d personas for business '%s'", len(personas), b.business_name)
+        return personas
+
+    except (json.JSONDecodeError, ValidationError, ValueError) as e:
+        logger.exception("Failed to parse/validate regenerated Gemini JSON output for business '%s'", b.business_name)
+        raise RuntimeError(
+            f"Failed to parse Gemini regenerate response as JSON Personas: {e}\n\nRaw Gemini response:\n{raw}"
+        )

app/ads/schemas.py

@@ -0,0 +1,104 @@
+# app/ads/schemas.py
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class GoalEnum(str, Enum):
+    GET_MORE_WEBSITE_VISITORS = (
+        "Get more website visitors",
+        "Drive quality traffic to your website and increase page views"
+    )
+    GENERATE_LEADS = (
+        "Generate Leads",
+        "Collect contact information from potential customers"
+    )
+    INCREASE_SALES = (
+        "Increase Sales",
+        "Drive purchases and boost your revenue"
+    )
+    BRAND_AWARENESS = (
+        "Brand Awareness",
+        "Increase visibility and recognition of your brand"
+    )
+
+    def __new__(cls, value, description):
+        obj = str.__new__(cls, value)
+        obj._value_ = value
+        obj.description = description
+        return obj
+
+class Persona(BaseModel):
+    name: str
+    headline: str
+    age_range: str
+    location: str
+    interests: List[str]
+    description: str
+
+class BusinessInput(BaseModel):
+    business_name: str = Field(..., example="GrowthAspired")
+    business_category: str = Field(..., example="Software House")
+    business_description: str
+    promotion_type: str
+    offer_description: str
+    value: str
+    main_goal: GoalEnum = Field(..., description="Primary marketing goal (enum)", example=GoalEnum.GENERATE_LEADS.value)
+    serving_clients_info: str
+    serving_clients_location: str
+    num_personas: int = 3
+
+
+class RegenerateRequest(BusinessInput):
+    """
+    Request model for regenerating personas:
+    - includes the same business inputs as BusinessInput
+    - plus previous_personas (list of Persona objects) to inform regeneration
+    """
+    previous_personas: List[Persona]
+
+
+class HeadingsRequest(BaseModel):
+    business_name: str = Field(..., example="GrowthAspired")
+    business_category: str = Field(..., example="Software House")
+    business_description: str
+    promotion_type: str
+    offer_description: str
+    value: str
+    main_goal: GoalEnum = Field(..., description="Primary marketing goal (enum)")
+    serving_clients_info: str
+    serving_clients_location: str
+    # list of previously generated or selected persona objects (use Persona model)
+    selected_personas: List[Persona] = Field(..., description="List of selected persona objects to target")
+    # optional: prefer number of headings (defaults to 4)
+    num_headings: Optional[int] = Field(4, description="How many headings to generate")
+
+
+class DescriptionsRequest(BaseModel):
+    business_name: str = Field(..., example="GrowthAspired")
+    business_category: str = Field(..., example="Software House")
+    business_description: str
+    promotion_type: str
+    offer_description: str
+    value: str
+    main_goal: GoalEnum = Field(..., description="Primary marketing goal (enum)")
+    serving_clients_info: str
+    serving_clients_location: str
+    selected_personas: List[Persona] = Field(..., description="List of selected persona objects to target")
+    num_descriptions: Optional[int] = Field(4, description="How many ad descriptions to generate (default 4)")
+
+
+class ImageRequest(BaseModel):
+    business_name: str = Field(..., example="GrowthAspired")
+    business_category: str = Field(..., example="Software House")
+    business_description: str
+    promotion_type: str
+    offer_description: str
+    value: str
+    main_goal: GoalEnum = Field(..., description="Primary marketing goal (enum)")
+    serving_clients_info: str
+    serving_clients_location: str
+    selected_personas: List[Persona] = Field(..., description="List of selected persona objects to target")
+    # optional style/size params
+    style: Optional[str] = Field("modern", description="Desired art style or mood (e.g. modern, minimal, illustrative)")
+    width: Optional[int] = Field(1200, description="Image width in px")
+    height: Optional[int] = Field(628, description="Image height in px")

app/main.py

@@ -21,7 +21,7 @@ from app.content_relevence import routes as content_relevance_routes
 from app.keywords.routes import router as keywords_router
 from app.uiux import routes as uiux_routes
 from app.mobile_usability import routes as mobile_usability
-
+from app.ads.persona_routes import router as persona_router
 # ─────────────────────────────────────────────
 # Suppress warnings
 # ─────────────────────────────────────────────
@@ -82,6 +82,7 @@ app.include_router(page_speed_routes.router)
 app.include_router(keywords_router)
 app.include_router(uiux_routes.router)
 app.include_router(mobile_usability.router)
+app.include_router(persona_router)
 
 # CORS
 app.add_middleware(

app/rag/embeddings.py

@@ -1,24 +1,68 @@
 import os
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from dotenv import load_dotenv
+from typing import Any, Optional
+import logging
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
 
-load_dotenv()  
+def get_llm(model: str = "gemini-2.5-flash",
+            temperature: float = 0.0,
+            max_tokens: Optional[int] = None,
+            timeout: Optional[int] = None,
+            max_retries: int = 3) -> Any:
+    """
+    Return a LangChain ChatGoogleGenerativeAI LLM configured to use Gemini.
 
+    - Reads GEMINI_API_KEY from environment.
+    - Default model: 'gemini-2.5-flash' (change if you need another).
+    - Temperature default 0 for deterministic responses.
+    - max_tokens/timeout can be None to allow defaults from the underlying client.
 
-def get_llm():
-    """
-    Returns a ChatGroq LLM instance using the GROQ API key
-    stored in the environment.
+    Returns:
+        An instance of langchain.chat_models.ChatGoogleGenerativeAI (or raises informative error).
     """
-    from langchain_groq import ChatGroq
-
-    llm = ChatGroq(
-        model="openai/gpt-oss-120b",
-        temperature=0,
-        max_tokens=1024,
-        api_key=os.getenv("GROQ_API_KEY", "")  
-    )
-    return llm
+    try:
+        from langchain_google_genai import ChatGoogleGenerativeAI
+    except Exception as e:
+        logger.exception("langchain ChatGoogleGenerativeAI import failed")
+        raise RuntimeError(
+            "langchain (with ChatGoogleGenerativeAI) is required but not installed. "
+            "Install with: pip install 'langchain[google]' or refer to your LangChain version docs."
+        ) from e
+
+    # Prefer explicit environment variable or other configured setting
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        msg = "GEMINI_API_KEY environment variable not set. Set it to your Gemini API key."
+        logger.error(msg)
+        raise RuntimeError(msg)
+
+    # Build client config
+    try:
+        llm = ChatGoogleGenerativeAI(
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            max_retries=max_retries,
+            api_key=api_key,
+        )
+        logger.info("Initialized ChatGoogleGenerativeAI LLM (model=%s)", model)
+        return llm
+    except TypeError:
+        # Some langchain versions may accept different parameter names (api_key vs openai_api_key etc.)
+        # Try a safer fallback with only the most common args.
+        try:
+            llm = ChatGoogleGenerativeAI(model=model, temperature=temperature, api_key=api_key)
+            logger.info("Initialized ChatGoogleGenerativeAI LLM (fallback constructor) model=%s", model)
+            return llm
+        except Exception as e:
+            logger.exception("Failed to create ChatGoogleGenerativeAI instance")
+            raise RuntimeError(f"Failed to initialize Gemini LLM: {e}") from e
+    except Exception as e:
+        logger.exception("Failed to initialize Gemini LLM")
+        raise RuntimeError(f"Failed to initialize Gemini LLM: {e}") from e
+
 
 # ──────────────────────────────────────────────────────────────────────────────
 # 1. Text Splitter (512 tokens per chunk, 100 token overlap)