Implementing AI classification of incoming documents by type
The incoming correspondence department processes 500+ documents per day. Employees manually determine the type — whether it's an invoice or a contract — and then enter it into the system. Errors occur in 15% of cases, each document takes 3–5 minutes. We know this pain, so we build automatic classifiers that work with 97–99% accuracy and save up to 80% of time on routine routing. For example, for a large logistics operator, we implemented a classifier that processes 2000+ documents daily with 98.5% accuracy, completely replacing manual sorting.
Key problems solved by AI classification
Low accuracy for similar documents
An invoice and a waybill often have identical fields and structure. A text classifier will err in 5–10% of cases. A multimodal approach — text + tables + file metadata — reduces error to 1–3%.
Unknown types
A system without the UNKNOWN class sends an unfamiliar document to the nearest category with low confidence. This disrupts business processes. We allocate a separate class for manual processing and log all cases for retraining.
Integration with existing ECM/ERP
API layer based on FastAPI or GraphQL, support for REST, SOAP, gRPC. The classifier can be easily embedded into the processing pipeline — from scanning to loading into 1C, SAP, or DocuWare.
How the multimodal classifier works
Our stack: PyTorch, HuggingFace Transformers, LangChain for chains, ChromaDB or Qdrant for storing embeddings. Models — rubert-tiny2 for Russian or multilingual-e5-large for multilingual document flow. Deployment via Triton Inference Server with INT8 quantization support — p99 latency < 100 ms.
def classify_document(file_path: str) -> DocumentClass: features = {} # Text features text = extract_text(file_path) features["text_class"] = text_classifier.predict(text[:2000]) # Structural features features["has_tables"] = detect_tables(file_path) features["page_count"] = get_page_count(file_path) features["filename_hint"] = extract_filename_hint(file_path) # Document metadata features["creation_date"] = get_document_metadata(file_path).get("created") # Ensemble decision return ensemble_classifier.predict(features) Case study: classifying 500K documents per month
A large retailer (our client) implemented a processing system for waybills and acts. Before implementation — 4 employees on manual sorting, 85% accuracy. After — an AI classifier based on RuBERT fine-tuned on 20K labeled documents. Accuracy: 98.5% for waybills, 97.2% for acts. Processing time per document — 0.7 s. Result: 3 out of 4 employees were reassigned to quality control, the cost of processing one document decreased by tens of times.
Why multimodal approach is better
| Criteria | Text only | Multimodal (text + structure + metadata) |
|---|---|---|
| Accuracy on similar documents | 85–90% | 96–99% |
| Robustness to low-quality scans | Low | High (uses layout features) |
| Processing speed | < 50 ms | 150–300 ms (due to table and metadata analysis) |
| Retrainability | BERT fine-tuning | Ensemble fine-tuning |
The multimodal approach is 3 times more accurate than pure-text on documents with similar structure.
Why invest in model fine-tuning?
Fine-tuning on your data boosts accuracy by 5–10% compared to an out-of-the-box model. For a client handling 1000 documents per day, the savings from reduced rework cover the fine-tuning cost within the first month.
Implementation process
| Stage | Duration | Result |
|---|---|---|
| Analytics | 5–10 days | Taxonomy, document statistics, integration requirements |
| Design | 3–5 days | Pipeline architecture, model selection, MVP specification |
| Implementation | 15–30 days | Classifier model, API layer, integration tests |
| Testing | 7–14 days | Validation on real data, A/B test with current process |
| Deployment and support | 3–7 days | Deployment on your server or cloud, documentation |
What's included in the result
- Ready classifier model (fine-tuned for your taxonomy)
- API for integration (OpenAPI specification)
- Docker images for deployment (CPU/GPU)
- Operation manual and operator training
- Guaranteed accuracy of at least 95% on the test set
- 3 months of post-launch support
Typical mistakes in self-implementation
- Ignoring layout features. A simple BERT classifier confuses an invoice and a payment order if the texts are similar. Add table embeddings and page counts — accuracy will increase by 10–15%.
- Missing the UNKNOWN class. Always provide a fallback for unknown types. Without it, a classification error breaks the processing chain.
- Insufficient labeled data. Fine-tuning requires at least 200–500 examples per class. Less leads to high variance, more is better.
Timeline and budget
Implementation timeline — from 4 to 12 weeks depending on taxonomy complexity and integration. The budget is calculated individually after analyzing the document flow. Contact us — we will evaluate your project and propose a scenario with a guaranteed result. Request a consultation to get savings of up to 80% of time on manual sorting.
Experience: 10+ years in AI/ML, 80+ document classification projects, certified specialists in PyTorch and HuggingFace.