OCR e .NET: Arquiteturas para Processamento Inteligente de Documentos em Escala
Introdução
Se você já trabalhou em uma empresa que lida com muito papel, conhece a cena: faturas, contratos, prontuários e comprovantes chegam como imagens ou PDFs escaneados, sem uma única linha de texto pesquisável. Enquanto o conteúdo estiver preso na imagem, não dá para automatizar, buscar ou analisar nada. É aí que entra o reconhecimento óptico de caracteres (OCR), que transforma essas imagens em texto e serve de base para qualquer projeto de processamento inteligente de documentos.
Hoje, extrair texto de uma imagem é a parte fácil. O difícil é fazer isso com milhões de documentos sem perder nenhum pelo caminho, sem estourar o orçamento e sem deixar dados pessoais expostos. Neste artigo, vamos montar juntos uma arquitetura distribuída de OCR em .NET 10, passando por ingestão assíncrona, processamento paralelo, tratamento de imagens, machine learning, observabilidade e LGPD.
Um Pouco de Contexto
Do OCR clássico ao entendimento de documentos
O OCR evoluiu bastante. Motores clássicos como o Tesseract seguem um roteiro bem definido: analisam o layout, separam as linhas e classificam caractere por caractere. Depois vieram os modelos de deep learning, como as redes convolucionais recorrentes (CRNN), que leem a sequência inteira de uma vez, sem precisar recortar cada letra. Mais recentemente, modelos como o LayoutLM passaram a considerar também onde o texto está na página. Com isso, a pergunta deixou de ser só “o que está escrito?” e passou a ser “o que este documento significa?”, abrindo espaço para extrair campos, tabelas e formulários.
Por que .NET?
Porque o .NET 10 já traz praticamente tudo de que esse tipo de sistema precisa: ASP.NET Core para as APIs,
System.Threading.Channels e Parallel.ForEachAsync para controlar a concorrência,
ML.NET e ONNX Runtime para rodar modelos localmente, além de uma boa integração com containers e OpenTelemetry.
O ML.NET, aliás, nasceu justamente para levar machine learning a aplicações .NET de produção sem depender de
runtimes externos (AHMED et al., 2019).
Os Desafios de Processar em Escala
Escalabilidade e tolerância a falhas
OCR é pesado: consome bastante CPU (ou GPU), e o tempo de processamento varia muito de um documento para outro. Se você processar tudo dentro da própria requisição HTTP, o throughput despenca e o cliente fica esperando até tomar um timeout. A saída natural é colocar uma fila no meio, separando quem recebe de quem processa. Só que filas trazem seus próprios problemas: mensagens duplicadas, mensagens perdidas e reprocessamento. A regra de ouro é assumir que toda mensagem pode chegar mais de uma vez (at-least-once) e tornar cada etapa idempotente (KLEPPMANN, 2017).
Qualidade de extração
Na vida real, os documentos não chegam bonitos. Tem foto torta tirada pelo celular, digitalização em baixa resolução, carimbo em cima do texto e cada fornecedor com um layout diferente. Por isso, o pipeline precisa se adaptar: aplicar o tratamento certo para cada tipo de documento e combinar OCR com modelos de layout para recuperar a estrutura, e não só o texto.
Segurança e privacidade
Documentos corporativos estão cheios de dados pessoais: nome, CPF, endereço e, em alguns setores, até informações de saúde. A LGPD exige base legal, coleta apenas do necessário, segurança e capacidade de provar que tudo isso está sendo cumprido (BRASIL, 2018). Ou seja, privacidade precisa estar no desenho desde o começo, e não ser remendada no final.
Mãos à Obra: Arquitetura de Referência em .NET
Um serviço para cada etapa
A ideia é quebrar o pipeline em serviços pequenos, cada um com uma única responsabilidade: ingestão, pré-processamento, OCR, extração semântica, anonimização, indexação e entrega. A grande vantagem é que cada etapa escala do seu jeito, o que faz toda a diferença, já que o OCR consome muito mais recursos do que receber um arquivo ou indexar um texto (NEWMAN, 2021). Os serviços conversam por mensageria (Azure Service Bus, RabbitMQ ou Kafka), assim um não precisa esperar o outro estar disponível para seguir trabalhando (RICHARDSON, 2018).
Ingestão assíncrona com 202 Accepted
A porta de entrada não faz OCR nenhum. Ela só guarda o arquivo em um armazenamento de objetos, registra o job,
publica uma mensagem na fila e responde na hora com 202 Accepted, informando onde o cliente pode
acompanhar o status:
public sealed record DocumentMessage(Guid JobId, Uri BlobUri);
[ApiController]
[Route("api/ocr/documents")]
public sealed class OcrDocumentsController(
IBlobStorage storage,
IDocumentQueue queue,
IJobStore jobs) : ControllerBase
{
[HttpPost]
[RequestSizeLimit(20_000_000)]
public async Task<IActionResult> Submit(IFormFile document, CancellationToken ct)
{
if (document.Length == 0)
{
return BadRequest("Documento vazio.");
}
var jobId = Guid.CreateVersion7();
await using var content = document.OpenReadStream();
var blobUri = await storage.UploadAsync(jobId, content, ct);
await jobs.CreateAsync(jobId, ct);
await queue.EnqueueAsync(new DocumentMessage(jobId, blobUri), ct);
return AcceptedAtAction(nameof(GetStatus), new { jobId }, new { jobId });
}
[HttpGet("{jobId:guid}")]
public async Task<IActionResult> GetStatus(Guid jobId, CancellationToken ct)
=> await jobs.FindAsync(jobId, ct) is { } job ? Ok(job) : NotFound();
}
Um detalhe que vale destacar: Guid.CreateVersion7() gera identificadores ordenados por tempo. Isso
deixa os índices do banco mais eficientes e facilita muito seguir um documento pelos logs do pipeline.
Workers paralelos com backpressure
Dentro de cada worker, a concorrência precisa ter limite. Um canal com capacidade fixa resolve isso com backpressure: se os workers não estiverem dando conta, quem produz mensagens espera um pouco, em vez de ir acumulando tudo na memória até o container cair.
var channel = Channel.CreateBounded<DocumentMessage>(new BoundedChannelOptions(capacity: 500)
{
FullMode = BoundedChannelFullMode.Wait
});
public static Task RunOcrWorkersAsync(
ChannelReader<DocumentMessage> reader,
IOcrProcessor processor,
int degreeOfParallelism,
CancellationToken ct)
{
var options = new ParallelOptions
{
MaxDegreeOfParallelism = degreeOfParallelism,
CancellationToken = ct
};
return Parallel.ForEachAsync(reader.ReadAllAsync(ct), options, async (message, token) =>
{
// Idempotência: entregas duplicadas não geram reprocessamento
if (await processor.IsAlreadyProcessedAsync(message.JobId, token))
{
return;
}
await processor.ProcessAsync(message, token);
});
}
Como OCR é pesado em CPU, um bom ponto de partida para o grau de paralelismo é o número de núcleos do container. Daí em diante, ajuste olhando as métricas reais de latência e uso de recursos.
Pré-processamento de imagens
Imagem ruim gera texto ruim, simples assim. Antes do OCR, vale a pena converter para escala de cinza, corrigir a orientação, realçar o contraste, binarizar, remover ruído e endireitar páginas tortas (deskew). No .NET, o ImageSharp dá conta do básico sem nenhuma dependência nativa; para operações mais avançadas, como o deskew, você pode recorrer ao OpenCV via OpenCvSharp.
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
public static async Task<Stream> PreprocessAsync(Stream input, CancellationToken ct)
{
// L8 carrega a imagem diretamente em escala de cinza (8 bits)
using var image = await Image.LoadAsync<L8>(input, ct);
image.Mutate(ctx => ctx
.AutoOrient()
.Contrast(1.2f)
.BinaryThreshold(0.5f));
var output = new MemoryStream();
await image.SaveAsPngAsync(output, ct);
output.Position = 0;
return output;
}
Colocando Machine Learning no Pipeline
Que documento é este?
Com o texto em mãos, o próximo passo é descobrir que tipo de documento é aquele: uma nota fiscal, um contrato, um comprovante? Essa resposta define qual extrator de campos vai entrar em ação. Com ML.NET, dá para treinar e rodar um classificador multiclasse dentro do próprio processo .NET (AHMED et al., 2019):
public sealed class OcrDocument
{
public string OcrText { get; set; } = string.Empty;
public string DocumentType { get; set; } = string.Empty;
}
public sealed class DocumentTypePrediction
{
[ColumnName("PredictedLabel")]
public string DocumentType { get; set; } = string.Empty;
}
var mlContext = new MLContext(seed: 42);
IDataView trainingData = mlContext.Data.LoadFromEnumerable(labeledDocuments);
var pipeline = mlContext.Transforms.Conversion
.MapValueToKey("Label", nameof(OcrDocument.DocumentType))
.Append(mlContext.Transforms.Text.FeaturizeText("Features", nameof(OcrDocument.OcrText)))
.Append(mlContext.MulticlassClassification.Trainers.SdcaMaximumEntropy())
.Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));
var model = pipeline.Fit(trainingData);
var engine = mlContext.Model.CreatePredictionEngine<OcrDocument, DocumentTypePrediction>(model);
var prediction = engine.Predict(new OcrDocument { OcrText = extractedText });
Fica o alerta: o PredictionEngine não é thread-safe. Em APIs e serviços web, use o
PredictionEnginePool do pacote Microsoft.Extensions.ML.
Tabelas, layouts e modelos externos
Para entender tabelas e formulários, não basta ler as palavras em sequência: o modelo precisa saber onde cada texto está na página. Normalmente, esses modelos são treinados em Python e exportados para ONNX, rodando no .NET via ONNX Runtime. Outra opção é publicá-los como microsserviços dedicados em GPU, acessados via gRPC. A escolha certa depende de quanto você pode gastar com hardware e de quanta latência cada etapa aguenta.
Observabilidade e Escala Automática
Métricas com OpenTelemetry
Sem métricas por etapa, você não sabe onde está o gargalo, e escalar vira chute. No mínimo, acompanhe a latência
por tipo de documento, a taxa de falhas por etapa e o tamanho das filas. São esses sinais que vão sustentar seus
SLOs e alertas (BEYER et al., 2016). No .NET 10, a API
System.Diagnostics.Metrics conversa direto com o OpenTelemetry, e você pode exportar os dados para
Prometheus, Azure Monitor ou qualquer backend compatível com OTLP:
using System.Diagnostics.Metrics;
public sealed class OcrMetrics
{
public const string MeterName = "Leaders.Ocr";
private readonly Histogram<double> _duration;
private readonly Counter<long> _failures;
public OcrMetrics(IMeterFactory meterFactory)
{
var meter = meterFactory.Create(MeterName);
_duration = meter.CreateHistogram<double>("ocr.document.duration", unit: "ms");
_failures = meter.CreateCounter<long>("ocr.document.failures");
}
public void RecordSuccess(TimeSpan duration, string documentType)
=> _duration.Record(duration.TotalMilliseconds, new KeyValuePair<string, object?>("document.type", documentType));
public void RecordFailure(string stage)
=> _failures.Add(1, new KeyValuePair<string, object?>("ocr.stage", stage));
}
// Program.cs
builder.Services.AddSingleton<OcrMetrics>();
builder.Services.AddOpenTelemetry()
.WithMetrics(metrics => metrics
.AddMeter(OcrMetrics.MeterName)
.AddOtlpExporter());
Escalando pela fila
Para workers de OCR, uso de CPU nem sempre é o melhor indicador de quando escalar. O tamanho da fila mostra com muito mais clareza quanto trabalho está esperando. No Kubernetes, dá para combinar o Horizontal Pod Autoscaler com o KEDA e escalar os pods de acordo com a fila no Service Bus, RabbitMQ ou Kafka, chegando até a zero réplicas quando não há nada para processar (BURNS; BEDA; HIGHTOWER, 2019).
Segurança, Compliance e Governança
Criptografia e anonimização
Os dados precisam estar protegidos tanto parados, com chaves gerenciadas em serviços como Azure Key Vault ou HashiCorp Vault, quanto em trânsito, com TLS 1.2 ou superior. E, antes de indexar qualquer coisa, mascare os identificadores pessoais: é o princípio da minimização da LGPD na prática (BRASIL, 2018). Para uma primeira camada de proteção, uma expressão regular gerada em tempo de compilação já ajuda bastante:
using System.Text.RegularExpressions;
public static partial class PiiMasker
{
// Aceita CPF formatado (000.000.000-00) ou apenas dígitos
[GeneratedRegex(@"\b\d{3}\.?\d{3}\.?\d{3}-?\d{2}\b")]
private static partial Regex CpfRegex();
public static string MaskCpf(string text)
=> CpfRegex().Replace(text, "***.***.***-**");
}
Só não confie apenas em regex: ela gera falsos positivos e não pega nomes nem endereços. Em produção, combine a validação dos dígitos verificadores com modelos de reconhecimento de entidades (NER) treinados para o seu domínio.
Auditoria e rastreabilidade
Cada etapa deve deixar registrado quem processou o documento, com qual versão de modelo e qual foi o resultado. Essa trilha de auditoria é o que permite prestar contas, como exige a LGPD (BRASIL, 2018). E ainda tem um bônus: quando um modelo for atualizado, você sabe exatamente quais documentos precisam ser reprocessados.
Armazenamento, Busca e Entrega
Indexação para busca
Os arquivos originais ficam em um armazenamento de objetos (Azure Blob Storage ou Amazon S3), enquanto o texto
já anonimizado e os metadados vão para um motor de busca. Se você ainda usa o NEST, fica a dica: ele foi
descontinuado a partir do Elasticsearch 8, e o cliente oficial agora é o
Elastic.Clients.Elasticsearch:
using Elastic.Clients.Elasticsearch;
public sealed record OcrIndexedDocument(
Guid Id,
string FileName,
string DocumentType,
string MaskedText,
DateTimeOffset ProcessedAt);
var settings = new ElasticsearchClientSettings(new Uri("https://localhost:9200"))
.DefaultIndex("ocr-documents");
var client = new ElasticsearchClient(settings);
var document = new OcrIndexedDocument(jobId, fileName, documentType, PiiMasker.MaskCpf(ocrText), DateTimeOffset.UtcNow);
var response = await client.IndexAsync(document, ct);
if (!response.IsValidResponse)
{
throw new InvalidOperationException($"Falha ao indexar o documento {jobId}.");
}
Integração com sistemas legados
O resultado pode chegar ao cliente por consulta de status (polling), webhooks ou eventos publicados no barramento. Quando o destino é um ERP ou outro sistema legado, uma camada anticorrupção traduz o modelo do pipeline para os contratos que já existem. Assim, mudanças internas não respingam em quem consome os dados (RICHARDSON, 2018).
Na Prática: Um Pipeline Multitenant de Alto Volume
O cenário
Para tirar tudo isso do papel (com o perdão do trocadilho), imagine um grupo financeiro que precisa processar contratos e comprovantes de várias empresas. As metas são: 1 milhão de documentos por dia, picos de 10 mil documentos por minuto, latência média de 2 segundos por documento, extração de tabelas, anonimização e trilha de auditoria completa. O cenário é ilustrativo, mas os números ajudam a enxergar as decisões.
Quantos workers são necessários?
A Lei de Little responde: a concorrência necessária é a taxa de chegada multiplicada pela latência. No pico, 10 mil documentos por minuto dão cerca de 167 por segundo. Com 2 segundos por documento, o sistema precisa dar conta de uns 334 processamentos ao mesmo tempo. Com workers de 8 slots de paralelismo, são em torno de 42 pods de OCR no pico, contra poucas réplicas no dia a dia. Manter tudo isso ligado o tempo todo seria desperdício, e é por isso que escalar pela fila faz tanto sentido.
Decisões arquiteturais
- Isolamento por tenant: cada cliente tem suas próprias filas e prefixos de armazenamento, assim um tenant com volume enorme não atrapalha os outros.
- Prioridade por SLA: documentos urgentes e processamento em lote vão para filas diferentes.
- GPU só onde faz diferença: modelos de layout e NER rodam em pools dedicados, acessados via gRPC; o OCR clássico fica em CPU.
- Dead-letter queues: documentos que falham repetidamente são separados para análise, sem travar o resto do fluxo.
Riscos e como se proteger
Os maiores riscos aqui são a enorme variedade de layouts e a perda silenciosa de qualidade dos modelos com o tempo. Para se proteger, classifique o documento antes de extrair os campos, mantenha conjuntos de validação por tipo de documento e acompanhe a distribuição dos dados de entrada para perceber quando eles começam a mudar (SCULLEY et al., 2015).
Boas Práticas e Lições Aprendidas
1. Trate modelos como código
Modelos, pipelines e infraestrutura merecem versionamento e deploy por CI/CD, com Infrastructure as Code (Terraform, Bicep ou Helm). Sistemas de machine learning acumulam dívida técnica rapidinho quando dependências de dados e configurações ficam implícitas (SCULLEY et al., 2015).
2. Teste com documentos de verdade
Testes unitários e de integração são importantes, mas não bastam. Monte um conjunto de documentos de referência com o texto esperado e meça a taxa de erro por caractere a cada nova versão. Assim você pega aquela queda de acurácia que nenhum teste funcional mostraria.
3. Planeje para falhas desde o primeiro dia
Timeouts, retries com backoff exponencial, idempotência e dead-letter queues precisam estar no desenho desde o início, e não aparecer às pressas depois do primeiro incidente (KLEPPMANN, 2017).
Conclusão
No fim das contas, OCR em escala é muito mais um problema de arquitetura distribuída do que de reconhecimento de texto. E o .NET 10 entrega as peças certas para resolvê-lo: pipelines assíncronos, paralelos e observáveis, juntando OCR clássico, modelos de layout e machine learning no mesmo ecossistema.
Ingestão assíncrona, backpressure, idempotência, escala pela fila e anonimização antes da indexação: com esses ingredientes, processar documentos deixa de ser dor de cabeça e vira uma capacidade previsível e auditável. E o futuro é promissor: modelos multimodais, que entendem texto, imagem e layout ao mesmo tempo, devem reduzir cada vez mais a necessidade de regras específicas por tipo de documento. Se você está começando, não tente construir tudo de uma vez: comece pela fila e pela idempotência, meça tudo e evolua a partir daí.
Referências
-
AHMED, Zeeshan et al. Machine learning at Microsoft with ML.NET. In: ACM SIGKDD INTERNATIONAL CONFERENCE ON KNOWLEDGE DISCOVERY & DATA MINING, 25., 2019, Anchorage. Acesso em: 7 out. 2026.
-
BEYER, Betsy et al. Site reliability engineering: how Google runs production systems. Sebastopol: O'Reilly Media, 2016. Disponível em: Google Scholar. Acesso em: 7 out. 2026.
-
BRASIL. Lei nº 13.709, de 14 de agosto de 2018. Lei Geral de Proteção de Dados Pessoais (LGPD). Diário Oficial da União, Brasília, DF, 15 ago. 2018. Acesso em: 7 out. 2026.
-
BURNS, Brendan; BEDA, Joe; HIGHTOWER, Kelsey. Kubernetes: up and running: dive into the future of infrastructure. 2. ed. Sebastopol: O'Reilly Media, 2019. Acesso em: 7 out. 2026.
-
KLEPPMANN, Martin. Designing data-intensive applications: the big ideas behind reliable, scalable, and maintainable systems. Sebastopol: O'Reilly Media, 2017. Acesso em: 7 out. 2026.
-
NEWMAN, Sam. Building microservices: designing fine-grained systems. 2. ed. Sebastopol: O'Reilly Media, 2021. Acesso em: 7 out. 2026.
-
RICHARDSON, Chris. Microservices patterns: with examples in Java. Shelter Island: Manning, 2018. Acesso em: 7 out. 2026.
-
SCULLEY, D. et al. Hidden technical debt in machine learning systems. In: ADVANCES IN NEURAL INFORMATION PROCESSING SYSTEMS, 28., 2015, Montreal. Proceedings [...]. Red Hook: Curran Associates, 2015. p. 2503-2511. Acesso em: 7 out. 2026.