lorai-workspace 0.1.0__tar.gz

lorai_workspace-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 LorAI Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lorai_workspace-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: lorai-workspace
+Version: 0.1.0
+Summary: All of AI. One Command. Port 1842.
+Author-email: LorAI Team <hello@getlorai.com>
+License: MIT
+Project-URL: Homepage, https://getlorai.com
+Project-URL: Repository, https://github.com/getlorai/lorai-sdk
+Keywords: ai,llm,openai,ollama,docker,lora
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.30.0
+Requires-Dist: httpx>=0.27.0
+Dynamic: license-file
+
+# LorAI SDK
+
+**All of AI. One Command. Port 1842.**
+
+LorAI gives you a local, free, OpenAI-compatible AI platform with 50+ tools — LLMs, image gen, video, voice, code, agents, RAG, vision — all running in a Docker container on port 1842.
+
+## Quick Start
+
+```bash
+pip install lorai-workspace
+```
+
+```python
+from lorai import LorAI
+
+ai = LorAI()              # auto-pulls Docker image, starts container
+print(ai.chat("Hello!"))   # gets response from local LLM
+```
+
+## CLI
+
+```bash
+lorai-workspace start          # Start the LorAI container
+lorai-workspace chat "Hello!"  # Chat with your local AI
+lorai-workspace status         # Check system status
+lorai-workspace desktop        # Open the browser desktop
+lorai-workspace stop           # Stop the container
+```
+
+## Features
+
+- **OpenAI-compatible**: Drop-in replacement for `openai.OpenAI()`
+- **Auto-managed Docker**: Container pulls and starts automatically
+- **10 AI services**: Chat, Image, Video, Voice, Knowledge, Agents, Code, Vision, LoRA, Hub
+- **Port 1842**: Named after Ada Lovelace's year
+
+## License
+
+MIT

lorai_workspace-0.1.0/README.md

@@ -0,0 +1,39 @@
+# LorAI SDK
+
+**All of AI. One Command. Port 1842.**
+
+LorAI gives you a local, free, OpenAI-compatible AI platform with 50+ tools — LLMs, image gen, video, voice, code, agents, RAG, vision — all running in a Docker container on port 1842.
+
+## Quick Start
+
+```bash
+pip install lorai-workspace
+```
+
+```python
+from lorai import LorAI
+
+ai = LorAI()              # auto-pulls Docker image, starts container
+print(ai.chat("Hello!"))   # gets response from local LLM
+```
+
+## CLI
+
+```bash
+lorai-workspace start          # Start the LorAI container
+lorai-workspace chat "Hello!"  # Chat with your local AI
+lorai-workspace status         # Check system status
+lorai-workspace desktop        # Open the browser desktop
+lorai-workspace stop           # Stop the container
+```
+
+## Features
+
+- **OpenAI-compatible**: Drop-in replacement for `openai.OpenAI()`
+- **Auto-managed Docker**: Container pulls and starts automatically
+- **10 AI services**: Chat, Image, Video, Voice, Knowledge, Agents, Code, Vision, LoRA, Hub
+- **Port 1842**: Named after Ada Lovelace's year
+
+## License
+
+MIT

lorai_workspace-0.1.0/lorai/__init__.py

@@ -0,0 +1,5 @@
+from lorai.client import LorAI
+
+__version__ = "0.1.0"
+PORT = 1842
+__all__ = ["LorAI", "PORT"]

lorai_workspace-0.1.0/lorai/cli/__init__.py

@@ -0,0 +1,227 @@
+"""LorAI CLI — All of AI. One Command. Port 1842.
+
+Usage:
+    lorai-workspace start [--gpu] [--port PORT]
+    lorai-workspace stop
+    lorai-workspace status
+    lorai-workspace chat "message"
+    lorai-workspace desktop
+    lorai-workspace pull <model>
+    lorai-workspace bench
+    lorai-workspace logs
+    lorai-workspace version
+    lorai-workspace help
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import webbrowser
+
+import httpx
+
+BANNER = r"""
+  ██╗      ██████╗  ██████╗  █████╗ ██╗
+  ██║     ██╔═══██╗██╔══██╗██╔══██╗██║
+  ██║     ██║   ██║██████╔╝███████║██║
+  ██║     ██║   ██║██╔══██╗██╔══██║██║
+  ███████╗╚██████╔╝██║  ██║██║  ██║██║
+  ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝
+
+  All of AI. One Command. Port 1842.
+"""
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="lorai",
+        description="LorAI — All of AI. One Command.",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # start
+    p_start = sub.add_parser("start", help="Start the LorAI container")
+    p_start.add_argument("--gpu", action="store_true", help="Enable GPU passthrough")
+    p_start.add_argument("--port", type=int, default=1842, help="API port (default: 1842)")
+
+    # stop
+    sub.add_parser("stop", help="Stop the LorAI container")
+
+    # status
+    sub.add_parser("status", help="Show LorAI status")
+
+    # chat
+    p_chat = sub.add_parser("chat", help="Chat with the local AI")
+    p_chat.add_argument("message", help="Message to send")
+    p_chat.add_argument("--model", default=None, help="Model to use")
+
+    # desktop
+    sub.add_parser("desktop", help="Open LorAI desktop in browser")
+
+    # pull
+    p_pull = sub.add_parser("pull", help="Pull/download an AI model")
+    p_pull.add_argument("model", help="Model name (e.g. llama3, phi3:mini)")
+
+    # bench
+    sub.add_parser("bench", help="Benchmark your hardware")
+
+    # logs
+    sub.add_parser("logs", help="Show container logs")
+
+    # version
+    sub.add_parser("version", help="Show LorAI version")
+
+    # help (explicit)
+    sub.add_parser("help", help="Show help with banner")
+
+    args = parser.parse_args(argv)
+
+    if args.command is None or args.command == "help":
+        _cmd_help()
+    elif args.command == "start":
+        _cmd_start(port=args.port, gpu=args.gpu)
+    elif args.command == "stop":
+        _cmd_stop()
+    elif args.command == "status":
+        _cmd_status()
+    elif args.command == "chat":
+        _cmd_chat(args.message, model=args.model)
+    elif args.command == "desktop":
+        _cmd_desktop()
+    elif args.command == "pull":
+        _cmd_pull(args.model)
+    elif args.command == "bench":
+        _cmd_bench()
+    elif args.command == "logs":
+        _cmd_logs()
+    elif args.command == "version":
+        _cmd_version()
+
+
+def _cmd_help() -> None:
+    print(BANNER)
+    print("Usage: lorai <command> [options]\n")
+    print("Commands:")
+    print("  start [--gpu] [--port N]   Start the LorAI container")
+    print("  stop                       Stop the LorAI container")
+    print("  status                     Show system status")
+    print('  chat "message"             Chat with the local AI')
+    print("  desktop                    Open browser desktop (noVNC)")
+    print("  pull <model>               Download an AI model")
+    print("  bench                      Benchmark your hardware")
+    print("  logs                       Show container logs")
+    print("  version                    Show version info")
+    print("  help                       Show this help")
+    print()
+    print("Examples:")
+    print("  lorai-workspace start")
+    print('  lorai-workspace chat "What is the meaning of life?"')
+    print("  lorai-workspace pull llama3")
+    print("  lorai-workspace desktop")
+    print("  lorai-workspace stop")
+
+
+def _cmd_start(port: int = 1842, gpu: bool = False) -> None:
+    from lorai.docker import ensure_running
+    ensure_running(port=port, gpu=gpu)
+    print(f"\nLorAI is running at http://localhost:{port}")
+    print("Desktop available at http://localhost:6080")
+
+
+def _cmd_stop() -> None:
+    from lorai.docker import stop_container
+    stop_container()
+    print("LorAI stopped.")
+
+
+def _cmd_status() -> None:
+    from lorai.docker import status
+    s = status()
+    print(BANNER)
+    print(f"  Docker installed:    {'yes' if s['docker_installed'] else 'NO'}")
+    print(f"  Image pulled:        {'yes' if s['image_pulled'] else 'no'}")
+    print(f"  Container running:   {'yes' if s['container_running'] else 'no'}")
+    print(f"  API healthy:         {'yes' if s['api_healthy'] else 'no'}")
+    print(f"  API URL:             {s['url']}")
+    print(f"  Desktop URL:         {s['desktop_url']}")
+
+
+def _cmd_chat(message: str, model: str | None = None) -> None:
+    payload = {
+        "model": model or "auto",
+        "messages": [{"role": "user", "content": message}],
+    }
+    try:
+        resp = httpx.post(
+            "http://localhost:1842/v1/chat/completions",
+            json=payload, timeout=120,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        print(data["choices"][0]["message"]["content"])
+    except httpx.ConnectError:
+        print("Error: LorAI is not running. Start it with: lorai-workspace start")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+
+def _cmd_desktop() -> None:
+    url = "http://localhost:6080"
+    print(f"Opening LorAI desktop: {url}")
+    webbrowser.open(url)
+
+
+def _cmd_pull(model: str) -> None:
+    print(f"Pulling model: {model}")
+    try:
+        resp = httpx.post(
+            "http://localhost:1842/lorai/hub/pull",
+            json={"name": model}, timeout=600,
+        )
+        resp.raise_for_status()
+        print(json.dumps(resp.json(), indent=2))
+    except httpx.ConnectError:
+        print("Error: LorAI is not running. Start it with: lorai-workspace start")
+        sys.exit(1)
+
+
+def _cmd_bench() -> None:
+    print("Running benchmark...")
+    try:
+        resp = httpx.post(
+            "http://localhost:1842/lorai/hub/bench",
+            json={}, timeout=300,
+        )
+        resp.raise_for_status()
+        print(json.dumps(resp.json(), indent=2))
+    except httpx.ConnectError:
+        print("Error: LorAI is not running. Start it with: lorai-workspace start")
+        sys.exit(1)
+
+
+def _cmd_logs() -> None:
+    try:
+        subprocess.run(
+            ["docker", "logs", "--tail", "50", "-f", "lorai"],
+            check=True,
+        )
+    except FileNotFoundError:
+        print("Error: Docker is not installed.")
+        sys.exit(1)
+    except subprocess.CalledProcessError:
+        print("Error: LorAI container not found. Start it with: lorai-workspace start")
+        sys.exit(1)
+
+
+def _cmd_version() -> None:
+    from lorai import __version__, PORT
+    print(BANNER)
+    print(f"  Version: {__version__}")
+    print(f"  Port:    {PORT}")
+    print(f"  URL:     http://localhost:{PORT}")
+    print("  Desktop: http://localhost:6080")

lorai_workspace-0.1.0/lorai/client.py

@@ -0,0 +1,339 @@
+"""LorAI client — extends OpenAI with 10 AI services.
+
+Usage:
+    from lorai import LorAI
+    ai = LorAI()
+    print(ai.chat("Hello!"))
+"""
+
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+from typing import Any
+
+import httpx
+from openai import OpenAI
+
+from lorai.docker import ensure_running, stop_container
+
+
+class LorAI(OpenAI):
+    """OpenAI-compatible client backed by a local LorAI Docker container.
+
+    Extends the official OpenAI Python SDK so that any existing OpenAI code
+    works unchanged — just swap ``OpenAI()`` for ``LorAI()``.
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        port: int = 1842,
+        auto_start: bool = True,
+        gpu: bool = False,
+        default_model: str = "auto",
+    ) -> None:
+        self._port = port
+        self._default_model = default_model
+
+        if auto_start:
+            ensure_running(port=port, gpu=gpu)
+
+        super().__init__(
+            base_url=base_url or f"http://localhost:{port}/v1",
+            api_key=api_key or "not-needed",
+        )
+
+        # Initialize service objects
+        self.image = _ImageService(self)
+        self.video = _VideoService(self)
+        self.voice = _VoiceService(self)
+        self.knowledge = _KnowledgeService(self)
+        self.agents = _AgentsService(self)
+        self.code = _CodeService(self)
+        self.vision = _VisionService(self)
+        self.lora = _LoRAService(self)
+        self.hub = _HubService(self)
+
+    # ------------------------------------------------------------------
+    # Convenience helpers
+    # ------------------------------------------------------------------
+
+    def chat(
+        self,
+        message: str,
+        *,
+        model: str | None = None,
+        system: str | None = None,
+        lora: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+        stream: bool = False,
+        json_mode: bool = False,
+    ) -> str:
+        """Simple one-shot chat. Returns the assistant's text reply."""
+        messages: list[dict[str, str]] = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": message})
+
+        kwargs: dict[str, Any] = {
+            "model": model or self._default_model,
+            "messages": messages,
+            "temperature": temperature,
+        }
+        if max_tokens is not None:
+            kwargs["max_tokens"] = max_tokens
+        if json_mode:
+            kwargs["response_format"] = {"type": "json_object"}
+
+        # Attach LoRA header if requested
+        extra_headers = {}
+        if lora:
+            extra_headers["X-LorAI-LoRA"] = lora
+
+        if stream:
+            chunks = []
+            response = self.chat.completions.create(
+                **kwargs, stream=True, extra_headers=extra_headers or None,
+            )
+            for chunk in response:
+                delta = chunk.choices[0].delta.content
+                if delta:
+                    chunks.append(delta)
+            return "".join(chunks)
+
+        response = self.chat.completions.create(
+            **kwargs, extra_headers=extra_headers or None,
+        )
+        return response.choices[0].message.content
+
+    def stop(self) -> None:
+        """Stop the LorAI Docker container."""
+        stop_container()
+
+    @property
+    def _native_base(self) -> str:
+        return f"http://localhost:{self._port}"
+
+
+# ======================================================================
+# Service classes
+# ======================================================================
+
+class _BaseNativeService:
+    """Base for services that call LorAI-native endpoints."""
+
+    def __init__(self, client: LorAI) -> None:
+        self._client = client
+
+    def _post(self, path: str, **kwargs: Any) -> Any:
+        resp = httpx.post(
+            f"{self._client._native_base}{path}",
+            json=kwargs, timeout=300,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def _get(self, path: str) -> Any:
+        resp = httpx.get(
+            f"{self._client._native_base}{path}",
+            timeout=30,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+
+class _ImageService:
+    """Image generation via OpenAI /v1/images endpoints."""
+
+    def __init__(self, client: LorAI) -> None:
+        self._client = client
+
+    def generate(
+        self,
+        prompt: str,
+        *,
+        model: str = "dall-e-3",
+        size: str = "1024x1024",
+        lora: str | None = None,
+        save_to: str | None = None,
+    ) -> Any:
+        extra_headers = {}
+        if lora:
+            extra_headers["X-LorAI-LoRA"] = lora
+        response = self._client.images.generate(
+            model=model, prompt=prompt, size=size,
+            extra_headers=extra_headers or None,
+        )
+        if save_to and response.data and response.data[0].b64_json:
+            Path(save_to).write_bytes(base64.b64decode(response.data[0].b64_json))
+        return response
+
+    def edit(self, image_path: str, prompt: str, **kwargs: Any) -> Any:
+        with open(image_path, "rb") as f:
+            return self._client.images.edit(image=f, prompt=prompt, **kwargs)
+
+
+class _VideoService(_BaseNativeService):
+    """Video generation via LorAI-native /lorai/video endpoints."""
+
+    def generate(
+        self,
+        prompt: str,
+        *,
+        model: str = "auto",
+        duration: float = 4.0,
+        fps: int = 24,
+        image_path: str | None = None,
+        save_to: str | None = None,
+    ) -> Any:
+        payload: dict[str, Any] = {
+            "prompt": prompt, "model": model,
+            "duration": duration, "fps": fps,
+        }
+        if image_path:
+            payload["image"] = base64.b64encode(Path(image_path).read_bytes()).decode()
+        return self._post("/lorai/video/generate", **payload)
+
+
+class _VoiceService:
+    """Voice services via OpenAI /v1/audio endpoints."""
+
+    def __init__(self, client: LorAI) -> None:
+        self._client = client
+
+    def transcribe(self, audio_path: str, *, model: str = "whisper-1") -> str:
+        with open(audio_path, "rb") as f:
+            result = self._client.audio.transcriptions.create(model=model, file=f)
+        return result.text
+
+    def speak(
+        self, text: str, *, voice: str = "alloy", save_to: str | None = None,
+    ) -> Any:
+        response = self._client.audio.speech.create(
+            model="tts-1", voice=voice, input=text,
+        )
+        if save_to:
+            response.write_to_file(save_to)
+        return response
+
+
+class _KnowledgeService(_BaseNativeService):
+    """RAG / knowledge base via LorAI-native /lorai/knowledge endpoints."""
+
+    def ingest(self, source: str, *, collection: str = "default") -> Any:
+        return self._post("/lorai/knowledge/ingest", source=source, collection=collection)
+
+    def search(self, query: str, *, top_k: int = 5) -> Any:
+        return self._post("/lorai/knowledge/search", query=query, top_k=top_k)
+
+    def ask(self, question: str) -> Any:
+        return self._post("/lorai/knowledge/ask", question=question)
+
+
+class _AgentsService(_BaseNativeService):
+    """Agent workflows via LorAI-native /lorai/agents endpoints."""
+
+    def run(
+        self,
+        task: str,
+        *,
+        agents: list[str] | None = None,
+        tools: list[str] | None = None,
+        max_steps: int = 10,
+    ) -> Any:
+        return self._post(
+            "/lorai/agents/run",
+            task=task, agents=agents or [], tools=tools or [],
+            max_steps=max_steps,
+        )
+
+    def list_agents(self) -> Any:
+        return self._get("/lorai/agents/list")
+
+    def list_tools(self) -> Any:
+        return self._get("/lorai/agents/tools")
+
+
+class _CodeService(_BaseNativeService):
+    """Code generation and execution."""
+
+    def __init__(self, client: LorAI) -> None:
+        super().__init__(client)
+
+    def generate(
+        self, prompt: str, *, language: str = "python", execute: bool = False,
+    ) -> Any:
+        return self._post(
+            "/lorai/code/execute",
+            prompt=prompt, language=language, execute=execute,
+        )
+
+    def review(self, code: str) -> str:
+        response = self._client.chat.completions.create(
+            model=self._client._default_model,
+            messages=[
+                {"role": "system", "content": "You are a code reviewer. Review the following code and provide feedback."},
+                {"role": "user", "content": code},
+            ],
+        )
+        return response.choices[0].message.content
+
+
+class _VisionService:
+    """Vision analysis via OpenAI multimodal endpoints."""
+
+    def __init__(self, client: LorAI) -> None:
+        self._client = client
+
+    def analyze(self, image_path: str, prompt: str = "Describe this image.") -> str:
+        b64 = base64.b64encode(Path(image_path).read_bytes()).decode()
+        response = self._client.chat.completions.create(
+            model=self._client._default_model,
+            messages=[{
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
+                ],
+            }],
+        )
+        return response.choices[0].message.content
+
+    def ocr(self, image_path: str) -> str:
+        return self.analyze(image_path, prompt="Extract all text from this image (OCR).")
+
+
+class _LoRAService(_BaseNativeService):
+    """LoRA adapter management via /lorai/lora endpoints."""
+
+    def list(self) -> Any:
+        return self._get("/lorai/lora/list")
+
+    def load(self, name: str, *, base_model: str = "auto") -> Any:
+        return self._post("/lorai/lora/load", name=name, base_model=base_model)
+
+    def unload(self, name: str) -> Any:
+        return self._post("/lorai/lora/unload", name=name)
+
+
+class _HubService(_BaseNativeService):
+    """Model hub management via /lorai/hub endpoints."""
+
+    def models(self) -> Any:
+        return self._get("/lorai/hub/models")
+
+    def pull(self, model: str) -> Any:
+        return self._post("/lorai/hub/pull", name=model)
+
+    def remove(self, model: str) -> Any:
+        return self._post("/lorai/hub/remove", name=model)
+
+    def status(self) -> Any:
+        return self._get("/lorai/hub/status")
+
+    def bench(self) -> Any:
+        return self._post("/lorai/hub/bench")

lorai_workspace-0.1.0/lorai/docker.py

@@ -0,0 +1,134 @@
+"""Docker container management for LorAI.
+
+Handles pulling, starting, stopping, and health-checking the
+LorAI Desktop Docker container.
+"""
+
+import os
+import shutil
+import subprocess
+import time
+
+import httpx
+
+IMAGE = os.environ.get("LORAI_IMAGE", "gajapathiks/lorai-workspace:latest")
+CONTAINER_NAME = "lorai"
+HEALTH_TIMEOUT = 120  # seconds to wait for healthy state
+
+
+def is_docker_installed() -> bool:
+    """Check if the docker CLI is available on PATH."""
+    return shutil.which("docker") is not None
+
+
+def is_image_pulled() -> bool:
+    """Check if the LorAI Desktop image exists locally."""
+    result = subprocess.run(
+        ["docker", "images", "-q", IMAGE],
+        capture_output=True, text=True,
+    )
+    return bool(result.stdout.strip())
+
+
+def is_container_running() -> bool:
+    """Check if a container named 'lorai' is currently running."""
+    result = subprocess.run(
+        ["docker", "inspect", "-f", "{{.State.Running}}", CONTAINER_NAME],
+        capture_output=True, text=True,
+    )
+    return result.stdout.strip() == "true"
+
+
+def is_lorai_healthy(port: int = 1842) -> bool:
+    """Check if the LorAI API responds on the given port."""
+    try:
+        resp = httpx.get(f"http://localhost:{port}/api/health", timeout=5)
+        return resp.status_code == 200
+    except (httpx.ConnectError, httpx.TimeoutException):
+        return False
+
+
+def pull_image() -> None:
+    """Pull the LorAI Desktop Docker image."""
+    print("Pulling LorAI Docker image (this may take a while)...")
+    subprocess.run(["docker", "pull", IMAGE], check=True)
+
+
+def start_container(port: int = 1842, vnc_port: int = 6080, gpu: bool = False) -> None:
+    """Start the LorAI Docker container."""
+    cmd = [
+        "docker", "run", "-d",
+        "--name", CONTAINER_NAME,
+        "-p", f"{port}:1842",
+        "-p", f"{vnc_port}:6080",
+        "-v", f"{_data_dir()}:/data",
+        "-e", "LORAI_MODE=hybrid",
+        "-e", "LORAI_MODEL=phi3:mini",
+    ]
+    if gpu:
+        cmd.extend(["--gpus", "all"])
+    cmd.append(IMAGE)
+
+    print(f"Starting LorAI container on port {port}...")
+    subprocess.run(cmd, check=True)
+
+
+def stop_container() -> None:
+    """Stop and remove the LorAI container."""
+    subprocess.run(["docker", "stop", CONTAINER_NAME], capture_output=True)
+    subprocess.run(["docker", "rm", CONTAINER_NAME], capture_output=True)
+
+
+def ensure_running(port: int = 1842, gpu: bool = False) -> None:
+    """Orchestrate: check -> pull -> start -> health check."""
+    if not is_docker_installed():
+        raise RuntimeError(
+            "Docker is not installed. Please install Docker first: https://docs.docker.com/get-docker/"
+        )
+
+    if is_container_running() and is_lorai_healthy(port):
+        return
+
+    # Stop stale container if exists
+    if is_container_running():
+        stop_container()
+
+    if not is_image_pulled():
+        pull_image()
+
+    start_container(port=port, gpu=gpu)
+
+    # Wait for health
+    print("Waiting for LorAI to become ready...")
+    deadline = time.time() + HEALTH_TIMEOUT
+    while time.time() < deadline:
+        if is_lorai_healthy(port):
+            print(f"LorAI is ready at http://localhost:{port}")
+            return
+        time.sleep(2)
+
+    raise RuntimeError(
+        f"LorAI did not become healthy within {HEALTH_TIMEOUT}s. "
+        "Check logs with: docker logs lorai"
+    )
+
+
+def status(port: int = 1842) -> dict:
+    """Return a dict describing the current state of LorAI."""
+    return {
+        "docker_installed": is_docker_installed(),
+        "image_pulled": is_image_pulled() if is_docker_installed() else False,
+        "container_running": is_container_running() if is_docker_installed() else False,
+        "api_healthy": is_lorai_healthy(port),
+        "port": port,
+        "url": f"http://localhost:{port}",
+        "desktop_url": "http://localhost:6080",
+    }
+
+
+def _data_dir() -> str:
+    """Return the host-side data directory (~/.lorai/data)."""
+    from pathlib import Path
+    data = Path.home() / ".lorai" / "data"
+    data.mkdir(parents=True, exist_ok=True)
+    return str(data)

lorai_workspace-0.1.0/lorai_workspace.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: lorai-workspace
+Version: 0.1.0
+Summary: All of AI. One Command. Port 1842.
+Author-email: LorAI Team <hello@getlorai.com>
+License: MIT
+Project-URL: Homepage, https://getlorai.com
+Project-URL: Repository, https://github.com/getlorai/lorai-sdk
+Keywords: ai,llm,openai,ollama,docker,lora
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.30.0
+Requires-Dist: httpx>=0.27.0
+Dynamic: license-file
+
+# LorAI SDK
+
+**All of AI. One Command. Port 1842.**
+
+LorAI gives you a local, free, OpenAI-compatible AI platform with 50+ tools — LLMs, image gen, video, voice, code, agents, RAG, vision — all running in a Docker container on port 1842.
+
+## Quick Start
+
+```bash
+pip install lorai-workspace
+```
+
+```python
+from lorai import LorAI
+
+ai = LorAI()              # auto-pulls Docker image, starts container
+print(ai.chat("Hello!"))   # gets response from local LLM
+```
+
+## CLI
+
+```bash
+lorai-workspace start          # Start the LorAI container
+lorai-workspace chat "Hello!"  # Chat with your local AI
+lorai-workspace status         # Check system status
+lorai-workspace desktop        # Open the browser desktop
+lorai-workspace stop           # Stop the container
+```
+
+## Features
+
+- **OpenAI-compatible**: Drop-in replacement for `openai.OpenAI()`
+- **Auto-managed Docker**: Container pulls and starts automatically
+- **10 AI services**: Chat, Image, Video, Voice, Knowledge, Agents, Code, Vision, LoRA, Hub
+- **Port 1842**: Named after Ada Lovelace's year
+
+## License
+
+MIT

lorai_workspace-0.1.0/lorai_workspace.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+lorai/__init__.py
+lorai/client.py
+lorai/docker.py
+lorai/cli/__init__.py
+lorai_workspace.egg-info/PKG-INFO
+lorai_workspace.egg-info/SOURCES.txt
+lorai_workspace.egg-info/dependency_links.txt
+lorai_workspace.egg-info/entry_points.txt
+lorai_workspace.egg-info/requires.txt
+lorai_workspace.egg-info/top_level.txt
+tests/test_client.py

lorai_workspace-0.1.0/lorai_workspace.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lorai_workspace-0.1.0/lorai_workspace.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lorai-workspace = lorai.cli:main

lorai_workspace-0.1.0/lorai_workspace.egg-info/requires.txt

@@ -0,0 +1,2 @@
+openai>=1.30.0
+httpx>=0.27.0

lorai_workspace-0.1.0/lorai_workspace.egg-info/top_level.txt

@@ -0,0 +1 @@
+lorai

lorai_workspace-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lorai-workspace"
+version = "0.1.0"
+description = "All of AI. One Command. Port 1842."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "LorAI Team", email = "hello@getlorai.com"},
+]
+keywords = ["ai", "llm", "openai", "ollama", "docker", "lora"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "openai>=1.30.0",
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://getlorai.com"
+Repository = "https://github.com/getlorai/lorai-sdk"
+
+[project.scripts]
+lorai-workspace = "lorai.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["lorai*"]

lorai_workspace-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lorai_workspace-0.1.0/tests/test_client.py

@@ -0,0 +1,211 @@
+"""Tests for the LorAI SDK."""
+
+from unittest.mock import patch
+
+
+# ------------------------------------------------------------------
+# Test constants
+# ------------------------------------------------------------------
+
+def test_port_is_1842():
+    import lorai
+    assert lorai.PORT == 1842
+
+
+def test_version_is_set():
+    import lorai
+    assert lorai.__version__ == "0.1.0"
+
+
+# ------------------------------------------------------------------
+# Test LorAI client
+# ------------------------------------------------------------------
+
+@patch("lorai.client.ensure_running")
+def test_lorai_inherits_from_openai(mock_ensure):
+    from openai import OpenAI
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    assert isinstance(ai, OpenAI)
+
+
+@patch("lorai.client.ensure_running")
+def test_auto_start_calls_ensure_running(mock_ensure):
+    from lorai import LorAI
+    LorAI(auto_start=True)
+    mock_ensure.assert_called_once_with(port=1842, gpu=False)
+
+
+@patch("lorai.client.ensure_running")
+def test_auto_start_false_skips_ensure_running(mock_ensure):
+    from lorai import LorAI
+    LorAI(auto_start=False)
+    mock_ensure.assert_not_called()
+
+
+@patch("lorai.client.ensure_running")
+def test_custom_port_passes_through(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=True, port=9999)
+    mock_ensure.assert_called_once_with(port=9999, gpu=False)
+    assert ai._port == 9999
+
+
+@patch("lorai.client.ensure_running")
+def test_gpu_flag_passes_through(mock_ensure):
+    from lorai import LorAI
+    LorAI(auto_start=True, gpu=True)
+    mock_ensure.assert_called_once_with(port=1842, gpu=True)
+
+
+# ------------------------------------------------------------------
+# Test all 9 services exist with correct methods
+# ------------------------------------------------------------------
+
+@patch("lorai.client.ensure_running")
+def test_image_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.image
+    assert hasattr(svc, "generate")
+    assert hasattr(svc, "edit")
+
+
+@patch("lorai.client.ensure_running")
+def test_video_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.video
+    assert hasattr(svc, "generate")
+
+
+@patch("lorai.client.ensure_running")
+def test_voice_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.voice
+    assert hasattr(svc, "transcribe")
+    assert hasattr(svc, "speak")
+
+
+@patch("lorai.client.ensure_running")
+def test_knowledge_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.knowledge
+    assert hasattr(svc, "ingest")
+    assert hasattr(svc, "search")
+    assert hasattr(svc, "ask")
+
+
+@patch("lorai.client.ensure_running")
+def test_agents_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.agents
+    assert hasattr(svc, "run")
+    assert hasattr(svc, "list_agents")
+    assert hasattr(svc, "list_tools")
+
+
+@patch("lorai.client.ensure_running")
+def test_code_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.code
+    assert hasattr(svc, "generate")
+    assert hasattr(svc, "review")
+
+
+@patch("lorai.client.ensure_running")
+def test_vision_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.vision
+    assert hasattr(svc, "analyze")
+    assert hasattr(svc, "ocr")
+
+
+@patch("lorai.client.ensure_running")
+def test_lora_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.lora
+    assert hasattr(svc, "list")
+    assert hasattr(svc, "load")
+    assert hasattr(svc, "unload")
+
+
+@patch("lorai.client.ensure_running")
+def test_hub_service(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    svc = ai.hub
+    assert hasattr(svc, "models")
+    assert hasattr(svc, "pull")
+    assert hasattr(svc, "remove")
+    assert hasattr(svc, "status")
+    assert hasattr(svc, "bench")
+
+
+# ------------------------------------------------------------------
+# Test docker.py functions exist
+# ------------------------------------------------------------------
+
+def test_docker_module_functions():
+    from lorai import docker
+    assert callable(docker.is_docker_installed)
+    assert callable(docker.is_image_pulled)
+    assert callable(docker.is_container_running)
+    assert callable(docker.is_lorai_healthy)
+    assert callable(docker.pull_image)
+    assert callable(docker.start_container)
+    assert callable(docker.stop_container)
+    assert callable(docker.ensure_running)
+    assert callable(docker.status)
+
+
+# ------------------------------------------------------------------
+# Test CLI entry point
+# ------------------------------------------------------------------
+
+def test_cli_entry_point():
+    """Verify the CLI main function is importable and callable."""
+    from lorai.cli import main
+    assert callable(main)
+
+
+def test_cli_version_command(capsys):
+    """Test that 'lorai-workspace version' prints version and port."""
+    from lorai.cli import main
+    main(["version"])
+    captured = capsys.readouterr()
+    assert "0.1.0" in captured.out
+    assert "1842" in captured.out
+
+
+def test_cli_help_command(capsys):
+    """Test that 'lorai-workspace help' prints the banner."""
+    from lorai.cli import main
+    main(["help"])
+    captured = capsys.readouterr()
+    assert "All of AI" in captured.out
+    assert "1842" in captured.out
+
+
+# ------------------------------------------------------------------
+# Test default model
+# ------------------------------------------------------------------
+
+@patch("lorai.client.ensure_running")
+def test_default_model(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False, default_model="llama3")
+    assert ai._default_model == "llama3"
+
+
+@patch("lorai.client.ensure_running")
+def test_default_model_auto(mock_ensure):
+    from lorai import LorAI
+    ai = LorAI(auto_start=False)
+    assert ai._default_model == "auto"