Ngoại trừ requests.exceptions.RequestException như e:
                print(f"Lỗi khi truy cập URL {url}: {e}")
                return None

        def extract_data_with_perplexity(html_content, prompt):
            """Sử dụng Perplexity AI để trích xuất dữ liệu từ HTML dựa trên một hướng dẫn."""
            if not html_content:
                return "Không có nội dung HTML để xử lý."
            
            try:
                # Xây dựng thông điệp cho Perplexity AI
                messages = [
                    {"role": "system", "content": "Bạn là một trợ lý AI trích xuất thông tin từ nội dung HTML dựa trên hướng dẫn của người dùng. Cung cấp dữ liệu đã được trích xuất theo định dạng ngắn gọn."},
                    {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nHướng dẫn: {prompt}"}
                ]
                
                chat_completion = client.chat.completions.create(
                    model="sonar-small-online", # Hoặc "sonar-medium-online" cho các nhiệm vụ phức tạp hơn
                    messages=messages,
                    max_tokens=500
                )
                return chat_completion.choices[0].message.content
            except Exception as e:
                print(f"Lỗi khi trích xuất dữ liệu với Perplexity AI: {e}")
                return None

        # Ví dụ sử dụng
        target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        html = fetch_html(target_url)

        if html:
            extraction_prompt = "Trích xuất tên sản phẩm, giá và mô tả. Trình bày chúng rõ ràng."
            extracted_info = extract_data_with_perplexity(html, extraction_prompt)
            print("\n--- Thông tin đã được trích xuất ---")
            print(extracted_info)

Giải pháp này chứng minh nguyên tắc cơ bản của việc sử dụng Perplexity AI để giải nghĩa HTML thô và trích xuất thông tin mong muốn, giúp đơn giản hóa giai đoạn trích xuất dữ liệu ban đầu bằng cách rời xa việc phân tích dựa trên các bộ chọn không ổn định.

### 2. Trích xuất dữ liệu có cấu trúc sử dụng mô hình Pydantic

Giải pháp này tập trung vào việc tận dụng Perplexity AI để trả về dữ liệu đã được trích xuất theo định dạng có cấu trúc được định nghĩa trước bằng mô hình Pydantic. Điều này đảm bảo tính nhất quán của dữ liệu và đơn giản hóa quy trình xử lý sau này.

*   **Mô tả:** Thay vì nhận văn bản tự do từ Perplexity AI, chúng ta có thể hướng dẫn đầu ra của nó phù hợp với một sơ đồ cụ thể được định nghĩa bởi `BaseModel` của Pydantic. Điều này đặc biệt hữu ích khi bạn cần trích xuất nhiều trường (ví dụ: tên sản phẩm, giá, đánh giá) và muốn chúng được tổ chức gọn gàng thành một đối tượng Python hoặc cấu trúc JSON. Thư viện `instructor`, đóng gói API OpenAI (và do đó API tương thích với Perplexity AI), rất tuyệt vời cho mục đích này, cho phép đầu ra có cấu trúc với kiểu được gợi ý.

*   **Ví dụ mã/ Các bước:**

    1.  **Cài đặt các thư viện cần thiết:**

        ```bash
        pip install openai requests pydantic instructor
        ```

    2.  **Định nghĩa mô hình Pydantic của bạn:** Tạo một `BaseModel` đại diện cho cấu trúc dữ liệu mà bạn muốn trích xuất.

    3.  **Chỉnh sửa hàm trích xuất:** Sử dụng thư viện `instructor` để tích hợp mô hình Pydantic với lời gọi API của Perplexity AI.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor # Nhập thư viện instructor

        # Thiết lập khóa API của Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Vá client OpenAI với instructor để có đầu ra có cấu trúc
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        # 1. Định nghĩa một mô hình Pydantic cho cấu trúc đầu ra mong muốn
        class ProductDetails(BaseModel):
            name: str
            price: str
            description: str
            # Thêm nhiều trường hơn nếu cần, ví dụ: rating: float, availability: bool

        def fetch_html(url):
            """Lấy nội dung HTML của một URL cho trước."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Lỗi khi truy cập URL {url}: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Sử dụng Perplexity AI để trích xuất dữ liệu có cấu trúc từ HTML dựa trên mô hình Pydantic."""
            if not html_content:
                return None
            
            try:
                # Tham số response_model cho biết cho instructor để phân tích đầu ra thành mô hình Pydantic của chúng ta
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online", # Hoặc "sonar-medium-online"
                    response_model=target_model,
                    messages=[
{"role": "system", "content": "Bạn là một trợ lý AI có khả năng trích xuất thông tin cấu trúc từ nội dung HTML. Trích xuất các chi tiết được yêu cầu vào schema JSON được cung cấp."},
{"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất các chi tiết sản phẩm sau: tên, giá và mô tả."}
```python
print(f"Lỗi khi lấy URL động {url} bằng Selenium: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Sử dụng Perplexity AI để trích xuất dữ liệu có cấu trúc từ HTML dựa trên mô hình Pydantic."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=target_model,
                    messages=[
                        {"role": "system", "content": "Bạn là một trợ lý AI có nhiệm vụ trích xuất thông tin có cấu trúc từ nội dung HTML. Trích xuất các chi tiết yêu cầu vào sơ đồ JSON được cung cấp."},
                        {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất các chi tiết sản phẩm sau: tên, giá và mô tả."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Lỗi khi trích xuất dữ liệu có cấu trúc bằng Perplexity AI: {e}")
                return None

        # Ví dụ sử dụng (sử dụng một trang động giả định)
        # Lưu ý: Thay bằng một trang động thực tế để thử nghiệm
        dynamic_target_url = "https://www.example.com/dynamic-product-page" # Thay bằng một URL động thực tế
        print(f"Đang lấy nội dung động từ: {dynamic_target_url}")
        dynamic_html = fetch_dynamic_html(dynamic_target_url)

        if dynamic_html:
            print("Đã lấy HTML động thành công. Đang chuyển đến Perplexity AI...")
            product_info = extract_structured_data_with_perplexity(dynamic_html, ProductDetails)
            if product_info:
                print("\n--- Chi tiết sản phẩm đã trích xuất từ trang động ---")
                print(f"Tên: {product_info.name}")
                print(f"Giá: {product_info.price}")
                print(f"Mô tả: {product_info.description}")
                print(f"Đầu ra JSON: {product_info.model_dump_json(indent=2)}")
            else:
                print("Không thể trích xuất thông tin sản phẩm từ trang động.")
        else:
            print("Không thể lấy HTML động.")

    Giải pháp này giải quyết hiệu quả nội dung động bằng cách đảm bảo rằng Perplexity AI nhận được HTML đã được render hoàn chỉnh, cho phép nó áp dụng khả năng phân tích thông minh của mình ngay cả đối với các trang web phức tạp, dựa vào JavaScript. Sự kết hợp này rất quan trọng cho việc trích xuất dữ liệu web toàn diện trong môi trường web ngày nay.




### 4. Vượt qua các biện pháp chống thu thập dữ liệu bằng cách sử dụng Proxy và Perplexity AI

Nhiều trang web áp dụng các cơ chế chống thu thập dữ liệu như chặn IP, CAPTCHA và giới hạn tần suất. Kết hợp Perplexity AI với các giải pháp proxy mạnh mẽ giúp vượt qua những rào cản này, đảm bảo luồng dữ liệu không bị gián đoạn.

*   **Mô tả:** Trong khi Perplexity AI xuất sắc trong việc phân tích, nó không xử lý được các thách thức ở cấp độ mạng. Đây là lúc dịch vụ proxy trở nên cần thiết. Bằng cách chuyển hướng các yêu cầu của bạn qua một mạng lưới các proxy dân cư hoặc datacenter, bạn có thể che giấu địa chỉ IP của mình, phân phối yêu cầu và vượt qua các hạn chế địa lý. Khi proxy thành công lấy trang web, nội dung HTML của nó sẽ được gửi tới Perplexity AI để trích xuất thông minh. Sự phân chia nhiệm vụ này - proxy để truy cập, AI để phân tích - tạo ra một kiến trúc thu thập dữ liệu hiệu quả và bền bỉ.

*   **Ví dụ mã/Các bước:**

    1.  **Cài đặt các thư viện cần thiết:**

        ```bash
        pip install openai requests pydantic instructor
        ```

    2.  **Thiết lập khóa API Perplexity AI và thông tin xác thực proxy:** Đối với ví dụ này, chúng ta sẽ sử dụng thông tin xác thực giả cho dịch vụ proxy. Thay thế `YOUR_PROXY_USERNAME` và `YOUR_PROXY_PASSWORD` bằng thông tin thực tế từ một nhà cung cấp như Oxylabs hoặc Brightdata.

    3.  **Viết kịch bản Python:**

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor

        # Thiết lập khóa API Perplexity AI của bạn
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Chỉnh sửa client OpenAI với instructor cho đầu ra có cấu trúc
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        # Thông tin xác thực proxy (thay bằng thông tin xác thực của bạn)
        PROXY_USERNAME = os.getenv("PROXY_USERNAME", "YOUR_PROXY_USERNAME")
        PROXY_PASSWORD = os.getenv("PROXY_PASSWORD", "YOUR_PROXY_PASSWORD")

        class ProductDetails(BaseModel):
            name: str
            price: str
            description: str

        def fetch_html_with_proxy(url):
            """Lấy nội dung HTML của một URL bằng cách sử dụng proxy."""
            proxy_url = f"http://{PROXY_USERNAME}:{PROXY_PASSWORD}@pr.oxylabs.io:7777" # Ví dụ cho proxy dân cư Oxylabs
            proxies = {

"http": proxy_url,
                "https": proxy_url,
            }
            headers = {
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36",
                "Accept-Language": "en-US,en;q=0.9",
            }
            try:
                response = requests.get(url, headers=headers, proxies=proxies, timeout=15)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Lỗi khi lấy URL {url} với proxy: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Sử dụng Perplexity AI để trích xuất dữ liệu có cấu trúc từ HTML dựa trên mô hình Pydantic."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=target_model,
                    messages=[
                        {"role": "system", "content": "Bạn là một trợ lý AI trích xuất thông tin có cấu trúc từ nội dung HTML. Trích xuất các chi tiết được yêu cầu vào sơ đồ JSON đã cung cấp."},
                        {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất các chi tiết sản phẩm sau: tên, giá, và mô tả."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Lỗi khi trích xuất dữ liệu có cấu trúc với Perplexity AI: {e}")
                return None

        # Ví dụ Sử Dụng
        target_url = "https://www.amazon.com/some-product-page" # Thay thế bằng một URL mục tiêu có thể yêu cầu proxy
        print(f"Đang lấy nội dung từ: {target_url} bằng cách sử dụng proxy...")
        html = fetch_html_with_proxy(target_url)

        if html:
            print("HTML đã được lấy thành công qua proxy. Đang truyền cho Perplexity AI...")
            product_info = extract_structured_data_with_perplexity(html, ProductDetails)
            if product_info:
                print("\n--- Chi Tiết Sản Phẩm Đã Trích Xuất (qua Proxy) ---")
                print(f"Tên: {product_info.name}")
                print(f"Giá: {product_info.price}")
                print(f"Mô tả: {product_info.description}")
                print(f"Đầu Ra JSON: {product_info.model_dump_json(indent=2)}")
            else:
                print("Không thể trích xuất thông tin sản phẩm.")
        else:
            print("Không thể lấy HTML qua proxy.")
        ```

    Giải pháp này nhấn mạnh sự kết hợp giữa mạng proxy và Perplexity AI. Các proxy đảm bảo truy cập đáng tin cậy vào các trang web mục tiêu, ngay cả những trang có biện pháp chống bot nghiêm ngặt, trong khi Perplexity AI xử lý việc trích xuất thông minh dữ liệu từ nội dung đã lấy. Sự kết hợp này rất quan trọng cho các hoạt động c scraping web quy mô lớn và mạnh mẽ, cho phép bạn thu thập dữ liệu từ nhiều nguồn hơn mà không bị chặn hoặc giới hạn tần suất. Để quản lý proxy nâng cao hơn, hãy cân nhắc sử dụng một API c scraping web chuyên dụng như Scrapeless, tích hợp xoay vòng proxy, giải quyết CAPTCHA và khả năng trình duyệt không đầu vào một dịch vụ duy nhất dễ sử dụng.

### 5. Tự Động Hóa Xác Định Chọn Lọc với Perplexity AI

Một trong những khía cạnh dễ gặp phải vấn đề nhất của c scraping web truyền thống là sự phụ thuộc vào các bộ chọn CSS hoặc biểu thức XPath được mã hóa cứng. Giải pháp này chứng minh cách Perplexity AI có thể xác định các bộ chọn một cách động, giúp các công cụ c scraping linh hoạt hơn trước những thay đổi của trang web.

*   **Mô tả:** Thay vì kiểm tra thủ công một trang web để tìm các bộ chọn đúng cho các phần tử như tên sản phẩm hoặc giá, Perplexity AI có thể được yêu cầu với HTML gốc và hỏi để xác định các bộ chọn CSS thích hợp. Khả năng này đặc biệt mạnh mẽ vì nó cho phép công cụ c scraping thích nghi với những thay đổi nhỏ trong bố cục mà không cần thay đổi mã. AI hoạt động như một bộ tạo chọn lọc thông minh, cung cấp các giá trị `str` cần thiết mà sau đó có thể được sử dụng bởi các thư viện như BeautifulSoup để trích xuất chính xác.

*   **Ví dụ Mã/Bước:**

    1.  **Cài đặt các thư viện cần thiết:**

        ```bash
        pip install openai requests pydantic instructor beautifulsoup4
        ```

    2.  **Thiết lập khóa API Perplexity AI của bạn** (như trong các giải pháp trước).

    3.  **Viết script Python:**

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor
        from bs4 import BeautifulSoup

        # Thiết lập khóa API Perplexity AI của bạn
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Vá khách hàng OpenAI với instructor cho đầu ra có cấu trúc

    # Định nghĩa một mô hình Pydantic cho các bộ chọn mà chúng ta muốn Perplexity xác định
    class ProductSelectors(BaseModel):
        name_selector: str
        price_selector: str
        description_selector: str

    def fetch_html(url):
        """Lấy nội dung HTML của một URL nhất định."""
        try:
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            return response.text
        except requests.exceptions.RequestException as e:
            print(f"Lỗi khi lấy URL {url}: {e}")
            return None

    def get_selectors_with_perplexity(html_content):
        """Sử dụng Perplexity AI để xác định các bộ chọn CSS từ HTML."""
        if not html_content:
            return None
        
        try:
            selectors = client.chat.completions.create(
                model="sonar-small-online",
                response_model=ProductSelectors,
                messages=[
                    {"role": "system", "content": "Bạn là một trợ lý AI xác định các bộ chọn CSS từ nội dung HTML. Cung cấp bộ chọn CSS chính xác nhất cho các phần tử yêu cầu."},
                    {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nXác định các bộ chọn CSS cho tên sản phẩm, giá và mô tả."}
                ]
            )
            return selectors
        except Exception as e:
            print(f"Lỗi khi lấy bộ chọn với Perplexity AI: {e}")
            return None

    def extract_data_with_bs4(html_content, selectors: ProductSelectors):
        """Trích xuất dữ liệu bằng BeautifulSoup và các bộ chọn đã cung cấp."""
        soup = BeautifulSoup(html_content, 'html.parser')
        name = soup.select_one(selectors.name_selector).get_text(strip=True) if soup.select_one(selectors.name_selector) else "N/A"
        price = soup.select_one(selectors.price_selector).get_text(strip=True) if soup.select_one(selectors.price_selector) else "N/A"
        description = soup.select_one(selectors.description_selector).get_text(strip=True) if soup.select_one(selectors.description_selector) else "N/A"
        return {"name": name, "price": price, "description": description}

    # Ví dụ sử dụng
    target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
    html = fetch_html(target_url)

    if html:
        print("HTML đã được lấy. Đang hỏi Perplexity AI về các bộ chọn...")
        product_selectors = get_selectors_with_perplexity(html)
        if product_selectors:
            print("\n--- Bộ chọn đã xác định ---")
            print(f"Bộ chọn Tên: {product_selectors.name_selector}")
            print(f"Bộ chọn Giá: {product_selectors.price_selector}")
            print(f"Bộ chọn Mô tả: {product_selectors.description_selector}")
            
            print("\nTrích xuất dữ liệu bằng BeautifulSoup với các bộ chọn do AI xác định...")
            extracted_data = extract_data_with_bs4(html, product_selectors)
            print("\n--- Dữ liệu sản phẩm đã trích xuất ---")
            print(f"Tên sản phẩm: {extracted_data['name']}")
            print(f"Giá sản phẩm: {extracted_data['price']}")
            print(f"Mô tả sản phẩm: {extracted_data['description']}")
        else:
            print("Không thể lấy bộ chọn từ Perplexity AI.")
    else:
        print("Không thể lấy HTML.")
    
Giải pháp này nâng cao khả năng thích ứng của các trình thu thập dữ liệu của bạn. Bằng cách thu nhận động các bộ chọn, logic thu thập dữ liệu của bạn trở nên ít phụ thuộc vào cấu trúc trang web tĩnh, giảm thiểu bảo trì và cải thiện tuổi thọ của các pipeline trích xuất dữ liệu của bạn. Cách tiếp cận này đặc biệt có giá trị cho việc theo dõi các trang web thường xuyên có cập nhật thiết kế, đảm bảo dòng dữ liệu liên tục mà không cần can thiệp thủ công thường xuyên.

```python
html = fetch_html(next_url)
            if html:
                products_on_page, next_page_link = extract_products_and_pagination(html, next_url)
                all_products.extend(products_on_page)
                print(f"Đã tìm thấy {len(products_on_page)} sản phẩm trên trang {current_page}.")
                next_url = next_page_link
                current_page += 1
            else:
                print(f"Không thể lấy HTML cho {next_url}. Dừng lại.")
                break

        print("\n--- Tất cả sản phẩm đã trích xuất ---")
        for product in all_products:
            print(f"Tiêu đề: {product.title}, Giá: {product.price}, Liên kết: {product.link}")
        print(f"Tổng số sản phẩm đã trích xuất: {len(all_products)}")
        ```

    Giải pháp này cho thấy cách mà Perplexity AI có thể đơn giản hóa nhiệm vụ phức tạp của việc thu thập dữ liệu từ nhiều trang. Bằng cách nhận diện một cách thông minh cả dữ liệu và liên kết phân trang tiếp theo, nó giảm thiểu nhu cầu về logic tùy chỉnh cho từng sơ đồ phân trang độc đáo của từng trang web, làm cho các trình thu thập dữ liệu của bạn trở nên thích ứng và hiệu quả hơn cho việc thu thập dữ liệu quy mô lớn. Đây là một bước tiến quan trọng trong việc xây dựng các tác nhân thu thập dữ liệu tự động thực sự có khả năng điều hướng và trích xuất thông tin từ toàn bộ trang web.

### 8. Tích hợp Perplexity AI với Cloud Functions để thu thập dữ liệu có thể mở rộng

Đối với các tác vụ thu thập dữ liệu quy mô lớn, theo sự kiện hoặc theo lịch trình, việc tích hợp Perplexity AI với các chức năng điện toán đám mây không có máy chủ (ví dụ: AWS Lambda, Google Cloud Functions, Azure Functions) mang lại khả năng mở rộng và hiệu quả chi phí to lớn.

*   **Mô tả:** Các chức năng điện toán đám mây cho phép bạn chạy mã phản hồi với các sự kiện (như một mục mới xuất hiện trong hàng đợi hoặc một bộ đếm theo lịch) mà không cần cung cấp hoặc quản lý máy chủ. Bằng cách triển khai logic thu thập dữ liệu sử dụng Perplexity AI trong một chức năng điện toán đám mây, bạn có thể tạo ra các giải pháp thu thập dữ liệu có khả năng mở rộng cao và hiệu quả về chi phí. Mỗi lần gọi chức năng có thể xử lý một tác vụ thu thập dữ liệu đơn lẻ, tận dụng Perplexity AI để trích xuất dữ liệu thông minh, và tự động mở rộng để đáp ứng nhu cầu. Kiến trúc này rất lý tưởng cho việc xử lý một lượng lớn URL hoặc theo dõi liên tục nhiều trang web.

*   **Ví dụ/Một số bước:**

    1.  **Điều kiện tiên quyết:**
        *   Tài khoản AWS, Google Cloud hoặc Azure.
        *   Kiến thức về việc triển khai các chức năng không có máy chủ.
        *   Khóa API Perplexity AI được cấu hình một cách an toàn (ví dụ: thông qua các biến môi trường trong chức năng điện toán đám mây).

    2.  **Cài đặt thư viện cần thiết (cho phát triển địa phương và đóng gói):**

        ```bash
        pip install openai requests pydantic instructor
        ```

    3.  **Ví dụ (AWS Lambda với Python):**

        Tạo tệp `lambda_function.py`:

        ```python
        import json
        import os
        import requests
        from openai import OpenAI
        from pydantic import BaseModel
        import instructor

        # Khởi tạo khách hàng Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY")
        if not perplexity_api_key:
            raise ValueError("Biến môi trường PERPLEXITY_API_KEY chưa được thiết lập.")

        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductDetails(BaseModel):
            name: str
            price: str
            description: str

        def fetch_html(url):
            """Lấy nội dung HTML của một URL nhất định."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Lỗi khi lấy URL {url}: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Sử dụng Perplexity AI để trích xuất dữ liệu có cấu trúc từ HTML dựa trên mô hình Pydantic."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=target_model,
                    messages=[
                        {"role": "system", "content": "Bạn là một trợ lý AI trích xuất thông tin có cấu trúc từ nội dung HTML. Hãy trích xuất các chi tiết yêu cầu vào schema JSON được cung cấp."},
                        {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất các chi tiết sản phẩm sau: tên, giá, và mô tả."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Lỗi khi trích xuất dữ liệu có cấu trúc với Perplexity AI: {e}")
                return None

        def lambda_handler(event, context):
            """Biến xử lý hàm AWS Lambda."""
            print(f"Nhận sự kiện: {json.dumps(event)}")
            
            # Mong đợi 'url' trong payload sự kiện

target_url = event.get("url")
            if not target_url:
                return {
                    "statusCode": 400,
                    "body": json.dumps({"message": "Thiếu 'url' trong payload sự kiện"})
                }

            html = fetch_html(target_url)
            if html:
                product_info = extract_structured_data_with_perplexity(html, ProductDetails)
                if product_info:
                    return {
                        "statusCode": 200,
                        "body": product_info.model_dump_json(indent=2)
                    }
                else:
                    return {
                        "statusCode": 500,
                        "body": json.dumps({"message": "Không thể trích xuất thông tin sản phẩm."})
                    }
            else:
                return {
                    "statusCode": 500,
                    "body": json.dumps({"message": "Không thể lấy HTML."})
                }
        ```

    4.  **Các bước triển khai (Chung):**
        *   Đóng gói `lambda_function.py` của bạn cùng với tất cả các phụ thuộc (bao gồm `openai`, `requests`, `pydantic`, `instructor`) vào một gói triển khai (ví dụ: một tệp `.zip`).
        *   Tải gói lên nhà cung cấp đám mây mà bạn chọn (ví dụ: AWS Lambda).
        *   Cấu hình chức năng với bộ nhớ, thời gian chờ và biến môi trường phù hợp (đặc biệt là `PERPLEXITY_API_KEY`).
        *   Thiết lập các kích hoạt (ví dụ: API Gateway cho yêu cầu HTTP, SQS cho xử lý dựa trên hàng đợi, EventBridge cho các tác vụ theo lịch).

    Cách tiếp cận không máy chủ này cho phép bạn xây dựng các giải pháp trích xuất dữ liệu web có khả năng mở rộng cao, tiết kiệm chi phí và hướng theo sự kiện. Bằng cách chuyển giao việc thực thi cho các chức năng đám mây, bạn chỉ phải trả tiền cho thời gian tính toán thực tế được sử dụng, điều này làm cho nó lý tưởng cho khối lượng công việc biến động và việc thu thập dữ liệu quy mô lớn. Năng lực phân tích thông minh của Perplexity AI trong kiến trúc này đảm bảo rằng ngay cả với khối lượng cao, dữ liệu trích xuất vẫn chính xác và có cấu trúc.



### 9. Xử lý lỗi và độ bền trong việc Scraping với Perplexity AI

Xây dựng các công cụ trích xuất dữ liệu web bền vững yêu cầu xử lý lỗi tổng quát để quản lý một cách duyên dáng các vấn đề về mạng, thay đổi trang web và lỗi API. Giải pháp này phác thảo các chiến lược để làm cho các công cụ trích xuất dữ liệu được hỗ trợ bởi Perplexity AI bền vững hơn.

*   **Mô tả:** Ngay cả với Perplexity AI, các vấn đề không mong đợi có thể xảy ra trong quá trình trích xuất dữ liệu web. Việc triển khai xử lý lỗi đúng cách đảm bảo rằng công cụ trích xuất của bạn không bị sập và có thể phục hồi hoặc ghi lại các lỗi một cách hiệu quả. Điều này bao gồm việc xử lý lỗi HTTP, thời gian chờ mạng, lỗi API của Perplexity AI, và các trường hợp mà AI có thể không trích xuất dữ liệu như mong muốn. Các chiến lược bao gồm cơ chế thử lại, phân tích dự phòng và ghi chép chi tiết.

*   **Ví dụ/Thao tác mã:**

    1.  **Cài đặt các thư viện cần thiết:**

        ```bash
        pip install openai requests pydantic instructor tenacity
        ```

    2.  **Thiết lập khóa API của Perplexity AI** (như trong các giải pháp trước).

    3.  **Viết kịch bản Python:** Ví dụ này kết hợp `tenacity` cho logic thử lại mạnh mẽ và xử lý lỗi toàn diện hơn.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor
        from tenacity import retry, stop_after_attempt, wait_fixed, retry_if_exception_type
        import logging

        # Cấu hình ghi chép
        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

        # Đặt khóa API của Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Đắp OpenAI client bằng instructor để có đầu ra có cấu trúc
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductDetails(BaseModel):
            name: str | None = None
            price: str | None = None
            description: str | None = None

        # Decorator thử lại cho các yêu cầu mạng
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), retry=retry_if_exception_type(requests.exceptions.RequestException))
        def fetch_html_robust(url):
            """Lấy nội dung HTML của một URL cho trước với các lần thử lại."""
            logging.info(f"Đang cố gắng lấy HTML từ {url}")
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            return response.text

        # Decorator thử lại cho các cuộc gọi Perplexity AI
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(5), retry=retry_if_exception_type(Exception))
        def extract_structured_data_robust(html_content, target_model: BaseModel):
            """Sử dụng Perplexity AI để trích xuất dữ liệu có cấu trúc từ HTML với các lần thử lại."""
            if not html_content:
                logging.warning("Không có nội dung HTML nào được cung cấp để trích xuất.")
                return None

logging.info("Đang cố gắng trích xuất dữ liệu với Perplexity AI.")
            extracted_data = client.chat.completions.create(
                model="sonar-small-online",
                response_model=target_model,
                messages=[
                    {"role": "system", "content": "Bạn là một trợ lý AI giúp trích xuất thông tin có cấu trúc từ nội dung HTML. Trích xuất các chi tiết yêu cầu vào định dạng JSON được cung cấp."},
                    {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất các chi tiết sản phẩm sau: tên, giá và mô tả."}
                ]
            )
            return extracted_data

        # Ví dụ Sử Dụng
        target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        # Ví dụ về một URL có thể gặp lỗi (ví dụ: 404 hoặc lỗi mạng)
        # failing_url = "https://www.example.com/non-existent-page"

        print(f"\n--- Đang xử lý {target_url} ---")
        try:
            html = fetch_html_robust(target_url)
            if html:
                product_info = extract_structured_data_robust(html, ProductDetails)
                if product_info:
                    print("\n--- Chi tiết sản phẩm đã trích xuất ---")
                    print(f"Tên: {product_info.name}")
                    print(f"G giá: {product_info.price}")
                    print(f"Mô tả: {product_info.description}")
                else:
                    logging.error("Perplexity AI đã thất bại trong việc trích xuất dữ liệu sau nhiều lần thử.")
            else:
                logging.error("Không thể lấy HTML sau nhiều lần thử.")
        except Exception as e:
            logging.critical(f"Lỗi nghiêm trọng trong quá trình cào dữ liệu cho {target_url}: {e}")

        # Ví dụ với một URL có thể gặp lỗi (bỏ chú thích để kiểm tra)
        # print(f"\n--- Đang xử lý {failing_url} ---")
        # try:
        #     html_failing = fetch_html_robust(failing_url)
        #     if html_failing:
        #         product_info_failing = extract_structured_data_robust(html_failing, ProductDetails)
        #         if product_info_failing:
        #             print("\n--- Chi tiết sản phẩm đã trích xuất (URL gặp lỗi) ---")
        #             print(f"Tên: {product_info_failing.name}")
        #             print(f"G giá: {product_info_failing.price}")
        #             print(f"Mô tả: {product_info_failing.description}")
        #         else:
        #             logging.error("Perplexity AI đã thất bại trong việc trích xuất dữ liệu từ URL gặp lỗi sau nhiều lần thử.")
        #     else:
        #         logging.error("Không thể lấy HTML từ URL gặp lỗi sau nhiều lần thử.")
        # except Exception as e:
        #     logging.critical(f"Lỗi nghiêm trọng trong quá trình cào dữ liệu cho {failing_url}: {e}")
        ```

Giải pháp này nhấn mạnh tầm quan trọng của việc xây dựng tính mạnh mẽ vào hoạt động cào dữ liệu của bạn. Bằng cách triển khai cơ chế thử lại, xử lý lỗi toàn diện và ghi nhật ký chi tiết, bạn có thể tạo ra các trình cào dữ liệu sử dụng Perplexity AI đáng tin cậy hơn và ít bị gián đoạn hơn. Điều này rất quan trọng để duy trì các luồng dữ liệu liên tục và đảm bảo tính toàn vẹn của dữ liệu thu thập được, ngay cả trong điều kiện môi trường web không ổn định.

### 10. Biến đổi và làm sạch dữ liệu nâng cao với Perplexity AI

Dữ liệu trích xuất thô thường cần được biến đổi và làm sạch thêm trước khi có thể được sử dụng hiệu quả. Perplexity AI có thể được tận dụng để tự động hóa những quy trình sau khi trích xuất này, đảm bảo chất lượng và tính nhất quán của dữ liệu.

* **Mô tả:** Sau khi trích xuất dữ liệu ban đầu, dữ liệu có thể ở định dạng không đồng nhất, chứa tiếng ồn hoặc cần được làm phong phú (ví dụ: chuyển đổi tiền tệ, chuẩn hóa ngày tháng, phân loại văn bản). Perplexity AI, với khả năng hiểu ngôn ngữ tự nhiên mạnh mẽ của mình, có thể được sử dụng để thực hiện những nhiệm vụ biến đổi và làm sạch nâng cao này. Bằng cách cung cấp cho AI dữ liệu đã trích xuất và các hướng dẫn rõ ràng, nó có thể định dạng lại, làm sạch, và thậm chí làm phong phú dữ liệu, chuẩn bị cho việc phân tích hoặc lưu trữ. Điều này giảm thiểu cần thiết cho các kịch bản làm sạch dựa trên quy tắc phức tạp và làm cho quy trình dữ liệu trở nên linh hoạt hơn.

* **Ví dụ/ Các bước mã:**

    1. **Cài đặt các thư viện cần thiết:**

        ```bash
        pip install openai requests pydantic instructor
        ```

    2. **Thiết lập khóa API Perplexity AI của bạn** (như trong các giải pháp trước).

    3. **Viết mã Python:** Ví dụ này minh họa việc làm sạch và chuẩn hóa thông tin sản phẩm.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel, Field
        import instructor

        # Thiết lập khóa API Perplexity AI của bạn
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "KHÓA_API_PERPLEXITY_CỦA_BẠN")

        # Bổ sung client OpenAI với instructor cho đầu ra có cấu trúc
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

    lớp CleanedProductDetails(BaseModel):
        tên_sản_phẩm: str
        giá_usd: float
        tóm_tắt_mô_tả: str
        danh_mục: str

    def fetch_html(url):
        """Lấy nội dung HTML của URL đã cho."""
        try:
            phản_hồi = requests.get(url, timeout=10)
            phản_hồi.raise_for_status()
            return phản_hồi.text
        except requests.exceptions.RequestException as e:
            print(f"Có lỗi khi lấy URL {url}: {e}")
            return None

    def extract_raw_data_with_perplexity(html_content):
        """Sử dụng Perplexity AI để trích xuất dữ liệu thô từ HTML."""
        if not html_content:
            return None
        
        try:
            raw_data = client.chat.completions.create(
                model="sonar-small-online",
                response_model=RawProductDetails,
                messages=[
                    {"role": "system", "content": "Bạn là một trợ lý AI trích xuất thông tin sản phẩm thô từ nội dung HTML. Trích xuất tên, giá và mô tả."},
                    {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất tên sản phẩm, chuỗi giá thô, và mô tả thô của nó."}
                ]
            )
            return raw_data
        except Exception as e:
            print(f"Có lỗi khi trích xuất dữ liệu thô với Perplexity AI: {e}")
            return None

    def transform_and_clean_data_with_perplexity(raw_data: RawProductDetails):
        """Sử dụng Perplexity AI để chuyển đổi và làm sạch dữ liệu thô đã trích xuất."""
        if not raw_data:
            return None
        
        transformation_prompt = f"Làm sạch và chuyển đổi dữ liệu sản phẩm sau thành định dạng có cấu trúc:\n\nTên sản phẩm: {raw_data.name}\nGiá thô: {raw_data.price_raw}\nMô tả thô: {raw_data.description_raw}\n\nHướng dẫn:\n1. Chuẩn hóa tên sản phẩm (ví dụ: loại bỏ khoảng trắng thừa, viết hoa).

Giải pháp này thể hiện sự đa dạng của Perplexity AI không chỉ dừng lại ở việc trích xuất. Bằng cách tận dụng khả năng ngôn ngữ tự nhiên để biến đổi và làm sạch dữ liệu, bạn có thể hợp lý hóa đáng kể quy trình làm việc sau khi thu thập dữ liệu. Cách tiếp cận này đặc biệt có lợi cho việc duy trì chất lượng dữ liệu cao, đảm bảo tính nhất quán giữa các nguồn dữ liệu đa dạng, và chuẩn bị dữ liệu để sử dụng ngay lập tức trong phân tích, các mô hình học máy hoặc bảng điều khiển thông minh. Nó biến đổi dữ liệu web thô, lộn xộn thành những thông tin hữu ích, sạch sẽ với sự can thiệp thủ công tối thiểu.

### 8. Tích hợp Perplexity AI với Cloud Functions để thu thập dữ liệu quy mô lớn

Đối với các tác vụ thu thập dữ liệu quy mô lớn, theo sự kiện hoặc lên lịch, việc tích hợp Perplexity AI với các chức năng đám mây không máy chủ (ví dụ: AWS Lambda, Google Cloud Functions, Azure Functions) cung cấp khả năng mở rộng và hiệu quả chi phí rất lớn.

*   **Mô tả:** Các chức năng đám mây cho phép bạn chạy mã phản hồi theo các sự kiện (như có một mục mới xuất hiện trong hàng đợi hoặc một bộ hẹn giờ theo lịch) mà không cần cung cấp hoặc quản lý máy chủ. Bằng cách triển khai logic thu thập dữ liệu của Perplexity AI vào một chức năng đám mây, bạn có thể tạo ra những giải pháp thu thập dữ liệu có khả năng mở rộng cao và tiết kiệm chi phí. Mỗi lần gọi hàm có thể xử lý một tác vụ thu thập dữ liệu đơn lẻ, tận dụng Perplexity AI cho việc trích xuất dữ liệu thông minh, và tự động mở rộng để đáp ứng nhu cầu. Kiến trúc này rất lý tưởng cho việc xử lý khối lượng lớn URL hoặc theo dõi liên tục nhiều trang web.

*   **Ví dụ mã/Các bước:**

    1.  **Yêu cầu cần có:**
        *   Tài khoản AWS, Google Cloud hoặc Azure.
        *   Kiến thức về việc triển khai các chức năng không máy chủ.
        *   Khóa API Perplexity AI được cấu hình an toàn (ví dụ: thông qua các biến môi trường trong chức năng đám mây).

    2.  **Cài đặt các thư viện cần thiết (cho phát triển địa phương và gói):**

        ```bash
        pip install openai requests pydantic instructor
        ```

    3.  **Ví dụ (AWS Lambda với Python):**

        Tạo một tệp `lambda_function.py`:

        ```python
        import json
        import os
        import requests
        from openai import OpenAI
        from pydantic import BaseModel
        import instructor

        # Khởi tạo client Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY")
        if not perplexity_api_key:
            raise ValueError("Biến môi trường PERPLEXITY_API_KEY chưa được thiết lập.")

        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductDetails(BaseModel):
            name: str
            price: str
            description: str

        def fetch_html(url):
            """Lấy nội dung HTML của một URL cho trước."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Đã xảy ra lỗi khi lấy URL {url}: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Sử dụng Perplexity AI để trích xuất dữ liệu có cấu trúc từ HTML dựa trên một mô hình Pydantic."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=target_model,
                    messages=[
                        {"role": "system", "content": "Bạn là một trợ lý AI trích xuất thông tin có cấu trúc từ nội dung HTML. Trích xuất các chi tiết đã được yêu cầu vào schema JSON đã cung cấp."},
                        {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất các chi tiết sản phẩm sau: tên, giá và mô tả."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Đã xảy ra lỗi khi trích xuất dữ liệu có cấu trúc với Perplexity AI: {e}")
                return None

        def lambda_handler(event, context):
            """Bộ xử lý hàm AWS Lambda."""
            print(f"Đã nhận sự kiện: {json.dumps(event)}")
            
            # Mong đợi \'url\' trong tải trọng sự kiện
            target_url = event.get("url")
            if not target_url:
                return {
                    "statusCode": 400,
                    "body": json.dumps({"message": "Thiếu \'url\' trong tải trọng sự kiện"})
                }

            html = fetch_html(target_url)
            if html:
                product_info = extract_structured_data_with_perplexity(html, ProductDetails)
                if product_info:
                    return {
                        "statusCode": 200,
                        "body": product_info.model_dump_json(indent=2)
                    }
                else:
                    return {

"statusCode": 500,
                        "body": json.dumps({"message": "Không thể trích xuất thông tin sản phẩm."})
                    }
            else:
                return {
                    "statusCode": 500,
                    "body": json.dumps({"message": "Không thể truy cập HTML."})
                }
        ```

    4.  **Các bước triển khai (Chung):**
        *   Đóng gói `lambda_function.py` cùng với tất cả các phụ thuộc của nó (bao gồm `openai`, `requests`, `pydantic`, `instructor`) vào một gói triển khai (ví dụ: một tệp `.zip`).
        *   Tải gói lên nhà cung cấp đám mây mà bạn đã chọn (ví dụ: AWS Lambda).
        *   Cấu hình chức năng với bộ nhớ, thời gian chờ, và các biến môi trường phù hợp (đặc biệt là `PERPLEXITY_API_KEY`).
        *   Thiết lập các kích hoạt (ví dụ: API Gateway cho các yêu cầu HTTP, SQS cho xử lý dựa trên hàng đợi, EventBridge cho các tác vụ theo lịch).

    Cách tiếp cận không máy chủ này cho phép bạn xây dựng các giải pháp thu thập thông tin web có khả năng mở rộng cao, tiết kiệm chi phí và dựa trên sự kiện. Bằng cách chuyển giao thực thi cho các chức năng đám mây, bạn chỉ phải trả cho thời gian tính toán thực tế sử dụng, điều này lý tưởng cho các khối lượng công việc dao động và việc thu thập dữ liệu quy mô lớn. Khả năng phân tích thông minh của Perplexity AI trong kiến trúc này đảm bảo rằng ngay cả với khối lượng lớn, dữ liệu được trích xuất vẫn chính xác và có cấu trúc.

### 9. Xử lý lỗi và độ ổn định trong việc thu thập dữ liệu Perplexity AI

Xây dựng các bộ thu thập thông tin web đáng tin cậy yêu cầu xử lý lỗi toàn diện để quản lý hiệu quả các vấn đề mạng, thay đổi trang web và lỗi API. Giải pháp này phác thảo các chiến lược để tăng cường độ bền cho các bộ thu thập dữ liệu do Perplexity AI cung cấp.

*   **Mô tả:** Ngay cả với Perplexity AI, các vấn đề bất ngờ có thể phát sinh trong quá trình thu thập thông tin web. Thực hiện xử lý lỗi đúng cách đảm bảo rằng bộ thu thập của bạn không bị sập và có thể phục hồi hoặc ghi lại các lỗi một cách hiệu quả. Điều này bao gồm xử lý các lỗi HTTP, thời gian chờ mạng, lỗi API Perplexity AI và những trường hợp mà AI có thể không trích xuất dữ liệu như mong đợi. Các chiến lược bao gồm cơ chế thử lại, phân tích dự phòng và ghi lại chi tiết.

*   **Ví dụ mã/ Các bước:**

    1.  **Cài đặt các thư viện cần thiết:**

        ```bash
        pip install openai requests pydantic instructor tenacity
        ```

    2.  **Thiết lập khóa API Perplexity AI của bạn** (như trong các giải pháp trước).

    3.  **Viết đoạn mã Python:** Ví dụ này tích hợp `tenacity` cho logic thử lại đáng tin cậy và xử lý lỗi toàn diện hơn.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor
        from tenacity import retry, stop_after_attempt, wait_fixed, retry_if_exception_type
        import logging

        # Cấu hình ghi nhật ký
        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

        # Đặt khóa API Perplexity AI của bạn
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Cập nhật client OpenAI với instructor để có đầu ra có cấu trúc
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductDetails(BaseModel):
            name: str | None = None
            price: str | None = None
            description: str | None = None

        # Thử lại decorator cho các yêu cầu mạng
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), retry=retry_if_exception_type(requests.exceptions.RequestException))
        def fetch_html_robust(url):
            """Lấy nội dung HTML của một URL đã cho với các lần thử lại."""
            logging.info(f"Đang cố gắng lấy HTML từ {url}")
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            return response.text

        # Thử lại decorator cho các cuộc gọi Perplexity AI
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(5), retry=retry_if_exception_type(Exception))
        def extract_structured_data_robust(html_content, target_model: BaseModel):
            """Sử dụng Perplexity AI để trích xuất dữ liệu có cấu trúc từ HTML với các lần thử lại."""
            if not html_content:
                logging.warning("Không có nội dung HTML nào được cung cấp để trích xuất.")
                return None
            
            logging.info("Đang cố gắng trích xuất dữ liệu với Perplexity AI.")
            extracted_data = client.chat.completions.create(
                model="sonar-small-online",
                response_model=target_model,
                messages=[
                    {"role": "system", "content": "Bạn là một trợ lý AI trích xuất thông tin có cấu trúc từ nội dung HTML. Trích xuất các chi tiết yêu cầu vào sơ đồ JSON đã cung cấp."},
                    {"role": "user", "content": f"Nội dung HTML: {html_content}\n\nTrích xuất các chi tiết sản phẩm sau: tên, giá và mô tả."}
                ]
            )
            return extracted_data

    target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
    # Ví dụ về một URL có thể gặp lỗi (ví dụ: 404 hoặc lỗi mạng)
    # failing_url = "https://www.example.com/non-existent-page"

    print(f"\n--- Đang xử lý {target_url} ---")
    try:
        html = fetch_html_robust(target_url)
        if html:
            product_info = extract_structured_data_robust(html, ProductDetails)
            if product_info:
                print("\n--- Thông Tin Sản Phẩm Được Trích Xuất ---")
                print(f"Tên: {product_info.name}")
                print(f"Giá: {product_info.price}")
                print(f"Mô tả: {product_info.description}")
            else:
                logging.error("Perplexity AI không thể trích xuất dữ liệu sau nhiều lần thử.")
        else:
            logging.error("Không thể lấy HTML sau nhiều lần thử.")
    except Exception as e:
        logging.critical(f"Lỗi nghiêm trọng trong quá trình thu thập dữ liệu cho {target_url}: {e}")

    # Ví dụ với một URL có khả năng gây lỗi (bỏ chú thích để thử nghiệm)
    # print(f"\n--- Đang xử lý {failing_url} ---")
    # try:
    #     html_failing = fetch_html_robust(failing_url)
    #     if html_failing:
    #         product_info_failing = extract_structured_data_robust(html_failing, ProductDetails)
    #         if product_info_failing:
    #             print("\n--- Thông Tin Sản Phẩm Được Trích Xuất (URL Gặp Lỗi) ---")
    #             print(f"Tên: {product_info_failing.name}")
    #             print(f"Giá: {product_info_failing.price}")
    #             print(f"Mô tả: {product_info_failing.description}")
    #         else:
    #             logging.error("Perplexity AI không thể trích xuất dữ liệu từ URL gặp lỗi sau nhiều lần thử.")
    #     else:
    #         logging.error("Không thể lấy HTML từ URL gặp lỗi sau nhiều lần thử.")
    # except Exception as e:
    #     logging.critical(f"Lỗi nghiêm trọng trong quá trình thu thập dữ liệu cho {failing_url}: {e}")

Giải pháp này nhấn mạnh tầm quan trọng của việc xây dựng khả năng chống chịu trong các hoạt động thu thập dữ liệu của bạn. Bằng cách triển khai các cơ chế thử lại, xử lý lỗi toàn diện và ghi nhật ký chi tiết, bạn có thể tạo ra các trình thu thập dữ liệu sử dụng Perplexity AI mà đáng tin cậy hơn và ít bị gián đoạn hơn. Điều này là rất quan trọng để duy trì dòng dữ liệu liên tục và đảm bảo tính toàn vẹn của dữ liệu bạn thu thập, ngay cả khi đối diện với các môi trường web khó lường.