Hey Leute! ?

Weißt du, was mich nachts wach hält? Wir denken darüber nach, wie wir unsere KI-Systeme intelligenter und effizienter machen können. Heute möchte ich über etwas sprechen, das vielleicht einfach klingt, aber bei der Entwicklung erstklassiger KI-Anwendungen von entscheidender Bedeutung ist: Chunking ✨.

Was zum Teufel ist überhaupt Chunking? ?

Stellen Sie sich Chunking als die Methode Ihrer KI vor, ein riesiges Buffet an Informationen in überschaubare, mundgerechte Portionen aufzuteilen. Genauso wie Sie nicht versuchen würden, sich eine ganze Pizza auf einmal in den Mund zu stopfen (oder vielleicht doch, kein Urteil hier!), muss Ihre KI große Texte in kleinere Teile zerlegen, um sie effektiv zu verarbeiten.

Dies ist besonders wichtig für das, was wir RAG-Modelle (Retrieval-Augmented Generation) nennen. Diese bösen Jungs erfinden nicht nur Dinge, sie besorgen sich tatsächlich echte Informationen aus externen Quellen. Ziemlich ordentlich, oder?

Warum sollte es dich interessieren? ?

Sehen Sie, wenn Sie etwas erstellen, das sich mit Text befasst – sei es ein Kundensupport-Chatbot oder eine ausgefallene Wissensdatenbanksuche –, ist die richtige Aufteilung der Datenblöcke der Unterschied zwischen einer KI, die punktgenaue Antworten gibt, und einer, die einfach … . meh.

Zu große Stücke? Ihr Modell verfehlt den Kern.
Zu kleine Stücke? Es geht im Detail verloren.

Machen wir uns die Hände schmutzig: Echte Beispiele?

Python-Beispiel: Semantic Chunking

Schauen wir uns zunächst ein Python-Beispiel an, das LangChain für semantisches Chunking verwendet:

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader

def semantic_chunk(file_path):
    # Load the document
    loader = TextLoader(file_path)
    document = loader.load()

    # Create a text splitter
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len,
        separators=["\n\n", "\n", " ", ""]
    )

    # Split the document into chunks
    chunks = text_splitter.split_documents(document)

    return chunks

# Example usage
chunks = semantic_chunk('knowledge_base.txt')
for i, chunk in enumerate(chunks):
    print(f"Chunk {i}: {chunk.page_content[:50]}...")

Node.js- und CDK-Beispiel: Aufbau einer Wissensdatenbank

Jetzt bauen wir etwas Echtes auf – eine serverlose Wissensdatenbank mit AWS CDK und Node.js! ?

Zuerst die CDK-Infrastruktur (hier passiert die Magie):

import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as opensearch from 'aws-cdk-lib/aws-opensearch';
import * as iam from 'aws-cdk-lib/aws-iam';

export class KnowledgeBaseStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // S3 bucket to store our documents
    const documentBucket = new s3.Bucket(this, 'DocumentBucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });

    // OpenSearch domain for storing our chunks
    const openSearchDomain = new opensearch.Domain(this, 'DocumentSearch', {
      version: opensearch.EngineVersion.OPENSEARCH_2_5,
      capacity: {
        dataNodes: 1,
        dataNodeInstanceType: 't3.small.search',
      },
      ebs: {
        volumeSize: 10,
      },
    });

    // Lambda function for processing documents
    const processorFunction = new lambda.Function(this, 'ProcessorFunction', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
      environment: {
        OPENSEARCH_DOMAIN: openSearchDomain.domainEndpoint,
      },
      timeout: cdk.Duration.minutes(5),
    });

    // Grant permissions
    documentBucket.grantRead(processorFunction);
    openSearchDomain.grantWrite(processorFunction);
  }
}

Und jetzt die Lambda-Funktion, die das Chunking und die Indizierung übernimmt:

import { S3Event } from 'aws-lambda';
import { S3 } from 'aws-sdk';
import { Client } from '@opensearch-project/opensearch';
import { defaultProvider } from '@aws-sdk/credential-provider-node';
import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';

const s3 = new S3();
const CHUNK_SIZE = 1000;
const CHUNK_OVERLAP = 200;

// Create OpenSearch client
const client = new Client({
  ...AwsSigv4Signer({
    region: process.env.AWS_REGION,
    service: 'es',
    getCredentials: () => {
      const credentialsProvider = defaultProvider();
      return credentialsProvider();
    },
  }),
  node: `https://${process.env.OPENSEARCH_DOMAIN}`,
});

export const handler = async (event: S3Event) => {
  for (const record of event.Records) {
    const bucket = record.s3.bucket.name;
    const key = decodeURIComponent(record.s3.object.key.replace(/\ /g, ' '));

    // Get the document from S3
    const { Body } = await s3.getObject({ Bucket: bucket, Key: key }).promise();
    const text = Body.toString('utf-8');

    // Chunk the document
    const chunks = chunkText(text);

    // Index chunks in OpenSearch
    for (const [index, chunk] of chunks.entries()) {
      await client.index({
        index: 'knowledge-base',
        body: {
          content: chunk,
          documentKey: key,
          chunkIndex: index,
          timestamp: new Date().toISOString(),
        },
      });
    }
  }
};

function chunkText(text: string): string[] {
  const chunks: string[] = [];
  let start = 0;

  while (start 




  
  
  Wie funktioniert alles zusammen?



Dokument-Upload: Wenn Sie ein Dokument in den S3-Bucket hochladen, wird unsere Lambda-Funktion ausgelöst.

Verarbeitung: Die Lambda-Funktion:

Ruft das Dokument aus S3 ab
Chunking mit unserem intelligenten Chunking-Algorithmus
Indiziert jeden Block in OpenSearch mit Metadaten


Abruf: Wenn Ihre Anwendung später Informationen finden muss, kann sie OpenSearch abfragen, um die relevantesten Abschnitte zu finden.
Hier ist ein kurzes Beispiel dafür, wie Sie diese Wissensdatenbank abfragen können:


async function queryKnowledgeBase(query: string) {
  const response = await client.search({
    index: 'knowledge-base',
    body: {
      query: {
        multi_match: {
          query: query,
          fields: ['content'],
        },
      },
    },
  });

  return response.body.hits.hits.map(hit => ({
    content: hit._source.content,
    documentKey: hit._source.documentKey,
    score: hit._score,
  }));
}





  
  
  Der AWS-Vorteil ?️


Die Verwendung von AWS-Diensten wie S3, Lambda und OpenSearch bietet uns:

• Serverlose Skalierbarkeit (keine zu verwaltenden Server!)
• Pay-per-Use-Preis (Ihr Geldbeutel wird es Ihnen danken)
• Verwaltete Dienste (weniger Betriebsaufwand = mehr Programmierspaß)

Letzte Gedanken?

Da habt ihr es, Leute! Ein reales Beispiel für die Implementierung von Chunking in einer serverlosen Wissensdatenbank. Das Beste daran? Dies skaliert automatisch und kann Dokumente jeder Größe verarbeiten.

Denken Sie daran, der Schlüssel zu gutem Chunking ist:

1. Wählen Sie die richtige Blockgröße für Ihren Anwendungsfall
2. Berücksichtigen Sie Überschneidungen, um den Kontext aufrechtzuerhalten
3. Verwenden Sie nach Möglichkeit natürliche Grenzen (wie Sätze oder Absätze)

Welche Erfahrungen haben Sie mit dem Aufbau von Wissensdatenbanken gemacht? Haben Sie verschiedene Chunking-Strategien ausprobiert? Lass es mich unten in den Kommentaren wissen! ?