Docker and Fragrantica Support

.dockerignore

@@ -0,0 +1,8 @@
+tmp/
+.ruff_cache/
+__pycache__/
+.venv/
+.vscode/
+data/
+.env
+local/

.gitignore

@@ -0,0 +1,7 @@
+tmp/
+.ruff_cache/
+__pycache__/
+.venv/
+.vscode/
+data/
+local/

Dockerfile

@@ -0,0 +1,51 @@
+FROM python:3.12-slim
+
+# Install uv globally
+RUN pip install uv
+
+# Update system packages and install Playwright system dependencies (as root)
+RUN apt-get update && apt-get install -y \
+    libnss3 \
+    libatk-bridge2.0-0 \
+    libdrm2 \
+    libxkbcommon0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxrandr2 \
+    libgbm1 \
+    libxss1     libasound2     libcups2     libxfixes3     libcairo2     libpango-1.0-0     --no-install-recommends &&     rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+RUN adduser --disabled-password --gecos '' appuser
+
+# Create /app directory and set ownership
+RUN mkdir /app && chown appuser:appuser /app
+
+WORKDIR /app
+
+# Switch to the non-root user
+USER appuser
+
+# Create virtual environment as appuser
+RUN uv venv .venv
+# Use the virtual environment automatically
+ENV VIRTUAL_ENV=/app/.venv
+ENV PATH="/app/.venv/bin:$PATH"
+ENV PYTHONUNBUFFERED=1
+
+# Copy dependency files and install dependencies as appuser
+COPY pyproject.toml uv.lock ./ 
+RUN uv sync
+
+# Install Playwright browser binaries as appuser
+RUN /app/.venv/bin/playwright install chromium
+
+# Copy the rest of your application code as appuser
+COPY . .
+
+# Expose the port Gradio runs on
+EXPOSE 7860
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# Command to run the Gradio application
+CMD ["uv", "run", "--active", "app.py"]

README.md

@@ -1,8 +1,7 @@
 ---
 title: nat-ad
-app_file: app.py
-sdk: gradio
-sdk_version: 5.38.0
+sdk: docker
+app_port: 7860
 ---
 # Social Media Ads Creator
 
@@ -10,40 +9,47 @@ This project leverages AI agents to automatically generate social media ad copy
 
 ## How it Works
 
-The system uses a Gradio interface (`app.py`) to take product URLs and other parameters as input. Behind the scenes, a "crew" of AI agents, each with a specific role, processes this information:
+The system uses a Gradio interface (`app.py`) with two main tabs:
 
-1.  **Product Analyst:** This agent scrapes a product URL to extract key information like the product name, features, price, and any available discounts. It also uses a tool to shorten the URL.
-2.  **Social Media Copywriter:** This agent takes the product information and crafts a compelling social media post in Portuguese, tailored for platforms like WhatsApp. The post includes a call to action, emojis, and the shortened URL.
+1.  **Social Media Ad Generator:** This tab takes product URLs and other parameters as input. Behind the scenes, a "crew" of AI agents, each with a specific role, processes this information:
+    *   **Product Analyst:** This agent scrapes a product URL to extract key information like the product name, features, price, and any available discounts. It also uses a tool to shorten the URL.
+    *   **Social Media Copywriter:** This agent takes the product information and crafts a compelling social media post in Portuguese, tailored for platforms like WhatsApp. The post includes a call to action, emojis, and the shortened URL.
+
+2.  **Fragrantica Website Analyzer:** This new tab allows users to input a Fragrantica.com URL for a perfume. A dedicated "FragranticaCrew" analyzes the webpage using a stealthy web scraping tool (`StealthScrapeTool`) to bypass anti-bot measures. The crew then generates a comprehensive perfume analysis report.
+    *   **Expert Perfume Analyst and Web Data Extractor:** This agent extracts detailed perfume information (notes, accords, longevity, sillage, similar fragrances, reviews) from the Fragrantica page.
+    *   **Fragrance Expert Woman and Perfume Analysis Reporter:** This agent synthesizes the extracted data into a human-friendly report, including graded evaluations and personalized recommendations.
 
 ## Setup and Usage
 
 1.  **Prerequisites:**
-    *   Python 3.12 or higher
+    *   Docker installed
     *   An OpenAI API key
     *   A Natura API token (for the URL shortener)
 
-2.  **Installation:**
-    *   The dependencies are listed in the `pyproject.toml` file.
-
-3.  **Configuration:**
-    *   Create a `.env` file in the root directory.
-    *   Add your OpenAI API key and Natura API token to the `.env` file:
-        ```
-        OPENAI_API_KEY="your_openai_api_key"
-        NATURA_API_TOKEN="your_natura_api_token"
+2.  **Installation & Execution (Docker):**
+    *   Build the Docker image:
+        ```bash
+        docker build -t natura-ads .
         ```
-
-4.  **Execution:**
-    *   Run the `app.py` script to launch the Gradio application:
+    *   Run the Docker container, mapping port 7860 and passing API keys as environment variables:
         ```bash
-        u run app.py
+        docker run -p 7860:7860 -e OPENAI_API_KEY="your_openai_api_key" -e NATURA_API_TOKEN="your_natura_api_token" -e OPENAI_BASE_URL="your_openai_base_url" -e OPENAI_MODEL_NAME="your_openai_model_name" natura-ads
         ```
-    *   Access the Gradio interface in your web browser at the address provided in the console (usually `http://127.0.0.1:7860`).
+    *   Access the Gradio interface in your web browser at `http://localhost:7860`.
 
 ## Key Files
 
 *   `app.py`: The Gradio application that provides the user interface.
-*   `social_media_crew.py`: Defines the AI agents and their tasks.
+*   `social_media_crew.py`: Defines the AI agents and their tasks for social media ad generation.
+*   `fragrantica_crew.py`: Defines the AI agents and their tasks for Fragrantica website analysis.
+*   `stealth_scrape_tool.py`: A custom tool for stealthy web scraping using Playwright.
 *   `shortener_tool.py`: A custom tool for shortening URLs.
-*   `.env`: The configuration file for API keys.
+*   `Dockerfile`: Defines the Docker image for deploying the application.
+*   `.env`: The configuration file for API keys (used for local development, environment variables preferred for Docker).
 *   `pyproject.toml`: The project's metadata and dependencies.
+
+
+# Roadmap
+
+- [x] Add support for any model/api key supported by LiteLLM.
+- [x] Add Fragrantica support, where user will input a Fragrantica URL and the agent will extract and generate a Perfume Analysis report.

app.py

@@ -1,12 +1,12 @@
 import gradio as gr
 import os
 import requests
-from dotenv import load_dotenv
-
-load_dotenv()
 from crewai import Agent, Task, Crew, Process, LLM
 from crewai_tools import ScrapeWebsiteTool
 from crewai.tools import BaseTool
+from dotenv import load_dotenv
+
+load_dotenv()
 
 class ShortenerTool(BaseTool):
     name: str = "URL Shortener Tool"
@@ -27,7 +27,7 @@ class ShortenerTool(BaseTool):
             print(f"Warning: Error generating short URL: {e}. Returning original URL.")
             return original_url
         except ValueError:
-            print(f"Warning: Invalid JSON response from shortener API. Returning original URL.")
+            print("Warning: Invalid JSON response from shortener API. Returning original URL.")
             return original_url
 
 class CalculateDiscountedPriceTool(BaseTool):
@@ -105,9 +105,9 @@ class SocialMediaCrew:
             return "INVALID_URL"
 
         analyze_product_task = Task(
-            description=(f"1. Scrape the content of the URL: {product_url} using the 'scrape_tool'.\n2. Identify and extract the original product price and the final discounted price if existing. IGNORE any price breakdowns like 'produto' or 'consultoria'.\n3. Extract the product name, key characteristics, and any other relevant DISCOUNT available.\n4. Use the 'Calculate Discounted Price Tool' with the extracted final best price and the provided discount percentage ({main_cupom_discount_percentage}) to get the CUPOM DISCOUNTED PRICE.\n5. Use the 'URL Shortener Tool' to generate a short URL for {product_url}. If the shortener tool returns an error, use the original URL.\n6. Provide all this information, including the product name, ORIGINAL PRICE (the primary price from step 2), CUPOM DISCOUNTED PRICE, and the generated short URL (or the original if the shortener failed). If any of this information cannot be extracted, you MUST return 'MISSING_PRODUCT_INFO'."),
+            description=(f"1. Scrape the content of the URL: {product_url} using the 'scrape_tool'.\n2. Identify and extract the original product price and the final discounted price if existing. IGNORE any price breakdowns like 'produto' or 'consultoria'.\n3. Extract the product name, key characteristics, and any other relevant DISCOUNT available.\n4. Use the 'Calculate Discounted Price Tool' with the extracted final best price and the provided discount percentage ({main_cupom_discount_percentage}) to get the CUPOM DISCOUNTED PRICE.\n5. Use the 'URL Shortener Tool' to generate a short URL for {product_url}. If the shortener tool returns an error, use the original URL.\n6. Provide all this information, including the product name, ORIGINAL PRICE, DISCOUNTED PRICE  (the one used as the input in the tool 'Calculate Discounted Price Tool'), 2) CUPOM DISCOUNTED PRICE, and the generated short URL (or the original if the shortener failed). If any of this information cannot be extracted, you MUST return 'MISSING_PRODUCT_INFO'."),
             agent=self.product_analyst,
-            expected_output="A concise summary of the product including its name, key features, unique selling points, ORIGINAL PRICE, CUPOM DISCOUNTED PRICE, and the SHORT SHAREABLE URL (or the original if the shortener failed), OR 'MISSING_PRODUCT_INFO' if essential product details are not found."
+            expected_output="A concise summary of the product including its name, key features, unique selling points, ORIGINAL PRICE, DISCOUNTED PRICE (the one used as the input in the tool 'Calculate Discounted Price Tool'), CUPOM DISCOUNTED PRICE, and the SHORT SHAREABLE URL (or the original if the shortener failed), OR 'MISSING_PRODUCT_INFO' if essential product details are not found."
         )
 
         create_post_task = Task(
@@ -180,20 +180,40 @@ with gr.Blocks() as demo:
         cupom_1_input = gr.Textbox(label="Cupom 1 (e.g., AMIGO15)", placeholder="Enter first coupon code...")
         cupom_2_input = gr.Textbox(label="Cupom 2 (e.g., JULHOA)", placeholder="Enter second coupon code...")
         generate_button = gr.Button("Generate Ad")
-        ad_output = gr.Markdown(label="Your Generated Ad")
+        ad_output = gr.Markdown(label="Your Generated Ad", show_copy_button=True)
         
+    with gr.Tab("Fragrantica"):
+        gr.Markdown("### 👃 Fragrantica Website Analyzer")
+        fragrantica_url_input = gr.Textbox(label="Fragrantica Product URL", placeholder="Enter Fragrantica product URL here...")
+        analyze_fragrantica_button = gr.Button("Analyze Fragrantica Product")
+        fragrantica_output = gr.Markdown(label="Fragrantica Analysis Report")
+
     with gr.Tab("Settings"):
         gr.Markdown("### ⚙️ API Key Settings")
         gr.Markdown("Enter your API keys below. These will be used for the current session.")
         openai_key_input = gr.Textbox(label="OPENAI_API_KEY", type="password", value=os.getenv("OPENAI_API_KEY", ""))
         natura_token_input = gr.Textbox(label="NATURA_API_TOKEN", type="password", value=os.getenv("NATURA_API_TOKEN", ""))
         openai_base_url_input = gr.Textbox(label="OPENAI_BASE_URL", value=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1"))
-        openai_model_name_input = gr.Textbox(label="OPENAI_MODEL_NAME", value=os.getenv("OPENAI_MODEL_NAME", "gpt-4o-mini"))
+        openai_model_name_input = gr.Textbox(label="OPENAI_MODEL_NAME", value=os.getenv("OPENAI_MODEL_NAME", "gpt-4.1"))
         
         clean_env_vars()
         # No save button needed as keys are passed directly
         gr.Markdown("API keys are used directly from these fields when you click 'Generate Ad'. They are not saved persistently.")
 
     generate_button.click(generate_ad, inputs=[url_input, main_cupom_input, main_cupom_discount_percentage_input, cupom_1_input, cupom_2_input, openai_key_input, natura_token_input, openai_base_url_input, openai_model_name_input], outputs=ad_output)
-
-demo.launch()
+    
+    # Placeholder for Fragrantica analysis function
+    def analyze_fragrantica_url(url, openai_api_key, natura_api_token, openai_base_url, openai_model_name):
+        if not openai_api_key or not openai_model_name or not openai_base_url:
+            return "Please configure your API keys in the settings section below."
+        from fragrantica_crew import FragranticaCrew
+        fragrantica_crew = FragranticaCrew(openai_api_key, openai_base_url, openai_model_name)
+        report = fragrantica_crew.kickoff(url=url)
+        if report == "SCRAPING_FAILED":
+            return "❌ Scraping failed. The website could not be accessed or parsed. Please check the URL or try again later."
+        return report.raw
+
+    analyze_fragrantica_button.click(analyze_fragrantica_url, inputs=[fragrantica_url_input, openai_key_input, natura_token_input, openai_base_url_input, openai_model_name_input], outputs=fragrantica_output)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

fragrantica_crew.py

@@ -0,0 +1,109 @@
+from crewai import Agent, Task, Crew, Process, LLM
+
+from stealth_scrape_tool import StealthScrapeTool
+
+class FragranticaCrew:
+    def __init__(self, openai_api_key: str, openai_base_url: str, openai_model_name: str):
+        self.openai_api_key = openai_api_key
+        self.openai_base_url = openai_base_url
+        self.openai_model_name = openai_model_name
+        self.scrape_tool = StealthScrapeTool()
+
+        llm = LLM(
+            api_key=self.openai_api_key, 
+            model=self.openai_model_name, 
+            base_url=self.openai_base_url
+        )
+
+        self.research_agent = Agent(
+            role='Expert Perfume Analyst and Web Data Extractor',
+            goal="Analyze the content of the provided URL, which leads to a perfume review page. Based on the page's content, including official descriptions and user reviews, you must extract the specified information and format it as a user friendly text.",
+            backstory=("As an expert in the world of fragrances and olfactory evaluator, you have a gift for dissecting complex perfume pages. You can read through hundreds of user reviews and technical details on a webpage, synthesizing them into a clear, structured summary. Your expertise allows you to adeptly identify olfactory notes, longevity, sillage and similar fragrances, providing a comprehensive analysis for any fragrance enthusiast."),
+            verbose=True,
+            tools=[self.scrape_tool],
+            allow_delegation=False,
+            llm=llm,
+            max_retries=3
+        )
+
+        self.reporter_agent = Agent(
+            role='Fragrance Expert Woman and Perfume Analysis Reporter',
+            goal='Produce a "Human Friendly" analysis containing specific graded evaluations and personalized recommendations based on the extracted perfume information.',
+            backstory=("You are a seasoned reporter with a passion for fragrances. You excel at transforming raw data about perfumes into engaging, well-structured, and informative reports. Your reports highlight key characteristics, unique selling points, and provide a holistic view of the fragrance, making it easy for enthusiasts to understand and appreciate. You are also an extraordinary woman, capable of providing insightful and personalized recommendations."),
+            verbose=True,
+            allow_delegation=False,
+            llm=llm,
+            max_retries=3
+        )
+
+    def kickoff(self, url: str) -> str:
+        research_task = Task(
+            description=(
+                f"""1. Scrape the content of the URL: {url} using the 'Stealth Web Scraper' tool with `website_url` as {url} and `css_element` as "#main-content". If the scraping tool fails or returns empty content ONCE, try the `css_element` as "body", If they also fail when you pass `css_element` as "body", then you MUST return the exact string "SCRAPING_FAILED".
+
+                2. If scraping is successful, carefully analyze the entire page content to extract the following information:
+
+                   - Resumo: Look for a general summary of the perfume, often found near the top or in introductory paragraphs, synthesizing user opinions if available.
+
+                   - Acordes principais: Find the section listing 'Main Accords' or similar, and extract the list of accords (e.g., 'amadeirado', 'cítrico', 'floral').
+
+                   - Pirâmide Olfativa: Identify sections for 'Top Notes', 'Middle Notes', and 'Base Notes'. Extract the notes for 'topo' (top), 'coracao' (heart), and 'fundo' (base) into a dictionary format.
+
+                   - Longevidade: Locate user polls or reviews discussing longevity. Choose one of the following exact string values based on the overall sentiment: 'Fraca', 'Moderada', 'Longa', 'Eterna'.
+                   - Projeção: Locate user polls or reviews discussing sillage/projection. Choose one of the following exact string values based on the overall sentiment: 'Íntima', 'Moderada', 'Forte', 'Enorme'.
+
+                   - Este Perfume me Lembra do: Find the section titled "Este perfume me lembra do", and list the perfume names mentioned there.
+
+                   - Resumo detalhado: Look for a section containing detailed user reviews, such as "Todas as Resenhas por Data" or similar, and synthesize a detailed summary from these reviews.
+
+                3. Present the extracted information in a clear, structured format, ready for reporting. If any specific piece of information cannot be found, check again to make sure they are not found, after check again, if you truly do not find the info, state 'N/A' for that field. If the entire scraping process fails, return "SCRAPING_FAILED".
+"""
+            ),
+            agent=self.research_agent,
+            expected_output=(
+                """A structured text containing all the extracted information: 
+                    Resumo, 
+                    Acordes principais, 
+                    Pirâmide Olfativa, 
+                    Longevidade, 
+                    Projeção, 
+                    Este Perfume me Lembra do,
+                    and Resumo detalhado.
+                Ensure Longevidade and Projeção use the exact specified string values.
+                If any information is not found, state 'N/A' for that specific field. If the scraping process fails entirely, return the exact string "SCRAPING_FAILED"."""
+            )
+        )
+
+        report_task = Task(
+            description=(
+                """With the extracted information, as an Fragrance Expert woman, your next step is to produce a "Human Friendly" analysis containing:\n"
+                "If the input you receive from the research agent is "SCRAPING_FAILED", you MUST stop and output only that same message.\n"
+                   - Nível de "doçura": Ranging from 1 to 5\n
+                   - Intensidade: Ranging from 1 to 5\n
+                   - Fixação na minha pele: Ranging from 1 to 5\n
+                   - Projeção: Ranging from 1 to 5\n
+                   - Segue o estilo do perfurme: Select the perfume that most match this one, based on "Este Perfume me Lembra do" and "Resumo detalhado" extracted earlier\n
+                   - Como ele é, na minha percepção: Based on your analyses, write a concise summary about "How do I see it". Where you give your opinion using info about the perfume grades, and etc.\n
+                   - Eu indico para quem: Give your opinion two opinions about who would like it. Something like "gostam de frangâncias cítricas e amedeirado", "Querem um perfurme forte para usar no inverno"\n
+                Your output must be a text containing the "Extraction" values and the "Process" values, in user friaendly format."""
+            ),
+            agent=self.reporter_agent,
+            expected_output=(
+                """A comprehensive perfume analysis report in markdown format.
+                The report must include all extracted information (Resumo, Acordes principais, Pirâmide Olfativa, Longevidade, Projeção, Este Perfume me Lembra, Resumo detalhado) 
+                and the "Human Friendly" analysis (Nível de "doçura", Intensidade, Fixação na minha pele, Projeção, Segue o estilo do perfurme, Como ele é, na minha percepção, Eu indico para quem)."""
+            ),
+            context=[research_task]
+        )
+
+        crew = Crew(
+            agents=[self.research_agent, self.reporter_agent],
+            tasks=[research_task, report_task],
+            process=Process.sequential
+        )
+
+        print(f"Fragrantica Crew is kicking off for URL: {url}")
+        result = crew.kickoff()
+        if result == "SCRAPING_FAILED":
+            return result
+        return result

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "crewai-agent"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "beautifulsoup4>=4.13.4",
+    "crewai>=0.148.0",
+    "crewai-tools>=0.55.0",
+    "gradio>=5.38.0",
+    "litellm>=1.72.6",
+    "playwright>=1.53.0",
+    "playwright-stealth>=2.0.0",
+]

requirements.txt

@@ -1,4 +1,6 @@
 crewai>=0.148.0
 crewai-tools>=0.55.0
 gradio>=5.38.0
-litellm
+litellm>=1.72.6
+playwright>=1.53.0
+playwright-stealth>=2.0.0

social_media_crew.py

@@ -0,0 +1,56 @@
+import os
+from crewai import Agent, Task, Crew, Process
+from crewai_tools import ScrapeWebsiteTool
+from shortener_tool import ShortenerTool
+
+class SocialMediaCrew:
+    def __init__(self):
+        self.scrape_tool = ScrapeWebsiteTool()
+        self.shortener_tool = ShortenerTool()
+
+        self.product_analyst = Agent(
+            role='Product Analyst',
+            goal='Analyze the provided URL and extract key product information',
+            backstory=("""You are an expert in analyzing product pages and extracting the most important information. 
+            You can identify the product name, the price, discount if any, its main features, and the target audience."""),
+            verbose=True,
+            tools=[self.scrape_tool, self.shortener_tool],
+        )
+
+        self.social_media_copywriter = Agent(
+            role='Social Media Copywriter',
+            goal='Create a compelling social media post in Portuguese to sell the product',
+            backstory=("""You are a creative copywriter specialized in the beauty and fragrance market. 
+            You know how to craft posts that are engaging, persuasive, and tailored for a Portuguese-speaking audience. 
+            You are an expert in using emojis and hashtags to increase engagement."""),
+            verbose=True,
+        )
+
+    def run_crew(self, product_url: str) -> str:
+        analyze_product_task = Task(
+            description=(f"""Using the 'scrape_tool', scrape the content of the URL: {product_url} and provide a summary of the product. 
+            Focus on the product name, its key characteristics, the FINAL PRICE, any DISCOUNT available. 
+            Then, use the 'URL Shortener Tool' to generate a short URL for {product_url}. If the shortener tool returns an error, use the original URL. 
+            Finally, provide all this information, including the generated short URL (or the original if shortener failed)."""),
+            agent=self.product_analyst,
+            expected_output="A concise summary of the product including its name, key features, unique selling points, FINAL PRICE, any DISCOUNT available, and the SHORT SHAREABLE URL (or the original URL if shortener failed)."
+        )
+
+        create_post_task = Task(
+            description=("""Based on the product analysis, create a CONCISE and DIRECT social media post in Portuguese, suitable for a WhatsApp group. 
+            The post should be exciting and highlight the main benefits of the perfume, including the FINAL PRICE, any DISCOUNT, and the SHORT SHAREABLE URL. 
+            Ensure a URL is always present in the output. Include a clear call to action and a MAXIMUM of 2 relevant emojis. DO NOT include hashtags. Keep it short and impactful."""),
+            agent=self.social_media_copywriter,
+            expected_output="A short, direct, and impactful social media post in Portuguese for WhatsApp, including the FINAL PRICE, any DISCOUNT, the SHORT SHAREABLE URL, a call to action, and up to 2 emojis. No hashtags should be present. A URL must always be present in the final output.",
+            context=[analyze_product_task]
+        )
+
+        crew = Crew(
+            agents=[self.product_analyst, self.social_media_copywriter],
+            tasks=[analyze_product_task, create_post_task],
+            process=Process.sequential
+        )
+
+        print(f"Crew is kicking off for URL: {product_url}")
+        result = crew.kickoff()
+        return result

stealth_scrape_tool.py

@@ -0,0 +1,37 @@
+import asyncio
+from playwright.async_api import async_playwright
+from playwright_stealth import Stealth
+from bs4 import BeautifulSoup
+from crewai.tools import BaseTool
+
+class StealthScrapeTool(BaseTool):
+    name: str = "Stealth Web Scraper"
+    description: str = "A tool for stealthily scraping content from a given URL using Playwright and a CSS selector."
+
+    async def _arun(self, website_url: str, css_element: str) -> str:
+        try:
+            async with Stealth().use_async(async_playwright()) as p:
+                browser = await p.chromium.launch(headless=True)
+                page = await browser.new_page()
+                
+                await page.goto(website_url, timeout=120000)
+                
+                # Wait for the specific element to be present
+                await page.wait_for_selector(css_element, timeout=60000)
+                
+                html_content = await page.content()
+                soup = BeautifulSoup(html_content, 'html.parser')
+                
+                target_element = soup.select_one(css_element)
+                if target_element:
+                    return target_element.prettify()
+                else:
+                    return f"Error: Could not find element with selector '{css_element}' on the page."
+        except Exception as e:
+            return f"Error during stealth web scraping: {e}"
+
+    def _run(self, website_url: str, css_element: str) -> str:
+        # This method is for synchronous execution, which is not ideal for Playwright.
+        # CrewAI typically calls _arun for async tools.
+        # For simplicity, we'll just call the async version here.
+        return asyncio.run(self._arun(website_url, css_element))