AI Prompt Engineering · Aula

Estratégias de divisão para textos longos

Abordagens de divisão por tamanho fixo, limites de frases e semântica.

Estratégias de divisão para textos longos é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Por que documentos longos são um desafio

Os LLMs têm uma janela de contexto — um número máximo de tokens que podem processar de uma vez. O GPT-4 aceita 128 mil tokens e o Claude aceita 200 mil, mas muitos documentos excedem até mesmo esses limites. Mais importante, pesquisas mostram que a precisão do modelo costuma diminuir em contextos muito longos. Particionar em blocos é a prática de dividir documentos em partes menores antes do processamento.

Particionamento de tamanho fixo

O particionamento de tamanho fixo divide o texto a cada N tokens (ou caracteres), independentemente dos limites do conteúdo. É a estratégia mais simples e não exige compreensão semântica.

Tamanho típico do bloco: 500–1000 tokens. Os blocos são fáceis de indexar e recuperar, mas podem dividir frases no meio, perdendo significado nos limites.

import tiktoken

def fixed_chunk(text, max_tokens=1000):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    for i in range(0, len(tokens), max_tokens):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
    return chunks

chunks = fixed_chunk(long_document)
print(f'Total chunks: {len(chunks)}')

Vantagens e desvantagens do particionamento de tamanho fixo

Vantagens:

Fácil de implementar — não exige PLN
Tamanhos de bloco previsíveis — mais fácil controlar os custos da API
Processamento rápido

Desvantagens:

Ignora os limites de frases e parágrafos
Uma frase dividida entre blocos perde contexto durante a recuperação
Ruim para sumarização — o bloco pode terminar no meio de uma argumentação

Particionamento nos limites das frases

O particionamento nos limites das frases divide o texto em quebras naturais de frases ou parágrafos. Cada bloco termina com um ponto final, garantindo que nenhuma frase seja cortada ao meio. Isso produz blocos mais legíveis e coerentes.

Use um tokenizador de frases (spaCy ou NLTK) para detectar os limites e depois agrupe as frases até que o bloco atinja o tamanho desejado.

import spacy

nlp = spacy.load('en_core_web_sm')

def sentence_chunk(text, max_tokens=1000):
    doc = nlp(text)
    sentences = [sent.text.strip() for sent in doc.sents]
    chunks, current, count = [], [], 0
    for sent in sentences:
        word_count = len(sent.split())
        if count + word_count > max_tokens and current:
            chunks.append(' '.join(current))
            current, count = [], 0
        current.append(sent)
        count += word_count
    if current:
        chunks.append(' '.join(current))
    return chunks

Particionamento semântico

O particionamento semântico vai além: ele divide o texto quando o tema muda. Ao gerar representações vetoriais de frases adjacentes e medir a similaridade de cosseno, podemos detectar quando a discussão passa para um novo assunto.

Quando a similaridade cai abaixo de um limiar, insira um limite de bloco. Isso produz blocos com coesão temática, ideais para geração aumentada por recuperação (RAG).

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

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

def semantic_chunk(sentences, threshold=0.75):
    embeddings = model.encode(sentences)
    chunks, current = [], [sentences[0]]
    for i in range(1, len(sentences)):
        sim = cosine_similarity(
            [embeddings[i-1]], [embeddings[i]]
        )[0][0]
        if sim < threshold:
            chunks.append(' '.join(current))
            current = []
        current.append(sentences[i])
    if current:
        chunks.append(' '.join(current))
    return chunks

Comparação das três estratégias

Veja uma comparação lado a lado para ajudar na escolha:

Tamanho fixo: limites mais rápidos e menos precisos — use em fluxos de processamento simples
Limites de frases: preserva a integridade das frases — use quando a coerência for importante
Semântico: melhor coesão temática — use em RAG quando a recuperação precisa for fundamental

Na prática, o particionamento semântico acrescenta latência devido ao cálculo das representações vetoriais. Escolha com base nos requisitos de precisão da recuperação.

Particionamento para tarefas de recuperação

Na geração aumentada por recuperação (RAG), os blocos se tornam a unidade de busca. Uma consulta do usuário é convertida em uma representação vetorial, e os blocos mais semelhantes são recuperados e inseridos na instrução.

Blocos menores (200–400 tokens) melhoram a precisão da recuperação — cada bloco contém uma ideia específica. Blocos maiores (800–1000 tokens) oferecem mais contexto, mas podem incluir conteúdo irrelevante junto ao trecho pertinente.

import openai
import numpy as np

client = openai.OpenAI(api_key='sk-...')

def embed(text):
    resp = client.embeddings.create(
        model='text-embedding-3-small',
        input=text
    )
    return np.array(resp.data[0].embedding)

def retrieve(query, chunks, top_k=3):
    q_emb = embed(query)
    scores = [(i, np.dot(q_emb, embed(c))) for i, c in enumerate(chunks)]
    scores.sort(key=lambda x: x[1], reverse=True)
    return [chunks[i] for i, _ in scores[:top_k]]

Particionamento para tarefas de sumarização

Para sumarização, os blocos devem ser grandes o suficiente para conter uma argumentação ou seção completa. Blocos de 600–800 tokens delimitados por frases funcionam bem.

Cada bloco é resumido de forma independente (a etapa de mapeamento) e, em seguida, os resumos são combinados em um resumo final (a etapa de redução). Esse é o padrão clássico de mapeamento-redução, abordado na próxima lição.

Sobreposição: conectando os limites dos blocos

Uma técnica prática para reduzir erros nos limites é adicionar sobreposição entre os blocos. Os últimos 100–200 tokens do bloco N são repetidos no início do bloco N+1.

A sobreposição garante que uma frase que atravesse um limite apareça completa em pelo menos um bloco. Isso é especialmente importante para a recuperação — uma consulta sobre um tema que atravesse um limite corresponderá ao bloco sobreposto.

def fixed_chunk_with_overlap(text, max_tokens=1000, overlap=200):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    step = max_tokens - overlap
    for i in range(0, len(tokens), step):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
        if i + max_tokens >= len(tokens):
            break
    return chunks

Enriquecimento de metadados por bloco

Cada bloco deve conter metadados para que as etapas subsequentes possam referenciar sua origem:

source: nome do arquivo ou URL
page: número da página
chunk_index: posição no documento
section: capítulo ou título

Esses metadados são armazenados junto à representação vetorial em um banco de dados vetorial (Pinecone, Chroma, Weaviate) e retornados com os blocos recuperados para que o LLM possa citar as fontes.

def chunk_with_metadata(text, source='doc.pdf', page=1):
    chunks = fixed_chunk_with_overlap(text)
    return [
        {
            'text': chunk,
            'metadata': {
                'source': source,
                'page': page,
                'chunk_index': i
            }
        }
        for i, chunk in enumerate(chunks)
    ]

Escolhendo a estratégia correta

Um guia rápido para decidir:

A velocidade é prioritária e o conteúdo é prosa: particionamento nos limites das frases
A precisão da recuperação é fundamental: particionamento semântico com blocos pequenos (300 tokens)
Para resumir um livro ou relatório: particionamento nos limites das frases, blocos maiores (800 tokens), mapeamento-redução
Documentos jurídicos ou técnicos: particionamento semântico para manter as cláusulas juntas

Sempre meça a cobertura da recuperação em um conjunto representativo de consultas antes de escolher definitivamente uma estratégia.

Verificação de conhecimentos

Qual estratégia de fragmentação divide o texto quando a similaridade de cosseno entre as representações vetoriais de sentenças adjacentes cai abaixo de um limiar?

Recapitulação: estratégias de fragmentação

Você aprendeu três estratégias fundamentais de fragmentação:

Tamanho fixo: divide a cada N tokens — rápida, simples e sem considerar limites naturais
Limite de sentença: divide nas pausas naturais entre sentenças — coerente e de complexidade moderada
Semântica: divide nas mudanças de tópico por meio da similaridade entre representações vetoriais — mais precisa e de maior custo

Adicione sobreposição entre os fragmentos para reduzir erros nos limites e sempre associe metadados (fonte, página, índice) para permitir citação e rastreabilidade. A próxima lição aborda o padrão de sumarização por mapeamento e redução.

Perguntas Frequentes

A aula “Estratégias de divisão para textos longos” é grátis?

Sim — o texto completo de “Estratégias de divisão para textos longos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Estratégias de divisão para textos longos”?

Abordagens de divisão por tamanho fixo, limites de frases e semântica. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Estratégias de divisão para textos longos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Estratégias de divisão para textos longos
Padrão de sumarização Map-Reduce
Sumarização hierárquica
Mantendo o contexto entre partes

← Voltar para AI Prompt Engineering