El flujo completo de contenido con IA: de la idea a la publicación

TENDENCIA → INVESTIGACIÓN → ESQUEMA → TEXTO → ADAPTACIONES → IMAGEN → VIDEO → VOZ → PUBLICACIÓN

{
  "brand": {
    "name": "Acme Realty",
    "voice": "Experto amable. No un vendedor. Datos + historias.",
    "audience": "Personas de 35 a 55 años que piensan mudarse a Ecuador o invertir ahí",
    "languages": ["es"],
    "channels": ["newsletter", "youtube", "instagram", "linkedin"]
  },
  "week": "2026-10-05",
  "posts": [
    {
      "id": "post-001",
      "publish_at": "2026-10-05T09:00:00-05:00",
      "topic": "Cuánto cuesta de verdad vivir en Cuenca en 2026",
      "content_type": "educational",
      "formats": {
        "blog": { "words": 1200, "status": "pending" },
        "newsletter": { "sections": 3, "status": "pending" },
        "youtube_script": { "duration_min": 8, "status": "pending" },
        "twitter": { "tweets": 5, "status": "pending" },
        "linkedin": { "status": "pending" }
      },
      "assets": {
        "cover_image": null,
        "short_video": null,
        "voice_over": null
      },
      "keywords": ["costo de vida en Cuenca", "costo de vida en Ecuador", "mudarse a Ecuador"],
      "approved": false
    }
  ]
}

import anthropic
import json
import os

claude = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])


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_main_article(topic: str, keywords: list[str],
                           brand_voice: str, word_count: int = 1200) -> str:
    """Genera un artículo completo optimizado para SEO con Claude Sonnet."""
    response = claude.messages.create(
        model="claude-sonnet-5-5",  # IDs de modelo vigentes: revisa la documentación de Anthropic
        max_tokens=8000,  # con margen: el "razonamiento" del modelo también cuenta para este límite
        messages=[{
            "role": "user",
            "content": f"""Escribe un artículo de blog.

Tema: {topic}
Extensión: {word_count} palabras
Palabras clave SEO: {', '.join(keywords)}
Voz de la marca: {brand_voice}

Estructura:
1. Título H1 (con la palabra clave principal)
2. Introducción (150 palabras, un gancho + una promesa)
3. 3–4 secciones H2 con datos y cifras concretas
4. Consejos prácticos (lista con viñetas)
5. Conclusión + llamado a la acción

Requisitos:
- Solo datos, sin relleno como "esto es muy importante"
- Cifras y ejemplos concretos; no inventes cifras: si no tienes datos sólidos, marca el lugar como "por verificar"
- Tono conversacional pero experto
- Idioma: español neutro de América Latina, formato Markdown"""
        }]
    )
    return text_of(response)


def adapt_to_all_platforms(main_article: str, brand_context: str,
                            topic: str) -> dict:
    """
    Convierte un artículo base en contenido para cada plataforma.
    Claude Haiku: rápido y barato (un par de centavos).
    """
    response = claude.messages.create(
        model="claude-haiku-4-5",  # Haiku 4.5: su retiro de la API es posible no antes del 15 de octubre de 2026; revisa los IDs en la documentación de Anthropic
        max_tokens=6000,
        messages=[{
            "role": "user",
            "content": f"""Eres el estratega de contenido de la marca. Marca: {brand_context}

Artículo principal sobre el tema "{topic}":
---
{main_article}
---

Adáptalo a los siguientes formatos. Devuelve SOLO JSON válido, sin explicaciones y sin triples comillas invertidas alrededor:

{{
  "newsletter": {{
    "subject_line": "Asunto (corto y concreto)",
    "sections": [
      "Sección 1: la historia principal (hasta 1,000 caracteres, con emoji, amigable)",
      "Sección 2: profundiza en una idea (800 caracteres)",
      "Sección 3: un consejo práctico + llamado a la acción (600 caracteres)"
    ]
  }},
  "twitter_thread": [
    "Publicación 1/5: gancho (hasta 280 caracteres)",
    "Publicación 2/5: dato clave",
    "Publicación 3/5: un ejemplo o una historia",
    "Publicación 4/5: un ángulo inesperado",
    "Publicación 5/5: conclusión + enlace"
  ],
  "linkedin_post": "Versión para LinkedIn (300–400 palabras, tono profesional)",
  "instagram_caption": "Versión para Instagram (150–200 palabras + 15 hashtags)",
  "youtube_description": "Descripción para YouTube (300 palabras, marcas de tiempo, palabras clave)"
}}"""
        }]
    )
    return json.loads(text_of(response))


def generate_youtube_script(topic: str, duration_minutes: int,
                              brand_voice: str) -> str:
    """Genera el guion de un video de YouTube con marcas de tiempo."""
    words_per_minute = 130    # un ritmo de habla típico; mídete y ajústalo
    target_words = duration_minutes * words_per_minute

    response = claude.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=8000,
        messages=[{
            "role": "user",
            "content": f"""Escribe el guion de un video de YouTube.

Tema: {topic}
Duración: {duration_minutes} min (~{target_words} palabras)
Voz: {brand_voice}

Formato de cada bloque:
[MM:SS] TÍTULO DEL BLOQUE
(Nota de dirección: qué mostrar en pantalla / tomas de apoyo)
Texto del presentador...

Estructura:
[00:00] GANCHO: los primeros 30 segundos, la parte más importante
[00:30] INTRO: quién es el presentador, de qué trata el video
[01:00] PARTE PRINCIPAL: 3–4 bloques de 2–3 minutos cada uno
[{duration_minutes-1}:00] CIERRE: resumen + llamado a la acción
[{duration_minutes-1}:30] DESPEDIDA: suscríbete, siguiente video

Escribe de forma viva y conversacional, como si le hablaras a un amigo."""
        }]
    )
    return text_of(response)

import asyncio
from telegram import Bot, InputFile
import os

TELEGRAM_BOT_TOKEN = os.environ["TELEGRAM_BOT_TOKEN"]
CHANNEL_ID = os.environ["TELEGRAM_CHANNEL_ID"]


async def publish_to_telegram(text: str, image_path: str = None) -> dict:
    """Publica en un canal de Telegram."""
    bot = Bot(token=TELEGRAM_BOT_TOKEN)

    if image_path:
        with open(image_path, "rb") as img:
            message = await bot.send_photo(
                chat_id=CHANNEL_ID,
                photo=InputFile(img),
                caption=text,
                parse_mode="Markdown"
            )
    else:
        message = await bot.send_message(
            chat_id=CHANNEL_ID,
            text=text,
            parse_mode="Markdown"
        )

    return {"message_id": message.message_id, "date": str(message.date)}


# Para correrlo: asyncio.run(publish_to_telegram("Publicación de prueba"))
# El bot tiene que ser administrador del canal; TELEGRAM_CHANNEL_ID es la dirección del canal, como @tu_canal

import json
import os
import requests

BUFFER_API_KEY = os.environ["BUFFER_API_KEY"]
BUFFER_CHANNEL_IDS = {
    "instagram": os.environ["BUFFER_INSTAGRAM_CHANNEL_ID"],
    "linkedin": os.environ["BUFFER_LINKEDIN_CHANNEL_ID"],
    "twitter": os.environ["BUFFER_TWITTER_CHANNEL_ID"],
}


def schedule_to_buffer(text: str, platform: str, due_at: str) -> dict:
    """
    Programa una publicación con la API de Buffer (GraphQL).
    due_at: hora de publicación en formato ISO 8601, UTC, por ejemplo 2026-10-12T14:00:00.000Z
    Los archivos multimedia se mandan a la API de Buffer como un enlace público: revisa la documentación.
    """
    query = f"""
    mutation {{
      createPost(input: {{
        text: {json.dumps(text, ensure_ascii=False)},
        channelId: "{BUFFER_CHANNEL_IDS[platform]}",
        schedulingType: automatic,
        mode: customScheduled,
        dueAt: "{due_at}"
      }}) {{
        ... on PostActionSuccess {{ post {{ id dueAt }} }}
        ... on MutationError {{ message }}
      }}
    }}
    """
    response = requests.post(
        "https://api.buffer.com",
        headers={"Authorization": f"Bearer {BUFFER_API_KEY}"},
        json={"query": query},
    )
    return response.json()

Ejecución programada (lunes 09:00)
  → HTTP: leer content-calendar.json desde GitHub
  → Code: quedarse solo con approved: true
  → Loop: para cada publicación:
    → API de Claude: generar el artículo (Sonnet)
    → API de Claude: adaptaciones por plataforma (Haiku) [en paralelo]
    → Generación de imagen: portada [en paralelo]
    → API de Buffer: programar LinkedIn y Twitter/X
    → Plataforma de boletines: guardar la edición como borrador
    → Google Docs: guardar todo para una revisión final
  → Aviso por Slack o correo: "X publicaciones listas, esperando revisión"

#!/usr/bin/env bash
# content-factory-orchestrator.sh
# Córrelo desde la carpeta del proyecto: bash content-factory-orchestrator.sh (necesita la herramienta jq)
set -euo pipefail

WEEK_DATE="${1:-$(date +%Y-%m-%d)}"
CALENDAR_FILE="content-calendar.json"
OUTPUT_DIR="./content-output/${WEEK_DATE}"

mkdir -p "$OUTPUT_DIR"
log() { echo "[$(date +%H:%M:%S)] $1"; }

log "🏭 La fábrica de contenido arrancó. Semana: $WEEK_DATE"

POSTS=$(jq -r '.posts[] | select(.approved == true) | .id' "$CALENDAR_FILE")

if [ -z "$POSTS" ]; then
    log "⚠️ No hay publicaciones aprobadas. Deteniendo."
    exit 0
fi

for POST_ID in $POSTS; do
    log "▶️ Procesando: $POST_ID"
    POST_DIR="${OUTPUT_DIR}/${POST_ID}"
    mkdir -p "$POST_DIR"

    TOPIC=$(jq -r ".posts[] | select(.id == \"$POST_ID\") | .topic" "$CALENDAR_FILE")
    KEYWORDS=$(jq -r ".posts[] | select(.id == \"$POST_ID\") | .keywords | join(\", \")" "$CALENDAR_FILE")
    PUBLISH_AT=$(jq -r ".posts[] | select(.id == \"$POST_ID\") | .publish_at" "$CALENDAR_FILE")

    log "  Tema: $TOPIC"

    # Artículo y guion de YouTube en paralelo
    python3 scripts/generate_article.py --topic "$TOPIC" --keywords "$KEYWORDS" \
        --output "${POST_DIR}/article.md" &
    python3 scripts/generate_script.py --topic "$TOPIC" --duration 8 \
        --output "${POST_DIR}/youtube-script.md" &

    wait

    # Adaptaciones e imagen de portada en paralelo
    python3 scripts/adapt_platforms.py --article "${POST_DIR}/article.md" \
        --output "${POST_DIR}/adaptations.json" &
    python3 scripts/generate_image.py --topic "$TOPIC" \
        --output "${POST_DIR}/cover.jpg" &

    wait
    log "  ✅ El contenido de $POST_ID está listo"

    # Programar las publicaciones
    python3 scripts/schedule_content.py --post-id "$POST_ID" \
        --adaptations "${POST_DIR}/adaptations.json" \
        --cover "${POST_DIR}/cover.jpg" \
        --publish-at "$PUBLISH_AT"
done

log "🎉 ¡Listo! Publicaciones programadas: $(echo "$POSTS" | wc -w)"

def run_analytics_loop(days_back: int = 7) -> dict:
    """
    Reúne las métricas de la semana pasada y genera temas para la próxima semana.
    """
    # get_*_stats() y update_calendar_with_recommendations() aquí solo están nombradas:
    # escríbelas para tus propias plataformas (o pídeselo a Claude)
    newsletter_stats = get_newsletter_stats(days_back)
    youtube_stats = get_youtube_stats(days_back)
    instagram_stats = get_instagram_stats(days_back)

    combined_stats = {
        "newsletter": newsletter_stats,
        "youtube": youtube_stats,
        "instagram": instagram_stats,
        "period_days": days_back,
    }

    response = claude.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=6000,
        messages=[{
            "role": "user",
            "content": f"""Eres analista de estrategia de contenido.
Analiza los resultados de los últimos {days_back} días:

{json.dumps(combined_stats, ensure_ascii=False, indent=2)}

Da un análisis estructurado. Devuelve solo JSON, sin explicaciones y sin triples comillas invertidas alrededor:
{{
  "winners": ["publicación + por qué funcionó"],
  "flops": ["publicación + por qué no pegó"],
  "patterns": ["qué tipo de contenido funciona de forma constante"],
  "best_time": {{"newsletter": "HH:MM", "instagram": "HH:MM"}},
  "next_week_topics": ["tema 1", "tema 2", "tema 3", "tema 4", "tema 5"],
  "strategy_changes": ["qué cambiar en el proceso de producción"]
}}

Usa solo los datos de estas estadísticas; no inventes nada."""
        }]
    )

    recommendations = json.loads(text_of(response))
    update_calendar_with_recommendations(recommendations)
    return recommendations

mkdir -p content-factory/{scripts,templates,logs}
cd content-factory
touch content-calendar.json content-factory-orchestrator.sh .env \
      scripts/generate_article.py scripts/generate_script.py \
      scripts/adapt_platforms.py scripts/generate_image.py \
      scripts/schedule_content.py

pip install python-telegram-bot