\n\n\n\n Comom otimizar o uso de tokens com Milvus (passo a passo) - AgntUp \n

Comom otimizar o uso de tokens com Milvus (passo a passo)

By /
📖 13 min read•2,519 words•Updated Apr 5, 2026

“`html

Como Otimizar o Uso dos Tokens com Milvus (Passo a Passo)

Gerenciar o uso dos tokens de forma eficaz com Milvus pode reduzir os custos de computação desnecessários e tornar seus embeddings—e, portanto, sua pesquisa vetorial—muito mais rápidos e inteligentes. Embora muitos considerem “milvus otimizar o uso dos tokens” como uma caixa-preta, eu vou mostrar exatamente como você pode reduzir o fluxo de tokens em suas pipelines RAG, na sua pesquisa vetorial e nas suas consultas sem sacrificar a precisão.

Requisitos

  • Python 3.11+
  • Milvus Server 2.2.9+ (última versão estável a partir de 21 de março de 2026)
  • pymilvus>=2.2.9
  • Conhecimento básico dos conceitos de embeddings e pesquisa vetorial
  • Acesso a uma codificação vetorial baseada em GPU ou CPU (como embeddings OpenAI, modelos Huggingface ou similares)
  • Familiaridade com os limites de tokens dos seus LLM (por exemplo, os 8k tokens do GPT-4) e como isso afeta o custo e a latência

O Que Você Está Realmente Construindo

Estamos projetando uma pipeline de pesquisa vetorial que elimina o supérfluo das suas entradas textuais de modo que Milvus conserve apenas o que realmente enriquece o contexto da sua solicitação, mantendo a qualidade dos embeddings. Se você já enviou todos os seus documentos de origem diretamente ao Milvus e observou a explosão dos custos e das contagens de tokens, esta é a solução.

Passo a Passo

Passo 1: Meça Seus Tokens Antes de Validar

from transformers import GPT2TokenizerFast

tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")

def count_tokens(text: str) -> int:
 return len(tokenizer.encode(text))

sample_text = "Este parágrafo será tokenizado e contado para evitar desperdício de tokens."
print(f"Contagem de tokens: {count_tokens(sample_text)}")

Por Que: Se você enviar cegamente grandes textos tais como estão na fase de embedding, estará consumindo tokens que não precisa pagar ou armazenar. O tokenizer GPT-2 é um proxy econômico e fácil que corresponde grosso modo às contagens de tokens no estilo OpenAI. Este passo de contagem inicial previne que trechos muito longos se infiltrem no Milvus.

erros que você pode encontrar: Usar um tokenizer que não corresponde ao seu LLM resulta em uma contagem insuficiente ou excessiva. Por exemplo, os tokenizers do Huggingface para T5 diferem significativamente dos de GPT-3/4. Sempre verifique qual tokenizer está alinhado ao uso do seu modelo.

Passo 2: Divida o Texto de Forma Inteligente – Opte pelo Semântico em vez do Estatístico

def chunk_text(text: str, max_tokens: int = 500):
 words = text.split()
 chunks = []
 current_chunk = []
 current_tokens = 0
 for word in words:
 word_tokens = count_tokens(word)
 if current_tokens + word_tokens > max_tokens:
 chunks.append(" ".join(current_chunk))
 current_chunk = [word]
 current_tokens = word_tokens
 else:
 current_chunk.append(word)
 current_tokens += word_tokens
 if current_chunk:
 chunks.append(" ".join(current_chunk))
 return chunks

long_text = " ".join(["palavra"] * 2000) # Exemplo de texto longo
split_chunks = chunk_text(long_text, max_tokens=500)
print(f"Criado {len(split_chunks)} pedaços.")

Por Que: Dividir por contagens de tokens em vez de por comprimentos fixos de caracteres previne que você acidentalmente ultrapasse os limites de tokens na fase de embedding ou de consulta. Eu vi pipelines travarem ou degradarem porque as contagens de tokens explodem inesperadamente quando aparecem espaços ou caracteres UTF-8. O corte semântico (como limites de frases ou quebras de parágrafo) geralmente funciona melhor, mas uma simples maximização de tokens funciona de maneira confiável.

erros que você pode encontrar: Divisões ingênuas de caracteres criam correspondências de consulta incorretas—os fragmentos de contexto não representam um sentido coerente. Pedaços muito volumosos causam erros na API de embedding ou rapidamente te empurram para fora dos limites gratuitos.

Passo 3: Deduplicate Antes de Enviar para Milvus

“““html

from hashlib import sha256

def deduplicate_chunks(chunks):
 seen = set()
 unique_chunks = []
 for chunk in chunks:
 fingerprint = sha256(chunk.encode("utf-8")).hexdigest()
 if fingerprint not in seen:
 unique_chunks.append(chunk)
 seen.add(fingerprint)
 return unique_chunks

unique_chunks = deduplicate_chunks(split_chunks)
print(f"Deduplicado {len(unique_chunks)} pedaços únicos.")

Por quê: A redundância é inimiga. Não posso sublinhar isso o suficiente—muitos conjuntos de dados reais apresentam estranhas repetições, seja por PDFs corrompidos ou logs. A deduplicação evita o desperdício de tokens de embedding e de armazenamento no Milvus, economizando dinheiro em computação e prevenindo ruídos de pesquisa posteriormente.

erros que você pode encontrar: Pular a deduplicação enche o Milvus com vetores duplicados, desacelera a pesquisa e aumenta o armazenamento. Seu orçamento baseado em tokens explodirá.

Passo 4: Codifique os Pedaços em Vetores de Forma Eficiente

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

def encode_chunks(chunks):
 embeddings = model.encode(chunks, convert_to_tensor=True)
 return embeddings

embeddings = encode_chunks(unique_chunks)
print(f"Forma dos embeddings produzidos: {embeddings.shape}")

Por quê: Escolha modelos de embedding menores e mais rápidos a menos que você precise especificamente dos maiores transformers para uma precisão semântica. Para a maioria das aplicações, modelos como “all-MiniLM-L6-v2” representam o melhor compromisso entre dimensão vetorial (384), velocidade e orçamento de tokens. Embeddings de alta dimensão nem sempre são melhores; podem inflar seu índice Milvus e desacelerar a pesquisa.

erros que você pode encontrar: Tentar usar os embeddings do OpenAI para milhares de longos pedaços sem pré-processamento consumirá tokens e atingirá rapidamente os limites de velocidade da API. Além disso, o embedding sem batching reduz o throughput.

Passo 5: Armazene com Metadados para Filtrar o Contexto

from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection

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

fields = [
 FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
 FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=384),
 FieldSchema(name="token_count", dtype=DataType.INT64),
 FieldSchema(name="chunk_text", dtype=DataType.VARCHAR, max_length=1024)
]

schema = CollectionSchema(fields, "Pedaços de documentos com metadados dos tokens")
collection = Collection("doc_chunks", schema)

token_counts = [count_tokens(chunk) for chunk in unique_chunks]

entities = [
 token_counts,
 embeddings.tolist(),
 unique_chunks
]

collection.insert(entities)
collection.create_index("embedding", {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"})
collection.load()

Por quê: Armazenar as contagens de tokens ao lado dos embeddings permite que você filtre ou classifique os pedaços de baixo custo sem ter que retokenizar mais tarde. Os metadados dos tokens reduzem as consultas que tentam comprimir muito contexto—e lhe dão controle sobre o tamanho do payload do Milvus no momento da pesquisa.

Passo 6: Consulte Tendo em Mente os Orçamentos de Tokens

def search_similar(query: str, top_k=5, max_query_tokens=1000):
 query_token_count = count_tokens(query)
 if query_token_count > max_query_tokens:
 raise ValueError(f"A consulta excede o orçamento de tokens: {query_token_count} > {max_query_tokens}")

 query_embedding = model.encode([query])[0].tolist()
 results = collection.search(
 [query_embedding],
 "embedding",
 param={"metric_type": "L2", "params": {"nprobe": 10}},
 limit=top_k,
 output_fields=["token_count", "chunk_text"]
 )
 
 filtered_results = [res for res in results[0] if res.entity.get("token_count", 0) + query_token_count < max_query_tokens]
 return filtered_results

query = "Uso eficaz dos tokens com Milvus"
result_docs = search_similar(query)
for hit in result_docs:
 print(hit.entity.get("chunk_text"))

Por quê: A janela de contexto do seu LLM é preciosa. Se você esquecer de verificar seus tokens de consulta junto com os tokens dos pedaços relevantes, ultrapassará seus limites—resultando em erros ou placeholders truncados. A filtragem no Milvus com base nos metadados dos tokens armazenados ajuda você a se manter dinamicamente dentro do orçamento.

``````html

erros que você pode encontrar: Passar conjuntos de tokens combinados muito grandes para o seu gerador leva a falhas nos completamentos ou a saltos de contexto estranhos. Uma vez, eu tive uma queda de sistema depois de ignorar os limites de tokens. Não é divertido.

As Armadilhas

  1. O Contador de Tokens da API de Embedding Te Penalizará: Os embeddings da OpenAI contam tokens que você não espera sempre, como os tokens de prompt implícitos ou os separadores. Sempre faça testes a seco com contagens para chunk antes de fazer embedding em massa.
  2. Os Custos de Armazenamento do Milvus Crescem Rapidamente: O repositório Milvus sob a licença Apache-2.0 milvus-io/milvus tem 43.421 estrelas — sim, é popular — mas o tamanho vetorial e o número de vetores que você armazena resultam em um uso rápido de RAM/armazenamento. Vetores superdimensionados sem poda de tokens aumentam os custos.
  3. Os Tokenizers Não Se Acordam: Se o tokenizer para a criação de chunks e o tokenizer do seu LLM não correspondem, você estará subestimando ou superestimando os tokens. Use o tokenizer exato que seu LLM precisa.
  4. Tempo de Criação do Índice & Memória: Usar valores altos de nlist nos índices IVF_FLAT melhora a recuperação, mas adiciona latência e consumo de RAM. Encontre seu meio-termo. Normalmente, começo com nlist=128.
  5. Coerência dos Chunks vs Tamanho: Chunks maiores contêm mais contexto, mas custam mais tokens. Chunks menores causam fragmentação e reduzem a precisão. Experimente.

Código Completo

``````html

from transformers import GPT2TokenizerFast
from sentence_transformers import SentenceTransformer
from hashlib import sha256
from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection

# Passo 1: Inicializar o tokenizer e os modelos
tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
model = SentenceTransformer('all-MiniLM-L6-v2')

def count_tokens(text: str) -> int:
 return len(tokenizer.encode(text))

def chunk_text(text: str, max_tokens: int = 500):
 words = text.split()
 chunks = []
 current_chunk = []
 current_tokens = 0
 for word in words:
 word_tokens = count_tokens(word)
 if current_tokens + word_tokens > max_tokens:
 chunks.append(" ".join(current_chunk))
 current_chunk = [word]
 current_tokens = word_tokens
 else:
 current_chunk.append(word)
 current_tokens += word_tokens
 if current_chunk:
 chunks.append(" ".join(current_chunk))
 return chunks

def deduplicate_chunks(chunks):
 seen = set()
 unique_chunks = []
 for chunk in chunks:
 fingerprint = sha256(chunk.encode("utf-8")).hexdigest()
 if fingerprint not in seen:
 unique_chunks.append(chunk)
 seen.add(fingerprint)
 return unique_chunks

def encode_chunks(chunks):
 embeddings = model.encode(chunks, convert_to_tensor=True)
 return embeddings

# Conectar ao Milvus
connections.connect("default", host="localhost", port="19530")

# Definir o esquema
fields = [
 FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
 FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=384),
 FieldSchema(name="token_count", dtype=DataType.INT64),
 FieldSchema(name="chunk_text", dtype=DataType.VARCHAR, max_length=1024)
]
schema = CollectionSchema(fields, "Documentos de chunks com metadados dos tokens")

collection = Collection("doc_chunks", schema)

def insert_chunks(chunks):
 unique_chunks = deduplicate_chunks(chunks)
 embeddings = encode_chunks(unique_chunks)
 token_counts = [count_tokens(chunk) for chunk in unique_chunks]

 entities = [
 token_counts,
 embeddings.tolist(),
 unique_chunks
 ]

 collection.insert(entities)
 collection.create_index("embedding", {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"})
 collection.load()

def search_similar(query: str, top_k=5, max_query_tokens=1000):
 query_token_count = count_tokens(query)
 if query_token_count > max_query_tokens:
 raise ValueError(f"O número de tokens da consulta ({query_token_count}) ultrapassa o limite ({max_query_tokens})")

 query_embedding = model.encode([query])[0].tolist()
 results = collection.search(
 [query_embedding],
 "embedding",
 param={"metric_type": "L2", "params": {"nprobe": 10}},
 limit=top_k,
 output_fields=["token_count", "chunk_text"]
 )

 filtered_results = [res for res in results[0] if res.entity.get("token_count", 0) + query_token_count < max_query_tokens]
 return filtered_results

# Exemplo de uso
if __name__ == "__main__":
 raw_text = ("Este é um exemplo de parágrafo que gostaríamos de dividir, deduplicar, integrar e armazenar. " * 100)
 chunks = chunk_text(raw_text)
 insert_chunks(chunks)

 query = "uso dos tokens em um exemplo de parágrafo"
 found = search_similar(query)
 for hit in found:
 print(hit.entity.get("chunk_text"))

E agora

Agora que você dominou a proliferação dos tokens no Milvus, o próximo passo é implementar uma particionamento dinâmico das requisições, o que significa que sua aplicação deve monitorar o comprimento combinado dos tokens (requisição mais contexto recuperado) e remover ou reformular automaticamente os chunks de baixo valor antes de chamar seu LLM. Isso economizará dinheiro e evitará erros de limite de tokens durante a execução em produção.

FAQ

P: Como posso confirmar que minhas contagens de tokens correspondem às do LLM?

A: A melhor opção é usar o tokenizer fornecido pelo seu LLM. Para os modelos OpenAI, tiktoken é o tokenizer canônico. O tokenizer GPT-2 é um proxy razoável, mas não exato. Sempre execute casos de teste com a contagem do seu modelo para verificar.

P: Qual é o número máximo de vetores que o Milvus pode gerenciar antes que o desempenho seja afetado?

A: O Milvus é otimizado para milhões de vetores, mas na prática, seu tipo de índice, o tamanho do vetor e o hardware ditam o desempenho. Por exemplo, IVF_FLAT com nlist=128 é gerenciável com alguns milhões de vetores em servidores adequados, mas a latência e a RAM podem aumentar sem processamento em lote e poda.

P: Posso automatizar a poda dos tokens durante a inserção?

A: Absolutamente, mas tenha cuidado. Você pode remover ou resumir os chunks que excedem os limites de tokens antes da integração, mas uma poda excessiva reduz a riqueza semântica, prejudicando a qualidade da pesquisa a montante. Use limiares adaptativos calibrados para seu conjunto de dados.

```

Resumo das estatísticas do Milvus

Métrica Valor Comentário
Estrelas no GitHub 43.421 Indica uma alta adoção e suporte da comunidade
Forks 3.909 Mostra uma contribuição ativa e casos de uso personalizados
Problemas abertos 1.098 Relata o desenvolvimento em andamento e o monitoramento de bugs
Licença Apache-2.0 Licença permissiva favorável ao uso empresarial
Última atualização 21 de março de 2026 O projeto é mantido ativamente

Recomendações para diferentes tipos de desenvolvedores

1. O hacker de startup: Se você está construindo MVP rapidamente, concentre-se em modelos de integração prontos para uso como 'all-MiniLM-L6-v2' e em uma simples partição de tokens para reduzir o horizonte e os custos. Utilize a indexação integrada do Milvus e monitore seu uso de tokens com contadores simples.

2. O cientista de dados: Experimente abordagens de partição semântica: teste a detecção de limites de frases ou a codificação de parágrafos para melhorar a fidelidade das integrações. Incorpore metadados sobre a contagem de tokens para a poda no momento da solicitação. Você também deve considerar um fine-tuning da integração com base na complexidade dos tokens dos chunks.

3. O engenheiro empresarial: Construa um pipeline adaptativo que inclua monitoramento em tempo real do orçamento de tokens, deduplicação de chunks, dimensionalidade de vetores dinâmica e ajuste do índice no Milvus. Integre suas pipelines LLM de forma estreita para evitar cenários de estouro e otimizar os custos computacionais.

Dados até 21 de março de 2026. Fontes: https://github.com/milvus-io/milvus, Limites de tokens do Milvus LangChain, Otimização de LLM do Milvus

Artigos relacionados

You May Also Like

🕒 Published:

📚 You Might Also Like

✍️
Written by Jake Chen

AI technology writer and researcher.

Learn more →
Browse Topics: Best Practices | CI/CD | Cloud | Deployment | Migration
Scroll to Top