Building a Hardware Advisor Agent

from gaia.agents.base.agent import Agent

class SimpleAdvisorAgent(Agent):
    """Minimal hardware advisor with no tools."""

    def _get_system_prompt(self) -> str:
        return """You are a hardware advisor for running local LLMs.

When users ask about LLM capabilities, explain that you need
to check their actual hardware to give accurate recommendations.

Be helpful and explain concepts in plain language."""

    def _register_tools(self):
        # No tools yet
        pass

# Use it
agent = SimpleAdvisorAgent()
result = agent.process_query("What size LLM can I run?")
print(result)

from typing import Dict, Any
from gaia.agents.base.agent import Agent
from gaia.agents.base.tools import tool
from gaia.llm.lemonade_client import LemonadeClient

class HardwareDetectorAgent(Agent):
    """Agent that can check system hardware."""

    def __init__(self, **kwargs):
        self.client = LemonadeClient(keep_alive=True)
        super().__init__(**kwargs)

    def _get_system_prompt(self) -> str:
        return """You are a hardware advisor for running local LLMs.

Use get_hardware_info to check the user's actual system specs.
Always check real hardware - never guess specifications."""

    def _register_tools(self):
        client = self.client

        @tool
        def get_hardware_info() -> Dict[str, Any]:
            """Get system RAM, GPU, and NPU information."""
            try:
                info = client.get_system_info()

                # Parse RAM
                ram_str = info.get("Physical Memory", "0 GB")
                ram_gb = float(ram_str.split()[0]) if ram_str else 0

                # Get NPU info
                devices = info.get("devices", {})
                npu_info = devices.get("npu", {})
                npu_available = npu_info.get("available", False)

                return {
                    "success": True,
                    "ram_gb": ram_gb,
                    "processor": info.get("Processor", "Unknown"),
                    "npu_available": npu_available
                }
            except Exception as e:
                return {"success": False, "error": str(e)}

# Test it
agent = HardwareDetectorAgent()
result = agent.process_query("How much RAM do I have?")

# Add to existing agent...

@tool
def list_available_models() -> Dict[str, Any]:
    """List all models with their sizes and download status."""
    try:
        response = client.list_models(show_all=True)
        models_data = response.get("data", [])

        enriched_models = []
        for model in models_data:
            model_id = model.get("id", "")
            model_info = client.get_model_info(model_id)
            size_gb = model_info.get("size_gb", 0)

            enriched_models.append({
                "id": model_id,
                "name": model.get("name", model_id),
                "size_gb": size_gb,
                "downloaded": model.get("downloaded", False)
            })

        # Sort by size (largest first)
        enriched_models.sort(key=lambda m: m["size_gb"], reverse=True)

        return {
            "success": True,
            "models": enriched_models,
            "count": len(enriched_models)
        }
    except Exception as e:
        return {"success": False, "error": str(e)}

# Test it
agent = HardwareDetectorAgent()
result = agent.process_query("What models are available?")
print(result)

# Add to existing agent...

@tool
def recommend_models(ram_gb: float, gpu_memory_mb: int = 0) -> Dict[str, Any]:
    """Recommend models based on available memory.

    Args:
        ram_gb: Available system RAM in GB
        gpu_memory_mb: Available GPU memory in MB (0 if no GPU)
    """
    try:
        # Get all models
        models_result = list_available_models()
        if not models_result.get("success"):
            return models_result

        all_models = models_result.get("models", [])

        # Apply 70% rule
        max_model_size_gb = ram_gb * 0.7

        # Filter models that fit
        fitting_models = [
            model for model in all_models
            if model["size_gb"] <= max_model_size_gb and model["size_gb"] > 0
        ]

        # Add runtime estimates
        for model in fitting_models:
            model["estimated_runtime_gb"] = round(model["size_gb"] * 1.3, 2)
            model["fits_in_ram"] = model["estimated_runtime_gb"] <= ram_gb

        return {
            "success": True,
            "recommendations": fitting_models,
            "max_model_size_gb": round(max_model_size_gb, 2),
            "total_fitting": len(fitting_models)
        }
    except Exception as e:
        return {"success": False, "error": str(e)}

# Test it
agent = HardwareDetectorAgent()
result = agent.process_query("What size LLM can I run?")
print(result)