Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Pesquisa semântica vs. pesquisa por palavras-chave

Aula 6 de 22 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Objetivos
  2. Os limites da pesquisa por palavras-chave
  3. Pesquisa semântica
  4. Comparação estruturada
  5. Quando utilizar cada um?
  6. Implementação de uma pesquisa semântica completa
  7. Pontos-chave

Objetivos

  • Compreender as limitações da pesquisa por palavras-chave
  • Descobrir como a pesquisa semântica resolve estes problemas
  • Implementar uma pesquisa semântica simples

Os limites da pesquisa por palavras-chave

A pesquisa clássica — TF-IDF, BM25, Elasticsearch — baseia-se na correspondência lexical: procura as palavras exatas da consulta nos documentos. Este mecanismo é rápido, previsível e perfeitamente fiável, desde que o utilizador empregue o mesmo vocabulário dos documentos. O problema é que quase nunca o fazem.

O pequeno corpus comentado abaixo ilustra as quatro situações típicas perante a consulta “how to feed a puppy”.

# Keyword search
query = "how to feed a puppy"

# ✅ Found: contains the same words
doc_a = "How to feed a 3-month-old puppy"

# ❌ Not found: different words, same meaning
doc_b = "Feeding the young dog"

# ❌ Not found: rephrasing
doc_c = "Dietary regimen for newborn puppies"

# ⚠️ False positive: same words, different meaning
doc_d = "How to feed a startup project like a puppy"

Apenas o primeiro documento é recuperado, embora o segundo e o terceiro respondam igualmente bem à pergunta. Pior ainda, o quarto ocupa um lugar de destaque unicamente por partilhar palavras com a consulta, apesar de tratar de gestão empresarial. Sinónimos, reformulação e ambiguidade: a pesquisa lexical falha nos três casos.

Pesquisa semântica

A pesquisa semântica compara o significado dos textos, e não as suas palavras. Codifica o corpus uma vez por todas, codifica a consulta no momento da sua chegada e classifica os documentos por similaridade.

from openai import OpenAI
import numpy as np

client = OpenAI()

def embed(text: str) -> np.ndarray:
    response = client.embeddings.create(
        input=text,
        model="text-embedding-3-large"
    )
    return np.array(response.data[0].embedding)

# Corpus
documents = [
    "How to feed a 3-month-old puppy",
    "Feeding the young dog",
    "Dietary regimen for newborn puppies",
    "How to feed a startup project like a puppy",
    "The basics of Italian cuisine",
]

# Index the corpus
corpus_embeddings = np.array([embed(doc) for doc in documents])

# Search
query = "how to feed a puppy"
query_embedding = embed(query)

# Calculate similarities
similarities = corpus_embeddings @ query_embedding

# Sort by relevance
results = sorted(
    enumerate(similarities), key=lambda x: x[1], reverse=True
)

for idx, score in results:
    print(f"{score:.4f} | {documents[idx]}")

Resultado esperado:

0.9123 | How to feed a 3-month-old puppy
0.8756 | Dietary regimen for newborn puppies
0.8421 | Feeding the young dog
0.4532 | How to feed a startup project like a puppy
0.1245 | The basics of Italian cuisine

Os três documentos relevantes ocupam os três primeiros lugares, apesar de formulações totalmente diferentes, e o falso positivo desce para 0,45 — muito abaixo do limiar que o colocaria no topo. O modelo compreendeu que “puppy” serve aqui de comparação, e não de sujeito.

Comparação estruturada

CritérioPalavras-chave (BM25)Semântica (embeddings)
Sinónimos❌ Falha✅ Funciona
Reformulação❌ Falha✅ Funciona
Multilingue❌ Impossível✅ Possível
Erros ortográficos❌ Falha✅ Tolerante
Correspondência exata✅ Excelente⚠️ Por vezes imprecisa
Nomes próprios, códigos✅ Excelente⚠️ Pode confundir
Velocidade (corpus grande)✅ Muito rápido⚠️ Requer um índice
Custo✅ Gratuito⚠️ Chamadas à API

Quando utilizar cada um?

A leitura da tabela oferece uma regra simples: quanto mais uma consulta se assemelhar a um identificador, mais adequada se torna a pesquisa lexical. Uma referência de produto como XR-4471-B, uma data, uma categoria exata ou um nome próprio raro devem ser pesquisados palavra por palavra; um modelo de embeddings tenderá a confundir essa referência com as suas vizinhas. Esta é também a escolha padrão quando o corpus é massivo e o orçamento para embeddings é zero.

A pesquisa semântica assume a liderança assim que o utilizador se expressa em linguagem natural. Um FAQ, apoio ao cliente, documentação técnica consultada por não especialistas, um corpus multilingue onde a pergunta é feita em francês e a resposta escrita em inglês, ou mesmo uma consulta vaga e exploratória: em todos estes casos, o fosso entre o vocabulário do utilizador e o dos documentos é precisamente aquilo que os embeddings sabem colmatar.

Como estes dois perfis são complementares e não concorrentes, a melhor resposta consiste frequentemente em combinar ambas as abordagens para cobrir todos os casos. Esse é o tema da Lição 9.

Implementação de uma pesquisa semântica completa

Na prática, encapsula a indexação e a consulta numa pequena classe. Isto evita recalcular os vetores do corpus para cada consulta — o erro mais dispendioso que os iniciantes cometem.

class SemanticSearch:
    def __init__(self, model: str = "text-embedding-3-large"):
        self.client = OpenAI()
        self.model = model
        self.documents: list[dict] = []
        self.embeddings: np.ndarray | None = None

    def index(self, documents: list[dict]):
        """Indexes a list of documents {id, text, ...}."""
        self.documents = documents
        texts = [d["text"] for d in documents]

        response = self.client.embeddings.create(
            input=texts,
            model=self.model
        )

        vectors = sorted(response.data, key=lambda x: x.index)
        self.embeddings = np.array(
            [v.embedding for v in vectors], dtype=np.float32
        )

    def search(self, query: str, k: int = 5) -> list[dict]:
        """Searches for the k most relevant documents."""
        query_emb = self.client.embeddings.create(
            input=query,
            model=self.model
        ).data[0].embedding

        similarities = self.embeddings @ np.array(query_emb)
        top_k = np.argsort(similarities)[-k:][::-1]

        return [
            {**self.documents[i], "score": float(similarities[i])}
            for i in top_k
        ]

# Usage
engine = SemanticSearch()
engine.index([
    {"id": 1, "text": "How to install Python on Windows"},
    {"id": 2, "text": "Guide to configuring the Python environment"},
    {"id": 3, "text": "The basics of the Python language"},
])

results = engine.search("set up Python on my PC")
for r in results:
    print(f"[{r['score']:.3f}] {r['text']}")

Teste este motor com a consulta “set up Python on my PC”: nenhuma destas cinco palavras aparece no documento 1, que fala sobre “installing Python on Windows”. No entanto, este deve ocupar o primeiro lugar. Em seguida, modifique a consulta para falar sobre “configuring the environment” e observe a classificação mudar para o documento 2 — dispõe agora de um banco de testes mínimo para verificar o comportamento do seu índice antes de o povoar seriamente.

Pontos-chave

  • A pesquisa por palavras-chave falha com sinónimos e reformulações
  • A pesquisa semântica compara significados através de embeddings
  • Cada abordagem tem os seus pontos fortes: a pesquisa híbrida combina ambas
  • Um motor semântico simples pode ser construído em algumas dezenas de linhas