Välkomna till del 9! I tidigare delar , byggde vi ett robust RAG-system som bearbetar markerdown-poster och gör dem sökbara genom semantiska inbäddar. Dokling - en kraftfull dokumentbearbetande bibliotek som kan integrera PDFs , DOCX M SK2 och andra formater , vilket gör vår advokat GPT verkligt komplex

NOTET: Det här är en del av mina experiment med AI ( assisterad redigering ) + mitt eget redigerande M SK4 Samma röst, , samma pragmatism,; bara snabbare fingrar

Det är inte så att jag behöver det här för bloggen. Men för avsluta tänkte jag att jag skulle visa hur man enkelt kan lägga till dokumentinspegförmågan i din RAG pipeline. Detta är särskilt användbart om du bygger ett system som behöver processa lagdokument. , contract, , eller andra affärsdokument.

Varför är dokumentingestion viktigt

Än så länge kan vår advokat GPT bara förstå markerdown-filer.

• PDF-kontrakt - livsbloodet för rättsarbete
• Woorddokument - anteckningar
• PowerPoint-presentationer - kunders pitcher , fallförteckningar
• Skanderade dokument - äldre rekord som behöver OCR
• HTML-sidor - innehåll på webben , online resources

Om vi vill att vårt system ska agera som en riktig juristisk AI-assistent, måste det konsumera alla dessa.

Vad är Docling?

Dokling är en öppen dokumentbehandlings-Toolkit från IBM.

Varför markerdown? ?? Därför att detta är vad vår nuvarande ledning redan förstår. !? Vi har redan byggt chunking, ,, inbäddad generation och ,, och vektorlagning för markdown innehåll. .? Genom att konvertera allt till markdown först, M SK7, kan vi återanvända all den infrastrukturen.

Vad Docling hanterar:

• PDF extraktion (both native and scanned via OCR
• DOCX och DOC-Dater
• PPTX-presentationer
• HTML-sidor
• Bilder med text (via OCR

Vad gör det speciellt:

• Bevarar dokumentstrukturen (rubriker , listor
• Handler komplexa layouts (multi-columnM SK2 blandad innehåll
• Tabell extraktion fungerar faktiskt (olik många PDF-Parser )
• Runner lokalt - inga data som skickas till externa tjänster

Att köra dokumentering som en tjänst

Dokling själv är en Python bibliotek, men teamet erbjuder Docling-Serve - en REST API-wrapper som vi kan kalla från C

Start av tjänsten

Det enklaste sättet att köra Docling är via Docker:

docker run -p 5001:5001 quay.io/docling-project/docling-serve

Det där' är det . Du har nu en dokumentomvandlingsAPI som körs på http://localhost:5001.

Vill du leka med den interaktivt? Aktivera gränssnittet

docker run -p 5001:5001 -e DOCLING_SERVE_ENABLE_UI=1 quay.io/docling-project/docling-serve

Sedan besök http://localhost:5001/ui att dra dokument i droppar, och se resultatet.

Att välja den rätta bilden

Docling erbjuder flera containerbilder beroende på din hårdvara:

Om du gör tung OCR-arbete (skannade dokument ), är GPU-bilderna värda extra storleken | . | För digitala apparater

Att lägga till Docker Compose

För produktionen, lägg Docling till din existerande stapel:

services:
  docling:
    image: quay.io/docling-project/docling-serve:latest
    ports:
      - "5001:5001"
    volumes:
      - docling_cache:/root/.cache
    restart: unless-stopped

Cachevolumen är viktigt. - Docling laddar ned ML-modeller på första gången.

Docling API

Innan du dyker in i C, ska du förstå vad vi arbetar med.

Att omvandla ett dokument från URL

curl -X POST 'http://localhost:5001/v1/convert/source' \
  -H 'Content-Type: application/json' \
  -d '{
    "sources": [{"kind": "http", "url": "https://example.com/contract.pdf"}],
    "options": {"to_formats": ["md"]}
  }'

Att ladda upp en lokal file

curl -X POST 'http://localhost:5001/v1/convert/file' \
  -F '[email protected]'

Båda kommer tillbaka JSON som innehåller omvandlat markerdown, plus metadata som sidatal och upptäckt filetyp.

Nyckeloptioner

• to_formats: Vilken utgång vill du få - md (markdown), json (strukturerad ), eller text (plain
• ocr: Aktivera
• table_mode: fast eller accurate - handelshastighet för bordskvalitet

Integrering med C#

Eftersom Docling är en REST- tjänst, så är integreringen enkel med HTTP sändningar.

1. Att skapa en dokumenteringsclient

Vi behöver en tjänst som hanterar HTTP kommunikationen:

public class DoclingClient
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;

    public DoclingClient(HttpClient httpClient, string baseUrl = "http://localhost:5001")
    {
        _httpClient = httpClient;
        _baseUrl = baseUrl;
    }

    public async Task<string?> ConvertFromUrlAsync(string documentUrl)
    {
        var request = new
        {
            sources = new[] { new { kind = "http", url = documentUrl } },
            options = new { to_formats = new[] { "md" } }
        };

        var response = await _httpClient.PostAsJsonAsync(
            $"{_baseUrl}/v1/convert/source", request);

        if (!response.IsSuccessStatusCode)
            return null;

        var result = await response.Content.ReadFromJsonAsync<DoclingResponse>();
        return result?.Document?.MarkdownContent;
    }

    public async Task<string?> ConvertFileAsync(string filePath)
    {
        using var content = new MultipartFormDataContent();
        using var fileStream = File.OpenRead(filePath);
        content.Add(new StreamContent(fileStream), "files", Path.GetFileName(filePath));

        var response = await _httpClient.PostAsync(
            $"{_baseUrl}/v1/convert/file", content);

        if (!response.IsSuccessStatusCode)
            return null;

        var result = await response.Content.ReadFromJsonAsync<DoclingResponse>();
        return result?.Document?.MarkdownContent;
    }
}

Den viktigaste insikten, :, är att vi får markdown tillbaka.

2. Införing i det existerande pippelet

Kom ihåg vårt inspegningsrör från del 4? Det tar markdown , delar av det M SK2 genererar inbäddar , och lagrar i Qdrant MSC4 Vi behöver bara lägga till Docling som en ny ingångskälla

public async Task ProcessDocumentAsync(string filePath)
{
    // Step 1: Convert to markdown with Docling
    var markdown = await _doclingClient.ConvertFileAsync(filePath);
    
    if (string.IsNullOrEmpty(markdown))
    {
        _logger.LogError("Failed to convert {File}", filePath);
        return;
    }

    // Step 2: Parse the markdown (reuse existing code!)
    var document = _markdownParser.ParseFromContent(markdown, Path.GetFileName(filePath));

    // Step 3: Chunk it (reuse existing code!)
    var chunks = _chunker.ChunkDocument(document);

    // Step 4: Generate embeddings (reuse existing code!)
    await _embedder.GenerateEmbeddingsAsync(chunks);

    // Step 5: Store in vector database (reuse existing code!)
    await _vectorStore.UpsertChunksAsync(chunks);
}

Se hur lite ny kod vi behöver? Det fina med att bygga en pipeline runt markdown är att varje ny inmatningsformat bara behöver en konvertör - allting i nedströmmen är lika

3. Handle olika typer av dokument

Olika dokument kan behöva olika behandling:

public async Task ProcessDocumentAsync(string filePath, string[] categories)
{
    var extension = Path.GetExtension(filePath).ToLower();
    
    // Scanned PDFs need OCR, which is slower
    var useOcr = extension == ".pdf" && await IsScannedPdfAsync(filePath);
    
    var markdown = await _doclingClient.ConvertFileAsync(filePath, new ConvertOptions
    {
        EnableOcr = useOcr,
        TableMode = extension == ".xlsx" ? "accurate" : "fast"
    });

    // ... rest of pipeline
}

Tillvägagångspunkter

Konvertering av dokument är inte't omedelbart. HärM SK2 vad man förväntar sigMSC3

Tipps för produktion:

1. Processa asynkront - Don

2. Cacheresultat - Bevara omvandlade markering

3. Använd GPU för OCR - Om du processar stora mängder av skannade dokument, är CUDA-bilderna 5-10x snabbare,

4. Springa över OCR när möjligt - Digitala-intillverkliga PDF-versioner behöver inga OCR, . gör dokumentering automatiskt,- upptäcker,, men du kan tvinga det av för kända digitala källor,

Automatisk dokumentvakting

För en praktisk upplevelse-off experience, titta på en folder för nya dokument

public class DocumentWatcher : BackgroundService
{
    private FileSystemWatcher _watcher;

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _watcher = new FileSystemWatcher("/documents/incoming")
        {
            Filters = { "*.pdf", "*.docx", "*.pptx" }
        };

        _watcher.Created += async (s, e) => 
        {
            await Task.Delay(1000); // Wait for file to finish writing
            await _ingestionService.ProcessDocumentAsync(e.FullPath);
        };

        _watcher.EnableRaisingEvents = true;
        return Task.CompletedTask;
    }
}

Släng in en PDF i foldern, och den blir automatiskt omvandlad, knutenM SK2 inbäddad , och gör den sökbar

Vad detta gör möjligt

Med Docling integrerad, kan vår advokat GPT nu,

• Ingripa kunderskontrakter - ladda upp en PDF, ställa frågor om specifika clauser
• sök genom korta - Hitta argumentet du gjorde i ett liknande fall
• Referens- forskningsartiklar - Lägg till akademiska PDFs i din kunskapsbas
• Processa arvdokument - OCR de gamla skannade rekorden

Nyckelinsikten är att dokumentformat bara är ett inmatningsproblem.

sammanfattning

Vi” ' ” har lagt till dokumentingestion till vår advokat GPT“ : ”

1. Dokling konverterar PDFs, DOCX, PPTX till markdown
2. Docling-Serve ompackar den i en REST API som vi kan ringa från C#
3. Vår existerande pipeline hanterar allt därifrån - inga ändringar behövs

Detta är kraften i att bygga kring ett gemensamt format

Seri Navigation

• Del 1: Inleiding & Arkitektur
• Del 2: GPU Setup & CUDA i C#
• Del 3: Understanding Embeddings | & | Vektordatabaser
• Del 4: Byggnaden av införingsledning
• Del 5: Windows Client
• Del 6: Lokal LLM integration
• Del 7: innehållsgenerering & Vinniga ingenjörskonst
• Del 8: Utvecklade egenskaper & Tillverkning av produktion
• Del 9: Dokumentinföring med dokumentisering (this postM SK1

resurser

• Docling GitHub
• Docling Serve GitHub
• Dokumentet (arXiv)
• API Dokumentation ( när det körs lokalt )