Construyamos una herramienta gratuita de raspado web que combine servidores proxy e inteligencia artificial para el análisis de datos

Si bien algunos sitios web son fáciles de rastrear con solo Selenium, Puppeteer y similares, otros sitios web que implementan medidas de seguridad avanzadas, como CAPTCHA y prohibiciones de IP, pueden resultar difíciles. Para superar estos desafíos y garantizar que puede rastrear el 99 % de los sitios web de forma gratuita con Scraper, lo desarrollará en este artículo e integrará un herramienta proxy en su código que ayudará a eludir estas medidas de seguridad.

Sin embargo, la recopilación de datos es solo un paso; lo que haga con ellos es igualmente importante, si no más. A menudo, esto requiere una minuciosa selección manual de grandes volúmenes de información. Pero ¿qué sucedería si pudiera automatizar este proceso? Al aprovechar un modelo de lenguaje (LLM), no solo puede recopilar datos, sino también consultarlos para extraer información significativa, lo que le permitirá ahorrar tiempo y esfuerzo.

En esta guía, aprenderá a combinar el web scraping con la IA para crear una herramienta poderosa para recopilar y analizar datos a gran escala de forma gratuita. ¡Vamos a profundizar!

Prerrequisitos

Antes de comenzar, asegúrese de tener lo siguiente:

1. Conocimientos básicos de Python, ya que este proyecto implica escribir y comprender código Python.
2. Instale Python (3.7 o posterior) en su sistema. Puede descargarlo desde python.org .

Instalación y configuración

Para continuar con este tutorial, complete los siguientes pasos:

Siga estos pasos para configurar su entorno y prepararse para construir el raspador impulsado por IA.

1. Crea un entorno virtual

En primer lugar, configure un entorno virtual para administrar las dependencias de su proyecto. Esto garantizará que tenga un espacio aislado para todos los paquetes necesarios.

1. Crear un nuevo directorio de proyecto:

   Abra su terminal (o Símbolo del sistema/PowerShell en Windows) y cree un nuevo directorio para su proyecto:

    mkdir ai-website-scraper cd ai-website-scraper

   
   

2. Crear el entorno virtual:

Ejecute el siguiente comando para crear el entorno virtual:

• En Windows:

   python -m venv venv

• En macOS/Linux:

   python3 -m venv venv

Esto crea una carpeta venv que almacenará el entorno virtual.

2. Activar el entorno virtual

Activa el entorno virtual para comenzar a trabajar dentro de él:

• En Windows:

   .\venv\Scripts\activate

• En macOS/Linux:

   source venv/bin/activate

El indicador de tu terminal cambiará para mostrar ( venv ), lo que confirma que ahora estás dentro del entorno virtual.

3. Instalar las dependencias necesarias

Ahora, instala las bibliotecas que necesita tu proyecto. Crea un archivo requirements.txt en el directorio de tu proyecto y agrega las siguientes dependencias:

 streamlit selenium Beautifulsoup4 langchain langchain-ollama lxml html5lib

Estos paquetes son esenciales para el raspado, el procesamiento de datos y la creación de la interfaz de usuario:

• streamlit : se utiliza para crear la interfaz de usuario interactiva.

• Selenium : para extraer contenido del sitio web.

• beautifulsoup4 : Para analizar y limpiar el HTML.

• langchain y langchain-ollama : esto es para integrar con Ollama LLM y procesar texto.

• lxml y html5lib : para análisis HTML avanzado.

  
  

Instale las dependencias ejecutando el siguiente comando:

(Asegúrese de estar en la carpeta donde se encuentra el archivo antes de ejecutar el comando).

 pip install -r requirements.txt

Construyendo la interfaz de usuario con Streamlit

Iluminado por el sol facilita la creación de una interfaz de usuario (IU) interactiva para aplicaciones Python. En esta sección, creará una interfaz sencilla y fácil de usar en la que los usuarios pueden ingresar una URL y mostrar los datos extraídos.

1. Configurar el script Streamlit

Cree un archivo llamado ui.py en el directorio de su proyecto. Este script definirá la interfaz de usuario de su scraper. Use el código a continuación para estructurar su aplicación:

 import streamlit as st import pathlib from main import scrape_website # function to load css from the assets folder def load_css(file_path): with open(file_path) as f: st.html(f"<style>{f.read()}</style>") # Load the external CSS css_path = pathlib.Path("assets/style.css") if css_path.exists(): load_css(css_path) st.title("AI Scraper") st.markdown( "Enter a website URL to scrape, clean the text content, and display the result in smaller chunks." ) url = st.text_input(label= "", placeholder="Enter the URL of the website you want to scrape") if st.button("Scrape", key="scrape_button"): st.write("scraping the website...") result = scrape_website(url) st.write("Scraping complete.") st.write(result)

• Las funciones st.title y st.markdown configuran el título de la aplicación y proporcionan instrucciones a los usuarios.
• El componente st.text_input permite a los usuarios ingresar la URL del sitio web que desean rastrear.
• Al hacer clic en el botón "Raspar", se activa la lógica de raspado y se muestran mensajes de progreso mediante st.info .

Puede obtener más información sobre los componentes Streamlit en su documentación .

2. Agregar estilos personalizados

Para darle estilo a su aplicación, cree una carpeta de recursos en el directorio de su proyecto y agregue un archivo style.css. Personalice la interfaz de Streamlit con CSS:

 .stAppViewContainer { background-image: url("https://images.unsplash.com/photo-1732979887702-40baea1c1ff6?q=80&w=2832&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D"); background-size: cover; color: black; } .stAppHeader { background-color: rgba(0, 0, 0, 0); } .st-ae { background-color: rgba(233, 235, 234, 0.895); } .st-emotion-cache-ysk9xe { color: black; } .st.info, .stAlert { background-color: black; } .st-key-scrape_button button { display: inline-block; padding: 10px 20px; font-size: 16px; color: #fff; background-color: #007bff; border: none; border-radius: 5px; cursor: pointer; animation: pulse 2s infinite; } .st-key-scrape_button button:hover { background-color: #0056b3; color: #fff; }

3. Ejecute la aplicación Streamlit

En el directorio de su proyecto, ejecute el siguiente comando:

 streamlit run ui.py

Esto iniciará un servidor local y debería ver una URL en la terminal, generalmente http://localhost:8501 . Abra esta URL en su navegador para interactuar con la aplicación web.

Rastreo de sitios web con Selenium

A continuación, escribe el código para extraer el contenido HTML de cualquier página web mediante Selenium. Sin embargo, para que el código funcione, necesitas un Chrome WebDriver.

Instalar ChromeDriver para Selenium

Selenium requiere un WebDriver para interactuar con las páginas web. A continuación, se explica cómo configurarlo:

1. Descargar ChromeDriver:
   Visita esto Sitio web de ChromeDriver y descargue la versión que coincida con su navegador Google Chrome.
2. Agregar ChromeDriver a PATH

Después de descargar ChromeDriver, extraiga el archivo y copie el nombre del archivo de la aplicación “ chromedriver ” y péguelo en la carpeta de su proyecto.

Una vez hecho esto, cree un nuevo archivo llamado main.py e implemente el código a continuación:

 from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.chrome.service import Service from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC # Function to scrape HTML from a website def scrape_website(website_url): # Path to WebDriver webdriver_path = "./chromedriver" # Replace with your WebDriver path service = Service(webdriver_path) driver = webdriver.Chrome(service=service) try: # Open the website driver.get(website_url) # Wait for the page to fully load WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body"))) # Extract the HTML source html_content = driver.page_source return html_content finally: # Ensure the browser is closed after scraping driver.quit()

Guarde y ejecute el código; debería obtener todo el HTML de la página que extrajo y mostrarlo en su aplicación Streamlit de la siguiente manera:

Cómo usar un proveedor de proxy para evitar sitios web con Captcha y prohibiciones de IP

Si bien ahora puede recuperar el HTML de un sitio web, es posible que el código anterior no funcione en sitios con mecanismos avanzados contra el scraping, como desafíos CAPTCHA o prohibiciones de IP. Por ejemplo, el scraping de un sitio como Indeed o Amazon con Selenium puede provocar que una página CAPTCHA bloquee el acceso. Esto sucede porque el sitio web detecta que un bot está intentando acceder a su contenido. Si este comportamiento persiste, el sitio puede eventualmente bloquear su dirección IP, impidiendo el acceso futuro.

Para solucionar esto, integre Navegador de extracción de datos de Bright Data en su script. El navegador de scraping es una herramienta robusta que aprovecha múltiples redes proxy, incluidas las IP residenciales, para eludir las defensas anti-scraping. Se encarga de desbloquear páginas mediante la gestión de encabezados personalizados, la identificación del navegador, la resolución de CAPTCHA y más. Esto garantiza que sus esfuerzos de scraping permanezcan sin ser detectados mientras accede al contenido sin problemas.

Configuración gratuita del navegador de scraping de Bright Data

1. Registrarse — ir a Página de inicio de Bright Data y haga clic en “ Iniciar prueba gratuita ”. Si ya tiene una cuenta en Bright Data, puede iniciar sesión.

2. Después de iniciar sesión, haga clic en “ Obtener productos proxy ”.

   

   
   

3. Haga clic en el botón “ Agregar ” y seleccione “ Scraping Browser ”.

   

   
   

4. A continuación, accederá a la página “ Agregar zona ”, donde deberá elegir un nombre para la nueva zona proxy del navegador para el rastreo de datos. Después, haga clic en “ Agregar ”.

   

   
   

5. Después de esto, se crearán las credenciales de tu zona proxy. Necesitarás estos detalles en tu script para evitar cualquier mecanismo anti-scraping utilizado en cualquier sitio web.

   

   
   

También puede consultar la documentación para desarrolladores de Bright Data para obtener más detalles sobre el navegador de raspado.

En el archivo main.py , cambia el código por este. Notarás que este código es más claro y más corto que el código anterior.

 from selenium.webdriver import Remote, ChromeOptions from selenium.webdriver.chromium.remote_connection import ChromiumRemoteConnection from selenium.webdriver.common.by import By from bs4 import BeautifulSoup AUTH = '<username>:<passord>' SBR_WEBDRIVER = f'https://{AUTH}@brd.superproxy.io:9515' # Function to scrape HTML from a website def scrape_website(website_url): print("Connecting to Scraping Browser...") sbr_connection = ChromiumRemoteConnection(SBR_WEBDRIVER, "goog", "chrome") with Remote(sbr_connection, options=ChromeOptions()) as driver: driver.get(website_url) print("Waiting captcha to solve...") solve_res = driver.execute( "executeCdpCommand", { "cmd": "Captcha.waitForSolve", "params": {"detectTimeout": 10000}, }, ) print("Captcha solve status:", solve_res["value"]["status"]) print("Navigated! Scraping page content...") html = driver.page_source return html

Reemplace <nombre de usuario> y <contraseña> con el nombre de usuario y la contraseña de su navegador de raspado.

Limpieza del contenido del Dom

Después de extraer el contenido HTML de un sitio web, este suele estar repleto de elementos innecesarios, como JavaScript, estilos CSS o etiquetas no deseadas que no contribuyen a la información principal que se está extrayendo. Para que los datos estén más estructurados y sean útiles para su posterior procesamiento, es necesario limpiar el contenido DOM eliminando los elementos irrelevantes y organizando el texto.

En esta sección se explica cómo limpiar el contenido HTML, extraer texto significativo y dividirlo en fragmentos más pequeños para su posterior procesamiento. El proceso de limpieza es esencial para preparar los datos para tareas como el procesamiento del lenguaje natural o el análisis de contenido.

Tutorial de código para limpiar el contenido del DOM

Aquí está el código que se agregará a main.py para manejar la limpieza del contenido del DOM:

 from bs4 import BeautifulSoup # Extract the body content from the HTML def extract_body_content(html_content): soup = BeautifulSoup(html_content, "html.parser") body_content = soup.body if body_content: return str(body_content) return "" # Clean the body content by removing scripts, styles, and other unwanted elements def clean_body_content(body_content): soup = BeautifulSoup(body_content, "html.parser") # Remove <script> and <style> tags for script_or_style in soup(["script", "style"]): script_or_style.extract() # Extract cleaned text with each line separated by a newline cleaned_content = soup.get_text(separator="\n") cleaned_content = "\n".join( line.strip() for line in cleaned_content.splitlines() if line.strip() ) return cleaned_content # Split the cleaned content into smaller chunks for processing def split_dom_content(dom_content, max_length=5000): return [ dom_content[i : i + max_length] for i in range(0, len(dom_content), max_length) ]

Qué hace el Código

1. Extrayendo el contenido del cuerpo:
   • La función extract_body_content utiliza BeautifulSoup para analizar el HTML y extraer el contenido de la etiqueta <body> .
   • Si existe una etiqueta <body> , la función la devuelve como una cadena. De lo contrario, devuelve una cadena vacía.
2. Limpieza del contenido:
   • La función clean_body_content procesa el contenido extraído para eliminar elementos innecesarios:
     • Se eliminan las etiquetas <script> y <style> para eliminar JavaScript y CSS.
     • La función recupera el texto sin formato del contenido limpio.
     • Formatea el texto eliminando líneas vacías y espacios extraños.
3. Dividiendo el contenido:
   • La función split_dom_content toma el contenido limpio y lo divide en fragmentos más pequeños con una longitud máxima predeterminada de 5000 caracteres.
   • Esto es útil para procesar grandes cantidades de texto en partes manejables, especialmente al pasar datos a modelos con límites de tamaño de entrada o de token.

Guarde los cambios y pruebe la aplicación. Debería obtener un resultado como este después de extraer datos de un sitio web.

Analizando el contenido de Dom para Ollama

Una vez que el contenido DOM está limpio y preparado, el siguiente paso es analizar la información para extraer detalles específicos utilizando Ola , un modelo de lenguaje grande (LLM) integrado con LangChain. Ollama es una herramienta CLI que se utiliza para descargar y ejecutar LLM de forma local. Sin embargo, antes de utilizar Ollama, debe realizar las siguientes instalaciones:

• Si aún no lo has hecho, descarga e instala Ollama desde sitio web oficial Puedes instalarlo en Mac usando el comando Homebrew.

   brew install ollama

• A continuación, instale cualquier modelo de Esta lista Existen modelos como Phi3, Mistral, Gemma 2, etc.; cada uno tiene sus propios requisitos de sistema. Este código utiliza el phi3 principalmente porque es liviano.

   ollama pull phi3

Después de la instalación, puede llamar a ese modelo desde su script usando LangChain para proporcionar información significativa a partir de los datos que se le enviarán.

Aquí se explica cómo configurar la funcionalidad para analizar el contenido del DOM en el modelo phi3

Tutorial de código para llm.py

El siguiente código implementa la lógica para analizar fragmentos DOM con Ollama y extraer detalles relevantes:

 from langchain_ollama import OllamaLLM from langchain_core.prompts import ChatPromptTemplate # Template to instruct Ollama for parsing template = ( "You are tasked with extracting specific information from the following text content: {dom_content}. " "Please follow these instructions carefully: \n\n" "1. **Extract Information:** Only extract the information that directly matches the provided description: {parse_description}. " "2. **No Extra Content:** Do not include any additional text, comments, or explanations in your response. " "3. **Empty Response:** If no information matches the description, return an empty string ('')." "4. **Direct Data Only:** Your output should contain only the data that is explicitly requested, with no other text." ) # Initialize the Ollama model model = OllamaLLM(model="phi3") # Function to parse DOM chunks with Ollama def parse_with_ollama(dom_chunks, parse_description): prompt = ChatPromptTemplate.from_template(template) chain = prompt | model parsed_results = [] for i, chunk in enumerate(dom_chunks, start=1): if not chunk.strip(): # Skip empty chunks print(f"Skipping empty chunk at batch {i}") continue try: print(f"Processing chunk {i}: {chunk[:100]}...") # Print a preview print(f"Parse description: {parse_description}") response = chain.invoke( { "dom_content": chunk, "parse_description": parse_description, } ) print(f"Response for batch {i}: {response}") parsed_results.append(response) except Exception as e: print(f"Error parsing chunk {i}: {repr(e)}") parsed_results.append(f"Error: {repr(e)}") return "\n".join(parsed_results)

Qué hace el código.

1. Plantilla de instrucciones:
   • Proporciona orientación precisa a Ollama sobre qué información extraer.
   • Garantiza que la salida sea limpia, concisa y relevante para la descripción del análisis.
2. Procesamiento de fragmentos:
   • La función parse_with_ollama itera a través de los fragmentos DOM, procesando cada uno con el LLM.
   • Omite fragmentos vacíos para optimizar el rendimiento.
3. Manejo de errores:
   • Maneja los errores con elegancia, los registra y continúa procesando los fragmentos restantes.

Actualizando el archivo ui.py

Agregue el siguiente código al archivo ui.py para permitir que los usuarios ingresen instrucciones de análisis al LLM y vean los resultados:

 from main import scrape_website, extract_body_content, clean_body_content, split_dom_content from llm import parse_with_ollama if "dom_content" in st.session_state: parse_description = st.text_area("Enter a description to extract specific insights from your scraped data:") if st.button("Parse Content", key="parse_button"): if parse_description.strip() and st.session_state.get("dom_content"): st.info("Parsing the content...") dom_chunks = split_dom_content(st.session_state.dom_content) parsed_result = parse_with_ollama(dom_chunks, parse_description) st.text_area("Parsed Results", parsed_result, height=300) else: st.error("Please provide valid DOM content and a description to parse.")

Cómo funciona en la interfaz de usuario

1. Entrada del usuario:
   • El usuario proporciona una descripción en lenguaje natural de los datos a extraer en un área de texto.
2. Disparador de análisis:
   • Cuando se hace clic en el botón Analizar contenido, el contenido DOM limpio se divide en fragmentos manejables y se pasa a parse_with_ollama.
3. Visualización de resultados:
   • Los resultados analizados se muestran en un área de texto, lo que permite a los usuarios revisar la información extraída.

Una vez hecho esto, el raspador ahora puede proporcionar respuestas a sus indicaciones en función de los datos extraídos.

¿Que sigue?

La combinación de web scraping e IA abre posibilidades interesantes para obtener información basada en datos. Además de recopilar y guardar datos, ahora puede aprovechar la IA para optimizar el proceso de obtención de información a partir de los datos extraídos. Esto es útil para equipos de marketing y ventas, análisis de datos, propietarios de empresas y mucho más.

Puedes encontrar el código completo del AI scraper aquí. Experimenta con él y adáptalo a tus necesidades particulares. Las contribuciones también son bienvenidas. Si tienes ideas para mejorar, ¡considera crear una solicitud de incorporación de cambios!

También puedes llevar esto más allá. Aquí tienes algunas ideas:

• Experimente con indicaciones: adapte sus indicaciones para extraer información específica o abordar requisitos únicos del proyecto.
• Interfaz de usuario
• Integre otros modelos LLM: Explore otros modelos de lenguaje como IA abierta , Géminis , etc. para optimizar aún más el análisis de datos.