Server and Models API Reference¶

class ServerManager:
    def __init__(self, server_url: str = "http://127.0.0.1:8080")

with ServerManager() as manager:
    manager.start_server(model_path="/path/to/model.gguf", gpu_layers=99)
    # Server is running...
# Server is automatically stopped on exit

def find_llama_server(self) -> Optional[Path]

def start_server(
    self,
    model_path: str,
    port: int = 8080,
    host: str = "127.0.0.1",
    gpu_layers: int = 99,
    ctx_size: int = 2048,
    n_parallel: int = 1,
    batch_size: int = 512,
    ubatch_size: int = 128,
    timeout: int = 60,
    verbose: bool = True,
    skip_gpu_check: bool = False,
    silent: bool = False,
    multi_gpu_config: Optional[Any] = None,
    nccl_config: Optional[Any] = None,
    enable_metrics: bool = False,
    enable_props: bool = False,
    enable_slots: bool = True,
    **kwargs,
) -> bool

manager = ServerManager(server_url="http://127.0.0.1:8080")
manager.start_server(
    model_path="/models/gemma-3-1b-it-Q4_K_M.gguf",
    gpu_layers=99,
    ctx_size=4096,
    flash_attn=True,
    enable_metrics=True,
)

def stop_server(self, timeout: float = 10.0) -> bool

manager = ServerManager()
manager.start_server("/path/to/model.gguf", enable_metrics=True)

# Check health
print(manager.check_server_health())  # True

# Get Prometheus metrics
metrics_text = manager.get_metrics()

# Get slot status
slots = manager.get_slots()

# Get loaded model info
models = manager.get_models()

def restart_server(self, model_path: str, **kwargs) -> bool

def start_from_preset(self, model_path: str, preset_name: Any = None, **kwargs) -> bool

class ModelInfo:
    def __init__(self, filepath: str)

from llamatelemetry.models import ModelInfo
info = ModelInfo.from_file("/models/gemma-3-1b-it-Q4_K_M.gguf")
print(f"Architecture: {info.architecture}")
print(f"Size: {info.file_size_mb:.1f} MB")
settings = info.get_recommended_settings(vram_gb=15.0)
print(f"Recommended GPU layers: {settings['gpu_layers']}")
print(f"Recommended context: {settings['ctx_size']}")

class ModelManager:
    def __init__(self, directories: Optional[List[str]] = None)

from llamatelemetry.models import ModelManager
manager = ModelManager(directories=["/kaggle/working/models"])
models = manager.find_by_size(max_mb=4000)  # Models under 4GB
best = manager.get_best_for_vram(vram_gb=15.0)
if best:
    print(f"Best model: {best.filepath.name} ({best.file_size_mb:.0f} MB)")

def load_model_smart(
    model_name_or_path: str,
    cache_dir: Optional[Path] = None,
    interactive: bool = True,
    force_download: bool = False,
) -> Path

from llamatelemetry.models import load_model_smart

# From registry
path = load_model_smart("gemma-3-1b-Q4_K_M")

# Local path
path = load_model_smart("/path/to/model.gguf")

# HuggingFace syntax
path = load_model_smart("unsloth/gemma-3-1b-it-GGUF:gemma-3-1b-it-Q4_K_M.gguf")

def download_model(
    repo_id: str,
    filename: str,
    output_dir: Optional[str] = None,
    show_progress: bool = True,
) -> str

def list_models(directories: Optional[List[str]] = None) -> List[Dict[str, Any]]

def list_registry_models() -> Dict[str, Dict[str, Any]]

from llamatelemetry.models import list_registry_models
for name, info in list_registry_models().items():
    print(f"{name}: {info['size_mb']}MB - {info['description']}")

def get_model_recommendations(vram_gb: float = 8.0) -> List[Dict[str, str]]

class SmartModelDownloader:
    def __init__(
        self,
        vram_gb: Optional[float] = None,
        cache_dir: Optional[Path] = None,
        auto_recommend: bool = True,
    )

from llamatelemetry.models import SmartModelDownloader
downloader = SmartModelDownloader(vram_gb=15.0)

result = downloader.validate_model("gemma-3-12b-Q4_K_M")
if not result["fits"]:
    print(f"Try: {result['alternative_models']}")

path = downloader.download("gemma-3-4b-Q4_K_M")