Hoe platformteams GroupDocs.Parser gebruiken om documenttools in MCP-clients op .NET te integreren

💡 Volledig werkend voorbeeld beschikbaar op GitHub: parser-mcp-document-tools-dotnet

De platformuitdaging: waarom documenttools stagneren bij MCP-grenzen

Docker‑ondersteunde documenttools voor MCP‑clients zijn een GroupDocs.Parser.Mcp‑implementatiepatroon op .NET dat een container‑image koppelt aan offline bibliotheekcontroles voor get_document_info, extract_text en extract_tables. Platform‑engineergroepen die documenttools voor assistenten leveren, worstelen zelden met “kunnen we een DOCX parseren?”. Ze worstelen met een scherpere beperking: de MCP‑server moet in client‑configuraties verschijnen als een benoemde tool‑lijst, terwijl de parser‑engine zo groot is dat GroupDocs.Parser.Mcp alleen als een container‑image wordt geleverd, niet als een NuGet‑package.

Wanneer een product‑squad vraagt om document‑info, platte tekst en chat‑klare tabellen binnen een MCP‑client, erft het platformteam twee sporen. Spoor één is operaties: docker run met een volume op /data, vastgezette tags zoals :26.9.0, en een stabiele mcpServers‑vermelding. Spoor twee is verificatie: bewijzen dat GroupDocs.Parser voor .NET dezelfde feiten retourneert als die tools voordat iemand afhankelijk wordt van een live handshake. Mis je één van de sporen, dan verschijnen fouten als lege MCP‑client‑antwoorden in plaats van een mislukte unit‑test.

Wat die teams nodig hebben is expliciet: een registratiesnippet die ze in MCP‑clients kunnen plakken, plus offline C#‑aanroepen die JSON, tekst en Markdown‑artefacten voor review schrijven. Ik kwam hierachter toen een partner vroeg om extract_tables in chat voordat Docker was goedgekeurd op ontwikkelaars‑laptops – de bibliotheek‑mirrors hielden de levering gaande terwijl security de container‑review afrondde.

Industry snapshot: GroupDocs.Parser.Mcp wordt gepubliceerd op ghcr.io/groupdocs-parser/parser-net-mcp en documenteert een Docker‑only distributie omdat de engine de NuGet‑grootte‑limieten overschrijdt. Lokale demo’s verifiëren daarom tool‑equivalente API’s zonder een live MCP‑sessie (MCP docs).

Waarom generieke benaderingen hier tekortschieten

Teams proberen meestal een van deze paden voordat ze een dedicated MCP‑documentserver adopteren:

  • Ad‑hoc shell‑scripts rond desktop‑converters: broos over DOCX en XLSX, en ze presenteren geen benoemde MCP‑tools.
  • Parser alleen aanroepen in een private API: werkt in‑process, maar MCP‑clients zien get_document_info of extract_text nooit als first‑class tools.
  • Wachten op een NuGet MCP‑package: niet beschikbaar voor deze server; het gepubliceerde pad is de container‑image.

GroupDocs.Parser sluit de kloof door de Docker MCP‑server te koppelen aan dezelfde Parser‑API’s die jouw .NET‑services al gebruiken.

De oplossing: GroupDocs.Parser in een platform‑MCP‑workflow

GroupDocs.Parser voor .NET wordt de verificatie‑helft van het MCP‑verhaal. Parser.GetDocumentInfo, Parser.GetText, GetFormattedText(Markdown) en GetTables spiegelen de tools die GroupDocs.Parser.Mcp aan MCP‑clients blootstelt. De voorbeeld‑repository schrijft Result/mcp-server.example.json voor registratie, en test vervolgens de drie meest gebruikte tools tegen gebundelde DOCX‑ en XLSX‑bestanden zodat operators de output onder Result/ kunnen inspecteren.

Om de onderstaande implementatie te volgen, heb je nodig:

  • .NET 8 SDK
  • GroupDocs.Parser 26.10.0 (temporary license)
  • Voorbeeld‑documenten (de repo bevat sample.docx, sample.xlsx, sample.pdf)
  • Docker Engine alleen wanneer de live MCP‑server wordt gestart
dotnet add package GroupDocs.Parser --version 26.10.0

Implementatie van MCP‑documenttools stap voor stap

Hier zie je hoe je GroupDocs.Parser.Mcp registreert en de tool‑equivalente API’s verifieert. Het scenario komt overeen met een platform‑squad die documenttools voor assistenten onboardt op .NET 8.

Stap 1 - De Docker MCP‑registratie genereren

Schrijf een mcpServers‑vermelding die de container interactief draait en de host‑documentenmap mount op /data. Zet tags vast in gedeelde configuraties.

// 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
            }
        }
    },

Ga verder met de tool‑lijst en schrijf UTF‑8 JSON voor client‑import:

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

Stap 2 - get_document_info spiegelen voor preflight‑controles

MCP‑clients roepen vaak get_document_info aan vóór zwaardere tools. Spiegelen dat contract met Parser.GetDocumentInfo zodat schema’s stabiel blijven.

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

Waarom deze velden belangrijk zijn voor platform‑ops:

  • fileType: Bevestigt dat de parser het formaat herkende vóórdat tekst‑tools draaien
  • pageCount: Goedkope indicator voor het dimensioneren van MCP‑client‑contextbudgetten
  • sizeBytes: Ondersteunt quota‑ en anomaliedetectie bij inkomende uploads

Op de gebundelde sample.docx meldt de run een Microsoft Word Open XML‑type, 2 pagina’s en 15214 bytes.

Stap 3 - extract_text spiegelen voor assistent‑leesbare output

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;

Het retourneren van het teken‑aantal geeft CI‑ en console‑omgevingen een meetbaar succes‑signaal dat overeenkomt met wat operators verwachten van de MCP extract_text‑tool.

Stap 4 - extract_tables spiegelen als Markdown voor chat‑UIs

Geef de voorkeur aan geformatteerde Markdown, val dan terug op pipe‑tabellen van GetTables zodat chat‑clients een consistent renderpad behouden.

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

Wanneer geformatteerde Markdown niet beschikbaar is, controleer dan features en structurele tabellen:

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

Downstream‑systemen kunnen de Markdown naast de bron‑XLSX archiveren, of pipe‑tabellen rechtstreeks in MCP‑client‑chat‑panels voeren zonder een tweede converter.

Waarom platformteams zowel Docker MCP als bibliotheek‑mirrors moeten behouden

Behoud Docker MCP wanneer MCP‑clients benoemde tools moeten aanroepen tegen bestanden onder /data via ghcr.io/groupdocs-parser/parser-net-mcp. Bewaar bibliotheek‑mirrors wanneer PR’s moeten bewijzen dat get_document_info, extract_text en extract_tables werken zonder een live handshake. Dat duale pad scheidt container‑beleid van parser‑regressies. Zet een productietag vast en voer de .NET‑mirrors uit in CI bij elke Parser‑package‑bump, zoals de voorbeeld‑repo laat zien.

Werkelijke workflow: onboarding van documenttools voor een gedeelde MCP‑clientvloot

Een platformteam dat drie product‑squads ondersteunt, onderhoudt één MCP‑client‑baseline. Elke squad plaatst DOCX‑beleid en XLSX‑tariefbladen in een gedeelde documenten‑volume. Voordat een nieuw parser-net-mcp‑tag wordt gepromoveerd, draait het team de .NET‑console‑host: registratie‑JSON wordt opnieuw gegenereerd, document-info.json wordt vergeleken met gouden waarden (2 pagina’s / 15214 bytes voor de smoke DOCX), teken‑aantallen van tekst worden gelogd, en Sheet1/Sheet2‑Markdown van het XLSX‑voorbeeld wordt beoordeeld op pipe‑table‑structuur.

Die workflow map direct naar de bovenstaande stappen. Stap 1 is de vloot‑configuratie. Stappen 2‑4 zijn de offline poorten. Alleen nadat die poorten slagen, wordt de vastgezette container‑image uitgerold naar MCP‑client‑hosts. Voor Docker‑specifieke fouten gebruiken operators de MCP troubleshooting guide.

Zakelijke impact: wat dit verandert

Metric Before (ad‑hoc) After (GroupDocs.Parser + MCP)
Clientregistratie Handmatige notities, afwijking per laptop Ingecheckte mcpServers JSON
Toolcontractcontroles Alleen nadat live MCP‑aanroepen falen Offline JSON/tekst/Markdown fixtures
Tabellevering aan chat Aangepaste CSV-converters Markdown afgestemd op extract_tables
Pakketdistributie Verwachting van NuGet MCP Duidelijke Docker‑only server + NuGet‑bibliotheek
Image‑drift Zwevende :latest Vastgezette tags zoals :26.9.0
Auditspoor Alleen chatlogs Result/ artefacten per run

Het samengestelde effect is snellere onboarding voor MCP‑clients en minder productie‑verrassingen wanneer container‑beleid en parser‑gedrag op verschillende klokken lopen.

Andere platformscenario’s waar dit past

Zodra registratie en mirrors aanwezig zijn, ondersteunen dezelfde API’s:

  • Pre‑ingest‑poorten: uploads afwijzen wanneer pageCount of sizeBytes buiten het beleid vallen vóórdat MCP‑clients draaien
  • Spreadsheet‑briefings: Markdown‑tabellen uit XLSX naar stand‑up‑bots sturen
  • Multi‑format smoke‑packs: DOCX, XLSX en PDF‑samples naast de MCP‑config bewaren voor wekelijkse regressie
  • Sidecar‑rollouts: GroupDocs.Parser.Mcp naast een .NET‑API draaien die nog steeds in‑process Parser gebruikt voor interne taken

Aan de slag in jouw platformomgeving

Je hebt gezien hoe GroupDocs.Parser MCP‑documenttools voor platformteams op .NET afhandelt. Volgende stappen:

Resources