Trasforma i documenti in presentazioni PowerPoint con l'IA in C#

Trasformare documenti in presentazioni PowerPoint con l'AI in C# è più di una semplice conversione di formato. Un report di 30 pagine che diventa una presentazione di 10 diapositive significa che qualcuno ha letto l'intero documento, ha deciso quale 90% escludere, ha riorganizzato ciò che rimaneva in una narrazione e ha applicato un design visivo. Questa è sintesi editoriale — la parte che le librerie PowerPoint tradizionali non fanno.

La parte interessante è cosa viene sintetizzato. Nei flussi di lavoro reali la fonte raramente è un singolo file. Una revisione aziendale trimestrale attinge numeri da un file Excel, la narrazione da un report Word e una fattura firmata da un PDF. Il valore di un agente documentale AI non è "convertire un .docx in .pptx" — è "leggi tutti e tre e dammi una presentazione che racconti la storia attraverso di essi." Questo articolo mostra il modo più semplice per farlo esattamente con Spire.Agent.Office in C#: consegna all'agente ogni documento più una istruzione, e lascia che generi la presentazione in una singola chiamata.

1. Una sola istruzione, molte fonti

Il codice tradizionale di Spire.Office tratta ogni formato come un'isola. Per costruire una presentazione da un report Word più un foglio Excel dovresti:

1. Usare Spire.Doc per aprire il .docx ed estrarre il testo che desideri.
2. Usare Spire.XLS per leggere il workbook e calcolare i valori.
3. Usare Spire.Pdf se una fonte è un PDF.
4. Usare Spire.Presentation per creare le diapositive una per una, posizionare ogni casella di testo e grafico, e calcolare i layout manualmente.

Sono quattro superfici API, un parser per formato e un motore di layout manuale. Nel momento in cui la struttura di un documento cambia, il codice si rompe.

Spire.Agent.Office riduce tutto ciò a una singola istruzione. Consegni all'agente tutti i tuoi file di origine e gli dici quale storia deve raccontare la presentazione. L'agente legge ogni formato, decide cosa conta tra essi e produce le diapositive — senza codice di layout manuale.

Il modello mentale è un singolo passaggio:

Invece di scrivere un parser per ogni formato, lasci che l'agente legga ogni file e generi la presentazione direttamente. Una chiamata, una stringa di istruzione, un file .pptx.

2. Cosa ti serve

• .NET 6+ (l'esempio ha come target net10.0).
• Il pacchetto NuGet Spire.Agent.Office. Include transitivamente Spire.Doc, Spire.Pdf, Spire.XLS e Spire.Presentation, quindi non è necessario installarli separatamente.
• Un SpireToken (chiave API di Spire.Agent.Office). L'agente comunica con il servizio AI, quindi è necessario un token valido per la generazione effettiva.
• Import degli spazi dei nomi:

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

3. La ricetta semplice: una chiamata, una presentazione

L'idea centrale è di una semplicità radicale: passa ogni documento di origine come allegato, scrivi una singola istruzione in linguaggio naturale e lascia che l'agente faccia tutto — lettura, comprensione, sintesi, layout — in una sola chiamata 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);

Questa è l'intera ricetta: una chiamata al metodo, una stringa di istruzione. Nessun parser per formato, nessun file intermedio, nessun codice di layout manuale. L'agente legge ogni formato, decide cosa conta tra essi e scrive la presentazione direttamente in savePath.

Il flag autonomousOutput: true è ciò che rende possibile tutto questo — dice all'agente che può scrivere file (incluso il .pptx finale) senza chiedere conferma a ogni passaggio. Imposta maxTurns su null (o un numero elevato) in modo che l'agente abbia turni sufficienti per terminare.

4. Esempio completo: una presentazione da Word + PDF + Excel

Ecco il programma completo. Puntalo su un file o una cartella, e costruisce la presentazione in una singola chiamata AI:

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

Questo è l'intero programma. A parte la chiamata all'Agent stessa, l'unico codice è ResolveInputs, che decide semplicemente quali file allegare: non legge né analizza mai un documento. L'istruzione è l'unica parte che descrive il design (tema, numero di diapositive, focus); la lettura, le decisioni e il layout sono compito dell'agente.

Una chiamata, cinque diapositive — la presentazione che il programma sopra produce:

5. Come funziona dietro le quinte

• AIDocumentProcessor si ottiene da un Presentation tramite ppt.AI(options). L'oggetto Presentation è la tela su cui l'agente disegna le diapositive.
• AIOptions contiene la configurazione: SpireToken (la tua chiave) e TimeoutMs (impostalo su un valore elevato per documenti reali — l'analisi AI di documenti di grandi dimensioni richiede tempo).
• ExecuteInstruction esegue l'agente. Passi il Presentation, un'instruction in linguaggio naturale, il savePath per il .pptx di output e un string[] di percorsi dei file di origine (qualsiasi combinazione di Word, PDF, Excel, Markdown). Con autonomousOutput: true l'agente può scrivere file — inclusa la presentazione finale — senza chiedere conferma. Restituisce un AIResult con Success, ErrorMessage e OutputFiles (tutto ciò che l'agente ha creato).
• maxTurns controlla quanti passaggi dell'agente sono consentiti. Impostalo su null per nessun limite, o su un numero elevato (ad esempio 80) per grandi insiemi di documenti.
• GeneratePresentation(sourcePath, instruction, savePath) è la scorciatoia dedicata quando hai esattamente un documento di origine. Restituisce un PPTGenerationResult (Success, GeneratedPages, TotalPages, OutputPath, ErrorMessage) invece di un AIResult. Il suo sourcePath è un singolo file, ed è esattamente per questo che questo articolo utilizza il percorso ExecuteInstruction con allegati multipli: è ciò che permette a una presentazione di attingere a diverse fonti in una singola chiamata.

Perché non unire prima in Markdown? Puoi farlo — vedi la Variante B nella Sezione 6. Ma per la maggior parte dei casi d'uso l'approccio a chiamata singola è più semplice, più veloce e produce lo stesso risultato. Il Markdown intermedio è utile solo quando vuoi ispezionare o modificare il contenuto consolidato prima di spendere token per la presentazione.

6. Controllo preciso

La ricetta sopra è volutamente minimale. Quando hai bisogno di più controllo, queste varianti si basano sulla stessa chiamata ExecuteInstruction.

Metti a punto l'istruzione. La struttura, la lunghezza, il tema e i grafici della presentazione sono tutti controllati dalla stringa di istruzione. Sii esplicito:

// 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 — riassumi tu stesso ogni fonte (più prevedibile). Se preferisci interrogare ogni documento individualmente piuttosto che affidarti a una singola istruzione trasversale, esegui in ciclo SummarizeDocument, che restituisce il riassunto di un singolo file prodotto dall'agente come 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());

Poi passa il Markdown consolidato a ExecuteInstruction come unica fonte — ottieni un riassunto separato per documento che puoi leggere e modificare prima della generazione.

Variante B — consolida in Markdown, poi genera (due passaggi). Nei casi in cui desideri un file intermedio ispezionabile, dividi il lavoro in due chiamate. Il passaggio 1 usa ExecuteInstruction in modalità autonoma per unire tutte le fonti in un unico file Markdown; il passaggio 2 fornisce quel Markdown a ExecuteInstruction nuovamente per costruire la presentazione:

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

Il compromesso: la Variante B ti offre un file Markdown ispezionabile tra le due chiamate, utile per il debug o quando il consolidamento necessita di revisione umana. La ricetta a chiamata singola della Sezione 3 è il default consigliato perché è più semplice e più veloce.

Potrebbe interessarti anche: Automatizzare l'elaborazione delle fatture con un agente AI in .NET — un altro flusso di lavoro ricco di documenti che consegna all'agente una cartella di file e ne riceve un documento finito.

7. Rileggi e ispeziona il risultato

Dopo la generazione, riapri la presentazione e verificala a livello di codice:

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

È anche il punto in cui si inserisce un passaggio di revisione umana: carica la presentazione generata, controlla i titoli e perfeziona l'istruzione se qualcosa non va.

8. FAQ

La presentazione generata ha un numero errato di diapositive. Se una fonte è di grandi dimensioni, l'analisi può richiedere più tempo del timeout predefinito e l'agente si interrompe in anticipo. Imposta AIOptions.TimeoutMs su un valore elevato (ad esempio 1000000 per circa 17 minuti) e indica un intervallo di pagine nell'istruzione, ad esempio "Mantieni la presentazione finale tra 8 e 12 diapositive."

L'agente non include il contenuto di uno dei documenti. I documenti complessi possono confondere un singolo passaggio. Nomina esplicitamente nell'istruzione il contenuto che desideri ("includi i risultati del report Word", "preserva la tabella nel foglio Excel"). Se il problema persiste, prova l'approccio in due passaggi (Variante B nella Sezione 6) per ispezionare il Markdown consolidato prima della generazione.

La chiamata fallisce con "401 Invalid token". Il SpireToken viene rifiutato — verifica che sia valido, non scaduto e copiato correttamente in AIOptions.SpireToken.

Come faccio a passare più documenti? ExecuteInstruction accetta un string[] di percorsi di file come quarto argomento. Passa ogni file di origine — qualsiasi combinazione di .docx, .pdf, .xlsx, .md e altro — e l'agente li legge tutti in una singola chiamata. Con un singolo documento di origine, la scorciatoia dedicata è GeneratePresentation(sourcePath, instruction, savePath); la chiamata con allegati multipli sopra è ciò che rende possibile creare una presentazione da più fonti.

Ottieni la tua chiave SpireToken Contattaci per richiedere una chiave API di prova o commerciale, oppure richiedi una licenza temporanea. Configurala nel codice:

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

Vedi anche

• Panoramica del prodotto Spire.Agent.Office — l'SDK agente AI per Word, Excel, PowerPoint e PDF
• Introduzione a Spire.Agent.Office — installa l'SDK ed esegui la tua prima istruzione
• Generare PPT da documenti — il tutorial ufficiale per l'API di presentazione utilizzata in questo articolo
• Generazione batch di contratti con Spire.Agent.Office — lo stesso pattern guidato da istruzioni applicato alla generazione di documenti in blocco