Upload 9 files

src/aibom_generator/__init__.py

@@ -0,0 +1,8 @@
+"""
+AIBOM Generator for Hugging Face Models.
+
+This package provides tools to generate AI Bills of Materials (AIBOMs) in CycloneDX format
+for machine learning models hosted on the Hugging Face Hub.
+"""
+
+__version__ = "0.1.0"

src/aibom_generator/api.py

@@ -0,0 +1,157 @@
+"""
+FastAPI server for the AIBOM Generator.
+"""
+
+import logging
+import os
+from typing import Dict, List, Optional, Any, Union
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from aibom_generator.generator import AIBOMGenerator
+from aibom_generator.utils import setup_logging, calculate_completeness_score
+
+# Set up logging
+setup_logging()
+logger = logging.getLogger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title="AIBOM Generator API",
+    description="API for generating AI Bills of Materials (AIBOMs) in CycloneDX format for Hugging Face models.",
+    version="0.1.0",
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Create generator instance
+generator = AIBOMGenerator(
+    hf_token=os.environ.get("HF_TOKEN"),
+    inference_model_url=os.environ.get("AIBOM_INFERENCE_URL"),
+    use_inference=os.environ.get("AIBOM_USE_INFERENCE", "true").lower() == "true",
+    cache_dir=os.environ.get("AIBOM_CACHE_DIR"),
+)
+
+
+# Define request and response models
+class GenerateRequest(BaseModel):
+    model_id: str
+    include_inference: Optional[bool] = None
+    completeness_threshold: Optional[int] = 0
+
+
+class GenerateResponse(BaseModel):
+    aibom: Dict[str, Any]
+    completeness_score: int
+    model_id: str
+
+
+class StatusResponse(BaseModel):
+    status: str
+    version: str
+
+
+# Define API endpoints
+@app.get("/", response_model=StatusResponse)
+async def root():
+    """Get API status."""
+    return {
+        "status": "ok",
+        "version": "0.1.0",
+    }
+
+
+@app.post("/generate", response_model=GenerateResponse)
+async def generate_aibom(request: GenerateRequest):
+    """Generate an AIBOM for a Hugging Face model."""
+    try:
+        # Generate the AIBOM
+        aibom = generator.generate_aibom(
+            model_id=request.model_id,
+            include_inference=request.include_inference,
+        )
+        
+        # Calculate completeness score
+        completeness_score = calculate_completeness_score(aibom)
+        
+        # Check if it meets the threshold
+        if completeness_score < request.completeness_threshold:
+            raise HTTPException(
+                status_code=400,
+                detail=f"AIBOM completeness score ({completeness_score}) is below threshold ({request.completeness_threshold})",
+            )
+        
+        return {
+            "aibom": aibom,
+            "completeness_score": completeness_score,
+            "model_id": request.model_id,
+        }
+    except Exception as e:
+        logger.error(f"Error generating AIBOM: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error generating AIBOM: {str(e)}",
+        )
+
+
+@app.post("/generate/async")
+async def generate_aibom_async(
+    request: GenerateRequest,
+    background_tasks: BackgroundTasks,
+):
+    """Generate an AIBOM asynchronously for a Hugging Face model."""
+    # Add to background tasks
+    background_tasks.add_task(
+        _generate_aibom_background,
+        request.model_id,
+        request.include_inference,
+        request.completeness_threshold,
+    )
+    
+    return {
+        "status": "accepted",
+        "message": f"AIBOM generation for {request.model_id} started in the background",
+    }
+
+
+async def _generate_aibom_background(
+    model_id: str,
+    include_inference: Optional[bool] = None,
+    completeness_threshold: Optional[int] = 0,
+):
+    """Generate an AIBOM in the background."""
+    try:
+        # Generate the AIBOM
+        aibom = generator.generate_aibom(
+            model_id=model_id,
+            include_inference=include_inference,
+        )
+        
+        # Calculate completeness score
+        completeness_score = calculate_completeness_score(aibom)
+        
+        # TODO: Store the result or notify the user
+        logger.info(f"Background AIBOM generation completed for {model_id}")
+        logger.info(f"Completeness score: {completeness_score}")
+    except Exception as e:
+        logger.error(f"Error in background AIBOM generation for {model_id}: {e}")
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 5000)))

src/aibom_generator/cli.py

@@ -0,0 +1,193 @@
+"""
+CLI interface for the AIBOM Generator.
+"""
+
+import argparse
+import json
+import os
+import sys
+from typing import Optional
+
+from aibom_generator.generator import AIBOMGenerator
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Generate AI Bills of Materials (AIBOMs) in CycloneDX format for Hugging Face models."
+    )
+    
+    parser.add_argument(
+        "model_id",
+        help="Hugging Face model ID (e.g., 'google/bert-base-uncased')"
+    )
+    
+    parser.add_argument(
+        "-o", "--output",
+        help="Output file path (default: <model_id>.aibom.json)",
+        default=None
+    )
+    
+    parser.add_argument(
+        "--token",
+        help="Hugging Face API token for accessing private models",
+        default=os.environ.get("HF_TOKEN")
+    )
+    
+    parser.add_argument(
+        "--inference-url",
+        help="URL of the inference model service for metadata extraction",
+        default=os.environ.get("AIBOM_INFERENCE_URL")
+    )
+    
+    parser.add_argument(
+        "--no-inference",
+        help="Disable inference model for metadata extraction",
+        action="store_true"
+    )
+    
+    parser.add_argument(
+        "--cache-dir",
+        help="Directory to cache API responses and model cards",
+        default=os.environ.get("AIBOM_CACHE_DIR", ".aibom_cache")
+    )
+    
+    parser.add_argument(
+        "--completeness-threshold",
+        help="Minimum completeness score (0-100) required for the AIBOM",
+        type=int,
+        default=0
+    )
+    
+    parser.add_argument(
+        "--format",
+        help="Output format (json or yaml)",
+        choices=["json", "yaml"],
+        default="json"
+    )
+    
+    parser.add_argument(
+        "--pretty",
+        help="Pretty-print the output",
+        action="store_true"
+    )
+    
+    return parser.parse_args()
+
+
+def main():
+    """Main entry point for the CLI."""
+    args = parse_args()
+    
+    # Determine output file if not specified
+    if not args.output:
+        model_name = args.model_id.replace("/", "_")
+        args.output = f"{model_name}.aibom.json"
+    
+    # Create the generator
+    generator = AIBOMGenerator(
+        hf_token=args.token,
+        inference_model_url=args.inference_url,
+        use_inference=not args.no_inference,
+        cache_dir=args.cache_dir
+    )
+    
+    try:
+        # Generate the AIBOM
+        aibom = generator.generate_aibom(
+            model_id=args.model_id,
+            output_file=None  # We'll handle saving ourselves
+        )
+        
+        # Calculate completeness score (placeholder for now)
+        completeness_score = calculate_completeness_score(aibom)
+        
+        # Check if it meets the threshold
+        if completeness_score < args.completeness_threshold:
+            print(f"Warning: AIBOM completeness score ({completeness_score}) is below threshold ({args.completeness_threshold})")
+        
+        # Save the output
+        save_output(aibom, args.output, args.format, args.pretty)
+        
+        print(f"AIBOM generated successfully: {args.output}")
+        print(f"Completeness score: {completeness_score}/100")
+        
+        return 0
+    
+    except Exception as e:
+        print(f"Error generating AIBOM: {e}", file=sys.stderr)
+        return 1
+
+
+def calculate_completeness_score(aibom):
+    """
+    Calculate a completeness score for the AIBOM.
+    
+    This is a placeholder implementation that will be replaced with a more
+    sophisticated scoring algorithm based on the field mapping framework.
+    """
+    # TODO: Implement proper completeness scoring
+    score = 0
+    
+    # Check required fields
+    if all(field in aibom for field in ["bomFormat", "specVersion", "serialNumber", "version"]):
+        score += 20
+    
+    # Check metadata
+    if "metadata" in aibom:
+        metadata = aibom["metadata"]
+        if "timestamp" in metadata:
+            score += 5
+        if "tools" in metadata and metadata["tools"]:
+            score += 5
+        if "authors" in metadata and metadata["authors"]:
+            score += 5
+        if "component" in metadata:
+            score += 5
+    
+    # Check components
+    if "components" in aibom and aibom["components"]:
+        component = aibom["components"][0]
+        if "type" in component and component["type"] == "machine-learning-model":
+            score += 10
+        if "name" in component:
+            score += 5
+        if "bom-ref" in component:
+            score += 5
+        if "licenses" in component:
+            score += 5
+        if "externalReferences" in component:
+            score += 5
+        if "modelCard" in component:
+            model_card = component["modelCard"]
+            if "modelParameters" in model_card:
+                score += 10
+            if "quantitativeAnalysis" in model_card:
+                score += 10
+            if "considerations" in model_card:
+                score += 10
+    
+    return score
+
+
+def save_output(aibom, output_file, format_type, pretty):
+    """Save the AIBOM to the specified output file."""
+    if format_type == "json":
+        with open(output_file, "w") as f:
+            if pretty:
+                json.dump(aibom, f, indent=2)
+            else:
+                json.dump(aibom, f)
+    else:  # yaml
+        try:
+            import yaml
+            with open(output_file, "w") as f:
+                yaml.dump(aibom, f, default_flow_style=False)
+        except ImportError:
+            print("Warning: PyYAML not installed. Falling back to JSON format.")
+            with open(output_file, "w") as f:
+                json.dump(aibom, f, indent=2 if pretty else None)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/aibom_generator/generator.py

@@ -0,0 +1,388 @@
+"""
+Core functionality for generating CycloneDX AIBOMs from Hugging Face models.
+"""
+
+import json
+import uuid
+import datetime
+from typing import Dict, List, Optional, Union, Any
+
+from huggingface_hub import HfApi, ModelCard, ModelCardData
+
+
+class AIBOMGenerator:
+    """
+    Generator for AI Bills of Materials (AIBOMs) in CycloneDX format.
+    
+    This class provides functionality to generate CycloneDX 1.6 compliant
+    AIBOMs for machine learning models hosted on the Hugging Face Hub.
+    """
+    
+    def __init__(
+        self,
+        hf_token: Optional[str] = None,
+        inference_model_url: Optional[str] = None,
+        use_inference: bool = True,
+        cache_dir: Optional[str] = None,
+    ):
+        """
+        Initialize the AIBOM Generator.
+        
+        Args:
+            hf_token: Hugging Face API token for accessing private models
+            inference_model_url: URL of the inference model service for extracting
+                                 metadata from unstructured text
+            use_inference: Whether to use the inference model for metadata extraction
+            cache_dir: Directory to cache API responses and model cards
+        """
+        self.hf_api = HfApi(token=hf_token)
+        self.inference_model_url = inference_model_url
+        self.use_inference = use_inference
+        self.cache_dir = cache_dir
+        
+    def generate_aibom(
+        self,
+        model_id: str,
+        output_file: Optional[str] = None,
+        include_inference: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """
+        Generate a CycloneDX AIBOM for the specified Hugging Face model.
+        
+        Args:
+            model_id: The Hugging Face model ID (e.g., "google/bert-base-uncased")
+            output_file: Optional path to save the generated AIBOM
+            include_inference: Override the default inference model usage setting
+            
+        Returns:
+            The generated AIBOM as a dictionary
+        """
+        # Determine whether to use inference
+        use_inference = include_inference if include_inference is not None else self.use_inference
+        
+        # Fetch model information
+        model_info = self._fetch_model_info(model_id)
+        model_card = self._fetch_model_card(model_id)
+        
+        # Generate the AIBOM
+        aibom = self._create_aibom_structure(model_id, model_info, model_card, use_inference)
+        
+        # Save to file if requested
+        if output_file:
+            with open(output_file, 'w') as f:
+                json.dump(aibom, f, indent=2)
+                
+        return aibom
+    
+    def _fetch_model_info(self, model_id: str) -> Dict[str, Any]:
+        """
+        Fetch model information from the Hugging Face API.
+        
+        Args:
+            model_id: The Hugging Face model ID
+            
+        Returns:
+            Model information as a dictionary
+        """
+        # TODO: Implement caching
+        try:
+            model_info = self.hf_api.model_info(model_id)
+            return model_info
+        except Exception as e:
+            # Log the error and return empty dict
+            print(f"Error fetching model info for {model_id}: {e}")
+            return {}
+    
+    def _fetch_model_card(self, model_id: str) -> Optional[ModelCard]:
+        """
+        Fetch the model card for the specified model.
+        
+        Args:
+            model_id: The Hugging Face model ID
+            
+        Returns:
+            ModelCard object if available, None otherwise
+        """
+        # TODO: Implement caching
+        try:
+            model_card = ModelCard.load(model_id)
+            return model_card
+        except Exception as e:
+            # Log the error and return None
+            print(f"Error fetching model card for {model_id}: {e}")
+            return None
+    
+    def _create_aibom_structure(
+        self,
+        model_id: str,
+        model_info: Dict[str, Any],
+        model_card: Optional[ModelCard],
+        use_inference: bool,
+    ) -> Dict[str, Any]:
+        """
+        Create the CycloneDX AIBOM structure.
+        
+        Args:
+            model_id: The Hugging Face model ID
+            model_info: Model information from the API
+            model_card: ModelCard object if available
+            use_inference: Whether to use inference for metadata extraction
+            
+        Returns:
+            CycloneDX AIBOM as a dictionary
+        """
+        # Extract structured metadata
+        metadata = self._extract_structured_metadata(model_id, model_info, model_card)
+        
+        # Extract unstructured metadata if requested and available
+        if use_inference and model_card and self.inference_model_url:
+            unstructured_metadata = self._extract_unstructured_metadata(model_card)
+            # Merge with structured metadata, giving priority to structured
+            metadata = {**unstructured_metadata, **metadata}
+        
+        # Create the AIBOM structure
+        aibom = {
+            "bomFormat": "CycloneDX",
+            "specVersion": "1.6",
+            "serialNumber": f"urn:uuid:{str(uuid.uuid4())}",
+            "version": 1,
+            "metadata": self._create_metadata_section(model_id, metadata),
+            "components": [self._create_component_section(model_id, metadata)],
+        }
+        
+        # Add external references if available
+        if "external_references" in metadata:
+            aibom["externalReferences"] = metadata["external_references"]
+        
+        return aibom
+    
+    def _extract_structured_metadata(
+        self,
+        model_id: str,
+        model_info: Dict[str, Any],
+        model_card: Optional[ModelCard],
+    ) -> Dict[str, Any]:
+        """
+        Extract structured metadata from model info and model card.
+        
+        Args:
+            model_id: The Hugging Face model ID
+            model_info: Model information from the API
+            model_card: ModelCard object if available
+            
+        Returns:
+            Structured metadata as a dictionary
+        """
+        metadata = {}
+        
+        # Extract from model_info
+        if model_info:
+            metadata.update({
+                "name": model_info.modelId.split("/")[-1] if hasattr(model_info, "modelId") else model_id.split("/")[-1],
+                "author": model_info.author if hasattr(model_info, "author") else None,
+                "tags": model_info.tags if hasattr(model_info, "tags") else [],
+                "pipeline_tag": model_info.pipeline_tag if hasattr(model_info, "pipeline_tag") else None,
+                "downloads": model_info.downloads if hasattr(model_info, "downloads") else 0,
+                "last_modified": model_info.lastModified if hasattr(model_info, "lastModified") else None,
+            })
+        
+        # Extract from model_card
+        if model_card and model_card.data:
+            card_data = model_card.data.to_dict() if hasattr(model_card.data, "to_dict") else {}
+            
+            # Map card data to metadata
+            metadata.update({
+                "language": card_data.get("language"),
+                "license": card_data.get("license"),
+                "library_name": card_data.get("library_name"),
+                "base_model": card_data.get("base_model"),
+                "datasets": card_data.get("datasets"),
+                "model_name": card_data.get("model_name"),
+                "tags": card_data.get("tags", metadata.get("tags", [])),
+            })
+            
+            # Extract evaluation results if available
+            if hasattr(model_card.data, "eval_results") and model_card.data.eval_results:
+                metadata["eval_results"] = model_card.data.eval_results
+        
+        return {k: v for k, v in metadata.items() if v is not None}
+    
+    def _extract_unstructured_metadata(self, model_card: ModelCard) -> Dict[str, Any]:
+        """
+        Extract metadata from unstructured text using the inference model.
+        
+        Args:
+            model_card: ModelCard object
+            
+        Returns:
+            Extracted metadata as a dictionary
+        """
+        # TODO: Implement inference model integration
+        # This is a placeholder that will be replaced with actual inference model calls
+        return {}
+    
+    def _create_metadata_section(self, model_id: str, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Create the metadata section of the CycloneDX AIBOM.
+        
+        Args:
+            model_id: The Hugging Face model ID
+            metadata: Extracted metadata
+            
+        Returns:
+            Metadata section as a dictionary
+        """
+        # Create timestamp
+        timestamp = datetime.datetime.utcnow().isoformat() + "Z"
+        
+        # Create tools section
+        tools = [{
+            "vendor": "AIBOM Generator",
+            "name": "aibom-generator",
+            "version": __import__("aibom_generator").__version__,
+        }]
+        
+        # Create authors section
+        authors = []
+        if "author" in metadata and metadata["author"]:
+            authors.append({
+                "name": metadata["author"],
+                "url": f"https://huggingface.co/{metadata['author']}"
+            })
+        
+        # Create component section (reference to the main component)
+        component = {
+            "type": "machine-learning-model",
+            "name": metadata.get("name", model_id.split("/")[-1]),
+            "bom-ref": f"pkg:huggingface/{model_id}",
+        }
+        
+        # Create properties section
+        properties = []
+        for key, value in metadata.items():
+            if key not in ["name", "author", "license"] and value is not None:
+                if isinstance(value, (list, dict)):
+                    value = json.dumps(value)
+                properties.append({
+                    "name": key,
+                    "value": str(value)
+                })
+        
+        # Assemble metadata section
+        metadata_section = {
+            "timestamp": timestamp,
+            "tools": tools,
+        }
+        
+        if authors:
+            metadata_section["authors"] = authors
+            
+        if component:
+            metadata_section["component"] = component
+            
+        if properties:
+            metadata_section["properties"] = properties
+            
+        return metadata_section
+    
+    def _create_component_section(self, model_id: str, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Create the component section of the CycloneDX AIBOM.
+        
+        Args:
+            model_id: The Hugging Face model ID
+            metadata: Extracted metadata
+            
+        Returns:
+            Component section as a dictionary
+        """
+        # Create basic component information
+        component = {
+            "type": "machine-learning-model",
+            "bom-ref": f"pkg:huggingface/{model_id}",
+            "name": metadata.get("name", model_id.split("/")[-1]),
+            "purl": f"pkg:huggingface/{model_id}",
+        }
+        
+        # Add description if available
+        if "description" in metadata:
+            component["description"] = metadata["description"]
+        
+        # Add version if available
+        if "version" in metadata:
+            component["version"] = metadata["version"]
+        
+        # Add license if available
+        if "license" in metadata:
+            component["licenses"] = [{
+                "license": {
+                    "id": metadata["license"]
+                }
+            }]
+        
+        # Add external references
+        component["externalReferences"] = [
+            {
+                "type": "website",
+                "url": f"https://huggingface.co/{model_id}"
+            }
+        ]
+        
+        # Add model card section
+        component["modelCard"] = self._create_model_card_section(metadata)
+        
+        return component
+    
+    def _create_model_card_section(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Create the modelCard section of the component.
+        
+        Args:
+            metadata: Extracted metadata
+            
+        Returns:
+            ModelCard section as a dictionary
+        """
+        model_card_section = {}
+        
+        # Add model parameters if available
+        model_parameters = {}
+        for param in ["base_model", "library_name", "pipeline_tag"]:
+            if param in metadata and metadata[param]:
+                model_parameters[param] = metadata[param]
+                
+        if model_parameters:
+            model_card_section["modelParameters"] = model_parameters
+        
+        # Add quantitative analysis if available
+        if "eval_results" in metadata:
+            model_card_section["quantitativeAnalysis"] = {
+                "performanceMetrics": metadata["eval_results"]
+            }
+        
+        # Add considerations if available
+        considerations = {}
+        for consideration in ["limitations", "ethical_considerations", "bias", "risks"]:
+            if consideration in metadata and metadata[consideration]:
+                considerations[consideration] = metadata[consideration]
+                
+        if considerations:
+            model_card_section["considerations"] = considerations
+        
+        # Add properties if available
+        properties = []
+        for key, value in metadata.items():
+            if key not in ["name", "author", "license", "base_model", "library_name", 
+                          "pipeline_tag", "eval_results", "limitations", 
+                          "ethical_considerations", "bias", "risks"] and value is not None:
+                if isinstance(value, (list, dict)):
+                    value = json.dumps(value)
+                properties.append({
+                    "name": key,
+                    "value": str(value)
+                })
+                
+        if properties:
+            model_card_section["properties"] = properties
+        
+        return model_card_section

src/aibom_generator/inference.py

@@ -0,0 +1,359 @@
+"""
+Inference model integration for extracting metadata from unstructured text.
+"""
+
+import json
+import logging
+import re
+import requests
+from typing import Dict, List, Optional, Any, Union
+
+logger = logging.getLogger(__name__)
+
+
+class InferenceModelClient:
+    """
+    Client for interacting with the inference model service to extract
+    metadata from unstructured text in model cards.
+    """
+    
+    def __init__(
+        self,
+        inference_url: str,
+        timeout: int = 30,
+        max_retries: int = 3,
+    ):
+        """
+        Initialize the inference model client.
+        
+        Args:
+            inference_url: URL of the inference model service
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retries for failed requests
+        """
+        self.inference_url = inference_url
+        self.timeout = timeout
+        self.max_retries = max_retries
+    
+    def extract_metadata(
+        self,
+        model_card_text: str,
+        structured_metadata: Optional[Dict[str, Any]] = None,
+        fields: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Extract metadata from unstructured text using the inference model.
+        
+        Args:
+            model_card_text: The text content of the model card
+            structured_metadata: Optional structured metadata to provide context
+            fields: Optional list of specific fields to extract
+            
+        Returns:
+            Extracted metadata as a dictionary
+        """
+        if not self.inference_url:
+            logger.warning("No inference model URL provided, skipping extraction")
+            return {}
+        
+        # Prepare the request payload
+        payload = {
+            "text": model_card_text,
+            "structured_metadata": structured_metadata or {},
+            "fields": fields or [],
+        }
+        
+        # Make the request to the inference model
+        try:
+            response = self._make_request(payload)
+            return response.get("metadata", {})
+        except Exception as e:
+            logger.error(f"Error extracting metadata with inference model: {e}")
+            return {}
+    
+    def _make_request(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Make a request to the inference model service.
+        
+        Args:
+            payload: Request payload
+            
+        Returns:
+            Response from the inference model
+            
+        Raises:
+            Exception: If the request fails after max_retries
+        """
+        headers = {"Content-Type": "application/json"}
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = requests.post(
+                    self.inference_url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.timeout,
+                )
+                response.raise_for_status()
+                return response.json()
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"Request failed (attempt {attempt+1}/{self.max_retries}): {e}")
+                if attempt == self.max_retries - 1:
+                    raise
+        
+        # This should never be reached due to the raise in the loop
+        raise Exception("Failed to make request to inference model")
+
+
+class FallbackExtractor:
+    """
+    Fallback extractor for extracting metadata using regex and heuristics
+    when the inference model is not available or fails.
+    """
+    
+    def extract_metadata(
+        self,
+        model_card_text: str,
+        structured_metadata: Optional[Dict[str, Any]] = None,
+        fields: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Extract metadata using regex and heuristics.
+        
+        Args:
+            model_card_text: The text content of the model card
+            structured_metadata: Optional structured metadata to provide context
+            fields: Optional list of specific fields to extract
+            
+        Returns:
+            Extracted metadata as a dictionary
+        """
+        metadata = {}
+        
+        # Extract model parameters
+        metadata.update(self._extract_model_parameters(model_card_text))
+        
+        # Extract limitations and ethical considerations
+        metadata.update(self._extract_considerations(model_card_text))
+        
+        # Extract datasets
+        metadata.update(self._extract_datasets(model_card_text))
+        
+        # Extract evaluation results
+        metadata.update(self._extract_evaluation_results(model_card_text))
+        
+        return metadata
+    
+    def _extract_model_parameters(self, text: str) -> Dict[str, Any]:
+        """Extract model parameters from text."""
+        params = {}
+        
+        # Extract model type/architecture
+        architecture_patterns = [
+            r"(?:model|architecture)(?:\s+type)?(?:\s*:\s*|\s+is\s+)([A-Za-z0-9\-]+)",
+            r"based\s+on\s+(?:the\s+)?([A-Za-z0-9\-]+)(?:\s+architecture)?",
+        ]
+        
+        for pattern in architecture_patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                params["architecture"] = match.group(1).strip()
+                break
+        
+        # Extract number of parameters
+        param_patterns = [
+            r"(\d+(?:\.\d+)?)\s*(?:B|M|K)?\s*(?:billion|million|thousand)?\s*parameters",
+            r"parameters\s*:\s*(\d+(?:\.\d+)?)\s*(?:B|M|K)?",
+        ]
+        
+        for pattern in param_patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                params["parameters"] = match.group(1).strip()
+                # TODO: Normalize to a standard unit
+                break
+        
+        return {"model_parameters": params} if params else {}
+    
+    def _extract_considerations(self, text: str) -> Dict[str, Any]:
+        """Extract limitations and ethical considerations from text."""
+        considerations = {}
+        
+        # Extract limitations
+        limitations_section = self._extract_section(text, ["limitations", "limits", "shortcomings"])
+        if limitations_section:
+            considerations["limitations"] = limitations_section
+        
+        # Extract ethical considerations
+        ethics_section = self._extract_section(
+            text, ["ethical considerations", "ethics", "bias", "fairness", "risks"]
+        )
+        if ethics_section:
+            considerations["ethical_considerations"] = ethics_section
+        
+        return {"considerations": considerations} if considerations else {}
+    
+    def _extract_datasets(self, text: str) -> Dict[str, Any]:
+        """Extract dataset information from text."""
+        datasets = []
+        
+        # Extract dataset mentions
+        dataset_patterns = [
+            r"trained\s+on\s+(?:the\s+)?([A-Za-z0-9\-\s]+)(?:\s+dataset)?",
+            r"dataset(?:\s*:\s*|\s+is\s+)([A-Za-z0-9\-\s]+)",
+            r"using\s+(?:the\s+)?([A-Za-z0-9\-\s]+)(?:\s+dataset)",
+        ]
+        
+        for pattern in dataset_patterns:
+            for match in re.finditer(pattern, text, re.IGNORECASE):
+                dataset = match.group(1).strip()
+                if dataset and dataset.lower() not in ["this", "these", "those"]:
+                    datasets.append(dataset)
+        
+        return {"datasets": list(set(datasets))} if datasets else {}
+    
+    def _extract_evaluation_results(self, text: str) -> Dict[str, Any]:
+        """Extract evaluation results from text."""
+        results = {}
+        
+        # Extract accuracy
+        accuracy_match = re.search(
+            r"accuracy(?:\s*:\s*|\s+of\s+|\s+is\s+)(\d+(?:\.\d+)?)\s*%?",
+            text,
+            re.IGNORECASE,
+        )
+        if accuracy_match:
+            results["accuracy"] = float(accuracy_match.group(1))
+        
+        # Extract F1 score
+        f1_match = re.search(
+            r"f1(?:\s*[\-_]?score)?(?:\s*:\s*|\s+of\s+|\s+is\s+)(\d+(?:\.\d+)?)",
+            text,
+            re.IGNORECASE,
+        )
+        if f1_match:
+            results["f1"] = float(f1_match.group(1))
+        
+        # Extract precision
+        precision_match = re.search(
+            r"precision(?:\s*:\s*|\s+of\s+|\s+is\s+)(\d+(?:\.\d+)?)",
+            text,
+            re.IGNORECASE,
+        )
+        if precision_match:
+            results["precision"] = float(precision_match.group(1))
+        
+        # Extract recall
+        recall_match = re.search(
+            r"recall(?:\s*:\s*|\s+of\s+|\s+is\s+)(\d+(?:\.\d+)?)",
+            text,
+            re.IGNORECASE,
+        )
+        if recall_match:
+            results["recall"] = float(recall_match.group(1))
+        
+        return {"evaluation_results": results} if results else {}
+    
+    def _extract_section(self, text: str, section_names: List[str]) -> Optional[str]:
+        """
+        Extract a section from the text based on section names.
+        
+        Args:
+            text: The text to extract from
+            section_names: Possible names for the section
+            
+        Returns:
+            The extracted section text, or None if not found
+        """
+        # Create pattern to match section headers
+        header_pattern = r"(?:^|\n)(?:#+\s*|[0-9]+\.\s*|[A-Z\s]+:\s*)(?:{})(?:\s*:)?(?:\s*\n|\s*$)".format(
+            "|".join(section_names)
+        )
+        
+        # Find all section headers
+        headers = list(re.finditer(header_pattern, text, re.IGNORECASE))
+        
+        for i, match in enumerate(headers):
+            start = match.end()
+            
+            # Find the end of the section (next header or end of text)
+            if i < len(headers) - 1:
+                end = headers[i + 1].start()
+            else:
+                end = len(text)
+            
+            # Extract the section content
+            section = text[start:end].strip()
+            
+            if section:
+                return section
+        
+        return None
+
+
+class MetadataExtractor:
+    """
+    Metadata extractor that combines inference model and fallback extraction.
+    """
+    
+    def __init__(
+        self,
+        inference_url: Optional[str] = None,
+        use_inference: bool = True,
+    ):
+        """
+        Initialize the metadata extractor.
+        
+        Args:
+            inference_url: URL of the inference model service
+            use_inference: Whether to use the inference model
+        """
+        self.use_inference = use_inference and inference_url is not None
+        self.inference_client = InferenceModelClient(inference_url) if self.use_inference else None
+        self.fallback_extractor = FallbackExtractor()
+    
+    def extract_metadata(
+        self,
+        model_card_text: str,
+        structured_metadata: Optional[Dict[str, Any]] = None,
+        fields: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Extract metadata from model card text.
+        
+        Args:
+            model_card_text: The text content of the model card
+            structured_metadata: Optional structured metadata to provide context
+            fields: Optional list of specific fields to extract
+            
+        Returns:
+            Extracted metadata as a dictionary
+        """
+        metadata = {}
+        
+        # Try inference model first if enabled
+        if self.use_inference and self.inference_client:
+            try:
+                inference_metadata = self.inference_client.extract_metadata(
+                    model_card_text, structured_metadata, fields
+                )
+                metadata.update(inference_metadata)
+            except Exception as e:
+                logger.error(f"Inference model extraction failed: {e}")
+        
+        # Use fallback extractor for missing fields or if inference failed
+        if not metadata or (fields and not all(field in metadata for field in fields)):
+            missing_fields = fields if fields else None
+            if fields:
+                missing_fields = [field for field in fields if field not in metadata]
+            
+            fallback_metadata = self.fallback_extractor.extract_metadata(
+                model_card_text, structured_metadata, missing_fields
+            )
+            
+            # Only update with fallback data for fields that weren't extracted by inference
+            for key, value in fallback_metadata.items():
+                if key not in metadata or not metadata[key]:
+                    metadata[key] = value
+        
+        return metadata

src/aibom_generator/inference_model.py

@@ -0,0 +1,532 @@
+"""
+Inference model implementation for metadata extraction from model cards.
+
+This module provides a fine-tuned model for extracting structured metadata
+from unstructured text in Hugging Face model cards.
+"""
+
+import json
+import logging
+import os
+import re
+import torch
+from typing import Dict, List, Optional, Any, Union
+
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+from transformers import AutoModelForSeq2SeqLM, T5Tokenizer
+
+logger = logging.getLogger(__name__)
+
+
+class ModelCardExtractor:
+    """
+    Fine-tuned model for extracting metadata from model card text.
+    """
+    
+    def __init__(
+        self,
+        model_name: str = "distilbert-base-uncased",
+        device: str = "cpu",
+        max_length: int = 512,
+        cache_dir: Optional[str] = None,
+    ):
+        """
+        Initialize the model card extractor.
+        
+        Args:
+            model_name: Name or path of the pre-trained model
+            device: Device to run the model on ('cpu' or 'cuda')
+            max_length: Maximum sequence length for tokenization
+            cache_dir: Directory to cache models
+        """
+        self.model_name = model_name
+        self.device = device
+        self.max_length = max_length
+        self.cache_dir = cache_dir
+        
+        # Load tokenizer and model
+        self.tokenizer = None
+        self.model = None
+        
+        # Initialize extraction pipelines
+        self.section_classifier = None
+        self.metadata_extractor = None
+        
+        # Load models
+        self._load_models()
+    
+    def _load_models(self):
+        """Load the required models for extraction."""
+        try:
+            # Load section classifier
+            logger.info(f"Loading section classifier model: {self.model_name}")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name,
+                cache_dir=self.cache_dir,
+            )
+            self.model = AutoModelForSequenceClassification.from_pretrained(
+                self.model_name,
+                cache_dir=self.cache_dir,
+            )
+            self.model.to(self.device)
+            
+            # Create section classification pipeline
+            self.section_classifier = pipeline(
+                "text-classification",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if self.device == "cuda" else -1,
+            )
+            
+            # For demonstration purposes, we'll use a T5-based model for extraction
+            # In a real implementation, this would be a fine-tuned model specific to the task
+            logger.info("Loading metadata extraction model")
+            extraction_model_name = "t5-small"  # Placeholder for fine-tuned model
+            self.extraction_tokenizer = T5Tokenizer.from_pretrained(
+                extraction_model_name,
+                cache_dir=self.cache_dir,
+            )
+            self.extraction_model = AutoModelForSeq2SeqLM.from_pretrained(
+                extraction_model_name,
+                cache_dir=self.cache_dir,
+            )
+            self.extraction_model.to(self.device)
+            
+            logger.info("Models loaded successfully")
+        except Exception as e:
+            logger.error(f"Error loading models: {e}")
+            raise
+    
+    def extract_metadata(
+        self,
+        text: str,
+        fields: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Extract metadata from model card text.
+        
+        Args:
+            text: The model card text
+            fields: Optional list of specific fields to extract
+            
+        Returns:
+            Extracted metadata as a dictionary
+        """
+        # Split text into sections
+        sections = self._split_into_sections(text)
+        
+        # Classify sections
+        classified_sections = self._classify_sections(sections)
+        
+        # Extract metadata from each section
+        metadata = {}
+        for section_type, section_text in classified_sections.items():
+            if fields and section_type not in fields:
+                continue
+                
+            extracted = self._extract_from_section(section_type, section_text)
+            if extracted:
+                metadata[section_type] = extracted
+        
+        return metadata
+    
+    def _split_into_sections(self, text: str) -> List[Dict[str, str]]:
+        """
+        Split the model card text into sections.
+        
+        Args:
+            text: The model card text
+            
+        Returns:
+            List of sections with title and content
+        """
+        # Simple section splitting based on headers
+        # In a real implementation, this would be more sophisticated
+        sections = []
+        
+        # Match markdown headers (# Header, ## Header, etc.)
+        header_pattern = r"(?:^|\n)(#+)\s+(.*?)(?:\n|$)"
+        
+        # Find all headers
+        headers = list(re.finditer(header_pattern, text))
+        
+        for i, match in enumerate(headers):
+            header_level = len(match.group(1))
+            header_text = match.group(2).strip()
+            
+            start = match.end()
+            
+            # Find the end of the section (next header or end of text)
+            if i < len(headers) - 1:
+                end = headers[i + 1].start()
+            else:
+                end = len(text)
+            
+            # Extract the section content
+            content = text[start:end].strip()
+            
+            sections.append({
+                "title": header_text,
+                "level": header_level,
+                "content": content,
+            })
+        
+        # If no sections were found, treat the entire text as one section
+        if not sections:
+            sections.append({
+                "title": "Main",
+                "level": 1,
+                "content": text.strip(),
+            })
+        
+        return sections
+    
+    def _classify_sections(self, sections: List[Dict[str, str]]) -> Dict[str, str]:
+        """
+        Classify sections into metadata categories.
+        
+        Args:
+            sections: List of sections with title and content
+            
+        Returns:
+            Dictionary mapping section types to section content
+        """
+        classified = {}
+        
+        # Map common section titles to metadata fields
+        title_mappings = {
+            "model description": "description",
+            "description": "description",
+            "model details": "model_parameters",
+            "model architecture": "model_parameters",
+            "parameters": "model_parameters",
+            "training data": "datasets",
+            "dataset": "datasets",
+            "datasets": "datasets",
+            "training": "training_procedure",
+            "evaluation": "evaluation_results",
+            "results": "evaluation_results",
+            "performance": "evaluation_results",
+            "metrics": "evaluation_results",
+            "limitations": "limitations",
+            "biases": "ethical_considerations",
+            "bias": "ethical_considerations",
+            "ethical considerations": "ethical_considerations",
+            "ethics": "ethical_considerations",
+            "risks": "ethical_considerations",
+            "license": "license",
+            "citation": "citation",
+            "references": "citation",
+        }
+        
+        for section in sections:
+            title = section["title"].lower()
+            content = section["content"]
+            
+            # Check for direct title matches
+            matched = False
+            for key, value in title_mappings.items():
+                if key in title:
+                    if value not in classified:
+                        classified[value] = content
+                    else:
+                        classified[value] += "\n\n" + content
+                    matched = True
+                    break
+            
+            # If no match by title, use the classifier
+            if not matched and self.section_classifier and len(content.split()) > 5:
+                try:
+                    # This is a placeholder for actual classification
+                    # In a real implementation, this would use the fine-tuned classifier
+                    section_type = self._classify_text(content)
+                    if section_type and section_type not in classified:
+                        classified[section_type] = content
+                    elif section_type:
+                        classified[section_type] += "\n\n" + content
+                except Exception as e:
+                    logger.error(f"Error classifying section: {e}")
+        
+        return classified
+    
+    def _classify_text(self, text: str) -> Optional[str]:
+        """
+        Classify text into a metadata category.
+        
+        Args:
+            text: The text to classify
+            
+        Returns:
+            Metadata category or None if classification fails
+        """
+        # This is a placeholder for actual classification
+        # In a real implementation, this would use the fine-tuned classifier
+        
+        # Simple keyword-based classification for demonstration
+        keywords = {
+            "description": ["is a", "this model", "based on", "pretrained"],
+            "model_parameters": ["parameters", "layers", "hidden", "dimension", "architecture"],
+            "datasets": ["dataset", "corpus", "trained on", "fine-tuned on"],
+            "evaluation_results": ["accuracy", "f1", "precision", "recall", "performance"],
+            "limitations": ["limitation", "limited", "does not", "cannot", "fails to"],
+            "ethical_considerations": ["bias", "ethical", "fairness", "gender", "race"],
+        }
+        
+        # Count keyword occurrences
+        counts = {category: 0 for category in keywords}
+        for category, words in keywords.items():
+            for word in words:
+                counts[category] += len(re.findall(r'\b' + re.escape(word) + r'\b', text.lower()))
+        
+        # Return the category with the most keyword matches
+        if counts:
+            max_category = max(counts.items(), key=lambda x: x[1])
+            if max_category[1] > 0:
+                return max_category[0]
+        
+        return None
+    
+    def _extract_from_section(self, section_type: str, text: str) -> Any:
+        """
+        Extract structured metadata from a section.
+        
+        Args:
+            section_type: The type of section
+            text: The section text
+            
+        Returns:
+            Extracted metadata
+        """
+        # This is a placeholder for actual extraction
+        # In a real implementation, this would use the fine-tuned extraction model
+        
+        if section_type == "description":
+            # Simply return the text for description
+            return text.strip()
+        
+        elif section_type == "model_parameters":
+            # Extract model parameters using regex
+            params = {}
+            
+            # Extract architecture
+            arch_match = re.search(r'(?:architecture|model type|based on)[:\s]+([A-Za-z0-9\-]+)', text, re.IGNORECASE)
+            if arch_match:
+                params["architecture"] = arch_match.group(1).strip()
+            
+            # Extract parameter count
+            param_match = re.search(r'(\d+(?:\.\d+)?)\s*(?:B|M|K)?\s*(?:billion|million|thousand)?\s*parameters', text, re.IGNORECASE)
+            if param_match:
+                params["parameter_count"] = param_match.group(1).strip()
+            
+            return params
+        
+        elif section_type == "datasets":
+            # Extract dataset names
+            datasets = []
+            dataset_patterns = [
+                r'trained on\s+(?:the\s+)?([A-Za-z0-9\-\s]+)(?:\s+dataset)?',
+                r'dataset[:\s]+([A-Za-z0-9\-\s]+)',
+                r'using\s+(?:the\s+)?([A-Za-z0-9\-\s]+)(?:\s+dataset)',
+            ]
+            
+            for pattern in dataset_patterns:
+                for match in re.finditer(pattern, text, re.IGNORECASE):
+                    dataset = match.group(1).strip()
+                    if dataset and dataset.lower() not in ["this", "these", "those"]:
+                        datasets.append(dataset)
+            
+            return list(set(datasets))
+        
+        elif section_type == "evaluation_results":
+            # Extract evaluation metrics
+            results = {}
+            
+            # Extract accuracy
+            acc_match = re.search(r'accuracy[:\s]+(\d+(?:\.\d+)?)\s*%?', text, re.IGNORECASE)
+            if acc_match:
+                results["accuracy"] = float(acc_match.group(1))
+            
+            # Extract F1 score
+            f1_match = re.search(r'f1(?:\s*[\-_]?score)?[:\s]+(\d+(?:\.\d+)?)', text, re.IGNORECASE)
+            if f1_match:
+                results["f1"] = float(f1_match.group(1))
+            
+            # Extract precision
+            prec_match = re.search(r'precision[:\s]+(\d+(?:\.\d+)?)', text, re.IGNORECASE)
+            if prec_match:
+                results["precision"] = float(prec_match.group(1))
+            
+            # Extract recall
+            recall_match = re.search(r'recall[:\s]+(\d+(?:\.\d+)?)', text, re.IGNORECASE)
+            if recall_match:
+                results["recall"] = float(recall_match.group(1))
+            
+            return results
+        
+        elif section_type == "limitations":
+            # Simply return the text for limitations
+            return text.strip()
+        
+        elif section_type == "ethical_considerations":
+            # Simply return the text for ethical considerations
+            return text.strip()
+        
+        elif section_type == "license":
+            # Extract license information
+            license_match = re.search(r'(?:license|licensing)[:\s]+([A-Za-z0-9\-\s]+)', text, re.IGNORECASE)
+            if license_match:
+                return license_match.group(1).strip()
+            return text.strip()
+        
+        elif section_type == "citation":
+            # Simply return the text for citation
+            return text.strip()
+        
+        # Default case
+        return text.strip()
+
+
+class InferenceModelServer:
+    """
+    Server for the inference model.
+    
+    This class provides a server for the inference model that can be deployed
+    as a standalone service with a REST API.
+    """
+    
+    def __init__(
+        self,
+        model_name: str = "distilbert-base-uncased",
+        device: str = "cpu",
+        cache_dir: Optional[str] = None,
+    ):
+        """
+        Initialize the inference model server.
+        
+        Args:
+            model_name: Name or path of the pre-trained model
+            device: Device to run the model on ('cpu' or 'cuda')
+            cache_dir: Directory to cache models
+        """
+        self.extractor = ModelCardExtractor(
+            model_name=model_name,
+            device=device,
+            cache_dir=cache_dir,
+        )
+    
+    def extract_metadata(
+        self,
+        text: str,
+        structured_metadata: Optional[Dict[str, Any]] = None,
+        fields: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Extract metadata from model card text.
+        
+        Args:
+            text: The model card text
+            structured_metadata: Optional structured metadata to provide context
+            fields: Optional list of specific fields to extract
+            
+        Returns:
+            Extracted metadata as a dictionary
+        """
+        try:
+            # Extract metadata using the extractor
+            metadata = self.extractor.extract_metadata(text, fields)
+            
+            # Enhance with structured metadata if provided
+            if structured_metadata:
+                # Use structured metadata for fields not extracted
+                for key, value in structured_metadata.items():
+                    if key not in metadata or not metadata[key]:
+                        metadata[key] = value
+            
+            return {"metadata": metadata, "success": True}
+        except Exception as e:
+            logger.error(f"Error extracting metadata: {e}")
+            return {"metadata": {}, "success": False, "error": str(e)}
+
+
+def create_app(model_name: str = "distilbert-base-uncased", device: str = "cpu"):
+    """
+    Create a Flask app for the inference model server.
+    
+    Args:
+        model_name: Name or path of the pre-trained model
+        device: Device to run the model on ('cpu' or 'cuda')
+        
+    Returns:
+        Flask app
+    """
+    from flask import Flask, request, jsonify
+    
+    app = Flask(__name__)
+    server = InferenceModelServer(model_name=model_name, device=device)
+    
+    @app.route("/extract", methods=["POST"])
+    def extract():
+        data = request.json
+        text = data.get("text", "")
+        structured_metadata = data.get("structured_metadata", {})
+        fields = data.get("fields", [])
+        
+        result = server.extract_metadata(text, structured_metadata, fields)
+        return jsonify(result)
+    
+    @app.route("/health", methods=["GET"])
+    def health():
+        return jsonify({"status": "healthy"})
+    
+    return app
+
+
+def main():
+    """Main entry point for the inference model server."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="Start the inference model server for AIBOM metadata extraction."
+    )
+    
+    parser.add_argument(
+        "--model",
+        help="Name or path of the pre-trained model",
+        default="distilbert-base-uncased",
+    )
+    
+    parser.add_argument(
+        "--device",
+        help="Device to run the model on ('cpu' or 'cuda')",
+        choices=["cpu", "cuda"],
+        default="cpu",
+    )
+    
+    parser.add_argument(
+        "--host",
+        help="Host to bind the server to",
+        default="0.0.0.0",
+    )
+    
+    parser.add_argument(
+        "--port",
+        help="Port to bind the server to",
+        type=int,
+        default=5000,
+    )
+    
+    parser.add_argument(
+        "--debug",
+        help="Enable debug mode",
+        action="store_true",
+    )
+    
+    args = parser.parse_args()
+    
+    # Create and run the app
+    app = create_app(model_name=args.model, device=args.device)
+    app.run(host=args.host, port=args.port, debug=args.debug)
+
+
+if __name__ == "__main__":
+    main()

src/aibom_generator/integration.py

@@ -0,0 +1,134 @@
+"""
+Integration with the main generator class to use the inference model.
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+
+from huggingface_hub import ModelCard
+
+from aibom_generator.inference import MetadataExtractor
+from aibom_generator.utils import merge_metadata
+
+logger = logging.getLogger(__name__)
+
+
+class InferenceModelIntegration:
+    """
+    Integration with the inference model for metadata extraction.
+    """
+    
+    def __init__(
+        self,
+        inference_url: Optional[str] = None,
+        use_inference: bool = True,
+    ):
+        """
+        Initialize the inference model integration.
+        
+        Args:
+            inference_url: URL of the inference model service
+            use_inference: Whether to use the inference model
+        """
+        self.extractor = MetadataExtractor(inference_url, use_inference)
+    
+    def extract_metadata_from_model_card(
+        self,
+        model_card: ModelCard,
+        structured_metadata: Optional[Dict[str, Any]] = None,
+        fields: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Extract metadata from a model card using the inference model.
+        
+        Args:
+            model_card: The ModelCard object
+            structured_metadata: Optional structured metadata to provide context
+            fields: Optional list of specific fields to extract
+            
+        Returns:
+            Extracted metadata as a dictionary
+        """
+        if not model_card:
+            logger.warning("No model card provided for inference extraction")
+            return {}
+        
+        # Get the model card text content
+        model_card_text = model_card.text if hasattr(model_card, "text") else ""
+        
+        if not model_card_text:
+            logger.warning("Model card has no text content for inference extraction")
+            return {}
+        
+        # Extract metadata using the extractor
+        extracted_metadata = self.extractor.extract_metadata(
+            model_card_text, structured_metadata, fields
+        )
+        
+        return extracted_metadata
+    
+    def enhance_metadata(
+        self,
+        structured_metadata: Dict[str, Any],
+        model_card: ModelCard,
+    ) -> Dict[str, Any]:
+        """
+        Enhance structured metadata with information extracted from the model card.
+        
+        Args:
+            structured_metadata: Structured metadata from API
+            model_card: The ModelCard object
+            
+        Returns:
+            Enhanced metadata as a dictionary
+        """
+        # Identify missing fields that could be extracted from unstructured text
+        missing_fields = self._identify_missing_fields(structured_metadata)
+        
+        if not missing_fields:
+            logger.info("No missing fields to extract from unstructured text")
+            return structured_metadata
+        
+        # Extract missing fields from unstructured text
+        extracted_metadata = self.extract_metadata_from_model_card(
+            model_card, structured_metadata, missing_fields
+        )
+        
+        # Merge the extracted metadata with the structured metadata
+        # Structured metadata takes precedence
+        enhanced_metadata = merge_metadata(structured_metadata, extracted_metadata)
+        
+        return enhanced_metadata
+    
+    def _identify_missing_fields(self, metadata: Dict[str, Any]) -> List[str]:
+        """
+        Identify fields that are missing or incomplete in the metadata.
+        
+        Args:
+            metadata: The metadata to check
+            
+        Returns:
+            List of missing field names
+        """
+        missing_fields = []
+        
+        # Check for missing or empty fields
+        important_fields = [
+            "description",
+            "license",
+            "model_parameters",
+            "datasets",
+            "evaluation_results",
+            "limitations",
+            "ethical_considerations",
+        ]
+        
+        for field in important_fields:
+            if field not in metadata or not metadata[field]:
+                missing_fields.append(field)
+            elif isinstance(metadata[field], dict) and not any(metadata[field].values()):
+                missing_fields.append(field)
+            elif isinstance(metadata[field], list) and not metadata[field]:
+                missing_fields.append(field)
+        
+        return missing_fields

src/aibom_generator/utils.py

@@ -0,0 +1,222 @@
+"""
+Utility functions for the AIBOM Generator.
+"""
+
+import json
+import logging
+import os
+import re
+import uuid
+from typing import Dict, List, Optional, Any, Union
+
+logger = logging.getLogger(__name__)
+
+
+def setup_logging(level=logging.INFO):
+    """Set up logging configuration."""
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+def ensure_directory(directory_path):
+    """Ensure that a directory exists, creating it if necessary."""
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path)
+    return directory_path
+
+
+def generate_uuid():
+    """Generate a UUID for the AIBOM serialNumber."""
+    return str(uuid.uuid4())
+
+
+def normalize_license_id(license_text):
+    """
+    Normalize a license string to a SPDX license identifier if possible.
+    
+    Args:
+        license_text: The license text to normalize
+        
+    Returns:
+        SPDX license identifier or the original text if no match
+    """
+    # Common license mappings
+    license_mappings = {
+        "mit": "MIT",
+        "apache": "Apache-2.0",
+        "apache 2": "Apache-2.0",
+        "apache 2.0": "Apache-2.0",
+        "apache-2": "Apache-2.0",
+        "apache-2.0": "Apache-2.0",
+        "gpl": "GPL-3.0-only",
+        "gpl-3": "GPL-3.0-only",
+        "gpl-3.0": "GPL-3.0-only",
+        "gpl3": "GPL-3.0-only",
+        "gpl v3": "GPL-3.0-only",
+        "gpl-2": "GPL-2.0-only",
+        "gpl-2.0": "GPL-2.0-only",
+        "gpl2": "GPL-2.0-only",
+        "gpl v2": "GPL-2.0-only",
+        "lgpl": "LGPL-3.0-only",
+        "lgpl-3": "LGPL-3.0-only",
+        "lgpl-3.0": "LGPL-3.0-only",
+        "bsd": "BSD-3-Clause",
+        "bsd-3": "BSD-3-Clause",
+        "bsd-3-clause": "BSD-3-Clause",
+        "bsd-2": "BSD-2-Clause",
+        "bsd-2-clause": "BSD-2-Clause",
+        "cc": "CC-BY-4.0",
+        "cc-by": "CC-BY-4.0",
+        "cc-by-4.0": "CC-BY-4.0",
+        "cc-by-sa": "CC-BY-SA-4.0",
+        "cc-by-sa-4.0": "CC-BY-SA-4.0",
+        "cc-by-nc": "CC-BY-NC-4.0",
+        "cc-by-nc-4.0": "CC-BY-NC-4.0",
+        "cc0": "CC0-1.0",
+        "cc0-1.0": "CC0-1.0",
+        "public domain": "CC0-1.0",
+        "unlicense": "Unlicense",
+        "proprietary": "NONE",
+        "commercial": "NONE",
+    }
+    
+    if not license_text:
+        return None
+    
+    # Normalize to lowercase and remove punctuation
+    normalized = re.sub(r'[^\w\s-]', '', license_text.lower())
+    
+    # Check for direct matches
+    if normalized in license_mappings:
+        return license_mappings[normalized]
+    
+    # Check for partial matches
+    for key, value in license_mappings.items():
+        if key in normalized:
+            return value
+    
+    # Return original if no match
+    return license_text
+
+
+def calculate_completeness_score(aibom: Dict[str, Any]) -> int:
+    """
+    Calculate a completeness score for the AIBOM.
+    
+    Args:
+        aibom: The AIBOM dictionary
+        
+    Returns:
+        Completeness score (0-100)
+    """
+    score = 0
+    max_score = 100
+    
+    # Define scoring weights for different sections
+    weights = {
+        "required_fields": 20,
+        "metadata": 20,
+        "component_basic": 20,
+        "component_model_card": 30,
+        "external_references": 10,
+    }
+    
+    # Check required fields (20%)
+    required_fields = ["bomFormat", "specVersion", "serialNumber", "version"]
+    required_score = sum(1 for field in required_fields if field in aibom)
+    score += (required_score / len(required_fields)) * weights["required_fields"]
+    
+    # Check metadata (20%)
+    if "metadata" in aibom:
+        metadata = aibom["metadata"]
+        metadata_fields = ["timestamp", "tools", "authors", "component"]
+        metadata_score = sum(1 for field in metadata_fields if field in metadata)
+        score += (metadata_score / len(metadata_fields)) * weights["metadata"]
+    
+    # Check component basic info (20%)
+    if "components" in aibom and aibom["components"]:
+        component = aibom["components"][0]
+        component_fields = ["type", "name", "bom-ref", "purl", "description", "licenses"]
+        component_score = sum(1 for field in component_fields if field in component)
+        score += (component_score / len(component_fields)) * weights["component_basic"]
+        
+        # Check model card (30%)
+        if "modelCard" in component:
+            model_card = component["modelCard"]
+            model_card_fields = ["modelParameters", "quantitativeAnalysis", "considerations"]
+            model_card_score = sum(1 for field in model_card_fields if field in model_card)
+            score += (model_card_score / len(model_card_fields)) * weights["component_model_card"]
+    
+    # Check external references (10%)
+    if "externalReferences" in aibom and aibom["externalReferences"]:
+        score += weights["external_references"]
+    
+    return round(score)
+
+
+def merge_metadata(primary: Dict[str, Any], secondary: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Merge two metadata dictionaries, giving priority to the primary dictionary.
+    
+    Args:
+        primary: Primary metadata dictionary
+        secondary: Secondary metadata dictionary
+        
+    Returns:
+        Merged metadata dictionary
+    """
+    result = secondary.copy()
+    
+    for key, value in primary.items():
+        if value is not None:
+            if key in result and isinstance(value, dict) and isinstance(result[key], dict):
+                result[key] = merge_metadata(value, result[key])
+            else:
+                result[key] = value
+    
+    return result
+
+
+def extract_model_id_parts(model_id: str) -> Dict[str, str]:
+    """
+    Extract parts from a Hugging Face model ID.
+    
+    Args:
+        model_id: Hugging Face model ID (e.g., "google/bert-base-uncased")
+        
+    Returns:
+        Dictionary with parts (owner, name)
+    """
+    parts = model_id.split("/")
+    
+    if len(parts) == 1:
+        return {
+            "owner": None,
+            "name": parts[0],
+        }
+    else:
+        return {
+            "owner": parts[0],
+            "name": "/".join(parts[1:]),
+        }
+
+
+def create_purl(model_id: str) -> str:
+    """
+    Create a Package URL (purl) for a Hugging Face model.
+    
+    Args:
+        model_id: Hugging Face model ID
+        
+    Returns:
+        Package URL string
+    """
+    parts = extract_model_id_parts(model_id)
+    
+    if parts["owner"]:
+        return f"pkg:huggingface/{parts['owner']}/{parts['name']}"
+    else:
+        return f"pkg:huggingface/{parts['name']}"

src/aibom_generator/worker.py

@@ -0,0 +1,103 @@
+"""
+Background worker for the AIBOM Generator.
+
+This module provides a background worker that can be used to process
+AIBOM generation tasks asynchronously.
+"""
+
+import logging
+import os
+import time
+from typing import Dict, List, Optional, Any
+
+from aibom_generator.generator import AIBOMGenerator
+from aibom_generator.utils import setup_logging, calculate_completeness_score
+
+# Set up logging
+setup_logging()
+logger = logging.getLogger(__name__)
+
+
+class Worker:
+    """
+    Background worker for AIBOM generation.
+    """
+    
+    def __init__(
+        self,
+        poll_interval: int = 60,
+        hf_token: Optional[str] = None,
+        inference_model_url: Optional[str] = None,
+        use_inference: bool = True,
+        cache_dir: Optional[str] = None,
+    ):
+        """
+        Initialize the worker.
+        
+        Args:
+            poll_interval: Interval in seconds to poll for new tasks
+            hf_token: Hugging Face API token
+            inference_model_url: URL of the inference model service
+            use_inference: Whether to use the inference model
+            cache_dir: Directory to cache API responses and model cards
+        """
+        self.poll_interval = poll_interval
+        self.generator = AIBOMGenerator(
+            hf_token=hf_token,
+            inference_model_url=inference_model_url,
+            use_inference=use_inference,
+            cache_dir=cache_dir,
+        )
+        self.running = False
+    
+    def start(self):
+        """Start the worker."""
+        self.running = True
+        logger.info("Worker started")
+        
+        try:
+            while self.running:
+                # Process tasks
+                self._process_tasks()
+                
+                # Sleep for poll interval
+                time.sleep(self.poll_interval)
+        except KeyboardInterrupt:
+            logger.info("Worker stopped by user")
+        except Exception as e:
+            logger.error(f"Worker error: {e}")
+        finally:
+            self.running = False
+            logger.info("Worker stopped")
+    
+    def stop(self):
+        """Stop the worker."""
+        self.running = False
+    
+    def _process_tasks(self):
+        """Process pending tasks."""
+        # This is a placeholder for actual task processing
+        # In a real implementation, this would fetch tasks from a queue or database
+        logger.debug("Processing tasks")
+        
+        # Simulate task processing
+        # In a real implementation, this would process actual tasks
+        pass
+
+
+def main():
+    """Main entry point for the worker."""
+    # Create and start the worker
+    worker = Worker(
+        poll_interval=int(os.environ.get("AIBOM_POLL_INTERVAL", 60)),
+        hf_token=os.environ.get("HF_TOKEN"),
+        inference_model_url=os.environ.get("AIBOM_INFERENCE_URL"),
+        use_inference=os.environ.get("AIBOM_USE_INFERENCE", "true").lower() == "true",
+        cache_dir=os.environ.get("AIBOM_CACHE_DIR"),
+    )
+    
+    worker.start()
+
+
+if __name__ == "__main__":
+    main()