CrewAI + API SERP: agentes más inteligentes en tiempo real

En este tutorial aprenderás:

Qué es CrewAI y en qué se diferencia de otras bibliotecas de agentes de IA.
Sus mayores limitaciones y cómo superarlas con un flujo de trabajo RAG.
Cómo integrarlo con una API de scraping para proporcionar a los agentes de IA datos SERP para obtener respuestas más precisas.

Sumerjámonos.

¿Qué es CrewAI?

CrewAI es un framework Python de código abierto para orquestar y gestionar agentes autónomos de IA que colaboran para completar tareas complejas. A diferencia de los sistemas de agente único como Browser Use, CrewAI se construye en torno a “tripulaciones”, que son un conjunto de agentes.

En una cuadrilla, cada agente tiene un papel, un objetivo y un conjunto de herramientas definidos. En detalle, puede equipar a los agentes de IA con herramientas personalizadas para tareas especializadas como raspado web, conexión a bases de datos, etc. Este enfoque abre la puerta a la resolución de problemas especializada impulsada por la IA y a una toma de decisiones eficaz.

La arquitectura multiagente de CrewAI favorece tanto la eficiencia como la escalabilidad. Periódicamente se añaden nuevas funciones, como la compatibilidad con modelos Qwen y las llamadas a funciones paralelas, lo que lo convierte en un ecosistema en rápida evolución.

Limitaciones de CrewAI y cómo superarlas con datos web frescos

CrewAI es un marco de trabajo rico en funciones para construir sistemas multiagente. Sin embargo, hereda algunas limitaciones clave de los LLM en los que se basa. Dado que los LLM suelen estar preentrenados en conjuntos de datos estáticos, carecen de conocimiento en tiempo real y no pueden acceder a las últimas noticias o a contenidos web en directo.

Esto puede dar lugar a respuestas obsoletas o, peor aún, a alucinaciones. Estos problemas son especialmente probables si los agentes no están limitados o no se les proporcionan datos actualizados y fiables en una configuración de Recuperación-Generación mejorada.

Para hacer frente a estas limitaciones, debe proporcionar a los agentes (y, por extensión, a sus LLM) datos externos fiables. La Web es la fuente de datos más completa y dinámica disponible, lo que la convierte en un objetivo ideal. Por lo tanto, un enfoque eficaz es permitir que los agentes de CrewAI realicen consultas de búsqueda en directo en plataformas como Google u otros motores de búsqueda.

Esto puede hacerse creando una herramienta CrewAI personalizada que permita a los agentes recuperar páginas web relevantes de las que aprender. Sin embargo, el scraping de las SERP (páginas de resultados de los motores de búsqueda) es un reto técnico debido a la necesidad de renderizar JavaScript, resolver CAPTCHA, rotar IP y las estructuras cambiantes de los sitios.

Gestionar todo esto internamente puede ser más complejo que desarrollar la propia lógica de CrewAI. Una mejor solución es confiar en las mejores API de SERP scraping, como la API SERP de Bright Data. Estos servicios se encargan del trabajo pesado de extraer datos limpios y estructurados de la web.

Al integrar estas API en su flujo de trabajo de CrewAI, sus agentes obtienen acceso a información actualizada y precisa sin la sobrecarga operativa. La misma estrategia puede aplicarse a otros dominios conectando a los agentes a API de raspado específicas del dominio.

Cómo integrar CrewAI con las API de SERP para acceder a los datos en tiempo real

En esta sección guiada, verá cómo dar a su agente de IA construido con CrewAI la capacidad de obtener datos directamente de los motores SERP a través de la API SERP de Bright Data.

Esta integración de RAG permite a sus agentes de CrewAI ofrecer resultados más contextuales y actualizados, con enlaces reales para lecturas adicionales.

Siga los pasos que se indican a continuación para crear un equipo sobrecargado con la integración de la API SERP de Bright Data.

Requisitos previos

Para seguir este tutorial, asegúrate de tener:

Una clave API de Bright Data.
Una clave API para conectarse a un LLM (utilizaremos Gemini en este tutorial).
Python 3.10 o superior instalado localmente.

Para más detalles, consulte la página de instalación de la documentación de CrewAI, que contiene los requisitos previos actualizados.

No se preocupe si aún no dispone de una clave de API de Bright Data, ya que en los próximos pasos se le guiará para crear una. En cuanto a la clave de API de LLM, si no dispone de una, le recomendamos que configure una clave de API de Gemini siguiendo la guía oficial de Google.

Paso 1: Instalar CrewAI

Empieza por instalar CrewAI globalmente ejecutando el siguiente comando en tu terminal:

pip install crewai

Nota: Esto descargará y configurará varios paquetes, por lo que puede tardar un poco.

Si tiene problemas durante la instalación o el uso, consulte la sección de solución de problemas de la documentación oficial.

Una vez instalado, tendrás acceso al comando crewai CLI. Compruébalo ejecutando lo siguiente en tu terminal:

crewai

Deberías ver una salida similar a:

Usage: crewai [OPTIONS] COMMAND [ARGS]...

  Top-level command group for crewai.

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  chat               Start a conversation with the Crew, collecting...
  create             Create a new crew, or flow.
  deploy             Deploy the Crew CLI group.
  flow               Flow related commands.
  install            Install the Crew.
  log-tasks-outputs  Retrieve your latest crew.kickoff() task outputs.
  login              Sign Up/Login to CrewAI+.
  replay             Replay the crew execution from a specific task.
  reset-memories     Reset the crew memories (long, short, entity,...
  run                Run the Crew.
  signup             Sign Up/Login to CrewAI+.
  test               Test the crew and evaluate the results.
  tool               Tool Repository related commands.
  train              Train the crew.
  update             Update the pyproject.toml of the Crew project to use...
  version            Show the installed version of crewai.

¡Genial! Ahora tienes la CrewAI CLI lista para inicializar tu proyecto.

Paso nº 2: Configuración del proyecto

Ejecute el siguiente comando para crear un nuevo proyecto CrewAI llamado serp_agent:

crewai create crew serp_agent

Durante la configuración, se le pedirá que seleccione su proveedor de LLM preferido:

Select a provider to set up:
1. openai
2. anthropic
3. gemini
4. nvidia_nim
5. groq
6. huggingface
7. ollama
8. watson
9. bedrock
10. azure
11. cerebras
12. sambanova
13. other
q. Quit
Enter the number of your choice or 'q' to quit:

En este caso, vamos a seleccionar la opción “3” para Gemini, ya que su integración vía API es gratuita.

A continuación, seleccione el modelo Gemini específico que desea utilizar:

Select a model to use for Gemini:
1. gemini/gemini-1.5-flash
2. gemini/gemini-1.5-pro
3. gemini/gemini-2.0-flash-lite-001
4. gemini/gemini-2.0-flash-001
5. gemini/gemini-2.0-flash-thinking-exp-01-21
6. gemini/gemini-2.5-flash-preview-04-17
7. gemini/gemini-2.5-pro-exp-03-25
8. gemini/gemini-gemma-2-9b-it
9. gemini/gemini-gemma-2-27b-it
10. gemini/gemma-3-1b-it
11. gemini/gemma-3-4b-it
12. gemini/gemma-3-12b-it
13. gemini/gemma-3-27b-it
q. Quit

En este ejemplo, el modelo gemini/gemini-1.5-flash libre es suficiente. Por lo tanto, puede seleccionar la opción “1”.

A continuación, se le pedirá que introduzca su clave API Gemini:

Enter your GEMINI API key from https://ai.dev/apikey (press Enter to skip):

Pégalo y, si todo va como esperas, deberías ver una salida como ésta:

API keys and model saved to .env file
Selected model: gemini/gemini-1.5-flash
  - Created serp_agent.gitignore
  - Created serp_agentpyproject.toml
  - Created serp_agentREADME.md
  - Created serp_agentknowledgeuser_preference.txt
  - Created serp_agentsrcserp_agent__init__.py
  - Created serp_agentsrcserp_agentmain.py
  - Created serp_agentsrcserp_agentcrew.py
  - Created serp_agentsrcserp_agenttoolscustom_tool.py
  - Created serp_agentsrcserp_agenttools__init__.py
  - Created serp_agentsrcserp_agentconfigagents.yaml
  - Created serp_agentsrcserp_agentconfigtasks.yaml
Crew serp_agent created successfully!

Este procedimiento generará la siguiente estructura de proyecto:

serp_agent/
├── .gitignore
├── pyproject.toml
├── README.md
├── .env
├── knowledge/
├── tests/
└── src/
    └── serp_agent/
        ├── __init__.py
        ├── main.py
        ├── crew.py
        ├── tools/
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml
            └── tasks.yaml

Toma:

main.py es el punto de entrada principal de tu proyecto.
crew.py es donde defines la lógica de tu tripulación.
config/agents.yaml define tus agentes de IA.
config/tasks.yaml define las tareas que manejarán tus agentes.
tools/custom_tool.py le permitirá añadir herramientas personalizadas que sus agentes podrán utilizar.
.env almacenan las claves API y otras variables de entorno.

Navega hasta la carpeta del proyecto e instala las dependencias de CrewAI:

cd serp_agent
crewai install

El último comando creará un entorno virtual local .venv carpeta dentro de su directorio de proyecto. Esto te permitirá ejecutar tu CrewAI localmente.

Perfecto. Ahora tienes un proyecto CrewAI completamente inicializado usando la API Gemini. Estás listo para construir y ejecutar tu agente SERP inteligente.

Paso 3: Empezar a utilizar la API SERP

Como ya hemos mencionado, utilizaremos la API SERP de Bright Data para obtener contenido de las páginas de resultados de los motores de búsqueda y enviarlo a nuestros agentes de CrewAI. En concreto, realizaremos búsquedas precisas en Google a partir de los datos introducidos por el usuario y utilizaremos los datos extraídos en tiempo real para mejorar las respuestas del agente.

Para configurar la API SERP, puede consultar la documentación oficial. También puede seguir los pasos que se indican a continuación.

Si aún no lo ha hecho, regístrese para obtener una cuenta en Bright Data. Si no, sólo tiene que iniciar sesión. Una vez conectado, vaya a la sección “Mis zonas” y haga clic en la fila “SERP API”:

Si no ve esa fila en la tabla, significa que aún no ha configurado una zona SERP API. En ese caso, desplácese hacia abajo y haga clic en “Crear zona” en la sección “API SERP”:

En la página del producto SERP API, active el interruptor “Activar” para habilitar el producto:

A continuación, siga la guía oficial para generar su clave API de Bright Data. A continuación, añádala a su archivo .env como se indica a continuación:

BRIGHT_DATA_API_KEY=<YOUR_BRIGHT_DATA_API_KEY>

Sustituya el por el valor real de su clave API de Bright Data.

¡Ya está! Ya puedes utilizar la API SERP de Bright Data en tu integración con CrewAI.

Paso 4: Crear una herramienta de búsqueda CrewAI SERP

Es hora de definir una herramienta de búsqueda SERP que sus agentes puedan utilizar para interactuar con la API SERP de Bright Data y recuperar datos de resultados de búsqueda.

Para ello, abra el archivo custom_tool.py dentro de la carpeta tools/ y sustituya su contenido por lo siguiente:

# src/search_agent/tools/custom_tool.py

import os
import json
from typing import Type
import requests
from pydantic import BaseModel, PrivateAttr
from crewai.tools import BaseTool


class SerpSearchToolInput(BaseModel):
    query: str


class SerpSearchTool(BaseTool):
    _api_key: str = PrivateAttr()

    name: str = "Bright Data SERP Search Tool"
    description: str = """
    Uses Bright Data's SERP API to retrieve real-time Google search results based on the user's query.
    This tool fetches organic search listings to support agent responses with live data.
    """
    args_schema: Type[BaseModel] = SerpSearchToolInput

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # Read the Bright Data API key from the envs
        self._api_key = os.environ.get("BRIGHT_DATA_API_KEY")

        if not self._api_key:
            raise ValueError("Missing Bright Data API key. Please set BRIGHT_DATA_API_KEY in your .env file")

    def _run(self, query: str) -> str:
        url = "https://api.brightdata.com/request"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self._api_key}"
        }
        payload = {
            "zone": "serp", # Replace with the name of your actual Bright Data SERP API zone
            "format": "json",
            "url": f"https://www.google.com/search?q={query}&brd_json=1"
        }

        try:
            response = requests.post(url, json=payload, headers=headers)
            # Raise exceptions in case of errors
            response.raise_for_status()

            # Parse the JSON response
            json_response = response.json()
            response_body = json.loads(json_response.get("body", "{}"))

            if "organic" not in response_body:
                return "The response did not include organic search results."

            # Return the SERP data as a JSON string
            return json.dumps(response_body["organic"], indent=4)

        except requests.exceptions.HTTPError as http_err:
            return f"HTTP error occurred while querying Bright Data SERP API: {http_err}"
        except requests.exceptions.RequestException as req_err:
            return f"Network error occurred while connecting to Bright Data: {req_err}"
        except (json.JSONDecodeError, KeyError) as parse_err:
            return f"Error parsing Bright Data SERP API response: {parse_err}"

Esta herramienta de CrewAI define una función que toma una consulta de usuario y obtiene los resultados SERP de la API SERP de Bright Data a través de requets.

Tenga en cuenta que cuando se utiliza el parámetro de consulta brd_json=1 y el formato se establece en json, la API SERP responde con esta estructura:

{
  "status_code": 200,
  "headers": {
    "content-type": "application/json",
    // omitted for brevity...
  },
  "body": "{"general":{"search_engine":"google","query":"pizza","results_cnt":1980000000, ...}}"
}

En concreto, tras analizar el campo body, que contiene una cadena JSON, obtendrá la siguiente estructura de datos:

{
  "general": {
    "search_engine": "google",
    "query": "pizza",
    "results_cnt": 1980000000,
    "search_time": 0.57,
    "language": "en",
    "mobile": false,
    "basic_view": false,
    "search_type": "text",
    "page_title": "pizza - Google Search",
    "timestamp": "2023-06-30T08:58:41.786Z"
  },
  "input": {
    "original_url": "https://www.google.com/search?q=pizza&brd_json=1",
    "request_id": "hl_1a1be908_i00lwqqxt1"
  },
  "organic": [
    {
      "link": "https://www.pizzahut.com/",
      "display_link": "https://www.pizzahut.com",
      "title": "Pizza Hut | Delivery & Carryout - No One OutPizzas The Hut!",
      "rank": 1,
      "global_rank": 1
    },
    {
      "link": "https://www.dominos.com/en/",
      "display_link": "https://www.dominos.com",
      "title": "Domino's: Pizza Delivery & Carryout, Pasta, Chicken & More",
      "description": "Order pizza, pasta, sandwiches & more online...",
      "rank": 2,
      "global_rank": 3
    },
    // ...additional organic results omitted for brevity
  ]
}

Por lo tanto, usted está interesado principalmente en el campo orgánico. Ese es el campo al que se accede en el código, se analiza en una cadena JSON y, a continuación, la herramienta lo devuelve.

¡Impresionante! Su agente CrewAI ahora puede utilizar esta herramienta para recuperar datos SERP frescos.

Paso nº 5: Definir los agentes

Para llevar a cabo esta tarea, necesitarás dos agentes CrewAI, cada uno con un propósito distinto:

Investigador: Recopila resultados de búsqueda de Google y filtra información útil.
Analista de informes: Recopila los resultados en un resumen estructurado y legible.

Puedes definirlos en tu archivo agents.yml rellenándolo de la siguiente manera:

# src/search_agent/configs/agents.yml

researcher:
  role: >
    Online Research Specialist
  goal: >
    Conduct smart Google searches and collect relevant, trustworthy details from the top results.
  backstory: >
    You have a knack for phrasing search queries that deliver the most accurate and insightful content.
    Your expertise lies in quickly identifying high-quality information from reputable sources.

reporting_analyst:
  role: >
    Strategic Report Creator
  goal: >
    Organize collected data into a clear, informative narrative that’s easy to understand and act on.
  backstory: >
    You excel at digesting raw information and turning it into meaningful analysis. Your work helps
    teams make sense of data by presenting it in a well-structured and strategic format.

Observa cómo esta configuración captura lo que se supone que debe hacer cada agente, ni más ni menos. Sólo define su papel, su objetivo y su historia. Muy bien.

Paso#6: Especificar las tareas para cada agente

Prepárese para definir tareas específicas que delimiten claramente el papel de cada agente dentro del flujo de trabajo. Según la documentación de CrewAI, para obtener resultados precisos, ladefinición de la tarea es más importante que la definición del agente.

Por lo tanto, en tasks.yml tienes que decirle a tus agentes exactamente lo que tienen que hacer, como se indica a continuación:

# src/search_agent/configs/tasks.yml

research_task:
  description: >
    Leverage SerpSearchTool to perform a targeted search based on the user's {query}.
    Build API parameters like:
    - 'query': develop a short, Google-like, keyword-optimized search phrase for search engines.
    From the returned data, identify the most relevant and factual content.

  expected_output: >
    A file containing well-structured raw JSON content with the data from search results.
    Avoid rewriting, summarizing, or modifying any content.

  agent: researcher
  output_file: output/serp_data.json

report_task:
  description: >
    Turn the collected data into a digestible, insight-rich report.
    Address the user's {query} with fact-based findings. Add links for further reading. Do not fabricate or guess any information.

  expected_output: >
    A Markdown report with key takeaways and meaningful insights.
    Keep the content brief and clearly, visually structured.

  agent: reporting_analyst
  context: [research_task]
  output_file: output/report.md

En esta configuración, se definen dos tareas, una para cada agente:

tarea_de_investigación: Indica al investigador cómo utilizar la API SERP de Bright Data a través de la herramienta, incluido cómo construir parámetros de API dinámicamente en función de la consulta.
tarea_informe: Especifica que el resultado final debe ser un informe legible e informativo construido estrictamente a partir de los datos recogidos.

Esta definición tasks.yml es todo lo que sus agentes CrewAI necesitan para recopilar datos SERP y producir un informe basado en resultados de búsqueda reales.

Es hora de integrar tus agentes CrewAI en tu código y dejar que se pongan a trabajar.

Paso 7: Cree su tripulación

Ahora que todos los componentes están en su lugar, conecte todo en el archivo crew. py para crear una tripulación completamente funcional. Específicamente, así es como puedes definir tu crew.py:

# src/search_agent/crew.py

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from .tools.custom_tool import SerpSearchTool
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase
class SerpAgent():
    """SerpAgent crew"""

    agents: List[BaseAgent]
    tasks: List[Task]

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config["researcher"],
            tools=[SerpSearchTool()],
            verbose=True
        )

    @agent
    def reporting_analyst(self) -> Agent:
        return Agent(
            config=self.agents_config["reporting_analyst"],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config["research_task"],
            output_file="output/serp_data.json"
        )

    @task
    def report_task(self) -> Task:
        return Task(
            config=self.tasks_config["report_task"],
            output_file="output/report.md"
        )

    @crew
    def crew(self) -> Crew:
        """Creates the SerpAgent crew"""
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True,
        )

En crew.py, tienes que utilizar los decoradores de CrewAI(@agent, @task, @crew, en este caso) para vincular la lógica de tus archivos YAML y cablear la funcionalidad real.

En este ejemplo:

El agente investigador recibe acceso a SerpSearchTool, lo que le permite realizar consultas reales de búsqueda en Google utilizando la API SERP de Bright Data.
El agente reporting_analyst está configurado para generar el informe final, utilizando la salida del investigador.
Cada tarea corresponde a lo definido en su tasks.yml, y está explícitamente vinculada al archivo de salida apropiado.
El proceso se establece como secuencial, asegurando que el investigador se ejecuta primero y luego pasa sus datos a reporting_analyst.

¡Allá vamos! Su equipo SerpAgent está ahora listo para ejecutar.

Paso 8: Crear el bucle principal

En main.py, activa el equipo pasando la consulta del usuario como entrada:

# src/search_crew/main.py

import os
from serp_agent.crew import SerpAgent

# Create the output/ folder if it doesn"t already exist
os.makedirs("output", exist_ok=True)

def run():
    try:
        # Read the user's input and pass it to the crew
        inputs = {"query": input("nSearch for: ").strip()}

        # Start the SERP agent crew
        result = SerpAgent().crew().kickoff(
            inputs=inputs
        )
        return result
    except Exception as e:
        print(f"An error occurred: {str(e)}")

if __name__ == "__main__":
    run()

¡Misión completada! Tu integración CrewAI + API SERP (usando Gemini como LLM) es ahora completamente funcional. Simplemente ejecuta main.py, introduce una consulta de búsqueda y observa cómo el equipo recopila y analiza los datos SERP para producir un informe.

Paso 9: Ejecute su agente de IA

En la carpeta de tu proyecto, ejecuta tu aplicación CrewAI con el siguiente comando:

crewai run

Ahora, introduce una consulta como

"What are the new AI protocols?"

Este es el tipo de pregunta que a un LLM típico le costaría responder con precisión. La razón es que la mayoría de los últimos protocolos de IA, como CMP, A2A, AGP y ACP, no existían cuando se entrenó el modelo.

Esto es lo que ocurrirá en detalle:

Como puedes notar arriba, CrewAI maneja la solicitud de esta manera:

Se ejecuta el agente de investigación, que:
1. Transforma la entrada del usuario en una consulta estructurada "nuevos protocolos de IA"
2. Envía la consulta a la API SERP de Bright Data a través de SerpSearchTool.
3. Recibe los resultados de la API y los guarda en el archivo output/serp_data.json.
A continuación, se activa el agente reporting_analyst, que:
1. Lee los datos estructurados del archivo serp_data.json.
2. Utiliza esa información reciente para generar un informe contextual en Markdown.
3. Guarda el informe estructurado final en output/report.md.

Si abre report.md con un visor Markdown, verá algo parecido a esto:

El informe final Markdown producido por CrewAI

El informe incluye información contextual pertinente e incluso enlaces que le ayudarán a profundizar.

¡Et voilà! Acabas de implementar un flujo de trabajo RAG en CrewAI impulsado por la integración con una API SERP.

Próximos pasos

La herramienta SERP API de Bright Data integrada en Crew permite a los agentes recibir resultados recientes de los motores de búsqueda. Dadas las URL de esas SERP, podría utilizarlas para llamar a otras API de raspado para extraer contenido en bruto de las páginas enlazadas, ya sea en forma no procesada(para convertir en Markdown y alimentar al agente) o ya analizada en JSON.

Esta idea permite a los agentes descubrir automáticamente algunas fuentes fiables y recuperar de ellas información actualizada. Además, podría integrar una solución como Agent Browser para permitir a los agentes interactuar dinámicamente con cualquier página web en directo.

Estos son sólo algunos ejemplos, pero los posibles escenarios y casos de uso son prácticamente ilimitados.

Conclusión

En esta entrada de blog, aprendió cómo hacer que sus agentes CrewAI sean más conscientes del contexto mediante la integración de una configuración RAG utilizando la API SERP de Bright Data.

Como se ha explicado, ésta es sólo una de las muchas posibilidades que puede explorar conectando sus agentes con API de scraping externas o herramientas de automatización. En concreto, las soluciones de Bright Data pueden servir como potentes bloques de construcción para flujos de trabajo inteligentes de IA.

Mejore su infraestructura de IA con las herramientas de Bright Data:

Agentes autónomos de IA: Busque, acceda e interactúe con cualquier sitio web en tiempo real mediante un potente conjunto de API.
Aplicaciones verticales de IA: cree canalizaciones de datos fiables y personalizadas para extraer datos web de fuentes específicas del sector.
Modelos básicos: Acceda a conjuntos de datos compatibles a escala web para potenciar el preentrenamiento, la evaluación y el ajuste.
IA multimodal: aproveche el mayor repositorio del mundo de imágenes, vídeos y audio optimizados para la IA.
Proveedores de datos: Conéctese con proveedores de confianza para obtener conjuntos de datos de alta calidad preparados para la IA a escala.
Paquetes de datos: Obtenga conjuntos de datos comisariados, listos para usar, estructurados, enriquecidos y anotados.

Para más información, explore nuestro centro de IA.

Cree una cuenta de Bright Data y pruebe todos nuestros productos y servicios para el desarrollo de agentes de IA.

Mejora de los agentes de CrewAI mediante las API de SERP Scraping a través de RAG