Cómo resolver CAPTCHA en Agentes de AutoGen

El marco AutoGen de Microsoft permite agentes de inteligencia artificial conversacionales que colaboran mediante diálogos de múltiples turnos para completar tareas complejas. Cuando los agentes AutoGen realizan operaciones basadas en web - recuperación de datos, envío de formularios o investigación automatizada - los desafíos CAPTCHA interrumpen el flujo de la conversación y bloquean la finalización de la tarea. El paquete capsolver-agent de CapSolver proporciona esquemas de herramientas y un ejecutor asíncrono que se integran directamente en el mecanismo de llamada a funciones de AutoGen, otorgando a sus agentes la capacidad de resolver reCAPTCHA, Cloudflare Turnstile y otros desafíos de verificación durante la conversación.

TL;DR

• Los agentes conversacionales de AutoGen se detienen cuando las tareas web encuentran desafíos de verificación CAPTCHA
• CapSolver se integra a través de la API register_function de AutoGen como una herramienta llamable
• El ejecutor capsolver-agent resuelve de forma asíncrona y devuelve resultados estructurados
• Soporta reCAPTCHA v2/v3 (incluyendo Enterprise) y Cloudflare Turnstile
• Funciona con los patrones de chat de dos agentes y chat grupal de AutoGen

¿Por qué los agentes de AutoGen necesitan resolver CAPTCHA?

La arquitectura multi-agente de AutoGen utiliza patrones conversacionales donde los agentes colaboran mediante mensajes. Una configuración típica incluye un AssistantAgent (la IA) y un UserProxyAgent (que ejecuta código y herramientas). Cuando el asistente determina que una tarea web requiere resolver CAPTCHA, necesita una función registrada para llamar - de lo contrario, el bucle de conversación se detiene sin manera de continuar.

El problema se agrava en los escenarios de chat grupal de AutoGen. Múltiples agentes pueden necesitar acceso web simultáneamente: un agente investigando datos de una empresa, otro verificando información de contacto, un tercero revisando documentos regulatorios. Cada uno puede encontrar CAPTCHAs en sitios diferentes. Sin un mecanismo de resolución, toda la conversación grupal se detiene en el primer muro de verificación.

Según los datos de producción de CapSolver, aproximadamente el 30% de las tareas web de los agentes encuentran desafíos de verificación. Para un flujo de trabajo de AutoGen que ejecuta 10 pasos dependientes de web, eso significa 3 interrupciones potenciales por conversación - cada una requiriendo intervención humana o una herramienta de resolución automatizada.

Lo que necesita antes de comenzar

Instale los paquetes requeridos:

# Motor de CapSolver (dependencia requerida)
pip install git+https://github.com/capsolver-ai/capsolver-core.git

# Herramientas de agente de CapSolver
pip install git+https://github.com/capsolver-ai/capsolver-agent.git

# Marco AutoGen
pip install autogen-agentchat

Establezca variables de entorno:

export CAPSOLVER_API_KEY="su-clave-de-api-de-capsolver"
export OPENAI_API_KEY="su-clave-de-api-de-openai"

Necesita una cuenta de CapSolver con créditos de API cargados.

Paso 1 — Registrar la resolución de CAPTCHA como una función de AutoGen

Qué hacer

AutoGen utiliza register_function para hacer disponibles las herramientas a los agentes. Cree una función para resolver CAPTCHA y regístrela:

import asyncio
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
from capsolver_agent.schema import create_executor

# Crear el ejecutor de CapSolver
executor = create_executor(api_key="SU_CLAVE_DE_API_DE_CAPSOLVER")

def solve_captcha(
    captcha_type: str,
    website_url: str,
    website_key: str,
    page_action: str = "",
    min_score: float = 0.7
) -> str:
    """Resolver un desafío CAPTCHA y devolver el token de verificación.
    
    Args:
        captcha_type: El tipo de CAPTCHA - 'reCaptchaV2', 'reCaptchaV3' o 'cloudflare'
        website_url: La URL completa de la página con el CAPTCHA
        website_key: La clave del sitio (atributo data-sitekey)
        page_action: Nombre de la acción para reCAPTCHA v3 (opcional)
        min_score: Puntuación mínima para reCAPTCHA v3 (predeterminado 0.7)
    
    Returns:
        El token de CAPTCHA resuelto o un mensaje de error
    """
    params = {
        "captcha_type": captcha_type,
        "website_url": website_url,
        "website_key": website_key
    }
    if page_action and captcha_type == "reCaptchaV3":
        params["page_action"] = page_action
        params["min_score"] = min_score
    
    result = asyncio.run(executor.execute("solve_captcha", params))
    
    if result["success"]:
        token = result["solution"]["token"]
        return f"CAPTCHA resuelto correctamente. Token (primeros 80 caracteres): {token[:80]}..."
    return f"Falló la resolución de CAPTCHA: {result['error']}"

Por qué esto importa

El registro de funciones de AutoGen es el método estándar para otorgar capacidades ejecutables a los agentes. El agente asistente ve la descripción de la función, comprende sus parámetros a través del docstring y la llama cuando la conversación requiere resolver CAPTCHA. Esto sigue exactamente el patrón de diseño de AutoGen.

Paso 2 — Configurar el chat de dos agentes de AutoGen

Qué hacer

Cree un par de AssistantAgent y UserProxyAgent con capacidad de resolución de CAPTCHA:

# Configuración de LLM
llm_config = {
    "config_list": [{"model": "gpt-4o", "api_key": "SU_CLAVE_DE_API_DE_OPENAI"}],
    "temperature": 0
}

# Agente asistente (la IA que decide qué hacer)
assistant = AssistantAgent(
    name="web_assistant",
    system_message="""Eres un asistente de investigación web con capacidad de resolver CAPTCHA.
    Cuando una tarea requiera acceder a una página protegida por CAPTCHA, usa la función solve_captcha 
    con los parámetros adecuados:
    - captcha_type: 'reCaptchaV2', 'reCaptchaV3' o 'cloudflare'
    - website_url: la URL completa de la página
    - website_key: la clave del sitio de la página
    
    Después de resolverlo, devuelve el token al usuario para el envío del formulario.""",
    llm_config=llm_config
)

# Agente proxy de usuario (ejecuta funciones en nombre del asistente)
user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=5,
    code_execution_config={"work_dir": "workspace", "use_docker": False}
)

# Registrar la función de resolución de CAPTCHA
from autogen import register_function

register_function(
    solve_captcha,
    caller=assistant,      # El asistente decide cuándo llamar
    executor=user_proxy,   # El agente proxy ejecuta la función
    name="solve_captcha",
    description="Resolver un desafío CAPTCHA (reCAPTCHA v2/v3 o Cloudflare Turnstile) y devolver el token de verificación"
)

Por qué esto importa

El patrón de dos agentes es la arquitectura central de AutoGen. El asistente razona sobre la tarea y decide llamar a solve_captcha cuando sea necesario. El agente proxy ejecuta la llamada a la función y devuelve el resultado al asistente, quien luego continúa la conversación con el token disponible.

Paso 3 — Ejecutar una conversación con resolución de CAPTCHA

Qué hacer

Inicie una conversación que requiera resolver CAPTCHA:

# Iniciar la conversación
user_proxy.initiate_chat(
    assistant,
    message="""Necesito acceder a una página protegida por reCAPTCHA v2.
    URL: https://example.com/data-portal
    Clave del sitio: 6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI
    
    Por favor, resuelva el CAPTCHA y me proporcione el token."""
)

Flujo de conversación:

1. El agente proxy envía el mensaje de tarea
2. El asistente reconoce que se necesita resolver CAPTCHA
3. El asistente llama a solve_captcha con los parámetros
4. El agente proxy ejecuta la función (CapSolver lo resuelve)
5. El resultado regresa al asistente
6. El asistente presenta el token para completar la tarea

Paso 4 — Usar en chat grupal de AutoGen

Qué hacer

Para flujos de trabajo complejos con múltiples agentes, registre la resolución de CAPTCHA en un chat grupal:

from autogen import GroupChat, GroupChatManager

# Agentes especializados
researcher = AssistantAgent(
    name="researcher",
    system_message="Investiga sitios web y recopila datos. Usa solve_captcha cuando encuentre desafíos de verificación.",
    llm_config=llm_config
)

analyst = AssistantAgent(
    name="analyst",
    system_message="Analiza los datos recopilados y produce insights.",
    llm_config=llm_config
)

executor_agent = UserProxyAgent(
    name="executor",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "workspace", "use_docker": False}
)

# Registrar resolución de CAPTCHA para el investigador
register_function(
    solve_captcha,
    caller=researcher,
    executor=executor_agent,
    name="solve_captcha",
    description="Resolver desafíos de CAPTCHA en sitios web"
)

# Crear chat grupal
group_chat = GroupChat(
    agents=[researcher, analyst, executor_agent],
    messages=[],
    max_round=10
)

manager = GroupChatManager(groupchat=group_chat, llm_config=llm_config)

# Iniciar tarea de investigación grupal
executor_agent.initiate_chat(
    manager,
    message="Investigue los datos en https://example.com/reports. Está protegido por reCAPTCHA v2 (clave: 6Le...). Resuelva el CAPTCHA, recopile los datos y luego analícelos."
)

La guía de reCAPTCHA de CapSolver y la documentación de Cloudflare Turnstile proporcionan detalles adicionales sobre los parámetros para cada tipo de CAPTCHA.

Obtenga su código de bonificación: Use el código WEBS en el Panel de CapSolver para obtener un 5% adicional de bonificación en cada recarga. Perfecto para equipos que ejecutan flujos de trabajo multiagente de AutoGen.

Paso 5 — Patrones de producción y manejo de errores

Qué hacer

Agregue lógica de reintentos y verificación de balance para despliegues de producción:

def solve_captcha_with_retry(
    captcha_type: str,
    website_url: str,
    website_key: str,
    max_retries: int = 3
) -> str:
    """Resolver CAPTCHA con reintentos automáticos en caso de fallo."""
    for attempt in range(max_retries):
        params = {
            "captcha_type": captcha_type,
            "website_url": website_url,
            "website_key": website_key
        }
        result = asyncio.run(executor.execute("solve_captcha", params))
        
        if result["success"]:
            return f"Resuelto (intentos {attempt+1}). Token: {result['solution']['token'][:80]}..."
        
        if attempt < max_retries - 1:
            import time
            time.sleep(3)
    
    return f"Fallo tras {max_retries} intentos: {result.get('error', 'Desconocido')}"

def check_captcha_balance() -> str:
    """Verificar el balance de créditos para resolver CAPTCHA."""
    result = asyncio.run(executor.execute("get_balance", {}))
    if result["success"]:
        return f"Balance de CapSolver: ${result['balance']:.2f}"
    return "No se pudo recuperar el balance"

Registre ambas funciones para una capacidad completa:

register_function(solve_captcha_with_retry, caller=assistant, executor=user_proxy,
    name="solve_captcha", description="Resolver CAPTCHA con lógica de reintentos")
register_function(check_captcha_balance, caller=assistant, executor=user_proxy,
    name="check_balance", description="Verificar el balance de créditos para resolver CAPTCHA")

La documentación de scraping web de CapSolver cubre patrones adicionales para recolección de datos de alto volumen aplicables a agentes de investigación de AutoGen. Para automatización basada en navegador, la extensión de CapSolver ayuda a identificar parámetros de CAPTCHA durante el desarrollo.

Conclusión

Integrar la resolución de CAPTCHA en agentes de AutoGen requiere registrar una función de resolución mediante register_function, conectarla al ejecutor de CapSolver y permitir que el agente asistente decida cuándo invocarla durante las conversaciones. CapSolver proporciona la infraestructura de resolución impulsada por IA que elimina los desafíos de verificación en 3-12 segundos, manteniendo las conversaciones de AutoGen sin intervención humana.

Comience con el patrón de dos agentes para tareas simples, luego expanda a chat grupal para flujos de trabajo complejos multiagente. El enfoque de registro de funciones significa que los agentes deciden naturalmente cuándo resolver basándose en el contexto de la conversación - sin necesidad de detección de CAPTCHA codificada.

Preguntas frecuentes

¿Funciona CapSolver con la ejecución asíncrona de AutoGen?

Sí. Aunque register_function de AutoGen utiliza firmas de funciones sincrónicas, puede envolver al ejecutor asíncrono de CapSolver con asyncio.run() dentro de la función registrada. Esto proporciona los beneficios de resolución asíncrona (agrupación de conexiones, solicitudes concurrentes) dentro de la interfaz de llamada a funciones sincrónicas de AutoGen.

¿Pueden múltiples agentes de AutoGen compartir el mismo solucionador de CAPTCHA?

Sí. Registre la misma función de resolución con múltiples agentes llamadores en un chat grupal. Cada agente puede invocar independientemente la resolución de CAPTCHA cuando su tarea específica lo requiera. La API de CapSolver maneja solicitudes concurrentes sin conflictos.

¿Cómo decide AutoGen cuándo llamar a la función de resolución de CAPTCHA?

El agente asistente de AutoGen utiliza la descripción de la función y el contexto de la conversación para decidir. Cuando la tarea menciona acceder a un recurso protegido por CAPTCHA, el asistente reconoce la necesidad y genera una llamada a la función con parámetros adecuados. También puede incluir instrucciones explícitas en el mensaje del sistema.

¿Qué ocurre si la resolución de CAPTCHA falla durante la conversación?

La función devuelve un mensaje de error al agente asistente. El asistente puede intentar nuevamente con diferentes parámetros, pedir aclaración o informar el fallo. El bucle de conversación de AutoGen continúa sin importar - el fallo se maneja como parte del diálogo en lugar de hacer caer el sistema.

¿Cuánto cuesta resolver CAPTCHA por conversación de AutoGen?

Una conversación de AutoGen que encuentre 1-3 CAPTCHAs cuesta aproximadamente $0.002-0.009 en tarifas de resolución. reCAPTCHA v2 cuesta alrededor de $2-3 por 1,000 resoluciones, y Cloudflare Turnstile cuesta $1-2 por 1,000. Para la mayoría de los flujos de trabajo, el costo de resolución de CAPTCHA es despreciable en comparación con los costos de la API de LLM.