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-mcpet 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_infoouextract_textcomme 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écutentpageCount: signal économique pour dimensionner les budgets de contexte des clients MCPsizeBytes: 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
pageCountousizeBytessortent 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 :
- Commencer gratuitement : Obtenir une licence temporaire
- Lire la configuration MCP : Documentation GroupDocs.Parser MCP
- Suivre le cas d’usage : Analyser des documents via MCP
- Explorer les exemples : Exemples GroupDocs.Parser pour .NET
- Poser des questions : Forum Parser