Crea un Agente de Presentaciones con IA: Guía Completa para Desarrolladores

Los agentes de IA están transformando cómo el software crea contenido. Un agente de presentaciones con IA puede generar, personalizar y entregar presentaciones profesionales como parte de flujos de trabajo automatizados — desde pipelines de CRM hasta herramientas de informes internos.

Esta guía te guiará en la creación de un agente de presentaciones listo para producción utilizando la API de 2Slides.

Visión General de la Arquitectura

Un agente de presentaciones típicamente sigue este flujo:

User Request → Agent Logic → 2Slides API → Poll Job → Deliver Result
                  ↓
           Context Gathering
           (data, templates, brand assets)

Componentes Principales

Manejador de Entradas — recibe solicitudes de presentación (texto, datos, archivos)
Constructor de Contexto — enriquece las solicitudes con plantillas, información de marca, datos
Motor de Generación — llama a la API de 2Slides para crear diapositivas
Monitor de Estado — consulta el estado del trabajo hasta su finalización
Capa de Entrega — devuelve enlaces de descarga, envía por correo electrónico, publica en Slack

Primeros Pasos

1. Obtén tu Clave API

Regístrate en 2slides.com y crea una clave API en 2slides.com/api.

2. Instala las Dependencias

npm install node-fetch dotenv

3. Implementación Básica del Agente

import fetch from 'node-fetch';

class PresentationAgent {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://2slides.com/api/v1';
  }

  async generateSlides({ topic, themeId, language = 'en', resolution = '2K' }) {
    // Paso 1: Iniciar la generación
    const response = await fetch(`${this.baseUrl}/slides/generate`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        userInput: topic,
        themeId,
        responseLanguage: language,
        resolution,
        mode: 'async'
      })
    });

    const job = await response.json();
    if (!response.ok) throw new Error(job.error || 'Generation failed');

    // Paso 2: Consultar hasta completar
    return await this.waitForCompletion(job.jobId);
  }

  async waitForCompletion(jobId, maxWait = 300000) {
    const start = Date.now();
    while (Date.now() - start < maxWait) {
      const response = await fetch(`${this.baseUrl}/jobs/${jobId}`, {
        headers: { 'Authorization': `Bearer ${this.apiKey}` }
      });
      const status = await response.json();

      if (status.status === 'success') return status;
      if (status.status === 'failed') throw new Error('Generation failed');

      await new Promise(r => setTimeout(r, 3000));
    }
    throw new Error('Generation timed out');
  }

  async generateFromFile({ fileUrl, prompt, themeId }) {
    const response = await fetch(`${this.baseUrl}/slides/create-pdf-slides`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        fileUrl,
        userInput: prompt,
        themeId,
        mode: 'async'
      })
    });

    const job = await response.json();
    return await this.waitForCompletion(job.jobId);
  }

  async generateWithDesign({ topic, referenceImageUrl, resolution = '2K' }) {
    const response = await fetch(`${this.baseUrl}/slides/create-like-this`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        userInput: topic,
        designStyle: {
          global: { referenceImageUrl }
        },
        resolution,
        mode: 'async'
      })
    });

    const job = await response.json();
    return await this.waitForCompletion(job.jobId);
  }

  async addNarration({ jobId, mode = 'single', voice = 'Charon' }) {
    const response = await fetch(`${this.baseUrl}/slides/generate-narration`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ jobId, mode, voice, contentMode: 'concise' })
    });

    return await response.json();
  }
}

// Uso
const agent = new PresentationAgent('sk-2slides-xxx');

const result = await agent.generateSlides({
  topic: 'Q1 2026 Business Review',
  themeId: 'mckinsey-theme-id',
  resolution: '2K'
});

console.log('Descargar:', result.downloadUrl);

Implementación en Python

import requests
import time

class PresentationAgent:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = 'https://2slides.com/api/v1'
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }

    def generate_slides(self, topic, theme_id=None, language='en', resolution='2K'):
        response = requests.post(
            f'{self.base_url}/slides/generate',
            headers=self.headers,
            json={
                'userInput': topic,
                'themeId': theme_id,
                'responseLanguage': language,
                'resolution': resolution,
                'mode': 'async'
            }
        )
        response.raise_for_status()
        job = response.json()
        return self._wait_for_completion(job['jobId'])

    def generate_from_file(self, file_url, prompt, theme_id=None):
        response = requests.post(
            f'{self.base_url}/slides/create-pdf-slides',
            headers=self.headers,
            json={
                'fileUrl': file_url,
                'userInput': prompt,
                'themeId': theme_id,
                'mode': 'async'
            }
        )
        response.raise_for_status()
        job = response.json()
        return self._wait_for_completion(job['jobId'])

    def _wait_for_completion(self, job_id, max_wait=300):
        start = time.time()
        while time.time() - start < max_wait:
            response = requests.get(
                f'{self.base_url}/jobs/{job_id}',
                headers=self.headers
            )
            status = response.json()
            if status['status'] == 'success':
                return status
            if status['status'] == 'failed':
                raise Exception('Generation failed')
            time.sleep(3)
        raise TimeoutError('Generation timed out')

# Uso
agent = PresentationAgent('sk-2slides-xxx')
result = agent.generate_slides('AI Trends 2026', resolution='4K')
print(f"Descargar: {result['downloadUrl']}")

Patrones Avanzados

Patrón 1: Generación Basada en Plantillas

Preconfigura temas para diferentes casos de uso:

const TEMPLATES = {
  'pitch-deck': { themeId: 'apple-id', resolution: '2K' },
  'quarterly-review': { themeId: 'mckinsey-id', resolution: '2K' },
  'training': { themeId: 'corporate-id', resolution: '1K' },
  'social-media': { themeId: 'saul-bass-id', resolution: '4K', aspectRatio: '1:1' },
};

async function generateByType(type, topic) {
  const config = TEMPLATES[type];
  return agent.generateSlides({ topic, ...config });
}

Patrón 2: Integración con Pipelines de Datos

Conéctate a tus fuentes de datos:

async function weeklyReport(dataSource) {
  // 1. Obtener los datos más recientes
  const data = await dataSource.getWeeklyMetrics();

  // 2. Formatear como entrada para la presentación
  const topic = `Weekly Report: Revenue $${data.revenue}, Users ${data.users}, Churn ${data.churn}%`;

  // 3. Generar diapositivas
  const result = await agent.generateSlides({ topic, themeId: 'mckinsey-id' });

  // 4. Entregar
  await slackBot.postMessage('#team-updates', `Weekly report ready: ${result.downloadUrl}`);
}

Patrón 3: Salida Multiformato

Genera diapositivas + narración + video en un solo pipeline:

async function fullPresentation(topic) {
  // 1. Generar diapositivas
  const slides = await agent.generateSlides({ topic });

  // 2. Añadir narración de voz
  await agent.addNarration({ jobId: slides.jobId, mode: 'multi', voice: 'Charon' });

  // 3. Descargar con audio
  const download = await fetch(`${agent.baseUrl}/slides/download-slides-pages-voices`, {
    method: 'POST',
    headers: agent.headers,
    body: JSON.stringify({ jobId: slides.jobId })
  });

  return download.json();
}

Consideraciones para Producción

Limitación de Tasa

Por defecto: 60 solicitudes/minuto
Maneja las respuestas 429 con retroceso exponencial
Usa el modo asíncrono para operaciones por lotes

Manejo de Errores

Envuelve todas las llamadas a la API en try/catch
Implementa lógica de reintento para fallos transitorios
Registra los IDs de los trabajos para depuración

Gestión de Costos

Rastrea el uso de créditos por generación
Configura alertas de presupuesto en tu panel de 2Slides
Usa resoluciones más bajas para contenido interno/borrador

Seguridad

Almacena las claves API en variables de entorno, nunca en el código
Usa solo llamadas a la API desde el lado del servidor — nunca expongas las claves a los clientes
Implementa la firma de solicitudes para las devoluciones de llamada de webhook

Preguntas Frecuentes

¿Puedo construir un producto SaaS sobre la API de 2Slides?

Sí — la API está diseñada para uso en producción. No hay restricciones en aplicaciones comerciales.

¿Cuál es el límite máximo de generación concurrente?

La API maneja solicitudes concurrentes mediante limitación de tasa. Para necesidades de alto volumen, contacta al equipo de 2Slides para límites empresariales.

¿Existe un webhook para la finalización de trabajos?

Actualmente, usa el sondeo a través del endpoint de trabajos. El soporte para webhooks está en la hoja de ruta.

Crea tu agente de presentaciones — obtén tu clave API en 2Slides y empieza a generar diapositivas programáticamente.