Transforme Documentos em Apresentações PowerPoint com IA em C#

Transformar documentos em apresentações do PowerPoint com IA em C# é mais do que conversão de formato. Um relatório de 30 páginas se tornar um deck de 10 slides significa que alguém leu o documento inteiro, decidiu quais 90% deixar de fora, reorganizou o que restou em uma narrativa e aplicou design visual. Isso é síntese editorial — a parte que as bibliotecas tradicionais do PowerPoint não fazem.

A parte interessante é o que é sintetizado. Em fluxos de trabalho reais, a fonte raramente é um único arquivo. Uma revisão trimestral de negócios extrai números de uma pasta de trabalho do Excel, a narrativa de um relatório do Word e uma fatura assinada de um PDF. O valor de um agente de documentos com IA não é "converter um .docx em .pptx" — é "ler os três e me dar um deck que conte a história entre eles." Este artigo mostra a maneira mais simples de fazer exatamente isso com o Spire.Agent.Office em C#: entregue ao agente todos os documentos mais uma instrução, e deixe-o gerar o deck em uma única chamada.

1. Uma Instrução, Muitas Fontes

O código tradicional do Spire.Office trata cada formato como uma ilha. Para construir um deck a partir de um relatório do Word mais uma planilha do Excel, você precisaria:

1. Usar o Spire.Doc para abrir o .docx e extrair o texto desejado.
2. Usar o Spire.XLS para ler a pasta de trabalho e calcular os números.
3. Usar o Spire.Pdf se a fonte for um PDF.
4. Usar o Spire.Presentation para criar os slides um a um, posicionar cada caixa de texto e gráfico e calcular os layouts manualmente.

Isso são quatro superfícies de API, um analisador por formato e um motor de layout manual. No momento em que a estrutura de um documento muda, o código quebra.

O Spire.Agent.Office reduz tudo isso a uma única instrução. Você entrega ao agente todos os seus arquivos de origem e diz a ele qual história o deck deve contar. O agente lê cada formato, decide o que importa entre eles e produz os slides — sem código de layout manual.

O modelo mental é uma única etapa:

Em vez de escrever um analisador por formato, você deixa o agente ler cada arquivo e gerar o deck diretamente. Uma chamada, uma string de instrução, um arquivo .pptx.

2. O Que Você Precisa

• .NET 6+ (o exemplo tem como alvo net10.0).
• O pacote NuGet Spire.Agent.Office. Ele traz transitivamente o Spire.Doc, o Spire.Pdf, o Spire.XLS e o Spire.Presentation, portanto você não precisa instalá-los separadamente.
• Um SpireToken (chave de API do Spire.Agent.Office). O agente se comunica com o serviço de IA, então um token válido é necessário para a geração de fato.
• Importações de namespace:

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

3. A Receita Simples: Uma Chamada, Um Deck

A ideia central é de uma simplicidade radical: passe cada documento de origem como anexo, escreva uma instrução em linguagem natural e deixe o agente fazer tudo — leitura, compreensão, síntese, layout — em uma única chamada 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);

Essa é a receita inteira: uma chamada de método, uma string de instrução. Sem analisadores por formato, sem arquivos intermediários, sem código de layout manual. O agente lê cada formato, decide o que importa entre eles e grava o deck diretamente em savePath.

O sinalizador autonomousOutput: true é o que faz isso funcionar — ele diz ao agente que ele pode gravar arquivos (incluindo o .pptx final) sem pedir confirmação a cada etapa. Defina maxTurns como null (ou um número grande) para que o agente tenha turnos suficientes para terminar.

4. Exemplo Completo: Um Deck a Partir de Word + PDF + Excel

Aqui está o programa completo. Aponte-o para um arquivo ou uma pasta, e ele constrói o deck em uma única chamada de 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());
}

Esse é o programa inteiro. Além da própria chamada ao Agent, o único código é ResolveInputs, que apenas decide quais arquivos anexar: ele nunca lê nem analisa um documento. A instrução é a única parte que descreve o design (tema, número de slides, foco); a leitura, a decisão e o layout são tarefa do agente.

Uma chamada, cinco slides — o deck que o programa acima produz:

5. Como Funciona nos Bastidores

• AIDocumentProcessor é obtido de um Presentation por meio de ppt.AI(options). O objeto Presentation é a tela na qual o agente desenha os slides.
• AIOptions carrega a configuração: SpireToken (sua chave) e TimeoutMs (defina um valor grande para documentos reais — a análise de IA de documentos extensos leva tempo).
• ExecuteInstruction executa o agente. Você passa o Presentation, uma instruction em linguagem natural, o savePath para o .pptx de saída e um string[] de caminhos de arquivos de origem (qualquer combinação de Word, PDF, Excel, Markdown). Com autonomousOutput: true, o agente pode gravar arquivos — incluindo o deck final — sem pedir confirmação. Ele retorna um AIResult com Success, ErrorMessage e OutputFiles (tudo o que o agente criou).
• maxTurns controla quantas etapas do agente são permitidas. Defina como null para nenhum limite, ou um número grande (por exemplo, 80) para grandes conjuntos de documentos.
• GeneratePresentation(sourcePath, instruction, savePath) é o atalho dedicado quando você tem exatamente um documento de origem. Ele retorna um PPTGenerationResult (Success, GeneratedPages, TotalPages, OutputPath, ErrorMessage) em vez de um AIResult. Seu sourcePath é um único arquivo, e é exatamente por isso que este artigo usa o caminho de múltiplos anexos do ExecuteInstruction: é isso que permite que um deck se baseie em várias fontes em uma única chamada.

Por que não mesclar em Markdown primeiro? Você pode — veja a Variante B na Seção 6. Mas, para a maioria dos casos de uso, a abordagem de chamada única é mais simples, mais rápida e produz o mesmo resultado. O Markdown intermediário só é útil quando você quer inspecionar ou editar o conteúdo consolidado antes de gastar tokens com o deck.

6. Controle Preciso

A receita acima é deliberadamente mínima. Quando você precisa de mais controle, estas variações se baseiam na mesma chamada ExecuteInstruction.

Ajuste a instrução. A estrutura, o comprimento, o tema e os gráficos do deck são todos controlados pela string de instrução. Seja 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 — resuma cada fonte você mesmo (mais previsível). Se você preferir instruir cada documento individualmente em vez de confiar em uma única instrução entre documentos, faça um loop com SummarizeDocument, que retorna o resumo do agente de um único arquivo como uma 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());

Em seguida, passe o Markdown consolidado para ExecuteInstruction como a única fonte — você obtém um resumo separado por documento que pode ler e editar antes da geração.

Variante B — consolide em Markdown e depois gere (duas etapas). Para casos em que você quer um arquivo intermediário inspecionável, divida o trabalho em duas chamadas. A Etapa 1 usa ExecuteInstruction em modo autônomo para mesclar todas as fontes em um único arquivo Markdown; a Etapa 2 alimenta esse Markdown novamente no ExecuteInstruction para construir o deck:

// 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);

O trade-off: a Variante B oferece um arquivo Markdown inspecionável entre as duas chamadas, o que é útil para depuração ou quando a consolidação precisa de revisão humana. A receita de chamada única da Seção 3 é o padrão recomendado porque é mais simples e mais rápida.

Você também pode gostar de: Automatize o Processamento de Faturas com um Agente de IA no .NET — outro fluxo de trabalho repleto de documentos que entrega ao agente uma pasta de arquivos e recebe de volta um documento finalizado.

7. Reler e Inspecionar o Resultado

Após a geração, reabra o deck e verifique-o programaticamente:

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}");
    }
}

É também aqui que se encaixa uma etapa de revisão humana: carregue o deck gerado, verifique os títulos e refine a instrução se algo estiver errado.

8. Perguntas Frequentes

O deck gerado tem o número errado de slides. Se uma fonte for grande, a análise pode levar mais tempo do que o tempo limite padrão e o agente para antes de terminar. Defina AIOptions.TimeoutMs com um valor grande (por exemplo, 1000000 para cerca de 17 minutos) e informe um intervalo de páginas na instrução, por exemplo: "Mantenha o deck final com 8 a 12 slides."

O agente não inclui conteúdo de um dos documentos. Documentos complexos podem confundir uma única passagem. Nomeie explicitamente o conteúdo que você deseja na instrução ("inclua os resultados do relatório do Word", "preserve a tabela da planilha do Excel"). Se o problema persistir, tente a abordagem de duas etapas (Variante B na Seção 6) para inspecionar o Markdown consolidado antes da geração.

A chamada falha com "401 Invalid token". O SpireToken foi rejeitado — confirme se ele é válido, se não expirou e se foi copiado corretamente para AIOptions.SpireToken.

Como faço para passar vários documentos? ExecuteInstruction aceita um string[] de caminhos de arquivos como quarto argumento. Passe todos os arquivos de origem — qualquer combinação de .docx, .pdf, .xlsx, .md e outros — e o agente lê todos eles em uma única chamada. Com um único documento de origem, o atalho dedicado é GeneratePresentation(sourcePath, instruction, savePath); a chamada com múltiplos anexos acima é o que torna possível criar um deck a partir de várias fontes.

Obtenha Sua Chave SpireToken Entre em contato conosco para solicitar uma chave de API de avaliação ou comercial, ou solicite uma licença temporária. Configure-a no código:

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

Veja Também

• Visão geral do produto Spire.Agent.Office — o SDK de agente de IA para Word, Excel, PowerPoint e PDF
• Introdução ao Spire.Agent.Office — instale o SDK e execute sua primeira instrução
• Gerar PPT a partir de Documentos — o tutorial oficial da API de apresentação usada neste artigo
• Geração em Lote de Contratos com Spire.Agent.Office — o mesmo padrão orientado por instruções aplicado à geração de documentos em massa