Extraindo dados de texto não estruturado
Crie um fluxo de extração de informações que leia textos brutos, como e-mails, recibos e artigos, e retorne campos estruturados com tipos, valores padrão e validação.
Extraindo dados de texto não estruturado é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.
O problema da extração de informações
As organizações estão se afogando em texto não estruturado: e-mails, tíquetes de suporte, contratos, faturas, artigos de notícias, anotações médicas e publicações em redes sociais. Dados estruturados valiosos estão ocultos nesse texto, mas extraí-los manualmente é lento, caro e sujeito a erros. Os LLMs com saídas estruturadas mudam esse cenário: eles podem ler qualquer texto e preencher um esquema predefinido com os campos relevantes, em grande escala e com precisão razoável.
Extração de informações (IE) é o processo de identificar e extrair automaticamente fatos estruturados de texto não estruturado. A IE baseada em LLM supera amplamente as abordagens anteriores baseadas em regras ou no PLN clássico, porque os LLMs compreendem contexto, sinonímia e informações implícitas sem precisar de padrões de expressões regulares criados manualmente para cada variação.
Casos de uso comuns da extração
A extração de informações viabiliza muitas aplicações empresariais valiosas:
- Processamento de faturas: extraia fornecedor, itens de linha, valores e datas de vencimento de faturas em PDF para automatizar o processamento de contas a pagar
- Análise de contratos: extraia partes, datas de vigência, condições de pagamento e cláusulas de rescisão de documentos jurídicos
- Análise de currículos: extraia competências, experiência, formação e informações de contato de currículos para sistemas ATS
- Encaminhamento de tíquetes de suporte: extraia categoria, gravidade, produto afetado e nível do cliente para encaminhar tíquetes automaticamente
- Monitoramento de notícias: extraia entidades, eventos e sentimentos de artigos de notícias para obter inteligência competitiva
Construindo um pipeline de extração de e-mails
Vamos construir um pipeline prático de extração que lê e-mails de clientes e extrai dados estruturados acionáveis. O pipeline usa um esquema Pydantic para definir exatamente o que queremos de cada e-mail e, em seguida, processa os e-mails em lote.
import openai
from pydantic import BaseModel
from typing import List, Optional
from enum import Enum
client = openai.OpenAI()
class Priority(str, Enum):
urgent = 'urgent'
high = 'high'
normal = 'normal'
low = 'low'
class EmailExtraction(BaseModel):
subject_summary: str
sender_intent: str
product_mentioned: Optional[str]
issue_category: str # billing / technical / general / feedback
priority: Priority
action_required: bool
action_description: Optional[str]
customer_sentiment: str # positive / negative / neutral / frustrated
def extract_from_email(email_body: str) -> EmailExtraction:
result = client.beta.chat.completions.parse(
model='gpt-4o-mini',
messages=[
{'role': 'system', 'content': 'You are an expert at analyzing customer emails and extracting structured information for a support team.'},
{'role': 'user', 'content': f'Analyze this customer email:\n\n{email_body}'}
],
response_format=EmailExtraction
)
return result.choices[0].message.parsedReconhecimento de entidades nomeadas com LLMs
Reconhecimento de entidades nomeadas (NER) é uma tarefa clássica de IE: identificar e classificar entidades nomeadas (pessoas, organizações, locais, datas e valores monetários) no texto. Os LLMs simplificam drasticamente o NER, pois basta descrever as entidades desejadas para que eles as extraiam, sem a necessidade de um modelo de NER treinado especificamente.
import openai
from pydantic import BaseModel
from typing import List, Optional
client = openai.OpenAI()
class NamedEntity(BaseModel):
text: str # The exact text as it appears
entity_type: str # PERSON / ORG / LOCATION / DATE / MONEY / PRODUCT
normalized: Optional[str] # Standardized form where applicable
class NERResult(BaseModel):
entities: List[NamedEntity]
text = '''
Apple Inc. CEO Tim Cook announced yesterday that the company will invest $1.2 billion
in a new manufacturing facility in Austin, Texas, expected to open in Q3 2026.
'''
result = client.beta.chat.completions.parse(
model='gpt-4o-mini',
messages=[
{'role': 'system', 'content': 'Extract all named entities from the text. Classify each as PERSON, ORG, LOCATION, DATE, MONEY, or PRODUCT.'},
{'role': 'user', 'content': text}
],
response_format=NERResult
)
for entity in result.choices[0].message.parsed.entities:
print(f'[{entity.entity_type}] {entity.text}')Extraindo documentos em grande escala
Para pipelines de extração em produção que processam milhares de documentos, é necessário usar processamento assíncrono e lidar com limites de taxa. Um padrão típico usa asyncio com um semáforo para processar documentos em paralelo, respeitando os limites de taxa da API.
import asyncio
import openai
from pydantic import BaseModel
from typing import List, Optional
async_client = openai.AsyncOpenAI()
class InvoiceExtraction(BaseModel):
vendor: str
total_amount: Optional[float]
currency: str
invoice_date: Optional[str]
async def extract_invoice(doc_text: str, semaphore: asyncio.Semaphore) -> InvoiceExtraction:
async with semaphore: # Limit concurrent requests
result = await async_client.beta.chat.completions.parse(
model='gpt-4o-mini',
messages=[
{'role': 'system', 'content': 'Extract invoice data.'},
{'role': 'user', 'content': doc_text}
],
response_format=InvoiceExtraction
)
return result.choices[0].message.parsed
async def process_invoices(documents: List[str]):
sem = asyncio.Semaphore(5) # Max 5 concurrent requests
tasks = [extract_invoice(doc, sem) for doc in documents]
return await asyncio.gather(*tasks, return_exceptions=True)
# results = asyncio.run(process_invoices(invoice_texts))
print('Async pipeline defined - handles rate limits via semaphore')Lidando com informações implícitas e inferidas
Os LLMs podem extrair não apenas informações declaradas explicitamente, mas também informações inferidas ou implícitas. Se uma avaliação disser “Uso isto diariamente há um mês e ainda funciona perfeitamente”, o modelo poderá inferir durabilidade como um atributo positivo, mesmo que a palavra “durabilidade” nunca apareça. Essa é uma grande vantagem em relação à extração baseada em expressões regulares, que só consegue encontrar o que está explicitamente presente.
Entretanto, esse poder traz riscos: o modelo pode fazer inferências excessivas e preencher campos com suposições em vez de fatos. Para extrações de alto risco (jurídicas, financeiras ou médicas), adicione um campo confidence ao seu esquema e instrua o modelo a avaliar o grau de certeza, sinalizando as extrações com baixa confiança para revisão humana.
Projetando prompts de extração
A qualidade da sua extração depende muito do design do prompt. Princípios fundamentais para prompts de extração:
- Defina campos ambíguos: se “data” puder significar data da fatura, data de vencimento ou data de recebimento, especifique exatamente qual delas você deseja
- Forneça exemplos para formatos incomuns: “Para o preço, retorne somente o valor numérico, por exemplo, 29.99, e não $29.99”
- Lide com a normalização: “Normalize os nomes de países para códigos ISO 3166-1 alfa-2”
- Especifique a fonte da extração: “Extraia somente da linha de assunto, não do corpo do e-mail”
Considere o prompt de extração como uma especificação precisa para um operador humano de entrada de dados: toda ambiguidade deixada no prompt será uma decisão que o modelo tomará de maneira inconsistente.
Extração em múltiplas passagens para documentos complexos
Alguns documentos são complexos demais para serem extraídos em uma única passagem, porque o esquema completo é grande, diferentes seções exigem conhecimentos distintos ou a estrutura do documento varia muito. A extração em múltiplas passagens divide a tarefa em etapas sequenciais: primeiro classifica o tipo de documento e, depois, extrai o esquema apropriado para esse tipo.
import openai
from pydantic import BaseModel
from typing import Optional
client = openai.OpenAI()
class DocumentType(BaseModel):
doc_type: str # invoice / contract / resume / report
confidence: float
def classify_document(text: str) -> str:
result = client.beta.chat.completions.parse(
model='gpt-4o-mini',
messages=[
{'role': 'system', 'content': 'Classify the document type.'},
{'role': 'user', 'content': text[:500]} # Use only the beginning for classification
],
response_format=DocumentType
)
return result.choices[0].message.parsed.doc_type
# Then route to the appropriate extraction schema
EXTRACTION_SCHEMAS = {
'invoice': 'InvoiceSchema', # Replace with actual Pydantic classes
'contract': 'ContractSchema',
'resume': 'ResumeSchema',
}
print('Multi-pass: classify first, then extract with the right schema')Enriquecimento após a extração
Os dados extraídos frequentemente precisam ser enriquecidos após a extração inicial: converter nomes de empresas extraídos para formas canônicas consultando um banco de dados de empresas, consultar o código postal extraído para preencher cidade e estado ou converter datas extraídas para um formato padrão. Essa etapa de enriquecimento deve ocorrer no código da sua aplicação após a extração, e não durante a chamada ao LLM.
Manter a extração e o enriquecimento separados torna o pipeline mais fácil de testar e manter. Você pode testar unitariamente a lógica de enriquecimento de forma independente e trocar o modelo de extração sem alterar o código de enriquecimento.
Medindo a precisão da extração
Para pipelines de extração em produção, meça a precisão sistematicamente usando um conjunto de testes rotulado. As principais métricas são:
- Precisão por campo: porcentagem de campos extraídos corretamente por documento
- Correspondência exata: o valor do campo corresponde exatamente à verdade de referência
- Correspondência normalizada: o valor do campo corresponde após a normalização (por exemplo, '$1,234.00' == '1234.0')
- Taxa de falsos positivos: frequência com que o modelo extrai um campo que deveria ser nulo
- Taxa de falsos negativos: frequência com que o modelo retorna nulo para um campo que está presente
Execute essa avaliação sempre que alterar modelos, atualizar prompts ou adicionar novas fontes de documentos ao seu pipeline. Mesmo pequenas quedas de precisão podem gerar um impacto empresarial significativo ao processar milhares de documentos.
Registro da extração para melhoria contínua
Cada resultado de extração em produção é um ponto de dados que pode melhorar seu pipeline. Registre em um banco de dados cada documento de entrada, a saída extraída e quaisquer erros de validação. Periodicamente, faça amostragens dos registros de produção para identificar padrões comuns de falha: determinados formatos de documento com os quais o modelo tem dificuldade, campos que frequentemente são nulos quando não deveriam ser ou valores incomuns que indicam desvio do prompt.
Esses dados registrados também se tornam seu futuro conjunto de treinamento caso você queira ajustar um modelo especificamente para sua tarefa de extração, oferecendo uma alternativa de maior precisão e menor custo aos LLMs de uso geral para extração estruturada.
Verificação rápida
Teste sua compreensão dos conceitos de Engenharia de IA desta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: LLMs com esquemas Pydantic extraem dados estruturados de qualquer fonte de texto não estruturado de forma confiável; o processamento assíncrono com semáforos permite a extração em lote de milhares de documentos, respeitando os limites de taxa; e a extração em múltiplas passagens classifica primeiro os documentos e depois aplica o esquema apropriado a cada tipo. A seguir, vamos criar uma lógica de validação e novas tentativas automáticas para lidar com casos em que os dados extraídos não atendem às regras empresariais.
Perguntas Frequentes
A aula “Extraindo dados de texto não estruturado” é grátis?
Sim — o texto completo de “Extraindo dados de texto não estruturado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.
O que vou aprender em “Extraindo dados de texto não estruturado”?
Crie um fluxo de extração de informações que leia textos brutos, como e-mails, recibos e artigos, e retorne campos estruturados com tipos, valores padrão e validação. Você pratica AI Engineering Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Engineering Academy?
Nenhuma experiência prévia é necessária. AI Engineering Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Extraindo dados de texto não estruturado”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Engineering Academy?
Sim. Cada aula de AI Engineering Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Modo JSON e response_format
- Saídas estruturadas com Pydantic
- Extraindo dados de texto não estruturado
- Validando e repetindo saídas inválidas