Olá pessoal! ?

Você sabe o que me mantém acordado à noite? Pensando em como tornar nossos sistemas de IA mais inteligentes e eficientes. Hoje, quero falar sobre algo que pode parecer básico, mas é crucial ao construir aplicativos de IA incríveis: chunking ✨.

O que diabos é chunking, afinal? ?

Pense no chunking como a maneira que sua IA usa para dividir um enorme bufê de informações em porções gerenciáveis ​​e pequenas. Assim como você não tentaria colocar uma pizza inteira na boca de uma só vez (ou talvez tentasse, sem julgamento aqui!), sua IA precisa quebrar textos grandes em pedaços menores para processá-los de forma eficaz.

Isso é especialmente importante para o que chamamos de modelos RAG (Retrieval-Augmented Generation). Esses bandidos não apenas inventam coisas - eles na verdade vão buscar informações reais de fontes externas. Muito legal, certo?

Por que você deveria se importar? ?

Olha, se você está construindo algo que lide com texto - seja um chatbot de suporte ao cliente ou uma pesquisa sofisticada na base de conhecimento - acertar a segmentação é a diferença entre uma IA que fornece respostas precisas e outra que é apenas. .meh.

Pedaços muito grandes? Seu modelo não entende o objetivo.
Pedaços muito pequenos? Perde-se nos detalhes.

Vamos sujar as mãos: exemplos reais?

Exemplo de Python: fragmentação semântica

Primeiro, vamos dar uma olhada em um exemplo de Python usando LangChain para agrupamento semântico:

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]}...")

Exemplo de Node.js e CDK: construindo uma base de conhecimento

Agora, vamos construir algo real: uma base de conhecimento sem servidor usando AWS CDK e Node.js! ?

Primeiro, a infraestrutura CDK (é aqui que a mágica acontece):

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);
  }
}

E agora, a função Lambda que faz o chunking e a indexação:

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 




  
  
  Como tudo funciona junto?



Upload de documento: quando você faz upload de um documento para o bucket S3, ele aciona nossa função Lambda.

Processamento: A função Lambda:

Recupera o documento do S3
Compartimenta usando nosso algoritmo de segmentação inteligente
Indexa cada pedaço no OpenSearch com metadados


Recuperação: Mais tarde, quando seu aplicativo precisar encontrar informações, ele poderá consultar o OpenSearch para encontrar os pedaços mais relevantes.
Aqui está um exemplo rápido de como você pode consultar esta base de conhecimento:


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,
  }));
}





  
  
  A vantagem da AWS ?️


Usar serviços AWS como S3, Lambda e OpenSearch nos dá:

• Escalabilidade sem servidor (sem servidores para gerenciar!)
• Preços pagos por uso (sua carteira vai agradecer)
• Serviços gerenciados (menos trabalho operacional = mais diversão com programação)

Considerações finais?

Aí está, pessoal! Um exemplo real de como implementar chunking em uma base de conhecimento sem servidor. A melhor parte? Isso é dimensionado automaticamente e pode lidar com documentos de qualquer tamanho.

Lembre-se, a chave para um bom chunking é:

1. Escolha o tamanho de bloco certo para seu caso de uso
2. Considere a sobreposição para manter o contexto
3. Use limites naturais quando possível (como frases ou parágrafos)

Qual é a sua experiência na construção de bases de conhecimento? Você já tentou diferentes estratégias de chunking? Deixe-me saber nos comentários abaixo! ?