Cómo construir sistemas RAG de nivel de producción y reducir los costos de tokens de LLM en un 70%

Conclusiones clave:

• El Markdown limpio es el formato que los LLM realmente desean. El HTML en bruto es principalmente navegación, scripts, espacios publicitarios y estilos en línea; ruido que desperdicia el contexto y degrada la calidad de recuperación. scrape_markdown de Scrapeless devuelve el cuerpo legible de una página como Markdown limpio, por lo que el texto que llega a tu modelo de incrustación es el texto del que trata la página.
• La tubería consta de cuatro movimientos: Descubrir → Extraer → Dividir → Incrustar. Encuentra las URL que importan, renderiza cada una a Markdown limpio con el navegador en la nube, divide el Markdown en fragmentos superpuestos de tamaño adecuado para tu modelo y luego incrusta y persiste en una base de datos vectorial para generación aumentada por recuperación.
• Las páginas pesadas en JavaScript y los muros anti-bots son manejados en la plataforma. Muchas fuentes de alto valor hidratan su contenido a través del renderizado del lado del cliente o se encuentran detrás de desafíos para bots. Scrapeless Scraping Browser renderiza la página en un verdadero navegador en la nube anti-detección con salida residencial, por lo que el Markdown que obtienes es la página completamente hidratada, no una concha vacía.
• Dos superficies, un primitivo. Llama a scrape_markdown desde el servidor MCP de Scrapeless cuando un agente de IA impulsa la tubería, o crea una sesión de navegador en la nube con el SDK de Python cuando un script posee el bucle. Ambos utilizan el mismo navegador en la nube anti-detección.
• Las herramientas MCP sin estado prefijan su carga útil con Response:\n\n. Cuando leas la salida de scrape_markdown a través del servidor MCP, quita ese prefijo antes de dividir; es una solución de una línea que mantiene un encabezado extraviado fuera de tu corpus.
• Navegador en la nube anti-detección, proxies residenciales en más de 195 países. Scrapeless Scraping Browser maneja el renderizado de JavaScript, la salida de proxy residencial y la aleatorización de huellas digitales (UA, zona horaria, WebGL, canvas) en cada sesión, por lo que el script de construcción del corpus se mantiene enfocado en la calidad del texto en lugar de la evasión.
• Gratis para comenzar. Las nuevas cuentas de Scrapeless incluyen el tiempo de ejecución gratuito de Scraping Browser; regístrate en Scrapeless.

Introducción: alimenta tu modelo con el texto, no con el chrome de la página

Un modelo de lenguaje es tan bueno como el texto que lee. Ya sea que estés ensamblando un corpus de ajuste fino, construyendo una base de conocimientos de generación aumentada por recuperación (RAG) sobre tu propia documentación o fundamentando un agente en datos de mercado en vivo, la etapa de entrada decide el límite en todo lo posterior. Basura que entra no es solo basura que sale; son tokens desperdiciados, incrustaciones contaminadas y recuperaciones que presentan un banner de cookies en lugar de una respuesta.

El problema es que la web moderna está construida para navegadores y humanos, no para modelos de incrustación. Una página de artículo típica contiene unos pocos miles de palabras de contenido real envueltas en decenas de miles de caracteres de menús de navegación, botones de compartir, cuadrículas de publicaciones relacionadas, widgets de comentarios, avisos de cookies, scripts de seguimiento y CSS en línea. Alimenta ese HTML en bruto a un incrustador y la señal se ahoga en la marca. Además del ruido, una parte creciente de las páginas renderiza su contenido principal con JavaScript después de la carga inicial, por lo que una simple solicitud HTTP devuelve un contenedor vacío. Otras páginas están detrás de retos anti-bots que bloquean completamente la recolección automatizada.

Esta publicación recorre un flujo de trabajo en Python sobre Scrapeless Scraping Browser que convierte páginas web públicas desordenadas en texto limpio, dividido y listo para incrustar. La tubería tiene cuatro movimientos: descubrir las URL, extraer Markdown limpio, dividir para RAG, incrustar en una base de datos vectorial, y scrape_markdown hace el trabajo pesado en la etapa de extracción devolviendo el cuerpo legible de cualquier página como Markdown limpio. Para una versión de marco de agente del mismo primitivo, consulta el post de integración de LangChain.

Lo que Puedes Construir

La extracción de texto limpio es la base para una amplia gama de sistemas LLM y RAG:

• RAG sobre tu propia documentación. Rastrea un sitio de documentación o base de conocimientos para obtener Markdown limpio, divídelo y incrústalo para que un agente de soporte responda a partir de la documentación actual en lugar de un corte de entrenamiento obsoleto.
• Corpus de ajuste fino y preentrenamiento continuo. Ensambla conjuntos de datos de texto grandes y deduplicados de artículos y referencias públicas, con el material de texto ya despojado en el momento de la recolección.
• Fundamentación de web en vivo para agentes. Renderiza las páginas que un agente necesita en el momento de la consulta y entrégale Markdown limpio, para que la respuesta cite la página tal como se lee hoy.
• Inteligencia competitiva y de mercado. Convierte páginas de productos públicos, entradas de blog y notas de lanzamiento en un índice vectorial buscable que un analista o LLM puede consultar.
• Monitoreo de noticias e investigación. Ingesta páginas de editores y revistas en un horario, normaliza a Markdown e incrusta para búsqueda semántica a través de un cuerpo en movimiento de fuentes.
• Búsqueda semántica interna. Construye una capa de recuperación privada sobre material de referencia público en el que tu equipo confía, mantenida fresca en un horario.

Por qué Scrapeless Scraping Browser

El Navegador Nube de Raspado Sin Residuos es un navegador personalizable y anti-detección diseñado para rastreadores web y agentes de IA. Específicamente para tuberías de texto LLM y RAG, aporta:

• Extracción limpia de Markdown. scrape_markdown renderiza una URL y devuelve el cuerpo legible en Markdown: títulos, párrafos, listas, tablas y enlaces preservados; navegación, scripts, espacios publicitarios y estilos en línea eliminados. Ese es el formato que mejor lee un modelo de incrustación.
• Renderizado de JavaScript del lado de la nube. Chromium completo hidrata la página antes de la extracción, por lo que aplicaciones de una sola página, secciones cargadas de manera perezosa y contenido inyectado después de la solicitud inicial son capturadas en lugar de ser omitidas.
• Proxies residenciales en más de 195 países. Las páginas con restricciones geográficas devuelven el contenido que vería un lector local, y la rotación es automática en cada sesión: la diferencia entre un artículo real y una página bloqueada regionalmente.
• Huellas anti-detección en cada sesión: UA, zona horaria, idioma, resolución de pantalla, WebGL y canvas son aleatorizados por sesión, por lo que fuentes de alto valor permanecen accesibles sin necesidad de ajustar huellas por solicitud.
• Una primitiva, dos superficies. El mismo navegador en la nube se puede acceder como herramienta MCP para tuberías impulsadas por agentes y como sesión de SDK de Python para tuberías impulsadas por scripts, por lo que el mismo paso de extracción se compone en cualquiera de las arquitecturas.

Obtén tu clave API en el plan gratuito en Scrapeless.

Requisitos previos

• Python 3.10 o más reciente.
• Una cuenta de Scrapeless y clave API: regístrate en app.scrapeless.com y copia la clave desde Configuración → Gestión de claves API.
• Una clave API de modelo de incrustación si planeas incrustar (los ejemplos a continuación usan OpenAI; cualquier proveedor de incrustación funciona cambiando una línea).
• Familiaridad básica con pip y venv.

El SDK completo y la referencia de herramientas se encuentran en docs.scrapeless.com.

Instalación

Hay dos formas de acceder al mismo navegador en la nube. Elige la que se adapte a quién impulsa la tubería: un agente o un script.

Opción A — SDK de Python (impulsado por script)

Para un script que posee el ciclo descubrir → extraer → fragmentar → incrustar, instala el SDK de Python de Scrapeless además de las bibliotecas de incrustación y almacenamiento vectorial que piensas usar:

python -m venv .venv
source .venv/bin/activate          # Windows: .venv\Scripts\activate
pip install scrapeless openai chromadb tiktoken

Exporta tu clave API para la shell actual. El SDK lee SCRAPELESS_API_KEY del entorno automáticamente:

export SCRAPELESS_API_KEY="tu_token_api_aqui"
export OPENAI_API_KEY="tu_token_openai_aqui"

Opción B — Servidor MCP (impulsado por agente)

Para un agente de IA que llama a herramientas, ejecuta el servidor MCP de Scrapeless. Expone scrape_markdown, scrape_html, google_search y un conjunto de herramientas de navegador a cualquier cliente compatible con MCP:

npx -y scrapeless-mcp-server

Apunta tu cliente MCP al comando y pasa la clave API como la variable de entorno SCRAPELESS_KEY en la configuración del servidor. El agente puede entonces llamar a scrape_markdown directamente.

La tubería a simple vista

Descubrir URLs            Extraer texto limpio         Fragmentar para RAG            Incrustar + almacenar
┌──────────────┐         ┌──────────────────┐       ┌──────────────┐        ┌──────────────┐
│ google_search│         │ scrape_markdown   │       │ dividir en    │        │ incrustar cada │
│ o sitemap    │  ────►   │ (el navegador nube │ ────► │ ~500–1000-tok │ ────►  │ fragmento, upsert │
│ o lista de    │         │  renderiza + limpia)│     │ fragmentos   │        │ a DB vectorial │
└──────────────┘         └──────────────────┘       └──────────────┘        └──────────────┘

Cuatro etapas, separación limpia. El descubrimiento decide qué páginas entran en el corpus; la extracción decide qué tan limpio está el texto; la fragmentación decide qué tan recuperable es; la incrustación lo hace buscable. Scrapeless posee las dos primeras etapas: aquellas en las que la web viva lucha de vuelta; y las bibliotecas estándar poseen las últimas dos.

Paso 1 — Descubrir las URLs

Un corpus comienza con una lista de URLs. Tres fuentes comunes cubren casi cada caso:

• Una lista de semillas o sitemap que ya tienes: el caso más simple; salta directamente al Paso 2.
• Un rastreo del sitio: comienza desde una raíz de sección y sigue enlaces dentro del dominio hasta una profundidad limitada.
• Descubrimiento por búsqueda: cuando las páginas relevantes no se conocen de antemano, búscalas.

El servidor MCP de Scrapeless envía una herramienta google_search que devuelve resultados orgánicos como filas estructuradas, lo que es una forma limpia de descubrir URLs fuente para un tema. Cada fila lleva posición, título, enlace, fragmento y fuente:

# discover.py — recopilar URLs candidatas de una consulta de búsqueda
# (los argumentos de la herramienta MCP están en camelCase; esto ilustra la forma devuelta)
results = [

{"posición": 1, "título": "Generación Aumentada por Recuperación, explicado",
     "enlace": "https://example.com/guides/rag-explained", "fuente": "example.com"},
    {"posición": 2, "título": "Estrategias de fragmentación para RAG",
     "enlace": "https://example.com/blog/chunking-strategies", "fuente": "example.com"},
    # ...
]

urls = [fila["enlace"] para fila en resultados]

Mantén la etapa de descubrimiento honesta: elimina URLs duplicadas, descarta dominios fuera de tema y limita el conteo antes de gastar presupuesto de representación por página. Un corpus enfocado de 200 URL recupera mejor que uno ruidoso de 2,000 URL.

Paso 2 — Extraer Markdown limpio con scrape_markdown

Esta es la etapa que decide la calidad del corpus. scrape_markdown muestra la URL en el navegador en la nube anti-detección: se ejecuta JavaScript, la página se hidrata, el acceso residencial mantiene el contenido accesible, y devuelve el cuerpo legible como Markdown limpio. Los encabezados permanecen como encabezados, las listas como listas, las tablas como tablas, y todo lo que no sea contenido se elimina.

Impulsado por agente (MCP)

Cuando un agente llama a la herramienta, recibe el Markdown como el resultado de la herramienta. Un detalle es importante para la higiene del corpus: las herramientas MCP sin estado prefijan su carga de texto con Response:\n\n. Elimina ese encabezado antes de que el texto entre en tu corpus, o aterrizará en la parte superior de tu primer fragmento:

# clean_mcp_payload.py — normaliza un resultado de herramienta MCP antes de fragmentar
PREFIX = "Response:\n\n"

def clean_markdown(resultado_herramienta: str) -> str:
    """Elimina el prefijo 'Response:' de la herramienta sin estado de un resultado de scrape_markdown."""
    if resultado_herramienta.startswith(PREFIX):
        resultado_herramienta = resultado_herramienta[len(PREFIX):]
    return resultado_herramienta.strip()

Impulsado por script (SDK de Python)

Cuando un script posee el bucle, crea una sesión de navegador en la nube con el SDK y muestra cada URL. El SDK lee SCRAPELESS_API_KEY del entorno; proxy_country fija el acceso residencial (snake_case en el SDK):

# extract.py — muestra cada URL descubierta a Markdown limpio
from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser

cliente = Scrapeless()  # lee SCRAPELESS_API_KEY
sesión = cliente.browser.create(
    ICreateBrowser(proxy_country="US", session_ttl=240)
)

def fetch_markdown(url: str) -> str:
    """Muestra una URL en el navegador en la nube y devuelve el texto limpio del cuerpo Markdown."""
    # La sesión expone un endpoint CDP en session.browser_ws_endpoint;
    # dirígelo a navegar a `url`, deja que la página se hidrate, luego lee el
    # cuerpo Markdown limpio para el corpus.
    # `render_to_markdown` es tu propio ayudante: impulsa el endpoint CDP a navegar,
    # espera la hidratación, luego convierte el HTML limpio a Markdown. Para un resultado operativo 
    # sin ayudante que escribir, usa la herramienta MCP `scrape_markdown` mostrada
    # arriba, que devuelve Markdown directamente.
    markdown = render_to_markdown(sesión, url)
    return markdown.strip()

documentos = []
for url in urls:
    texto = fetch_markdown(url)
    if len(texto) > 200:                # omitir páginas casi vacías / bloque
        documentos.append({"url": url, "texto": texto})

Un guardia de longitud corta al final vale la pena mantener: una página que devuelve solo unas pocas docenas de caracteres de Markdown suele ser un muro de consentimiento o un contenedor vacío, no un artículo, y no debería contaminar el corpus.

Obtén tu clave API en el plan gratuito: Scrapeless

¿Markdown o HTML?

scrape_markdown y scrape_html muestran el mismo renderizado. La diferencia es lo que regresa y lo que haces con ello:

Para un corpus LLM o RAG, Markdown es la opción predeterminada. Le entrega al modelo de incrustación el contenido y nada más, sobrevive la rotación del DOM mejor que los selectores CSS, y cuesta muchos menos tokens en cada etapa posterior. Usa scrape_html solo cuando necesites ejecutar tus propios selectores contra un diseño específico.

Paso 3 — Fragmentar para RAG

Un modelo de incrustación tiene un tamaño de entrada finito, y la recuperación funciona mejor cuando cada unidad almacenada es un pasaje coherente en lugar de un documento completo. La fragmentación divide el Markdown limpio en ventanas superpuestas. Un valor predeterminado práctico es 500–1000 tokens por fragmento con un 10–15% de superposición — lo suficientemente grande como para contener una idea completa, lo suficientemente pequeña como para mantener la recuperación precisa, con superposición para que una oración dividida a través de un límite aún aparezca completa en al menos un fragmento.

# chunk.py — divide Markdown limpio en fragmentos superpuestos del tamaño de token
import tiktoken

enc = tiktoken.get_encoding("cl100k_base")

def chunk_text(text: str, max_tokens: int = 800, overlap: int = 100):
"""Generar ventanas de tokens superpuestos sobre el Markdown limpiado."""
tokens = enc.encode(text)
step = max_tokens - overlap
for start in range(0, len(tokens), step):
window = tokens[start:start + max_tokens]
if not window:
break
yield enc.decode(window)

chunks = []
for doc in documents:
for i, piece in enumerate(chunk_text(doc["text"])):
chunks.append({
"id": f"{doc['url']}#chunk-{i}",
"url": doc["url"],
"chunk_index": i,
"text": piece,
})

Debido a que la entrada ya es Markdown limpio, el segmentador nunca tiene que lidiar con banners de cookies o bloques `<script>` que dividan un párrafo en dos. Dividir en encabezados de Markdown antes de la ventana de tokens mantiene el contenido relacionado junto incluso mejor: segmentar dentro de una sección, no a través de dos, cuando los documentos fuente tienen una estructura de encabezado clara.

Un registro de segmento único se ve así:

```json
{
  "id": "https://example.com/guides/rag-explained#chunk-0",
  "url": "https://example.com/guides/rag-explained",
  "chunk_index": 0,
  "token_count": 800,
  "text": "## Generación Aumentada por Recuperación\n\nRAG fundamenta un modelo de lenguaje en un corpus externo al recuperar los pasajes más relevantes en el momento de la consulta y pasarlos al modelo como contexto. La calidad de la recuperación depende directamente de cuán limpiamente se extrajo y segmentó el texto fuente ..."
}

Paso 4 — Integrar y persistir en una base de datos vectorial

La etapa final convierte cada segmento en un vector y lo almacena para recuperación. El ejemplo a continuación utiliza una tienda Chroma local y embeddings de OpenAI; la forma es idéntica para pgvector, Pinecone, o cualquier otra base de datos vectorial: cambia el cliente y mantén los registros iguales:

# embed.py — integrar cada segmento y actualizar en una tienda de vectores
import chromadb
from openai import OpenAI

oai = OpenAI()
db = chromadb.PersistentClient(path=".chroma")
collection = db.get_or_create_collection("web_corpus")

def embed(texts: list[str]) -> list[list[float]]:
    resp = oai.embeddings.create(model="text-embedding-3-small", input=texts)
    return [d.embedding for d in resp.data]

batch = chunks[:64]                                   # integrar en lotes
collection.upsert(
    ids=[c["id"] for c in batch],
    documents=[c["text"] for c in batch],
    embeddings=embed([c["text"] for c in batch]),
    metadatas=[{"url": c["url"], "chunk_index": c["chunk_index"]} for c in batch],
)

Los metadatos url y chunk_index viajan con cada vector, por lo que cuando la recuperación muestra un segmento, puedes citar la página de origen y volver a ensamblar segmentos vecinos para un contexto más completo. Esos metadatos también son lo que te permite actualizar por id: refrescar una página reemplaza sus segmentos en su lugar en lugar de duplicarlos.

Lo Que Obtienes de Vuelta

El corpus que aterriza en la tienda de vectores es una lista de segmentos limpios, integrados y vinculados a fuentes. Un registro recuperado se ve así:

{
  "id": "https://example.com/blog/chunking-strategies#chunk-2",
  "document": "### Superposición\n\nUna superposición del 10-15% entre segmentos adyacentes mantiene intacta una oración que se encuentra en un límite en al menos una ventana, lo que incrementa la recuperación en las consultas que apuntan la costura entre dos ideas ...",
  "metadata": {
    "url": "https://example.com/blog/chunking-strategies",
    "chunk_index": 2
  },
  "distance": 0.18
}
// El esquema refleja exactamente lo que el paso 4 actualiza. Los valores de los campos son ejemplos ilustrativos.

Algunas observaciones sinceras sobre qué esperar cuando esto funciona contra la web en vivo:

• La calidad del Markdown sigue la estructura de la página. Las páginas con HTML semántico limpio se convierten en excelente Markdown; las páginas construidas a partir de sopa genérica de <div> se convierten aceptablemente pero pueden fusionar un pie de foto de barra lateral en el cuerpo. Verifica una muestra de las páginas convertidas antes de confiar en un gran corpus.
• El tiempo de hidratación varía según el sitio. La mayoría de las páginas están completamente renderizadas cuando se lee el Markdown, pero algunas hidratan su contenido principal a través de una solicitud retrasada; para esos, permite que la página se asiente un momento antes de leer.
• Desduplicar en dos niveles. Elimina URLs duplicadas al descubrir y cerca de segmentos duplicados antes de integrar (un hash o un umbral de similitud) — artículos sindicados y pies de página de plantilla de otro modo inflan el corpus y sesgan la recuperación.
• Fija la región de salida para contenido geovariable. Los sitios que localizan contenido devuelven texto diferente por región; establece proxy_country en la región cuya versión deseas en el corpus para que el conjunto de datos se mantenga consistente.
• Mantén la regulación de longitud. Una página que devuelve solo unas pocas docenas de caracteres es generalmente un muro de consentimiento o un contenedor vacío, no contenido: filtra eso antes de segmentar.

Conclusión: construye un pipeline de texto limpio que escale.

El formato Descubrir → Extraer → Agrupar → Incrustar se reduce aproximadamente a sesenta líneas de Python. La etapa crucial es la extracción, y scrape_markdown se encarga de ello: el navegador en la nube anti-detección renderiza la página, el acceso residencial la mantiene alcanzable, y lo que regresa es el cuerpo legible en Markdown limpio: el formato que mejor lee un modelo de incrustación. Agrupar e incrustar son entonces trabajos de la biblioteca estándar sobre texto que ya está limpio.

Para la misma primitiva del Navegador de Raspado Sin Scrapeless conectada a un marco de agente con salida tipada y un almacén vectorial, consulta la publicación de integración de LangChain. Para más patrones de extremo a extremo que combinan búsqueda, renderización y extracción en sistemas operativos, consulta la publicación de casos de uso de agentes de IA. El patrón que se sostiene en todos ellos: fija una región, devuelve Markdown no HTML, agrupa con solapamiento y deduplica antes de incrustar.

¿Listo para construir tu pipeline de datos impulsado por IA?

Únete a nuestra comunidad para reclamar un plan gratuito y conectar con desarrolladores que construyen pipelines de datos LLM y RAG en Scrapeless: Discord · Telegram.

Regístrate en Scrapeless para obtener tiempo de ejecución gratuito del Navegador de Raspado y adapta los patrones anteriores a las fuentes, regiones y tamaños de agrupación que tu pipeline necesita. Los planes y límites están en scrapeless.com/en/pricing.

FAQ

P: ¿Es legal raspar texto de sitios web para un corpus LLM o RAG?

Raspar datos públicamente visibles está generalmente permitido en la mayoría de las jurisdicciones, pero las reglas varían según el país y los términos de servicio del sitio. Revisa los términos de servicio del sitio objetivo, respeta robots.txt donde sea aplicable, no recojas datos personales sin una base legal y consulta a un abogado para corpus a escala comercial. Construir un conjunto de datos de entrenamiento o RAG no cambia la obligación subyacente de acceder solo a datos públicos de manera legal.

P: ¿Por qué Markdown en lugar de HTML sin procesar para la entrada LLM?

HTML sin procesar es principalmente marcado - navegación, scripts, espacios publicitarios, estilos en línea - que diluye la señal de contenido, infla el costo de tokens y contamina las incrustaciones. Markdown limpio de scrape_markdown mantiene los encabezados, párrafos, listas, tablas y enlaces sobre los que realmente trata la página y elimina el resto, de modo que el modelo de incrustación lea solo contenido y nada más. Markdown también soporta mejor los cambios de DOM que la extracción por selectores CSS.

P: ¿Qué tamaño de agrupación debería usar para RAG?

Un valor predeterminado práctico es de 500 a 1000 tokens por agrupación con un 10 a 15% de solapamiento. Agrupaciones más pequeñas aumentan la precisión de recuperación, pero pueden dividir una idea; agrupaciones más grandes mantienen más contexto pero diluyen la relevancia. Ajusta al tamaño de entrada de tu modelo de incrustación y a tus consultas: las búsquedas fácticas cortas favorecen agrupaciones más pequeñas, mientras que las preguntas de síntesis favorecen agrupaciones más grandes. Dividir en encabezados de Markdown antes de la ventana de tokens mantiene el contenido relacionado junto.

P: ¿Necesito un proxy?

Sí, para la mayoría de las fuentes públicas que valen la pena recolectar. El acceso residencial es lo que mantiene alcanzables las páginas geo-localizadas y protegidas contra bots, y es lo que hace que una página con mucho JavaScript renderice contenido real en lugar de una página de bloque. El Navegador de Raspado Sin Scrapeless se conecta a través de proxies residenciales en más de 195 países; establece proxy_country para fijar la región cuya versión del contenido deseas.

P: ¿Cómo puedo deduplicar y limpiar el corpus?

Deduplica en dos niveles: elimina las URL duplicadas en el descubrimiento y elimina los fragmentos casi duplicados antes de incrustar utilizando un hash de contenido o un umbral de similitud. Como scrape_markdown ya elimina lo genérico, la limpieza restante es ligera: una guardia de longitud para descartar páginas casi vacías y una división opcional consciente de encabezados suelen ser suficientes.

P: ¿Por qué el resultado de scrape_markdown de MCP comienza con Response:?

Las herramientas sin estado en el servidor MCP de Scrapeless prefijan su carga útil de texto con Response:\n\n. Es un encabezado de capa de transporte, no forma parte del contenido de la página. Elimínalo antes de agrupar: el ayudante de una línea clean_markdown en el Paso 2 se encarga de ello, así que el prefijo no llega a la parte superior de tu primer agrupamiento.

P: ¿Puedo ejecutar esto sin un agente de IA?

Sí. La ruta del SDK de Python en el Paso 2 posee el bucle descubrir → extraer → agrupar → incrustar de principio a fin sin un agente involucrado. El servidor MCP es el camino recomendado cuando un agente decide qué páginas recolectar; el SDK es el camino recomendado cuando un script lo hace.