Temario Lección 154 de 250 · Construye una canalización RAG
Construye una canalización RAG

Dividir documentos largos en fragmentos

La generación aumentada por recuperación (RAG) es la forma de apuntar un modelo general a tus datos: un manual de políticas, un manual de producto, los tickets de soporte del último trimestre. El modelo nunca memorizó nada de eso, así que en el momento de la pregunta recuperas los pasajes relevantes y los pegas en el prompt. Toda la canalización son solo cinco piezas honestas: dividir los documentos en fragmentos, crear el embedding de cada fragmento, guardar los vectores, recuperar las mejores coincidencias para una consulta y construir un prompt fundamentado. Construirás las cinco a lo largo de este módulo. El modelo que escribe la frase final puede ser el WebLLM del dispositivo en tu navegador, pero cada paso a su alrededor es Python sencillo y comprobable, que es justo la parte que miran las empresas al contratar.

El primer paso es la división en fragmentos. Un documento de 40 páginas es demasiado grande para un solo vector y demasiado grande para meterlo en un prompt, así que lo cortas en ventanas solapadas. ¿Por qué solapadas? Porque un dato que necesitas puede quedar a caballo de un corte. Si cortas limpiamente en el carácter 500 y la frase "refunds take five business days" va del 495 al 515, ningún fragmento contiene la respuesta completa. Unos pocos caracteres de solapamiento permiten que la misma frase viva intacta en los dos vecinos.

La forma: deslizas una ventana de size caracteres hacia delante con un step de size - overlap cada vez.

def chunk(text, size, overlap):
    step = size - overlap
    chunks = []
    i = 0
    while i < len(text):
        chunks.append(text[i:i + size])
        if i + size >= len(text):
            break          # this window already reached the end
        i += step
    return chunks

Ese break importa: sin él sigues avanzando más allá del final y emites un resto diminuto como "g" como "fragmento" final. Parar en cuanto una ventana llega al final hace que el último fragmento sea uno de verdad.

Qué construir. Escribe chunk(text, size, overlap), que devuelva una lista de ventanas solapadas. Reglas que comprueban las pruebas:

  • Valida las entradas: lanza ValueError si size <= 0, o si overlap es negativo o >= size (un solapamiento tan grande nunca avanza).
  • Un texto vacío devuelve una lista vacía [].
  • Los últimos overlap caracteres de un fragmento son iguales a los primeros overlap caracteres del siguiente.
  • Cobertura completa: unir chunks[0] con chunks[i][overlap:] de cada fragmento posterior reproduce exactamente el texto original, sin caracteres perdidos ni duplicados.

Aquí viven los errores de uno en uno, así que pulsa Ejecutar y mira cómo un párrafo se divide en ventanas que puedes revisar a ojo.

Tu turno

Escribe chunk(text, size, overlap), que deslice una ventana de size caracteres hacia delante en size - overlap en cada paso y devuelva la lista de ventanas. Lanza ValueError cuando size <= 0 o cuando overlap sea negativo o >= size. Devuelve [] para un texto vacío. Detente en cuanto una ventana llegue al final del texto (así el último fragmento puede ser más corto que size, y nunca hay una ventana extra que solo repita el solapamiento). Los fragmentos contiguos deben compartir exactamente overlap caracteres, y unir el primer fragmento con chunk[overlap:] de cada fragmento posterior debe reconstruir el texto original.

¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección

Este ejercicio se abre pronto

Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.