En este tutorial, demostramos cómo aprovechar RaspégrafoLas poderosas herramientas de raspado en combinación con Gemini AI para automatizar la recolección, el análisis y el análisis de la información de la competencia. Al utilizar SmartSCraperTool y Markdowntool de ScrapeGraph, los usuarios pueden extraer información detallada de las ofertas de productos, estrategias de precios, pilas de tecnología y presencia en el mercado directamente de los sitios web de la competencia. El tutorial luego emplea el modelo de lenguaje avanzado de Gemini para sintetizar estos puntos de datos dispares en inteligencia estructurada y procesable. A lo largo del proceso, ScrapeGraph asegura que la extracción en bruto sea precisa y escalable, lo que permite a los analistas centrarse en la interpretación estratégica en lugar de la recopilación de datos manuales.
%pip install --quiet -U langchain-scrapegraph langchain-google-genai pandas matplotlib seabornActualizamos o instalamos en silencio las últimas versiones de bibliotecas esenciales, incluido el cárcel langchain para el raspado web avanzado y el langchain-gogogle-Genai para integrar la IA de Gemini, así como las herramientas de análisis de datos como Pandas, Matplotlib y SeaBorn, para garantizar que su entorno esté listo para los flujos de trabajo inteligencia competitivos sin problemas.
import getpass
import os
import json
import pandas as pd
from typing import List, Dict, Any
from datetime import datetime
import matplotlib.pyplot as plt
import seaborn as snsImportamos bibliotecas esenciales de Python para configurar una tubería segura y basada en datos: GetPass y OS Administrar contraseñas y variables de entorno, JSON maneja datos serializados y Pandas ofrece operaciones sólidas de marcos de datos. El módulo de tipificación proporciona sugerencias de tipo para una mejor claridad de código, mientras que DateTime registra marcas de tiempo. Finalmente, matplotlib.pyplot y Seaborn nos equipan con herramientas para crear visualizaciones perspicaces.
if not os.environ.get("SGAI_API_KEY"):
os.environ["SGAI_API_KEY"] = getpass.getpass("ScrapeGraph AI API key:\n")
if not os.environ.get("GOOGLE_API_KEY"):
os.environ["GOOGLE_API_KEY"] = getpass.getpass("Google API key for Gemini:\n")Verificamos si las variables de entorno SGAI_API_KEY y Google_API_Key ya están configuradas; Si no, el script solicita segura al usuario para sus claves de la API de ScrapeGraph y Google (Gemini) a través de GetPass y las almacena en el entorno para solicitudes autenticadas posteriores.
from langchain_scrapegraph.tools import (
SmartScraperTool,
SearchScraperTool,
MarkdownifyTool,
GetCreditsTool,
)
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableConfig, chain
from langchain_core.output_parsers import JsonOutputParser
smartscraper = SmartScraperTool()
searchscraper = SearchScraperTool()
markdownify = MarkdownifyTool()
credits = GetCreditsTool()
llm = ChatGoogleGenerativeAI(
model="gemini-1.5-flash",
temperature=0.1,
convert_system_message_to_human=True
)
Aquí, importamos e instanciamos las herramientas de raspeado, el SmartScreperTool, SearchsCraperTool, MarkdownTool y GetCreditStool, para extraer y procesar datos web, luego configure el ChatGoogleGenerativeai con el modelo “Gemini-1.5-Flash” (mensajes de sistema de baja temperatura y leales humanos) para impulsar nuestro análisis. También traemos chatPromptTemplate, runnableconfig, Chain y jsonoutputParser de langchain_core para estructurar indicaciones y salidas del modelo de análisis.
class CompetitiveAnalyzer:
def __init__(self):
self.results = []
self.analysis_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
def scrape_competitor_data(self, url: str, company_name: str = None) -> Dict[str, Any]:
"""Scrape comprehensive data from a competitor website"""
extraction_prompt = """
Extract the following information from this website:
1. Company name and tagline
2. Main products/services offered
3. Pricing information (if available)
4. Target audience/market
5. Key features and benefits highlighted
6. Technology stack mentioned
7. Contact information
8. Social media presence
9. Recent news or announcements
10. Team size indicators
11. Funding information (if mentioned)
12. Customer testimonials or case studies
13. Partnership information
14. Geographic presence/markets served
Return the information in a structured JSON format with clear categorization.
If information is not available, mark as 'Not Available'.
"""
try:
result = smartscraper.invoke({
"user_prompt": extraction_prompt,
"website_url": url,
})
markdown_content = markdownify.invoke({"website_url": url})
competitor_data = {
"company_name": company_name or "Unknown",
"url": url,
"scraped_data": result,
"markdown_length": len(markdown_content),
"analysis_date": self.analysis_timestamp,
"success": True,
"error": None
}
return competitor_data
except Exception as e:
return {
"company_name": company_name or "Unknown",
"url": url,
"scraped_data": None,
"error": str(e),
"success": False,
"analysis_date": self.analysis_timestamp
}
def analyze_competitor_landscape(self, competitors: List[Dict[str, str]]) -> Dict[str, Any]:
"""Analyze multiple competitors and generate insights"""
print(f"🔍 Starting competitive analysis for {len(competitors)} companies...")
for i, competitor in enumerate(competitors, 1):
print(f"📊 Analyzing {competitor['name']} ({i}/{len(competitors)})...")
data = self.scrape_competitor_data(
competitor['url'],
competitor['name']
)
self.results.append(data)
analysis_prompt = ChatPromptTemplate.from_messages([
("system", """
You are a senior business analyst specializing in competitive intelligence.
Analyze the scraped competitor data and provide comprehensive insights including:
1. Market positioning analysis
2. Pricing strategy comparison
3. Feature gap analysis
4. Target audience overlap
5. Technology differentiation
6. Market opportunities
7. Competitive threats
8. Strategic recommendations
Provide actionable insights in JSON format with clear categories and recommendations.
"""),
("human", "Analyze this competitive data: {competitor_data}")
])
clean_data = []
for result in self.results:
if result['success']:
clean_data.append({
'company': result['company_name'],
'url': result['url'],
'data': result['scraped_data']
})
analysis_chain = analysis_prompt | llm | JsonOutputParser()
try:
competitive_analysis = analysis_chain.invoke({
"competitor_data": json.dumps(clean_data, indent=2)
})
except:
analysis_chain_text = analysis_prompt | llm
competitive_analysis = analysis_chain_text.invoke({
"competitor_data": json.dumps(clean_data, indent=2)
})
return {
"analysis": competitive_analysis,
"raw_data": self.results,
"summary_stats": self.generate_summary_stats()
}
def generate_summary_stats(self) -> Dict[str, Any]:
"""Generate summary statistics from the analysis"""
successful_scrapes = sum(1 for r in self.results if r['success'])
failed_scrapes = len(self.results) - successful_scrapes
return {
"total_companies_analyzed": len(self.results),
"successful_scrapes": successful_scrapes,
"failed_scrapes": failed_scrapes,
"success_rate": f"{(successful_scrapes/len(self.results)*100):.1f}%" if self.results else "0%",
"analysis_timestamp": self.analysis_timestamp
}
def export_results(self, filename: str = None):
"""Export results to JSON and CSV files"""
if not filename:
filename = f"competitive_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
with open(f"{filename}.json", 'w') as f:
json.dump({
"results": self.results,
"summary": self.generate_summary_stats()
}, f, indent=2)
df_data = []
for result in self.results:
if result['success']:
df_data.append({
'Company': result['company_name'],
'URL': result['url'],
'Success': result['success'],
'Data_Length': len(str(result['scraped_data'])) if result['scraped_data'] else 0,
'Analysis_Date': result['analysis_date']
})
if df_data:
df = pd.DataFrame(df_data)
df.to_csv(f"{filename}.csv", index=False)
print(f"✅ Results exported to {filename}.json and {filename}.csv")La clase competitiva de la clase orquesta la investigación de la competencia de extremo a extremo, raspando información detallada de la compañía utilizando herramientas de raspégrafo, compilando y limpiando los resultados, y luego aprovechando Gemini AI para generar ideas competitivas estructuradas. También rastrea las tasas de éxito y las marcas de tiempo, y proporciona métodos de utilidad para exportar datos sin procesar y resumidos en formatos JSON y CSV para facilitar informes y análisis posteriores.
def run_ai_saas_analysis():
"""Run a comprehensive analysis of AI/SaaS competitors"""
analyzer = CompetitiveAnalyzer()
ai_saas_competitors = [
{"name": "OpenAI", "url": "https://openai.com"},
{"name": "Anthropic", "url": "https://anthropic.com"},
{"name": "Hugging Face", "url": "https://huggingface.co"},
{"name": "Cohere", "url": "https://cohere.ai"},
{"name": "Scale AI", "url": "https://scale.com"},
]
results = analyzer.analyze_competitor_landscape(ai_saas_competitors)
print("\n" + "="*80)
print("🎯 COMPETITIVE ANALYSIS RESULTS")
print("="*80)
print(f"\n📊 Summary Statistics:")
stats = results['summary_stats']
for key, value in stats.items():
print(f" {key.replace('_', ' ').title()}: {value}")
print(f"\n🔍 Strategic Analysis:")
if isinstance(results['analysis'], dict):
for section, content in results['analysis'].items():
print(f"\n {section.replace('_', ' ').title()}:")
if isinstance(content, list):
for item in content:
print(f" • {item}")
else:
print(f" {content}")
else:
print(results['analysis'])
analyzer.export_results("ai_saas_competitive_analysis")
return resultsLa función anterior inicia el análisis competitivo al instancias de la competencia competitiva y definiendo los jugadores clave de AI/SAA a evaluar. Luego ejecuta el flujo de trabajo completo de raspado e inscva, imprime estadísticas de resumen formateadas y hallazgos estratégicos, y finalmente exporta los resultados detallados a JSON y CSV para un uso posterior.
def run_ecommerce_analysis():
"""Analyze e-commerce platform competitors"""
analyzer = CompetitiveAnalyzer()
ecommerce_competitors = [
{"name": "Shopify", "url": "https://shopify.com"},
{"name": "WooCommerce", "url": "https://woocommerce.com"},
{"name": "BigCommerce", "url": "https://bigcommerce.com"},
{"name": "Magento", "url": "https://magento.com"},
]
results = analyzer.analyze_competitor_landscape(ecommerce_competitors)
analyzer.export_results("ecommerce_competitive_analysis")
return resultsLa función anterior establece un competencia competitiva para evaluar las principales plataformas de comercio electrónico raspando los detalles de cada sitio, generando ideas estratégicas y luego exportando los hallazgos a archivos JSON y CSV bajo el nombre “ECOMMERCE_COMPETITIVE_Analysis”.
@chain
def social_media_monitoring_chain(company_urls: List[str], config: RunnableConfig):
"""Monitor social media presence and engagement strategies of competitors"""
social_media_prompt = ChatPromptTemplate.from_messages([
("system", """
You are a social media strategist. Analyze the social media presence and strategies
of these companies. Focus on:
1. Platform presence (LinkedIn, Twitter, Instagram, etc.)
2. Content strategy patterns
3. Engagement tactics
4. Community building approaches
5. Brand voice and messaging
6. Posting frequency and timing
Provide actionable insights for improving social media strategy.
"""),
("human", "Analyze social media data for: {urls}")
])
social_data = []
for url in company_urls:
try:
result = smartscraper.invoke({
"user_prompt": "Extract all social media links, community engagement features, and social proof elements",
"website_url": url,
})
social_data.append({"url": url, "social_data": result})
except Exception as e:
social_data.append({"url": url, "error": str(e)})
chain = social_media_prompt | llm
analysis = chain.invoke({"urls": json.dumps(social_data, indent=2)}, config=config)
return {
"social_analysis": analysis,
"raw_social_data": social_data
}
Aquí, esta función encadenada define una tubería para recopilar y analizar las huellas de las redes sociales de los competidores: utiliza el raspador inteligente de Scrapegraph para extraer enlaces de redes sociales y elementos de participación, luego alimenta esos datos a Gemini con un aviso enfocado en la presencia, la estrategia de contenido y las tácticas comunitarias. Finalmente, devuelve tanto la información raspada sin procesar como las ideas de redes sociales generadas por IA en una sola salida estructurada.
def check_credits():
"""Check available credits"""
try:
credits_info = credits.invoke({})
print(f"💳 Available Credits: {credits_info}")
return credits_info
except Exception as e:
print(f"⚠️ Could not check credits: {e}")
return NoneLa función anterior llama a GetCreditStool para recuperar y mostrar sus créditos de API de scrapegraph/gemini disponibles, imprimir el resultado o una advertencia si el cheque falla y devuelve la información de crédito (o ninguno con error).
if __name__ == "__main__":
print("🚀 Advanced Competitive Analysis Tool with Gemini AI")
print("="*60)
check_credits()
print("\n🤖 Running AI/SaaS Competitive Analysis...")
ai_results = run_ai_saas_analysis()
run_additional = input("\n❓ Run e-commerce analysis as well? (y/n): ").lower().strip()
if run_additional == 'y':
print("\n🛒 Running E-commerce Platform Analysis...")
ecom_results = run_ecommerce_analysis()
print("\n✨ Analysis complete! Check the exported files for detailed results.")Finalmente, la última pieza de código sirve como el punto de entrada del script: imprime un encabezado, verifica los créditos de la API, luego comienza el análisis de la competencia AI/SAAS (y opcionalmente el análisis de comercio electrónico) antes de señalar que todos los resultados se han exportado.
En conclusión, la integración de las capacidades de raspado de Scrapegraph con Gemini AI transforma un flujo de trabajo de inteligencia competitivo tradicionalmente que lleva mucho tiempo en una tubería eficiente y repetible. RapeGraph maneja el trabajo pesado de obtener y normalizar la información basada en la web, mientras que la comprensión del lenguaje de Gemini convierte los datos en bruto en recomendaciones estratégicas de alto nivel. Como resultado, las empresas pueden evaluar rápidamente el posicionamiento del mercado, identificar las brechas de características y descubrir oportunidades emergentes con una intervención manual mínima. Al automatizar estos pasos, los usuarios obtienen velocidad y consistencia, así como la flexibilidad para expandir su análisis a nuevos competidores o mercados según sea necesario.
Mira el Cuaderno en Github. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro 95k+ ml de subreddit y suscribirse a Nuestro boletín.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.