IA aplicada a dados

Janela de contexto (context window)

• Por que importa: limita o quanto o modelo “olha” de uma vez. Estouro = perda de informação relevante.
• Como escolher: estime o tamanho médio dos prompts + dados; use janelas maiores para tarefas com muitos trechos, mas prefira RAG quando o corpus crescer.
• Boas práticas: comprima/estruture entradas, use resumos e metadados; priorize trechos por relevância antes de enviar ao modelo.

Weaviate — híbrido (vetor + BM25)

Banco vetorial com busca híbrida. Por quê: combinar semântica e palavras‑chave. Como: upsert com vetor e consulta nearVector.

# Python — weaviate-client
import weaviate, os

client = weaviate.WeaviateClient("http://localhost:8080")

# Inserção com vetor gerado externamente
vec = embed("Normalização até 3FN reduz redundância")
client.collections.get_or_create("documents", vectorizer_config={"none": {}})
client.collections.get("documents").data.insert({
  "content": "Normalização até 3FN reduz redundância",
  "metadata": {"topic": "modelagem"}
}, vector=vec)

# Busca semântica
q = embed("Como normalizar tabelas?")
res = client.collections.get("documents").query.near_vector(q, limit=5)
context = "\n".join(f"- {o['content']}" for o in res.objects)
answer = llm.generate(f"Contexto:\n{context}\n\nPergunta: Como normalizar tabelas?")
      

Milvus — open source em escala

Banco vetorial open source. Por quê: alto desempenho e ecossistema maduro. Como: coleção com campo FLOAT_VECTOR.

# Python — pymilvus
from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection

connections.connect(alias="default", host="localhost", port="19530")

fields = [
  FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
  FieldSchema(name="content", dtype=DataType.VARCHAR, max_length=2048),
  FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536),
]
schema = CollectionSchema(fields, description="docs")
col = Collection("documents", schema=schema)

# Índice e carga
col.create_index("embedding", {"index_type":"IVF_FLAT","metric_type":"COSINE","params":{"nlist":1024}})
col.load()

# Inserção
emb = embed("Índices aceleram leitura")
col.insert([[None], ["Índices aceleram leitura"], [emb]])

# Busca
q = embed("Quando criar um índice?")
res = col.search([q], "embedding", params={"nprobe":16}, limit=5, output_fields=["content"])
context = "\n".join(f"- {hit.entity.get('content')}" for hit in res[0])
answer = llm.generate(f"Contexto:\n{context}\n\nPergunta: Quando criar um índice?")
      

Qdrant — vetorial com payload

Armazena vetores com metadados (payload). Por quê: filtros estruturados + semântica. Como: coleção com cosine.

# Python — qdrant-client
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

qc = QdrantClient(host="localhost", port=6333)
qc.recreate_collection(
  collection_name="documents",
  vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

emb = embed("Transações garantem atomicidade")
qc.upsert("documents", [PointStruct(id=1, vector=emb, payload={"content":"Transações garantem atomicidade","topic":"transacoes"})])

q = embed("O que é ACID?")
res = qc.search("documents", query_vector=q, limit=5)
      

Redis com vetores (RedisVL/FTS)

# Definição do índice com campo vetorial
FT.CREATE idx:docs ON HASH PREFIX 1 doc: SCHEMA embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 1536 DISTANCE_METRIC COSINE content TEXT

# Consulta KNN (retorna top‑5 por similaridade)
FT.SEARCH idx:docs '*=>[KNN 5 @embedding $vec AS score]' PARAMS 2 vec <BLOB_QUERY> SORTBY score RETURN 2 content score DIALECT 2
      

Chroma — local/dev

Armazenamento vetorial leve para desenvolvimento local. Por quê: simplicidade. Como: coleção com embeddings externos.

# Python — chromadb
import chromadb
client = chromadb.Client()
col = client.get_or_create_collection("documents")

emb = embed("Índices e EXPLAIN")
col.add(documents=["Índices e EXPLAIN"], embeddings=[emb], ids=["doc-1"], metadatas=[{"topic":"indices"}])

q = embed("Como usar EXPLAIN?")
res = col.query(query_embeddings=[q], n_results=5)
context = "\n".join(f"- {d}" for d in res['documents'][0])
answer = llm.generate(f"Contexto:\n{context}\n\nPergunta: Como usar EXPLAIN?")
      

Azure AI Search — índice vetorial

Índice gerenciado com campos vetoriais. Por quê: integração com filtros e ranking. Como: campo vector + skillset opcional.

{
  "name": "documents",
  "fields": [
    {"name":"id","type":"Edm.String","key":true},
    {"name":"content","type":"Edm.String","searchable":true},
    {"name":"embedding","type":"Collection(Edm.Single)","searchable":true,"vectorSearchDimensions":1536}
  ],
  "vectorSearch": {"algorithmConfigurations": [{"name":"vec-config","kind":"hnsw"}]}
}
      

RAG com vetores

RAG (Retrieval‑Augmented Generation) injeta conhecimento externo relevante na janela de contexto do modelo. Vetores (embeddings) permitem buscar por similaridade semântica.

• Por que usar: escalar além da janela, manter respostas atualizadas, reduzir alucinações.
• Como usar (pipeline): ingestão → chunking → geração de embeddings → indexação vetorial → consulta → reranking opcional → montagem do prompt → geração.
• Ferramentas comuns: pgvector (PostgreSQL), FAISS, Milvus, Elasticsearch/OpenSearch com vetores.
• Dicas: escolha tamanho de chunk coerente com as perguntas; armazene metadados (título, seção, fonte); faça avaliações offline (precisão/recall, utilidade).

# Exemplo conceitual (pseudocódigo)
docs = split_into_chunks(load_corpus(), tokens=600)
vecs = embed(docs)
index = build_vector_index(vecs)

query = embed("Como normalizar tabelas?")
tops = index.search(query, k=5)
prompt = compose(system, user, context=tops)
answer = llm.generate(prompt)
      

pgvector no PostgreSQL

Armazene embeddings diretamente no PostgreSQL e faça busca por similaridade. Por quê: integra dados relacionais e semânticos no mesmo SGBD. Como: extensão pgvector.

-- Instalar extensão (exige permissões de superuser)
CREATE EXTENSION IF NOT EXISTS vector;

-- Tabela com coluna vetorial (dimensão 1536 como exemplo)
CREATE TABLE doc_chunk (
  id BIGSERIAL PRIMARY KEY,
  content TEXT NOT NULL,
  embedding VECTOR(1536)
);

-- Inserir: gere o embedding na app e envie como array
INSERT INTO doc_chunk (content, embedding)
VALUES (
  'Normalização até 3FN reduz redundância',
  '[0.012, -0.034, ...]'::vector
);

-- Consulta por similaridade (menor distância = mais similar)
-- <->: distância euclidiana | <#>: inner product | <=>: cosine
WITH q AS (
  SELECT '[0.010, -0.020, ...]'::vector AS v
)
SELECT id, content
FROM doc_chunk, q
ORDER BY embedding <=> q.v
LIMIT 5;