# Creación de Contenido con IA - Guía Completa Técnica

## Introducción y Fundamentos

### Content Creation Automation
- **Definición**: Automatización completa del proceso de creación, desde ideación hasta publicación multicanal
- **Objetivo**: Producir contenido de alta calidad a escala sin intervención humana constante
- **Stack tecnológico**: IA generativa + automatización + APIs de redes sociales

### Arquitectura de Content Creation Pipeline
```
Content Triggers → Research & Analysis → Content Generation → 
Visual Creation → Multi-Platform Publishing → Performance Tracking
```

### Tipos de Contenido Automatizable
- **Social Media Posts**: LinkedIn, Instagram, Twitter/X, Facebook
- **Blog Articles**: SEO-optimized long-form content
- **Video Content**: Scripts, thumbnails, automated editing
- **Email Newsletters**: Personalized campaigns
- **Visual Assets**: Images, infographics, presentations
- **E-books**: Comprehensive guides and reports

## Social Media Automation

### Publicaciones Automáticas desde Noticias

#### Email-to-Content Pipeline:

**Mailhook Configuration (n8n/Make)**:
```json
{
  "trigger_type": "mailhook",
  "email_address": "content@your-webhook.make.com",
  "processing": "automatic",
  "expected_input": "news_url or article_text"
}
```

**Content Extraction Workflow**:
```
Mailhook → URL Extraction → Web Scraping → Article Analysis → 
Content Generation → Image Creation → Social Publishing
```

#### Web Scraping Implementation:

**HTTP Request para Artículos**:
```json
{
  "method": "GET",
  "url": "{{$json.extracted_url}}",
  "headers": {
    "User-Agent": "Mozilla/5.0 (compatible; ContentBot/1.0)",
    "Accept": "text/html,application/xhtml+xml"
  },
  "timeout": 30000
}
```

**Text Extraction & Cleaning**:
```javascript
// Code node para extraer contenido principal
const extractArticleContent = (htmlContent) => {
  const cheerio = require('cheerio');
  const $ = cheerio.load(htmlContent);
  
  // Remover elementos no deseados
  $('script, style, nav, header, footer, aside, .ads, .advertisement').remove();
  
  // Buscar contenido principal
  const contentSelectors = [
    'article', 
    '[role="main"]',
    '.post-content', 
    '.article-body',
    '.entry-content',
    'main'
  ];
  
  let mainContent = '';
  for (const selector of contentSelectors) {
    const content = $(selector).text().trim();
    if (content.length > mainContent.length) {
      mainContent = content;
    }
  }
  
  // Extraer metadatos
  const metadata = {
    title: $('h1').first().text() || $('title').text(),
    description: $('meta[name="description"]').attr('content') || '',
    author: $('meta[name="author"]').attr('content') || '',
    publishDate: $('meta[property="article:published_time"]').attr('content') || '',
    tags: $('meta[name="keywords"]').attr('content')?.split(',') || []
  };
  
  return {
    content: mainContent,
    metadata: metadata,
    wordCount: mainContent.split(' ').length
  };
};
```

#### Content Generation con IA:

**LinkedIn Post Generation**:
```json
{
  "model": "gpt-4o",
  "messages": [
    {
      "role": "system",
      "content": "Eres un expert content creator para LinkedIn B2B. Creas posts virales que educan y generan engagement. Usa hooks fuertes, storytelling y CTAs efectivos."
    },
    {
      "role": "user",
      "content": "Crea un post de LinkedIn basado en este artículo:\n\nTítulo: {{$json.article_title}}\nContenido: {{$json.article_content}}\n\nRequisitos:\n- Hook impactante en primera línea\n- 150-250 palabras\n- Tono profesional pero accesible\n- Incluir insights propios\n- CTA para engagement\n- 3-5 hashtags relevantes\n- Formato con saltos de línea y emojis estratégicos"
    }
  ],
  "max_tokens": 600,
  "temperature": 0.8
}
```

**Twitter Thread Generation**:
```json
{
  "model": "gpt-4o", 
  "messages": [
    {
      "role": "system",
      "content": "Convierte artículos en Twitter threads virales. Cada tweet máximo 280 caracteres. Usa numeración (1/n). Hook fuerte en primer tweet."
    },
    {
      "role": "user",
      "content": "Artículo: {{$json.article_content}}\n\nCrea thread de 5-8 tweets que resuma los puntos clave de manera viral y educativa."
    }
  ]
}
```

#### Visual Content Generation:

**DALL-E Image Creation**:
```json
{
  "model": "dall-e-3",
  "prompt": "Professional LinkedIn post image about {{$json.article_topic}}, modern flat design, technology theme, blue and white color palette, minimalist style, business professional aesthetic, 1080x1080 aspect ratio, clean typography space for overlay text",
  "size": "1024x1024",
  "quality": "hd",
  "style": "vivid"
}
```

**Alternative: Midjourney via API**:
```json
{
  "method": "POST",
  "url": "https://api.midjourney.com/v1/imagine",
  "headers": {
    "Authorization": "Bearer {{midjourney_api_key}}"
  },
  "body": {
    "prompt": "{{$json.generated_image_prompt}} --ar 1:1 --style modern --quality 2",
    "webhook_url": "{{$json.webhook_callback}}"
  }
}
```

### Multi-Platform Publishing

#### LinkedIn API Publishing:
```json
{
  "method": "POST",
  "url": "https://api.linkedin.com/v2/ugcPosts",
  "headers": {
    "Authorization": "Bearer {{linkedin_access_token}}",
    "Content-Type": "application/json"
  },
  "body": {
    "author": "urn:li:person:{{person_id}}",
    "lifecycleState": "PUBLISHED",
    "specificContent": {
      "com.linkedin.ugc.ShareContent": {
        "shareCommentary": {
          "text": "{{$json.linkedin_post_content}}"
        },
        "shareMediaCategory": "IMAGE",
        "media": [
          {
            "status": "READY",
            "description": {
              "text": "{{$json.image_alt_text}}"
            },
            "media": "{{$json.uploaded_image_urn}}"
          }
        ]
      }
    },
    "visibility": {
      "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
    }
  }
}
```

#### Twitter/X API v2:
```json
{
  "method": "POST",
  "url": "https://api.twitter.com/2/tweets",
  "headers": {
    "Authorization": "Bearer {{twitter_bearer_token}}",
    "Content-Type": "application/json"
  },
  "body": {
    "text": "{{$json.tweet_content}}",
    "media": {
      "media_ids": ["{{$json.uploaded_media_id}}"]
    },
    "reply_settings": "everyone"
  }
}
```

#### Instagram Graph API:
```json
{
  "method": "POST",
  "url": "https://graph.facebook.com/v18.0/{{instagram_business_account_id}}/media",
  "body": {
    "image_url": "{{$json.hosted_image_url}}",
    "caption": "{{$json.instagram_caption}}",
    "access_token": "{{instagram_access_token}}"
  }
}
```

## Blog Content Automation

### SEO-Optimized Article Generation

#### Keyword Research Integration:
```javascript
// Code node para research de keywords
const performKeywordResearch = async (topic) => {
  // Integración con SEMrush API
  const keywordData = await fetch(`https://api.semrush.com/?type=phrase_all&key=${API_KEY}&phrase=${topic}&database=us`);
  
  // Integración con Ahrefs API
  const competitorData = await fetch(`https://apiv2.ahrefs.com/v3/site-explorer/top-pages?target=${domain}&mode=domain`, {
    headers: { 'Authorization': `Bearer ${AHREFS_TOKEN}` }
  });
  
  // Análisis de trending topics
  const trendingTopics = await fetch(`https://serpapi.com/search.json?engine=google_trends&q=${topic}&api_key=${SERPAPI_KEY}`);
  
  return {
    primary_keywords: keywordData.results.slice(0, 5),
    long_tail_keywords: keywordData.results.filter(k => k.word_count > 3).slice(0, 10),
    trending_related: trendingTopics.interest_over_time,
    competitor_gaps: await findContentGaps(competitorData.pages)
  };
};
```

#### Article Structure Generation:
```json
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "Eres un expert SEO content strategist. Creas estructuras de artículos optimizadas para SEO y engagement."
    },
    {
      "role": "user",
      "content": "Tema principal: {{$json.main_topic}}\nKeywords primarias: {{$json.primary_keywords}}\nKeywords long-tail: {{$json.long_tail_keywords}}\nAudiencia objetivo: {{$json.target_audience}}\n\nCrea una estructura detallada de artículo con:\n1. Título SEO-optimized\n2. Meta descripción\n3. Outline de secciones con H2/H3\n4. Distribución natural de keywords\n5. Estimación de palabras por sección\n6. Sugerencias de enlaces internos"
    }
  ]
}
```

#### Content Generation by Sections:
```javascript
// Code node para generación por secciones
const generateArticleBySection = async (articleStructure) => {
  const sections = [];
  
  for (const section of articleStructure.sections) {
    const sectionContent = await fetch('/api/openai/chat/completions', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${OPENAI_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        model: 'gpt-4',
        messages: [
          {
            role: 'system',
            content: `Escribe la sección "${section.title}" para un artículo sobre "${articleStructure.main_topic}". Mantén el tono profesional pero accesible. Incluye datos, ejemplos y valor práctico.`
          },
          {
            role: 'user',
            content: `Sección: ${section.title}\nPalabras objetivo: ${section.target_words}\nKeywords a incluir: ${section.keywords.join(', ')}\nPuntos clave a cubrir: ${section.key_points.join(', ')}`
          }
        ],
        max_tokens: section.target_words * 1.5
      })
    });
    
    const result = await sectionContent.json();
    sections.push({
      title: section.title,
      content: result.choices[0].message.content,
      keywords_used: extractKeywords(result.choices[0].message.content, section.keywords)
    });
  }
  
  return sections;
};
```

### WordPress Integration

#### Automated Publishing:
```json
{
  "method": "POST", 
  "url": "https://your-site.com/wp-json/wp/v2/posts",
  "headers": {
    "Authorization": "Bearer {{wordpress_jwt_token}}",
    "Content-Type": "application/json"
  },
  "body": {
    "title": "{{$json.article_title}}",
    "content": "{{$json.formatted_content}}",
    "status": "publish",
    "categories": [{{$json.category_ids}}],
    "tags": [{{$json.tag_ids}}],
    "featured_media": "{{$json.featured_image_id}}",
    "meta": {
      "yoast_wpseo_title": "{{$json.seo_title}}",
      "yoast_wpseo_metadesc": "{{$json.meta_description}}",
      "yoast_wpseo_focuskw": "{{$json.focus_keyword}}"
    }
  }
}
```

#### Content Formatting for WordPress:
```javascript
// Code node para formateo de WordPress
const formatContentForWordPress = (sections) => {
  let formattedContent = '';
  
  sections.forEach(section => {
    // Añadir tabla de contenidos automática
    if (section.is_heading) {
      formattedContent += `\n\n<h2 id="${slugify(section.title)}">${section.title}</h2>\n\n`;
    } else {
      formattedContent += `\n\n<h3 id="${slugify(section.title)}">${section.title}</h3>\n\n`;
    }
    
    // Formatear contenido con párrafos
    const paragraphs = section.content.split('\n\n');
    paragraphs.forEach(paragraph => {
      if (paragraph.trim()) {
        formattedContent += `<p>${paragraph.trim()}</p>\n\n`;
      }
    });
    
    // Añadir enlaces internos automáticamente
    formattedContent = addInternalLinks(formattedContent, section.keywords);
  });
  
  // Añadir tabla de contenidos al principio
  const tableOfContents = generateTableOfContents(sections);
  formattedContent = tableOfContents + formattedContent;
  
  return formattedContent;
};
```

## Video Content Automation

### Script Generation & Video Creation

#### YouTube Video Scripts:
```json
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "Eres un expert YouTube scriptwriter. Creas scripts engaging que mantienen la audiencia hasta el final. Usas storytelling, hooks, y estructura probada."
    },
    {
      "role": "user",
      "content": "Tema: {{$json.video_topic}}\nDuración objetivo: {{$json.target_duration}} minutos\nAudiencia: {{$json.target_audience}}\nEstilo: {{$json.video_style}}\n\nCrea un script completo con:\n1. Hook potente (primeros 15 segundos)\n2. Introducción y preview de contenido\n3. Cuerpo principal con transiciones\n4. CTA y cierre memorable\n5. Indicaciones de B-roll y efectos visuales\n6. Timemarks estimados"
    }
  ],
  "max_tokens": 2000
}
```

#### Thumbnail Generation:
```json
{
  "model": "dall-e-3",
  "prompt": "YouTube thumbnail for video about '{{$json.video_topic}}', eye-catching design, bold text overlay space, vibrant colors, shocked or excited facial expression, arrows and emphasis elements, clickbait style but professional, 1920x1080 resolution, high contrast",
  "size": "1024x1024", 
  "quality": "hd"
}
```

#### Automated Video Assembly:
```javascript
// Code node para ensamblaje de video con Remotion
const createAutomatedVideo = async (scriptData) => {
  const videoComposition = {
    scenes: [],
    totalDuration: 0,
    assets: {
      voiceover: null,
      background_music: null,
      stock_footage: []
    }
  };
  
  // Generar voiceover con ElevenLabs
  const voiceover = await fetch('https://api.elevenlabs.io/v1/text-to-speech/{{voice_id}}', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${ELEVENLABS_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: scriptData.narration_text,
      voice_settings: {
        stability: 0.75,
        similarity_boost: 0.85,
        style: 0.15,
        use_speaker_boost: true
      }
    })
  });
  
  // Buscar stock footage automáticamente
  const stockFootage = await searchStockFootage(scriptData.visual_keywords);
  
  // Crear composición de Remotion
  const composition = await createRemotionComposition({
    script: scriptData,
    voiceover: voiceover.audio_url,
    footage: stockFootage,
    style: scriptData.visual_style
  });
  
  return composition;
};
```

### Multi-Platform Video Distribution

#### YouTube Upload:
```json
{
  "method": "POST",
  "url": "https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status",
  "headers": {
    "Authorization": "Bearer {{youtube_access_token}}",
    "Content-Type": "application/json"
  },
  "body": {
    "snippet": {
      "title": "{{$json.video_title}}",
      "description": "{{$json.video_description}}",
      "tags": {{$json.video_tags}},
      "categoryId": "{{$json.category_id}}",
      "defaultLanguage": "es",
      "defaultAudioLanguage": "es"
    },
    "status": {
      "privacyStatus": "public",
      "madeForKids": false,
      "selfDeclaredMadeForKids": false
    }
  }
}
```

#### TikTok/Instagram Reels Adaptation:
```javascript
// Code node para adaptar contenido a formato vertical
const adaptToVerticalFormat = async (originalVideo) => {
  // Extraer clips más engaging (primeros 15, 30, 60 segundos)
  const shortClips = await extractEngagingClips(originalVideo, [15, 30, 60]);
  
  // Re-format para 9:16 aspect ratio
  const verticalVersions = await Promise.all(
    shortClips.map(async clip => {
      return await processVideo({
        input: clip.file_path,
        operations: [
          { type: 'crop', aspect_ratio: '9:16' },
          { type: 'add_captions', style: 'tiktok' },
          { type: 'add_hook_text', text: clip.hook },
          { type: 'optimize_engagement', platform: 'tiktok' }
        ]
      });
    })
  );
  
  return verticalVersions;
};
```

## Newsletter Automation

### RSS-to-Newsletter Pipeline

#### RSS Feed Processing:
```json
{
  "trigger": "RSS_Feed_Watch",
  "rss_urls": [
    "https://techcrunch.com/feed/",
    "https://feeds.feedburner.com/venturebeat/SZYF",
    "https://www.theverge.com/rss/index.xml"
  ],
  "filter_keywords": ["AI", "automation", "machine learning", "artificial intelligence"],
  "processing_frequency": "every_4_hours"
}
```

#### Content Curation & Summarization:
```json
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system", 
      "content": "Eres un curator de contenido tech experto. Creas newsletters semanales que educan e informan sobre las últimas tendencias en IA y automatización."
    },
    {
      "role": "user",
      "content": "Artículos de la semana:\n{{#each rss_articles}}\nTítulo: {{title}}\nFuente: {{source}}\nResumen: {{summary}}\nURL: {{url}}\n\n{{/each}}\n\nCrea una newsletter estructurada con:\n1. Intro personal y contextual\n2. Top 5 noticias más importantes (con análisis)\n3. Herramientas recomendadas\n4. Thought leadership section\n5. CTA para engagement"
    }
  ]
}
```

#### Mailchimp/ConvertKit Integration:
```json
{
  "method": "POST",
  "url": "https://{{region}}.api.mailchimp.com/3.0/campaigns",
  "headers": {
    "Authorization": "Bearer {{mailchimp_api_key}}"
  },
  "body": {
    "type": "regular",
    "recipients": {
      "list_id": "{{mailing_list_id}}"
    },
    "settings": {
      "subject_line": "{{$json.newsletter_subject}}",
      "title": "Newsletter {{$json.week_date}}",
      "from_name": "{{sender_name}}",
      "reply_to": "{{reply_email}}"
    },
    "content_type": "template",
    "content": {
      "template": {
        "id": "{{template_id}}",
        "sections": {
          "main_content": "{{$json.newsletter_html}}",
          "header_image": "{{$json.header_image_url}}"
        }
      }
    }
  }
}
```

## Visual Asset Creation

### Automated Graphic Design

#### Canva API Integration:
```json
{
  "method": "POST",
  "url": "https://api.canva.com/rest/v1/designs",
  "headers": {
    "Authorization": "Bearer {{canva_access_token}}"
  },
  "body": {
    "design_type": "InstagramPost",
    "template_id": "{{template_id}}",
    "modifications": [
      {
        "element_id": "text_1",
        "property": "text",
        "value": "{{$json.post_title}}"
      },
      {
        "element_id": "image_1", 
        "property": "image_url",
        "value": "{{$json.background_image_url}}"
      },
      {
        "element_id": "logo",
        "property": "image_url", 
        "value": "{{$json.brand_logo_url}}"
      }
    ]
  }
}
```

#### Programmatic Design with Code:
```javascript
// Code node para crear gráficos con Canvas API
const createSocialGraphic = async (postData) => {
  const canvas = createCanvas(1080, 1080);
  const ctx = canvas.getContext('2d');
  
  // Background
  ctx.fillStyle = postData.brand_colors.primary;
  ctx.fillRect(0, 0, 1080, 1080);
  
  // Add gradient
  const gradient = ctx.createLinearGradient(0, 0, 1080, 1080);
  gradient.addColorStop(0, postData.brand_colors.primary);
  gradient.addColorStop(1, postData.brand_colors.secondary);
  ctx.fillStyle = gradient;
  ctx.fillRect(0, 0, 1080, 1080);
  
  // Title text
  ctx.font = 'bold 72px Arial';
  ctx.fillStyle = '#FFFFFF';
  ctx.textAlign = 'center';
  
  const words = postData.title.split(' ');
  let line = '';
  let y = 400;
  
  words.forEach((word, index) => {
    const testLine = line + word + ' ';
    const metrics = ctx.measureText(testLine);
    
    if (metrics.width > 900 && index > 0) {
      ctx.fillText(line, 540, y);
      line = word + ' ';
      y += 80;
    } else {
      line = testLine;
    }
  });
  ctx.fillText(line, 540, y);
  
  // Logo
  if (postData.logo_url) {
    const logo = await loadImage(postData.logo_url);
    ctx.drawImage(logo, 50, 950, 120, 80);
  }
  
  // Export as buffer
  return canvas.toBuffer('image/png');
};
```

### Brand Consistency

#### Brand Guidelines Enforcement:
```json
{
  "model": "gpt-4o-mini",
  "messages": [
    {
      "role": "system",
      "content": "Eres un brand guardian. Verificas que el contenido siga las guidelines de marca: {{$json.brand_guidelines}}"
    },
    {
      "role": "user",
      "content": "Contenido a verificar:\n{{$json.content}}\n\nVerifica:\n1. Tono de voz correcto\n2. Términos de marca usados correctamente\n3. Valores de marca reflejados\n4. Compliance con guidelines\n\nDevuelve score 1-10 y sugerencias de mejora."
    }
  ]
}
```

#### Color Palette & Typography Automation:
```javascript
// Code node para aplicar brand consistency
const applyBrandGuidelines = (content, brandGuidelines) => {
  const brandedContent = {
    ...content,
    colors: {
      primary: brandGuidelines.colors.primary,
      secondary: brandGuidelines.colors.secondary,
      accent: brandGuidelines.colors.accent
    },
    fonts: {
      heading: brandGuidelines.typography.heading,
      body: brandGuidelines.typography.body,
      accent: brandGuidelines.typography.accent
    },
    logo_placement: brandGuidelines.logo.placement,
    voice_tone: brandGuidelines.voice.tone,
    messaging: applyMessagingGuidelines(content.text, brandGuidelines.messaging)
  };
  
  return brandedContent;
};
```

## E-book & Long-form Content

### Automated E-book Generation

#### Chapter Structure Planning:
```json
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "Eres un expert publishing strategist. Creas estructuras de libros y e-books que mantienen engagement y proporcionan valor progresivo."
    },
    {
      "role": "user", 
      "content": "Tema del e-book: {{$json.ebook_topic}}\nAudiencia objetivo: {{$json.target_audience}}\nObjetivo de aprendizaje: {{$json.learning_objectives}}\nLongitud objetivo: {{$json.target_pages}} páginas\n\nCrea una estructura detallada con:\n1. Título y subtítulo compelling\n2. Tabla de contenidos con 8-12 capítulos\n3. Resumen de cada capítulo (2-3 líneas)\n4. Key takeaways por capítulo\n5. Ejercicios prácticos sugeridos\n6. Distribución de páginas por capítulo"
    }
  ]
}
```

#### Automated Chapter Writing:
```javascript
// Code node para generación de capítulos
const generateEbookChapters = async (bookStructure) => {
  const chapters = [];
  
  for (let i = 0; i < bookStructure.chapters.length; i++) {
    const chapter = bookStructure.chapters[i];
    
    // Generar contenido del capítulo
    const chapterContent = await fetch('/api/openai/chat/completions', {
      method: 'POST',
      headers: { 
        'Authorization': `Bearer ${OPENAI_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        model: 'gpt-4',
        messages: [
          {
            role: 'system',
            content: `Escribe el capítulo ${i + 1} del e-book "${bookStructure.title}". Mantén consistencia con capítulos anteriores: ${JSON.stringify(chapters.map(c => c.title))}`
          },
          {
            role: 'user',
            content: `Capítulo: ${chapter.title}\nObjetivos: ${chapter.objectives.join(', ')}\nPuntos clave: ${chapter.key_points.join(', ')}\nLongitud: ${chapter.target_words} palabras\n\nIncluye: introducción, desarrollo con subsecciones, ejemplos prácticos, ejercicios, resumen del capítulo.`
          }
        ],
        max_tokens: chapter.target_words * 1.5
      })
    });
    
    const result = await chapterContent.json();
    
    chapters.push({
      number: i + 1,
      title: chapter.title,
      content: result.choices[0].message.content,
      word_count: result.choices[0].message.content.split(' ').length,
      generated_at: new Date().toISOString()
    });
    
    // Delay entre capítulos para evitar rate limiting
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
  
  return chapters;
};
```

#### PDF Generation & Formatting:
```javascript
// Code node para generar PDF con Puppeteer
const generateEbookPDF = async (chapters, bookMetadata) => {
  const puppeteer = require('puppeteer');
  
  // Crear HTML completo del libro
  let bookHTML = `
    <!DOCTYPE html>
    <html>
    <head>
      <title>${bookMetadata.title}</title>
      <style>
        body { font-family: 'Georgia', serif; line-height: 1.6; margin: 40px; }
        h1 { color: #2c3e50; font-size: 2.5em; margin-bottom: 0.5em; }
        h2 { color: #34495e; font-size: 2em; margin-top: 2em; page-break-before: always; }
        h3 { color: #7f8c8d; font-size: 1.5em; margin-top: 1.5em; }
        .chapter { margin-bottom: 3em; }
        .toc { page-break-after: always; }
        .exercise { background: #f8f9fa; padding: 20px; border-left: 4px solid #3498db; margin: 20px 0; }
        @media print {
          h2 { page-break-before: always; }
          .exercise { page-break-inside: avoid; }
        }
      </style>
    </head>
    <body>
      <div class="title-page">
        <h1>${bookMetadata.title}</h1>
        <h3>${bookMetadata.subtitle}</h3>
        <p>Por ${bookMetadata.author}</p>
      </div>
      
      <div class="toc">
        <h2>Tabla de Contenidos</h2>
        ${chapters.map((ch, i) => `
          <p>${i + 1}. ${ch.title}</p>
        `).join('')}
      </div>
  `;
  
  // Añadir capítulos
  chapters.forEach(chapter => {
    bookHTML += `
      <div class="chapter">
        <h2>Capítulo ${chapter.number}: ${chapter.title}</h2>
        ${formatChapterContent(chapter.content)}
      </div>
    `;
  });
  
  bookHTML += '</body></html>';
  
  // Generar PDF
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.setContent(bookHTML);
  
  const pdfBuffer = await page.pdf({
    format: 'A4',
    margin: {
      top: '2cm',
      bottom: '2cm', 
      left: '2cm',
      right: '2cm'
    },
    displayHeaderFooter: true,
    headerTemplate: `<div style="font-size: 10px; margin: 0 auto;">${bookMetadata.title}</div>`,
    footerTemplate: '<div style="font-size: 10px; margin: 0 auto;"><span class="pageNumber"></span></div>'
  });
  
  await browser.close();
  
  return pdfBuffer;
};
```

## Performance Analytics & Optimization

### Content Performance Tracking

#### Multi-Platform Analytics:
```javascript
// Code node para agregar métricas de todas las plataformas
const aggregateContentMetrics = async (contentId, platforms) => {
  const metrics = {};
  
  // LinkedIn metrics
  if (platforms.includes('linkedin')) {
    const linkedinData = await fetch(`https://api.linkedin.com/v2/shares/${contentId}/statistics`, {
      headers: { 'Authorization': `Bearer ${linkedin_token}` }
    });
    metrics.linkedin = await linkedinData.json();
  }
  
  // Twitter metrics
  if (platforms.includes('twitter')) {
    const twitterData = await fetch(`https://api.twitter.com/2/tweets/${contentId}/metrics`, {
      headers: { 'Authorization': `Bearer ${twitter_token}` }
    });
    metrics.twitter = await twitterData.json();
  }
  
  // Instagram metrics (requires Facebook Graph API)
  if (platforms.includes('instagram')) {
    const instagramData = await fetch(`https://graph.facebook.com/v18.0/${contentId}/insights?metric=impressions,reach,engagement&access_token=${instagram_token}`);
    metrics.instagram = await instagramData.json();
  }
  
  // Calculate aggregated metrics
  const aggregated = {
    total_impressions: 0,
    total_engagement: 0,
    total_shares: 0,
    engagement_rate: 0,
    top_performing_platform: null
  };
  
  Object.entries(metrics).forEach(([platform, data]) => {
    aggregated.total_impressions += data.impressions || 0;
    aggregated.total_engagement += data.likes + data.comments + data.shares || 0;
    aggregated.total_shares += data.shares || 0;
  });
  
  aggregated.engagement_rate = (aggregated.total_engagement / aggregated.total_impressions) * 100;
  
  return aggregated;
};
```

#### A/B Testing Framework:
```javascript
// Code node para A/B testing de contenido
const runContentABTest = async (contentVariants) => {
  const testResults = {};
  
  for (const variant of contentVariants) {
    // Publicar variant en muestra de audiencia
    const publishResult = await publishToTestAudience(variant, 0.1); // 10% de audiencia
    
    // Esperar período de prueba (ej. 2 horas)
    await new Promise(resolve => setTimeout(resolve, 2 * 60 * 60 * 1000));
    
    // Recopilar métricas
    const metrics = await getContentMetrics(publishResult.post_id);
    
    testResults[variant.id] = {
      variant: variant,
      metrics: metrics,
      performance_score: calculatePerformanceScore(metrics)
    };
  }
  
  // Determinar ganador
  const winner = Object.values(testResults).reduce((prev, current) => 
    prev.performance_score > current.performance_score ? prev : current
  );
  
  // Publicar ganador a audiencia completa
  await publishToFullAudience(winner.variant);
  
  return {
    test_results: testResults,
    winning_variant: winner,
    improvement_percentage: ((winner.performance_score - Math.min(...Object.values(testResults).map(r => r.performance_score))) / Math.min(...Object.values(testResults).map(r => r.performance_score))) * 100
  };
};
```

### Content Optimization

#### AI-Powered Content Improvement:
```json
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "Eres un content optimization expert. Analizas performance de contenido y sugieres mejoras específicas basadas en data."
    },
    {
      "role": "user",
      "content": "Contenido original:\n{{$json.original_content}}\n\nMétricas de performance:\nImpressions: {{$json.metrics.impressions}}\nEngagement Rate: {{$json.metrics.engagement_rate}}%\nClick Rate: {{$json.metrics.click_rate}}%\nShares: {{$json.metrics.shares}}\n\nBenchmark de la industria:\nEngagement Rate promedio: 3.2%\nClick Rate promedio: 1.1%\n\nSugiere 3 mejoras específicas para aumentar performance."
    }
  ]
}
```

#### Trend Analysis & Content Strategy:
```javascript
// Code node para análisis de tendencias
const analyzeContentTrends = async () => {
  const trends = {
    hashtag_performance: await analyzeHashtagTrends(),
    content_format_trends: await analyzeFormatTrends(),
    optimal_posting_times: await analyzePostingTimes(),
    emerging_topics: await identifyEmergingTopics(),
    competitor_analysis: await analyzeCompetitorContent()
  };
  
  // Generar recomendaciones estratégicas
  const recommendations = await generateContentStrategy(trends);
  
  return {
    trends: trends,
    recommendations: recommendations,
    next_month_strategy: await generateMonthlyStrategy(trends, recommendations)
  };
};
```

## URLs y Recursos

### APIs Esenciales:
```
- LinkedIn API: https://docs.microsoft.com/en-us/linkedin/
- Twitter API v2: https://developer.twitter.com/en/docs/api-reference-index
- Instagram Graph API: https://developers.facebook.com/docs/instagram-api/
- YouTube Data API: https://developers.google.com/youtube/v3
- WordPress REST API: https://developer.wordpress.org/rest-api/
- Mailchimp API: https://mailchimp.com/developer/marketing/
```

### Content Creation Tools:
```
- OpenAI: https://platform.openai.com/docs
- DALL-E 3: https://platform.openai.com/docs/guides/images
- ElevenLabs: https://docs.elevenlabs.io/
- Canva API: https://www.canva.com/developers/api/
- Midjourney: https://docs.midjourney.com/
- Remotion: https://www.remotion.dev/
```

### Analytics & Optimization:
```
- Google Analytics 4: https://developers.google.com/analytics/devguides/reporting/data/v1
- SEMrush API: https://developer.semrush.com/
- Ahrefs API: https://ahrefs.com/api
- SerpAPI: https://serpapi.com/
- Social Media APIs para métricas detalladas
```

---

*Esta guía proporciona todo el conocimiento técnico necesario para implementar sistemas completos de creación de contenido automatizado que produzcan resultados consistentes y de alta calidad a escala.*