RAG Avançado: Maximizando o Poder da IA com Dados Relevantes

Bem-vindo(a) ao Ki wi fy, a maior base de conhecimento sobre Inteligência Artificial do Brasil! Se você já conhece o básico sobre RAG (Retrieval Augmented Generation), prepare-se para mergulhar em técnicas avançadas que impulsionarão suas aplicações de IA para o próximo nível.

Recap Rápido: O Que é RAG?

RAG, ou Retrieval Augmented Generation (Geração Aumentada por Recuperação), é uma técnica que combina modelos de linguagem grandes (LLMs) com um sistema de recuperação de informações externas. Em vez de confiar apenas no conhecimento pré-treinado do LLM, o RAG permite que ele acesse e utilize informações atualizadas e específicas para gerar respostas mais precisas e contextualmente relevantes.

O processo básico do RAG envolve duas etapas principais: primeiro, um sistema de recuperação (Retrieval) busca documentos ou trechos de texto relevantes para a pergunta do usuário. Em seguida, um modelo de linguagem (Generation) usa essas informações recuperadas para gerar uma resposta. Isso permite que o LLM responda a perguntas sobre informações que ele não conhecia originalmente, tornando-o mais versátil e confiável.

Por Que RAG e Não Fine-tuning?

Tanto o RAG quanto o fine-tuning são técnicas para adaptar LLMs a tarefas ou domínios específicos, mas elas abordam o problema de maneiras diferentes. Enquanto o fine-tuning envolve treinar o modelo LLM com um novo conjunto de dados, o RAG mantém o LLM intacto e fornece informações externas relevantes durante a geração da resposta. Aqui estão algumas razões pelas quais o RAG pode ser preferível ao fine-tuning em muitos casos:

• Custo: Fine-tuning pode ser caro, pois requer poder computacional significativo e grandes conjuntos de dados rotulados. RAG, por outro lado, é geralmente mais econômico, pois não exige o treinamento do modelo.
• Atualização: Atualizar o conhecimento de um modelo fine-tuned requer um novo ciclo de treinamento, o que pode ser demorado. Com o RAG, basta atualizar o índice de documentos, o que é muito mais rápido e fácil. Novas regulamentações da ANVISA? Basta atualizar a base de dados.
• Transparência: Com o RAG, é fácil rastrear a fonte das informações usadas para gerar uma resposta, o que aumenta a transparência e a confiabilidade. Isso é mais difícil com o fine-tuning, pois o conhecimento é incorporado nos pesos do modelo. Você pode mostrar ao usuário "Estou respondendo isso baseado neste parágrafo deste documento".

Arquitetura Completa Passo a Passo do RAG

A arquitetura do RAG pode ser dividida em várias etapas principais. Abaixo, detalhamos cada uma delas, fornecendo uma visão completa do processo:

Diagrama Conceitual (descrito em texto):

Imagine um fluxo. Começamos com Documentos Originais (PDFs, Word, Sites). Eles passam por um processo de Ingestão, onde são lidos e preparados. Em seguida, ocorre o Chunking, que divide os documentos em pedaços menores. Cada pedaço é transformado em um Embedding (vetor numérico) usando um modelo como o da OpenAI ou Sentence Transformers. Esses embeddings são armazenados em um Vector Store (Pinecone, ChromaDB, etc.). Quando um usuário faz uma Pergunta, essa pergunta também é transformada em um embedding. O sistema de Retrieval busca os embeddings mais similares no Vector Store. Esses trechos relevantes (com seus embeddings) são enviados para o LLM (GPT-3, Llama 2, etc.). Finalmente, o LLM gera uma Resposta com base no contexto recuperado.

1. Ingestão de Documentos

A primeira etapa é coletar e preparar os documentos que serão usados como base de conhecimento. Isso pode envolver a extração de texto de diferentes formatos de arquivo, como:

• PDF: Use bibliotecas como PyPDF2 ou pdfminer.six para extrair o texto.
• Word: Utilize a biblioteca python-docx para ler o conteúdo dos arquivos .docx.
• Planilhas (Excel, CSV): A biblioteca pandas é excelente para ler e manipular dados de planilhas.
• Sites: Use requests para baixar o HTML e BeautifulSoup para extrair o texto relevante.

Exemplo de código (Python) para extrair texto de um PDF:

import PyPDF2

def extrair_texto_pdf(caminho_pdf):
    texto = ""
    with open(caminho_pdf, 'rb') as arquivo_pdf:
        leitor_pdf = PyPDF2.PdfReader(arquivo_pdf)
        for pagina_num in range(len(leitor_pdf.pages)):
            pagina = leitor_pdf.pages[pagina_num]
            texto += pagina.extract_text()
    return texto

caminho_do_pdf = 'exemplo.pdf'
texto_extraido = extrair_texto_pdf(caminho_do_pdf)
print(texto_extraido)
    

2. Chunking: Dividindo Documentos

Os LLMs têm um limite no tamanho da entrada (context window). Portanto, é crucial dividir os documentos em "chunks" (pedaços) menores. O tamanho ideal do chunk e o overlap (sobreposição entre os chunks) dependem do modelo de linguagem e da natureza dos dados.

• Tamanho Ideal: Geralmente, chunks de 200 a 500 tokens são um bom ponto de partida. Experimente diferentes tamanhos para otimizar o desempenho.
• Overlap: Uma sobreposição de 20% a 30% pode ajudar a manter o contexto entre os chunks.

Exemplo de código (Python) para chunking com overlap:

def chunk_texto(texto, tamanho_chunk=300, overlap=50):
    chunks = []
    inicio = 0
    while inicio < len(texto):
        fim = inicio + tamanho_chunk
        chunk = texto[inicio:fim]
        chunks.append(chunk)
        inicio += tamanho_chunk - overlap
    return chunks

texto_exemplo = "Este é um longo texto de exemplo..." # Substitua pelo seu texto
chunks = chunk_texto(texto_exemplo)
for i, chunk in enumerate(chunks):
    print(f"Chunk {i+1}: {chunk[:50]}...") # Imprime os primeiros 50 caracteres de cada chunk
    

3. Embeddings: Transformando Texto em Vetores

Embeddings são representações vetoriais de texto que capturam o significado semântico das palavras e frases. Eles permitem que o sistema compare a similaridade entre diferentes textos. Modelos populares para gerar embeddings incluem:

• OpenAI Embeddings: Oferecem alta qualidade e facilidade de uso através da API da OpenAI.
• Sentence Transformers: Uma biblioteca Python que fornece modelos pré-treinados para gerar embeddings de frases. São executados localmente, o que pode ser vantajoso em termos de custo e privacidade.

Exemplo de código (Python) usando Sentence Transformers:

from sentence_transformers import SentenceTransformer

modelo = SentenceTransformer('all-MiniLM-L6-v2') # Um modelo leve e eficiente

def gerar_embedding(texto):
    embedding = modelo.encode(texto)
    return embedding

texto_exemplo = "Este é um texto para gerar um embedding."
embedding = gerar_embedding(texto_exemplo)
print(embedding.shape) # Imprime a dimensão do embedding (geralmente 384 para all-MiniLM-L6-v2)
    

4. Vector Store: Onde Guardar os Embeddings

Um vector store (banco de dados vetorial) é uma base de dados otimizada para armazenar e consultar embeddings. Alguns dos vector stores mais populares incluem:

• Pinecone: Um serviço pago, mas altamente escalável e otimizado para buscas de similaridade de alta velocidade.
• ChromaDB: Uma opção open-source, fácil de usar e ideal para prototipagem e projetos menores.
• Qdrant: Outro vector store open-source que oferece recursos avançados, como filtragem e clustering.
• pgvector: Uma extensão para o PostgreSQL que permite armazenar e consultar embeddings diretamente no seu banco de dados relacional.

Exemplo de código (Python) usando ChromaDB:

import chromadb
from chromadb.utils import embedding_functions

# Define um modelo de embedding (pode ser OpenAI ou Sentence Transformers)
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
                api_key="SUA_CHAVE_OPENAI",
                model_name="text-embedding-ada-002"
)

# Cria um cliente ChromaDB
cliente = chromadb.Client()

# Cria uma coleção (tabela) para armazenar os embeddings
colecao = cliente.create_collection("meus_documentos", embedding_function=openai_ef)

# Adiciona dados à coleção
ids = ["doc1", "doc2", "doc3"]
documentos = ["Texto do documento 1", "Texto do documento 2", "Texto do documento 3"]
#embeddings = [gerar_embedding(doc) for doc in documentos] # Se usar Sentence Transformers

colecao.add(
    documents=documentos,
    ids=ids
)

# Realiza uma busca por similaridade
resultados = colecao.query(
    query_texts=["pergunta sobre os documentos"],
    n_results=2 # Retorna os 2 documentos mais similares
)

print(resultados)
    

5. Retrieval: Busca por Similaridade e Reranking

Quando um usuário faz uma pergunta, o sistema precisa encontrar os chunks mais relevantes no vector store. Isso é feito através de uma busca por similaridade, que compara o embedding da pergunta com os embeddings dos chunks. A métrica de similaridade mais comum é o "cosine similarity" (similaridade do cosseno).

Após a busca inicial, um passo importante é o reranking. Nem sempre os chunks mais similares são os mais relevantes para a pergunta. Modelos de reranking (como o Cohere Rerank) podem reordenar os resultados da busca, priorizando os chunks que melhor respondem à pergunta.

Exemplo conceitual: Imagine que a pergunta seja "Qual a cor do céu?". A busca inicial pode retornar chunks que mencionam a palavra "cor", mas que não falam especificamente sobre o céu. Um modelo de reranking inteligente priorizaria os chunks que mencionam "céu" e "azul".

6. Generation: LLM Gera Resposta com Contexto Recuperado

Finalmente, os chunks recuperados (e reranked) são enviados para o LLM, juntamente com a pergunta do usuário. O LLM usa essas informações para gerar uma resposta coerente e informativa. É importante formatar o prompt de forma clara e concisa, instruindo o LLM sobre como usar o contexto recuperado.

Exemplo de prompt:

Com base nas seguintes informações:
{contexto_recuperado}

Responda à seguinte pergunta:
{pergunta_do_usuario}
    

Exemplos Práticos Brasileiros

O RAG tem inúmeras aplicações práticas em diversos setores. Aqui estão alguns exemplos brasileiros:

• Chatbot que Responde sobre Regulamentação da ANVISA: Um chatbot que ajuda empresas e cidadãos a entenderem as complexas regulamentações da ANVISA, consultando documentos oficiais e respondendo a perguntas específicas.
• Assistente que Consulta Manuais Técnicos de uma Fábrica: Um assistente virtual que auxilia técnicos de uma fábrica a encontrarem informações em manuais técnicos extensos, agilizando a resolução de problemas.
• Base de Conhecimento Interna para Equipe de Vendas: Uma base de conhecimento que permite que a equipe de vendas encontre rapidamente informações sobre produtos, preços e políticas da empresa, melhorando o atendimento ao cliente.

RAG Avançado: Multi-Query, Hybrid Search, Agentic RAG

Para além da arquitetura básica, existem técnicas avançadas que podem melhorar significativamente o desempenho do RAG:

• Multi-Query: Em vez de usar apenas a pergunta original do usuário, o sistema gera múltiplas perguntas relacionadas, cada uma com um foco ligeiramente diferente. Isso permite que o sistema recupere informações mais abrangentes e relevantes.
• Hybrid Search: Combina diferentes métodos de busca, como busca semântica (usando embeddings) e busca por palavras-chave (usando técnicas de busca tradicionais). Isso pode melhorar a precisão e o recall da busca.
• Agentic RAG: Integra o RAG com agentes de IA, que podem realizar tarefas complexas, como navegar em sites, preencher formulários e executar APIs, para recuperar informações ainda mais relevantes.

Ferramentas: LangChain, LlamaIndex, Haystack

Existem diversas ferramentas que facilitam a implementação do RAG:

• LangChain: Um framework poderoso e flexível para construir aplicações de LLMs, incluindo RAG. Oferece módulos para ingestão de documentos, chunking, embeddings, vector stores e geração de respostas.
• LlamaIndex: Outro framework popular para RAG, com foco em indexação e busca de dados. Oferece recursos avançados como knowledge graphs e summarization.
• Haystack: Um framework open-source para construir pipelines de busca e resposta a perguntas, com suporte para diversos modelos de linguagem e vector stores.

Este artigo forneceu uma visão abrangente do RAG avançado. Esperamos que ele tenha sido útil e inspirador. Continue explorando o mundo da Inteligência Artificial com o Ki wi fy!