A técnica de RAG (Retrieval-Augmented Generation - Geração Aumentada por Recuperação) tornou-se a espinha dorsal de qualquer aplicação empresarial de inteligência artificial em 2026. Em vez de depender exclusivamente da memória congelada de um modelo de linguagem, o RAG busca trechos relevantes nos seus próprios documentos em tempo real e entrega esse contexto exato para o modelo responder.

Entretanto, enviar contratos de clientes e relatórios estratégicos para serviços vetoriais na nuvem representa um risco à privacidade e à conformidade com a LGPD.

Neste tutorial prático, você aprenderá a construir um Pipeline RAG completo, de alta velocidade e 100% local em Python, utilizando o banco vetorial Qdrant e a biblioteca de embeddings ultraleve FastEmbed.

---

A Arquitetura do Pipeline Local

O fluxo opera em duas etapas lineares:

[ INGESTÃO DE DOCUMENTOS ]
Arquivo PDF/TXT ──► Chunking com Overlap ──► FastEmbed (Vetores) ──► Qdrant Local

[ CONSULTA DO USUÁRIO ]
Pergunta ──► FastEmbed ──► Busca por Cosseno no Qdrant ──► Ollama (LLM) ──► Resposta Precisa

---

Passo 1: Preparando o Ambiente Python

Crie um ambiente virtual isolado e instale os pacotes necessários:

mkdir -p ~/local-rag-qdrant && cd ~/local-rag-qdrant
python3 -m venv venv
source venv/bin/activate

# Instalar bibliotecas essenciais
pip install qdrant-client fastembed requests

---

Passo 2: O Script Completo de Ingestão e Busca

Crie o arquivo rag_engine.py:

import os
import requests
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
from fastembed import TextEmbedding

# 1. Inicializar o cliente Qdrant (pode rodar 100% em memória local ou arquivo)
client = QdrantClient(path="./qdrant_db")
COLLECTION_NAME = "documentos_empresa"

# 2. Inicializar o modelo de embedding local (roda via ONNX na CPU)
print("Carregando modelo de embeddings leve...")
embedding_model = TextEmbedding(model_name="BAAI/bge-small-en-v1.5")

# 3. Criar a coleção vetorial se não existir
if not client.collection_exists(COLLECTION_NAME):
    client.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=384, distance=Distance.COSINE),
    )
    print(f"Coleção '{COLLECTION_NAME}' criada com sucesso!")

# 4. Função para segmentar texto com overlap
def chunk_text(text: str, chunk_size: int = 400, overlap: int = 80):
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunks.append(text[start:end])
        start += chunk_size - overlap
    return chunks

# 5. Indexando documentos na base vetorial
def index_document(doc_id: int, text: str, source_name: str):
    chunks = chunk_text(text)
    embeddings = list(embedding_model.embed(chunks))
    
    points = []
    for idx, (chunk, vector) in enumerate(zip(chunks, embeddings)):
        points.append(
            PointStruct(
                id=doc_id * 1000 + idx,
                vector=vector.tolist(),
                payload={"source": source_name, "content": chunk}
            )
        )
    
    client.upsert(collection_name=COLLECTION_NAME, points=points)
    print(f"✅ Documento '{source_name}' indexado com {len(chunks)} fragmentos.")

# 6. Função de Busca Semântica
def query_rag(query: str, top_k: int = 3):
    query_vector = list(embedding_model.embed([query]))[0].tolist()
    
    search_results = client.search(
        collection_name=COLLECTION_NAME,
        query_vector=query_vector,
        limit=top_k
    )
    
    context_chunks = [hit.payload["content"] for hit in search_results]
    return "\n---\n".join(context_chunks)

# 7. Função de Síntese com Ollama Local
def ask_ollama(query: str, context: str):
    prompt = f"""Você é um assistente técnico de cibersegurança e IA. Responda à pergunta baseando-se estritamente no contexto fornecido abaixo.
    
CONTEXTO RECUPERADO:
{context}

PERGUNTA DO USUÁRIO:
{query}

RESPOSTA BASEADA NO CONTEXTO:"""

    response = requests.post("http://localhost:11434/api/generate", json={
        "model": "llama3.2:3b",
        "prompt": prompt,
        "stream": False
    })
    
    return response.json().get("response", "Erro ao conectar com Ollama.")

# Demonstração Prática
if __name__ == "__main__":
    # Exemplo de documento interno
    documento_exemplo = """
    A política de segurança da Fymax estabelece que todas as senhas corporativas devem conter no mínimo 16 caracteres e autenticação multifator obrigatória via aplicativo FIDO2 ou Passkeys.
    Acesso remoto aos servidores de produção é permitido exclusivamente através de Cloudflare Tunnels com controle Zero Trust.
    Reuniões confidenciais devem utilizar verificação de presença fora de banda para evitar golpes de deepfakes.
    """
    
    index_document(doc_id=1, text=documento_exemplo, source_name="politica_seguranca_2026.txt")
    
    pergunta = "Qual é o procedimento obrigatório para acesso remoto aos servidores?"
    print(f"\nBuscando resposta para: '{pergunta}'")
    
    contexto = query_rag(pergunta)
    resposta = ask_ollama(pergunta, contexto)
    
    print("\nRESPOSTA DA IA LOCAL:")
    print(resposta)

---

Vantagens Desta Abordagem Local

1. Custo Zero por Token: Você pode indexar milhões de páginas e realizar centenas de milhares de consultas sem pagar faturas de nuvem.
2. Latência Mínima: A busca de vetores com Qdrant localmente leva menos de 5 milissegundos.
3. Privacidade Absoluta: O banco vetorial é salvo em disco local e o modelo roda no seu próprio hardware.

---

Conclusão

Ter um sistema de RAG local permite que empresas desbloqueiem o conhecimento escondido em manuais e bases de código sem jamais colocar em risco o sigilo industrial e a conformidade legal.

Precisa de suporte especializado para integrar soluções robustas de IA e construir interfaces web modernas e confiáveis? A equipe da Landingfymax está à sua disposição. Entre em contato conosco.