llmstack-cli 0.1.0__py3-none-any.whl

llmstack/__init__.py

@@ -0,0 +1,3 @@
+"""LLMStack — One command. Full LLM stack. Zero config."""
+
+__version__ = "0.1.0"

llmstack/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m llmstack`."""
+
+from llmstack.cli.app import app
+
+app()

llmstack/cli/app.py

@@ -0,0 +1,87 @@
+"""CLI entry point — Typer application."""
+
+from __future__ import annotations
+
+import typer
+
+from llmstack import __version__
+
+
+app = typer.Typer(
+    name="llmstack",
+    help="One command. Full LLM stack. Zero config.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"llmstack {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False, "--version", "-V",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+) -> None:
+    """LLMStack — One command. Full LLM stack. Zero config."""
+
+
+@app.command()
+def init(
+    preset: str = typer.Option(None, "--preset", "-p", help="Preset: chat, rag, agent"),
+    directory: str = typer.Option(None, "--dir", "-d", help="Target directory"),
+) -> None:
+    """Create a new llmstack.yaml configuration file."""
+    from pathlib import Path
+    from llmstack.cli.commands.init import init as _init
+    _init(preset=preset, directory=Path(directory) if directory else None)
+
+
+@app.command()
+def up(
+    attach: bool = typer.Option(False, "--attach", "-a", help="Stream logs after starting"),
+) -> None:
+    """Start all services defined in llmstack.yaml."""
+    from llmstack.cli.commands.up import up as _up
+    _up(attach=attach)
+
+
+@app.command()
+def down(
+    volumes: bool = typer.Option(False, "--volumes", "-v", help="Also remove data volumes"),
+) -> None:
+    """Stop and remove all llmstack services."""
+    from llmstack.cli.commands.down import down as _down
+    _down(volumes=volumes)
+
+
+@app.command()
+def status() -> None:
+    """Show the status of all running llmstack services."""
+    from llmstack.cli.commands.status import status as _status
+    _status()
+
+
+@app.command()
+def logs(
+    service: str = typer.Argument(help="Service name (ollama, qdrant, redis)"),
+    follow: bool = typer.Option(True, "--follow/--no-follow", "-f"),
+    tail: int = typer.Option(50, "--tail", "-n"),
+) -> None:
+    """Stream logs from a specific service."""
+    from llmstack.cli.commands.logs import logs as _logs
+    _logs(service=service, follow=follow, tail=tail)
+
+
+@app.command()
+def doctor() -> None:
+    """Check system requirements and diagnose issues."""
+    from llmstack.cli.commands.doctor import doctor as _doctor
+    _doctor()

llmstack/cli/commands/doctor.py

@@ -0,0 +1,72 @@
+"""llmstack doctor — diagnose common issues."""
+
+from __future__ import annotations
+
+import shutil
+import socket
+
+from llmstack.cli.console import console
+from llmstack.core.hardware import detect_hardware
+
+
+def _check_port(port: int) -> bool:
+    """Return True if port is available."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("127.0.0.1", port)) != 0
+
+
+def doctor() -> None:
+    """Check system requirements and diagnose common issues."""
+    console.print("\n[bold]LLMStack Doctor[/]\n")
+    issues = 0
+
+    # Docker
+    if shutil.which("docker"):
+        console.print("  [green]PASS[/] Docker is installed")
+    else:
+        console.print("  [red]FAIL[/] Docker is not installed")
+        issues += 1
+
+    # Docker daemon
+    try:
+        import docker
+        client = docker.from_env()
+        client.ping()
+        console.print("  [green]PASS[/] Docker daemon is running")
+    except Exception:
+        console.print("  [red]FAIL[/] Docker daemon is not reachable")
+        issues += 1
+
+    # Hardware
+    hw = detect_hardware()
+    if hw.gpu_vendor != "none":
+        console.print(f"  [green]PASS[/] GPU detected: {hw.gpu_name}")
+        if hw.gpu_vendor == "nvidia" and hw.docker_runtime != "nvidia":
+            console.print("  [yellow]WARN[/] nvidia-container-toolkit not found (GPU passthrough may not work)")
+    else:
+        console.print("  [yellow]WARN[/] No GPU detected (CPU inference only)")
+
+    console.print(f"  [green]INFO[/] RAM: {hw.ram_mb // 1024} GB, CPU: {hw.cpu_cores} cores")
+
+    # Ports
+    for port, service in [(11434, "Ollama"), (6333, "Qdrant"), (6379, "Redis"), (8000, "Gateway")]:
+        if _check_port(port):
+            console.print(f"  [green]PASS[/] Port {port} ({service}) is available")
+        else:
+            console.print(f"  [yellow]WARN[/] Port {port} ({service}) is in use")
+
+    # Config
+    try:
+        from llmstack.config.loader import load_config
+        load_config()
+        console.print("  [green]PASS[/] llmstack.yaml is valid")
+    except FileNotFoundError:
+        console.print("  [yellow]WARN[/] No llmstack.yaml found (run 'llmstack init')")
+    except SystemExit:
+        console.print("  [red]FAIL[/] llmstack.yaml has validation errors")
+        issues += 1
+
+    if issues:
+        console.print(f"\n[error]{issues} issue(s) found.[/]")
+    else:
+        console.print("\n[success]All checks passed![/]")

llmstack/cli/commands/down.py

@@ -0,0 +1,25 @@
+"""llmstack down — stop all services."""
+
+from __future__ import annotations
+
+import typer
+
+from llmstack.cli.console import console
+from llmstack.docker.manager import DockerManager
+
+
+def down(
+    volumes: bool = typer.Option(False, "--volumes", "-v", help="Also remove data volumes"),
+) -> None:
+    """Stop and remove all llmstack services."""
+    docker = DockerManager()
+    stopped = docker.stop_all(remove_volumes=volumes)
+
+    if stopped:
+        for name in stopped:
+            console.print(f"  [info]Stopped {name}[/]")
+        if volumes:
+            console.print("[warning]Volumes removed.[/]")
+        console.print("\n[success]All services stopped.[/]")
+    else:
+        console.print("[info]No llmstack services are running.[/]")

llmstack/cli/commands/init.py

@@ -0,0 +1,66 @@
+"""llmstack init — create llmstack.yaml with smart defaults."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from llmstack.cli.console import console
+from llmstack.config.loader import save_config, CONFIG_FILENAME
+from llmstack.config.presets import PRESETS
+from llmstack.config.schema import StackConfig
+from llmstack.core.hardware import detect_hardware
+
+
+def init(
+    preset: Optional[str] = typer.Option(
+        None, "--preset", "-p",
+        help="Preset to use: chat, rag, agent",
+    ),
+    directory: Optional[Path] = typer.Option(
+        None, "--dir", "-d",
+        help="Directory to create llmstack.yaml in",
+    ),
+) -> None:
+    """Initialize a new llmstack.yaml configuration file."""
+    target = directory or Path.cwd()
+
+    if (target / CONFIG_FILENAME).exists():
+        console.print(f"[warning]{CONFIG_FILENAME} already exists. Use --dir to specify another location.[/]")
+        raise typer.Exit(1)
+
+    # Detect hardware
+    hw = detect_hardware()
+    console.print("\n[info]Hardware detected:[/]")
+    console.print(f"  CPU: {hw.cpu_cores} cores")
+    console.print(f"  RAM: {hw.ram_mb // 1024} GB")
+    if hw.gpu_vendor != "none":
+        console.print(f"  GPU: {hw.gpu_name} ({hw.gpu_vram_mb // 1024} GB VRAM)")
+    else:
+        console.print("  GPU: none (will use CPU inference)")
+
+    # Pick config
+    if preset and preset in PRESETS:
+        config = PRESETS[preset].model_copy(deep=True)
+        console.print(f"\n[info]Using preset:[/] {preset}")
+    elif preset:
+        console.print(f"[error]Unknown preset '{preset}'. Available: {', '.join(PRESETS.keys())}[/]")
+        raise typer.Exit(1)
+    else:
+        config = StackConfig()
+        console.print("\n[info]Using default configuration[/]")
+
+    # Auto-resolve backend hint
+    if hw.gpu_vendor == "nvidia" and hw.gpu_vram_mb >= 16_000:
+        config.models.chat.backend = "vllm"
+        console.print("  Backend: [success]vLLM[/] (NVIDIA GPU detected)")
+    else:
+        config.models.chat.backend = "ollama"
+        console.print("  Backend: [success]Ollama[/]")
+
+    # Save
+    path = save_config(config, target)
+    console.print(f"\n[success]Created {path}[/]")
+    console.print("Next: edit the config if needed, then run [bold]llmstack up[/]")

llmstack/cli/commands/logs.py

@@ -0,0 +1,25 @@
+"""llmstack logs — stream logs from a service."""
+
+from __future__ import annotations
+
+import typer
+
+from llmstack.cli.console import console
+from llmstack.docker.manager import DockerManager
+
+
+def logs(
+    service: str = typer.Argument(help="Service name (e.g., ollama, qdrant, redis)"),
+    follow: bool = typer.Option(True, "--follow/--no-follow", "-f", help="Follow log output"),
+    tail: int = typer.Option(50, "--tail", "-n", help="Number of lines to show"),
+) -> None:
+    """Stream logs from a specific service."""
+    docker = DockerManager()
+    try:
+        for line in docker.stream_logs(service, follow=follow, tail=tail):
+            console.print(line, end="", highlight=False)
+    except ValueError as exc:
+        console.print(f"[error]{exc}[/]")
+        raise typer.Exit(1)
+    except KeyboardInterrupt:
+        pass

llmstack/cli/commands/status.py

@@ -0,0 +1,45 @@
+"""llmstack status — show health of all services."""
+
+from __future__ import annotations
+
+from rich.table import Table
+
+from llmstack.cli.console import console
+from llmstack.docker.manager import DockerManager
+
+
+def status() -> None:
+    """Show the status of all running llmstack services."""
+    docker = DockerManager()
+    services = docker.list_services()
+
+    if not services:
+        console.print("[info]No llmstack services are running.[/]")
+        console.print("Run [bold]llmstack up[/] to start.")
+        return
+
+    table = Table(title="LLMStack Status", show_header=True)
+    table.add_column("Service", style="cyan")
+    table.add_column("Container")
+    table.add_column("Status")
+    table.add_column("Ports")
+
+    for svc in services:
+        status_style = "green" if svc["status"] == "running" else "red"
+        ports_str = ""
+        if svc["ports"]:
+            port_list = []
+            for container_port, host_bindings in svc["ports"].items():
+                if host_bindings:
+                    for binding in host_bindings:
+                        port_list.append(f"{binding['HostPort']}->{container_port}")
+            ports_str = ", ".join(port_list)
+
+        table.add_row(
+            svc["name"],
+            svc["container_id"],
+            f"[{status_style}]{svc['status']}[/]",
+            ports_str,
+        )
+
+    console.print(table)

llmstack/cli/commands/up.py

@@ -0,0 +1,30 @@
+"""llmstack up — boot the full stack."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from llmstack.cli.console import console
+from llmstack.config.loader import load_config
+from llmstack.core.stack import Stack
+
+
+def up(
+    attach: bool = typer.Option(False, "--attach", "-a", help="Stream logs after starting"),
+) -> None:
+    """Start all services defined in llmstack.yaml."""
+    config = load_config()
+    stack = Stack(config)
+
+    console.print("\n[bold]Starting LLMStack...[/]\n")
+    asyncio.run(stack.up())
+
+    if attach:
+        console.print("[info]Streaming logs (Ctrl+C to detach)...[/]\n")
+        try:
+            for line in stack.docker.stream_logs("ollama", follow=True, tail=10):
+                console.print(line, end="")
+        except KeyboardInterrupt:
+            console.print("\n[info]Detached.[/]")

llmstack/cli/console.py

@@ -0,0 +1,13 @@
+"""Rich console singleton and display helpers."""
+
+from rich.console import Console
+from rich.theme import Theme
+
+theme = Theme({
+    "info": "cyan",
+    "success": "green",
+    "warning": "yellow",
+    "error": "red bold",
+})
+
+console = Console(theme=theme)

llmstack/config/__init__.py

@@ -0,0 +1,4 @@
+from llmstack.config.schema import StackConfig
+from llmstack.config.loader import load_config
+
+__all__ = ["StackConfig", "load_config"]

llmstack/config/loader.py

@@ -0,0 +1,44 @@
+"""Find, read, and validate llmstack.yaml."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+from pydantic import ValidationError
+
+from llmstack.config.schema import StackConfig
+
+CONFIG_FILENAME = "llmstack.yaml"
+
+
+def find_config(directory: Path | None = None) -> Path:
+    """Locate llmstack.yaml in the given or current directory."""
+    base = directory or Path.cwd()
+    path = base / CONFIG_FILENAME
+    if not path.exists():
+        raise FileNotFoundError(
+            f"{CONFIG_FILENAME} not found in {base}. Run 'llmstack init' first."
+        )
+    return path
+
+
+def load_config(directory: Path | None = None) -> StackConfig:
+    """Load and validate llmstack.yaml, returning a StackConfig."""
+    path = find_config(directory)
+    raw = yaml.safe_load(path.read_text())
+    if raw is None:
+        raw = {}
+    try:
+        return StackConfig(**raw)
+    except ValidationError as exc:
+        raise SystemExit(f"Invalid {CONFIG_FILENAME}:\n{exc}") from exc
+
+
+def save_config(config: StackConfig, directory: Path | None = None) -> Path:
+    """Write a StackConfig to llmstack.yaml."""
+    base = directory or Path.cwd()
+    path = base / CONFIG_FILENAME
+    data = config.model_dump(mode="json", exclude_defaults=False)
+    path.write_text(yaml.dump(data, default_flow_style=False, sort_keys=False, allow_unicode=True))
+    return path

llmstack/config/presets/__init__.py

@@ -0,0 +1,11 @@
+from llmstack.config.presets.chat import CHAT_PRESET
+from llmstack.config.presets.rag import RAG_PRESET
+from llmstack.config.presets.agent import AGENT_PRESET
+
+PRESETS = {
+    "chat": CHAT_PRESET,
+    "rag": RAG_PRESET,
+    "agent": AGENT_PRESET,
+}
+
+__all__ = ["PRESETS", "CHAT_PRESET", "RAG_PRESET", "AGENT_PRESET"]

llmstack/config/presets/agent.py

@@ -0,0 +1,13 @@
+"""Agent preset — large model + long context for agentic workflows."""
+
+from llmstack.config.schema import (
+    StackConfig, ModelsConfig, ModelSpec, EmbeddingSpec, GatewayConfig,
+)
+
+AGENT_PRESET = StackConfig(
+    models=ModelsConfig(
+        chat=ModelSpec(name="llama3.1:70b", backend="auto", context_length=16384),
+        embeddings=EmbeddingSpec(name="bge-m3"),
+    ),
+    gateway=GatewayConfig(rate_limit="30/min", request_timeout=300),
+)

llmstack/config/presets/chat.py

@@ -0,0 +1,14 @@
+"""Chat preset — minimal setup for conversational AI."""
+
+from llmstack.config.schema import (
+    StackConfig, ModelsConfig, ModelSpec, EmbeddingSpec,
+    ObserveConfig,
+)
+
+CHAT_PRESET = StackConfig(
+    models=ModelsConfig(
+        chat=ModelSpec(name="llama3.2", backend="auto"),
+        embeddings=EmbeddingSpec(name="bge-m3"),
+    ),
+    observe=ObserveConfig(metrics=False),
+)

llmstack/config/presets/rag.py

@@ -0,0 +1,10 @@
+"""RAG preset — chat + vector search + document ingestion."""
+
+from llmstack.config.schema import StackConfig, ModelsConfig, ModelSpec, EmbeddingSpec
+
+RAG_PRESET = StackConfig(
+    models=ModelsConfig(
+        chat=ModelSpec(name="llama3.2", backend="auto", context_length=8192),
+        embeddings=EmbeddingSpec(name="bge-m3"),
+    ),
+)

llmstack/config/schema.py

@@ -0,0 +1,76 @@
+"""Pydantic v2 models for llmstack.yaml configuration."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class ModelSpec(BaseModel):
+    name: str = "llama3.2"
+    backend: Literal["auto", "ollama", "vllm"] = "auto"
+    quantization: str | None = None
+    gpu_layers: int = -1
+    context_length: int = 8192
+    extra_args: dict = Field(default_factory=dict)
+
+
+class EmbeddingSpec(BaseModel):
+    name: str = "bge-m3"
+    backend: Literal["auto", "tei"] = "auto"
+    dimensions: int | None = None
+
+
+class ModelsConfig(BaseModel):
+    chat: ModelSpec = Field(default_factory=ModelSpec)
+    embeddings: EmbeddingSpec = Field(default_factory=EmbeddingSpec)
+
+
+class VectorDBConfig(BaseModel):
+    provider: Literal["qdrant"] = "qdrant"
+    port: int = 6333
+    storage_path: str = "./data/vectors"
+
+
+class CacheConfig(BaseModel):
+    provider: Literal["redis"] = "redis"
+    port: int = 6379
+    max_memory: str = "256mb"
+
+
+class ServicesConfig(BaseModel):
+    vectors: VectorDBConfig = Field(default_factory=VectorDBConfig)
+    cache: CacheConfig = Field(default_factory=CacheConfig)
+
+
+class GatewayConfig(BaseModel):
+    port: int = 8000
+    auth: Literal["none", "api_key"] = "api_key"
+    api_keys: list[str] = Field(default_factory=list)
+    rate_limit: str = "100/min"
+    cors: list[str] = Field(default_factory=lambda: ["*"])
+    request_timeout: int = 120
+
+
+class ObserveConfig(BaseModel):
+    metrics: bool = True
+    dashboard_port: int = 8080
+    retention: str = "7d"
+
+
+class DockerConfig(BaseModel):
+    network: str = "llmstack_net"
+    gpu: Literal["auto", "true", "false"] = "auto"
+    data_dir: str = "~/.llmstack/data"
+
+
+class StackConfig(BaseModel):
+    """Root config — 1:1 mapping with llmstack.yaml."""
+
+    version: str = "1"
+    models: ModelsConfig = Field(default_factory=ModelsConfig)
+    services: ServicesConfig = Field(default_factory=ServicesConfig)
+    gateway: GatewayConfig = Field(default_factory=GatewayConfig)
+    observe: ObserveConfig = Field(default_factory=ObserveConfig)
+    docker: DockerConfig = Field(default_factory=DockerConfig)