Crear Knowledge Base en AWS con Crawl4AI

En los últimos meses, el concepto de retrieval augmented generation (RAG) empezó a aparecer cada vez más en productos, demos y artículos sobre IA. La idea central es simple:
en lugar de que un modelo responda solo con lo que “sabe”, le damos documentos propios como fuente de información.

AWS Bedrock incorpora este enfoque a través de las Knowledge Bases, una forma administrada de conectar documentos, embeddings y modelos de lenguaje sin tener que construir toda la infraestructura desde cero.

En este artículo vamos a recorrer, paso a paso, cómo crear una Knowledge Base usando documentación pública como ejemplo. No vamos a construir un asistente ni una aplicación final: el objetivo es entender el proceso completo, desde los documentos hasta la consulta en Bedrock.

Qué vamos a hacer

A lo largo del artículo vamos a:

Extraer contenido limpio desde documentación técnica pública
Almacenar esos documentos en Amazon S3
Crear una Knowledge Base en Amazon Bedrock
Sincronizar los documentos
Probar consultas directamente desde la consola

Usaremos la documentación de Kubernetes únicamente como ejemplo, pero el mismo flujo aplica para:

documentación interna
manuales técnicos
wikis
guías operativas
o cualquier conjunto de archivos de texto

Conceptos clave

Antes de avanzar, vale la pena aclarar algunos conceptos que vamos a usar durante el tutorial.

Amazon Bedrock

Amazon Bedrock es un servicio administrado de AWS que permite trabajar con modelos fundacionales (como Claude o Titan) sin necesidad de entrenarlos ni desplegarlos.

Entre otras cosas, Bedrock ofrece:

gestión de modelos
embeddings
y Knowledge Bases, que es lo que vamos a usar acá

Knowledge Base en Bedrock

Una Knowledge Base es un recurso que conecta:

documentos almacenados (por ejemplo, en S3)
un modelo de embeddings
un vector store
y un modelo de lenguaje

El resultado es una base de conocimiento que puede responder preguntas usando exclusivamente los documentos que vos cargaste, con trazabilidad hacia las fuentes.

En este artículo vamos a crear la Knowledge Base y probarla desde la consola. La integración en una app o chatbot queda para más adelante.

Crawl4AI

Crawl4AI es una herramienta de scraping pensada específicamente para casos de uso con LLMs.

A diferencia de scrapers tradicionales, su foco está en:

extraer solo el contenido principal
eliminar navegación, footers y elementos visuales
generar texto limpio en Markdown

Esto es clave cuando el destino final del contenido no es un humano, sino un sistema de embeddings.

Stack que vamos a usar

El stack es simple y económico:

Crawl4AI – para extraer contenido limpio
Amazon S3 – almacenamiento de documentos
Amazon Bedrock Knowledge Bases – gestión del RAG
S3 Vector Store – almacenamiento de embeddings

Parte 1: Setup del entorno

Pre-requisitos

Python 3.11 o superior
AWS CLI configurado
Cuenta de AWS con acceso a Bedrock

Instalación de dependencias

mkdir scraper-kb-bedrock
cd scraper-kb-bedrock

python3 -m venv venv
source venv/bin/activate

pip install crawl4ai boto3 requests
playwright install

Configurar AWS CLI

aws configure

Configurar:

Access Key
Secret Key
Región (ej: us-east-1)

Crear bucket S3

aws s3 mb s3://docs-kb-bedrock --region us-east-1

Este bucket va a contener los documentos que luego usará la Knowledge Base.

Parte 2: Descubrir URLs usando sitemaps

Para cargar documentos en una Knowledge Base primero necesitamos saber qué páginas existen.

Muchos sitios publican un sitemap, un archivo XML que lista todas las URLs disponibles.

En el caso de Kubernetes:

curl -s https://kubernetes.io/en/sitemap.xml | head

A partir de ese archivo podemos identificar secciones relevantes y decidir qué contenido usar.
Para este tutorial vamos a limitarnos a un conjunto pequeño de páginas, solo para demostrar el flujo completo.

Parte 3: Scraping controlado (10 páginas)

En lugar de scrapear cientos de URLs, vamos a hacer algo mucho más simple:
extraer 10 páginas reales, limpiarlas y subirlas a S3.

Esto es suficiente para:

crear la Knowledge Base
sincronizar documentos
probar consultas en Bedrock

Script de scraping

import asyncio
import boto3
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig

BUCKET = "docs-kb-bedrock"

URLS = [
    "https://kubernetes.io/docs/concepts/overview/",
    "https://kubernetes.io/docs/concepts/workloads/pods/",
    "https://kubernetes.io/docs/concepts/services-networking/service/",
    "https://kubernetes.io/docs/concepts/configuration/configmap/",
    "https://kubernetes.io/docs/concepts/workloads/controllers/deployment/",
    "https://kubernetes.io/docs/tasks/run-application/run-stateless-application-deployment/",
    "https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/",
    "https://kubernetes.io/docs/tutorials/kubernetes-basics/",
    "https://kubernetes.io/docs/setup/",
    "https://kubernetes.io/docs/reference/glossary/"
]

s3 = boto3.client("s3")

async def scrape():
    config = CrawlerRunConfig(
        excluded_tags=["nav", "footer", "header", "aside"],
        remove_overlay_elements=True,
        word_count_threshold=10
    )

    async with AsyncWebCrawler() as crawler:
        for url in URLS:
            result = await crawler.arun(url=url, config=config)
            if result.success:
                key = f"kubernetes/{url.split('/')[-2]}.md"
                s3.put_object(
                    Bucket=BUCKET,
                    Key=key,
                    Body=result.markdown.encode("utf-8")
                )
                print(f"Subido: {key}")

asyncio.run(scrape())

Este script: