uv pip install faiss-cpu sentence-transformers openai python-dotenv ipykernel- fais-cpu é a lib para busca de similaridade em vetores desenvolvida pelo facebook
- sentence-transformers para criar embeddings ou representações vetoriais de textos
- client oficial da openai
- python-dotenv para carregar variáveis de ambiente em um arquivo .env
Primeiro vamos importar as bibliotecas necessárias:
import faiss
from sentence_transformers import SentenceTransformer
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()Agora vamos montar a nossa base de conhecimento, nesse caso textos que vão servir como fonte de informação para resposnder às perguntas.
Aqui eu tenho uma lista dos documentos. Vou setar como um array de strings. Em um sistema real, este corpus geralmente seria carregado de uma base de dados ou arquivos de texto.
documents = [
"FAISS é uma biblioteca para busca eficiente de similaridade desenvolvida pelo Facebook AI Research.",
"RAG (Retrieval-Augmented Generation) é uma técnica que melhora os modelos de linguagem recuperando informações relevantes de uma base de conhecimento.",
"Embeddings são representações vetoriais de texto que capturam significado semântico.",
"Bancos de dados vetoriais como FAISS permitem buscas eficientes de similaridade em espaços de alta dimensão.",
"A similaridade de cosseno entre dois vetores mede o cosseno do ângulo entre eles, fornecendo uma medida de sua similaridade.",
"Transformers de sentenças são modelos especificamente projetados para criar embeddings de sentenças que capturam significado semântico.",
"Chunking é o processo de dividir documentos longos em pedaços menores e mais gerenciáveis para processamento.",
"Busca semântica usa significado em vez de palavras-chave para encontrar informações relevantes.",
"Recuperação densa usa representações vetoriais densas de consultas e documentos para realizar a recuperação.",
"Retrieval-Augmented Generation combina sistemas de recuperação com modelos generativos para produzir respostas mais precisas e factuais.",
]model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")Aqui vamos carregar um modelo pré-treinado que converte textos em vetores, esse é um modelo leve que funciona bem em inglês, mas podemos escolher outro que funciona com múltiplos idiomas incluindo português.: https://huggingface.co/sentence-transformers/paraphrase-multilingual-mpnet-base-v2
Agora vamos transformar cada documento em um vetor numérico.
E imprimir a dimensão de cada vetor por meio do método .shape
document_embeddings = model.encode(documents)
print(f"Embedding dimension: {document_embeddings.shape[1]}")Aqui o método encode() processa cada documento através do pipeline do transformer desse modelo de embeddings.
O resultado é uma matriz Numpy onde cada linha é um vetor denso representando a semântica de um documento.
index = faiss.IndexFlatL2(document_embeddings.shape[1])
index.add(document_embeddings.astype('float32'))
print(f"Index contains {index.ntotal} vectors")- aqui vamos criar um índice FAISS do tipo
FlatL2que faz uma busca exata usando distância euclidiana - com o index.add vamos adicionar os embeddings ao índice convertendo para float32 que é o formato necessário para o FAISS
- vamos imprimir quantos vetores foram adicionados
A dimensão do índice é definida para corresponder à dimensão dos embeddings (384). Então adicionamos os vetores convertidos para float32 (FAISS requer este formato específico para eficiência).
def retrieve(query, top_k=3):
# Encode the query and search in FAISS
query_vector = model.encode([query]).astype("float32")
distances, indices = index.search(query_vector, top_k)
# Return results
results = []
for i, idx in enumerate(indices[0]):
results.append({"document": documents[idx], "distance": distances[0][i]})
return results- a ideia aqui é converter a consulta do usuário em um vetor usando o mesmo modelo
- com isso eu posso fazer uma busca no índice FAISS retornando os
top_kdocumentos mais similaresindex.search()vai calcular a distância euclidiana entre o vetor de consulta e todos os vetores no índice- Usa um algoritmo de ordenação parcial para encontrar os k vetores mais próximos
- Retorna dois arrays NumPy: um de distâncias e outro de índices correspondentes
- como resposta eu tenho uma lista de dicionários contendo os documentos e suas distâncias
def rag_query(query, top_k=3):
# Retrieve relevant documents
results = retrieve(query, top_k)
# Format context - versão simplificada
context = ""
for i in range(len(results)):
context += f"Documento {i + 1}: {results[i]['document']}\n\n"
# Generate response with OpenAI
client = OpenAI()
prompt = f"""
Com base nos seguintes documentos, responda à pergunta.
Documentos:
{context}
Pergunta: {query}
"""
response = client.responses.create(model="gpt-4o-mini", input=prompt)
answer = response.output_text
return {
"query": query,
"retrieved_documents": results,
"context": context,
"response": answer,
}- primeiro eu vou recuperar os documentos relevantes, usando a função anterior
retrieve - vou formatar os documentos em um único texto de contexto para passar isso no prompt
- vou instanciar o client da openai
- vamos definir o prompt para combinar o contexto e a pergunta
- agora é chamar a api do modelo
gpt-4o-minipara gerar uma resposta - como resposta vamos retornar os dados relevantes, consulta, documentos, contexto e a resposta
query = "Como funciona o RAG?"
results = rag_query(query)
# 8. Print results
print(f"\nConsulta: {results['query']}")
print("\nDocumentos Recuperados:")
for i, doc in enumerate(results["retrieved_documents"]):
print(f"{i + 1}. {doc['document']} (Pontuação: {doc['distance']:.4f})")
print(f"\nResposta: {results['response']}")- Agora vamos testar, eu vou definir a pergunta
- chamamos nossa função RAG
- e vou fazer um loop para imprimir os resultados formatados