Embeddings em IA

Convertendo Significado em Números

Introdução

Como uma máquina entende que “cachorro” e “cão” significam essencialmente a mesma coisa? Ou que “rei” e “rainha” estão relacionados de forma análoga a “homem” e “mulher”? A resposta está em uma das tecnologias mais fundamentais da Inteligência Artificial moderna: os embeddings.

Embeddings são representações vetoriais — basicamente, arrays de números — que capturam o significado semântico de textos, imagens, áudios ou outros tipos de dados em um espaço multidimensional. Eles são a ponte que permite às máquinas processar não apenas palavras isoladas, mas o significado por trás delas.

Neste artigo, vamos explorar o que são embeddings, como funcionam, onde são usados e por que se tornaram a base de praticamente todas as aplicações modernas de IA, desde mecanismos de busca semântica até sistemas de RAG (Retrieval-Augmented Generation).

O Que São Embeddings?

Um embedding é, na sua essência, uma lista de números (um vetor) que representa um objeto — uma palavra, uma frase, um documento, uma imagem — em um espaço de alta dimensão. Cada dimensão captura uma característica semântica, e a posição do vetor nesse espaço carrega informações sobre o significado do objeto.

Por exemplo, a frase “O cachorro correu atrás da bola no parque” pode ser convertida em um vetor com centenas ou milhares de dimensões, como:

[0.023, -0.112, 0.078, ..., -0.021, 0.009, 0.045]

Esse vetor não é aleatório: ele é construído de tal forma que frases com significados semelhantes terão vetores próximos uns dos outros nesse espaço multidimensional.

Como Funciona?

O processo de criação de um embedding segue um fluxo simples:

1. Dado de entrada: um texto, imagem ou outro tipo de dado.
2. Modelo de embedding: uma rede neural pré-treinada (como all-MiniLM-L6-v2 ou text-embedding-3-small) processa o dado.
3. Vetor numérico: a saída é um array denso de números, normalmente com 384, 512, 768, 1536 ou até 3072 dimensões.
4. Uso: esse vetor pode ser usado em busca semântica, RAG, recomendação, agrupamento, classificação e muito mais.

O modelo transforma o texto (ou outro dado) em um vetor denso que preserva o significado semântico — e é essa preservação que torna os embeddings tão poderosos.

As Quatro Grandes Vantagens dos Embeddings

1. Semântica

Palavras com significados semelhantes ficam próximas no espaço vetorial. Isso permite que sistemas entendam relações de sentido, e não apenas correspondência literal de caracteres.

2. Escalabilidade

É possível buscar, comparar e agrupar milhões de itens de forma eficiente. Bancos de dados vetoriais modernos conseguem realizar buscas em coleções gigantescas em milissegundos.

3. Generalização

Embeddings capturam contexto, sinônimos, relações e intenções — vão muito além da correspondência exata de palavras. Eles aprendem padrões linguísticos sutis a partir de vastos volumes de texto.

4. Versatilidade

São aplicáveis em busca semântica, recomendação, RAG, classificação, detecção de duplicatas, análise de sentimento e muito mais. A mesma técnica fundamental serve a dezenas de casos de uso.

Espaço Vetorial: Significado Como Proximidade

A ideia central por trás dos embeddings é simples e elegante: itens semanticamente similares ficam próximos no espaço vetorial.

Imagine um espaço onde cada ponto representa uma palavra. Nesse espaço, palavras como “gato”, “cachorro” e “hamster” formariam um agrupamento (cluster) — todas são animais domésticos. Outro cluster, distante desse, poderia conter “carro”, “moto” e “caminhão” — todos veículos. E ainda outro com “computador”, “smartphone” e “tablet” — tecnologia.

Exemplos de Proximidade

Veja como pares semanticamente próximos têm similaridade alta:

Par de palavras Similaridade (cosseno) rei ↔ rainha 0.92 cachorro ↔ cão 0.89 carro ↔ automóvel 0.91 paris ↔ frança 0.88

A distância entre vetores (geralmente medida por similaridade de cosseno) determina o quão semelhantes são os significados.

A Analogia Clássica

Um dos resultados mais famosos sobre embeddings é a chamada “analogia vetorial”:

$$\text{rei} — \text{homem} + \text{mulher} \approx \text{rainha}$$

Isso significa que, se você pegar o vetor de “rei”, subtrair o de “homem” e somar o de “mulher”, o vetor resultante estará muito próximo do vetor de “rainha”. Essa propriedade matemática mostra que os embeddings capturam relações conceituais de uma forma realmente significativa.

Aplicações Práticas

Os embeddings são a base de uma série de aplicações modernas de IA. Vejamos as principais:

🔍 Busca Semântica

Encontra resultados relevantes mesmo quando o usuário não usa as palavras exatas que aparecem nos documentos. Uma busca por “melhores notebooks para programação” retorna resultados sobre laptops para desenvolvedores, mesmo que essas palavras específicas não apareçam.

📚 RAG (Retrieval-Augmented Generation)

Recupera documentos relevantes para fornecer contexto ao LLM antes da geração da resposta. O resultado é maior precisão e respostas baseadas em fontes confiáveis, reduzindo significativamente o problema de “alucinação” em modelos de linguagem.

⭐ Recomendação

Encontra itens similares ao que o usuário gosta, gerando sugestões mais personalizadas e assertivas. É a tecnologia por trás de recomendações em e-commerce, plataformas de streaming e redes sociais.

👥 Agrupamento (Clustering)

Agrupa itens com significados semelhantes automaticamente, permitindo a organização automática de grandes volumes de dados sem necessidade de rotulação manual.

🏷️ Classificação

Embeddings servem como entrada para modelos supervisionados, melhorando significativamente a performance em tarefas de NLP e aplicações multimodais.

De Onde Vêm os Embeddings?

Embeddings são gerados por modelos pré-treinados em enormes volumes de dados. Esses modelos “aprendem” a representar significados durante o treinamento. Os principais provedores incluem:

• OpenAI: modelos como text-embedding-3-small e text-embedding-3-large.
• Sentence Transformers: família de modelos open-source como all-MiniLM-L6-v2, populares para projetos locais.
• Cohere: modelos como embed-english-v3.0, com forte foco em busca e recuperação.
• Google: modelos como text-embedding-004.
• E muitos outros modelos abertos ou proprietários, em constante evolução.

A escolha do modelo certo depende do idioma, do caso de uso, das restrições de custo e dos requisitos de qualidade.

Características Importantes a Considerar

✅ Dimensionalidade

Os vetores podem ter, por exemplo, 384, 512, 768, 1536 ou 3072 dimensões. Mais dimensões geralmente significam maior capacidade de representação, mas também maior custo computacional e de armazenamento.

✅ Normalização

Normalizar vetores (transformá-los em vetores unitários) ajuda em comparações de similaridade e é uma prática recomendada antes de armazenamento.

✅ Modelo certo para o caso de uso

O modelo ideal depende do idioma dos dados, do domínio (médico, jurídico, técnico) e do tipo de tarefa (busca, classificação, agrupamento).

✅ Qualidade dos embeddings

A qualidade do embedding impacta diretamente os resultados finais. Um modelo mal escolhido compromete toda a pipeline.

Como Medir Similaridade Entre Embeddings

Uma vez que temos os vetores, precisamos comparar quão semelhantes eles são. Existem três métricas principais:

Similaridade de Cosseno

Mede o ângulo entre dois vetores. Varia de -1 (opostos) a 1 (idênticos em direção). É a métrica mais usada em NLP, principalmente em busca semântica e RAG, porque ignora a magnitude e foca apenas na direção semântica.

Distância Euclidiana

Mede a distância em linha reta entre dois pontos no espaço. Útil em alguns cenários geométricos, mas menos comum em NLP devido à sensibilidade à magnitude dos vetores.

Produto Escalar (Dot Product)

Mede a projeção de um vetor sobre o outro. Bastante usado em sistemas de recomendação, onde a magnitude também carrega informação útil.

Dica prática: Cosine Similarity é, na maioria dos casos, a métrica padrão para busca semântica e RAG.

Exemplo Prático: Busca Semântica

Vamos ver como funciona um pipeline completo de busca semântica usando embeddings:

Usuário faz uma pergunta: “Como funciona energia solar?”

A pergunta é convertida em embedding pelo modelo.

O sistema realiza uma busca vetorial no banco de embeddings, procurando os documentos mais próximos da pergunta.

Os documentos mais relevantes são recuperados, por exemplo:

• Energia solar fotovoltaica: como funciona… (similaridade 0.92)
• Painéis solares: guia completo… (0.89)
• Vantagens da energia solar… (0.87)

O LLM gera uma resposta baseada nesses documentos recuperados, citando fontes e mantendo precisão.

Esse fluxo é a essência do RAG e representa a forma mais difundida de combinar embeddings com modelos generativos.

Implementação em Python

Vamos colocar a mão na massa. A seguir, uma implementação completa do pipeline acima usando bibliotecas populares. Mostraremos três variações: uma com sentence-transformers (open-source, roda localmente), uma com a API da OpenAI e uma versão completa com banco vetorial usando ChromaDB.

Pré-requisitos

• Python 3.10+ (python3 --version)
• Conexão à internet na primeira execução (download do modelo e dependências)
• Para Módulos 2 e 4: conta OpenAI e variável OPENAI_API_KEY

Estrutura de pastas

Crie uma pasta de trabalho (ex.: embeddings-lab) e, dentro dela, a estrutura abaixo. Todos os caminhos são relativos à raiz do projeto.

embeddings-lab/
├── requirements.txt
├── embeddings_lab/
│   ├── __init__.py
│   ├── corpus.py
│   ├── metrics.py
│   ├── v1_local_search.py
│   ├── v2_openai_search.py
│   ├── v3_chromadb_rag.py
│   ├── v4_full_rag.py
│   └── demo_metrics.py
└── .venv/          (criada na instalação — não versionar)

Passo 1 — Ambiente virtual

Na raiz do projeto (embeddings-lab/):

python3 -m venv .venv
source .venv/bin/activate    # Linux/macOS
# .venv\Scripts\activate     # Windows

Passo 2 — Dependências base

Crie o arquivo requirements.txt:

numpy>=1.24.0
sentence-transformers>=2.2.0

Instale PyTorch só CPU antes (evita baixar ~2 GB de pacotes NVIDIA):

pip install torch --index-url https://download.pytorch.org/whl/cpu
pip install -r requirements.txt

A primeira execução de qualquer script que use SentenceTransformer baixa o modelo all-MiniLM-L6-v2 (~90 MB) do Hugging Face.

Passo 3 — Dependências opcionais

MóduloPacote extraComando2 e 4openaipip install openai3 e 4chromadbpip install chromadb

Ou de uma vez: pip install openai chromadb

Passo 4 — API OpenAI (Módulos 2 e 4)

export OPENAI_API_KEY="sua-chave-aqui"

No Windows (PowerShell): $env:OPENAI_API_KEY="sua-chave-aqui"

Passo 5 — Executar a partir da raiz

Sempre com o venv ativo e na pasta embeddings-lab/:

python3 -m embeddings_lab.v1_local_search
python3 -m embeddings_lab.demo_metrics
# etc.

7. Módulo 0 — Corpus e métricas

Módulos compartilhados usados por todos os exemplos.

embeddings_lab/__init__.py

"""Laboratório prático de embeddings em IA."""

embeddings_lab/corpus.py

Base de conhecimento e pergunta padrão do laboratório:

"""Base de documentos compartilhada entre os exemplos."""

DOCUMENTOS = [
    "Energia solar fotovoltaica converte luz do sol em eletricidade através de células fotovoltaicas.",
    "Painéis solares são instalados em telhados e geram energia limpa para residências.",
    "Vantagens da energia solar incluem economia na conta de luz e redução de emissões.",
    "Carros elétricos utilizam baterias de lítio e estão se tornando mais populares.",
    "A fotossíntese é o processo pelo qual plantas convertem luz em energia química.",
]
PERGUNTA_PADRAO = "Como funciona energia solar?"

Narrativa: cinco frases curtas. Três falam de energia solar; uma de carros elétricos; uma de fotossíntese (também menciona “luz” e “energia”, mas em outro contexto). A pergunta padrão testa se o modelo prioriza o tema energia solar, não apenas palavras soltas.

embeddings_lab/metrics.py

"""Métricas de similaridade entre embeddings."""

import numpy as np

def normalizar(vetores: np.ndarray) -> np.ndarray:
    """Normaliza vetores para magnitude unitária."""
    normas = np.linalg.norm(vetores, axis=-1, keepdims=True)
    normas = np.where(normas == 0, 1, normas)
    return vetores / normas

def similaridade_cosseno(a: np.ndarray, b: np.ndarray) -> float | np.ndarray:
    """Similaridade de cosseno entre um ou mais pares de vetores."""
    a_norm = normalizar(np.atleast_2d(a))
    b_norm = normalizar(np.atleast_2d(b))
    return np.dot(a_norm, b_norm.T).squeeze()

def distancia_euclidiana(a: np.ndarray, b: np.ndarray) -> float:
    """Distância euclidiana entre dois vetores."""
    return float(np.linalg.norm(a - b))

def produto_escalar(a: np.ndarray, b: np.ndarray) -> float:
    """Produto escalar (dot product) entre dois vetores."""
    return float(np.dot(a, b))

8. Módulo 1 — Busca local (Sentence Transformers)

Objetivo: busca semântica gratuita e offline após o download do modelo. Não exige API key.

Código — embeddings_lab/v1_local_search.py

"""Versão 1: busca semântica local com Sentence Transformers."""

import numpy as np
from sentence_transformers import SentenceTransformer
from embeddings_lab.corpus import DOCUMENTOS, PERGUNTA_PADRAO
from embeddings_lab.metrics import similaridade_cosseno

def buscar(
    documentos: list[str],
    pergunta: str,
    top_k: int = 3,
    modelo_nome: str = "all-MiniLM-L6-v2",
) -> list[tuple[float, str]]:
    modelo = SentenceTransformer(modelo_nome)
    embeddings_docs = modelo.encode(documentos, normalize_embeddings=True)
    embedding_pergunta = modelo.encode(pergunta, normalize_embeddings=True)
    similaridades = similaridade_cosseno(embeddings_docs, embedding_pergunta)
    indices_top = np.argsort(similaridades)[::-1][:top_k]
    return [(float(similaridades[idx]), documentos[idx]) for idx in indices_top]

def main() -> None:
    pergunta = PERGUNTA_PADRAO
    resultados = buscar(DOCUMENTOS, pergunta)
    print(f"Pergunta: {pergunta}\n")
    print("Documentos mais relevantes:")
    for i, (score, doc) in enumerate(resultados, 1):
        print(f"{i}. [{score:.2f}] {doc}")

if __name__ == "__main__":
    main()

O que acontece, passo a passo

1. Carrega o modelo all-MiniLM-L6-v2.
2. Gera um vetor normalizado para cada documento e para a pergunta.
3. Calcula similaridade de cosseno entre a pergunta e cada documento.
4. Ordena do maior para o menor score e exibe o top 3.

Executar

python3 -m embeddings_lab.v1_local_search

Saída esperada (aproximada)

Os scores exatos variam levemente com versão do modelo; a ordem deve priorizar textos sobre energia solar:

Pergunta: Como funciona energia solar?

Documentos mais relevantes:
1. [0.64] Vantagens da energia solar incluem economia na conta de luz e redução de emissões.
2. [0.58] Painéis solares são instalados em telhados e geram energia limpa para residências.
3. [0.50] Energia solar fotovoltaica converte luz do sol em eletricidade através de células fotovoltaicas.

O documento sobre fotossíntese deve ficar abaixo do top 3 (contexto diferente, apesar de “luz” e “energia”). O de carros elétricos deve ter score ainda menor.

9. Módulo 2 — Busca com API OpenAI

Objetivo: mesmo fluxo do Módulo 1, usando embeddings da OpenAI (maior qualidade e suporte multilíngue, com custo por token).

Código — embeddings_lab/v2_openai_search.py

"""Versão 2: busca semântica com a API de embeddings da OpenAI."""

import os
import numpy as np
from openai import OpenAI
from embeddings_lab.corpus import DOCUMENTOS, PERGUNTA_PADRAO
from embeddings_lab.metrics import normalizar, similaridade_cosseno

def gerar_embedding(client: OpenAI, texto: str, modelo: str = "text-embedding-3-small") -> np.ndarray:
    resposta = client.embeddings.create(model=modelo, input=texto)
    return np.array(resposta.data[0].embedding)

def buscar(
    documentos: list[str],
    pergunta: str,
    top_k: int = 3,
    modelo: str = "text-embedding-3-small",
) -> list[tuple[float, str]]:
    client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
    embeddings_docs = np.array([gerar_embedding(client, doc, modelo) for doc in documentos])
    embeddings_docs = normalizar(embeddings_docs)
    embedding_pergunta = normalizar(gerar_embedding(client, pergunta, modelo))
    similaridades = similaridade_cosseno(embeddings_docs, embedding_pergunta)
    indices_top = np.argsort(similaridades)[::-1][:top_k]
    return [(float(similaridades[idx]), documentos[idx]) for idx in indices_top]

def main() -> None:
    if not os.environ.get("OPENAI_API_KEY"):
        raise SystemExit("Defina a variável de ambiente OPENAI_API_KEY antes de executar.")
    pergunta = PERGUNTA_PADRAO
    resultados = buscar(DOCUMENTOS, pergunta)
    print(f"Pergunta: {pergunta}\n")
    print("Documentos mais relevantes:")
    for i, (score, doc) in enumerate(resultados, 1):
        print(f"{i}. [{score:.2f}] {doc}")

if __name__ == "__main__":
    main()

Executar

pip install openai
export OPENAI_API_KEY="sua-chave-aqui"
python3 -m embeddings_lab.v2_openai_search

A saída segue o mesmo formato do Módulo 1; os scores costumam ser um pouco mais altos e estáveis em português.

10. Módulo 3 — Pipeline com ChromaDB

Objetivo: simular produção — embeddings persistidos em um banco vetorial (ChromaDB) e montagem do prompt para um LLM (sem chamar o LLM ainda).

Código — embeddings_lab/v3_chromadb_rag.py

"""Versão 3: pipeline de RAG com ChromaDB."""

from sentence_transformers import SentenceTransformer
from embeddings_lab.corpus import DOCUMENTOS, PERGUNTA_PADRAO

def montar_colecao(documentos: list[str], nome: str = "base_conhecimento"):
    import chromadb
    cliente = chromadb.Client()
    colecao = cliente.create_collection(name=nome)
    modelo = SentenceTransformer("all-MiniLM-L6-v2")
    colecao.add(
        documents=documentos,
        embeddings=modelo.encode(documentos).tolist(),
        ids=[f"doc_{i}" for i in range(len(documentos))],
    )
    return colecao, modelo

def buscar(colecao, modelo, pergunta: str, top_k: int = 3) -> list[str]:
    resultados = colecao.query(
        query_embeddings=modelo.encode(pergunta).tolist(),
        n_results=top_k,
    )
    return resultados["documents"][0]

def montar_prompt(pergunta: str, documentos: list[str]) -> str:
    contexto = "\n".join(documentos)
    return f"""Use o contexto abaixo para responder à pergunta.
Contexto:
{contexto}
Pergunta: {pergunta}
Resposta:"""

def main() -> None:
    colecao, modelo = montar_colecao(DOCUMENTOS)
    pergunta = PERGUNTA_PADRAO
    docs_recuperados = buscar(colecao, modelo, pergunta)
    print(f"Pergunta: {pergunta}\n")
    print("Documentos recuperados:")
    for i, doc in enumerate(docs_recuperados, 1):
        print(f"{i}. {doc}")
    print("\n--- Prompt para LLM ---\n")
    print(montar_prompt(pergunta, docs_recuperados))

if __name__ == "__main__":
    main()

Fluxo

1. Cria cliente ChromaDB em memória e uma coleção base_conhecimento.
2. Gera embeddings locais e insere documentos com IDs doc_0, doc_1, …
3. Consulta com o embedding da pergunta e retorna top 3.
4. Imprime o prompt pronto para enviar a um LLM.

Executar

pip install chromadb
python3 -m embeddings_lab.v3_chromadb_rag

Você verá a lista de documentos recuperados e, em seguida, o bloco Prompt para LLM com contexto + pergunta.

11. Módulo 4 — RAG completo com LLM

Objetivo: fechar o ciclo — recuperação (ChromaDB) + geração (OpenAI gpt-4o-mini), respondendo somente com base no contexto recuperado.

Código — embeddings_lab/v4_full_rag.py

"""Versão 4: RAG completo — recuperação + geração com LLM."""

import os
from openai import OpenAI
from sentence_transformers import SentenceTransformer
from embeddings_lab.corpus import DOCUMENTOS, PERGUNTA_PADRAO
from embeddings_lab.v3_chromadb_rag import buscar, montar_colecao

def responder_com_rag(
    client: OpenAI,
    pergunta: str,
    documentos_recuperados: list[str],
    modelo: str = "gpt-4o-mini",
) -> str:
    contexto = "\n\n".join(f"- {doc}" for doc in documentos_recuperados)
    resposta = client.chat.completions.create(
        model=modelo,
        messages=[
            {
                "role": "system",
                "content": (
                    "Você é um assistente que responde apenas com base no contexto "
                    "fornecido. Se a resposta não estiver no contexto, diga que não sabe."
                ),
            },
            {
                "role": "user",
                "content": f"Contexto:\n{contexto}\n\nPergunta: {pergunta}",
            },
        ],
    )
    return resposta.choices[0].message.content or ""

def main() -> None:
    if not os.environ.get("OPENAI_API_KEY"):
        raise SystemExit("Defina a variável de ambiente OPENAI_API_KEY antes de executar.")
    colecao, modelo = montar_colecao(DOCUMENTOS)
    pergunta = PERGUNTA_PADRAO
    docs_recuperados = buscar(colecao, modelo, pergunta)
    print(f"Pergunta: {pergunta}\n")
    print("Documentos recuperados:")
    for i, doc in enumerate(docs_recuperados, 1):
        print(f"{i}. {doc}")
    client = OpenAI()
    resposta = responder_com_rag(client, pergunta, docs_recuperados)
    print("\n--- Resposta do LLM ---\n")
    print(resposta)

if __name__ == "__main__":
    main()

Executar

pip install openai chromadb
export OPENAI_API_KEY="sua-chave-aqui"
python3 -m embeddings_lab.v4_full_rag

Saída esperada (formato)

1. Pergunta repetida.
2. Três documentos sobre energia solar.
3. Resposta do LLM explicando fotovoltaica / painéis / vantagens, sem inventar fatos fora do contexto.

Se perguntar algo ausente da base (ex.: “Como funciona fusão nuclear?”), o modelo deve indicar que não sabe, conforme a instrução de sistema.

12. Módulo extra — Métricas e analogia vetorial

Objetivo: comparar cosseno, euclidiana e dot product em pares de palavras; testar a analogia rei - homem + mulher; visualizar as primeiras 8 dimensões dos vetores.

Código — embeddings_lab/demo_metrics.py

"""Demonstração de métricas de similaridade e analogia vetorial."""

import numpy as np
from sentence_transformers import SentenceTransformer
from embeddings_lab.metrics import (
    distancia_euclidiana,
    produto_escalar,
    similaridade_cosseno,
)

PARES_SEMANTICOS = [
    ("rei", "rainha"),
    ("cachorro", "cão"),
    ("carro", "automóvel"),
    ("paris", "frança"),
]
PALAVRAS_ANALOGIA = ["rei", "homem", "mulher", "rainha"]

def demo_pares(modelo: SentenceTransformer) -> None:
    print("=== Similaridade entre pares semânticos ===\n")
    print(f"{'Par':<25} {'Cosseno':>8} {'Euclidiana':>12} {'Dot Product':>12}")
    print("-" * 60)
    for a, b in PARES_SEMANTICOS:
        emb_a = modelo.encode(a, normalize_embeddings=True)
        emb_b = modelo.encode(b, normalize_embeddings=True)
        cos = similaridade_cosseno(emb_a, emb_b)
        euc = distancia_euclidiana(emb_a, emb_b)
        dot = produto_escalar(emb_a, emb_b)
        print(f"{a + ' ↔ ' + b:<25} {cos:>8.2f} {euc:>12.4f} {dot:>12.4f}")

def demo_analogia(modelo: SentenceTransformer) -> None:
    print("\n=== Analogia vetorial: rei - homem + mulher ≈ rainha ===\n")
    embeddings = {
        palavra: modelo.encode(palavra, normalize_embeddings=True)
        for palavra in PALAVRAS_ANALOGIA
    }
    resultado = embeddings["rei"] - embeddings["homem"] + embeddings["mulher"]
    sim_rainha = similaridade_cosseno(resultado, embeddings["rainha"])
    print("Similaridade do vetor (rei - homem + mulher) com 'rainha':", f"{sim_rainha:.4f}")
    print("\nComparação com outras palavras:")
    for palavra in PALAVRAS_ANALOGIA:
        sim = similaridade_cosseno(resultado, embeddings[palavra])
        print(f"  → {palavra}: {sim:.4f}")

def demo_vetores_simplificados(modelo: SentenceTransformer) -> None:
    print("\n=== Representação simplificada (8 dimensões) ===\n")
    print(f"{'Texto':<10} Embedding (8 dimensões)")
    print("-" * 70)
    for palavra in PALAVRAS_ANALOGIA:
        vetor = modelo.encode(palavra, normalize_embeddings=True)[:8]
        valores = ", ".join(f"{v:.2f}" for v in vetor)
        print(f"{palavra:<10} [{valores}, ...]")

def main() -> None:
    modelo = SentenceTransformer("all-MiniLM-L6-v2")
    demo_pares(modelo)
    demo_analogia(modelo)
    demo_vetores_simplificados(modelo)

if __name__ == "__main__":
    main()

Executar

python3 -m embeddings_lab.demo_metrics

Interpretação dos resultados

Com all-MiniLM-L6-v2, scores de palavras isoladas em português costumam ser modestos (ex.: cosseno 0,3–0,6 entre sinônimos). A analogia clássica pode não destacar “rainha” como no Word2Vec em inglês — isso é esperado e didático: a escolha do modelo importa.

Para frases e documentos em português (Módulo 1), o comportamento de ranking costuma ser bem melhor que para palavras soltas.

Ferramentas Populares: Bancos de Dados Vetoriais

Para armazenar e consultar embeddings em larga escala, surgiu uma nova categoria de bancos de dados especializados. Os mais populares são:

• Pinecone: serviço gerenciado, fácil de começar.
• Weaviate: open-source com recursos avançados de busca híbrida.
• Qdrant: rápido, escalável e open-source.
• Milvus: alta performance, ideal para grandes volumes.
• Chroma: leve e ótimo para protótipos e aplicações em Python.
• FAISS: biblioteca da Meta, excelente para pesquisa local e benchmarking.

A escolha depende de fatores como volume de dados, latência exigida, necessidade de hospedagem própria ou serviço gerenciado, e integração com o stack existente.

Boas Práticas

Para obter os melhores resultados ao trabalhar com embeddings, siga estas recomendações:

1. Escolha o modelo certo para seu idioma e domínio. Um modelo em inglês geralmente performa pior em português, e modelos genéricos podem ser superados por modelos especializados em domínios específicos.
2. Normalize os vetores antes de comparar. Isso garante consistência nas medidas de similaridade.
3. Use dimensionalidade adequada. “Mais” nem sempre é “melhor”: dimensões extras aumentam custo sem necessariamente melhorar resultados.
4. Mantenha sua base vetorial atualizada. Embeddings de dados antigos podem perder relevância à medida que conteúdos novos surgem.
5. Avalie a qualidade com métricas adequadas, como Recall, MRR (Mean Reciprocal Rank) e NDCG (Normalized Discounted Cumulative Gain).

Conclusão

Embeddings são, sem exagero, uma das tecnologias mais transformadoras da IA moderna. Eles representam a ponte entre dados não estruturados e inteligência real — permitindo que máquinas entendam significados, e não apenas palavras isoladas.

São a fundação por trás de busca semântica, RAG, sistemas de recomendação, categorização automática e diversas outras aplicações que hoje consideramos essenciais. À medida que os modelos de embedding evoluem, evoluem também as capacidades dos sistemas que dependem deles.

A regra é simples: melhores embeddings, melhores respostas. Investir em entender, escolher e avaliar bem os modelos de embedding é, talvez, a decisão técnica mais importante em qualquer projeto moderno de IA que envolva busca, recuperação ou recomendação.

Se você está construindo qualquer aplicação séria com LLMs, dominar embeddings não é opcional — é o ponto de partida.

Até a próxima!