Semantische Aufteilung für besseren Abruf

Das Problem des Chunkings mit fester Größe

Das traditionelle Chunking teilt den Text alle N Zeichen oder tokens:

• ❌ Trennt Sätze mitten im Gedankengang
• ❌ Trennt zusammenhängende Inhalte
• ❌ Keine Kontextwahrnehmung

Semantisches Chunking teilt basierend auf Bedeutung, nicht auf Länge.

Wie semantisches Chunking funktioniert

1. Jeden Satz embedden mit einem Satz-Encoder
2. Ähnlichkeit berechnen zwischen aufeinanderfolgenden Sätzen
3. Teilen, wo die Ähnlichkeit stark abfällt (Themenwechsel)

DEVELOPERpython
from sentence_transformers import SentenceTransformer
import numpy as np

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

def semantic_chunk(text, similarity_threshold=0.5):
    # Split into sentences
    sentences = text.split('. ')

    # Embed all sentences
    embeddings = model.encode(sentences)

    # Calculate cosine similarity between consecutive sentences
    chunks = []
    current_chunk = [sentences[0]]

    for i in range(1, len(sentences)):
        similarity = np.dot(embeddings[i-1], embeddings[i]) / (
            np.linalg.norm(embeddings[i-1]) * np.linalg.norm(embeddings[i])
        )

        if similarity < similarity_threshold:
            # Topic changed - start new chunk
            chunks.append('. '.join(current_chunk))
            current_chunk = [sentences[i]]
        else:
            current_chunk.append(sentences[i])

    # Add final chunk
    chunks.append('. '.join(current_chunk))

    return chunks

Semantisches Chunking in LangChain (2025)

LangChain enthält jetzt integriertes semantisches Chunking:

DEVELOPERpython
from langchain.text_splitter import SemanticChunker
from langchain_openai.embeddings import OpenAIEmbeddings

text_splitter = SemanticChunker(
    OpenAIEmbeddings(),
    breakpoint_threshold_type="percentile",  # or "standard_deviation"
    breakpoint_threshold_amount=95
)

chunks = text_splitter.create_documents([long_text])

Fortgeschritten: Mehrstufiges semantisches Chunking

Kombinieren Sie semantische Teilungen mit Größenbeschränkungen:

DEVELOPERpython
def smart_semantic_chunk(text, max_chunk_size=1000, min_chunk_size=200):
    # First: semantic split
    semantic_chunks = semantic_chunk(text)

    final_chunks = []

    for chunk in semantic_chunks:
        # If chunk too large, further split
        if len(chunk) > max_chunk_size:
            # Split by paragraphs within this semantic section
            paragraphs = chunk.split('\n\n')
            sub_chunk = ""

            for para in paragraphs:
                if len(sub_chunk) + len(para) < max_chunk_size:
                    sub_chunk += para + "\n\n"
                else:
                    final_chunks.append(sub_chunk.strip())
                    sub_chunk = para + "\n\n"

            if sub_chunk:
                final_chunks.append(sub_chunk.strip())

        # If chunk too small, merge with next
        elif len(chunk) < min_chunk_size and final_chunks:
            final_chunks[-1] += "\n\n" + chunk
        else:
            final_chunks.append(chunk)

    return final_chunks

Semantischer Separator Llamaindex

DEVELOPERpython
from llama_index.node_parser import SemanticSplitterNodeParser
from llama_index.embeddings import OpenAIEmbedding

embed_model = OpenAIEmbedding()

splitter = SemanticSplitterNodeParser(
    buffer_size=1,  # Sentences to group
    breakpoint_percentile_threshold=95,
    embed_model=embed_model
)

nodes = splitter.get_nodes_from_documents(documents)

Wann semantisches Chunking verwenden

Verwenden Sie semantisches Chunking, wenn:

• Die Dokumente klare Themenübergänge haben
• Sie ein hochpräzises Retrieval benötigen
• Der Inhalt narrativ oder erklärend ist
• Sie sich die Rechenkosten leisten können

Bleiben Sie beim Chunking mit fester Größe, wenn:

• Die Geschwindigkeit kritisch ist
• Die Dokumente sehr einheitlich sind
• Das Budget begrenzt ist
• Der Inhalt tabellarisch oder strukturiert ist

Leistungsüberlegungen

Kosten für embedding :

• Semantisches Chunking erfordert das embedding jedes Satzes
• Für ein Dokument mit 10.000 Wörtern: ~300 Sätze zum embedden
• Erwägen Sie das Caching der embeddings

Geschwindigkeitsvergleich (November 2025) :

• Feste Größe: ~1ms pro Dokument
• Semantisch: ~100–500ms pro Dokument (modellabhängig)

Hybrider Ansatz: Das Beste aus beiden Welten

DEVELOPERpython
def hybrid_chunk(text, target_size=500):
    # 1. Semantic split first
    semantic_chunks = semantic_chunk(text, similarity_threshold=0.6)

    # 2. Merge small chunks, split large ones
    final_chunks = []
    buffer = ""

    for chunk in semantic_chunks:
        if len(buffer) + len(chunk) < target_size * 1.5:
            buffer += "\n\n" + chunk if buffer else chunk
        else:
            if buffer:
                final_chunks.append(buffer)
            buffer = chunk

    if buffer:
        final_chunks.append(buffer)

    return final_chunks

Evaluation

Testen Sie die Qualität der Retrieval mit semantischem vs. festem Chunking:

DEVELOPERpython
# Your test queries
queries = [
    "How does photosynthesis work?",
    "What are the benefits of exercise?"
]

# Compare retrieval accuracy
semantic_results = evaluate_chunking(semantic_chunks, queries)
fixed_results = evaluate_chunking(fixed_chunks, queries)

print(f"Semantic MRR: {semantic_results['mrr']}")
print(f"Fixed MRR: {fixed_results['mrr']}")

Semantisches Chunking verbessert typischerweise das Retrieval um 15–30% bringt aber etwa 100x mehr Rechenaufwand. Wählen Sie je nach Ihrem Präzisions-/Kosten-Kompromiss.