What is crawl for RAG?

Crawl for RAG is the process of discovering website pages, extracting clean content and metadata, chunking and embedding it, and storing it for retrieval-augmented generation.

Should I store HTML or Markdown for RAG?

Markdown is usually easier to chunk and audit because it removes much page chrome while preserving headings, lists, links, tables, and code. Raw HTML can be retained separately when reprocessing or compliance requires it.

How often should a RAG knowledge base be refreshed?

Refresh frequency should follow source volatility and business risk. A documentation site may need event-driven or daily updates, while a stable archive may need less frequent refreshes. Content hashes can be used to reprocess changed pages and remove deleted content.

Does the example use production embeddings?

No. The example uses a deterministic local hashed vector to demonstrate the pipeline without dependencies. A semantic embedding model and vector index should replace it for production use.

¿Qué es crawl para RAG?

Crawl para RAG es el proceso de descubrir páginas web, extraer contenido limpio y metadatos, agruparlo y embebido, y almacenarlo para generación aumentada por recuperación.

¿Debería almacenar HTML o Markdown para RAG?

Markdown suele ser más fácil de agrupar y auditar porque elimina gran parte del chrome de la página mientras preserva encabezados, listas, enlaces, tablas y código. Retén HTML sin procesar por separado cuando el reprocesamiento o los requisitos de cumplimiento lo exijan.

¿Con qué frecuencia se debe actualizar una base de conocimientos RAG?

La frecuencia de actualización debe seguir la volatilidad de la fuente y el riesgo comercial. Un sitio de documentación puede necesitar actualizaciones impulsadas por eventos o diarias; un archivo estable puede necesitar menos. Usa hashes de contenido para reprocesar páginas cambiadas y eliminar contenido eliminado de inmediato.

¿El ejemplo usa embebidos de producción?

No. Usa un vector hash local determinista para demostrar la tubería sin dependencias. Reemplázalo con un modelo de embebido semántico y un índice de vectores antes de usarlo en producción.

Cómo construir una base de conocimientos RAG a partir de cualquier sitio web 2026

TL;DR

Una base de conocimientos RAG útil comienza con documentos fuente limpios y trazables—no con un modelo de incrustación. Preserve la URL canónica, el título, el tiempo de rastreo, los encabezados y el hash de contenido con cada fragmento.
El pipeline es rastreo → normalizar → desduplicar → fragmentar → incrustar → almacenar → recuperar → responder con citas. Evalúe cada límite de manera independiente para que los errores de recuperación no se confundan con errores de modelo.
Markdown es un formato de intercambio práctico para la ingestión de sitios web. Elimina gran parte del ruido de navegación mientras mantiene una estructura de encabezados que puede guiar la fragmentación semántica.
Use Nstproxy Crawl cuando necesite contenido de sitio web renderizado sin mantener navegadores y orquestación de proxy. El ejemplo a continuación utiliza su ruta de raspado actual, y luego demuestra una línea base de recuperación local sin dependencias.

Convierte Páginas Web en Datos Utilizables

Usa Nstproxy Crawl para convertir una URL en salidas limpias para AI, RAG y flujos de trabajo de datos.

Configurar Crawl

Campo	Por qué es importante
`source_url`	Permite que una respuesta cite evidencia
`canonical_url`	Previene duplicados de parámetros de URL
`title` y encabezados	Mejora la visualización y los límites semánticos
`crawled_at`	Soporta políticas de frescura
`content_hash`	Detecta contenido sin cambios o duplicado
`markdown`	Proporciona texto normalizado con estructura
`http_status`	Separa páginas no disponibles de extracciones vacías
contexto de localidad/acceso	Explica diferencias regionales o de idioma

import hashlib
import json
import math
import re
import sqlite3
from datetime import datetime, timezone

DIMENSIONS = 256

def normalize(text: str) -> str:
    text = re.sub(r"\r\n?", "\n", text)
    text = re.sub(r"[ \t]+", " ", text)
    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()

def chunk_markdown(markdown: str, max_words: int = 90):
    chunks, heading, buffer = [], "", []
    for line in normalize(markdown).splitlines():
        if line.startswith("#"):
            if buffer:
                chunks.append((heading, "\n".join(buffer)))
                buffer = []
            heading = line.lstrip("# ")
        else:
            buffer.append(line)
            if len(" ".join(buffer).split()) >= max_words:
                chunks.append((heading, "\n".join(buffer)))
                buffer = []
    if buffer:
        chunks.append((heading, "\n".join(buffer)))
    return [(h, t.strip()) for h, t in chunks if t.strip()]

def embed(text: str):
    vector = [0.0] * DIMENSIONS
    for token in re.findall(r"[a-z0-9]+", text.lower()):
        slot = int(hashlib.sha256(token.encode()).hexdigest()[:8], 16) % DIMENSIONS
        vector[slot] += 1.0
    length = math.sqrt(sum(x * x for x in vector)) or 1.0
    return [x / length for x in vector]

def cosine(a, b):
    return sum(x * y for x, y in zip(a, b))

def ingest(db, url, title, markdown):
    cleaned = normalize(markdown)
    page_hash = hashlib.sha256(cleaned.encode()).hexdigest()
    crawled_at = datetime.now(timezone.utc).isoformat()
    db.execute("DELETE FROM chunks WHERE source_url = ?", (url,))
    for index, (heading, text) in enumerate(chunk_markdown(cleaned)):
        embedding_text = f"{title}\n{heading}\n{text}"
        db.execute(
            "INSERT INTO chunks VALUES (?, ?, ?, ?, ?, ?, ?)",
            (url, title, heading, index, text, json.dumps(embed(embedding_text)),
             f"{page_hash}:{crawled_at}"),
        )
    db.commit()

def search(db, question, limit=3):
    query_vector = embed(question)
    rows = db.execute(
        "SELECT source_url, title, heading, body, vector FROM chunks"
    ).fetchall()
    ranked = [
        (cosine(query_vector, json.loads(vector)), url, title, heading, body)
        for url, title, heading, body, vector in rows
    ]
    return sorted(ranked, reverse=True)[:limit]

db = sqlite3.connect(":memory:")
db.execute("""CREATE TABLE chunks (
    source_url TEXT, title TEXT, heading TEXT, chunk_index INTEGER,
    body TEXT, vector TEXT, version TEXT
)""")

sample = """# Acme Docs
## Authentication
Send an API key in the Authorization header. Never expose the key in client code.
## Retries
Retry rate limits with exponential backoff and jitter. Do not retry invalid credentials.
"""
ingest(db, "https://example.com/docs", "Acme Docs", sample)
for score, url, title, heading, body in search(db, "How should I handle rate limits?"):
    print(f"{score:.3f}\t{heading}\t{url}\t{body}")

TL;DR

Convierte Páginas Web en Datos Utilizables

¿Qué necesita una canalización Crawl-for-RAG?

Paso 1: Definir el Alcance y Rastrear el Sitio Web

Paso 2: Normalizar y Deduplicar Antes de Incrustar

Paso 3: Fragmentar Basado en el Significado, No en Conteos Arbitrarios de Caracteres

Paso 4: Incrustar, Almacenar y Recuperar una Línea Base Local Ejecutable

Paso 5: Generar Respuestas Solo a Partir de la Evidencia Recuperada

Paso 6: Evaluar el Pipeline de Extremo a Extremo

Errores Comunes en la Ingesta de RAG

Lista de Verificación de Producción

Preguntas Frecuentes