IA para publicidad: textos de anuncios, pruebas A/B e informes

import anthropic
import json


def text_of(response) -> str:
    """Junta el texto de la respuesta: los modelos nuevos pueden poner bloques de "razonamiento" antes del texto."""
    return "".join(block.text for block in response.content if block.type == "text")


def generate_ad_variants(
    product: str,
    target_audience: str,
    key_benefit: str,
    platform: str,
    count: int = 10
) -> list:
    """Genera variantes de texto para anuncios"""

    client = anthropic.Anthropic()

    # Largo recomendado de los textos según las páginas de ayuda de Meta y Google Ads, a octubre de 2026.
    # Cambia: compruébalo en la ayuda de cada plataforma antes de lanzar
    platform_specs = {
        "facebook": {
            "headline_chars": 27,       # titular en el feed de Facebook
            "primary_text_chars": 150,  # texto principal: Meta sugiere 50-150 caracteres
        },
        "google_rsa": {
            "headline_chars": 30,
            "description_chars": 90,
            "headline_count": 15
        },
        "instagram": {
            "caption_chars": 2200,
            "first_line_chars": 125  # lo que se ve antes de "más"
        }
    }

    specs = platform_specs.get(platform, platform_specs["facebook"])

    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,  # con margen: el "razonamiento" del modelo también cuenta para este límite
        messages=[{
            "role": "user",
            "content": f"""Crea {count} variantes de anuncio para {platform}.

Producto: {product}
Público objetivo: {target_audience}
Beneficio principal: {key_benefit}
Límites de la plataforma: {json.dumps(specs, ensure_ascii=False)}

Usa un enfoque distinto en cada variante:
- Emocional (miedo a quedarse fuera)
- Racional (números y hechos)
- Prueba social (reseñas, clientes)
- Curiosidad (una pregunta o un dato sorprendente)
- Directo (el beneficio, dicho sin rodeos)

Usa solo afirmaciones que sean ciertas para este producto. No inventes números, reseñas ni cantidades de clientes.

Devuelve solo un arreglo JSON, sin explicaciones y sin triples comillas invertidas alrededor:
[
  {{
    "variant_id": 1,
    "approach": "nombre del enfoque",
    "headline": "titular",
    "primary_text": "texto principal",
    "cta": "llamado a la acción",
    "target_emotion": "la emoción que busca",
    "hypothesis": "por qué debería funcionar"
  }}
]"""
        }]
    )

    return json.loads(text_of(response))


# Ejemplo: un producto inventado
variants = generate_ad_variants(
    product="Curso de Excel en línea para profesionales de finanzas",
    target_audience="Contadores y personal de finanzas de 25 a 45 años que dedican 2-3 horas a los informes",
    key_benefit="Bajar el tiempo de un informe de 3 horas a 20 minutos",
    platform="facebook",
    count=10
)

for v in variants[:3]:
    print(f"\n--- Variante {v['variant_id']}: {v['approach']} ---")
    print(f"Titular: {v['headline']}")
    print(f"Texto: {v['primary_text']}")
    print(f"CTA: {v['cta']}")

1. Claude → 10 variantes de texto
2. Flux / Midjourney / el generador de imágenes de ChatGPT → una imagen para cada texto
3. Lanza una prueba A/B (5 variantes a la vez)
4. 3-5 días → junta datos
5. Claude → analiza los resultados
6. Escala al ganador

def create_meta_campaign_brief(
    product: str,
    budget_daily: float,
    target_audience_description: str
) -> str:
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,
        messages=[{
            "role": "user",
            "content": f"""Crea un plan detallado para una campaña de Meta Ads.

Producto: {product}
Presupuesto diario: ${budget_daily}
Público: {target_audience_description}

Incluye:
1. **Estructura de la campaña**: cuántos conjuntos de anuncios y la lógica detrás
2. **Segmentación**: intereses detallados, edad, ubicación
3. **Recomendaciones de públicos similares**: en quién basar un público similar (lookalike)
4. **Formatos**: qué formatos de anuncio usar y por qué
5. **Presupuesto**: cómo repartirlo entre los conjuntos de anuncios
6. **KPI**: qué cuenta como éxito (CPC, CTR, CPL)
7. **Plan de pruebas**: qué probar primero

Sé específico: números, porcentajes, recomendaciones."""
        }]
    )

    return text_of(response)

def generate_google_rsa(
    product: str,
    landing_page_theme: str,
    keywords: list[str]
) -> dict:
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,
        messages=[{
            "role": "user",
            "content": f"""Crea un anuncio RSA para Google Ads.

Producto: {product}
Tema de la página de destino: {landing_page_theme}
Palabras clave: {', '.join(keywords)}

Requisitos:
- 15 titulares, cada uno de hasta 30 caracteres
- 4 descripciones, cada una de hasta 90 caracteres
- Los titulares deben funcionar bien en cualquier combinación
- Pon las palabras clave en 3-4 titulares (¡no en todos!)
- Variedad: beneficios, acciones, lo que te hace diferente, urgencia

Devuelve solo JSON, sin explicaciones y sin triples comillas invertidas alrededor:
{{
    "headlines": ["titular 1", ... "titular 15"],
    "descriptions": ["descripción 1", ... "descripción 4"],
    "pinning_recommendations": {{
        "headline_position_1": "qué titular fijar en la posición 1",
        "reason": "por qué"
    }}
}}"""
        }]
    )

    return json.loads(text_of(response))


# Ejemplo: un despacho de abogados
rsa = generate_google_rsa(
    product="Servicios legales inmobiliarios",
    landing_page_theme="Cierra la compra de tu casa de forma rápida y segura",
    keywords=["abogado inmobiliario", "escrituración de inmuebles", "abogado para comprar casa"]
)

print("Titulares:")
for i, h in enumerate(rsa["headlines"], 1):
    chars = len(h)
    status = "✅" if chars <= 30 else "⚠️"
    print(f"{i}. {status} {h} ({chars} caracteres)")

def analyze_ab_test(test_results: list[dict]) -> dict:
    """
    test_results: una lista de diccionarios con los resultados de cada variante
    Ejemplo: [{"variant": "A", "impressions": 5000, "clicks": 150, "conversions": 12, "spend": 200}]
    """
    client = anthropic.Anthropic()

    # Agrega las métricas calculadas
    for r in test_results:
        r["ctr"] = round(r["clicks"] / r["impressions"] * 100, 2)
        r["cpc"] = round(r["spend"] / r["clicks"], 2) if r["clicks"] > 0 else 0
        r["cpl"] = round(r["spend"] / r["conversions"], 2) if r["conversions"] > 0 else 0
        r["cvr"] = round(r["conversions"] / r["clicks"] * 100, 2) if r["clicks"] > 0 else 0

    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,
        messages=[{
            "role": "user",
            "content": f"""Analiza los resultados de esta prueba A/B de anuncios y dame recomendaciones.

Resultados:
{json.dumps(test_results, ensure_ascii=False, indent=2)}

Necesito:
1. **Ganador**: qué variante es mejor y POR QUÉ (considera todas las métricas)
2. **Significancia estadística**: si hay suficientes datos para una conclusión confiable
3. **Aprendizajes**: qué dicen los resultados sobre el público
4. **Siguiente paso**: qué probar después
5. **Escalamiento**: cuánto aumentar el presupuesto del ganador

Sé específico: da números y porcentajes."""
        }]
    )

    return {
        "raw_results": test_results,
        "analysis": text_of(response)
    }


# Una prueba con datos inventados
results = [
    {"variant": "A — Miedo (pérdida)", "impressions": 10000, "clicks": 180, "conversions": 9, "spend": 350},
    {"variant": "B — Beneficio (ahorro)", "impressions": 10000, "clicks": 220, "conversions": 18, "spend": 350},
    {"variant": "C — Prueba social", "impressions": 10000, "clicks": 195, "conversions": 14, "spend": 350}
]

analysis = analyze_ab_test(results)
print(analysis["analysis"])
# Ejemplo de respuesta para estos datos:
# Ganador: B — CTR 2.2%, CPL $19.4, CVR 8.2%
# La variante A pierde a pesar de su titular intrigante
# Recomendación: todavía hay pocos datos (9 y 18 conversiones); deja correr la prueba y sube poco a poco el presupuesto de B

def create_pmax_assets(
    product: str,
    key_benefits: list[str],
    audience_persona: str
) -> dict:
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,
        messages=[{
            "role": "user",
            "content": f"""Crea todos los materiales (recursos) que necesita una campaña de Performance Max.

Producto: {product}
Beneficios principales: {', '.join(key_benefits)}
Perfil del público: {audience_persona}

Devuelve solo JSON, sin explicaciones y sin triples comillas invertidas alrededor:
{{
    "headlines": ["5 titulares de hasta 30 caracteres, al menos uno de hasta 15"],
    "long_headlines": ["5 titulares largos de hasta 90 caracteres"],
    "descriptions": ["5 descripciones de hasta 90 caracteres"],
    "business_name": "nombre de la empresa (hasta 25 caracteres)",
    "call_to_actions": ["una lista de 5 llamados a la acción"],
    "image_prompts": ["5 prompts para generar imágenes en Midjourney/Flux"],
    "audience_signals": {{
        "interests": ["una lista de intereses para las señales de público"],
        "custom_intent_keywords": ["palabras clave de intención"],
        "remarketing_segments": ["segmentos de remarketing"]
    }}
}}"""
        }]
    )

    return json.loads(text_of(response))

# En Claude Code, con Adspirer MCP conectado:

"Muéstrame las campañas con un CTR menor a 1% en los últimos 7 días"
→ Claude ve los datos → te da una lista con recomendaciones

"¿Qué palabras clave están gastando dinero sin ninguna conversión?"
→ Claude lo analiza → una lista de palabras clave para pausar

"Crea un informe de ROI de todas las campañas del mes"
→ Claude lo genera → comparación, conclusiones, recomendaciones

def generate_weekly_ad_report(campaigns_data: dict) -> str:
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,
        messages=[{
            "role": "user",
            "content": f"""Genera un informe semanal de las campañas de anuncios.

Datos:
{json.dumps(campaigns_data, ensure_ascii=False, indent=2)}

Formato del informe:
## Resultados de esta semana
[3-4 números clave]

## Qué está funcionando
[las 3 cosas que mejor funcionaron, con números]

## Qué no está funcionando
[los 3 problemas principales, con números]

## Acciones para la próxima semana
[5 pasos concretos, con el efecto esperado]

## Presupuesto
[recomendaciones para redistribuirlo]

Escribe como analista: concreto, con números, sin relleno. Toma los números solo de los datos."""
        }]
    )

    return text_of(response)

# ad_generator.py

import anthropic
import json

client = anthropic.Anthropic()


def text_of(response) -> str:
    """Junta el texto de la respuesta: los modelos nuevos pueden poner bloques de "razonamiento" antes del texto."""
    return "".join(block.text for block in response.content if block.type == "text")


def create_ad_batch(product_info: dict) -> list:
    """Crea un lote de anuncios para probar"""

    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,
        messages=[{
            "role": "user",
            "content": f"""Crea 10 variantes de anuncio para Facebook.

PRODUCTO: {product_info['name']}
DESCRIPCIÓN: {product_info['description']}
PRECIO: {product_info['price']}
PÚBLICO: {product_info['audience']}
BENEFICIO PRINCIPAL: {product_info['main_benefit']}
PROBLEMA DEL PÚBLICO: {product_info['pain_point']}

Crea 2 variantes para cada enfoque:
1. Miedo a perder ("si no haces X, vas a perder Y")
2. Beneficio ("consigue X y ahorra Y")
3. Prueba social ("1,000 clientes ya...")
4. Curiosidad ("¿Sabías que...?")
5. Oferta directa ("Obtén X por Y ahora mismo")

Usa solo hechos de la información del producto de arriba. No inventes números, reseñas ni cantidades de clientes.

Devuelve solo JSON, sin explicaciones y sin triples comillas invertidas alrededor:
[{{
    "id": 1,
    "approach": "nombre",
    "headline": "hasta 27 caracteres",
    "text": "hasta 150 caracteres",
    "cta": "botón",
    "image_direction": "qué debe mostrar la imagen"
}}]"""
        }]
    )

    return json.loads(text_of(response))

# Pon tu propio producto (el ejemplo de abajo es inventado)
my_product = {
    "name": "Escuela en línea de inglés de negocios para profesionales de tecnología",
    "description": "Inglés para trabajar en equipos de EE. UU., en 3 meses",
    "price": "$99/mes",
    "audience": "Desarrolladores y profesionales de TI de 25 a 40 años para quienes el inglés es su segundo idioma",
    "main_benefit": "Sentirte seguro en entrevistas de trabajo y en reuniones de equipo",
    "pain_point": "Sé inglés técnico, pero me pierdo en reuniones rápidas con hablantes nativos"
}

ads = create_ad_batch(my_product)

print("=== ANUNCIOS GENERADOS ===\n")
for ad in ads:
    print(f"#{ad['id']} — {ad['approach']}")
    print(f"Titular: {ad['headline']}")
    print(f"Texto: {ad['text']}")
    print(f"CTA: {ad['cta']}")
    print(f"Imagen: {ad['image_direction']}")
    print()

# Captura tus datos reales después de 5 días de prueba (los números de abajo son inventados)
test_data = [
    {"id": 1, "approach": "Miedo a perder", "impressions": 8500, "clicks": 102, "conversions": 4, "spend": 180},
    {"id": 2, "approach": "Miedo a perder 2", "impressions": 8200, "clicks": 115, "conversions": 5, "spend": 175},
    {"id": 3, "approach": "Beneficio", "impressions": 8800, "clicks": 185, "conversions": 12, "spend": 182},
    {"id": 4, "approach": "Beneficio 2", "impressions": 8600, "clicks": 172, "conversions": 10, "spend": 178},
    {"id": 5, "approach": "Prueba social", "impressions": 8300, "clicks": 166, "conversions": 11, "spend": 176},
    {"id": 6, "approach": "Prueba social 2", "impressions": 8700, "clicks": 143, "conversions": 8, "spend": 181},
    {"id": 7, "approach": "Curiosidad", "impressions": 9100, "clicks": 228, "conversions": 7, "spend": 185},
    {"id": 8, "approach": "Curiosidad 2", "impressions": 8900, "clicks": 214, "conversions": 6, "spend": 183},
    {"id": 9, "approach": "Oferta directa", "impressions": 8400, "clicks": 126, "conversions": 9, "spend": 177},
    {"id": 10, "approach": "Oferta directa 2", "impressions": 8600, "clicks": 138, "conversions": 8, "spend": 179}
]

analysis = analyze_ab_test(test_data)
print(analysis["analysis"])