0Pricing
AI Agents · Lección

Indexar un conjunto de documentos

Genere embeddings para cada fragmento y almacene los vectores en un índice: el paso de preparación offline de cualquier sistema RAG.

Indexar un conjunto de documentos es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.

Pipeline de ingestión

El pipeline offline de RAG tiene cuatro pasos:

  1. Cargar documentos (PDF, HTML, MD)
  2. Fragmentar cada documento
  3. Generar embeddings de cada fragmento
  4. Almacenar los vectores y metadatos en un índice

Paso 1: cargar documentos

Utilice loaders especializados para cada formato:

# PDFs
from pypdf import PdfReader
text = ''
for page in PdfReader('doc.pdf').pages:
    text += page.extract_text()

# HTML
from bs4 import BeautifulSoup
text = BeautifulSoup(html, 'html.parser').get_text()

# Markdown — just read the file
text = open('doc.md').read()

Paso 2: fragmentar

Utilice el splitter de la lección anterior:

from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=100)
chunks = splitter.split_text(text)

Paso 3: generar embeddings en lotes

Genere embeddings de varios fragmentos en cada llamada a la API:

from openai import OpenAI
client = OpenAI()

def embed_batch(texts, batch_size=100):
    vectors = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        resp = client.embeddings.create(model='text-embedding-3-small', input=batch)
        vectors.extend(d.embedding for d in resp.data)
    return vectors

Paso 4: almacenar

Para entre 10k y 50k fragmentos, FAISS o Chroma son suficientes:

import chromadb
client = chromadb.Client()
collection = client.create_collection('docs')

collection.add(
    ids=[f'doc-{i}' for i in range(len(chunks))],
    embeddings=vectors,
    documents=chunks,
    metadatas=[{'source': 'doc.pdf', 'page': i} for i in range(len(chunks))]
)

Ingestión idempotente

Haga que la ingestión sea segura para volver a ejecutarla. Use IDs deterministas (un hash del contenido) para que repetirla no genere duplicados:

import hashlib

def chunk_id(source, text):
    h = hashlib.sha256(text.encode()).hexdigest()[:16]
    return f'{source}:{h}'

print(chunk_id('handbook.pdf', 'Employees get 20 vacation days per year.'))
print(chunk_id('handbook.pdf', 'Employees get 20 vacation days per year.'))

Actualizaciones incrementales

Cuando cambia un documento:

  1. Calcule los fragmentos nuevos
  2. Compárelos con los IDs existentes
  3. Elimine los que ya no estén, añada los nuevos y conserve los que no hayan cambiado

El enfoque ingenuo (eliminarlo todo y volver a insertarlo) es adecuado para corpus pequeños, pero desperdicia llamadas a la API de embeddings.

Metadatos para filtrar

Incluya cualquier campo por el que pueda querer filtrar más adelante:

metadata = {
    'source': '/docs/handbook.pdf',
    'page': 42,
    'department': 'engineering',
    'updated_at': '2024-08-12',
    'access_level': 'internal'
}
for k, v in metadata.items():
    print(f"{k}: {v}")

Progreso y puntos de control

Para ingestiones grandes, registre el progreso y cree puntos de control:

for i, batch in enumerate(batches):
    embed_and_store(batch)
    if i % 10 == 0:
        save_checkpoint(i)
        print(f'Processed {i * 100} chunks')

Límites de tasa

Los embeddings de OpenAI tienen un límite de tasa elevado, pero real. Use semáforos o reintentos con `tenacity`:

from asyncio import Semaphore
sem = Semaphore(10)  # 10 concurrent embed calls max

async def safe_embed(batch):
    async with sem:
        return await client.embeddings.create(...)

Comprobar el índice

Después de la ingestión, ejecute algunas consultas de prueba e inspeccione los resultados manualmente. Si no aparece nada relevante, la fragmentación o los embeddings no funcionan correctamente; descúbralo antes que los usuarios.

Versionado del índice

Versione el índice para poder cambiar a una nueva fragmentación o a un nuevo modelo de embeddings sin tiempo de inactividad:

collection = client.create_collection(f'docs-v2-{date.today()}')
# old collection stays live until new one is validated

IDs idempotentes

¿Por qué usar hashes del contenido como IDs de los fragmentos?

Resumen

Cargar -> fragmentar -> generar embeddings -> almacenar, con IDs idempotentes y metadatos. El índice es la base de todos los pasos posteriores de recuperación.

Preguntas frecuentes

¿La lección «Indexar un conjunto de documentos» es gratis?

Sí — el texto completo de «Indexar un conjunto de documentos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.

¿Qué aprenderé en «Indexar un conjunto de documentos»?

Genere embeddings para cada fragmento y almacene los vectores en un índice: el paso de preparación offline de cualquier sistema RAG. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Agents?

No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Indexar un conjunto de documentos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Agents?

Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Qué resuelve RAG (fecha de corte del conocimiento y alucinaciones)
  2. Estrategias de segmentación (fija, por frases y semántica)
  3. Indexar un conjunto de documentos
  4. Crear un RAG ingenuo con FAISS o Chroma
← Volver a AI Agents