CrewAI + Scrapeless: Ejecuta una tripulación de raspado multicámara con un LLM local.

Resumen:

• Este es un verdadero flujo de trabajo multi-agente. Tres agentes de CrewAI obtienen una página en vivo, extraen registros estructurados y validan el resultado a través de un traspaso de tareas secuencial.
• Solo el obtentor tiene acceso web. El Obtén Pagina Web recibe la herramienta scrape_markdown de Scrapeless MCP; el extractor y el validador trabajan únicamente a partir de las salidas de tareas anteriores.
• El LLM se ejecuta localmente. Los tres agentes utilizan qwen2.5:0.5b a través de Ollama, por lo que el flujo de trabajo no requiere una clave de API LLM en la nube.
• La ejecución exitosa no prueba la extracción correcta. crew.kickoff() se completó, pero la salida del validador capturada se contradijo a sí misma y tuvo que ser rechazada.
• La validación en producción debe ser determinista. Analiza la salida del modelo en Python, valida los campos requeridos y compara los valores extraídos con la respuesta original de MCP.
• Gratis para comenzar. Nuevas cuentas de Scrapeless incluyen tiempo de ejecución gratuito de Scraping Browser — regístrate en app.scrapeless.com.

Introducción: Un equipo completado no es todavía un pipeline confiable

Un Agente de CrewAI conectado a una herramienta MCP de Scrapeless ya puede obtener una página en vivo. Un equipo de CrewAI es un reclamo diferente: dos o más agentes con responsabilidades separadas deben entregarse trabajo mutuamente y terminar con crew.kickoff() devolviendo un resultado.

Esta guía construye ese segundo flujo de trabajo.

Crearás un equipo de tres agentes que:

1. Obtiene una página en vivo a través del Servidor MCP de Scrapeless.
2. Extrae registros de cita estructurados del Markdown devuelto.
3. Valida esos registros antes de que salgan del flujo de trabajo.

Los tres agentes se ejecutan en un modelo local de Ollama. No se requiere clave de API de OpenAI, Anthropic u otra clave de LLM en la nube. La única credencial externa es la clave API de Scrapeless utilizada por la herramienta MCP.

La integración se completa con éxito. Sin embargo, la respuesta final capturada es internamente inconsistente. Esa distinción es la lección más importante en este tutorial: un flujo de trabajo de agente completado es evidencia de ejecución, no evidencia de que los datos resultantes sean confiables.

Lo que puedes hacer con este equipo

El flujo de trabajo asigna una responsabilidad a cada agente:

• Obtén Pagina Web: Llama a la herramienta scrape_markdown de Scrapeless MCP contra una URL en vivo y devuelve el contenido de la página.
• Especialista en Extracción de Datos: Lee el Markdown obtenido y lo convierte en un arreglo JSON.
• Validador de QA: Verifica los registros extraídos en busca de campos faltantes y informa el resultado.

CrewAI pasa las salidas de tareas a través de un contexto de tarea explícito. El extractor recibe la salida de la tarea de obtención y el validador recibe la salida de la tarea de extracción.

No se necesita copiar nada manualmente entre los tres agentes.

Esto difiere de conectar un modelo local directamente a una función de obtención y extracción en Python. La guía de raspado web de Ollama cubre ese patrón más simple.

Aquí, CrewAI se encarga de la orquestación:

• Tres agentes
• Tres indicaciones específicas
• Tres límites de token separados
• Un traspaso secuencial gestionado por el marco

¿Por qué usar un equipo en lugar de un solo agente?

Un solo agente con una herramienta de raspado debe decidir qué obtener, cómo interpretar la página, cómo formatear el resultado y si ese resultado es aceptable.

Dividir esas responsabilidades en roles separados te brinda un mayor control sobre el flujo de trabajo.

Cada agente recibe:

• Un objetivo específico
• Una tarea enfocada
• Su propio límite de salida
• Acceso solo a las herramientas que necesita

Esto puede ser especialmente útil con modelos locales más pequeños. En lugar de pedir a un modelo que obtenga, extraiga, formatee y valide simultáneamente, cada turno maneja un trabajo más limitado.

La separación también te da puntos de inspección más claros. En un pipeline de producción, puedes guardar o validar la salida después de cada tarea e identificar si ocurrió un fallo durante la recuperación, extracción o validación.

¿Por qué el Servidor MCP de Scrapeless?

La especificación del Protocolo de Contexto del Modelo define una manera estándar para que un cliente de IA descubra e invoque herramientas expuestas por un servidor.

El Servidor MCP de Scrapeless expone datos web y capacidades de navegador a través de esa interfaz de herramienta. CrewAI no necesita implementar la representación de páginas, el enrutamiento proxy o la infraestructura del navegador directamente. Solo necesita conectarse al servidor y adjuntar la herramienta requerida a un agente.

La visión general del Servidor MCP de Scrapeless explica la familia de herramientas más amplia, que incluye recuperación de páginas, búsqueda y herramientas de control de navegador.

Para este flujo de trabajo, el equipo solo necesita una herramienta:

scrape_markdown

Recupera la página objetivo y devuelve el contenido en un formato que el agente de extracción posterior puede leer.

Puedes consultar la documentación para desarrolladores de Scrapeless para obtener los últimos detalles de conexión del servidor y argumentos de la herramienta.

Requisitos previos

Antes de ejecutar la tripulación, necesitas:

• Python 3.10 o posterior
• CrewAI y Herramientas CrewAI
• Una clave API de Scrapeless
• Ollama instalado y funcionando localmente
• El modelo qwen2.5:0.5b descargado en Ollama

No necesitas OPENAI_API_KEY, ANTHROPIC_API_KEY, ni otra credencial LLM alojada. Cada objeto LLM de CrewAI en este ejemplo apunta al servidor local de Ollama.

Paso 1 — Instalar CrewAI y soporte MCP

El ejemplo verificado utiliza paquetes de CrewAI fijados:

pip install "crewai==1.15.4" "crewai-tools[mcp]==1.15.4"

El extra [mcp] instala las dependencias de cliente MCP necesarias por MCPServerAdapter. El adaptador convierte las definiciones de herramienta MCP en herramientas que los agentes CrewAI pueden llamar.

Paso 2 — Configurar el modelo local de Ollama

Descarga el modelo usado en este ejemplo:

ollama pull qwen2.5:0.5b

Confirma que Ollama puede verlo:

ollama list

Ollama normalmente expone su API local en:

http://localhost:11434

Si Ollama está instalado pero la tripulación no puede conectarse, confirma que el servicio de Ollama está en funcionamiento antes de lanzar el script de Python.

A continuación, configura la clave API de Scrapeless en tu terminal:

export SCRAPELESS_API_KEY="your_api_key_here"

Leer la clave de una variable de entorno la mantiene fuera del archivo fuente de Python.

Paso 3 — Apuntar CrewAI a Ollama

Crea una configuración de LLM separada para cada agente:

from crewai import LLM

fetch_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=180,
    temperature=0,
)

extract_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=100,
    temperature=0,
)

validate_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=70,
    temperature=0,
)

Las tres configuraciones utilizan el mismo modelo, pero sus límites de salida reflejan sus responsabilidades:

• El extractor tiene más espacio para devolver el contenido de la página.
• El extractor necesita suficientes tokens para un corto array JSON.
• El validador solo necesita producir un informe compacto.

Configurar temperature=0 reduce la variación de salida. No garantiza resultados deterministas o correctos, especialmente con un modelo local pequeño.

En la inferencia local solo con CPU, max_tokens también es un control importante en tiempo de ejecución. Los límites más bajos evitan que un agente genere respuestas innecesariamente largas, aunque el tamaño del modelo, el hardware, la longitud del contexto y el número de turnos de los agentes también afectan el tiempo de ejecución.

Paso 4 — Conectar CrewAI al servidor MCP de Scrapeless

Importa MCPServerAdapter y define la conexión remota de MCP:

import os
from crewai_tools import MCPServerAdapter

server_params = {
    "url": "https://api.scrapeless.com/mcp",
    "transport": "streamable-http",
    "headers": {
        "x-api-token": os.environ["SCRAPELESS_API_KEY"]
    },
}

La configuración contiene tres valores importantes:

• url apunta al punto final MCP de Scrapeless.
• transport le dice al cliente que use HTTP transmitible.
• x-api-token autentica la solicitud con tu clave de Scrapeless.

La clave se accede con:

os.environ["SCRAPELESS_API_KEY"]

Python se detendrá inmediatamente si la variable de entorno falta, lo cual es preferible a lanzar silenciosamente una tripulación sin credenciales de herramienta válidas.

Paso 5 — Verificar la herramienta MCP disponible

Antes de construir la tripulación completa, verifica que el adaptador puede descubrir la herramienta solicitada:

with MCPServerAdapter(server_params, "scrape_markdown") as tools:
    print([tool.name for tool in tools])

La ejecución de verificación devolvió:

['scrape_markdown']

Esto confirma que:

• El cliente MCP alcanzó el servidor.
• El servidor aceptó el encabezado de autenticación.
• La herramienta solicitada estaba disponible para CrewAI.

No prueba que cada futura solicitud de página contendrá los datos esperados, ni que un modelo posterior interpretará la respuesta correctamente.

La superficie de herramienta MCP utilizada aquí

MCPServerAdapter puede exponer herramientas del servidor a agentes CrewAI. Pasar "scrape_markdown" limita este flujo de trabajo a la única herramienta que necesita:

with MCPServerAdapter(server_params, "scrape_markdown") as tools:
    ...

Esta superficie de herramienta más limitada es útil para la fiabilidad de los agentes. El extractor no necesita seleccionar entre herramientas no relacionadas de navegador o búsqueda, y los agentes de extracción y validación no reciben herramientas en absoluto.

El límite de permisos es directo:

Solo el capturador puede hacer una solicitud web en vivo.

Cómo Usarlo Realmente: Construir y Ejecutar el Equipo

Definir los Tres Roles de Agente

Crea un Agente para cada etapa:

from crewai import Agent

capturador = Agent(
    role="Capturador de Páginas Web",
    goal=(
        "Capturar la URL exacta dada usando la herramienta scrape_markdown "
        "y devolver su salida cruda."
    ),
    backstory=(
        "Recupera páginas web públicas para compañeros de equipo que no pueden "
        "navegar por la web por sí mismos."
    ),
    tools=tools,
    llm=fetch_llm,
    max_iter=2,
)

extractor = Agent(
    role="Especialista en Extracción de Datos",
    goal=(
        "Convertir el markdown de la página capturada en un registro estructurado "
        "limpio de cada cita y su autor."
    ),
    backstory=(
        "Lee el markdown raspado crudo y extrae exactamente los "
        "campos que necesita una base de datos."
    ),
    llm=extract_llm,
    max_iter=2,
)

validador = Agent(
    role="Validador de Calidad",
    goal="Verificar los registros de citas extraídas para detectar incompletitudes antes de su envío.",
    backstory=(
        "Rechaza registros incompletos o mal formados y reporta "
        "exactamente lo que verificó."
    ),
    llm=validate_llm,
    max_iter=2,
)

Solo capturador recibe tools=tools.

El extractor y el validador deben trabajar a partir del contexto de la tarea. No pueden navegar de forma independiente por la página objetivo ni hacer otra solicitud MCP.

¿Por Qué Establecer max_iter=2?

max_iter limita el número de ciclos de razonamiento y acción que un agente puede realizar durante una tarea.

Un valor de 2 le da al capturador suficiente margen para solicitar una llamada a la herramienta y luego producir una respuesta final. También evita que un modelo pequeño continúe a través de un número excesivo de bucles internos.

El límite es un mecanismo de control, no una garantía de corrección. Si un agente produce JSON mal formado o acepta campos vacíos, alcanzar el límite de iteración con éxito no hace que esa salida sea válida.

Adjuntar la Herramienta MCP Solo al Capturador

El papel del capturador está definido de manera estrecha:

1. Recibir la URL objetivo.
2. Llamar a scrape_markdown.
3. Devolver la salida de la herramienta sin comentarios adicionales.

El extractor nunca recibe la URL en vivo como una instrucción de navegación. Lee el contenido devuelto por el capturador.

El validador nunca recibe la herramienta MCP. Solo lee la salida del extractor.

Esa separación hace que el flujo de datos sea más fácil de entender y auditar.

Enlazar Contexto de Tarea Secuencial

Las tareas de CrewAI pueden hacer referencia a tareas anteriores a través del argumento context:

extract_task = Task(
    ...,
    context=[fetch_task],
)

validate_task = Task(
    ...,
    context=[extract_task],
)

Por lo tanto, la transferencia es:

fetch_task → extract_task → validate_task

El extractor recibe la respuesta final de la tarea de captura. El validador recibe la respuesta final de la tarea de extracción.

No se requiere un paso manual de cadenas.

Ejecutar el Equipo Con crew.kickoff()

El siguiente es el script completo:

import os

from crewai import Agent, Crew, LLM, Process, Task
from crewai_tools import MCPServerAdapter


URL_OBJETIVO = "https://quotes.toscrape.com/tag/obvious/"

parametros_servidor = {
    "url": "https://api.scrapeless.com/mcp",
    "transport": "streamable-http",
    "headers": {
        "x-api-token": os.environ["SCRAPELESS_API_KEY"]
    },
}

fetch_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=180,
    temperature=0,
)

extract_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=100,
    temperature=0,
)

validate_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=70,
    temperature=0,
)

with MCPServerAdapter(parametros_servidor, "scrape_markdown") as tools:
    capturador = Agent(
        role="Capturador de Páginas Web",
        goal=(
            f"Capturar la URL exacta {URL_OBJETIVO} usando la "
            "herramienta scrape_markdown y devolver su salida cruda."
        ),
        backstory=(
            "Recupera páginas web públicas para compañeros de equipo que "
            "no pueden navegar por la web por sí mismos."
        ),
        tools=tools,
        llm=fetch_llm,
        max_iter=2,
    )

    extractor = Agent(
        role="Especialista en Extracción de Datos",
        goal=(
            "Convertir el markdown de la página capturada en un registro estructurado "
            "limpio de cada cita y su autor."
        ),
        backstory=(
            "Lee el markdown raspado crudo y extrae exactamente "
            "los campos que necesita una base de datos."
        ),
        llm=extract_llm,
        max_iter=2,
    )

    validador = Agent(
        role="Validador de Calidad",
        goal=(
            "Verificar los registros de citas extraídas para detectar incompletitudes "
            "antes de su envío."
        ),
        backstory=(
            "Rechaza registros incompletos o mal formados y "

"informa exactamente lo que revisó."
),
llm=validate_llm,
max_iter=2,
)

fetch_task = Task(
    description=(
        f"Llama a la herramienta scrape_markdown con url='{TARGET_URL}'. "
        "Devuelve la salida de la herramienta exactamente como tu respuesta final, "
        "sin comentarios antes o después de ella."
    ),
    expected_output=(
        "El markdown bruto devuelto por la herramienta scrape_markdown."
    ),
    agent=fetcher,
)

extract_task = Task(
    description=(
        "Se te da el markdown bruto de una página de citas como "
        "contexto. Encuentra cada cita en la página. Para cada una, "
        'devuelve un objeto JSON con las claves "text" (la cita) '
        'y "author" (la persona nombrada después de "por"). Devuelve '
        "SOLO un arreglo JSON de estos objetos, nada más."
    ),
    expected_output=(
        'Un arreglo JSON como [{"text": "...", "author": "..."}] '
        "con una entrada por cada cita encontrada."
    ),
    agent=extractor,
    context=[fetch_task],
)

validate_task = Task(
    description=(
        "Se te da un arreglo JSON de registros de citas como contexto. "
        "Verifica que el arreglo tenga al menos una entrada y que "
        "cada entrada tenga un campo de texto y autor no vacío. "
        "Informa el conteo total de registros, la lista de autores, y "
        "una declaración de completitud."
    ),
    expected_output=(
        "Un breve informe: conteo de registros, lista de autores, "
        "declaración de completitud."
    ),
    agent=validator,
    context=[extract_task],
)

crew = Crew(
    agents=[fetcher, extractor, validator],
    tasks=[fetch_task, extract_task, validate_task],
    process=Process.sequential,
)

result = crew.kickoff()

print(result)

El script llama a `crew.kickoff()` dentro del contexto del adaptador MCP. Esto mantiene la conexión remota de la herramienta disponible mientras el recuperador realiza su tarea.

Después de que las tres tareas finalizan, el script imprime el `CrewOutput` final.

## Lo que Obtienes de Regreso

La ejecución de verificación produjo evidencia en tres capas diferentes:

| Capa | Evidencia capturada | Conclusión soportada |
|---|---|---|
| Conexión MCP | `['scrape_markdown']` | CrewAI descubrió la herramienta MCP solicitada |
| Ejecución del Crew | `crew.kickoff()` retornó sin levantar excepciones | El flujo de trabajo secuencial llegó a su tarea final |
| Calidad de los datos | La respuesta final se contradijo a sí misma | El registro resultante debe ser rechazado |

La salida final del validador fue:

```text
0  ["", "", ""] Completo. El arreglo JSON contiene una entrada y todos los campos están no vacíos. Por lo tanto, cumple con los criterios de completitud.

Esta salida es internamente inconsistente.

Informa:

• Un conteo de 0
• Tres cadenas vacías
• Una entrada supuestamente completa
• Una declaración de que todos los campos están no vacíos

Esas afirmaciones no pueden ser todas verdaderas al mismo tiempo.

El proceso se completó, pero los datos no pasaron una verificación de calidad significativa.

Por qué la Salida Final Falló la Validación

Lo que Demostró el Saludo MCP

El saludo MCP devolvió:

['scrape_markdown']

Esto prueba que CrewAI se conectó al servidor MCP de Scrapeless y descubrió la herramienta solicitada.

Por lo tanto, el recuperador de páginas web tenía una herramienta remota real disponible durante la ejecución.

Lo que crew.kickoff() Probó

crew.kickoff() devolvió un CrewOutput sin levantar una excepción.

Esto prueba que:

• El equipo se construyó con éxito.
• Las tres tareas fueron aceptadas.
• La orquestación secuencial alcanzó la tarea del validador.
• CrewAI devolvió un resultado final.

No prueba que el contenido recuperado sobrevivió con precisión cada traspaso del modelo.

Lo que la Respuesta Final No Probó

La página objetivo contiene una cita bajo la etiqueta obvio:

“Un día sin sol es como, ya sabes, noche.”
— Steve Martin

La respuesta final capturada no preservó esos valores.

Dado que el script imprime solo la salida final del equipo, no es posible atribuir el fallo a una etapa específica. Los valores vacíos podrían haber aparecido cuando:

• El recuperador resumió o alteró la respuesta del MCP.
• El extractor convirtió el Markdown en JSON.
• El validador interpretó la salida del extractor.
• Más de una etapa degradó los datos.

La evidencia disponible solo apoya una conclusión más estrecha: el equipo llegó a su tarea final, pero el validador aceptó un resultado que se contradijo a sí mismo.

Modelos Locales Pequeños en Equipos que Llaman Herramientas: El Resultado Honesto

El modelo probado contiene aproximadamente 494 millones de parámetros. Era lo suficientemente pequeño como para ejecutarse localmente y llevó el flujo de trabajo de CrewAI a su finalización.

La ejecución completa salió con código 0 después de 542 segundos en el host probado.

Ese tiempo no es un punto de referencia general de CrewAI o Ollama. Refleja una máquina, un modelo, una página, los prompts seleccionados y el número de turnos de agentes en este flujo de trabajo particular.
El resultado de la integración sigue siendo útil:

• CrewAI creó tres agentes.
• El fetcher recibió una herramienta MCP de Scrapeless en vivo.
• El contexto de la tarea conectó las tres etapas.
• crew.kickoff() se completó.
• No se utilizó una clave de LLM en la nube.

Sin embargo, la ejecución no admite la confianza en los campos resultantes. La salida final combinó un conteo cero, valores vacíos y una declaración de éxito.

Un modelo de menos de 1B puede ser útil para probar la orquestación, pero esta ejecución muestra por qué no debe ser tratado automáticamente como un extractor de datos estructurados confiable.

Agregar Validación Determinista Después del Equipo

La validación en lenguaje natural sigue siendo salida del modelo. Un agente validador puede malinterpretar datos mal formados, pasar por alto valores vacíos o generar una conclusión que contradiga su propio informe.

La validación en producción debe, por lo tanto, realizarse en código ordinario después del flujo de trabajo del modelo.

Analizar la Salida del Extractor

Utiliza json.loads para analizar la respuesta del extractor.

Rechaza el resultado si:

• No es un JSON válido.
• El valor de nivel superior no es un arreglo.
• La respuesta incluye prosa alrededor del JSON.
• El arreglo está inesperadamente vacío.

Validar los Campos Requeridos

Para cada registro, verifica que:

• text exista.
• author exista.
• Ambos valores sean cadenas.
• Ambos valores permanezcan no vacíos después de recortar espacios en blanco.
• Ningún valor sea un marcador de posición obvio.

No permitas que una declaración en lenguaje natural como "todos los campos están completos" anule una verificación programática fallida.

Rechazar Cuentas Contradictorias

Si el validador informa un conteo, comparalo con la longitud real del arreglo JSON.

Un informe que reclame una entrada completa mientras también informa un conteo de cero debería fallar de inmediato.

Comparar Valores Extraídos con la Fuente

Conserva el Markdown original devuelto por scrape_markdown.

Para campos copiados como citas y nombres de autores, confirma que los valores extraídos aparecen en la respuesta de la fuente. Esto ayuda a detectar contenido alucinado, truncado o sustituido.

Preservar Salidas de Tareas Intermedias

El ejemplo solo imprime la salida final del equipo. Para la depuración y el monitoreo en producción, preserva la salida de cada tarea.

Eso te da tres artefactos separados:

1. Markdown crudo obtenido
2. JSON extraído
3. Informe de validación

Con esas salidas disponibles, puedes identificar la etapa exacta donde se perdió el dato en lugar de inferir a partir de la respuesta final.

Aumentar la Capacidad del Modelo Cuando Sea Necesario

Una validación más fuerte puede rechazar resultados malos, pero no puede restaurar texto fuente que un modelo no pudo preservar.

Si un modelo pequeño pierde datos repetidamente durante la extracción o validación, utiliza un modelo local más grande o un modelo alojado más capaz. No debilites las verificaciones simplemente para que la canalización aparente ser exitosa.

Conclusión

Un equipo de CrewAI que funciona en un modelo local de Ollama puede conectarse al Servidor MCP de Scrapeless, llamar a una herramienta de scraping en vivo, pasar datos a través de tres agentes y completar crew.kickoff() sin una clave de LLM en la nube.

Ese es el resultado de la integración.

La salida final capturada seguía siendo incorrecta como para ser rechazada: informó un conteo cero y valores vacíos mientras afirmaba simultáneamente que los datos estaban completos.

Trata la finalización del flujo de trabajo y la corrección de datos como condiciones separadas. Preserva salidas intermedias, valida registros estructurados en Python, compara valores extraídos con la respuesta de MCP y falla la canalización siempre que estas verificaciones disientan de la conclusión del modelo.

¿Listo para Construir un Equipo que Llame Herramientas?

Crea una cuenta gratuita de Scrapeless para obtener tu clave API y conectar CrewAI a una herramienta de datos web en vivo.

Una vez que entiendas el número de páginas y llamadas de agentes que requiere tu flujo de trabajo, revisa los planes de precios de Scrapeless.

Para preguntas de implementación y soporte comunitario:

• Únete al Discord de Scrapeless
• Únete a la comunidad de Telegram de Scrapeless

Preguntas Frecuentes

P: ¿Necesita un equipo de CrewAI una clave de LLM en la nube para funcionar?

No. Establecer model="ollama/qwen2.5:0.5b" y base_url="http://localhost:11434" apunta a cada agente al servidor local de Ollama. El equipo no necesita una clave de LLM de OpenAI, Anthropic u otra LLM alojada.

Este flujo de trabajo aún necesita una clave API de Scrapeless porque el fetcher llama al Servidor MCP de Scrapeless remoto.

P: ¿Cómo pasa CrewAI la salida de un agente al siguiente?

Cada Task río abajo recibe una lista de context que contiene una tarea anterior.

Por ejemplo:

extract_task = Task(
    ...,
    context=[fetch_task],
)

CrewAI incluye la respuesta final de la tarea de fetcher en el contexto del extractor. El mismo mecanismo pasa el resultado de la extracción al validador.

P: ¿Por qué solo el fetcher recibe la herramienta MCP?
El recuperador es el único agente responsable de recuperar el contenido de la página en vivo. El extractor y el validador deben operar sobre las salidas de tareas existentes.

Limitar el acceso a las herramientas reduce elecciones innecesarias y facilita la auditoría del flujo de trabajo.

P: ¿Qué controla max_iter=2?

max_iter limita cuántos ciclos de razonamiento y acción un agente puede realizar durante una tarea.

Un valor de 2 le da al recuperador espacio para una llamada a la herramienta y una respuesta final, evitando un bucle sin fin. Limita la ejecución, pero no garantiza que la respuesta final del agente sea correcta.

P: ¿Extrajo el pequeño modelo local la cita correcta?

No. El equipo completó, pero la salida del validador final comenzó con:

0  ["", "", ""]

Luego afirmó que existía una entrada completa y que todos los campos no estaban vacíos. Debido a que esas declaraciones se contradicen, el resultado debe ser rechazado.

P: ¿Por qué usar validación determinista si el equipo ya tiene un agente de control de calidad?

Un agente de control de calidad sigue siendo un modelo de lenguaje grande (LLM). Puede pasar por alto campos faltantes o generar una conclusión que entre en conflicto con los datos que se le pidió inspeccionar.

Las comprobaciones deterministas en Python proporcionan una decisión independiente de pasar/fallar basada en la sintaxis JSON, la longitud del arreglo, los campos requeridos y la coincidencia de la fuente.

P: ¿Cuán lenta fue la ejecución local de Ollama?

La ejecución completa de verificación tomó 542 segundos en el host probado. Esa medida se aplica solo al hardware específico, modelo, página, indicaciones y configuración de agente utilizadas en la prueba.

La inferencia local de la CPU puede tomar minutos cuando están involucrados varios turnos de agentes.

P: ¿Qué se debe registrar en un equipo de producción?

Preserve al menos:

• La respuesta de la herramienta MCP
• Cada salida intermedia de la tarea
• Los datos estructurados analizados
• Errores de validación determinista
• El resultado final del equipo
• Tiempos de ejecución para cada etapa

Esto permite localizar la etapa que alteró o eliminó los datos de origen.

P: ¿Qué debo verificar antes de raspar un sitio web en vivo?

Revise los términos del sitio web y las directrices de /robots.txt, que siguen el Protocolo de Exclusión de Robots.

Mantenga la lista de objetivos limitada, use páginas públicas y evite dar a un agente autónomo una instrucción de rastreo indefinida.