Jak zespoły platformowe używają GroupDocs.Parser do integracji narzędzi dokumentów z klientami MCP w .NET

💡 Pełny działający przykład dostępny na GitHubie:
parser-mcp-document-tools-dotnet

Wyzwanie platformy: Dlaczego narzędzia dokumentów zatrzymują się na granicach MCP

Narzędzia dokumentów oparte na Dockerze dla klientów MCP to wzorzec wdrożeniowy GroupDocs.Parser.Mcp w .NET, który łączy obraz kontenera z offline’owymi kontrolami biblioteki dla get_document_info, extract_text i extract_tables. Grupy inżynierii platformowej, które dostarczają narzędzia dokumentów dla asystentów, rzadko zmagają się z pytaniem „czy możemy sparsować DOCX?”. Zmagają się z ostrzejszym ograniczeniem: serwer MCP musi pojawić się w konfiguracjach klienta jako nazwana lista narzędzi, podczas gdy silnik parsowania jest na tyle duży, że GroupDocs.Parser.Mcp jest dystrybuowany wyłącznie jako obraz kontenera, a nie jako pakiet NuGet.

Gdy zespół produktowy prosi o informacje o dokumencie, czysty tekst i tabele gotowe do czatu w kliencie MCP, zespół platformowy dziedziczy dwa toru. Tor pierwszy to operacje: docker run z wolumenem pod /data, przypięte tagi takie jak :26.9.0 i stabilny wpis mcpServers. Tor drugi to weryfikacja: udowodnienie, że GroupDocs.Parser for .NET zwraca te same fakty, które zwróciłyby narzędzia, zanim ktokolwiek zależy od żywego połączenia. Pominiesz którykolwiek tor, a awarie pojawią się jako puste odpowiedzi klienta MCP zamiast nieudanego testu jednostkowego.

Co te zespoły potrzebują, jest jasne: fragment rejestracji, który mogą wkleić do klientów MCP, plus offline’owe wywołania C#, które zapisują JSON, tekst i artefakty Markdown do przeglądu. Spotkałem się z tym, gdy partner poprosił o extract_tables w czacie, zanim Docker został zatwierdzony na laptopach deweloperów – lustrzane biblioteki utrzymały przepływ dostawy, podczas gdy bezpieczeństwo kończyło przegląd kontenera.

Industry snapshot: GroupDocs.Parser.Mcp jest publikowany pod adresem
ghcr.io/groupdocs-parser/parser-net-mcp i dokumentuje dystrybucję wyłącznie Docker, ponieważ silnik przekracza limity rozmiaru NuGet. Lokalne demonstracje w ten sposób weryfikują API równoważne narzędziom bez wymogu sesji MCP na żywo (MCP docs).


Dlaczego ogólne podejścia zawodzą tutaj

Zespoły zazwyczaj próbują jednej z następujących ścieżek przed przyjęciem dedykowanego serwera dokumentów MCP:

  • Skrypty ad‑hoc wokół konwerterów desktopowych: kruche przy DOCX i XLSX, nie prezentują nazwanych narzędzi MCP.
  • Wywoływanie Parsera wyłącznie w prywatnym API: działa w‑process, ale klienci MCP nigdy nie widzą get_document_info ani extract_text jako narzędzi pierwszej klasy.
  • Oczekiwanie na pakiet NuGet MCP: nie jest dostępny dla tego serwera; publikowaną ścieżką jest obraz kontenera.

GroupDocs.Parser zamyka lukę, łącząc serwer Docker MCP z tymi samymi API Parsera, które już używają Twoje usługi .NET.


Rozwiązanie: GroupDocs.Parser w przepływie pracy platformy MCP

GroupDocs.Parser for .NET staje się weryfikacyjną połową historii MCP. Parser.GetDocumentInfo, Parser.GetText, GetFormattedText(Markdown) i GetTables odzwierciedlają narzędzia, które GroupDocs.Parser.Mcp udostępnia klientom MCP. Przykładowe repozytorium zapisuje Result/mcp-server.example.json do rejestracji, a następnie testuje trzy najczęściej używane narzędzia na dołączonych plikach DOCX i XLSX, aby operatorzy mogli sprawdzić wyniki w katalogu Result/.

Aby podążać za implementacją poniżej, będziesz potrzebować:

  • .NET 8 SDK
  • GroupDocs.Parser 26.10.0
    (temporary license)
  • Przykładowe dokumenty (repozytorium zawiera sample.docx, sample.xlsx, sample.pdf)
  • Docker Engine tylko przy uruchamianiu żywego serwera MCP
dotnet add package GroupDocs.Parser --version 26.10.0

Implementacja narzędzi dokumentów MCP krok po kroku

Oto jak zarejestrować GroupDocs.Parser.Mcp i zweryfikować API równoważne narzędziom. Scenariusz odpowiada zespołowi platformowemu wprowadzającemu narzędzia dokumentów dla asystentów w .NET 8.

Krok 1 – Emitowanie rejestracji Docker MCP

Zapisz wpis mcpServers, który uruchamia kontener interaktywnie i montuje folder dokumentów hosta pod /data. Przypnij tagi w współdzielonych konfiguracjach.

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

Kontynuuj listę narzędzi i zapisz JSON UTF‑8 do importu klienta:

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

Krok 2 – Odbicie get_document_info dla wstępnych kontroli

Klienci MCP często wywołują get_document_info przed cięższymi narzędziami. Odbij ten kontrakt przy użyciu Parser.GetDocumentInfo, aby schematy pozostały stabilne.

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

Dlaczego te pola są ważne dla operacji platformowych:

  • fileType: Potwierdza, że parser rozpoznał format przed uruchomieniem narzędzi tekstowych
  • pageCount: Tani sygnał do określania budżetów kontekstu klienta MCP
  • sizeBytes: Wspiera limity i kontrole anomalii przy przyjmowanych plikach

Na dołączonym sample.docx zapisany wynik zgłasza typ Microsoft Word Open XML, 2 strony i 15214 bajtów.

Krok 3 – Odbicie extract_text dla czytelnego wyjścia asystenta

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;

Zwrócenie liczby znaków daje CI i konsolom mierzalny sygnał sukcesu, który odpowiada temu, czego operatorzy oczekują od narzędzia MCP extract_text.

Krok 4 – Odbicie extract_tables jako Markdown dla interfejsów czatu

Preferuj sformatowany Markdown, a w razie potrzeby przejdź do tabel w formacie pipe z GetTables, aby klienci czatu zachowali spójną ścieżkę renderowania.

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

Gdy sformatowany Markdown jest niedostępny, sprawdź funkcje i strukturalne tabele:

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

Systemy downstream mogą archiwizować Markdown obok źródłowego XLSX lub wprowadzać tabele pipe bezpośrednio do paneli czatu klienta MCP, bez potrzeby drugiego konwertera.


Dlaczego zespoły platformowe powinny utrzymywać zarówno Docker MCP, jak i lustrzane biblioteki?

Utrzymuj Docker MCP, gdy klienci MCP muszą wywoływać nazwane narzędzia przeciwko plikom w /data za pośrednictwem ghcr.io/groupdocs-parser/parser-net-mcp. Utrzymuj lustrzane biblioteki, gdy PR‑y muszą udowadniać get_document_info, extract_text i extract_tables bez żywego połączenia. Ten podwójny tor oddziela politykę kontenerów od regresji parsowania. Przypnij tag produkcyjny i uruchamiaj .NET‑owe lustrzane wywołania w CI przy każdym podniesieniu wersji pakietu Parser, jak pokazuje przykładowe repozytorium.


Rzeczywisty przepływ pracy: Wprowadzanie narzędzi dokumentów dla wspólnej floty klientów MCP

Zespół platformowy wspierający trzy zespoły produktowe utrzymuje jedną bazę konfiguracji klienta MCP. Każdy zespół wrzuca polityki DOCX i arkusze XLSX do wspólnego wolumenu dokumentów. Przed wypuszczeniem nowego tagu parser-net-mcp zespół uruchamia hosta konsolowego .NET: JSON rejestracji jest regenerowany, document-info.json jest porównywany ze złotymi wartościami (2 strony / 15214 bajtów dla testowego DOCX), liczone są liczby znaków tekstu, a Markdown z Sheet1/Sheet2 przykładowego XLSX jest przeglądany pod kątem struktury tabel pipe.

Ten przepływ mapuje się bezpośrednio na opisane wyżej kroki. Krok 1 to konfiguracja floty. Kroki 2‑4 to offline’owe bramki. Dopiero po ich przejściu przypięty obraz kontenera jest wdrażany na hostach klientów MCP. W przypadku awarii specyficznych dla Dockera operatorzy korzystają z
MCP troubleshooting guide.


Wpływ biznesowy: Co to zmienia

Metryka Przed (ad‑hoc) Po (GroupDocs.Parser + MCP)
Rejestracja klienta Ręczne notatki, dryf na laptopie Zatwierdzony JSON mcpServers
Sprawdzanie kontraktu narzędzi Tylko po niepowodzeniach żywych wywołań MCP Offline’owe fixture’y JSON/tekst/Markdown
Dostarczanie tabel do czatu Niestandardowe konwertery CSV Markdown zgodny z extract_tables
Dystrybucja pakietu Oczekiwanie na NuGet MCP Jasny serwer tylko Docker + biblioteka NuGet
Dryf obrazu Pływający :latest Przypięte tagi, np. :26.9.0
Ścieżka audytu Tylko logi czatu Artefakty Result/ na każde uruchomienie

Skumulowany efekt to szybsze wprowadzanie klientów MCP i mniej niespodzianek w produkcji, gdy polityka kontenerów i zachowanie parsowania poruszają się w różnych rytmach.


Inne scenariusze platformowe, w których to pasuje

Po wdrożeniu rejestracji i lustrzanych bibliotek, te same API obsługują:

  • Bramy wstępne przy przyjmowaniu: odrzucaj uploady, gdy pageCount lub sizeBytes wykraczają poza politykę, zanim klienci MCP je przetworzą
  • Briefingi arkuszy: wysyłaj tabele Markdown z XLSX do botów stand‑upowych
  • Pakiety dymne wieloformatowe: utrzymuj próbki DOCX, XLSX i PDF obok konfiguracji MCP dla cotygodniowej regresji
  • Sidecar‑owe wdrożenia: uruchamiaj GroupDocs.Parser.Mcp obok .NET‑owego API, które nadal używa wewnętrznego Parsera do zadań wewnętrznych

Rozpoczęcie w środowisku platformy

Widziałeś, jak GroupDocs.Parser obsługuje narzędzia dokumentów MCP dla zespołów platformowych w .NET. Kolejne kroki:

Resources