axetract 0.1.0__tar.gz

axetract-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Abdelrahman Mansour, Khaled Alshaer]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

axetract-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.3
+Name: axetract
+Version: 0.1.0
+Summary: Low-Cost Cross-Domain Web Structured Information Extraction using specialized LoRA adapters.
+Keywords: web-extraction,llm,structured-data,html-pruning,lora,vllm
+Author: Abdelrahman Mansour, Khaled Alshaer
+Author-email: Abdelrahman Mansour <abdelrahman.f.mansour@gmail.com>, Khaled Alshaer <khaled.w.alshaer@gmail.com>
+License: MIT License
+         
+         Copyright (c) [2026] [Abdelrahman Mansour, Khaled Alshaer]
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: fastapi>=0.135.1
+Requires-Dist: html-chunking>=0.0.4
+Requires-Dist: htmlrag>=0.1.1
+Requires-Dist: json-repair>=0.58.1
+Requires-Dist: peft>=0.18.1
+Requires-Dist: pydantic>=2.13.0b2
+Requires-Dist: torch>=2.9.1
+Requires-Dist: transformers>=4.57.6
+Requires-Dist: uvicorn>=0.41.0
+Requires-Dist: vllm>=0.16.0 ; extra == 'vllm'
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/abdo-Mansour/axetract
+Project-URL: Documentation, https://abdo-mansour.github.io/axetract/
+Project-URL: Issue Tracker, https://github.com/abdo-Mansour/axetract/issues
+Provides-Extra: vllm
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="docs/assets/logo-white-mode.svg#gh-light-mode-only" alt="AXEtract Logo" width="400">
+  <img src="docs/assets/logo-black-mode.svg#gh-dark-mode-only" alt="AXEtract Logo" width="400">
+  <h1>AXEtract</h1>
+  <h3>Low-Cost Cross-Domain Web Structured Information Extraction</h3>
+
+[!\[Documentation\](https://img.shields.io/badge/docs-latest-teal null)](https://abdo-mansour.github.io/axetract/)
+[!\[License: MIT\](https://img.shields.io/badge/License-MIT-yellow.svg null)](https://opensource.org/licenses/MIT)
+[!\[GitHub\](https://img.shields.io/github/stars/abdo-Mansour/axetract?style=social null)](https://github.com/abdo-Mansour/axetract)
+
+</div>
+
+***
+
+**AXEtract** is a high-performance, low-cost framework for extracting structured data from web pages. Based on the paper **"AXE: Low-Cost Cross-Domain Web Structured Information Extraction"**, it optimizes the extraction pipeline by using specialized LoRA adapters for pruning and query-specific extraction, enabling state-of-the-art results with small models (e.g., Qwen3-0.6B).
+
+## 🚀 Key Features
+
+- **🎯 Specialized LoRA Adapters**: Uses task-specific adapters for DOM pruning and structured extraction, achieving high accuracy with minimal token overhead.
+- **✂️ Smart DOM Pruning**: Classifies and prunes irrelevant HTML nodes before passing them to the extractor, significantly reducing context window usage and costs.
+- **📍 Grounded XPath Resolution (GXR)**: Automatically maps extracted JSON fields back to their original source XPaths in the DOM for verification and grounding.
+- **⚡ High-Throughput Pipeline**: Built-in support for multiple LLM engines, including **vLLM** for production-grade serving and **HuggingFace** for local research.
+- **🌐 Cross-Domain Versatility**: Designed to generalize across various web domains (e-commerce, real estate, listings) without needing domain-specific rules.
+
+## 🛠️ Architecture
+
+AXEtract follows a three-part decoupled pipeline for maximum efficiency:
+
+1. **Preprocessor**: Fetches raw HTML and chunks it into manageable, token-aware fragments.
+2. **AI Extractor**: Divided into two stages:
+   - **Pruner**: A lightweight LLM (LoRA-powered) filters out noise and selects only relevant HTML chunks.
+   - **Extractor**: A task-specific LLM maps the pruned HTML content directly to a structured JSON schema or natural language answer.
+3. **Postprocessor**: Validates the output and resolves source XPaths via Grounded XPath Resolution (GXR).
+
+## 📦 Installation
+
+```bash
+# Install from PyPI
+uv pip install axetract
+
+# Or install from source
+git clone https://github.com/abdo-Mansour/axetract.git
+cd axetract
+uv sync
+```
+
+## 🚥 Quick Start
+
+```python
+from pydantic import BaseModel
+from axetract.pipeline import AXEPipeline
+
+# 1. Initialize the pipeline with default LoRA adapters
+# (Automatically downloads adapters from HuggingFace Hub)
+pipeline = AXEPipeline.from_config(use_vllm=False)
+
+# 2. Define your desired extraction schema
+class Product(BaseModel):
+    name: str
+    price: str
+    rating: float
+
+# 3. Extract from a URL or raw HTML
+url = "https://example.com/item/12345"
+result = pipeline.extract(url, schema=Product)
+
+# 4. Access your structured data
+print(f"Status: {result.status}")
+print(f"Prediction: {result.prediction}")
+print(f"Source XPaths: {result.xpaths}")
+```
+
+## 🌐 API Server
+
+AXEtract includes a built-in FastAPI server for high-throughput serving. After installing the package, start it with the installed CLI entry point:
+
+```bash
+axe-server
+```
+
+Or via `python -m` for development installs:
+
+```bash
+python -m axetract.server
+```
+
+Configuration is done via environment variables:
+
+| Variable | Default | Description |
+|---|---|---|
+| `AXE_USE_VLLM` | `false` | Set to `true` to use vLLM backend |
+| `AXE_PORT` | `8000` | Port to listen on |
+| `AXE_HOST` | `0.0.0.0` | Host to bind to |
+| `AXE_LOG_FILE` | _(stderr)_ | Optional path to a log file |
+
+See `axe_server/client_example.py` for examples of interacting with the API via `requests`.
+
+## 📝 Citation
+
+If you use AXEtract in your research, please cite our paper:
+
+```bibtex
+@misc{mansour2026axe,
+      title={AXE: Low-Cost Cross-Domain Web Structured Information Extraction}, 
+      author={Abdelrahman Mansour and Khaled W. Alshaer and Moataz Elsaban},
+      year={2026},
+      eprint={2602.01838},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2602.01838}, 
+}
+```
+
+## 📜 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

axetract-0.1.0/README.md

@@ -0,0 +1,116 @@
+<div align="center">
+  <img src="docs/assets/logo-white-mode.svg#gh-light-mode-only" alt="AXEtract Logo" width="400">
+  <img src="docs/assets/logo-black-mode.svg#gh-dark-mode-only" alt="AXEtract Logo" width="400">
+  <h1>AXEtract</h1>
+  <h3>Low-Cost Cross-Domain Web Structured Information Extraction</h3>
+
+[!\[Documentation\](https://img.shields.io/badge/docs-latest-teal null)](https://abdo-mansour.github.io/axetract/)
+[!\[License: MIT\](https://img.shields.io/badge/License-MIT-yellow.svg null)](https://opensource.org/licenses/MIT)
+[!\[GitHub\](https://img.shields.io/github/stars/abdo-Mansour/axetract?style=social null)](https://github.com/abdo-Mansour/axetract)
+
+</div>
+
+***
+
+**AXEtract** is a high-performance, low-cost framework for extracting structured data from web pages. Based on the paper **"AXE: Low-Cost Cross-Domain Web Structured Information Extraction"**, it optimizes the extraction pipeline by using specialized LoRA adapters for pruning and query-specific extraction, enabling state-of-the-art results with small models (e.g., Qwen3-0.6B).
+
+## 🚀 Key Features
+
+- **🎯 Specialized LoRA Adapters**: Uses task-specific adapters for DOM pruning and structured extraction, achieving high accuracy with minimal token overhead.
+- **✂️ Smart DOM Pruning**: Classifies and prunes irrelevant HTML nodes before passing them to the extractor, significantly reducing context window usage and costs.
+- **📍 Grounded XPath Resolution (GXR)**: Automatically maps extracted JSON fields back to their original source XPaths in the DOM for verification and grounding.
+- **⚡ High-Throughput Pipeline**: Built-in support for multiple LLM engines, including **vLLM** for production-grade serving and **HuggingFace** for local research.
+- **🌐 Cross-Domain Versatility**: Designed to generalize across various web domains (e-commerce, real estate, listings) without needing domain-specific rules.
+
+## 🛠️ Architecture
+
+AXEtract follows a three-part decoupled pipeline for maximum efficiency:
+
+1. **Preprocessor**: Fetches raw HTML and chunks it into manageable, token-aware fragments.
+2. **AI Extractor**: Divided into two stages:
+   - **Pruner**: A lightweight LLM (LoRA-powered) filters out noise and selects only relevant HTML chunks.
+   - **Extractor**: A task-specific LLM maps the pruned HTML content directly to a structured JSON schema or natural language answer.
+3. **Postprocessor**: Validates the output and resolves source XPaths via Grounded XPath Resolution (GXR).
+
+## 📦 Installation
+
+```bash
+# Install from PyPI
+uv pip install axetract
+
+# Or install from source
+git clone https://github.com/abdo-Mansour/axetract.git
+cd axetract
+uv sync
+```
+
+## 🚥 Quick Start
+
+```python
+from pydantic import BaseModel
+from axetract.pipeline import AXEPipeline
+
+# 1. Initialize the pipeline with default LoRA adapters
+# (Automatically downloads adapters from HuggingFace Hub)
+pipeline = AXEPipeline.from_config(use_vllm=False)
+
+# 2. Define your desired extraction schema
+class Product(BaseModel):
+    name: str
+    price: str
+    rating: float
+
+# 3. Extract from a URL or raw HTML
+url = "https://example.com/item/12345"
+result = pipeline.extract(url, schema=Product)
+
+# 4. Access your structured data
+print(f"Status: {result.status}")
+print(f"Prediction: {result.prediction}")
+print(f"Source XPaths: {result.xpaths}")
+```
+
+## 🌐 API Server
+
+AXEtract includes a built-in FastAPI server for high-throughput serving. After installing the package, start it with the installed CLI entry point:
+
+```bash
+axe-server
+```
+
+Or via `python -m` for development installs:
+
+```bash
+python -m axetract.server
+```
+
+Configuration is done via environment variables:
+
+| Variable | Default | Description |
+|---|---|---|
+| `AXE_USE_VLLM` | `false` | Set to `true` to use vLLM backend |
+| `AXE_PORT` | `8000` | Port to listen on |
+| `AXE_HOST` | `0.0.0.0` | Host to bind to |
+| `AXE_LOG_FILE` | _(stderr)_ | Optional path to a log file |
+
+See `axe_server/client_example.py` for examples of interacting with the API via `requests`.
+
+## 📝 Citation
+
+If you use AXEtract in your research, please cite our paper:
+
+```bibtex
+@misc{mansour2026axe,
+      title={AXE: Low-Cost Cross-Domain Web Structured Information Extraction}, 
+      author={Abdelrahman Mansour and Khaled W. Alshaer and Moataz Elsaban},
+      year={2026},
+      eprint={2602.01838},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2602.01838}, 
+}
+```
+
+## 📜 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

axetract-0.1.0/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "axetract"
+version = "0.1.0"
+description = "Low-Cost Cross-Domain Web Structured Information Extraction using specialized LoRA adapters."
+readme = "README.md"
+requires-python = ">=3.12"
+license = { file = "LICENSE" }
+authors = [
+    {name="Abdelrahman Mansour", email = "abdelrahman.f.mansour@gmail.com"},
+    {name="Khaled Alshaer", email = "khaled.w.alshaer@gmail.com"},
+]
+keywords = ["web-extraction", "llm", "structured-data", "html-pruning", "lora", "vllm"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "fastapi>=0.135.1",
+    "html-chunking>=0.0.4",
+    "htmlrag>=0.1.1",
+    "json-repair>=0.58.1",
+    "peft>=0.18.1",
+    "pydantic>=2.13.0b2",
+    "torch>=2.9.1",
+    "transformers>=4.57.6",
+    "uvicorn>=0.41.0",
+]
+
+[project.optional-dependencies]
+vllm = [
+    "vllm>=0.16.0",
+]
+
+[project.urls]
+Repository = "https://github.com/abdo-Mansour/axetract"
+Documentation = "https://abdo-mansour.github.io/axetract/"
+"Issue Tracker" = "https://github.com/abdo-Mansour/axetract/issues"
+
+[project.scripts]
+axe-server = "axetract.server:main"
+
+[dependency-groups]
+dev = [
+    "mkdocs>=1.6.1,<2.0.0",
+    "pytest>=8.0.0",
+    "mkdocs-material>=9.7.3",
+    "mkdocs-autoapi[python]",
+    "mkdocstrings[python]>=1.0.3",
+    "ruff>=0.15.4",
+    "jupyter>=1.1.1",
+    "notebook>=7.5.4",
+    "ipywidgets>=8.1.8",
+]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "D"]
+ignore = ["D100", "D104", "E501"] # Ignore missing docstrings in modules and packages, and long lines
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["D1"] # Don't require docstrings in tests
+"*.ipynb" = ["W291"] # Ignore trailing whitespace in notebooks
+"*.py" = ["E402"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.isort]
+known-first-party = ["axetract"]
+
+[build-system]
+requires = ["uv_build>=0.10.6,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "axetract"
+module-root = "src"

axetract-0.1.0/src/axetract/__init__.py

@@ -0,0 +1,13 @@
+"""AXEtract: Low-Cost Cross-Domain Web Structured Information Extraction."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from axetract.data_types import AXEResult, AXESample, Status
+from axetract.pipeline import AXEPipeline
+
+try:
+    __version__ = version("axetract")
+except PackageNotFoundError:  # editable install not yet built
+    __version__ = "unknown"
+
+__all__ = ["AXEPipeline", "AXESample", "AXEResult", "Status", "__version__"]

axetract-0.1.0/src/axetract/data_types.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+
+class Status(Enum):
+    """Execution status for a processing sample."""
+
+    PENDING = "pending"
+    SUCCESS = "success"
+    FAILED = "failed"
+
+
+class AXEChunk(BaseModel):
+    """A single chunk of HTML content.
+
+    Attributes:
+        chunkid (str): Unique identifier for the chunk.
+        content (str): The raw or cleaned HTML content.
+    """
+
+    chunkid: str
+    content: str
+
+
+class AXESample(BaseModel):
+    """A data container for a single extraction request throughout the pipeline.
+
+    Attributes:
+        id (str): Unique identifier for the sample.
+        content (str): Input content (URL or raw HTML).
+        is_content_url (bool): Whether the content is a URL.
+        query (Optional[str]): Natural language extraction query.
+        schema_model (Optional[Union[str, Type[BaseModel], dict]]): Desired JSON schema.
+        chunks (List[AXEChunk]): List of processed HTML chunks.
+        original_html (str): The original, uncleaned HTML content.
+        current_html (str): The current state of HTML (e.g., after cleaning or pruning).
+        prediction (Optional[Union[str, dict, Any]]): The LLM's raw output or parsed JSON.
+        xpaths (Optional[dict]): Map of extracted fields to their source XPaths.
+        status (Status): Current processing status.
+    """
+
+    id: str
+    content: str
+    is_content_url: bool
+    query: Optional[str] = None
+    schema_model: Optional[Union[str, Type[BaseModel], dict]] = None
+    chunks: List[AXEChunk] = []
+    original_html: str = ""
+    current_html: str = ""
+    prediction: Optional[Union[str, dict, Any]] = None
+    xpaths: Optional[dict] = None
+
+    status: Status = Status.PENDING
+
+
+class AXEResult(BaseModel):
+    """Final extraction result returned to the user.
+
+    Attributes:
+        id (str): Sample identifier.
+        prediction (Union[str, dict, Any]): The extracted structured data.
+        xpaths (Optional[dict]): Reference XPaths for the extracted values.
+        status (Status): Success or failure indicator.
+        error (Optional[str]): Error message if processing failed.
+    """
+
+    id: str
+    prediction: Union[str, dict, Any]
+    xpaths: Optional[dict] = None
+    status: Status
+    error: Optional[str] = None

axetract-0.1.0/src/axetract/exceptions.py

@@ -0,0 +1,43 @@
+"""Custom exceptions for the Axetract package."""
+
+
+class AXEError(Exception):
+    """Base class for all Axetract exceptions."""
+
+    pass
+
+
+class PreprocessingError(AXEError):
+    """Raised when an error occurs during the preprocessing stage."""
+
+    pass
+
+
+class PruningError(AXEError):
+    """Raised when an error occurs during the pruning stage."""
+
+    pass
+
+
+class ExtractionError(AXEError):
+    """Raised when an error occurs during the extraction stage."""
+
+    pass
+
+
+class PostprocessingError(AXEError):
+    """Raised when an error occurs during the postprocessing stage."""
+
+    pass
+
+
+class ModelLoadError(AXEError):
+    """Raised when an error occurs while loading an LLM model."""
+
+    pass
+
+
+class ConfigurationError(AXEError):
+    """Raised when there is an invalid configuration for the pipeline."""
+
+    pass

axetract-0.1.0/src/axetract/extractor/axe_extractor.py

@@ -0,0 +1,143 @@
+import json
+import logging
+from typing import List
+
+from pydantic import BaseModel
+
+from axetract.data_types import AXESample, Status
+from axetract.extractor.base_extractor import BaseExtractor
+from axetract.llm.base_client import BaseClient
+from axetract.utils.json_util import is_schema
+
+logger = logging.getLogger(__name__)
+
+
+class AXEExtractor(BaseExtractor):
+    """Component for extracting structured data from HTML using LLMs.
+
+    Attributes:
+        llm_extractor_client (BaseClient): The LLM client used for extraction.
+        schema_prompt_template (str): Template for schema-based extraction prompts.
+        query_prompt_template (str): Template for natural language query prompts.
+        name (str): Component name.
+        batch_size (int): Processing batch size.
+        num_workers (int): Number of parallel workers.
+    """
+
+    def __init__(
+        self,
+        llm_extractor_client: BaseClient,
+        schema_generation_prompt_template: str,
+        query_generation_prompt_template: str,
+        name: str = "axe_extractor",
+        batch_size: int = 16,
+        num_workers: int = 4,
+    ):
+        """Initialize the extractor.
+
+        Args:
+            llm_extractor_client (BaseClient): LLM client.
+            schema_generation_prompt_template (str): Schema prompt template.
+            query_generation_prompt_template (str): Query prompt template.
+            name (str): Component name.
+            batch_size (int): Batch size.
+            num_workers (int): Parallel workers.
+        """
+        self.llm_extractor_client = llm_extractor_client
+        self.name = name
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.schema_prompt_template = schema_generation_prompt_template
+        self.query_prompt_template = query_generation_prompt_template
+
+    def _generate_output(self, samples: List[AXESample]) -> List[AXESample]:
+
+        def build_prompt(data):
+            query = data.query or data.schema_model
+            content = data.current_html
+
+            # Convert Query/Schema to appropriate string if it is a dictionary or Pydantic model
+            if query is not None and not isinstance(query, str):
+                if isinstance(query, dict):
+                    query = json.dumps(query)
+                elif isinstance(query, type) and issubclass(query, BaseModel):
+                        # For Pydantic V2 use model_json_schema, for V1 use schema_json
+                        if hasattr(query, "model_json_schema"):
+                            query = json.dumps(query.model_json_schema())
+                        elif hasattr(query, "schema_json"):
+                            query = query.schema_json()
+
+            if is_schema(query):
+                return self.schema_prompt_template.format(query=query, content=content)
+            else:
+                return self.query_prompt_template.format(query=query, content=content)
+
+        prompts = [build_prompt(sample) for sample in samples]
+        queries = [sample.query or sample.schema_model for sample in samples]
+
+        # Storage for split batches
+        qa_indices = []
+        qa_prompts = []
+
+        schema_indices = []
+        schema_prompts = []
+
+        # 1. Split based on Query Type
+        for idx, (q, p) in enumerate(zip(queries, prompts)):
+            if is_schema(q):
+                schema_indices.append(idx)
+                schema_prompts.append(p)
+            else:
+                qa_indices.append(idx)
+                qa_prompts.append(p)
+
+        # Holder for final results in original order
+        final_responses = [None] * len(prompts)
+
+        # 2. Run QA Batch (Adapter: "qa")
+        if qa_prompts:
+            logger.debug("Processing %d QA queries...", len(qa_prompts))
+            for idx, (orig_idx, q) in enumerate(zip(qa_indices, queries)):
+                if not is_schema(q):
+                    logger.debug("  [QA] sample %d query: %s", orig_idx, q)
+                    logger.debug("  [QA] sample %d prompt: %s", orig_idx, qa_prompts[idx])
+            qa_responses = self.llm_extractor_client.call_batch(qa_prompts, adapter_name="qa")
+
+            for original_idx, response in zip(qa_indices, qa_responses):
+                logger.debug("  [QA] sample %d response: %s", original_idx, response)
+                final_responses[original_idx] = response
+
+        # 3. Run Schema Batch (Adapter: "schema")
+        if schema_prompts:
+            logger.debug("Processing %d Schema queries...", len(schema_prompts))
+            for idx, (orig_idx, q) in enumerate(zip(schema_indices, queries)):
+                if is_schema(q):
+                    logger.debug("  [Schema] sample %d schema: %s", orig_idx, q)
+                    logger.debug("  [Schema] sample %d prompt: %s", orig_idx, schema_prompts[idx])
+            schema_responses = self.llm_extractor_client.call_batch(
+                schema_prompts, adapter_name="schema"
+            )
+
+            for original_idx, response in zip(schema_indices, schema_responses):
+                logger.debug("  [Schema] sample %d response: %s", original_idx, response)
+                final_responses[original_idx] = response
+
+        for sample, response in zip(samples, final_responses):
+            sample.prediction = response
+            sample.status = Status.SUCCESS if response is not None else Status.FAILED
+            logger.debug("  [Extractor] sample %s final prediction: %s", sample.id, response)
+        return samples
+
+    def __call__(self, samples: List[AXESample]) -> List[AXESample]:
+        """Run the extraction process on a batch of samples.
+
+        Args:
+            samples (List[AXESample]): Input samples with clean HTML.
+
+        Returns:
+            List[AXESample]: Samples with LLM-generated predictions.
+        """
+        # Step 3: Generate (Optimized Parallel)
+        generated_samples = self._generate_output(samples)
+
+        return generated_samples