Agentic Model Selector

.devcontainer/devcontainer.json

@@ -0,0 +1,35 @@
+{
+  "name": "Agentic Model Selector",
+  "image": "mcr.microsoft.com/devcontainers/python:3.11",
+  "features": {
+    "ghcr.io/devcontainers/features/python:1": {
+      "version": "3.11"
+    },
+    "ghcr.io/devcontainers/features/nvidia-cuda:1": {
+      "version": "11.8"
+    }
+  },
+  "postCreateCommand": "pip install -r requirements.txt && python -m spacy download en_core_web_sm",
+  "postStartCommand": "echo '🚀 Ready for agentic development!'",
+  "forwardPorts": [8000, 7860, 3000],
+  "portsAttributes": {
+    "8000": {
+      "label": "FastAPI",
+      "onAutoForward": "notify"
+    },
+    "7860": {
+      "label": "Gradio",
+      "onAutoForward": "notify"
+    }
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-python.python",
+        "ms-toolsai.jupyter",
+        "GitHub.copilot",
+        "GitHub.copilot-chat"
+      ]
+    }
+  }
+}

.github/workflows/ci.yml

@@ -0,0 +1,105 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+  release:
+    types: [ published ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8, 3.9, "3.10", "3.11"]
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install pytest pytest-cov flake8 black
+    
+    - name: Lint with flake8
+      run: |
+        flake8 src/ --count --select=E9,F63,F7,F82 --show-source --statistics
+        flake8 src/ --count --exit-zero --max-complexity=10 --statistics
+    
+    - name: Format with black
+      run: black --check src/
+    
+    - name: Test with pytest
+      run: |
+        pytest tests/ --cov=src/ --cov-report=xml
+    
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v3
+      with:
+        file: ./coverage.xml
+        flags: unittests
+
+  build-docker:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+    
+    - name: Login to GitHub Container Registry
+      uses: docker/login-action@v2
+      with:
+        registry: ghcr.io
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+    
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v4
+      with:
+        context: .
+        file: docker/Dockerfile
+        push: true
+        tags: |
+          ghcr.io/${{ github.repository }}/hf-selector:latest
+          ghcr.io/${{ github.repository }}/hf-selector:${{ github.sha }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+
+  deploy-docs:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.9'
+    
+    - name: Install dependencies
+      run: |
+        pip install mkdocs mkdocs-material
+    
+    - name: Build documentation
+      run: mkdocs build
+    
+    - name: Deploy to GitHub Pages
+      uses: peaceiris/actions-gh-pages@v3
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        publish_dir: ./site

.gitignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+pythonenv*
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Project specific
+deployments/
+*.log
+*.db
+.DS_Store
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Docker
+*.pid
+docker-compose.override.yml

README.md

@@ -0,0 +1,26 @@
+#  HuggingFace Model Selector
+
+Automatically find, evaluate, and deploy the best HuggingFace models for your specific task.
+
+##  Features
+
+- **Natural Language Understanding**: Describe your task in plain English
+- **Intelligent Search**: Finds relevant models on HuggingFace Hub
+- **Multi-criteria Scoring**: Evaluates models based on downloads, recency, license, size, and performance
+- **Real Benchmarking**: Tests actual inference speed and memory usage
+- **Deployment Generation**: Creates production-ready FastAPI/Gradio/Docker code
+- **Comprehensive Documentation**: Auto-generated README and configuration files
+
+##  Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/huggingface-model-selector.git
+cd huggingface-model-selector
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt

Scripts/setup-agent-env.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+echo " Setting up Agentic Environment..."
+
+# Install agentic frameworks
+pip install langchain langgraph chromadb
+
+# Set up memory store
+mkdir -p .memory/vector_store
+
+# Configure API keys (from Codespaces secrets)
+if [ -n "$OPENAI_API_KEY" ]; then
+    echo "OPENAI_API_KEY configured"
+fi
+
+echo " Agentic environment ready!"

docker/docker-compose.yml

@@ -0,0 +1,29 @@
+version: '3.8'
+
+services:
+  model-selector:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile
+    container_name: hf-model-selector
+    volumes:
+      - ../deployments:/app/deployments
+      - ~/.cache/huggingface:/home/appuser/.cache/huggingface
+    environment:
+      - HUGGINGFACE_TOKEN=${HUGGINGFACE_TOKEN}
+      - CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES:-}
+    stdin_open: true
+    tty: true
+    command: ["sentiment analysis", "--deploy", "fastapi"]
+
+  # Optional: Jupyter for development
+  jupyter:
+    image: jupyter/base-notebook:latest
+    container_name: hf-jupyter
+    ports:
+      - "8888:8888"
+    volumes:
+      - ../:/home/jovyan/work
+    environment:
+      - JUPYTER_ENABLE_LAB=yes
+    command: start-notebook.sh --NotebookApp.token=''

requirements.txt

@@ -0,0 +1,28 @@
+# Core dependencies
+transformers>=4.35.0
+torch>=2.0.0
+huggingface-hub>=0.19.0
+numpy>=1.24.0
+
+# Web frameworks
+fastapi>=0.104.0
+uvicorn>=0.24.0
+gradio>=4.0.0
+pydantic>=2.0.0
+python-multipart>=0.0.6
+
+# Utilities
+pyyaml>=6.0
+Jinja2>=3.1.0
+aiohttp>=3.9.0
+requests>=2.31.0
+
+# Testing
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+httpx>=0.25.0
+
+# Add to requirements.txt
+langchain>=0.3.0
+openai>=1.0.0
+anthropic>=0.30.0

run.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+"""
+Entry point for the HuggingFace Model Selector
+Run this file to start the model selection process
+"""
+
+import asyncio
+import argparse
+import sys
+from src.main import HuggingFaceModelSelector
+from src.models.schemas import DeploymentType
+
+
+def main():
+    """Main entry point"""
+    parser = argparse.ArgumentParser(
+        description="HuggingFace Model Selector - Find and deploy the best ML models"
+    )
+    
+    parser.add_argument(
+        "task",
+        type=str,
+        help="Task description (e.g., 'sentiment analysis', 'text summarization')"
+    )
+    
+    parser.add_argument(
+        "--deploy",
+        type=str,
+        choices=["fastapi", "gradio", "docker"],
+        default="fastapi",
+        help="Deployment type to generate"
+    )
+    
+    parser.add_argument(
+        "--no-benchmark",
+        action="store_true",
+        help="Skip performance benchmarking"
+    )
+    
+    parser.add_argument(
+        "--top-k",
+        type=int,
+        default=5,
+        help="Number of top models to consider"
+    )
+    
+    args = parser.parse_args()
+    
+    # Map deployment type
+    deploy_map = {
+        "fastapi": DeploymentType.FASTAPI,
+        "gradio": DeploymentType.GRADIO,
+        "docker": DeploymentType.DOCKER
+    }
+    
+    print("\n" + "=" * 60)
+    print(" HuggingFace Model Selector")
+    print("=" * 60)
+    print(f"\nTask: {args.task}")
+    print(f"Deployment: {args.deploy}")
+    print(f"Benchmark: {'No' if args.no_benchmark else 'Yes'}")
+    
+    # Run the selector
+    async def run():
+        selector = HuggingFaceModelSelector()
+        result = await selector.select_and_deploy(
+            task_description=args.task,
+            deployment_type=deploy_map[args.deploy],
+            benchmark=not args.no_benchmark,
+            top_k=args.top_k
+        )
+        
+        if result.status == "success":
+            print("\n" + "=" * 60)
+            print(" Selection Complete!")
+            print(f"Selected Model: {result.selected_model}")
+            print("\nNext steps:")
+            print(f"1. cd into the deployment folder")
+            print(f"2. pip install -r requirements.txt")
+            print(f"3. python app.py")
+            print("=" * 60)
+        else:
+            print("\n Selection failed:", result.error)
+            sys.exit(1)
+    
+    # Run async function
+    asyncio.run(run())
+
+
+if __name__ == "__main__":
+    main()

setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith("#")]
+
+setup(
+    name="huggingface-model-selector",
+    version="1.0.0",
+    author="Your Name",
+    description="Automatically select and deploy the best HuggingFace models for your task",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/huggingface-model-selector",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+    install_requires=requirements,
+    entry_points={
+        "console_scripts": [
+            "hf-selector=run:main",
+        ],
+    },
+)

src/agents/benchmarking_agent.py

@@ -0,0 +1,347 @@
+"""
+Benchmarking Agent - Tests model performance with real inference
+"""
+
+import torch
+import time
+import asyncio
+import numpy as np
+from transformers import (
+    AutoModelForSequenceClassification, 
+    AutoTokenizer, 
+    pipeline,
+    AutoModelForCausalLM
+)
+from typing import List, Dict, Any, Optional
+
+from src.models.schemas import (
+    TaskType, UserRequirements, BenchmarkResult
+)
+
+
+class BenchmarkingAgent:
+    """
+    Benchmarks models with real inference tests to measure latency and memory usage.
+    
+    This agent loads each model, runs warmup inferences, then measures
+    performance over multiple iterations.
+    """
+    
+    def __init__(self, sample_data: Dict[str, Any] = None):
+        self.sample_data = sample_data or self._get_default_samples()
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"   Using device: {self.device}")
+    
+    async def benchmark_models(self, 
+                              model_ids: List[str], 
+                              task_type: TaskType,
+                              requirements: UserRequirements,
+                              max_models: int = 3) -> List[BenchmarkResult]:
+        """
+        Benchmark top models with quick inference tests.
+        
+        Args:
+            model_ids: List of model IDs to benchmark
+            task_type: Type of ML task
+            requirements: User requirements
+            max_models: Maximum number of models to benchmark
+            
+        Returns:
+            List of BenchmarkResult objects
+        """
+        results = []
+        
+        print(f"   Benchmarking up to {max_models} models...")
+        
+        for i, model_id in enumerate(model_ids[:max_models]):
+            print(f"    Testing {i+1}/{min(len(model_ids), max_models)}: {model_id}")
+            
+            try:
+                result = await self._benchmark_single_model(
+                    model_id, task_type, requirements
+                )
+                results.append(result)
+                
+                if not result.error:
+                    print(f"       Latency: {result.latency_ms:.2f}ms, "
+                          f"Memory: {result.memory_usage_mb:.2f}MB")
+                else:
+                    print(f"       Error: {result.error}")
+                    
+            except Exception as e:
+                print(f"       Failed: {e}")
+                # FIXED: Added task_type to the error response
+                results.append(BenchmarkResult(
+                    model_id=model_id,
+                    task_type=task_type,  # This was missing!
+                    latency_ms=0,
+                    memory_usage_mb=0,
+                    error=str(e)
+                ))
+            
+            # Small delay between models
+            await asyncio.sleep(0.5)
+        
+        return results
+    
+    async def _benchmark_single_model(self, 
+                                model_id: str,
+                                task_type: TaskType,
+                                requirements: UserRequirements) -> BenchmarkResult:
+        """Benchmark a single model"""
+        
+        model = None
+        tokenizer = None
+        nlp_pipeline = None
+        
+        # Load model and tokenizer
+        try:
+            print(f"      Loading model...")
+            
+            if task_type == TaskType.TRANSLATION:
+                # For translation models, we need to use pipeline with specific task format
+                try:
+                    # Try the standard translation pipeline first
+                    nlp_pipeline = pipeline(
+                        "translation",
+                        model=model_id,
+                        device=self.device
+                    )
+                except Exception as e:
+                    # If that fails, try with specific language pair format
+                    if requirements.translation_reqs:
+                        src = requirements.translation_reqs.source_language.value
+                        tgt = requirements.translation_reqs.target_language.value
+                        task_name = f"translation_{src}_to_{tgt}"
+                        try:
+                            nlp_pipeline = pipeline(
+                                task_name,
+                                model=model_id,
+                                device=self.device
+                            )
+                        except:
+                            # If both fail, try loading as a general seq2seq model
+                            from transformers import AutoModelForSeq2SeqLM
+                            tokenizer = AutoTokenizer.from_pretrained(model_id)
+                            model = AutoModelForSeq2SeqLM.from_pretrained(model_id)
+                
+            elif task_type in [TaskType.TEXT_CLASSIFICATION, TaskType.NAMED_ENTITY_RECOGNITION]:
+                tokenizer = AutoTokenizer.from_pretrained(model_id)
+                model = AutoModelForSequenceClassification.from_pretrained(model_id)
+                
+            elif task_type == TaskType.TEXT_GENERATION:
+                tokenizer = AutoTokenizer.from_pretrained(model_id)
+                model = AutoModelForCausalLM.from_pretrained(model_id)
+                
+            else:
+                # Use pipeline for other tasks
+                nlp_pipeline = pipeline(
+                    task_type.value,
+                    model=model_id,
+                    device=self.device
+                )
+                
+        except Exception as e:
+            return BenchmarkResult(
+                model_id=model_id,
+                task_type=task_type,
+                latency_ms=0,
+                memory_usage_mb=0,
+                error=f"Failed to load model: {str(e)}"
+            )
+        
+        # Move model to device
+        if model:
+            model.to(self.device)
+            model.eval()
+        
+        # Get appropriate sample data
+        sample = self._get_task_sample(task_type)
+        
+        # Run warmup (first inference is always slower)
+        try:
+            await self._run_warmup(model_id, task_type, sample, model, tokenizer, nlp_pipeline, requirements)
+        except Exception as e:
+            print(f"      Warmup warning: {e}")
+        
+        # Benchmark inference
+        latencies = []
+        memory_usage = []
+        
+        for i in range(5):  # Run 5 iterations for stable measurement
+            # Reset memory stats if using CUDA
+            if self.device.type == "cuda":
+                torch.cuda.reset_peak_memory_stats()
+                start_memory = torch.cuda.memory_allocated()
+            
+            start_time = time.perf_counter()
+            
+            # Run inference
+            try:
+                with torch.no_grad():
+                    if task_type == TaskType.TRANSLATION and nlp_pipeline:
+                        # For translation pipeline
+                        result = nlp_pipeline(sample["text"], max_length=128)
+                        
+                    elif task_type == TaskType.TRANSLATION and model and tokenizer:
+                        # For seq2seq model
+                        inputs = tokenizer(
+                            sample["text"], 
+                            return_tensors="pt", 
+                            truncation=True, 
+                            max_length=128
+                        ).to(self.device)
+                        outputs = model.generate(**inputs, max_new_tokens=50)
+                        
+                    elif task_type == TaskType.TEXT_CLASSIFICATION and model and tokenizer:
+                        inputs = tokenizer(
+                            sample["text"], 
+                            return_tensors="pt", 
+                            truncation=True, 
+                            max_length=128
+                        ).to(self.device)
+                        outputs = model(**inputs)
+                        
+                    elif task_type == TaskType.TEXT_GENERATION and model and tokenizer:
+                        inputs = tokenizer(
+                            sample["text"], 
+                            return_tensors="pt", 
+                            truncation=True
+                        ).to(self.device)
+                        outputs = model.generate(**inputs, max_new_tokens=20)
+                        
+                    elif nlp_pipeline:
+                        result = nlp_pipeline(sample["text"])
+                        
+            except Exception as e:
+                return BenchmarkResult(
+                    model_id=model_id,
+                    task_type=task_type,
+                    latency_ms=0,
+                    memory_usage_mb=0,
+                    error=f"Inference failed: {str(e)}"
+                )
+            
+            end_time = time.perf_counter()
+            
+            # Measure memory
+            if self.device.type == "cuda":
+                end_memory = torch.cuda.memory_allocated()
+                peak_memory = torch.cuda.max_memory_allocated()
+                memory_used = (peak_memory - start_memory) / (1024 ** 2)  # Convert to MB
+                memory_usage.append(memory_used)
+            
+            latency_ms = (end_time - start_time) * 1000
+            latencies.append(latency_ms)
+            
+            # Small delay between runs
+            await asyncio.sleep(0.1)
+        
+        # Clean up
+        if model:
+            del model
+        if tokenizer:
+            del tokenizer
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        # Calculate statistics
+        avg_latency = float(np.mean(latencies))
+        avg_memory = float(np.mean(memory_usage)) if memory_usage else 0
+        
+        return BenchmarkResult(
+            model_id=model_id,
+            task_type=task_type,
+            latency_ms=avg_latency,
+            memory_usage_mb=avg_memory,
+            throughput=1000 / avg_latency if avg_latency > 0 else 0
+        )
+    
+    async def _run_warmup(self, model_id: str, task_type: TaskType, sample: Dict,
+                     model=None, tokenizer=None, nlp_pipeline=None, requirements=None):
+        """Run warmup inference to initialize model"""
+        try:
+            with torch.no_grad():
+                if task_type == TaskType.TRANSLATION and nlp_pipeline:
+                    nlp_pipeline(sample["text"], max_length=50)
+                    
+                elif task_type == TaskType.TRANSLATION and model and tokenizer:
+                    inputs = tokenizer(
+                        sample["text"], 
+                        return_tensors="pt", 
+                        truncation=True
+                    ).to(self.device)
+                    model.generate(**inputs, max_new_tokens=20)
+                    
+                elif task_type == TaskType.TEXT_CLASSIFICATION and model and tokenizer:
+                    inputs = tokenizer(
+                        sample["text"], 
+                        return_tensors="pt", 
+                        truncation=True
+                    ).to(self.device)
+                    model(**inputs)
+                    
+                elif task_type == TaskType.TEXT_GENERATION and model and tokenizer:
+                    inputs = tokenizer(
+                        sample["text"], 
+                        return_tensors="pt", 
+                        truncation=True
+                    ).to(self.device)
+                    model.generate(**inputs, max_new_tokens=10)
+                    
+                elif nlp_pipeline:
+                    nlp_pipeline(sample["text"])
+                    
+        except Exception as e:
+            raise e
+    
+    def _get_task_sample(self, task_type: TaskType) -> Dict[str, Any]:
+        """Get sample data for benchmarking"""
+        samples = {
+            TaskType.TEXT_CLASSIFICATION: {
+                "text": "This is a sample text for classification benchmarking."
+            },
+            TaskType.TEXT_GENERATION: {
+                "text": "Once upon a time in a land far away",
+            },
+            TaskType.SUMMARIZATION: {
+                "text": """Artificial intelligence is transforming industries across the globe. 
+                From healthcare to finance, AI systems are being deployed to solve complex problems. 
+                Machine learning algorithms can now diagnose diseases, predict market trends, 
+                and even create art. The rapid advancement of AI technology brings both opportunities 
+                and challenges that society must address."""
+            },
+            TaskType.QUESTION_ANSWERING: {
+                "context": "The Eiffel Tower is located in Paris, France.",
+                "question": "Where is the Eiffel Tower?"
+            },
+            TaskType.TRANSLATION: {
+                "text": "Hello, how are you today?"
+            },
+            TaskType.TEXT_TO_SPEECH: {
+                "text": "Hello, this is a test of the text to speech system."
+            },
+            TaskType.SPEECH_TO_TEXT: {
+                "text": "This is a sample audio transcription test."
+            },
+            TaskType.OCR: {
+                "text": "Sample text from an image."
+            }
+        }
+        
+        return samples.get(task_type, {"text": "Sample text for benchmarking."})
+    
+    def _get_default_samples(self) -> Dict[str, Any]:
+        """Get default sample data for various tasks"""
+        return {
+            "text_classification": [
+                {"text": "I love this product, it's amazing!", "label": "positive"},
+                {"text": "This is the worst experience ever.", "label": "negative"}
+            ],
+            "summarization": [
+                {"text": "Long article about AI advancements..."}
+            ],
+            "translation": [
+                {"text": "Hello world", "source_lang": "en", "target_lang": "fr"}
+            ]
+        }

src/agents/deployment_agent.py

@@ -0,0 +1,402 @@
+"""
+Deployment Agent - Generates deployment code and configuration
+"""
+
+import os
+import yaml
+import torch
+from datetime import datetime
+from typing import Dict, Optional
+from jinja2 import Template
+
+from src.models.schemas import (
+    TaskType, DeploymentType, BenchmarkResult, UserRequirements
+)
+
+
+class DeploymentAgent:
+    """
+    Generates production-ready deployment code for selected models.
+    
+    Supports FastAPI, Gradio, and Docker deployments with
+    appropriate configuration files.
+    """
+    
+    def __init__(self, output_dir: str = "deployments"):
+        self.output_dir = output_dir
+        self._load_templates()
+    
+    def _load_templates(self):
+        """Load deployment templates"""
+        self.templates = {}
+        
+        # FastAPI template
+        fastapi_template = '''"""
+FastAPI deployment for {{ model_id }}
+Generated by HuggingFace Model Selector
+"""
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from transformers import pipeline
+import torch
+import uvicorn
+import time
+from typing import Dict, Any
+
+app = FastAPI(
+    title="{{ model_id }} API",
+    description="Model deployment for {{ task_type }}",
+    version="1.0.0"
+)
+
+# Load model
+print("Loading model {{ model_id }}...")
+model = pipeline("{{ task_type }}", model="{{ model_id }}")
+print("Model loaded successfully!")
+
+class InferenceRequest(BaseModel):
+    text: str
+    parameters: Dict[str, Any] = {}
+
+class InferenceResponse(BaseModel):
+    result: Any
+    inference_time: float
+
+@app.post("/predict", response_model=InferenceResponse)
+async def predict(request: InferenceRequest):
+    """Run inference on input text"""
+    try:
+        start_time = time.time()
+        result = model(request.text, **request.parameters)
+        inference_time = time.time() - start_time
+        
+        return InferenceResponse(
+            result=result,
+            inference_time=inference_time
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {"status": "healthy", "model": "{{ model_id }}"}
+
+@app.get("/info")
+async def info():
+    """Model information"""
+    return {
+        "model_id": "{{ model_id }}",
+        "task": "{{ task_type }}",
+        "device": "cuda" if torch.cuda.is_available() else "cpu"
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+'''
+        self.templates[DeploymentType.FASTAPI] = Template(fastapi_template)
+        
+        # Gradio template
+        gradio_template = '''"""
+Gradio deployment for {{ model_id }}
+Generated by HuggingFace Model Selector
+"""
+
+import gradio as gr
+from transformers import pipeline
+import torch
+
+# Load model
+print("Loading model {{ model_id }}...")
+model = pipeline("{{ task_type }}", model="{{ model_id }}")
+print("Model loaded successfully!")
+
+def predict(text):
+    """Run inference on input text"""
+    try:
+        result = model(text)
+        return result
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Create interface
+interface = gr.Interface(
+    fn=predict,
+    inputs=gr.Textbox(label="Input Text", lines=3),
+    outputs=gr.Textbox(label="Result", lines=5),
+    title="{{ model_id }}",
+    description="Model deployment for {{ task_type }}",
+    examples=[["This is a sample input"]]
+)
+
+if __name__ == "__main__":
+    interface.launch(server_name="0.0.0.0", server_port=7860)
+'''
+        self.templates[DeploymentType.GRADIO] = Template(gradio_template)
+        
+        # Dockerfile template
+        docker_template = '''FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    gcc \\
+    g++ \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Run the application
+CMD ["python", "app.py"]
+'''
+        self.templates["dockerfile"] = Template(docker_template)
+    
+    def generate_deployment(self, 
+                          model_id: str,
+                          task_type: TaskType,
+                          deployment_type: DeploymentType,
+                          benchmark_results: Optional[BenchmarkResult] = None,
+                          requirements: Optional[UserRequirements] = None) -> Dict[str, str]:
+        """
+        Generate deployment code and configuration.
+        
+        Returns:
+            Dictionary mapping filenames to file contents
+        """
+        deployment_files = {}
+        
+        # Create timestamp for unique folder
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        safe_model_id = model_id.replace("/", "_")
+        deploy_folder = f"{self.output_dir}/{safe_model_id}_{timestamp}"
+        
+        # Generate main application file
+        if deployment_type == DeploymentType.FASTAPI:
+            deployment_files["app.py"] = self.templates[DeploymentType.FASTAPI].render(
+                model_id=model_id,
+                task_type=task_type.value
+            )
+        elif deployment_type == DeploymentType.GRADIO:
+            deployment_files["app.py"] = self.templates[DeploymentType.GRADIO].render(
+                model_id=model_id,
+                task_type=task_type.value
+            )
+        
+        # Generate requirements.txt
+        deployment_files["requirements.txt"] = self._generate_requirements(
+            task_type, deployment_type
+        )
+        
+        # Generate Dockerfile if requested
+        if deployment_type == DeploymentType.DOCKER:
+            deployment_files["Dockerfile"] = self.templates["dockerfile"].render()
+            
+            # Generate docker-compose.yml
+            deployment_files["docker-compose.yml"] = self._generate_docker_compose(
+                model_id, requirements
+            )
+        
+        # Generate configuration file
+        deployment_files["config.yaml"] = self._generate_config(
+            model_id, task_type, benchmark_results, requirements
+        )
+        
+        # Generate README
+        deployment_files["README.md"] = self._generate_readme(
+            model_id, task_type, deployment_type, benchmark_results
+        )
+        
+        # Add folder info
+        deployment_files["_folder"] = deploy_folder
+        
+        return deployment_files
+    
+    def _generate_requirements(self, task_type: TaskType, deployment_type: DeploymentType) -> str:
+        """Generate requirements.txt"""
+        requirements = "# Generated requirements\n"
+        requirements += "transformers>=4.35.0\n"
+        requirements += "torch>=2.0.0\n"
+        requirements += "huggingface-hub>=0.19.0\n"
+        
+        if deployment_type == DeploymentType.FASTAPI:
+            requirements += "fastapi>=0.104.0\n"
+            requirements += "uvicorn>=0.24.0\n"
+            requirements += "pydantic>=2.0.0\n"
+        elif deployment_type == DeploymentType.GRADIO:
+            requirements += "gradio>=4.0.0\n"
+        
+       # Task-specific requirements - using correct TaskType names
+        if task_type in [TaskType.IMAGE_CLASSIFICATION, TaskType.OBJECT_DETECTION]:
+            requirements += "pillow>=10.0.0\n"
+        elif task_type == TaskType.SPEECH_TO_TEXT:  # Changed from SPEECH_RECOGNITION
+            requirements += "librosa>=0.10.0\n"
+        elif task_type == TaskType.TEXT_TO_SPEECH:
+            requirements += "librosa>=0.10.0\n"
+        elif task_type == TaskType.OCR:
+            requirements += "pillow>=10.0.0\n"
+            requirements += "pytesseract>=0.3.10\n"
+        
+        return requirements
+    
+    def _generate_docker_compose(self, model_id: str, requirements: Optional[UserRequirements]) -> str:
+        """Generate docker-compose.yml"""
+        compose = "version: '3.8'\n\n"
+        compose += "services:\n"
+        compose += "  model-service:\n"
+        compose += "    build: .\n"
+        compose += "    ports:\n"
+        compose += "      - \"8000:8000\"\n"
+        compose += "    environment:\n"
+        compose += f"      - MODEL_ID={model_id}\n"
+        compose += "    restart: unless-stopped\n"
+        
+        # Add GPU support if needed
+        if requirements and any("gpu" in c.value for c in requirements.hardware_constraints):
+            compose += "    runtime: nvidia\n"
+            compose += "    environment:\n"
+            compose += "      - NVIDIA_VISIBLE_DEVICES=all\n"
+        
+        return compose
+    
+    def _generate_config(self, model_id: str, task_type: TaskType,
+                        benchmark_results: Optional[BenchmarkResult],
+                        requirements: Optional[UserRequirements]) -> str:
+        """Generate YAML configuration"""
+        config = {
+            "model": {
+                "id": model_id,
+                "task": task_type.value,
+            },
+            "deployment": {
+                "batch_size": 1,
+                "max_length": 512,
+                "device": "cuda" if torch.cuda.is_available() else "cpu"
+            }
+        }
+        
+        if benchmark_results and not benchmark_results.error:
+            config["performance"] = {
+                "latency_ms": benchmark_results.latency_ms,
+                "memory_mb": benchmark_results.memory_usage_mb,
+                "throughput_sps": benchmark_results.throughput
+            }
+        
+        if requirements:
+            config["requirements"] = {}
+            
+            # Add hardware constraints
+            if requirements.hardware_constraints:
+                config["requirements"]["hardware_constraints"] = [c.value for c in requirements.hardware_constraints]
+            
+            # Add max model size
+            if requirements.max_model_size_gb:
+                config["requirements"]["max_model_size_gb"] = requirements.max_model_size_gb
+            
+            # Add task-specific requirements based on task type
+            if requirements.task_type == TaskType.TRANSLATION and requirements.translation_reqs:
+                req = requirements.translation_reqs
+                config["requirements"]["source_language"] = req.source_language.value
+                config["requirements"]["target_language"] = req.target_language.value
+                if req.domain:
+                    config["requirements"]["domain"] = req.domain
+            
+            elif requirements.task_type == TaskType.TEXT_TO_SPEECH and requirements.tts_reqs:
+                req = requirements.tts_reqs
+                config["requirements"]["language"] = req.language.value
+                config["requirements"]["voice_type"] = req.voice_type.value
+            
+            elif requirements.task_type == TaskType.SPEECH_TO_TEXT and requirements.stt_reqs:
+                req = requirements.stt_reqs
+                config["requirements"]["language"] = req.language.value
+                if req.domain:
+                    config["requirements"]["domain"] = req.domain
+            
+            elif requirements.llm_reqs:
+                req = requirements.llm_reqs
+                config["requirements"]["model_size"] = req.model_size.value
+                config["requirements"]["context_length"] = req.context_length
+            
+            elif requirements.ocr_reqs:
+                req = requirements.ocr_reqs
+                config["requirements"]["languages"] = [lang.value for lang in req.languages]
+                config["requirements"]["handwritten"] = req.handwritten
+    
+        return yaml.dump(config, default_flow_style=False)
+    
+    def _generate_readme(self, model_id: str, task_type: TaskType,
+                        deployment_type: DeploymentType,
+                        benchmark_results: Optional[BenchmarkResult]) -> str:
+        """Generate README.md"""
+        readme = f"# {model_id} Deployment\n\n"
+        readme += "This deployment was automatically generated by the HuggingFace Model Selector.\n\n"
+        readme += "## Model Information\n\n"
+        readme += f"- **Model ID**: {model_id}\n"
+        readme += f"- **Task**: {task_type.value}\n"
+        readme += f"- **Deployment Type**: {deployment_type.value}\n\n"
+        
+        if benchmark_results and not benchmark_results.error:
+            readme += "## Performance Metrics\n\n"
+            readme += f"- **Average Latency**: {benchmark_results.latency_ms:.2f} ms\n"
+            readme += f"- **Memory Usage**: {benchmark_results.memory_usage_mb:.2f} MB\n"
+            readme += f"- **Throughput**: {benchmark_results.throughput_samples_per_second:.2f} samples/second\n\n"
+        
+        readme += "## Quick Start\n\n"
+        readme += "### 1. Install dependencies\n"
+        readme += "```bash\n"
+        readme += "pip install -r requirements.txt\n"
+        readme += "```\n\n"
+        
+        readme += "### 2. Run the application\n"
+        readme += "```bash\n"
+        readme += "python app.py\n"
+        readme += "```\n\n"
+        
+        readme += "### 3. Test the API\n\n"
+        
+        if deployment_type == DeploymentType.FASTAPI:
+            readme += "```bash\n"
+            readme += "# Health check\n"
+            readme += "curl http://localhost:8000/health\n\n"
+            readme += "# Run inference\n"
+            readme += 'curl -X POST http://localhost:8000/predict \\\n'
+            readme += '  -H "Content-Type: application/json" \\\n'
+            readme += '  -d \'{"text": "Your input text here"}\'\n'
+            readme += "```\n"
+        elif deployment_type == DeploymentType.GRADIO:
+            readme += "Open http://localhost:7860 in your browser to use the Gradio interface.\n"
+        
+        if deployment_type == DeploymentType.DOCKER:
+            readme += "\n## Docker Deployment\n\n"
+            readme += "```bash\n"
+            readme += "# Build the image\n"
+            readme += "docker build -t model-service .\n\n"
+            readme += "# Run the container\n"
+            readme += "docker run -p 8000:8000 model-service\n\n"
+            readme += "# Or use docker-compose\n"
+            readme += "docker-compose up\n"
+            readme += "```\n"
+        
+        return readme
+    
+    def save_deployment_files(self, deployment_files: Dict[str, str]) -> str:
+        """Save generated files to disk"""
+        folder = deployment_files.pop("_folder")
+        os.makedirs(folder, exist_ok=True)
+        
+        for filename, content in deployment_files.items():
+            filepath = os.path.join(folder, filename)
+            with open(filepath, "w", encoding="utf-8") as f:
+                f.write(content)
+            print(f"     Created {filepath}")
+        
+        return folder

src/agents/evaluation_agent.py

@@ -0,0 +1,312 @@
+"""
+Evaluation Agent - Scores speech and translation models
+"""
+
+import numpy as np
+from datetime import datetime, timezone
+from typing import List, Dict, Optional
+
+from src.models.schemas import (
+    ModelMetadata, UserRequirements, HardwareConstraint, 
+    ModelScore, TaskType
+)
+
+
+class EvaluationAgent:
+    """
+    Evaluates and scores translation, TTS, and STT models.
+    """
+    
+    def __init__(self, weights: Dict[str, float] = None):
+        self.weights = weights or {
+            'downloads': 0.20,
+            'recency': 0.15,
+            'license': 0.10,
+            'size': 0.15,
+            'performance': 0.25,
+            'language_match': 0.15
+        }
+        
+    def score_models(self, 
+                    models: List[ModelMetadata], 
+                    requirements: UserRequirements) -> List[ModelScore]:
+        """Score models based on multiple criteria"""
+        scored_models = []
+        
+        for model in models:
+            scores = {}
+            
+            # Common scores
+            scores['downloads'] = self._score_downloads(model.downloads)
+            scores['recency'] = self._score_recency(model.last_modified)
+            scores['license'] = self._score_license(model.license)
+            scores['size'] = self._score_size(model.model_size, requirements)
+            scores['performance'] = self._score_performance(model, requirements)
+            scores['language_match'] = self._score_language_match(model, requirements)
+            
+            # Task-specific scores
+            if model.task_type in [TaskType.TEXT_GENERATION, TaskType.CHAT, 
+                                  TaskType.INSTRUCTION_FOLLOWING, TaskType.CODE_GENERATION,
+                                  TaskType.QUESTION_ANSWERING, TaskType.SUMMARIZATION]:
+                scores['llm_capabilities'] = self._score_llm_capabilities(model, requirements)
+            elif model.task_type in [TaskType.OCR, TaskType.DOCUMENT_UNDERSTANDING]:
+                scores['ocr_capabilities'] = self._score_ocr_capabilities(model, requirements)
+            
+            # Calculate weighted total
+            total_score = 0.0
+            weight_sum = 0.0
+            
+            all_weights = {
+                'downloads': 0.15,
+                'recency': 0.10,
+                'license': 0.05,
+                'size': 0.10,
+                'performance': 0.20,
+                'language_match': 0.15,
+                'llm_capabilities': 0.25,
+                'ocr_capabilities': 0.25
+            }
+            
+            for metric, score in scores.items():
+                if metric in all_weights:
+                    total_score += score * all_weights[metric]
+                    weight_sum += all_weights[metric]
+            
+            if weight_sum > 0:
+                total_score /= weight_sum
+            
+            # Apply hardware penalty
+            hardware_penalty = self._check_hardware_constraints(model, requirements)
+            total_score *= hardware_penalty
+            
+            scored_models.append(ModelScore(
+                model_id=model.model_id,
+                task_type=model.task_type,
+                total_score=float(total_score),
+                component_scores=scores,
+                metadata=model
+            ))
+        
+        return sorted(scored_models, key=lambda x: x.total_score, reverse=True)
+    
+    def _score_downloads(self, downloads: int) -> float:
+        """Score based on downloads (log scale)"""
+        if downloads <= 0:
+            return 0.0
+        log_downloads = np.log10(downloads + 1)
+        return min(log_downloads / 6.0, 1.0)
+    
+    def _score_recency(self, last_modified) -> float:
+        """Score based on recency - FIXED timezone issue"""
+        if not last_modified:
+            return 0.5
+        
+        try:
+            # Make last_modified timezone-naive for comparison
+            if hasattr(last_modified, 'tzinfo') and last_modified.tzinfo is not None:
+                # Convert to timezone-naive by removing timezone info
+                last_modified = last_modified.replace(tzinfo=None)
+            
+            # Get current time as timezone-naive
+            now = datetime.now()
+            
+            # Calculate days difference
+            days_since_update = (now - last_modified).days
+            
+            if days_since_update < 30:
+                return 1.0
+            elif days_since_update < 90:
+                return 0.8
+            elif days_since_update < 180:
+                return 0.6
+            elif days_since_update < 365:
+                return 0.4
+            else:
+                return 0.2
+                
+        except Exception as e:
+            print(f"      Warning: Error calculating recency: {e}")
+            return 0.5
+    
+    def _score_license(self, license: str) -> float:
+        """Score based on license"""
+        license_lower = license.lower()
+        open_licenses = ['mit', 'apache', 'bsd', 'cc', 'gpl', 'lgpl']
+        
+        if any(open_license in license_lower for open_license in open_licenses):
+            return 0.9
+        elif 'commercial' in license_lower:
+            return 0.5
+        else:
+            return 0.7
+    
+    def _score_size(self, model_size: Optional[float], requirements: UserRequirements) -> float:
+        """Score based on size - smaller is better"""
+        if not model_size:
+            return 0.5
+        
+        if requirements.max_model_size_gb:
+            if model_size > requirements.max_model_size_gb:
+                return 0.0
+            size_ratio = 1.0 - (model_size / requirements.max_model_size_gb)
+            return 0.5 + (size_ratio * 0.5)
+        
+        # No constraint - smaller is better
+        if model_size < 0.5:
+            return 1.0
+        elif model_size < 1.0:
+            return 0.9
+        elif model_size < 2.0:
+            return 0.7
+        elif model_size < 5.0:
+            return 0.5
+        else:
+            return 0.3
+    
+    def _score_performance(self, model: ModelMetadata, requirements: UserRequirements) -> float:
+        """Score based on performance metrics"""
+        metrics = model.performance_metrics
+        
+        if not metrics:
+            return 0.5
+        
+        if model.task_type == TaskType.TRANSLATION:
+            # Prefer BLEU scores
+            if 'bleu' in metrics:
+                return min(metrics['bleu'] / 50, 1.0)  # BLEU up to 50
+            return 0.5
+        
+        elif model.task_type == TaskType.SPEECH_TO_TEXT:
+            # Prefer low WER
+            if 'wer' in metrics:
+                return max(0, 1.0 - (metrics['wer'] / 100))
+            return 0.5
+        
+        elif model.task_type == TaskType.TEXT_TO_SPEECH:
+            # Prefer more voices and higher sample rate
+            score = 0.5
+            if model.voice_count > 0:
+                score += min(model.voice_count / 10, 0.3)
+            if model.sample_rate and model.sample_rate >= 16000:
+                score += 0.2
+            return min(score, 1.0)
+        
+        return 0.5
+    
+    def _score_language_match(self, model: ModelMetadata, requirements: UserRequirements) -> float:
+        """Score based on language support"""
+        if requirements.task_type == TaskType.TRANSLATION and requirements.translation_reqs:
+            req = requirements.translation_reqs
+            source = req.source_language.value
+            target = req.target_language.value
+            
+            score = 0.5
+            if model.source_languages and source in model.source_languages:
+                score += 0.25
+            if model.target_languages and target in model.target_languages:
+                score += 0.25
+            return score
+        
+        elif requirements.task_type == TaskType.TEXT_TO_SPEECH and requirements.tts_reqs:
+            req = requirements.tts_reqs
+            lang = req.language.value
+            
+            if model.languages and lang in model.languages:
+                return 1.0
+            return 0.5
+        
+        elif requirements.task_type == TaskType.SPEECH_TO_TEXT and requirements.stt_reqs:
+            req = requirements.stt_reqs
+            lang = req.language.value
+            
+            if model.languages and lang in model.languages:
+                return 1.0
+            return 0.5
+        
+        return 0.5
+    
+    def _score_llm_capabilities(self, model: ModelMetadata, requirements: UserRequirements) -> float:
+        """Score LLM based on capabilities"""
+        if not requirements.llm_reqs:
+            return 0.5
+        
+        req = requirements.llm_reqs
+        score = 0.5
+        
+        # Check context length
+        if model.context_length and req.context_length:
+            if model.context_length >= req.context_length:
+                score += 0.2
+            else:
+                score -= 0.1
+        
+        # Check chat template
+        if req.wants_chat_template and model.has_chat_template:
+            score += 0.2
+        
+        # Check function calling
+        if req.wants_function_calling and model.supports_function_calling:
+            score += 0.2
+        
+        # Check code generation
+        if req.wants_code_generation and model.supports_code:
+            score += 0.2
+        
+        # Check instruction following
+        if req.wants_instruction_following and model.supports_instruction:
+            score += 0.2
+        
+        # Check quantization support
+        if req.quantization and req.quantization in model.quantization_supported:
+            score += 0.1
+        
+        return min(score, 1.0)
+    
+    def _score_ocr_capabilities(self, model: ModelMetadata, requirements: UserRequirements) -> float:
+        """Score OCR model based on capabilities"""
+        if not requirements.ocr_reqs:
+            return 0.5
+        
+        req = requirements.ocr_reqs
+        score = 0.5
+        
+        # Check handwriting support
+        if req.handwritten and model.supports_handwriting:
+            score += 0.3
+        elif req.handwritten and not model.supports_handwriting:
+            score -= 0.2
+        
+        # Check layout analysis
+        if req.wants_layout_analysis and model.supports_layout:
+            score += 0.2
+        
+        # Check table extraction
+        if req.wants_table_extraction and model.supports_tables:
+            score += 0.2
+        
+        # Check formula recognition
+        if req.wants_formula_recognition and model.supports_formulas:
+            score += 0.2
+        
+        return min(score, 1.0)
+    
+    def _check_hardware_constraints(self, model: ModelMetadata, 
+                                   requirements: UserRequirements) -> float:
+        """Apply penalty if hardware constraints not met"""
+        if not requirements.hardware_constraints:
+            return 1.0
+        
+        hardware = model.hardware_requirements
+        
+        for constraint in requirements.hardware_constraints:
+            if constraint == HardwareConstraint.CPU:
+                if hardware.get('cpu_compatible', True):
+                    return 1.0
+            elif constraint in [HardwareConstraint.GPU_4GB, HardwareConstraint.GPU_8GB, 
+                               HardwareConstraint.GPU_16GB, HardwareConstraint.GPU_24GB,
+                               HardwareConstraint.GPU_40GB, HardwareConstraint.GPU_80GB]:
+                if hardware.get('gpu_required', False):
+                    return 0.9  # Small penalty for requiring GPU
+                return 1.0
+        
+        return 0.8

src/agents/input_agent.py

@@ -0,0 +1,369 @@
+"""
+Input Agent - Parses user requirements for all model types
+"""
+
+import re
+from typing import List, Optional
+
+from src.models.schemas import (
+    TaskType, HardwareConstraint, UserRequirements,
+    TranslationRequirements, TTSRequirements, STTRequirements,
+    LLMRequirements, OCRRequirements,
+    Language, VoiceType, ModelSize
+)
+
+
+class InputAgent:
+    """
+    Analyzes user's task description and extracts structured requirements
+    for translation, TTS, STT, LLMs, and OCR.
+    """
+    
+    def __init__(self):
+        # Map keywords to task types
+        self.task_keywords = {
+            # Translation
+            TaskType.TRANSLATION: [
+                "translate", "translation", "convert language", "english to french",
+                "en to es", "german", "spanish", "french"
+            ],
+            
+            # TTS
+            TaskType.TEXT_TO_SPEECH: [
+                "text to speech", "tts", "speech synthesis", "voice", 
+                "speak", "audio from text", "read aloud"
+            ],
+            
+            # STT
+            TaskType.SPEECH_TO_TEXT: [
+                "speech to text", "stt", "transcribe", "audio to text",
+                "asr", "automatic speech recognition", "voice to text"
+            ],
+            
+            # LLMs
+            TaskType.TEXT_GENERATION: [
+                "generate", "write", "completion", "continue", "story",
+                "llm", "large language model", "gpt", "llama"
+            ],
+            TaskType.CHAT: [
+                "chat", "conversation", "dialogue", "chatbot", "assistant"
+            ],
+            TaskType.INSTRUCTION_FOLLOWING: [
+                "instruction", "follow instruction", "task", "command"
+            ],
+            TaskType.CODE_GENERATION: [
+                "code", "programming", "python", "javascript", "function"
+            ],
+            TaskType.QUESTION_ANSWERING: [
+                "question answering", "qa", "answer question", "extract answer"
+            ],
+            TaskType.SUMMARIZATION: [
+                "summarize", "summary", "abstract", "condense", "tl;dr"
+            ],
+            
+            # OCR
+            TaskType.OCR: [
+                "ocr", "optical character recognition", "extract text from image",
+                "read image", "scan document", "image to text", "text from photo"
+            ],
+            TaskType.DOCUMENT_UNDERSTANDING: [
+                "document understanding", "document qa", "document analysis",
+                "form understanding", "invoice parsing"
+            ]
+        }
+        
+    def parse_requirements(self, task_description: str) -> UserRequirements:
+        """
+        Parse user's task description and extract requirements.
+        """
+        task_type = self._extract_task_type(task_description)
+        hardware_constraints = self._extract_hardware_constraints(task_description)
+        max_model_size = self._extract_model_size(task_description)
+        
+        # Parse task-specific requirements
+        translation_reqs = None
+        tts_reqs = None
+        stt_reqs = None
+        llm_reqs = None
+        ocr_reqs = None
+        
+        if task_type == TaskType.TRANSLATION:
+            translation_reqs = self._parse_translation_requirements(task_description)
+        elif task_type == TaskType.TEXT_TO_SPEECH:
+            tts_reqs = self._parse_tts_requirements(task_description)
+        elif task_type == TaskType.SPEECH_TO_TEXT:
+            stt_reqs = self._parse_stt_requirements(task_description)
+        elif task_type in [TaskType.TEXT_GENERATION, TaskType.CHAT, 
+                          TaskType.INSTRUCTION_FOLLOWING, TaskType.CODE_GENERATION,
+                          TaskType.QUESTION_ANSWERING, TaskType.SUMMARIZATION]:
+            llm_reqs = self._parse_llm_requirements(task_description, task_type)
+        elif task_type in [TaskType.OCR, TaskType.DOCUMENT_UNDERSTANDING]:
+            ocr_reqs = self._parse_ocr_requirements(task_description)
+        
+        return UserRequirements(
+            task_type=task_type,
+            hardware_constraints=hardware_constraints,
+            max_model_size_gb=max_model_size,
+            translation_reqs=translation_reqs,
+            tts_reqs=tts_reqs,
+            stt_reqs=stt_reqs,
+            llm_reqs=llm_reqs,
+            ocr_reqs=ocr_reqs
+        )
+    
+    def _extract_task_type(self, description: str) -> TaskType:
+        """Identify the task from description"""
+        description_lower = description.lower()
+        
+        for task_type, keywords in self.task_keywords.items():
+            if any(keyword in description_lower for keyword in keywords):
+                return task_type
+        
+        # Default to text generation if unsure
+        return TaskType.TEXT_GENERATION
+    
+    def _parse_translation_requirements(self, description: str) -> TranslationRequirements:
+        """Extract translation-specific requirements"""
+        description_lower = description.lower()
+        
+        # Default values
+        source_lang = Language.ENGLISH
+        target_lang = Language.SPANISH
+        
+        # Try to extract language pairs
+        patterns = [
+            r'(?:from\s+)?(\w+)\s+(?:to|in(?:to)?)\s+(\w+)',
+            r'(\w+)[\s-]+to[\s-]+(\w+)',
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, description_lower)
+            if match:
+                lang1, lang2 = match.groups()
+                source_lang = self._map_language(lang1)
+                target_lang = self._map_language(lang2)
+                break
+        
+        # Determine domain
+        domain = None
+        domains = ["medical", "legal", "technical", "financial", "literary"]
+        for d in domains:
+            if d in description_lower:
+                domain = d
+                break
+        
+        # Quality preference
+        quality = "balanced"
+        if "fast" in description_lower or "quick" in description_lower:
+            quality = "speed"
+        elif "high quality" in description_lower or "accurate" in description_lower:
+            quality = "quality"
+        
+        return TranslationRequirements(
+            source_language=source_lang,
+            target_language=target_lang,
+            domain=domain,
+            quality_preference=quality
+        )
+    
+    def _parse_tts_requirements(self, description: str) -> TTSRequirements:
+        """Extract TTS-specific requirements"""
+        description_lower = description.lower()
+        
+        # Extract language
+        language = Language.ENGLISH
+        for lang in Language:
+            if lang.value in description_lower or lang.name.lower() in description_lower:
+                language = lang
+                break
+        
+        # Extract voice type
+        voice = VoiceType.NEUTRAL
+        if "male" in description_lower:
+            voice = VoiceType.MALE
+        elif "female" in description_lower:
+            voice = VoiceType.FEMALE
+        
+        # Check if multiple voices wanted
+        multiple = "multiple voices" in description_lower or "different voices" in description_lower
+        
+        return TTSRequirements(
+            language=language,
+            voice_type=voice,
+            wants_multiple_voices=multiple
+        )
+    
+    def _parse_stt_requirements(self, description: str) -> STTRequirements:
+        """Extract STT-specific requirements"""
+        description_lower = description.lower()
+        
+        # Extract language
+        language = Language.ENGLISH
+        for lang in Language:
+            if lang.value in description_lower or lang.name.lower() in description_lower:
+                language = lang
+                break
+        
+        # Extract domain
+        domain = None
+        if "medical" in description_lower:
+            domain = "medical"
+        elif "telephone" in description_lower or "call" in description_lower:
+            domain = "telephony"
+        elif "meeting" in description_lower:
+            domain = "meeting"
+        
+        # Check for advanced features
+        timestamps = "timestamp" in description_lower or "word timing" in description_lower
+        diarization = "speaker" in description_lower or "who said" in description_lower
+        
+        return STTRequirements(
+            language=language,
+            domain=domain,
+            wants_word_timestamps=timestamps,
+            wants_diarization=diarization
+        )
+    
+    def _parse_llm_requirements(self, description: str, task_type: TaskType) -> LLMRequirements:
+        """Extract LLM-specific requirements"""
+        description_lower = description.lower()
+        
+        # Determine model size preference
+        model_size = ModelSize.MEDIUM
+        if any(x in description_lower for x in ["tiny", "small", "lightweight", "fast"]):
+            model_size = ModelSize.SMALL
+        elif any(x in description_lower for x in ["large", "powerful", "best quality"]):
+            model_size = ModelSize.LARGE
+        elif any(x in description_lower for x in ["xlarge", "huge", "massive"]):
+            model_size = ModelSize.XXLARGE
+        
+        # Context length
+        context_length = 2048  # default
+        context_match = re.search(r'(\d+)[kK]?\s*(context|token)', description_lower)
+        if context_match:
+            val = context_match.group(1)
+            if 'k' in context_match.group(0).lower():
+                context_length = int(val) * 1024
+            else:
+                context_length = int(val)
+        
+        # Check for specific capabilities
+        wants_chat = any(x in description_lower for x in ["chat", "conversation", "dialogue"])
+        wants_code = any(x in description_lower for x in ["code", "programming", "python", "javascript"])
+        wants_instruction = any(x in description_lower for x in ["instruction", "task", "command"])
+        wants_function = any(x in description_lower for x in ["function calling", "tools", "actions"])
+        wants_multilingual = any(x in description_lower for x in ["multilingual", "multiple languages"])
+        
+        # Check for quantization
+        quantization = None
+        if "4bit" in description_lower or "4-bit" in description_lower:
+            quantization = "4bit"
+        elif "8bit" in description_lower or "8-bit" in description_lower:
+            quantization = "8bit"
+        
+        return LLMRequirements(
+            model_size=model_size,
+            context_length=context_length,
+            wants_chat_template=wants_chat,
+            wants_function_calling=wants_function,
+            wants_code_generation=wants_code,
+            wants_instruction_following=wants_instruction,
+            wants_multilingual=wants_multilingual,
+            quantization=quantization
+        )
+    
+    def _parse_ocr_requirements(self, description: str) -> OCRRequirements:
+        """Extract OCR-specific requirements"""
+        description_lower = description.lower()
+        
+        # Extract languages
+        languages = [Language.ENGLISH]
+        for lang in Language:
+            if lang.value in description_lower or lang.name.lower() in description_lower:
+                languages = [lang]
+                break
+        
+        # Check for handwriting
+        handwritten = "handwriting" in description_lower or "handwritten" in description_lower
+        
+        # Document type
+        doc_type = None
+        if "scanned" in description_lower:
+            doc_type = "scanned"
+        elif "photo" in description_lower or "photograph" in description_lower:
+            doc_type = "photo"
+        elif "document" in description_lower:
+            doc_type = "document"
+        
+        # Check for advanced features
+        layout = "layout" in description_lower or "paragraph" in description_lower
+        tables = "table" in description_lower or "spreadsheet" in description_lower
+        formulas = any(x in description_lower for x in ["formula", "equation", "math"])
+        
+        return OCRRequirements(
+            languages=languages,
+            handwritten=handwritten,
+            document_type=doc_type,
+            wants_layout_analysis=layout,
+            wants_table_extraction=tables,
+            wants_formula_recognition=formulas
+        )
+    
+    def _map_language(self, lang_text: str) -> Language:
+        """Map language name/code to Language enum"""
+        lang_map = {
+            "en": Language.ENGLISH, "english": Language.ENGLISH,
+            "es": Language.SPANISH, "spanish": Language.SPANISH,
+            "fr": Language.FRENCH, "french": Language.FRENCH,
+            "de": Language.GERMAN, "german": Language.GERMAN,
+            "it": Language.ITALIAN, "italian": Language.ITALIAN,
+            "pt": Language.PORTUGUESE, "portuguese": Language.PORTUGUESE,
+            "nl": Language.DUTCH, "dutch": Language.DUTCH,
+            "ru": Language.RUSSIAN, "russian": Language.RUSSIAN,
+            "zh": Language.CHINESE, "chinese": Language.CHINESE,
+            "ja": Language.JAPANESE, "japanese": Language.JAPANESE,
+            "ko": Language.KOREAN, "korean": Language.KOREAN,
+            "ar": Language.ARABIC, "arabic": Language.ARABIC,
+            "hi": Language.HINDI, "hindi": Language.HINDI
+        }
+        return lang_map.get(lang_text.lower(), Language.ENGLISH)
+    
+    def _extract_hardware_constraints(self, description: str) -> List[HardwareConstraint]:
+        """Extract hardware constraints"""
+        constraints = []
+        description_lower = description.lower()
+        
+        if any(word in description_lower for word in ["cpu", "no gpu", "without gpu"]):
+            constraints.append(HardwareConstraint.CPU)
+        if any(word in description_lower for word in ["4gb", "4 gb", "small gpu"]):
+            constraints.append(HardwareConstraint.GPU_4GB)
+        if any(word in description_lower for word in ["8gb", "8 gb", "medium gpu"]):
+            constraints.append(HardwareConstraint.GPU_8GB)
+        if any(word in description_lower for word in ["16gb", "16 gb"]):
+            constraints.append(HardwareConstraint.GPU_16GB)
+        if any(word in description_lower for word in ["24gb", "24 gb"]):
+            constraints.append(HardwareConstraint.GPU_24GB)
+        if any(word in description_lower for word in ["40gb", "40 gb", "a100"]):
+            constraints.append(HardwareConstraint.GPU_40GB)
+        if any(word in description_lower for word in ["80gb", "80 gb"]):
+            constraints.append(HardwareConstraint.GPU_80GB)
+        if "tpu" in description_lower:
+            constraints.append(HardwareConstraint.TPU)
+        
+        return constraints if constraints else [HardwareConstraint.CPU]
+    
+    def _extract_model_size(self, description: str) -> Optional[float]:
+        """Extract maximum model size constraint"""
+        size_pattern = r'(\d+(?:\.\d+)?)\s*(gb|mb)'
+        match = re.search(size_pattern, description.lower())
+        
+        if match:
+            size = float(match.group(1))
+            unit = match.group(2).lower()
+            
+            if unit == 'gb':
+                return size
+            elif unit == 'mb':
+                return size / 1024
+        
+        return None

src/agents/research_agent.py

@@ -0,0 +1,560 @@
+"""
+Research Agent - Searches HuggingFace for relevant models
+"""
+
+import asyncio
+import aiohttp
+import re
+from datetime import datetime
+from typing import List, Optional
+from huggingface_hub import HfApi
+
+from src.models.schemas import UserRequirements, ModelMetadata, TaskType
+
+
+class ResearchAgent:
+    """
+    Searches HuggingFace Hub for models matching user requirements.
+    
+    This agent queries the HuggingFace API, fetches model details,
+    and creates ModelMetadata objects for candidate models.
+    """
+    
+    # Pipeline tags for different tasks
+    PIPELINE_TAGS = {
+        # Translation
+        TaskType.TRANSLATION: "translation",
+        
+        # Speech
+        TaskType.TEXT_TO_SPEECH: "text-to-speech",
+        TaskType.SPEECH_TO_TEXT: "automatic-speech-recognition",
+        
+        # LLMs
+        TaskType.TEXT_GENERATION: "text-generation",
+        TaskType.CHAT: "text-generation",
+        TaskType.INSTRUCTION_FOLLOWING: "text-generation",
+        TaskType.CODE_GENERATION: "text-generation",
+        TaskType.QUESTION_ANSWERING: "question-answering",
+        TaskType.SUMMARIZATION: "summarization",
+        
+        # OCR
+        TaskType.OCR: "image-to-text",
+        TaskType.DOCUMENT_UNDERSTANDING: "document-question-answering",
+        
+        #Legacy
+        TaskType.TEXT_CLASSIFICATION: "text-classification",
+        TaskType.NAMED_ENTITY_RECOGNITION: "token-classification",
+        TaskType.IMAGE_CLASSIFICATION: "image-classification",
+        TaskType.OBJECT_DETECTION: "object-detection",
+        TaskType.ZERO_SHOT_CLASSIFICATION: "zero-shot-classification"
+    }
+    
+    def __init__(self):
+        self.api = HfApi()
+        
+    async def search_models(self, requirements: UserRequirements, top_k: int = 20) -> List[ModelMetadata]:
+        """
+        Search for models matching the requirements.
+        
+        Args:
+            requirements: UserRequirements object
+            top_k: Maximum number of models to return
+            
+        Returns:
+            List of ModelMetadata objects
+        """
+        task = requirements.task_type
+        pipeline_tag = self.PIPELINE_TAGS.get(task)
+        
+        print(f"   Searching for {task.value} models (pipeline: {pipeline_tag})...")
+        
+        try:
+            models = []
+            
+            # Method 1: Search by pipeline_tag filter (current API)
+            if pipeline_tag:
+                try:
+                    print(f"    Method 1: Using pipeline_tag filter...")
+                    models = list(self.api.list_models(
+                        filter=f"pipeline_tag:{pipeline_tag}",
+                        sort="downloads",
+                        limit=top_k * 2
+                    ))
+                    print(f"    Found {len(models)} models")
+                except Exception as e:
+                    print(f"    Method 1 failed: {e}")
+                    models = []
+            
+            # Method 1.5: For translation, try specific translation tags
+            if not models and task == TaskType.TRANSLATION:
+                try:
+                    print(f"    Method 1.5: Trying specific translation tags...")
+                    # Try common translation model patterns
+                    search_terms = ["translation", "mbart", "nllb", "m2m", "opus"]
+                    for term in search_terms:
+                        try:
+                            term_models = list(self.api.list_models(
+                                search=term,
+                                sort="downloads",
+                                limit=top_k
+                            ))
+                            models.extend(term_models)
+                            print(f"      Found {len(term_models)} models with '{term}'")
+                        except:
+                            continue
+                    # Remove duplicates
+                    unique_ids = set()
+                    unique_models = []
+                    for m in models:
+                        if m.modelId not in unique_ids:
+                            unique_ids.add(m.modelId)
+                            unique_models.append(m)
+                    models = unique_models
+                    print(f"    Total unique models after search: {len(models)}")
+                except Exception as e:
+                    print(f"    Method 1.5 failed: {e}")
+
+            # Method 2: Try without filter (get popular models)
+            if not models:
+                try:
+                    print(f"    Method 2: Getting popular models...")
+                    models = list(self.api.list_models(
+                        sort="downloads",
+                        limit=top_k * 2
+                    ))
+                    print(f"    Found {len(models)} models")
+                except Exception as e:
+                    print(f"    Method 2 failed: {e}")
+                    models = []
+            
+            # Method 3: Try with search parameter
+            if not models and pipeline_tag:
+                try:
+                    print(f"    Method 3: Using search parameter...")
+                    models = list(self.api.list_models(
+                        search=pipeline_tag,
+                        sort="downloads",
+                        limit=top_k * 2
+                    ))
+                    print(f"    Found {len(models)} models")
+                except Exception as e:
+                    print(f"    Method 3 failed: {e}")
+                    models = []
+            
+            print(f"  Total candidate models: {len(models)}")
+            
+            if not models:
+                print("   No models found from HuggingFace API")
+                return []
+            
+            # Fetch detailed metadata
+            model_details = []
+            for i, model in enumerate(models[:top_k]):
+                try:
+                    print(f"    Processing {i+1}/{min(len(models), top_k)}: {model.modelId}")
+                    
+                    metadata = await self._fetch_model_details(model, requirements)
+                    if metadata:
+                        model_details.append(metadata)
+                        print(f"      Added to candidates")
+                    
+                    await asyncio.sleep(0.1)
+                    
+                except Exception as e:
+                    print(f"      Error: {e}")
+                    continue
+            
+            print(f"   Found {len(model_details)} suitable models")
+            return model_details
+            
+        except Exception as e:
+            print(f"   Error searching models: {e}")
+            import traceback
+            traceback.print_exc()
+            return []
+    
+    async def _fetch_model_details(self, model, requirements: UserRequirements) -> Optional[ModelMetadata]:
+        """Fetch detailed information for a specific model"""
+        try:
+            # Get model info from HuggingFace
+            model_info = self.api.model_info(model.modelId)
+            
+            # Fetch model card content (README.md)
+            model_card = await self._fetch_model_card(model.modelId)
+            
+            # Extract performance metrics from model card
+            performance_metrics = self._extract_performance_metrics(model_card)
+            
+            # Estimate model size
+            model_size = self._estimate_model_size(model_info)
+            
+            # Filter by size constraint if specified
+            if requirements.max_model_size_gb and model_size:
+                if model_size > requirements.max_model_size_gb:
+                    return None
+            
+            # Extract language tags
+            languages = ["en"]  # Default
+            if hasattr(model_info, 'tags'):
+                for tag in model_info.tags:
+                    if tag.startswith("language:"):
+                        languages = [tag.replace("language:", "")]
+                        break
+            
+            # Get license from card data
+            license_info = "unknown"
+            if hasattr(model_info, 'cardData') and model_info.cardData:
+                license_info = model_info.cardData.get("license", "unknown")
+            
+            # Get tags
+            tags = getattr(model_info, 'tags', [])
+            
+            # Get pipeline tag
+            pipeline_tag = getattr(model_info, 'pipeline_tag', None)
+            
+            # Get LLM-specific info
+            llm_info = self._extract_llm_info(model_info, model_card)
+            
+            # Get OCR-specific info
+            ocr_info = self._extract_ocr_info(model_info, model_card)
+            
+            # Determine task type from pipeline tag
+            task_type = self._map_pipeline_to_task(pipeline_tag) or requirements.task_type
+            
+            # Extract source and target languages for translation
+            source_languages = self._extract_source_languages(model_info, model_card)
+            target_languages = self._extract_target_languages(model_info, model_card)
+            
+            # Extract voice count for TTS
+            voice_count = self._extract_voice_count(model_card)
+            
+            # Extract sample rate for audio models
+            sample_rate = self._extract_sample_rate(model_card)
+            
+            # Extract WER for STT
+            wer_score = self._extract_wer(model_card)
+            
+            return ModelMetadata(
+                model_id=model.modelId,
+                task_type=task_type,
+                downloads=getattr(model_info, 'downloads', 0) or 0,
+                likes=getattr(model_info, 'likes', 0) or 0,
+                last_modified=getattr(model_info, 'lastModified', datetime.now()),
+                license=license_info,
+                model_size=model_size,
+                languages=languages,
+                tags=tags,
+                pipeline_tag=pipeline_tag,
+                base_model=getattr(model_info, 'base_model', None),
+                finetuned_from=getattr(model_info, 'finetuned_from', None),
+                performance_metrics=performance_metrics,
+                hardware_requirements=self._extract_hardware_info(model_card),
+                model_card_content=model_card,
+                # Additional fields
+                source_languages=source_languages,
+                target_languages=target_languages,
+                voice_count=voice_count,
+                sample_rate=sample_rate,
+                wer_score=wer_score,
+                context_length=llm_info.get("context_length"),
+                has_chat_template=llm_info.get("has_chat_template", False),
+                supports_function_calling=llm_info.get("supports_function_calling", False),
+                supports_code=llm_info.get("supports_code", False),
+                supports_instruction=llm_info.get("supports_instruction", False),
+                quantization_supported=llm_info.get("quantization_supported", []),
+                supports_handwriting=ocr_info.get("supports_handwriting", False),
+                supports_layout=ocr_info.get("supports_layout", False),
+                supports_tables=ocr_info.get("supports_tables", False),
+                supports_formulas=ocr_info.get("supports_formulas", False),
+                supported_image_formats=ocr_info.get("supported_image_formats", ["jpg", "png"])
+            )
+            
+        except Exception as e:
+            print(f"      Error fetching details: {e}")
+            return None
+    
+    async def _fetch_model_card(self, model_id: str) -> str:
+        """Fetch model card content from HuggingFace"""
+        try:
+            card_url = f"https://huggingface.co/{model_id}/raw/main/README.md"
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.get(card_url, timeout=10) as response:
+                    if response.status == 200:
+                        return await response.text()
+                    return ""
+        except Exception:
+            return ""
+    
+    def _extract_performance_metrics(self, model_card: str) -> dict:
+        """Extract performance metrics from model card text"""
+        metrics = {}
+        
+        # Common metrics to look for
+        metric_patterns = {
+            "accuracy": r"accuracy[\s:]*([\d\.]+)%?",
+            "f1": r"f1[\s:]*([\d\.]+)",
+            "bleu": r"bleu[\s:]*([\d\.]+)",
+            "rouge": r"rouge[\s:]*([\d\.]+)",
+            "perplexity": r"perplexity[\s:]*([\d\.]+)",
+            "precision": r"precision[\s:]*([\d\.]+)",
+            "recall": r"recall[\s:]*([\d\.]+)"
+        }
+        
+        for metric, pattern in metric_patterns.items():
+            matches = re.findall(pattern, model_card.lower())
+            if matches:
+                try:
+                    metrics[metric] = float(matches[0])
+                except ValueError:
+                    pass
+        
+        return metrics
+    
+    def _estimate_model_size(self, model_info) -> Optional[float]:
+        """Estimate model size in GB"""
+        try:
+            # Try to get from config
+            if hasattr(model_info, 'config') and model_info.config:
+                param_size = model_info.config.get("num_parameters", 0)
+                if param_size:
+                    # Rough estimate: 4 bytes per parameter (float32)
+                    size_gb = (param_size * 4) / (1024 ** 3)
+                    return size_gb
+            
+            # Alternative: look for safetensors files
+            if hasattr(model_info, 'siblings'):
+                total_size = 0
+                for sibling in model_info.siblings:
+                    if hasattr(sibling, 'rfilename') and sibling.rfilename.endswith(('.safetensors', '.bin')):
+                        if hasattr(sibling, 'size'):
+                            total_size += sibling.size
+                if total_size > 0:
+                    return total_size / (1024 ** 3)  # Convert to GB
+        except Exception:
+            pass
+        
+        # Default size based on model name patterns
+        model_id = model_info.modelId.lower() if hasattr(model_info, 'modelId') else ""
+        
+        if any(x in model_id for x in ['tiny', 'mini', 'albert']):
+            return 0.05  # 50MB
+        elif any(x in model_id for x in ['small', 'distilbert']):
+            return 0.2   # 200MB
+        elif any(x in model_id for x in ['base', 'bert-base']):
+            return 0.5   # 500MB
+        elif any(x in model_id for x in ['large', 'bert-large']):
+            return 1.5   # 1.5GB
+        elif any(x in model_id for x in ['xl', 'gpt2-xl']):
+            return 3.0   # 3GB
+        
+        return None
+    
+    def _extract_hardware_info(self, model_card: str) -> dict:
+        """Extract hardware requirements from model card"""
+        hardware = {
+            "cpu_compatible": True,  # Assume CPU compatible by default
+            "gpu_required": False,
+            "tpu_compatible": False,
+            "min_ram_gb": 4  # Default assumption
+        }
+        
+        card_lower = model_card.lower()
+        
+        if "gpu" in card_lower and "no gpu" not in card_lower:
+            hardware["gpu_required"] = True
+        if "tpu" in card_lower:
+            hardware["tpu_compatible"] = True
+        
+        # Look for RAM requirements
+        ram_match = re.search(r'(\d+)\s*gb?\s*ram', card_lower)
+        if ram_match:
+            hardware["min_ram_gb"] = int(ram_match.group(1))
+        
+        return hardware
+    
+    def _extract_source_languages(self, model_info, model_card: str) -> List[str]:
+        """Extract source languages for translation models"""
+        languages = []
+        if hasattr(model_info, 'cardData') and model_info.cardData:
+            src_langs = model_info.cardData.get("src_lang", [])
+            if src_langs:
+                if isinstance(src_langs, str):
+                    languages = [src_langs]
+                elif isinstance(src_langs, list):
+                    languages = src_langs
+        return languages or ["en"]
+    
+    def _extract_target_languages(self, model_info, model_card: str) -> List[str]:
+        """Extract target languages for translation models"""
+        languages = []
+        if hasattr(model_info, 'cardData') and model_info.cardData:
+            tgt_langs = model_info.cardData.get("tgt_lang", [])
+            if tgt_langs:
+                if isinstance(tgt_langs, str):
+                    languages = [tgt_langs]
+                elif isinstance(tgt_langs, list):
+                    languages = tgt_langs
+        return languages or ["en"]
+    
+    def _extract_voice_count(self, model_card: str) -> int:
+        """Extract number of voices for TTS models"""
+        patterns = [
+            r'(\d+)\s+voices?',
+            r'voices?:?\s*(\d+)',
+            r'multi-voice.*?(\d+)',
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, model_card.lower())
+            if match:
+                try:
+                    return int(match.group(1))
+                except:
+                    pass
+        return 0
+    
+    def _extract_sample_rate(self, model_card: str) -> Optional[int]:
+        """Extract sample rate for audio models"""
+        patterns = [
+            r'(\d+)\s*[kK]?[hH][zZ]',
+            r'sample rate:?\s*(\d+)',
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, model_card.lower())
+            if match:
+                try:
+                    rate = int(match.group(1))
+                    if 'k' in match.group(0).lower():
+                        rate *= 1000
+                    return rate
+                except:
+                    pass
+        return None
+    
+    def _extract_wer(self, model_card: str) -> Optional[float]:
+        """Extract Word Error Rate for STT models"""
+        patterns = [
+            r'wer:?\s*([\d.]+)%?',
+            r'word error rate:?\s*([\d.]+)%?',
+            r'wer[\s=]+([\d.]+)',
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, model_card.lower())
+            if match:
+                try:
+                    return float(match.group(1))
+                except:
+                    pass
+        return None
+    
+    def _extract_llm_info(self, model_info, model_card: str) -> dict:
+        """Extract LLM-specific information"""
+        info = {
+            "context_length": 2048,  # default
+            "has_chat_template": False,
+            "supports_function_calling": False,
+            "supports_code": False,
+            "supports_instruction": False,
+            "quantization_supported": []
+        }
+        
+        card_lower = model_card.lower()
+        
+        # Check context length
+        context_patterns = [
+            r'context length:?\s*(\d+)[kK]?',
+            r'max[ _]?length:?\s*(\d+)[kK]?',
+            r'(\d+)[kK]\s*(?:context|tokens)'
+        ]
+        
+        for pattern in context_patterns:
+            match = re.search(pattern, card_lower)
+            if match:
+                val = int(match.group(1))
+                if 'k' in match.group(0).lower():
+                    info["context_length"] = val * 1024
+                else:
+                    info["context_length"] = val
+                break
+        
+        # Check for chat template
+        info["has_chat_template"] = "chat template" in card_lower or "conversation" in card_lower
+        
+        # Check for function calling
+        info["supports_function_calling"] = any(x in card_lower for x in 
+            ["function calling", "tools", "function call", "tool use"])
+        
+        # Check for code generation
+        info["supports_code"] = any(x in card_lower for x in 
+            ["code generation", "programming", "python", "javascript"])
+        
+        # Check for instruction following
+        info["supports_instruction"] = "instruction" in card_lower
+        
+        # Check quantization support
+        if "4bit" in card_lower or "4-bit" in card_lower:
+            info["quantization_supported"].append("4bit")
+        if "8bit" in card_lower or "8-bit" in card_lower:
+            info["quantization_supported"].append("8bit")
+        
+        return info
+    
+    def _extract_ocr_info(self, model_info, model_card: str) -> dict:
+        """Extract OCR-specific information"""
+        info = {
+            "supports_handwriting": False,
+            "supports_layout": False,
+            "supports_tables": False,
+            "supports_formulas": False,
+            "supported_image_formats": ["jpg", "png"]  # default
+        }
+        
+        card_lower = model_card.lower()
+        
+        # Check for handwriting
+        info["supports_handwriting"] = "handwriting" in card_lower or "handwritten" in card_lower
+        
+        # Check for layout analysis
+        info["supports_layout"] = any(x in card_lower for x in 
+            ["layout", "paragraph", "document structure"])
+        
+        # Check for table extraction
+        info["supports_tables"] = any(x in card_lower for x in 
+            ["table", "spreadsheet", "tabular"])
+        
+        # Check for formula recognition
+        info["supports_formulas"] = any(x in card_lower for x in 
+            ["formula", "equation", "math", "latex"])
+        
+        # Check image formats
+        formats = []
+        for fmt in ["jpg", "jpeg", "png", "tiff", "bmp", "pdf"]:
+            if fmt in card_lower:
+                formats.append(fmt)
+        if formats:
+            info["supported_image_formats"] = formats
+        
+        return info
+    
+    def _map_pipeline_to_task(self, pipeline_tag: Optional[str]) -> Optional[TaskType]:
+        """Map HuggingFace pipeline tag to our TaskType"""
+        mapping = {
+            "translation": TaskType.TRANSLATION,
+            "text-to-speech": TaskType.TEXT_TO_SPEECH,
+            "automatic-speech-recognition": TaskType.SPEECH_TO_TEXT,
+            "text-generation": TaskType.TEXT_GENERATION,
+            "question-answering": TaskType.QUESTION_ANSWERING,
+            "summarization": TaskType.SUMMARIZATION,
+            "image-to-text": TaskType.OCR,
+
+            "document-question-answering": TaskType.DOCUMENT_UNDERSTANDING,
+            "text-classification": TaskType.TEXT_CLASSIFICATION,
+            "token-classification": TaskType.NAMED_ENTITY_RECOGNITION,
+            "image-classification": TaskType.IMAGE_CLASSIFICATION,
+            "object-detection": TaskType.OBJECT_DETECTION,
+            "zero-shot-classification": TaskType.ZERO_SHOT_CLASSIFICATION
+        }
+        return mapping.get(pipeline_tag) if pipeline_tag else None

src/main.py

@@ -0,0 +1,186 @@
+"""
+Main orchestrator for the HuggingFace Model Selector
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add the project root to Python path
+project_root = str(Path(__file__).parent.parent.absolute())
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+import asyncio
+from typing import Optional
+
+from src.agents.input_agent import InputAgent
+from src.agents.research_agent import ResearchAgent
+from src.agents.evaluation_agent import EvaluationAgent
+from src.agents.benchmarking_agent import BenchmarkingAgent
+from src.agents.deployment_agent import DeploymentAgent
+from src.models.schemas import DeploymentType, SelectionResult, TaskType
+
+
+class HuggingFaceModelSelector:
+    """
+    Main orchestrator that coordinates all agents.
+    
+    This class:
+    1. Takes a task description
+    2. Parses requirements
+    3. Searches for models
+    4. Evaluates and scores them
+    5. Benchmarks top models
+    6. Generates deployment code
+    """
+    
+    def __init__(self):
+        self.input_agent = InputAgent()
+        self.research_agent = ResearchAgent()
+        self.evaluation_agent = EvaluationAgent()
+        self.benchmarking_agent = BenchmarkingAgent()
+        self.deployment_agent = DeploymentAgent()
+    
+    async def select_and_deploy(self,
+                               task_description: str,
+                               deployment_type: DeploymentType = DeploymentType.FASTAPI,
+                               benchmark: bool = True,
+                               top_k: int = 5) -> SelectionResult:
+        """
+        Complete pipeline: select best model and generate deployment code.
+        
+        Args:
+            task_description: Natural language task (e.g., "translate english to french")
+            deployment_type: Type of deployment to generate
+            benchmark: Whether to run performance benchmarks
+            top_k: Number of top models to consider
+            
+        Returns:
+            SelectionResult with all details
+        """
+        try:
+            print("\n" + "=" * 60)
+            print(" HuggingFace Model Selector")
+            print("=" * 60)
+            
+            # Step 1: Parse requirements
+            print("\n Step 1: Analyzing requirements...")
+            requirements = self.input_agent.parse_requirements(task_description)
+            print(f"  Task: {requirements.task_type.value}")
+            
+            # Display task-specific requirements
+            if requirements.task_type == TaskType.TRANSLATION and requirements.translation_reqs:
+                req = requirements.translation_reqs
+                print(f"  Translation: {req.source_language.value} → {req.target_language.value}")
+                if req.domain:
+                    print(f"  Domain: {req.domain}")
+            
+            elif requirements.task_type == TaskType.TEXT_TO_SPEECH and requirements.tts_reqs:
+                req = requirements.tts_reqs
+                print(f"  TTS Language: {req.language.value}")
+                print(f"  Voice: {req.voice_type.value}")
+            
+            elif requirements.task_type == TaskType.SPEECH_TO_TEXT and requirements.stt_reqs:
+                req = requirements.stt_reqs
+                print(f"  STT Language: {req.language.value}")
+                if req.domain:
+                    print(f"  Domain: {req.domain}")
+            
+            elif requirements.task_type in [TaskType.TEXT_GENERATION, TaskType.CHAT, 
+                                           TaskType.INSTRUCTION_FOLLOWING, TaskType.CODE_GENERATION,
+                                           TaskType.QUESTION_ANSWERING, TaskType.SUMMARIZATION] and requirements.llm_reqs:
+                req = requirements.llm_reqs
+                print(f"  LLM Size: {req.model_size.value}")
+                print(f"  Context Length: {req.context_length}")
+            
+            elif requirements.task_type in [TaskType.OCR, TaskType.DOCUMENT_UNDERSTANDING] and requirements.ocr_reqs:
+                req = requirements.ocr_reqs
+                langs = [lang.value for lang in req.languages]
+                print(f"  OCR Languages: {langs}")
+                if req.handwritten:
+                    print(f"  Handwriting: Yes")
+            
+            print(f"  Hardware: {[c.value for c in requirements.hardware_constraints]}")
+            
+            # Step 2: Search for models
+            print("\n Step 2: Searching HuggingFace...")
+            models = await self.research_agent.search_models(requirements, top_k=top_k*2)
+            
+            if not models:
+                return SelectionResult(
+                    status="error",
+                    error="No models found matching your requirements"
+                )
+            
+            # Step 3: Score models
+            print("\n Step 3: Evaluating models...")
+            scored_models = self.evaluation_agent.score_models(models, requirements)
+            
+            # Display top models
+            print("\n Top Models:")
+            for i, scored in enumerate(scored_models[:5]):
+                print(f"  {i+1}. {scored.model_id} (Score: {scored.total_score:.3f})")
+                # Show top 3 component scores
+                top_metrics = sorted(scored.component_scores.items(), key=lambda x: x[1], reverse=True)[:3]
+                for metric, score in top_metrics:
+                    print(f"     - {metric}: {score:.2f}")
+            
+            # Step 4: Select best model
+            best_model = scored_models[0]
+            print(f"\n Step 4: Selected model: {best_model.model_id}")
+            
+            # Step 5: Benchmark (optional)
+            benchmark_results = []
+            if benchmark:
+                print("\n Step 5: Running benchmarks...")
+                benchmark_results = await self.benchmarking_agent.benchmark_models(
+                    [m.model_id for m in scored_models[:3]],
+                    requirements.task_type,
+                    requirements
+                )
+                
+                if benchmark_results and not benchmark_results[0].error:
+                    print(f"\n Benchmark Results for {best_model.model_id}:")
+                    print(f"  Latency: {benchmark_results[0].latency_ms:.2f} ms")
+                    print(f"  Memory: {benchmark_results[0].memory_usage_mb:.2f} MB")
+                    if benchmark_results[0].throughput:
+                        print(f"  Throughput: {benchmark_results[0].throughput:.2f} samples/sec")
+            
+            # Step 6: Generate deployment code
+            print("\n Step 6: Generating deployment code...")
+            deployment_files = self.deployment_agent.generate_deployment(
+                model_id=best_model.model_id,
+                task_type=requirements.task_type,
+                deployment_type=deployment_type,
+                benchmark_results=benchmark_results[0] if benchmark_results else None,
+                requirements=requirements
+            )
+            
+            # Save files
+            output_folder = self.deployment_agent.save_deployment_files(deployment_files)
+            print(f"\n Deployment files saved to: {output_folder}")
+            
+            return SelectionResult(
+                status="success",
+                selected_model=best_model.model_id,
+                task_type=requirements.task_type,
+                requirements=requirements,
+                all_scores=scored_models,
+                benchmark_results=benchmark_results,
+                deployment_files=deployment_files
+            )
+            
+        except Exception as e:
+            print(f"\n Error: {e}")
+            import traceback
+            traceback.print_exc()
+            return SelectionResult(
+                status="error",
+                error=str(e)
+            )
+
+
+    
+
+        

src/models/schemas.py

@@ -0,0 +1,224 @@
+"""
+Data models and schemas for the HuggingFace Model Selector
+"""
+
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+from enum import Enum
+from datetime import datetime
+
+
+class TaskType(str, Enum):
+    """Supported ML tasks"""
+    TRANSLATION = "translation"
+    TEXT_TO_SPEECH = "text-to-speech"
+    SPEECH_TO_TEXT = "automatic-speech-recognition"
+    QUESTION_ANSWERING = "question-answering"
+    TEXT_GENERATION = "text-generation"
+    CHAT = "text-generation"  # Same pipeline tag
+    INSTRUCTION_FOLLOWING = "text-generation"
+    CODE_GENERATION = "text-generation"
+    SUMMARIZATION = "summarization"
+    OCR = "image-to-text"  # Pipeline tag for OCR
+    DOCUMENT_UNDERSTANDING = "document-question-answering"
+    # Legacy/Other
+    TEXT_CLASSIFICATION = "text-classification"
+    NAMED_ENTITY_RECOGNITION = "token-classification"
+    IMAGE_CLASSIFICATION = "image-classification"
+    OBJECT_DETECTION = "object-detection"
+    ZERO_SHOT_CLASSIFICATION = "zero-shot-classification"
+
+
+class Language(str, Enum):
+    """Common languages"""
+    ENGLISH = "en"
+    SPANISH = "es"
+    FRENCH = "fr"
+    GERMAN = "de"
+    ITALIAN = "it"
+    PORTUGUESE = "pt"
+    DUTCH = "nl"
+    RUSSIAN = "ru"
+    CHINESE = "zh"
+    JAPANESE = "ja"
+    KOREAN = "ko"
+    ARABIC = "ar"
+    HINDI = "hi"
+
+
+class VoiceType(str, Enum):
+    """Voice types for TTS models"""
+    MALE = "male"
+    FEMALE = "female"
+    NEUTRAL = "neutral"
+
+
+class HardwareConstraint(str, Enum):
+    """Hardware constraints for model deployment"""
+    CPU = "cpu"
+    GPU_4GB = "gpu_4gb"
+    GPU_8GB = "gpu_8gb"
+    GPU_16GB = "gpu_16gb"
+    GPU_24GB = "gpu_24gb"
+    GPU_40GB = "gpu_40gb"
+    GPU_80GB = "gpu_80gb"
+    TPU = "tpu"
+
+class ModelSize(str, Enum):
+    """Model size categories for LLMs"""
+    TINY = "tiny"        # < 1B parameters
+    SMALL = "small"      # 1B-3B parameters
+    MEDIUM = "medium"    # 3B-7B parameters
+    LARGE = "large"      # 7B-13B parameters
+    XLARGE = "xlarge"    # 13B-30B parameters
+    XXLARGE = "xxlarge"  # 30B-70B parameters
+    MASSIVE = "massive"  # 70B+ parameters
+
+class TranslationRequirements(BaseModel):
+    """Requirements for translation models"""
+    source_language: Language
+    target_language: Language
+    domain: Optional[str] = None  # e.g., medical, legal, technical
+    quality_preference: str = "balanced"  # "speed", "quality", "balanced"
+
+
+class TTSRequirements(BaseModel):
+    """Requirements for text-to-speech models"""
+    language: Language
+    voice_type: VoiceType = VoiceType.NEUTRAL
+    speaking_rate: float = 1.0  # 0.5 to 2.0
+    pitch: float = 1.0  # 0.5 to 2.0
+    wants_multiple_voices: bool = False
+
+
+class STTRequirements(BaseModel):
+    """Requirements for speech-to-text models"""
+    language: Language
+    domain: Optional[str] = None  # e.g., general, medical, telephony
+    wants_word_timestamps: bool = False
+    wants_diarization: bool = False  # Speaker diarization
+
+
+class LLMRequirements(BaseModel):
+    """Requirements for Large Language Models"""
+    model_size: ModelSize = ModelSize.MEDIUM
+    context_length: int = 2048  # tokens
+    wants_chat_template: bool = False
+    wants_function_calling: bool = False
+    wants_code_generation: bool = False
+    wants_instruction_following: bool = False
+    wants_multilingual: bool = False
+    quantization: Optional[str] = None  # "4bit", "8bit", None
+
+
+class OCRRequirements(BaseModel):
+    """Requirements for OCR models"""
+    languages: List[Language] = Field(default_factory=lambda: [Language.ENGLISH])
+    handwritten: bool = False  # Handwriting recognition
+    document_type: Optional[str] = None  # "scanned", "photo", "document"
+    wants_layout_analysis: bool = False  # Detect paragraphs, tables, etc.
+    wants_table_extraction: bool = False
+    wants_formula_recognition: bool = False  # Math formulas
+
+class UserRequirements(BaseModel):
+    """Combined user requirements"""
+    task_type: TaskType
+    hardware_constraints: List[HardwareConstraint] = Field(default_factory=lambda: [HardwareConstraint.CPU])
+    max_model_size_gb: Optional[float] = None
+    
+    # Task-specific requirements
+    translation_reqs: Optional[TranslationRequirements] = None
+    tts_reqs: Optional[TTSRequirements] = None
+    stt_reqs: Optional[STTRequirements] = None
+    llm_reqs: Optional[LLMRequirements] = None
+    ocr_reqs: Optional[OCRRequirements] = None
+    
+
+class ModelMetadata(BaseModel):
+    """Metadata for a HuggingFace model"""
+    model_id: str
+    task_type: TaskType
+    downloads: int
+    likes: int
+    last_modified: datetime
+    license: str
+    model_size: Optional[float] = None  # in GB
+    parameter_count: Optional[int] = None  # Number of parameters
+    languages: List[str] = Field(default_factory=list)
+    framework: str = "pytorch"  # pytorch, tensorflow, jax
+    pipeline_tag: Optional[str] = None
+    
+    # Translation-specific
+    source_languages: List[str] = Field(default_factory=list)
+    target_languages: List[str] = Field(default_factory=list)
+    
+    # TTS-specific
+    voice_count: int = 0
+    sample_rate: Optional[int] = None  # Hz
+    
+    # STT-specific
+    wer_score: Optional[float] = None  # Word Error Rate
+    
+    # LLM-specific
+    context_length: Optional[int] = None
+    has_chat_template: bool = False
+    supports_function_calling: bool = False
+    supports_code: bool = False
+    supports_instruction: bool = False
+    quantization_supported: List[str] = Field(default_factory=list)
+    
+    # OCR-specific
+    supports_handwriting: bool = False
+    supports_layout: bool = False
+    supports_tables: bool = False
+    supports_formulas: bool = False
+    supported_image_formats: List[str] = Field(default_factory=list)
+    
+    # General
+    performance_metrics: Dict[str, float] = Field(default_factory=dict)
+    hardware_requirements: Dict[str, Any] = Field(default_factory=dict)
+    model_card_content: str = ""
+
+
+class ModelScore(BaseModel):
+    """Scored model with component scores"""
+    model_id: str
+    task_type: TaskType
+    total_score: float
+    component_scores: Dict[str, float]
+    metadata: ModelMetadata
+
+
+class BenchmarkResult(BaseModel):
+    """Benchmark results for a model"""
+    model_id: str
+    task_type: TaskType
+    latency_ms: float
+    memory_usage_mb: float
+    accuracy: Optional[float] = None #oCR
+    throughput: Optional[float] = None
+    # Task-specific metrics
+    bleu_score: Optional[float] = None  # Translation
+    wer_score: Optional[float] = None   # STT
+    mos_score: Optional[float] = None   # TTS Mean Opinion Score
+    perplexity: Optional[float] = None  # LLMs
+    error: Optional[str] = None
+
+
+class DeploymentType(str, Enum):
+    """Supported deployment types"""
+    FASTAPI = "fastapi"
+    GRADIO = "gradio"
+    DOCKER = "docker"
+
+
+class SelectionResult(BaseModel):
+    """Final model selection result"""
+    status: str
+    selected_model: Optional[str] = None
+    task_type: Optional[TaskType] = None
+    requirements: Optional[UserRequirements] = None
+    all_scores: List[ModelScore] = Field(default_factory=list)
+    benchmark_results: List[BenchmarkResult] = Field(default_factory=list)
+    deployment_files: Optional[Dict[str, str]] = None
+    error: Optional[str] = None

structure.txt

@@ -0,0 +1,37 @@
+# project_structure.txt
+
+huggingface-model-selector/
+├── src/
+│   ├── agents/
+│   │   ├── __init__.py
+│   │   ├── input_agent.py      # Parses user requirements
+│   │   ├── research_agent.py   # Searches HuggingFace
+│   │   ├── evaluation_agent.py # Scores models
+│   │   ├── benchmarking_agent.py # Tests performance
+│   │   └── deployment_agent.py # Generates deployment code
+│   ├── models/
+│   │   ├── __init__.py
+│   │   └── schemas.py          # Pydantic models/data classes
+│   ├── utils/
+│   │   ├── __init__.py
+│   │   └── helpers.py           # Helper functions
+│   ├── config/
+│   │   ├── __init__.py
+│   │   └── settings.py          # Configuration
+│   └── main.py                   # Main orchestrator
+├── deployments/                   # Generated deployment code
+├── tests/
+│   ├── __init__.py
+│   └── test_agents.py
+├── docker/
+│   ├── Dockerfile
+│   └── docker-compose.yml
+├── .github/
+│   └── workflows/
+│       └── ci.yml                # GitHub Actions
+├── requirements.txt
+├── setup.py
+├── .env.example
+├── .gitignore
+├── README.md
+└── run.py                         # Entry point