O mundo dos grandes modelos de linguagem (LLMs) está se expandindo em um ritmo explosivo, mas por muito tempo, acessar recursos de ponta significava depender de APIs baseadas em nuvem. Essa dependência frequentemente vinha com preocupações sobre privacidade, custo e personalização. No entanto, a maré está virando, graças a poderosos modelos de código aberto e ferramentas como o Ollama que tornam a execução deles em sua máquina local mais fácil do que nunca.
Entre os desenvolvimentos recentes mais empolgantes está o lançamento da família de modelos Qwen3 pela Alibaba Cloud. Esses modelos, particularmente as versões especializadas de embedding e reranker, estão estabelecendo novos padrões de desempenho. Quando combinados com o Ollama, eles fornecem um conjunto de ferramentas potente para desenvolvedores e pesquisadores que buscam construir aplicações de IA sofisticadas, como mecanismos de busca avançados e sistemas de Geração Aumentada por Recuperação (RAG), tudo a partir do conforto de seu próprio hardware.
Este artigo é o seu guia completo e passo a passo para aproveitar esse poder. Vamos desmistificar o que são modelos de embedding e reranker, guiar você pela configuração do Ollama e fornecer código Python prático para executar os modelos de embedding e reranker Qwen3 para um fluxo de trabalho RAG completo, de ponta a ponta.
Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar em conjunto com produtividade máxima?
Apidog atende a todas as suas demandas e substitui o Postman por um preço muito mais acessível!
A Dupla Poderosa: Entendendo os Modelos de Embedding e Reranker
Antes de mergulharmos no "como", vamos entender o "o quê". No contexto de um sistema RAG, os modelos de embedding e reranker desempenham papéis distintos, mas complementares.
1. O Bibliotecário: O Modelo de Embedding
Imagine uma biblioteca enorme com milhões de livros, mas sem um sistema de catalogação. Encontrar informações seria um pesadelo. Um modelo de embedding é como um bibliotecário hiperinteligente que lê cada documento e atribui a ele uma localização específica em um vasto "espaço conceitual" multidimensional.
Tecnicamente, um embedding de texto é um processo que converte um pedaço de texto (uma palavra, frase ou documento inteiro) em um vetor denso de números. Este vetor captura o significado semântico do texto. Documentos com significados semelhantes terão vetores que estão "próximos" uns dos outros neste espaço.
Quando você tem uma consulta, o modelo de embedding converte sua pergunta em um vetor e, em seguida, pesquisa na biblioteca por vetores de documentos que estão mais próximos a ele. Essa busca inicial é incrivelmente eficiente e recupera um amplo conjunto de documentos potencialmente relevantes.
2. O Consultor Especialista: O Modelo de Reranker
A recuperação inicial do modelo de embedding é rápida, mas nem sempre é perfeita. Ela pode trazer documentos que estão tematicamente relacionados, mas que não respondem precisamente à consulta do usuário. É aqui que o reranker entra.
Se o modelo de embedding é um bibliotecário generalista, o reranker é um especialista no assunto. Ele pega os principais resultados da busca inicial e realiza uma análise mais detalhada e computacionalmente intensiva. Em vez de comparar um vetor de consulta com vetores de documentos independentemente, um modelo de reranker (tipicamente um cross-encoder) olha para a consulta e cada documento como um par.
Essa comparação direta permite que o reranker calcule uma pontuação de relevância muito mais precisa. Ele então reordena os documentos com base nessa pontuação, empurrando os resultados mais relevantes para o topo. Esse processo de duas etapas — uma recuperação inicial rápida seguida por um reranking preciso — é o segredo para o desempenho de ponta do RAG.
Conheça os Modelos Qwen3: Um Novo Padrão em IA de Código Aberto
A série Qwen3 da Alibaba Cloud não é apenas mais um conjunto de modelos; ela representa um salto significativo no PNL de código aberto. Veja o que faz os modelos de embedding e reranker se destacarem:
- Desempenho de Ponta: O modelo Qwen3-Embedding-8B, no momento de seu lançamento, alcançou a posição #1 na altamente competitiva tabela de classificação multilíngue MTEB (Massive Text Embedding Benchmark), superando muitos modelos estabelecidos.
- Capacidade Multilíngue Excepcional: Treinados em um vasto corpus, os modelos suportam mais de 100 idiomas, tornando-os ideais para a construção de aplicações em escala global.
- Flexível e Eficiente: Os modelos vêm em vários tamanhos (por exemplo, 0.6B, 4B e 8B parâmetros), permitindo que os desenvolvedores escolham o melhor equilíbrio entre desempenho, velocidade e requisitos de hardware. Eles também suportam vários níveis de quantização, o que reduz ainda mais sua pegada de memória com impacto mínimo na precisão.
- Sensível a Instruções: Você pode fornecer instruções personalizadas aos modelos para adaptar seu desempenho a tarefas ou domínios específicos, um recurso que pode gerar ganhos significativos de desempenho.
Configurando Seu Ambiente de IA Local
Agora, vamos colocar a mão na massa. O primeiro passo é configurar o Ollama e baixar os modelos Qwen3.
Passo 1: Instalar o Ollama
Ollama oferece um comando de instalação simples, de uma única linha, para macOS e Linux. Abra seu terminal e execute:
curl -fsSL https://ollama.com/install.sh | sh
Para Windows, baixe o instalador oficial do site do Ollama.
Uma vez instalado, você pode verificar se está funcionando executando:
ollama --version
Passo 2: Baixar os Modelos Qwen3
Com o Ollama em execução, você pode puxar modelos da biblioteca Ollama. Os modelos Qwen3 estão hospedados sob o namespace dengcao. Puxaremos uma versão recomendada dos modelos de embedding e reranker. A tag :Q5_K_M significa um nível de quantização específico que oferece um ótimo equilíbrio entre desempenho e uso de recursos.
Em seu terminal, execute os seguintes comandos:
# Baixar o modelo de embedding de 8B parâmetros
ollama pull dengcao/Qwen3-Embedding-8B:Q5_K_M
# Baixar o modelo de reranker de 4B parâmetros
ollama pull dengcao/Qwen3-Reranker-4B:Q5_K_M
Esses downloads podem levar algum tempo, dependendo da sua conexão com a internet. Uma vez concluídos, você pode ver seus modelos disponíveis localmente executando ollama list.
Parte 1: Gerando Embeddings com Qwen3
Com o modelo de embedding baixado, vamos gerar alguns vetores. Usaremos a biblioteca oficial ollama do Python. Se você não a tiver instalada, execute pip install ollama.
Aqui está um script Python simples para gerar um embedding para um pedaço de texto:
import ollama
# Define o nome do modelo como baixado
EMBEDDING_MODEL = 'dengcao/Qwen3-Embedding-8B:Q5_K_M'
def get_embedding(text: str):
"""Gera um embedding para um dado texto."""
try:
response = ollama.embeddings(
model=EMBEDDING_MODEL,
prompt=text
)
return response['embedding']
except Exception as e:
print(f"Ocorreu um erro: {e}")
return None
# --- Exemplo de Uso ---
sentence = "Ollama torna fácil executar LLMs localmente."
embedding = get_embedding(sentence)
if embedding:
print(f"Embedding para: '{sentence}'")
# Imprime as primeiras dimensões para brevidade
print(f"Primeiras 5 dimensões: {embedding[:5]}")
print(f"Dimensões totais: {len(embedding)}")
Este script irá gerar os primeiros cinco valores do vetor gerado e seu tamanho total (que é 4096 para o modelo de 8B). Este vetor é a representação numérica de nossa frase, pronta para ser armazenada e comparada.
Parte 2: Refinando Resultados com o Reranker Qwen3
Usar o reranker é ligeiramente diferente. Em vez de um endpoint rerank dedicado, usamos o endpoint padrão chat. Criamos um prompt específico que pede ao modelo para atuar como um reranker, recebendo uma consulta e um documento como entrada e produzindo uma pontuação de relevância.
Vamos criar uma função Python para lidar com isso. Pediremos ao modelo para retornar um simples "Sim" ou "Não" para indicar relevância, o que podemos facilmente converter em uma pontuação.
import ollama
# Define o nome do modelo como baixado
RERANKER_MODEL = 'dengcao/Qwen3-Reranker-4B:Q5_K_M'
def rerank_document(query: str, document: str) -> float:
"""
Usa o Reranker Qwen3 para pontuar a relevância de um documento para uma consulta.
Retorna uma pontuação de 1.0 para 'Sim' e 0.0 para 'Não'.
"""
prompt = f"""
Você é um avaliador de relevância especialista. Sua tarefa é avaliar se o
seguinte documento é relevante para a consulta do usuário.
Por favor, responda com um simples 'Sim' ou 'Não'.
Consulta: {query}
Documento: {document}
"""
try:
response = ollama.chat(
model=RERANKER_MODEL,
messages=[{'role': 'user', 'content': prompt}],
options={'temperature': 0.0} # Para saída determinística
)
answer = response['message']['content'].strip().lower()
if 'yes' in answer:
return 1.0
return 0.0
except Exception as e:
print(f"Ocorreu um erro durante o reranking: {e}")
return 0.0
# --- Exemplo de Uso ---
user_query = "Como faço para executar modelos localmente?"
doc1 = "Ollama é uma ferramenta para executar grandes modelos de linguagem em seu próprio computador."
doc2 = "A capital da França é Paris."
score1 = rerank_document(user_query, doc1)
score2 = rerank_document(user_query, doc2)
print(f"Relevância do Doc 1: {'Relevante' if score1 > 0.5 else 'Não Relevante'} (Pontuação: {score1})")
print(f"Relevância do Doc 2: {'Relevante' if score2 > 0.5 else 'Não Relevante'} (Pontuação: {score2})")
Esta função demonstra como interagir com o reranker. Ela identifica corretamente que doc1 é altamente relevante para a consulta, enquanto doc2 não é.
Unindo Tudo: Uma Implementação Simples de RAG
Agora para o evento principal. Vamos construir um mini-pipeline RAG que usa ambos os nossos modelos para responder a uma consulta a partir de uma pequena base de conhecimento. Para a busca de similaridade, usaremos numpy. Instale-o com pip install numpy.
import ollama
import numpy as np
# --- Definições de Modelo ---
EMBEDDING_MODEL = 'dengcao/Qwen3-Embedding-8B:Q5_K_M'
RERANKER_MODEL = 'dengcao/Qwen3-Reranker-4B:Q5_K_M'
# --- 1. Corpus e Geração de Embedding Offline ---
documents = [
"A série de modelos Qwen3 foi desenvolvida pela Alibaba Cloud.",
"Ollama fornece uma interface de linha de comando simples para executar LLMs.",
"Um modelo reranker refina os resultados da busca calculando uma pontuação de relevância precisa.",
"Para instalar o Ollama no Linux, você pode usar um comando curl.",
"Modelos de embedding convertem texto em vetores numéricos para busca semântica.",
]
# Em uma aplicação real, você armazenaria esses embeddings em um banco de dados vetorial
corpus_embeddings = []
print("Gerando embeddings para o corpus de documentos...")
for doc in documents:
response = ollama.embeddings(model=EMBEDDING_MODEL, prompt=doc)
corpus_embeddings.append(response['embedding'])
print("Embeddings gerados.")
def cosine_similarity(v1, v2):
"""Calcula a similaridade de cosseno entre dois vetores."""
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
# --- 2. Recuperação Online e Reranking ---
user_query = "Como faço para instalar o Ollama?"
# Incorporar a consulta do usuário
query_embedding = ollama.embeddings(model=EMBEDDING_MODEL, prompt=user_query)['embedding']
# Realizar recuperação inicial (busca semântica)
retrieval_scores = [cosine_similarity(query_embedding, emb) for emb in corpus_embeddings]
top_k_indices = np.argsort(retrieval_scores)[::-1][:3] # Obter os 3 principais resultados
print("\n--- Resultados da Recuperação Inicial (antes do reranking) ---")
for i in top_k_indices:
print(f"Pontuação: {retrieval_scores[i]:.4f} - Documento: {documents[i]}")
# --- 3. Rerankear os principais resultados ---
retrieved_docs = [documents[i] for i in top_k_indices]
print("\n--- Reranking dos principais resultados ---")
reranked_scores = [rerank_document(user_query, doc) for doc in retrieved_docs]
# Combinar documentos com suas novas pontuações e ordenar
reranked_results = sorted(zip(retrieved_docs, reranked_scores), key=lambda x: x[1], reverse=True)
print("\n--- Resultados Finais (após o reranking) ---")
for doc, score in reranked_results:
print(f"Pontuação de Relevância: {score:.2f} - Documento: {doc}")
Ao executar este script, você verá o poder do processo de duas etapas. A recuperação inicial encontra corretamente documentos relacionados a "Ollama" e "instalação". No entanto, o reranker então identifica precisamente o documento sobre o uso de curl como o mais relevante, empurrando-o para o topo com uma pontuação perfeita.
Conclusão
Você agora configurou e usou com sucesso uma das mais poderosas duplas de IA de código aberto disponíveis hoje, diretamente em sua máquina local. Ao combinar o amplo alcance do modelo de embedding Qwen3 com a precisão afiada do reranker Qwen3, você pode construir aplicações que entendem e processam a linguagem com um nível de nuance que antes era domínio exclusivo de grandes sistemas proprietários.
A jornada não termina aqui. Você pode experimentar diferentes tamanhos de modelo, tentar vários níveis de quantização e integrar este pipeline em aplicações mais complexas. A capacidade de executar essas ferramentas localmente abre um mundo de possibilidades, capacitando você a criar, innovar e explorar sem comprometer a privacidade ou o desempenho. Bem-vindo à nova era da IA local e de código aberto.
Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar em conjunto com produtividade máxima?
Apidog atende a todas as suas demandas e substitui o Postman por um preço muito mais acessível!