¡Hola amigos! ?

¿Sabes lo que me mantiene despierto por la noche? Pensando en cómo hacer que nuestros sistemas de IA sean más inteligentes y eficientes. Hoy quiero hablar sobre algo que puede parecer básico pero que es crucial a la hora de crear aplicaciones de IA increíbles: fragmentación ✨.

¿Qué diablos es fragmentar de todos modos? ?

Piense en la fragmentación como la manera que tiene su IA de descomponer un enorme conjunto de información en porciones manejables y del tamaño de un bocado. Así como no intentarías meterte una pizza entera en la boca de una vez (o tal vez lo harías, ¡no te juzgues!), tu IA necesita dividir textos grandes en pedazos más pequeños para procesarlos de manera efectiva.

Esto es especialmente importante para lo que llamamos modelos RAG (Recuperación-Generación Aumentada). Estos chicos malos no sólo inventan cosas, sino que buscan información real de fuentes externas. Bastante bueno, ¿verdad?

¿Por qué debería importarte? ?

Mira, si estás creando algo que tenga que ver con texto, ya sea un chatbot de atención al cliente o una búsqueda sofisticada en una base de conocimientos, lograr la fragmentación correcta es la diferencia entre una IA que brinda respuestas acertadas y una que simplemente... . meh.

¿Trozos demasiado grandes? Tu modelo no entiende el punto.
¿Trozos demasiado pequeños? Se pierde en los detalles.

Ensuciémonos las manos: ¿ejemplos reales?

Ejemplo de Python: fragmentación semántica

Primero, veamos un ejemplo de Python usando LangChain para fragmentación semántica:

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

Ejemplo de Node.js y CDK: creación de una base de conocimientos

Ahora, creemos algo real: ¡una base de conocimientos sin servidor utilizando AWS CDK y Node.js! ?

Primero, la infraestructura CDK (aquí es donde ocurre la magia):

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

Y ahora, la función Lambda que realiza la fragmentación y la indexación:

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 




  
  
  ¿Cómo funciona todo en conjunto?



Carga de documentos: cuando carga un documento en el depósito de S3, se activa nuestra función Lambda.

Procesamiento: La función Lambda:

Recupera el documento de S3
Lo fragmenta utilizando nuestro algoritmo de fragmentación inteligente
Indiza cada fragmento en OpenSearch con metadatos


Recuperación: Más tarde, cuando su aplicación necesite encontrar información, puede consultar OpenSearch para encontrar los fragmentos más relevantes.
Aquí tienes un ejemplo rápido de cómo puedes consultar esta base de conocimientos:


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





  
  
  ¿La ventaja de AWS? ️


El uso de servicios de AWS como S3, Lambda y OpenSearch nos brinda:

• Escalabilidad sin servidor (¡no hay servidores que administrar!)
• Precios de pago por uso (tu billetera te lo agradecerá)
• Servicios administrados (menos trabajo de operaciones = más diversión codificando)

¿Pensamientos finales?

¡Ahí lo tienen, amigos! Un ejemplo del mundo real de cómo implementar fragmentación en una base de conocimientos sin servidor. ¿La mejor parte? Esto se escala automáticamente y puede manejar documentos de cualquier tamaño.

Recuerde, la clave para una buena fragmentación es:

1. Elija el tamaño de fragmento adecuado para su caso de uso
2. Considere la superposición para mantener el contexto
3. Utilice límites naturales cuando sea posible (como oraciones o párrafos)

¿Cuál es su experiencia en la creación de bases de conocimiento? ¿Has probado diferentes estrategias de fragmentación? ¡Déjamelo saber en los comentarios a continuación! ?