Convierte documentos en presentaciones de PowerPoint con IA en C#

Convertir documentos en presentaciones de PowerPoint con IA en C# es más que una conversión de formato. Que un informe de 30 páginas se convierta en una presentación de 10 diapositivas significa que alguien leyó el documento completo, decidió qué 90% dejar fuera, reorganizó lo restante en una narrativa y aplicó un diseño visual. Eso es síntesis editorial: la parte que las bibliotecas tradicionales de PowerPoint no hacen.

La parte interesante es qué se sintetiza. En los flujos de trabajo reales, la fuente rara vez es un único archivo. Una revisión comercial trimestral extrae cifras de un libro de Excel, la narrativa de un informe de Word y una factura firmada de un PDF. El valor de un agente de documentos con IA no es «convertir un .docx a .pptx», sino «lee los tres y dame una presentación que cuente la historia a través de ellos». Este artículo muestra la forma más sencilla de hacer exactamente eso con Spire.Agent.Office en C#: entrega al agente todos los documentos más una instrucción, y deja que genere la presentación en una sola llamada.

1. Una Instrucción, Muchas Fuentes

El código tradicional de Spire.Office trata cada formato como una isla. Para construir una presentación a partir de un informe de Word más una hoja de Excel tendrías que:

1. Usar Spire.Doc para abrir el .docx y extraer el texto que quieres.
2. Usar Spire.XLS para leer el libro y calcular las cifras.
3. Usar Spire.Pdf si una fuente es un PDF.
4. Usar Spire.Presentation para crear diapositivas una por una, posicionar cada cuadro de texto y gráfico, y calcular los diseños a mano.

Eso son cuatro superficies de API, un analizador por formato y un motor de diseño manual. En el momento en que la estructura de un documento cambia, el código se rompe.

Spire.Agent.Office reduce todo eso a una sola instrucción. Entregas al agente todos tus archivos fuente y le dices qué historia debe contar la presentación. El agente lee cada formato, decide qué importa entre ellos y produce las diapositivas, sin código de diseño manual.

El modelo mental es un solo paso:

En lugar de escribir un analizador por formato, dejas que el agente lea cada archivo y genere la presentación directamente. Una llamada, una cadena de instrucción, un archivo .pptx.

2. Lo Que Necesitas

• .NET 6+ (el ejemplo apunta a net10.0).
• El paquete NuGet Spire.Agent.Office. Trae transitivamente Spire.Doc, Spire.Pdf, Spire.XLS y Spire.Presentation, así que no los instalas por separado.
• Un SpireToken (clave de API de Spire.Agent.Office). El agente se comunica con el servicio de IA, por lo que se requiere un token válido para la generación real.
• Importaciones de espacios de nombres:

using Spire.Agent.Office.AI;        // AIOptions, AIDocumentProcessor, AIResult
using Spire.Agent.Office.Extensions;// presentation.AI(...) extension
using Spire.Presentation;           // Presentation

3. La Receta Simple: Una Llamada, Una Presentación

La idea central es de una simplicidad radical: pasa cada documento fuente como adjunto, escribe una instrucción en lenguaje natural y deja que el agente haga todo —leer, comprender, sintetizar, diseñar— en una sola llamada a ExecuteInstruction.

string[] sources = new[]
{
    Path.Combine(sampleDir, "AI-Powered Document Processing Report.docx"),
    Path.Combine(sampleDir, "purchase-orders.xlsx"),
    Path.Combine(sampleDir, "invoice_INV-2026-0815.pdf")
};

string instruction =
    "Create a concise Q3 business review summary from the provided documents. " +
    "1. Use a clean blue theme; " +
    "2. Summarize business review, project status, customer pilot research, and platform performance; " +
    "3. Keep each slide focused on one key finding or metric; " +
    "4. Generate 5 slides.";

AIResult result = processor.ExecuteInstruction(
    ppt, instruction, savePath, sources,
    autonomousOutput: true, maxTurns: null);

Esa es toda la receta: una llamada a método, una cadena de instrucción. Sin analizadores por formato, sin archivos intermedios, sin código de diseño manual. El agente lee cada formato, decide qué importa entre ellos y escribe la presentación directamente en savePath.

El indicador autonomousOutput: true es lo que hace que esto funcione: le dice al agente que puede escribir archivos (incluido el .pptx final) sin pedir confirmación en cada paso. Establece maxTurns en null (o un número grande) para que el agente tenga suficientes turnos para terminar.

4. Ejemplo Completo: Una Presentación desde Word + PDF + Excel

Aquí está el programa completo. Apúntalo a un archivo o a una carpeta, y construye la presentación en una sola llamada a la IA:

using System;
using System.IO;
using System.Linq;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;
using Spire.Presentation;

class Program
{
    static void Main()
    {
        string instruction =
            "Create a concise Q3 business review summary from the provided documents. " +
            "1. Use a clean blue theme; " +
            "2. Summarize business review, project status, customer pilot research, and platform performance; " +
            "3. Keep each slide focused on one key finding or metric; " +
            "4. Generate 5 slides.";

        AIOptions options = new AIOptions { SpireToken = "sk-YourSpireToken", TimeoutMs = 1000000 };

        using (Presentation ppt = new Presentation())
        {
            AIResult result = ppt.AI(options).ExecuteInstruction(
                ppt, instruction, @"C:\Samples\Q3_Review.pptx", ResolveInputs(@"C:\Samples"),
                autonomousOutput: true, maxTurns: null);

            Console.WriteLine(result.Success ? "Success" : $"Error={result.ErrorMessage}");
        }
    }

    // Point at a file or a folder; a folder is filtered to supported document formats.
    static string[] ResolveInputs(string path) =>
        File.Exists(path) ? new[] { path }
        : Directory.GetFiles(path).Where(IsSupported).OrderBy(f => f).ToArray();

    static bool IsSupported(string file) =>
        new[] { ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".pdf", ".txt", ".md" }
            .Contains(Path.GetExtension(file).ToLowerInvariant());
}

Ese es todo el programa. Aparte de la llamada al agente en sí, el único código es ResolveInputs, que solo decide qué archivos adjuntar: nunca lee ni analiza un documento. La instrucción es la única parte que describe el diseño (tema, número de diapositivas, enfoque); la lectura, la decisión y el diseño son tarea del agente.

Una llamada, cinco diapositivas: la presentación que produce el programa anterior:

5. Cómo Funciona Internamente

• AIDocumentProcessor se obtiene de un Presentation mediante ppt.AI(options). El objeto Presentation es el lienzo sobre el que el agente dibuja las diapositivas.
• AIOptions contiene la configuración: SpireToken (tu clave) y TimeoutMs (establécelo en un valor grande para documentos reales: el análisis de IA de documentos grandes lleva tiempo).
• ExecuteInstruction ejecuta el agente. Le pasas el Presentation, una instruction en lenguaje natural, la savePath para el .pptx de salida y un string[] de rutas de archivos fuente (cualquier combinación de Word, PDF, Excel, Markdown). Con autonomousOutput: true el agente puede escribir archivos —incluida la presentación final— sin pedir confirmación. Devuelve un AIResult con Success, ErrorMessage y OutputFiles (todo lo que el agente creó).
• maxTurns controla cuántos pasos del agente se permiten. Establécelo en null para no tener límite, o en un número grande (por ejemplo, 80) para conjuntos grandes de documentos.
• GeneratePresentation(sourcePath, instruction, savePath) es el atajo dedicado cuando tienes exactamente un documento fuente. Devuelve un PPTGenerationResult (Success, GeneratedPages, TotalPages, OutputPath, ErrorMessage) en lugar de un AIResult. Su sourcePath es un único archivo, que es exactamente por lo que este artículo usa la ruta de ExecuteInstruction con múltiples adjuntos: eso es lo que permite que una presentación se base en varias fuentes en una sola llamada.

¿Por qué no fusionar primero a Markdown? Puedes hacerlo; consulta la Variante B en la Sección 6. Pero para la mayoría de los casos de uso, el enfoque de una sola llamada es más simple, más rápido y produce el mismo resultado. El Markdown intermedio solo es útil cuando quieres inspeccionar o editar el contenido consolidado antes de gastar tokens en la presentación.

6. Control Preciso

La receta anterior es deliberadamente mínima. Cuando necesitas más control, estas variaciones se basan en la misma llamada a ExecuteInstruction.

Ajusta la instrucción. La estructura, la longitud, el tema y los gráficos de la presentación se controlan mediante la cadena de instrucción. Sé explícito:

// e.g. ask for a specific page count, theme, and a chart on a given slide
"Create a 12-slide deck. Light minimalist theme, accent colour #2E5AAC. " +
"Include a bar chart of monthly revenue on slide 5. Keep each slide to one key message.";

Variante A — resume cada fuente tú mismo (más predecible). Si prefieres solicitar cada documento individualmente en lugar de confiar en una única instrucción entre documentos, recorre con un bucle SummarizeDocument, que devuelve el resumen del agente de un solo archivo como un string:

var sb = new StringBuilder();
foreach (var file in sources)
    sb.AppendLine($"## {Path.GetFileName(file)}\n\n{processor.SummarizeDocument(file)}");
File.WriteAllText(Path.Combine(workDir, "consolidated.md"), sb.ToString());

Luego pasa el Markdown consolidado a ExecuteInstruction como única fuente: obtienes un resumen separado por documento que puedes leer y editar antes de la generación.

Variante B — consolida en Markdown, luego genera (dos pasos). Para casos en los que quieres un archivo intermedio inspeccionable, divide el trabajo en dos llamadas. El Paso 1 usa ExecuteInstruction en modo autónomo para fusionar todas las fuentes en un único archivo Markdown; el Paso 2 alimenta ese Markdown a ExecuteInstruction de nuevo para construir la presentación:

// Step 1 — merge all documents into one Markdown file
string consolidateInstruction =
    "Read all the attached files. Merge their content into a SINGLE Markdown " +
    "document named 'output_consolidated.md'. Use one top-level heading per source, " +
    "preserve key facts / figures / tables, and drop boilerplate. Output ONLY that file.";
processor.ExecuteInstruction(ppt, consolidateInstruction,
    Path.Combine(workDir, "output_consolidated.pptx"), sources,
    autonomousOutput: true, maxTurns: 40);

string consolidatedMd = Path.Combine(workDir, "output_consolidated.md");

// Step 2 — generate the deck from the consolidated Markdown
string genInstruction =
    "Create a 9-slide quarterly business review deck from the consolidated material. " +
    "Professional corporate blue, clear hierarchy, speaker notes per slide.";
processor.ExecuteInstruction(ppt, genInstruction,
    Path.Combine(workDir, "QBR_Deck.pptx"), new[] { consolidatedMd },
    autonomousOutput: true, maxTurns: 40);

La contrapartida: la Variante B te da un archivo Markdown inspeccionable entre las dos llamadas, lo cual es útil para depurar o cuando la consolidación necesita revisión humana. La receta de una sola llamada de la Sección 3 es el valor predeterminado recomendado porque es más simple y más rápida.

También te puede interesar: Automatizar el Procesamiento de Facturas con un Agente de IA en .NET: otro flujo de trabajo con muchos documentos que entrega al agente una carpeta de archivos y devuelve un documento terminado.

7. Leer y Verificar el Resultado

Después de la generación, vuelve a abrir la presentación y verifícala programáticamente:

using (Presentation deck = new Presentation())
{
    deck.LoadFromFile(savePath);
    Console.WriteLine($"Total slides: {deck.Slides.Count}");

    for (int i = 0; i < deck.Slides.Count; i++)
    {
        ISlide slide = deck.Slides[i];
        string title = slide.Title ?? "(no title)";
        Console.WriteLine($"Slide {i + 1}: {title}");
    }
}

Aquí también es donde encaja un paso de revisión humana: carga la presentación generada, revisa los títulos y refina la instrucción si algo no está bien.

8. Preguntas Frecuentes

La presentación generada tiene un número incorrecto de diapositivas. Si una fuente es grande, el análisis puede tardar más que el tiempo de espera predeterminado y el agente se detiene antes de tiempo. Establece AIOptions.TimeoutMs en un valor grande (por ejemplo, 1000000 para unos 17 minutos) e indica un rango de páginas en la instrucción, por ejemplo: «Mantén la presentación final en 8–12 diapositivas».

El agente no incluye contenido de uno de los documentos. Los documentos complejos pueden confundir una sola pasada. Nombra explícitamente en la instrucción el contenido que quieres («incluye los hallazgos del informe de Word», «conserva la tabla de la hoja de Excel»). Si el problema persiste, prueba el enfoque de dos pasos (Variante B en la Sección 6) para inspeccionar el Markdown consolidado antes de la generación.

La llamada falla con «401 Invalid token». Se rechaza el SpireToken: confirma que es válido, que no ha expirado y que se copió correctamente en AIOptions.SpireToken.

¿Cómo paso varios documentos? ExecuteInstruction acepta un string[] de rutas de archivos como su cuarto argumento. Pasa cada archivo fuente —cualquier combinación de .docx, .pdf, .xlsx, .md y más— y el agente los lee todos en una sola llamada. Con un único documento fuente, el atajo dedicado es GeneratePresentation(sourcePath, instruction, savePath); la llamada con múltiples adjuntos anterior es lo que hace posible una presentación a partir de varias fuentes.

Obtén tu clave SpireToken Contáctanos para solicitar una clave de API de prueba o comercial, o solicita una licencia temporal. Configúrala en el código:

AIOptions options = new AIOptions();
options.SpireToken = "sk-YourSpireToken";
options.TimeoutMs  = 1000000;

Ver También

• Descripción general del producto Spire.Agent.Office: el SDK de agente de IA para Word, Excel, PowerPoint y PDF
• Introducción a Spire.Agent.Office: instala el SDK y ejecuta tu primera instrucción
• Generar PPT a partir de Documentos: el tutorial oficial de la API de presentaciones utilizada en este artículo
• Generación por Lotes de Contratos con Spire.Agent.Office: el mismo patrón basado en instrucciones aplicado a la generación masiva de documentos