Comment les équipes de plateforme utilisent GroupDocs.Parser pour intégrer les outils de documents dans les clients MCP sur .NET

💡 Exemple complet disponible sur GitHub : parser-mcp-document-tools-dotnet

Le défi de la plateforme : pourquoi les outils de documents s’arrêtent aux limites du MCP

Les outils de documents basés sur Docker pour les clients MCP constituent un modèle de déploiement GroupDocs.Parser.Mcp sur .NET qui associe une image de conteneur à des vérifications de bibliothèque hors ligne pour get_document_info, extract_text et extract_tables. Les équipes d’ingénierie de plateforme qui livrent des outils de documents pour les assistants ne se débattent généralement pas avec « pouvons‑nous analyser un DOCX ? ». Elles sont confrontées à une coupure plus nette : le serveur MCP doit apparaître dans les configurations client comme une liste d’outils nommés, tandis que le moteur d’analyse est suffisamment volumineux pour que GroupDocs.Parser.Mcp ne soit distribué que sous forme d’image de conteneur, et non comme un package NuGet.

Lorsqu’une escouade produit demande des informations de document, du texte brut et des tableaux prêts pour le chat à l’intérieur d’un client MCP, l’équipe plateforme hérite de deux pistes. La première piste est l’opération : docker run avec un volume à /data, des tags épinglés comme :26.9.0, et une entrée stable mcpServers. La deuxième piste est la vérification : prouver que GroupDocs.Parser pour .NET renvoie les mêmes faits que ces outils avant que quiconque ne dépende d’une poignée de main en direct. Manquer l’une ou l’autre piste entraîne des échecs qui apparaissent comme des réponses vides du client MCP au lieu d’un test unitaire échoué.

Ce dont ces équipes ont besoin est explicite : un extrait d’enregistrement qu’elles peuvent coller dans les clients MCP, plus des appels C# hors ligne qui écrivent des artefacts JSON, texte et Markdown pour révision. Je l’ai rencontré lorsqu’un partenaire a demandé extract_tables dans le chat avant que Docker ne soit approuvé sur les ordinateurs portables des développeurs — les miroirs de la bibliothèque ont permis de faire avancer la livraison pendant que la sécurité terminait la revue du conteneur.

Instantané de l’industrie : GroupDocs.Parser.Mcp est publié à ghcr.io/groupdocs-parser/parser-net-mcp et documente une distribution uniquement Docker parce que le moteur dépasse les limites de taille des packages NuGet. Les démonstrations locales vérifient donc les API équivalentes aux outils sans nécessiter une session MCP en direct (MCP docs).


Pourquoi les approches génériques échouent ici

Les équipes essaient généralement l’un de ces chemins avant d’adopter un serveur de documents MCP dédié :

  • Scripts shell ad‑hoc autour de convertisseurs de bureau : fragiles avec DOCX et XLSX, et ils ne présentent pas d’outils MCP nommés.
  • Appeler le Parser uniquement dans une API privée : fonctionne en‑processus, mais les clients MCP ne voient jamais get_document_info ou extract_text comme des outils de première classe.
  • Attendre un package NuGet MCP : non disponible pour ce serveur ; le chemin publié est l’image de conteneur.

GroupDocs.Parser comble le fossé en associant le serveur Docker MCP aux mêmes API Parser que vos services .NET utilisent déjà.


La solution : GroupDocs.Parser dans un flux de travail MCP de plateforme

GroupDocs.Parser pour .NET devient la moitié de vérification de l’histoire MCP. Parser.GetDocumentInfo, Parser.GetText, GetFormattedText(Markdown) et GetTables reflètent les outils que GroupDocs.Parser.Mcp expose aux clients MCP. Le dépôt d’exemple écrit Result/mcp-server.example.json pour l’enregistrement, puis exerce les trois outils les plus sollicités contre des fichiers DOCX et XLSX fournis afin que les opérateurs puissent inspecter les sorties sous Result/.

Pour suivre l’implémentation ci‑dessous, vous aurez besoin de :

  • .NET 8 SDK
  • GroupDocs.Parser 26.10.0 (licence temporaire)
  • Documents d’exemple (le dépôt inclut sample.docx, sample.xlsx, sample.pdf)
  • Docker Engine uniquement lors du démarrage du serveur MCP en direct
dotnet add package GroupDocs.Parser --version 26.10.0

Implémentation des outils de documents MCP étape par étape

Voici comment enregistrer GroupDocs.Parser.Mcp et vérifier les API équivalentes aux outils. Le scénario correspond à une escouade de plateforme qui intègre des outils de documents pour les assistants sur .NET 8.

Étape 1 - Émettre l’enregistrement Docker MCP

Écrivez une entrée mcpServers qui exécute le conteneur en mode interactif et monte le dossier des documents hôte à /data. Épinglez les tags dans les configurations partagées.

// JSON for MCP clients: docker run --rm -i -v <host>:/data <image>
string normalizedHost = hostDocumentsPath.Replace('\\', '/');
var payload = new
{
    mcpServers = new
    {
        groupdocs_parser = new
        {
            command = "docker",
            args = new[]
            {
                "run", "--rm", "-i",
                "-v", $"{normalizedHost}:/data",
                McpImage
            }
        }
    },

Continuez avec la liste d’outils et écrivez du JSON UTF‑8 pour l’importation client :

    tools = new[]
    {
        "extract_text",
        "extract_tables",
        "extract_metadata",
        "extract_images",
        "extract_barcodes",
        "get_document_info",
        "get_license_status"
    },
    notes = "Pin the image tag in shared configs "
        + "(for example :26.9.0) instead of :latest."
};
var json = JsonSerializer.Serialize(
    payload,
    new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText(outputPath, json, Encoding.UTF8);

Étape 2 - Refléter get_document_info pour les vérifications préliminaires

Les clients MCP appellent souvent get_document_info avant les outils plus lourds. Reflétez ce contrat avec Parser.GetDocumentInfo afin que les schémas restent stables.

using var parser = new Parser(sourcePath);
var info = parser.GetDocumentInfo();

var payload = new
{
    fileName = Path.GetFileName(sourcePath),
    fileType = info?.FileType?.ToString(),
    pageCount = info?.PageCount,
    sizeBytes = info?.Size
};

File.WriteAllText(
    outputPath,
    JsonSerializer.Serialize(
        payload,
        new JsonSerializerOptions { WriteIndented = true }),
    Encoding.UTF8);

Pourquoi ces champs sont importants pour les opérations de plateforme :

  • fileType : confirme que le parser a reconnu le format avant que les outils texte ne s’exécutent
  • pageCount : signal économique pour dimensionner les budgets de contexte des clients MCP
  • sizeBytes : prend en charge les quotas et les contrôles d’anomalies sur les téléchargements entrants

Sur le sample.docx fourni, l’exécution enregistrée indique un type Microsoft Word Open XML, 2 pages, et 15214 octets.

Étape 3 - Refléter extract_text pour une sortie lisible par l’assistant

using var parser = new Parser(sourcePath);
using TextReader? reader = parser.GetText();
if (reader == null)
{
    File.WriteAllText(outputPath, string.Empty, Encoding.UTF8);
    return 0;
}

string text = reader.ReadToEnd();
File.WriteAllText(outputPath, text, Encoding.UTF8);
return text.Length;

Retourner le nombre de caractères fournit aux CI et aux consoles un signal de succès mesurable qui correspond à ce que les opérateurs attendent de l’outil MCP extract_text.

Étape 4 - Refléter extract_tables en Markdown pour les interfaces de chat

Préférez le Markdown formaté, puis revenez aux tableaux à tubes (pipe tables) de GetTables afin que les clients de chat conservent un chemin de rendu cohérent.

using var parser = new Parser(sourcePath);

using (TextReader? formatted = parser.GetFormattedText(
           new FormattedTextOptions(FormattedTextMode.Markdown)))
{
    if (formatted != null)
    {
        string markdown = formatted.ReadToEnd();
        File.WriteAllText(outputPath, markdown, Encoding.UTF8);
        int rows = 0;
        using var sr = new StringReader(markdown);
        string? line;
        while ((line = sr.ReadLine()) != null)
        {
            if (line.Contains('|', StringComparison.Ordinal))
                rows++;
        }
        return rows > 0
            ? rows
            : (string.IsNullOrWhiteSpace(markdown) ? 0 : 1);
    }
}

Lorsque le Markdown formaté n’est pas disponible, vérifiez les fonctionnalités et les tableaux structurés :

if (!parser.Features.Tables)
{
    File.WriteAllText(
        outputPath,
        "_Tables extraction is not supported for this file._\n",
        Encoding.UTF8);
    return 0;
}

IEnumerable<PageTableArea>? tables = parser.GetTables();
if (tables == null)
{
    File.WriteAllText(outputPath, "_No tables returned._\n", Encoding.UTF8);
    return 0;
}

Les systèmes en aval peuvent archiver le Markdown à côté du fichier XLSX source, ou injecter directement les tableaux à tubes dans les panneaux de chat du client MCP sans convertisseur supplémentaire.


Pourquoi les équipes de plateforme doivent conserver à la fois le Docker MCP et les miroirs de bibliothèque ?

Conservez le Docker MCP lorsque les clients MCP doivent appeler des outils nommés sur des fichiers sous /data via ghcr.io/groupdocs-parser/parser-net-mcp. Conservez les miroirs de bibliothèque lorsque les PR doivent prouver get_document_info, extract_text et extract_tables sans poignée de main en direct. Cette double voie sépare la politique de conteneur des régressions d’analyse. Épinglez un tag de production et exécutez les miroirs .NET dans le CI à chaque mise à jour du package Parser, comme le montre le dépôt d’exemple.


Flux de travail réel : intégration des outils de documents pour un parc de clients MCP partagé

Une équipe de plateforme qui soutient trois escouades produit maintient une base de client MCP unique. Chaque escouade dépose des politiques DOCX et des feuilles de taux XLSX dans un volume de documents partagé. Avant de promouvoir un nouveau tag parser-net-mcp, l’équipe exécute l’hôte console .NET : le JSON d’enregistrement est régénéré, document-info.json est comparé aux valeurs d’or (2 pages / 15214 octets pour le DOCX de test), les comptes de caractères du texte sont journalisés, et le Markdown de Sheet1/Sheet2 du XLSX d’exemple est revu pour la structure des tableaux à tubes.

Ce flux de travail correspond directement aux étapes ci‑dessus. L’étape 1 est la configuration du parc. Les étapes 2‑4 sont les portes hors ligne. Ce n’est qu’après le passage de ces portes que l’image de conteneur épinglée est déployée sur les hôtes clients MCP. En cas d’échecs spécifiques à Docker, les opérateurs utilisent le MCP troubleshooting guide.


Impact métier : ce que cela change

Métrique Avant (ad‑hoc) Après (GroupDocs.Parser + MCP)
Enregistrement du client Notes manuelles, dérive par ordinateur portable JSON mcpServers versionné
Vérifications de contrat d’outil Seulement après échecs d’appels MCP en direct Fixtures JSON/texte/Markdown hors ligne
Livraison de tableaux au chat Convertisseurs CSV personnalisés Markdown aligné avec extract_tables
Distribution du package Attente d’un NuGet MCP Serveur Docker‑only clair + bibliothèque NuGet
Dérive d’image :latest flottant Tags épinglés comme :26.9.0
Traçabilité d’audit Journaux de chat uniquement Artefacts Result/ par exécution

L’effet cumulé est un onboarding plus rapide des clients MCP et moins de surprises en production lorsque la politique de conteneur et le comportement d’analyse évoluent à des rythmes différents.


Autres scénarios de plateforme où cela s’applique

Une fois l’enregistrement et les miroirs en place, les mêmes API supportent :

  • Portes de pré‑ingestion : rejeter les téléchargements lorsque pageCount ou sizeBytes sortent des limites de politique avant que les clients MCP n’exécutent
  • Briefings de feuilles de calcul : envoyer des tableaux Markdown depuis XLSX vers des bots de stand‑up
  • Packs de fumée multi‑format : garder des échantillons DOCX, XLSX et PDF à côté de la configuration MCP pour des régressions hebdomadaires
  • Déploiements sidecar : exécuter GroupDocs.Parser.Mcp à côté d’une API .NET qui utilise encore le Parser en‑processus pour des jobs internes

Démarrage dans votre environnement de plateforme

Vous avez vu comment GroupDocs.Parser gère les outils de documents MCP pour les équipes de plateforme sur .NET. Prochaines étapes :

Ressources