# Aufbau eines Anwalts-GPT-" für Ihren Blog.

<!--category-- AI, LLM, Docling, RAG, C#, AI-Article, mostlylucid.blogllm -->
<datetime class="hidden">2025-12-15T22:45</datetime>

Willkommen bei Part -9!. In vorherigen Teilen -,. wir-MSC2.ve baute ein robustes RAG-System, das Markdown Blogposts verarbeitet und sie durch semantische Einbettungen durchsuchbar macht -.. Jetzt ist es an der Zeit, unsere Fähigkeiten mit **Doktierung** Eine leistungsstarke Dokumentenverarbeitungs-Bibliothek, die PDFs aufnehmen kann. ,. DOCX., und andere Formate machen unseren Anwalt GPT wirklich umfassend

> HINWEIS:-Dies ist Teil meiner Experimente mit KI (-unterstütztes Abfassen-)- Meine eigene Bearbeitung - .- Dieselbe Stimme - gleiche Pragmatismus - gerade schnellere Finger - .-

Nicht, dass ich dies für den Blog brauche (-it-'s alle Markdown-MSC2 aber zur Fertigstellung Ich dachte mir, I'-d zeigen, wie man leicht hinzufügen Dokument Aufnahmefähigkeiten zu Ihrer RAG Pipeline .. . Dies ist besonders nützlich, wenn Sie bauen ein System, das juristische Dokumente verarbeiten muss ?,-Verträge oder andere Geschäftsdokumente

[TOC]

## Warum die Aufnahme von Dokumenten wichtig ist

Bislang kann unser Anwalt GPT nur Markdown-Dateien verstehen, die für einen Blog gut sind.,, aber wirkliche -, Weltwissensbasen enthalten.

- **PDF-Verträge** Das Lebensblut der juristischen Arbeit
- **Wortdokumente** Schriftzüge, Schriftsätze, Bewegungen, Korrespondenz
- **PowerPoint-Präsentationen** Zusammenfassungen des Falles
- **Gescannte Dokumente** Ältere Datensätze, die OCR benötigen
- **HTML-Seiten** Online-Ressourcen

Wenn wir wollen, dass unser System wie ein echter juristischer KI-Assistent handelt, dann muss es all diese Dinge verbrauchen.

## Was ist Docling?

[Doktierung](https://github.com/docling-project/docling) ist ein offenes Toolkit für die Verarbeitung von Dokumenten von IBM®..Denken Sie daran, als universeller Übersetzer für Dokumente... Sie füttern es mit einem PDF-Dokument namens ,.

Warum Markdown-?? Weil das, was unsere bestehende Pipeline bereits versteht, ! ist, dass wir bereits Chunking gebaut haben., embedding genery.,. and vector storage for Markdown content. .. Indem wir alles zuerst in Markdown konvertieren, können wir alle diese Infrastruktur wiederverwenden.

**Welche Docling-Handles?**

- PDF-Extraktion, sowohl native als auch gescannt über OCR.)
- DOCX und DOC-Dateien
- PPTX-Präsentationen
- HTML-Seiten
- Bilder mit Text

**Was macht es besonders?**

- Bewahrt die Dokumentenstruktur
- Behandelt komplexe Layouts (-multi---Spalte, gemischter Inhalt )-
- Tischextraktion funktioniert tatsächlich im Gegensatz zu vielen PDF-Parsern
- Läuft lokal aus, keine Daten an externe Dienste gesendet

## Docling als Dienst laufen lassen

Docling selbst ist eine Python-Bibliothek, aber das Team bietet [Docling Servieren](https://github.com/docling-project/docling-serve) Ein REST API Wrapper, den wir von C.#. anrufen können Dies ist der sauberste Integrationspfad.

### Starten des Dienstes

Der einfachste Weg, Docling zu laufen ist über Docker.

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

Das ist es .. Sie haben jetzt eine Dokumentkonvertierung API läuft bei `http://localhost:5001`.

Wollen Sie mit ihm interaktiv spielen??-Aktivieren Sie die Benutzeroberfläche

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

Dann besuchen Sie `http://localhost:5001/ui` um Dokumente zu ziehen und die Ergebnisse zu sehen

### Das richtige Bild wählen

Docling bietet mehrere Container-Images abhängig von Ihrer Hardware.

Bild - Anwendungsfall - Größe - Größe
|-------|----------|------|
| `docling-serve` Allgemeiner Zweck: ,, arbeitet überall
| `docling-serve-cpu` ,| , kleiner , , , nur , , | , ~4.4, GB ,| ,
| `docling-serve-cu126` NVIDIA-GPU mit CUDA-12.6, | und ~10, GB
| `docling-serve-cu128` NVIDIA-GPU mit CUDA-12.8, | und ~11.4, GB

Wenn du schwere OCR-Arbeit machst (Gescannte Dokumente),Die GPU-Bilder sind die Extragröße wert.. Für digitale -Native PDFs und Word docs,CPU ist fein.

### Hinzufügen zu Docker Compose

Für die Produktion fügen Sie das Docling zu Ihrem vorhandenen Stack hinzu.

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

Das Cache-Volume ist wichtig Downloaden von ML-Modellen auf dem ersten Lauf zu Docling und du willst sie bei jedem Neustart des Containers wieder herunterladen

## Die Docling-API

Vor dem Tauchen in den Code C.M.S.K.1, lassen Sie die ' verstehen, was wir mit der . arbeiten Docling Serve zeigt eine einfache REST API.

### Konvertieren eines Dokuments von der URL

```bash
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"]}
  }'
```

### Eine lokale Datei hochladen

```bash
curl -X POST 'http://localhost:5001/v1/convert/file' \
  -F 'files=@contract.pdf'
```

Beide geben JSON zurück, das den konvertierten Markdown enthält, sowie Metadaten wie Seitenanzahl und erkannten Dateityp.

### Schlüsseloptionen

- **`to_formats`**Welche Ausgabe Sie wünschen `md` (-Markierung `json` mit einer Dicke von mehr als 2 mm `text` ,(-plain , )-
- **`ocr`**:-Aktivieren von OCR-Deaktivieren von OSK2-Default-Aktivierung von :-Empfängern
- **`table_mode`**: `fast` oder `accurate` Handelsgeschwindigkeit für die Tischqualität

## Integrieren mit C-#

Da Docling ein REST-Service ist, ist die Integration einfach HTTP-Anrufe.

### Erstellen Sie einen Dokling Client

Wir brauchen einen Dienst, der die HTTP-Kommunikation behandelt.

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

Die Schlüsselinsights-: , wir erhalten Markdown zurück ,, , die direkt in unsere bestehende Pipeline Slots ,

### Einspeisung in die bestehende Rohrleitung

Erinnern Sie sich an unsere Aufnahme-Pipeline aus Teil 4?.Es nimmt markdown.,.Chunks es erzeugt Embeddings...,. und speichert in Qdrant... Wir müssen nur Docling als neue Eingangsquelle hinzufügen...

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

Sehen Sie, wie wenig neuer Code wir brauchen ..? . Die Schönheit des Bauens einer Pipeline um Markdown ist, dass jedes neue Eingabeformat nur einen Konverter benötigt . .

### Verschiedene Dokumenttypen behandeln

Unterschiedliche Dokumente könnten eine andere Behandlung benötigen

```csharp
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
}
```

## Leistungsbeurteilungen

Dokument-Konvertierung ist ' , nicht instant .. , Hier , ' , was zu erwarten

Art des Dokuments Typ des Dokumentes Typische Zeit
|--------------|--------------|
Einfaches PDF-Dokument Seiten
Komplexe PDF-Datei Seiten ) - Seite | - Sekunde 10-30 -
Gescanntes PDF mit OCR
Word-Dokument , |, Sekunden , |,
Sekundarbereich

**Tipps für die Produktion**

1. **asynchron verarbeiten** Blockierung auf Dokumentenkonvertierung: --Don-'-Queue-Dokumente und Prozess im Hintergrund:.-

2. **Ergebnisse des Caches** Speichern Sie den konvertierten Markdown ,. , wenn ein Dokument geändert hat , ( , überprüfen Sie die Datei hash , ), don , ' , reconvert ,. ,

3. **GPU für OCR verwenden** Wenn du viele gescannte Dokumente verarbeitest, sind die CUDA-Bilder schneller als ..

4. **OCR überspringen, wenn möglich** Digital – - – PDF-Dokumente benötigen nicht OCR.. – Dokling auto – - – detektiert zwar ,, aber Sie können es für bekannte digitale Quellen abzwingen.

## Automatisches Dokument ansehen

Für ein hands---off-Erlebnis, schauen Sie sich einen Ordner für neue Dokumente an

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

Lassen Sie ein PDF in den Ordner fallen und es wird automatisch konvertiert, klunked embedded , suchbar gemacht

## Was dies ermöglicht

Mit integriertem Docling®, , kann unser Anwalt GPT jetzt – : .

- **Aufnahme von Kundenverträgen** Fragen zu bestimmten Klauseln stellen
- **Durchsuchen von Briefen** Finden Sie dieses Argument, das Sie in einem ähnlichen Fall gemacht
- **Referenzforschungsberichte** Fügen Sie akademische PDFs zu Ihrer Wissensbasis hinzu
- **Vergangene Dokumente verarbeiten** OCR diese alten gescannten Datensätze

Die wichtigste Erkenntnis ist, dass das Dokumentformat nur ein Eingabeproblem ist..- Sobald alles markdown ist, kümmert sich unsere semantische Suche nicht mehr darum, woher der Inhalt kam.

## Zusammenfassung

Wir haben Dokument-Ingestion zu unserem Anwalt GPT.:

1. **Doktierung** Konvertiert PDFs.,, DOCX, , PPTX, um Markdown zu reinigen
2. **Docling Servieren** wickelt es in eine REST API ein, die wir von C.# aus anrufen können
3. **Unsere bestehende Pipeline** behandelt alles von dort aus keine Änderungen erforderlich

Dies ist die Macht des Bauens um ein gemeinsames Format... neue Eingabetypen sind einfach zu addieren... die Kernintelligenz bleibt gleich...

## Reihennavigation

- [Teil Einleitung](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- [Teil: GPU-Einrichtung von CUDA in C.#](/blog/building-a-lawyer-gpt-for-your-blog-part2)
- [Teil Verstehst du die Einbettungen? Vektordatenbanken](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Teil: Aufbau der Ingestion Pipeline](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Teil des Windows Clients](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [LLM-Integration vor Ort](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [Teil-Generierung von Inhalten](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [Teil 8:-Erweiterte Funktionen Produktionsbereitstellung](/blog/building-a-lawyer-gpt-for-your-blog-part8)
- **Teil: Dokumentenaufnahme mit Docling** Dieser Beitrag

## Aufkommen

- [Dokting GitHub](https://github.com/docling-project/docling)
- [Docling dienen GitHub](https://github.com/docling-project/docling-serve)
- [Dokling-Papier](https://arxiv.org/abs/2501.17887)
- [API-Dokumentation](http://localhost:5001/docs) Beim Betrieb vor Ort