Transformez des documents en présentations PowerPoint avec l'IA en C#

Transformer des documents en présentations PowerPoint avec l'IA en C# est plus qu'une conversion de format. Un rapport de 30 pages qui devient une présentation de 10 diapositives signifie que quelqu'un a lu le document complet, a décidé des 90 % à omettre, a réorganisé ce qui restait en un récit et a appliqué une conception visuelle. C'est de la synthèse éditoriale — la partie que les bibliothèques PowerPoint traditionnelles ne font pas.

La partie intéressante est ce qui est synthétisé. Dans les flux de travail réels, la source est rarement un seul fichier. Une revue trimestrielle d'activité tire des chiffres d'un classeur Excel, du récit d'un rapport Word et une facture signée d'un PDF. La valeur d'un agent documentaire IA n'est pas de « convertir un .docx en .pptx » — mais de « lire les trois, et me donner une présentation qui raconte l'histoire à travers eux. » Cet article montre la façon la plus simple de faire exactement cela avec Spire.Agent.Office en C# : transmettez à l'agent chaque document plus une instruction, et laissez-le générer la présentation en un seul appel.

1. Une instruction, plusieurs sources

Le code Spire.Office traditionnel traite chaque format comme une île. Pour construire une présentation à partir d'un rapport Word et d'une feuille Excel, vous devriez :

1. Utiliser Spire.Doc pour ouvrir le .docx et extraire le texte souhaité.
2. Utiliser Spire.XLS pour lire le classeur et calculer les chiffres.
3. Utiliser Spire.Pdf si une source est un PDF.
4. Utiliser Spire.Presentation pour créer les diapositives une par une, positionner chaque zone de texte et graphique, et calculer les mises en page à la main.

Cela représente quatre surfaces d'API, un analyseur par format et un moteur de mise en page manuel. Dès que la structure d'un document change, le code casse.

Spire.Agent.Office réduit cela à une seule instruction. Vous transmettez à l'agent tous vos fichiers sources et lui indiquez quelle histoire la présentation doit raconter. L'agent lit chaque format, décide ce qui compte à travers eux et produit les diapositives — sans code de mise en page manuel.

Le modèle mental est une seule étape :

Au lieu d'écrire un analyseur par format, vous laissez l'agent lire chaque fichier et générer la présentation directement. Un appel, une chaîne d'instruction, un fichier .pptx.

2. Ce dont vous avez besoin

• .NET 6+ (l'exemple cible net10.0).
• Le package NuGet Spire.Agent.Office. Il inclut de manière transitive Spire.Doc, Spire.Pdf, Spire.XLS et Spire.Presentation, vous n'avez donc pas à les installer séparément.
• Un SpireToken (clé API Spire.Agent.Office). L'agent communique avec le service d'IA, une clé valide est donc requise pour la génération réelle.
• Imports d'espaces de noms :

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

3. La recette simple : un appel, une présentation

L'idée centrale est d'une simplicité radicale : transmettez chaque document source comme pièce jointe, écrivez une instruction en langage naturel et laissez l'agent tout faire — lecture, compréhension, synthèse, mise en page — en un seul appel 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);

C'est toute la recette : un appel de méthode, une chaîne d'instruction. Pas d'analyseurs par format, pas de fichiers intermédiaires, pas de code de mise en page manuel. L'agent lit chaque format, décide ce qui compte à travers eux et écrit la présentation directement dans savePath.

L'indicateur autonomousOutput: true est ce qui rend cela possible — il indique à l'agent qu'il peut écrire des fichiers (y compris le .pptx final) sans demander de confirmation à chaque étape. Définissez maxTurns sur null (ou un grand nombre) pour que l'agent dispose de suffisamment de tours pour terminer.

4. Exemple complet : une présentation à partir de Word + PDF + Excel

Voici le programme complet. Pointez-le vers un fichier ou un dossier, et il construit la présentation en un seul appel 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());
}

C'est tout le programme. Hormis l'appel à l'Agent lui-même, le seul code est ResolveInputs, qui décide simplement quels fichiers joindre : il ne lit ni n'analyse jamais un document. L'instruction est la seule partie qui décrit la conception (thème, nombre de diapositives, focus) ; la lecture, la décision et la mise en page sont le travail de l'agent.

Un appel, cinq diapositives — la présentation que produit le programme ci-dessus :

5. Comment cela fonctionne sous le capot

• AIDocumentProcessor est obtenu à partir d'un Presentation via ppt.AI(options). L'objet Presentation est le canevas sur lequel l'agent dessine les diapositives.
• AIOptions porte la configuration : SpireToken (votre clé) et TimeoutMs (définissez-le grand pour de vrais documents — l'analyse IA de gros documents prend du temps).
• ExecuteInstruction exécute l'agent. Vous passez le Presentation, une instruction en langage naturel, le savePath pour le .pptx de sortie, et un string[] de chemins de fichiers sources (tout mélange de Word, PDF, Excel, Markdown). Avec autonomousOutput: true, l'agent peut écrire des fichiers — y compris la présentation finale — sans demander de confirmation. Il renvoie un AIResult avec Success, ErrorMessage et OutputFiles (tout ce que l'agent a créé).
• maxTurns contrôle le nombre d'étapes d'agent autorisées. Définissez-le sur null pour aucune limite, ou un grand nombre (par ex. 80) pour de grands ensembles de documents.
• GeneratePresentation(sourcePath, instruction, savePath) est le raccourci dédié lorsque vous avez exactement un document source. Il renvoie un PPTGenerationResult (Success, GeneratedPages, TotalPages, OutputPath, ErrorMessage) au lieu d'un AIResult. Son sourcePath est un seul fichier, ce qui explique exactement pourquoi cet article utilise le chemin multi-pièces jointes ExecuteInstruction : c'est ce qui permet à une présentation de s'appuyer sur plusieurs sources en un seul appel.

Pourquoi ne pas d'abord fusionner en Markdown ? Vous pouvez — voir la variante B à la section 6. Mais pour la plupart des cas d'utilisation, l'approche en un seul appel est plus simple, plus rapide et produit le même résultat. Le Markdown intermédiaire n'est utile que lorsque vous souhaitez inspecter ou modifier le contenu consolidé avant de dépenser des tokens pour la présentation.

6. Contrôle précis

La recette ci-dessus est délibérément minimale. Lorsque vous avez besoin de plus de contrôle, ces variantes s'appuient sur le même appel ExecuteInstruction.

Ajustez l'instruction. La structure, la longueur, le thème et les graphiques de la présentation sont tous contrôlés par la chaîne d'instruction. Soyez explicite :

// 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 — résumez vous-même chaque source (plus prévisible). Si vous préférez interroger chaque document individuellement plutôt que de faire confiance à une instruction inter-documents, bouclez sur SummarizeDocument, qui renvoie le résumé par l'agent d'un seul fichier sous forme de 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());

Passez ensuite le Markdown consolidé à ExecuteInstruction comme source unique — vous obtenez un résumé séparé par document que vous pouvez lire et modifier avant la génération.

Variante B — consolidez en Markdown, puis générez (en deux étapes). Pour les cas où vous voulez un fichier intermédiaire inspectable, divisez le travail en deux appels. L'étape 1 utilise ExecuteInstruction en mode autonome pour fusionner toutes les sources dans un seul fichier Markdown ; l'étape 2 fournit ce Markdown à ExecuteInstruction à nouveau pour construire la présentation :

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

Le compromis : la variante B vous donne un fichier Markdown inspectable entre les deux appels, ce qui est utile pour le débogage ou lorsque la consolidation doit être revue par un humain. La recette en un seul appel de la section 3 est la valeur par défaut recommandée car elle est plus simple et plus rapide.

Vous aimerez peut-être aussi : Automatiser le traitement des factures avec un agent IA en .NET — un autre flux de travail très documentaire qui remet à l'agent un dossier de fichiers et récupère un document fini.

7. Relire et inspecter le résultat

Après la génération, rouvrez la présentation et vérifiez-la par programmation :

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

C'est aussi là qu'intervient une étape de revue humaine : chargez la présentation générée, vérifiez les titres et affinez l'instruction si quelque chose ne va pas.

8. FAQ

La présentation générée n'a pas le bon nombre de diapositives. Si une source est volumineuse, l'analyse peut prendre plus de temps que le délai d'attente par défaut et l'agent s'arrête prématurément. Définissez AIOptions.TimeoutMs sur une grande valeur (par ex. 1000000 pour ~17 minutes) et indiquez une plage de pages dans l'instruction, par ex. « Limitez la présentation finale à 8–12 diapositives. »

L'agent n'inclut pas le contenu de l'un des documents. Les documents complexes peuvent perturber une seule passe. Nommez explicitement le contenu que vous voulez dans l'instruction (« inclure les conclusions du rapport Word », « préserver le tableau de la feuille Excel »). Si le problème persiste, essayez l'approche en deux étapes (variante B à la section 6) pour inspecter le Markdown consolidé avant la génération.

L'appel échoue avec « 401 Invalid token ». Le SpireToken est rejeté — confirmez qu'il est valide, non expiré et correctement copié dans AIOptions.SpireToken.

Comment passer plusieurs documents ? ExecuteInstruction accepte un string[] de chemins de fichiers comme quatrième argument. Passez chaque fichier source — tout mélange de .docx, .pdf, .xlsx, .md, et plus encore — et l'agent les lit tous en un seul appel. Avec un seul document source, le raccourci dédié est GeneratePresentation(sourcePath, instruction, savePath) ; l'appel multi-pièces jointes ci-dessus est ce qui permet de créer une présentation à partir de plusieurs sources.

Obtenez votre clé SpireToken Contactez-nous pour demander une clé API d'essai ou commerciale, ou demandez une licence temporaire. Configurez-la dans le code :

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

Voir aussi

• Présentation du produit Spire.Agent.Office — le SDK d'agent IA pour Word, Excel, PowerPoint et PDF
• Bien démarrer avec Spire.Agent.Office — installez le SDK et exécutez votre première instruction
• Générer un PPT à partir de documents — le tutoriel officiel de l'API de présentation utilisée dans cet article
• Génération par lots de contrats avec Spire.Agent.Office — le même modèle piloté par instruction appliqué à la génération de documents en masse