API wyodrębniania rekwizytów — automatyzacja przetwarzania dokumentów

API do automatycznego wyodrębniania rekwizytów: jak przetwarzać dokumenty bez ręcznego wprowadzania

Ręczny input rekwizytów z dokumentów prowadzi do błędów i spowalnia procesy. Nasze API automatyzuje wyodrębnianie INN, KPP, BIK i innych danych z PDF, DOCX i innych formatów, zapewniając dokładność i integrację z 1C i systemami CRM. Rozwiązanie zmniejsza liczbę błędów przy przetwarzaniu dokumentów o 70% dzięki analizie kontekstowej i ścisłej walidacji.

Architektura przetwarzania dokumentów

System jest oparty na wieloetapowym potoku przetwarzania. Pierwszy etap to normalizacja danych wejściowych. Obsługiwane są następujące formaty:

• PDF z warstwą tekstową
• DOCX/DOC
• TXT w kodowaniach UTF-8 i CP1251
• RTF i HTML

Ważne ograniczenie: zeskanowane PDF i obrazy wymagają wstępnej obróbki za pomocą OCR. Nasze API działa wyłącznie z dokumentami tekstowymi, co jest kluczowe dla poprawnego funkcjonowania modelu NER.

Kluczowym etapem jest analiza kontekstowa z wykorzystaniem kombinacji wyrażeń regularnych i uczenia maszynowego. Dla każdego typu rekwizytu stosowane są specyficzne reguły:

• INN: sprawdzenie długości (10/12 cyfr) i sumy kontrolnej
• OGRN: walidacja struktury i sumy kontrolnej
• BIK: zgodność z rejestrem bankowym i sprawdzenie rachunku korespondentowego
• Rachunki rozliczeniowe: sprawdzenie zgodności z formatem i logiką BIK
• Nazwy prawne: normalizacja za pomocą słownika zarejestrowanych organizacji

Realizacja techniczna

Endpoint API jest zbudowany zgodnie z zasadami RESTful przy minimalnych wymaganiach co do żądania. Do działania wystarczy klucz API w nagłówku X-API-Key. Ciało żądania przesyłane jest jako multipart/form-data z polem file.

Krytyczne parametry

• Limit czasu przetwarzania: 120 sekund (minimalny zalecany interwał)
• Maksymalny rozmiar pliku: 20 MB
• Obsługiwane kodowania: UTF-8, CP1251 (autodetekcja)
• Format odpowiedzi: JSON z obowiązkowym polem success

Przykład obsługi błędów:

{
  "success": false,
  "error": "payload_too_large",
  "message": "Size fayla exceeds 20 MB"
}

Przykłady integracji

Aby przyspieszyć wdrożenie, przygotowano szablony kodu dla popularnych stosów technologicznych. Każdy przykład obejmuje obsługę limitów czasu i walidację odpowiedzi.

Python z obsługą błędów

import requests
from requests.exceptions import Timeout, RequestException

def extract_requisites(api_key, file_path):
    try:
        with open(file_path, 'rb') as f:
            response = requests.post(
                'https://api-k.ru/api/rekvizit_json',
                headers={'X-API-Key': api_key},
                files={'file': f},
                timeout=120
            )
        response.raise_for_status()
        return response.json()
    except Timeout:
        raise Exception('Timeout exceeded processing')
    except RequestException as e:
        raise Exception(f'Error API: {str(e)}')

1C:Enterprise 8.3

Cechą implementacji jest ręczne tworzenie żądania multipart. Kluczowe jest przestrzeganie kolejności nagłówków i prawidłowa obsługa danych binarnych:

Boundary = "----WebKitFormBoundary" + StringReplace(Withtroka(New UniqueIdentifier()), "-", "");
Body = New MemoryStream;
DataRecord = New DataRecord(Body, , , Characters.VK + Characters.PWith, "");

DataRecord.WriteWithtroku("--" + Boundary);
DataRecord.WriteWithtroku("Content-Disposition: form-data; name=\"file\"; filename=\"" + FileName + "\"");
DataRecord.WriteWithtroku("Content-Type: application/octet-stream");
DataRecord.WriteWithtroku("");
DataRecord.Write(FileBinaryData);

Co ważne

• Walidacja za pomocą sum kontrolnych: API nie zwraca danych z niepoprawną sumą kontrolną INN/OGRN
• Limity czasu: Ustaw interwał co najmniej 120 sekund dla skomplikowanych dokumentów
• Ograniczenia: Obsługiwane tylko formaty tekstowe, dokumenty zeskanowane wymagają wstępnej obróbki OCR
• Integracja z 1C: Zrealizowana poprzez ręczne formowanie żądań multipart
• Maksymalny rozmiar: Pliki powyżej 20 MB są odrzucane z kodem 413

Obsługa błędów i monitorowanie

System stosuje hybrydowe podejście do obsługi błędów. Dla każdego typu błędu przewidziano dedykowany kod HTTP oraz opis tekstowy w odpowiedzi.

Krytyczne scenariusze:

• 408 Request Timeout: Zwiększ limit czasu do 120 sekund
• 413 Payload Too Large: Podziel dokument na części
• 401 Unauthorized: Sprawdź poprawność klucza API
• 500 Internal Error: Automatycznie powiadamiamy o błędzie za pomocą webhooka

Zalecamy wdrożenie mechanizmu ponawiania z wykładniczym backoffem dla błędów przejściowych. Przykład w Go:

func withRetry(attempts int, sleep time.Duration, f func() error) error {
    for i := 0; i < attempts; i++ {
        if i > 0 {
            time.Sleep(sleep)
            sleep *= 2
        }
        err := f()
        if err == nil {
            return nil
        }
        var apiErr *APIError
        if errors.As(err, &apiErr) && apiErr.Code != 500 {
            return err
        }
    }
    return errors.New("prevysheno count popytok")
}

Benchmarki i wydajność

Testy przeprowadzono na zbiorze 10 000 dokumentów w różnych formatach. Wyniki:

• Średni czas przetwarzania PDF: 4,2 s
• Maksymalny czas dla DOCX z grafiką: 118 s
• Dokładność wyodrębniania INN: 99,7%
• Dokładność wyodrębniania rachunków rozliczeniowych: 98,4%

System skaluje się poziomo za pomocą Kubernetes. Przy obciążeniu powyżej 50 RPS automatycznie dodawane są węzły worker. Dla klientów enterprise dostępna jest instalacja on-premise z obsługą FIPS 140-2.

— Editorial Team