Imagine poder enviar um contrato, uma apostila ou um relatório em PDF e fazer perguntas diretamente sobre o conteúdo, recebendo respostas contextualizadas em poucos segundos.
Essa é uma das aplicações práticas da Inteligência Artificial Generativa. Com Python, modelos de linguagem e a técnica RAG (Retrieval-Augmented Generation), podemos desenvolver assistentes capazes de consultar documentos e responder perguntas com base nas informações encontradas nos arquivos.
Neste tutorial, vamos construir um projeto do zero: um assistente de IA que recebe um arquivo PDF, processa seu conteúdo, encontra os trechos relevantes e utiliza um modelo de linguagem para elaborar respostas.
O que é um assistente de IA para PDF?
Um assistente de IA para PDF é uma aplicação que permite consultar documentos utilizando linguagem natural.
Em vez de procurar manualmente por palavras ou percorrer dezenas de páginas, o usuário pode fazer perguntas como:
- Quais são as principais obrigações descritas neste contrato?
- Qual é o prazo de entrega mencionado no documento?
- Quais foram os resultados apresentados no relatório?
- Resuma os principais conceitos deste material.
- Quais são os requisitos necessários para participar do projeto?
Para implementar essa solução, podemos utilizar RAG, uma arquitetura que combina recuperação de informações com geração de respostas por modelos de linguagem.
Como funciona a arquitetura RAG?
RAG é a sigla para Retrieval-Augmented Generation. A ideia é permitir que um modelo de linguagem consulte informações externas antes de produzir uma resposta.
Isso é especialmente útil quando queremos trabalhar com documentos específicos, informações internas de empresas ou conteúdos que não fazem parte dos dados utilizados no treinamento do modelo.
O funcionamento pode ser dividido em duas etapas:
- Preparação dos documentos: Primeiro, o sistema extrai o texto do PDF e divide o conteúdo em pequenos trechos, chamados de chunks. Em seguida, transforma esses trechos em embeddings (representações numéricas que permitem comparar a similaridade semântica entre textos). Esses vetores são armazenados em um banco de dados vetorial.
- Consulta e geração da resposta: Quando o usuário faz uma pergunta, o sistema também transforma essa pergunta em uma representação vetorial e procura os trechos mais relacionados no banco de dados. Os trechos encontrados são enviados junto com a pergunta para o modelo de linguagem, que utiliza esse contexto para formular a resposta.
O fluxo completo:
- Carregamento do arquivo PDF.
- Extração do conteúdo textual.
- Divisão do conteúdo em chunks.
- Geração dos embeddings.
- Armazenamento em um banco vetorial.
- Recuperação dos trechos relevantes para cada pergunta.
- Geração da resposta utilizando um modelo de linguagem.
Tecnologias utilizadas no projeto
Vamos utilizar Python e algumas bibliotecas úteis para aplicações com IA:
- Python: linguagem de programação utilizada no projeto.
- PyPDF: extração do conteúdo textual dos PDFs.
- LangChain: integração e organização dos componentes.
- OpenAI Embeddings: transformação dos textos em vetores.
- FAISS: armazenamento e busca por similaridade.
- OpenAI API: geração das respostas.
O FAISS é uma biblioteca desenvolvida para realizar buscas eficientes por similaridade entre vetores. Neste projeto, utilizaremos sua implementação local, sem precisar configurar um servidor de banco de dados.
Passo 1: Preparando o ambiente
Crie uma pasta para o projeto e, dentro dela, configure um ambiente virtual.
Execute o seguinte comando no terminal: python -m venv venv
Ative o ambiente virtual:
- No Windows: venv\Scripts\activate
- No Linux ou macOS: source venv/bin/activate
Instale as dependências necessárias: pip install pypdf langchain langchain-openai langchain-community langchain-text-splitters faiss-cpu python-dotenv
Também será necessário ter uma chave de API da OpenAI com acesso aos modelos e embeddings utilizados no projeto. Crie um arquivo chamado .env na raiz do projeto e adicione sua chave:
OPENAI_API_KEY=sua_chave_de_api
Aviso de segurança: Não compartilhe esse arquivo nem envie sua chave para repositórios públicos (como o GitHub).
Passo 2: Extraindo o conteúdo do PDF
O primeiro componente será responsável por abrir o arquivo e extrair seu conteúdo utilizando a biblioteca PyPDF.
Adicione os seguintes imports ao seu script:
from pypdf import PdfReader from langchain_core.documents import Document
Agora, crie a função responsável por carregar o PDF:
def carregar_pdf(caminho): leitor = PdfReader(caminho) documentos = []
for numero, pagina in enumerate(leitor.pages):
texto = pagina.extract_text() or ""
if texto.strip():
documentos.append(
Document(
page_content=texto,
metadata={
"pagina": numero + 1,
"arquivo": caminho
}
)
)
return documentos
A função percorre todas as páginas do documento e extrai o texto disponível. Cada página é armazenada como um objeto Document, contendo o conteúdo e alguns metadados (número da página e nome do arquivo).
Atenção: Esse método funciona com PDFs que possuem texto selecionável. Documentos digitalizados como imagens precisam passar por uma etapa adicional de OCR (Reconhecimento Óptico de Caracteres).
Passo 3: Dividindo o documento em chunks
Não é recomendável enviar um documento inteiro para o modelo de linguagem a cada pergunta. Por isso, vamos dividir o conteúdo em trechos menores utilizando o RecursiveCharacterTextSplitter.
Adicione o seguinte import:
from langchain_text_splitters import RecursiveCharacterTextSplitter
Crie a função de divisão:
def dividir_documentos(documentos): separador = RecursiveCharacterTextSplitter( chunk_size=1000, chunk_overlap=150, separators=[“\n\n”, “\n”, “.”, ” “, “”] ) chunks = separador.split_documents(documentos) return chunks
Neste exemplo, cada trecho terá aproximadamente 1.000 caracteres, com uma sobreposição de 150 caracteres entre partes consecutivas para preservar o contexto.
Passo 4: Criando os embeddings e o banco vetorial
Agora precisamos transformar os trechos em representações numéricas utilizando o modelo text-embedding-3-small da OpenAI.
Adicione os seguintes imports:
from langchain_openai import OpenAIEmbeddings from langchain_community.vectorstores import FAISS
Crie a função para gerar os embeddings e armazenar os vetores:
def criar_banco_vetorial(chunks): embeddings = OpenAIEmbeddings( model=”text-embedding-3-small” )
banco = FAISS.from_documents(
documents=chunks,
embedding=embeddings
)
return banco
Passo 5: Criando o assistente de IA
Quando o usuário fizer uma pergunta, precisamos recuperar os trechos mais relevantes e enviá-los ao modelo de linguagem (gpt-4.1-mini).
Adicione os imports:
from langchain_openai import ChatOpenAI from langchain_core.prompts import ChatPromptTemplate
Crie a função do assistente:
def criar_assistente(banco): modelo = ChatOpenAI( model=”gpt-4.1-mini”, temperature=0 )
prompt = ChatPromptTemplate.from_messages([
(
"system",
"""
Você é um assistente especializado em analisar documentos.
Responda às perguntas utilizando somente as informações presentes no contexto fornecido.
Se a informação não estiver disponível no contexto, informe claramente que não encontrou essa informação.
Contexto:
{contexto}
"""
),
(
"human",
"{pergunta}"
)
])
def responder(pergunta):
documentos = banco.similarity_search(pergunta, k=4)
contexto = "\n\n".join(
[
f"Página {doc.metadata['pagina']}:\n{doc.page_content}"
for doc in documentos
]
)
mensagens = prompt.format_messages(
contexto=contexto,
pergunta=pergunta
)
resposta = modelo.invoke(mensagens)
return resposta.content, documentos
return responder
Passo 6: Integrando todos os componentes
Crie um arquivo chamado main.py com o código de execução principal:
from dotenv import load_dotenv
load_dotenv()
1. Carregar o PDF
documentos = carregar_pdf(“documento.pdf”)
2. Dividir o conteúdo
chunks = dividir_documentos(documentos)
3. Criar o banco vetorial
banco = criar_banco_vetorial(chunks)
4. Criar o assistente
assistente = criar_assistente(banco)
5. Iniciar as perguntas
while True: pergunta = input(“Faça sua pergunta (ou digite sair): “)
if pergunta.lower() == "sair":
break
resposta, fontes = assistente(pergunta)
print("\nResposta:")
print(resposta)
print("\nPáginas utilizadas:")
paginas = sorted({doc.metadata["pagina"] for doc in fontes})
print(paginas)
print("-" * 40)
Para executar, coloque um arquivo chamado documento.pdf na mesma pasta do código e digite no terminal: python main.py
Como evoluir o projeto?
- Criar uma interface com Streamlit: Substituir o terminal por uma interface web interativa.
- Consultar vários documentos: Criar uma base vetorial unificada com múltiplos arquivos.
- Implementar memória de conversação: Armazenar o histórico de interações.
- Utilizar bancos vetoriais especializados: Avaliar Chroma, Qdrant ou Pinecone.
- Melhorar a recuperação: Aplicar buscas híbridas e reranking.
Conclusão
Criar um assistente de IA capaz de ler PDFs e responder perguntas é um excelente projeto para compreender como aplicações baseadas em RAG funcionam na prática.
Se você deseja desenvolver projetos mais avançados com Python, LangChain, RAG e agentes de Inteligência Artificial, conheça a Trilha de Aprendizagem em IA Generativa da IA Expert Academy:

