kalavai-client 0.6.13__py3-none-any.whl → 0.6.16__py3-none-any.whl

kalavai_client/__init__.py

@@ -1,2 +1,2 @@
 
-__version__ = "0.6.13"
+__version__ = "0.6.16"

kalavai_client/assets/apps.yaml

@@ -152,7 +152,7 @@ releases:
     - name: replicas
       value: 1
     - name: image_tag
-      value: "v2025.05.2"
+      value: "v2025.06.7"
     - name: deployment.in_cluster
       value: "True"
     - name: deployment.kalavai_username_key

kalavai_client/assets/docker-compose-gui.yaml

@@ -2,6 +2,7 @@ services:
   kalavai_gui:
     container_name: kalavai_gui
     image: bundenth/kalavai-gui:latest
+    platform: linux/amd64
     extra_hosts:
     - "host.docker.internal:host-gateway"
     networks:

kalavai_client/assets/docker-compose-template.yaml

@@ -3,6 +3,7 @@ services:
   {{vpn_name}}:
     image: gravitl/netclient:v0.90.0
     container_name: {{vpn_name}}
+    platform: linux/amd64
     cap_add:
       - NET_ADMIN
       - SYS_MODULE
@@ -17,7 +18,8 @@ services:
 # run worker only if command is set
 {%if command %}
   {{service_name}}:
-    image: docker.io/bundenth/kalavai-runner:gpu-latest
+    image: docker.io/bundenth/kalavai-runner:{{target_platform}}-latest
+    pull_policy: always
     container_name: {{service_name}}
   {% if vpn %}
     depends_on:
@@ -35,6 +37,9 @@ services:
     {% endif %}
       --node_name="{{node_name}}"
       --node_ip="{{node_ip_address}}"
+    {% if random_suffix %}
+      --random_suffix="{{random_suffix}}"
+    {% endif %}
       {% if command == "server" %}
       --port_range="30000-32767"
       {% else %}

kalavai_client/bridge_api.py

@@ -54,12 +54,22 @@ from kalavai_client.core import (
 )
 from kalavai_client.utils import load_user_id
 
-app = FastAPI()
+app = FastAPI(
+    title="Kalavai Bridge API",
+    description="API for managing Kalavai pools, jobs, and nodes",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
 
 ################################
 ## API Key Validation methods ##
 ################################
 async def verify_api_key(request: Request):
+    """
+    Verify the API key from the request headers.
+    The API key must match the user ID.
+    """
     user_id = load_user_id()
     if user_id is None:
         return None
@@ -68,35 +78,69 @@ async def verify_api_key(request: Request):
         raise HTTPException(status_code=401, detail="Request requires API Key")
     return api_key
 
-@app.post("/create_pool")
+@app.post("/create_pool", 
+    summary="Create a new pool",
+    description="Creates a new pool with the specified configuration",
+    response_description="Result of pool creation")
 def pool_create(request: CreatePoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Create a new pool with the following parameters:
+    
+    - **cluster_name**: Name of the cluster
+    - **ip_address**: IP address for the pool
+    - **app_values**: Application configuration values
+    - **num_gpus**: Number of GPUs to allocate
+    - **node_name**: Name of the node
+    - **only_registered_users**: Whether to restrict to registered users
+    - **location**: Location of the pool
+    - **description**: Pool description
+    - **token_mode**: Token type for authentication
+    """
     result = create_pool(
         cluster_name=request.cluster_name,
         ip_address=request.ip_address,
         app_values=request.app_values,
         num_gpus=request.num_gpus,
         node_name=request.node_name,
-        only_registered_users=request.only_registered_users,
         location=request.location,
         description=request.description,
-        token_mode=request.token_mode,
-        frontend=request.frontend
+        token_mode=request.token_mode
     )
     return result
 
-@app.post("/join_pool")
+@app.post("/join_pool",
+    summary="Join an existing pool",
+    description="Join a pool using a token",
+    response_description="Result of joining the pool")
 def pool_join(request: JoinPoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Join a pool with the following parameters:
+    
+    - **token**: Pool join token
+    - **ip_address**: IP address for the node
+    - **node_name**: Name of the node
+    - **num_gpus**: Number of GPUs to allocate
+    """
     result = join_pool(
         token=request.token,
         num_gpus=request.num_gpus,
         node_name=request.node_name,
-        ip_address=request.ip_address,
-        frontend=request.frontend
+        ip_address=request.ip_address
     )
     return result
 
-@app.post("/attach_to_pool")
+@app.post("/attach_to_pool",
+    summary="Attach to an existing pool",
+    description="Attach to a pool using a token",
+    response_description="Result of attaching to the pool")
 def pool_attach(request: JoinPoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Attach to a pool with the following parameters:
+    
+    - **token**: Pool token
+    - **node_name**: Name of the node
+    - **frontend**: Whether this is a frontend request
+    """
     result = attach_to_pool(
         token=request.token,
         node_name=request.node_name,
@@ -104,65 +148,157 @@ def pool_attach(request: JoinPoolRequest, api_key: str = Depends(verify_api_key)
     )
     return result
 
-@app.post("/stop_pool")
+@app.post("/stop_pool",
+    summary="Stop a pool",
+    description="Stop the current pool",
+    response_description="Result of stopping the pool")
 def pool_stop(request: StopPoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Stop the pool with the following parameters:
+    
+    - **skip_node_deletion**: Whether to skip node deletion
+    """
     result = stop_pool(
         skip_node_deletion=request.skip_node_deletion
     )
     return result
 
-@app.post("/delete_nodes")
+@app.post("/delete_nodes",
+    summary="Delete nodes",
+    description="Delete specified nodes from the pool",
+    response_description="Result of node deletion")
 def device_delete(request: NodesActionRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Delete nodes with the following parameters:
+    
+    - **nodes**: List of node names to delete
+    """
     result = delete_nodes(
         nodes=request.nodes
     )
     return result
 
-@app.post("/cordon_nodes")
+@app.post("/cordon_nodes",
+    summary="Cordon nodes",
+    description="Mark nodes as unschedulable",
+    response_description="Result of cordoning nodes")
 def device_cordon(request: NodesActionRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Cordon nodes with the following parameters:
+    
+    - **nodes**: List of node names to cordon
+    """
     result = cordon_nodes(
         nodes=request.nodes
     )
     return result
 
-@app.post("/uncordon_nodes")
+@app.post("/uncordon_nodes",
+    summary="Uncordon nodes",
+    description="Mark nodes as schedulable",
+    response_description="Result of uncordoning nodes")
 def device_uncordon(request: NodesActionRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Uncordon nodes with the following parameters:
+    
+    - **nodes**: List of node names to uncordon
+    """
     result = uncordon_nodes(
         nodes=request.nodes
     )
     return result
 
-@app.get("/get_pool_token")
+@app.get("/get_pool_token",
+    summary="Get pool token",
+    description="Get a token for the pool",
+    response_description="Pool token")
 def get_token(mode: int, api_key: str = Depends(verify_api_key)):
-
+    """
+    Get pool token with the following parameters:
+    
+    - **mode**: Token type mode
+    """
     return get_pool_token(mode=TokenType(mode))
 
-@app.get("/fetch_devices")
+@app.get("/fetch_devices",
+    summary="Fetch devices",
+    description="Get list of available devices",
+    response_description="List of devices")
 def get_devices(api_key: str = Depends(verify_api_key)):
+    """Get list of available devices"""
     return fetch_devices()
 
-@app.post("/send_pool_invites")
+@app.post("/send_pool_invites",
+    summary="Send pool invites",
+    description="Send invites to join the pool",
+    response_description="Result of sending invites")
 def send_pool_invites(request: InvitesRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Send pool invites with the following parameters:
+    
+    - **invitees**: List of invitee identifiers
+    """
     return send_invites(invitees=request.invitees)
 
-@app.get("/fetch_resources")
+@app.get("/fetch_resources",
+    summary="Fetch resources",
+    description="Get available resources",
+    response_description="Resource information")
 def resources(api_key: str = Depends(verify_api_key)):
+    """Get available resources"""
     return fetch_resources()
 
-@app.get("/fetch_job_names")
+@app.get("/fetch_job_names",
+    summary="Fetch job names",
+    description="Get list of job names",
+    response_description="List of job names")
 def job_names(api_key: str = Depends(verify_api_key)):
+    """Get list of job names"""
     return fetch_job_names()
 
-@app.get("/fetch_gpus")
+@app.get("/fetch_gpus",
+    summary="Fetch GPUs",
+    description="Get list of available GPUs",
+    response_description="List of GPUs")
 def gpus(available: bool = False, api_key: str = Depends(verify_api_key)):
+    """
+    Get list of GPUs with the following parameters:
+    
+    - **available**: Whether to show only available GPUs
+    """
     return fetch_gpus(available=available)
 
-@app.post("/fetch_job_details")
+@app.post("/fetch_job_details",
+    summary="Fetch job details",
+    description="Get details for specified jobs",
+    response_description="Job details")
 def job_details(request: JobDetailsRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Get job details with the following parameters:
+    
+    - **jobs**: List of jobs to get details for
+    """
     return fetch_job_details(jobs=request.jobs)
 
-@app.get("/fetch_job_logs")
-def job_logs(job_name: str, force_namespace: str=None, pod_name: str=None, tail: int=100, api_key: str = Depends(verify_api_key)):
+@app.get("/fetch_job_logs",
+    summary="Fetch job logs",
+    description="Get logs for a specific job",
+    response_description="Job logs")
+def job_logs(
+    job_name: str,
+    force_namespace: str = None,
+    pod_name: str = None,
+    tail: int = 100,
+    api_key: str = Depends(verify_api_key)
+):
+    """
+    Get job logs with the following parameters:
+    
+    - **job_name**: Name of the job
+    - **force_namespace**: Optional namespace override
+    - **pod_name**: Optional pod name
+    - **tail**: Number of log lines to return
+    """
     return fetch_job_logs(
         job_name=job_name,
         force_namespace=force_namespace,
@@ -170,16 +306,39 @@ def job_logs(job_name: str, force_namespace: str=None, pod_name: str=None, tail:
         tail=tail
     )
 
-@app.get("/fetch_job_templates")
+@app.get("/fetch_job_templates",
+    summary="Fetch job templates",
+    description="Get available job templates",
+    response_description="List of job templates")
 def job_templates(api_key: str = Depends(verify_api_key)):
+    """Get available job templates"""
     return fetch_job_templates()
 
-@app.get("/fetch_job_defaults")
+@app.get("/fetch_job_defaults",
+    summary="Fetch job defaults",
+    description="Get default values for a job template",
+    response_description="Job default values")
 def job_templates(name: str, api_key: str = Depends(verify_api_key)):
+    """
+    Get job defaults with the following parameters:
+    
+    - **name**: Name of the job template
+    """
     return fetch_job_defaults(name=name)
 
-@app.post("/deploy_job")
+@app.post("/deploy_job",
+    summary="Deploy job",
+    description="Deploy a new job",
+    response_description="Result of job deployment")
 def job_deploy(request: DeployJobRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Deploy a job with the following parameters:
+    
+    - **template_name**: Name of the job template
+    - **values**: Job configuration values
+    - **force_namespace**: Optional namespace override
+    - **target_labels**: Optional target node labels
+    """
     result = deploy_job(
         template_name=request.template_name,
         values_dict=request.values,
@@ -188,76 +347,154 @@ def job_deploy(request: DeployJobRequest, api_key: str = Depends(verify_api_key)
     )
     return result
 
-@app.post("/delete_job")
+@app.post("/delete_job",
+    summary="Delete job",
+    description="Delete a job",
+    response_description="Result of job deletion")
 def job_delete(request: DeleteJobRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Delete a job with the following parameters:
+    
+    - **name**: Name of the job to delete
+    - **force_namespace**: Optional namespace override
+    """
     result = delete_job(
         name=request.name,
         force_namespace=request.force_namespace
     )
     return result
 
-@app.get("/authenticate_user")
+@app.get("/authenticate_user",
+    summary="Authenticate user",
+    description="Authenticate a user",
+    response_description="Authentication result")
 def user_authenticate(user_id: str, api_key: str = Depends(verify_api_key)):
+    """
+    Authenticate user with the following parameters:
+    
+    - **user_id**: User identifier
+    """
     result = authenticate_user(
         user_id=user_id
     )
     return result
 
-@app.get("/load_user_session")
+@app.get("/load_user_session",
+    summary="Load user session",
+    description="Load the current user session",
+    response_description="User session information")
 def user_session(api_key: str = Depends(verify_api_key)):
+    """Load the current user session"""
     result = load_user_session()
     return result
 
-@app.get("/user_logout")
+@app.get("/user_logout",
+    summary="User logout",
+    description="Log out the current user",
+    response_description="Logout result")
 def logout_user():
+    """Log out the current user"""
     result = user_logout()
     return result
 
-@app.get("/is_connected")
+@app.get("/is_connected",
+    summary="Check connection",
+    description="Check if connected to a pool",
+    response_description="Connection status")
 def pool_connected():
+    """Check if connected to a pool"""
     result = is_connected()
     return result
 
-@app.get("/is_agent_running")
+@app.get("/is_agent_running",
+    summary="Check agent status",
+    description="Check if the agent is running",
+    response_description="Agent status")
 def agent_running():
+    """Check if the agent is running"""
     result = is_agent_running()
     return result
 
-@app.get("/is_server")
+@app.get("/is_server",
+    summary="Check server status",
+    description="Check if running as server",
+    response_description="Server status")
 def server():
+    """Check if running as server"""
     result = is_server()
     return result
 
-@app.post("/pause_agent")
+@app.post("/pause_agent",
+    summary="Pause agent",
+    description="Pause the agent",
+    response_description="Result of pausing agent")
 def agent_pause():
+    """Pause the agent"""
     result = pause_agent()
     return result
 
-@app.post("/resume_agent")
+@app.post("/resume_agent",
+    summary="Resume agent",
+    description="Resume the agent",
+    response_description="Result of resuming agent")
 def agent_resume():
+    """Resume the agent"""
     result = resume_agent()
     return result
 
-@app.get("/get_ip_addresses")
-def ip_addresses(subnet: str=None, api_key: str = Depends(verify_api_key)):
+@app.get("/get_ip_addresses",
+    summary="Get IP addresses",
+    description="Get available IP addresses",
+    response_description="List of IP addresses")
+def ip_addresses(subnet: str = None, api_key: str = Depends(verify_api_key)):
+    """
+    Get IP addresses with the following parameters:
+    
+    - **subnet**: Optional subnet to filter by
+    """
     result = get_ip_addresses(subnet=subnet)
     return result
 
-@app.get("/list_available_pools")
-def pool_connected(user_only: bool=False, api_key: str = Depends(verify_api_key)):
+@app.get("/list_available_pools",
+    summary="List available pools",
+    description="Get list of available pools",
+    response_description="List of available pools")
+def pool_connected(user_only: bool = False, api_key: str = Depends(verify_api_key)):
+    """
+    List available pools with the following parameters:
+    
+    - **user_only**: Whether to show only user's pools
+    """
     result = list_available_pools(user_only=user_only)
     return result
 
-@app.post("/add_node_labels")
+@app.post("/add_node_labels",
+    summary="Add node labels",
+    description="Add labels to a node",
+    response_description="Result of adding labels")
 def node_labels(request: NodeLabelsRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Add node labels with the following parameters:
+    
+    - **node_name**: Name of the node
+    - **labels**: Dictionary of labels to add
+    """
     result = add_node_labels(
         node_name=request.node_name,
         labels=request.labels
     )
     return result
 
-@app.post("/get_node_labels")
+@app.post("/get_node_labels",
+    summary="Get node labels",
+    description="Get labels for specified nodes",
+    response_description="Node labels")
 def node_labels_get(request: GetNodeLabelsRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Get node labels with the following parameters:
+    
+    - **node_names**: List of node names to get labels for
+    """
     result = get_node_labels(
         node_names=request.node_names
     )

kalavai_client/bridge_models.py

@@ -1,53 +1,51 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import List, Dict, Optional
 
 from kalavai_client.core import Job, TokenType
 
 
 class InvitesRequest(BaseModel):
-    invitees: list[str]
+    invitees: list[str] = Field(description="List of user identifiers to invite to the pool")
 
 class CreatePoolRequest(BaseModel):
-    cluster_name: str
-    ip_address: str
-    app_values: dict = None
-    num_gpus: int = None
-    node_name: str = None
-    only_registered_users: bool = False
-    location: str = None
-    token_mode: TokenType = TokenType.USER
-    description: str = ""
-    frontend: bool = False
+    cluster_name: str = Field(description="Name of the cluster to create")
+    ip_address: str = Field(description="IP address for the pool")
+    app_values: dict = Field(None, description="Application configuration values")
+    num_gpus: int = Field(None, description="Number of GPUs to allocate")
+    node_name: str = Field(None, description="Name of the node")
+    location: str = Field(None, description="Geographic location of the pool")
+    token_mode: TokenType = Field(TokenType.USER, description="Token type for authentication")
+    description: str = Field("", description="Description of the pool")
 
 class NodesActionRequest(BaseModel):
-    nodes: list[str]
+    nodes: list[str] = Field(description="List of node names to perform the action on")
 
 class JoinPoolRequest(BaseModel):
-    token: str
-    ip_address: str = None
-    node_name: str = None
-    num_gpus: int = None
-    frontend: bool = False
+    token: str = Field(description="Token to join the pool")
+    ip_address: str = Field(None, description="IP address for the node")
+    node_name: str = Field(None, description="Name of the node")
+    num_gpus: int = Field(None, description="Number of GPUs to allocate")
+    frontend: bool = Field(False, description="Whether this is a frontend request")
 class JobDetailsRequest(BaseModel):
-    jobs: list[Job]
+    jobs: list[Job] = Field(description="List of jobs to get details for")
 
 
 class StopPoolRequest(BaseModel):
-    skip_node_deletion: bool = False
+    skip_node_deletion: bool = Field(False, description="Whether to skip node deletion when stopping the pool")
 
 class DeployJobRequest(BaseModel):
-    template_name: str
-    values: dict
-    force_namespace: str = None
-    target_labels: dict[str, str] = None
+    template_name: str = Field(description="Name of the job template to use")
+    values: dict = Field(description="Job configuration values")
+    force_namespace: str = Field(None, description="Optional namespace override")
+    target_labels: dict[str, str] = Field(None, description="Optional target node labels")
 
 class DeleteJobRequest(BaseModel):
-    name: str
-    force_namespace: str = None
+    name: str = Field(description="Name of the job to delete")
+    force_namespace: str = Field(None, description="Optional namespace override")
 
 class NodeLabelsRequest(BaseModel):
-    node_name: str
-    labels: Dict[str, str]
+    node_name: str = Field(description="Name of the node to add labels to")
+    labels: Dict[str, str] = Field(description="Dictionary of labels to add to the node")
 
 class GetNodeLabelsRequest(BaseModel):
-    node_names: List[str]
+    node_names: List[str] = Field(description="List of node names to get labels for")

kalavai_client/cli.py

@@ -325,7 +325,7 @@ def pool__unpublish(cluster_name=None, *others):
         console.log(f"[green]Your cluster has been removed from {KALAVAI_PLATFORM_URL}")
 
 @arguably.command
-def pool__package_worker(output_file, *others, num_gpus=0, ip_address="0.0.0.0", node_name=None, storage_compatible=True):
+def pool__package_worker(output_file, *others, platform="amd64", num_gpus=0, ip_address="0.0.0.0", node_name=None, storage_compatible=True):
     """
     [AUTH]Package a worker for distribution (docker compose only)
     """
@@ -335,6 +335,7 @@ def pool__package_worker(output_file, *others, num_gpus=0, ip_address="0.0.0.0",
         return
     
     compose = generate_worker_package(
+        target_platform=platform,
         num_gpus=num_gpus,
         ip_address=ip_address,
         node_name=node_name,
@@ -374,7 +375,7 @@ def pool__list(*others, user_only=False):
 
 
 @arguably.command
-def pool__start(cluster_name, *others,  ip_address: str=None, location: str=None, app_values: str=None, pool_config_values: str=None, non_interactive: bool=False):
+def pool__start(cluster_name, *others,  platform="amd64", ip_address: str=None, location: str=None, app_values: str=None, pool_config_values: str=None, non_interactive: bool=False):
     """
     Start Kalavai pool and start/resume sharing resources.
 
@@ -411,6 +412,7 @@ def pool__start(cluster_name, *others,  ip_address: str=None, location: str=None
     console.log(f"[green]Creating {cluster_name} pool, this may take a few minutes...")
 
     result = create_pool(
+        target_platform=platform,
         cluster_name=cluster_name,
         ip_address=ip_address,
         app_values=app_values,
@@ -472,7 +474,7 @@ def pool__check_token(token, *others, public=False):
     return True
 
 @arguably.command
-def pool__join(token, *others, node_name=None, non_interactive=False):
+def pool__join(token, *others, platform="amd64", node_name=None, non_interactive=False):
     """
     Join Kalavai pool and start/resume sharing resources.
 
@@ -522,6 +524,7 @@ def pool__join(token, *others, node_name=None, non_interactive=False):
     
     console.log("Connecting worker to the pool...")
     result = join_pool(
+        target_platform=platform,
         token=token,
         node_name=node_name,
         num_gpus=num_gpus,

kalavai_client/core.py

@@ -595,7 +595,7 @@ def attach_to_pool(token, node_name=None):
 
     return cluster_name
 
-def generate_worker_package(num_gpus=0, node_name=None, ip_address="0.0.0.0", storage_compatible=True):
+def generate_worker_package(target_platform="amd64", num_gpus=0, node_name=None, ip_address="0.0.0.0", storage_compatible=True):
     # get pool data from token  
     token = get_pool_token(mode=TokenType.WORKER)
     if "error" in token:
@@ -620,6 +620,7 @@ def generate_worker_package(num_gpus=0, node_name=None, ip_address="0.0.0.0", st
     }
     # Generate docker compose recipe
     compose = generate_compose_config(
+        target_platform=target_platform,
         write_to_file=False,
         role="agent",
         node_ip_address=ip_address,
@@ -633,7 +634,13 @@ def generate_worker_package(num_gpus=0, node_name=None, ip_address="0.0.0.0", st
     return compose
 
 
-def join_pool(token, num_gpus=None, node_name=None, ip_address=None):
+def join_pool(
+        token,
+        num_gpus=None,
+        node_name=None,
+        ip_address=None,
+        target_platform="amd64"
+):
     compatibility = check_worker_compatibility()
     if len(compatibility["issues"]) > 0:
         return {"error": compatibility["issues"]}
@@ -668,6 +675,7 @@ def join_pool(token, num_gpus=None, node_name=None, ip_address=None):
     # local agent join
     # Generate docker compose recipe
     generate_compose_config(
+        target_platform=target_platform,
         role="agent",
         node_ip_address=ip_address,
         pool_ip=f"https://{kalavai_seed_ip}:6443",
@@ -722,7 +730,8 @@ def create_pool(
         pool_config_values: str=None,
         num_gpus: int=0,
         node_name: str=None,
-        location: str=None
+        location: str=None,
+        target_platform: str="amd64"
     ):
 
     if not check_seed_compatibility():
@@ -756,6 +765,7 @@ def create_pool(
     
     # Generate docker compose recipe
     generate_compose_config(
+        target_platform=target_platform,
         role="server",
         vpn_token=location,
         node_ip_address=ip_address,

kalavai_client/utils.py

@@ -106,12 +106,13 @@ def is_storage_compatible():
         return False
 ################
 
-def generate_compose_config(role, node_name, write_to_file=True, node_ip_address="0.0.0.0", num_gpus=0, node_labels=None, pool_ip=None, vpn_token=None, pool_token=None):
+def generate_compose_config(role, node_name, target_platform="amd64", write_to_file=True, node_ip_address="0.0.0.0", num_gpus=0, node_labels=None, pool_ip=None, vpn_token=None, pool_token=None):
     
     if node_labels is not None:
         node_labels = " ".join([f"--node-label {key}={value}" for key, value in node_labels.items()])
     rand_suffix = uuid.uuid4().hex[:8]
     compose_values = {
+        "target_platform": target_platform,
         "user_path": user_path(""),
         "service_name": DEFAULT_CONTAINER_NAME,
         "vpn": vpn_token is not None,
@@ -126,6 +127,7 @@ def generate_compose_config(role, node_name, write_to_file=True, node_ip_address
         "num_gpus": num_gpus,
         "k3s_path": f"{CONTAINER_HOST_PATH}/{rand_suffix}/k3s",
         "etc_path": f"{CONTAINER_HOST_PATH}/{rand_suffix}/etc",
+        "random_suffix": rand_suffix,
         "node_labels": node_labels,
         "flannel_iface": DEFAULT_FLANNEL_IFACE if vpn_token is not None else "",
         "user_id": load_user_id()

{kalavai_client-0.6.13.dist-info → kalavai_client-0.6.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kalavai-client
-Version: 0.6.13
+Version: 0.6.16
 Summary: Client app for kalavai platform
 License: Apache-2.0
 Keywords: LLM,platform
@@ -52,30 +52,28 @@ Description-Content-Type: text/markdown
 
 </div>
 
-⭐⭐⭐ **Kalavai and our AI pools are open source, and free to use in both commercial and non-commercial purposes. If you find it useful, consider supporting us by [giving a star to our GitHub project](https://github.com/kalavai-net/kalavai-client), joining our [discord channel](https://discord.gg/YN6ThTJKbM), follow our [Substack](https://kalavainet.substack.com/) and give us a [review on Product Hunt](https://www.producthunt.com/products/kalavai/reviews/new).**
+⭐⭐⭐ **Kalavai platform is open source, and free to use in both commercial and non-commercial purposes. If you find it useful, consider supporting us by [giving a star to our GitHub project](https://github.com/kalavai-net/kalavai-client), joining our [discord channel](https://discord.gg/YN6ThTJKbM) and follow our [Substack](https://kalavainet.substack.com/).**
 
 
 # Kalavai: turn your devices into a scalable AI platform
 
-### Taming the adoption of Large Language Models
+> AI in the cloud is not aligned with you, it's aligned with the company that owns it. Make sure you own your AI
 
-> Kalavai is an **open source** tool that turns **everyday devices** into your very own LLM platform. It aggregates resources from multiple machines, including desktops and laptops, and is **compatible with most model engines** to make LLM deployment and orchestration simple and reliable.
+### Taming the adoption of self-hosted GenAI
 
-<div align="center">
-
-<a href="https://www.producthunt.com/products/kalavai/reviews?utm_source=badge-product_review&utm_medium=badge&utm_souce=badge-kalavai" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/product_review.svg?product_id=720725&theme=neutral" alt="Kalavai - The&#0032;first&#0032;platform&#0032;to&#0032;crowdsource&#0032;AI&#0032;computation | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
-
-</div>
+Kalavai is an **open source** tool that turns **any devices** into a self-hosted AI platform. It aggregates resources from multiple machines, including cloud, on prem and personal computers, and is **compatible with most model engines** to make model deployment and orchestration simple and reliable.
 
 
 ## What can Kalavai do?
 
-Kalavai's goal is to make using AI (LLMs, AI agents) in real applications accessible and affordable to all. It's a _magic box_ that **integrates all the components required to make AI useful in the age of massive computing**, from model deployment and orchestration to Agentic AI. 
+Kalavai's goal is to make using self-hosted AI (GenAI models and agents) in real applications accessible and affordable to all. It's a tool that transforms machines into a _magic box_ that **integrates all the components required to make AI useful in the age of massive computing**, from model deployment and orchestration to Agentic AI. 
 
 ### Core features
 
 - Manage **multiple devices resources as one**. One pool of RAM, CPUs and GPUs
-- **Deploy Large Language Models seamlessly across devices**, wherever they are (multiple clouds, on premises, personal devices)
+- **Deploy open source models seamlessly across devices**, wherever they are (cloud, on premises, personal devices)
+- Beyond LLMs: not just for large language models, but text-to-speech, speech-to-text, image understanding, coding generation and embedding models.
+- The hybrid dream: build on your laptop, move to the cloud (any!) with zero changes
 - Auto-discovery: all **models are automatically exposed** through a single OpenAI-like API and a ChatGPT-like UI playground
 - Compatible with [most popular model engines](#support-for-llm-engines)
 - [Easy to expand](https://github.com/kalavai-net/kube-watcher/tree/main/templates) to custom workloads
@@ -83,19 +81,19 @@ Kalavai's goal is to make using AI (LLMs, AI agents) in real applications access
 
 <details>
 
-**<summary>Video tutorials</summary>**
+**<summary>Powered by Kalavai</summary>**
 
-### Self-hosted LLM pools
-
-https://github.com/user-attachments/assets/0d2316f3-79ea-46ac-b41e-8ef720f52672
+- [CoGen AI](https://cogenai.kalavai.net): A community hosted alternative to OpenAI API for unlimited inference.
+- [Create your own Free Cursor/Windsurf Clone](https://www.youtube.com/watch?v=6zHSo7oeCDQ&t=21s)
 
 
 </details>
 
+
 ### Latest updates
 
+- 11 June 2025: Native support for Mac and Raspberry pi devices (ARM).
 - 20 February 2025: New shiny GUI interface to control LLM pools and deploy models
-- 6 February 2025: 🔥🔥🔥 Access  **DeepSeek R1 model for free** when you join our [public LLM pool](https://kalavai-net.github.io/kalavai-client/public_llm_pool/)
 - 31 January 2025: `kalavai-client` is now a [PyPI package](https://pypi.org/project/kalavai-client/), easier to install than ever!
 <details>
 <summary>More news</summary>
@@ -148,8 +146,6 @@ The `kalavai-client` is the main tool to interact with the Kalavai platform, to
 
 <summary>Requirements</summary>
 
-### Requirements
-
 For workers sharing resources with the pool:
 
 - A laptop, desktop or Virtual Machine
@@ -157,37 +153,8 @@ For workers sharing resources with the pool:
 
 > **Support for Windows and MacOS workers is experimental**: kalavai workers run on docker containers that require access to the host network interfaces, thus systems that do not support containers natively (Windows and MacOS) may have difficulties finding each other.
 
-Any system that runs python 3.6+ is able to run the `kalavai-client` and therefore connect and operate an LLM pool, [without sharing with the pool](). Your computer won't be adding its capacity to the pool, but it wil be able to deploy jobs and interact with models.
-
 </details>
 
-<details>
-
-<summary> Common issues</summary>
-
-If you see the following error:
-
-```bash
-fatal error: Python.h: No such file or directory | #include <Python.h>
-```
-
-Make sure you also install python3-dev package. For ubuntu distros:
-
-```bash
-sudo apt install python3-dev
-```
-
-If you see:
-```bash
-AttributeError: install_layout. Did you mean: 'install_platlib'?
-      [end of output]
-```
-
-Upgrade your setuptools:
-```bash
-pip install -U setuptools
-```
-</details>
 
 ### Install the client
 
@@ -230,6 +197,8 @@ If your system is not currently supported, [open an issue](https://github.com/ka
 
 ### OS compatibility
 
+Currently **seed nodes** are supported exclusively on linux machines (x86_64 platform). However Kalavai supports mix-pools, i.e. having Windows and MacOS computers as workers.
+
 Since **worker nodes** run inside docker, any machine that can run docker **should** be compatible with Kalavai. Here are instructions for [linux](https://docs.docker.com/engine/install/), [Windows](https://docs.docker.com/desktop/setup/install/windows-install/) and [MacOS](https://docs.docker.com/desktop/setup/install/mac-install/).
 
 The kalavai client, which controls and access pools, can be installed on any machine that has python 3.10+.
@@ -237,9 +206,10 @@ The kalavai client, which controls and access pools, can be installed on any mac
 
 ### Hardware compatibility:
 
-- `amd64` or `x86_64` CPU architecture
+- `amd64` or `x86_64` CPU architecture for seed and worker nodes.
+- `arm64` CPU architecture for worker nodes.
 - NVIDIA GPU
-- AMD and Intel GPUs are currently not supported ([interested in helping us test it?](https://kalavai-net.github.io/kalavai-client/compatibility/#help-testing-amd-gpus))
+- Mac M series, AMD and Intel GPUs are currently not supported ([interested in helping us test it?](https://kalavai-net.github.io/kalavai-client/compatibility/#help-testing-amd-gpus))
 
 </details>
 
@@ -247,15 +217,15 @@ The kalavai client, which controls and access pools, can be installed on any mac
 
 - [x] Kalavai client on Linux
 - [x] [TEMPLATE] Distributed LLM deployment
-- [x] Kalavai client on Windows (with WSL2)
+- [x] Kalavai client on Windows (worker only)
+- [x] Kalavai client on Windows WSL2 (seed and worker)
 - [x] Self-hosted LLM pools
 - [x] Collaborative LLM deployment
 - [x] Ray cluster support
-- [x] Kalavai client on Mac
+- [x] Kalavai client on Mac (worker only)
 - [x] Kalavai pools UI
-- [ ] [TEMPLATE] [GPUStack](https://github.com/gpustack/gpustack) support
-- [ ] [TEMPLATE] [exo](https://github.com/exo-explore/exo) support
 - [ ] Support for AMD GPUs
+- [ ] Support for Mac M GPUs
 - [x] Docker install path
 
 

kalavai_client-0.6.16.dist-info/RECORD

@@ -0,0 +1,25 @@
+kalavai_client/__init__.py,sha256=1--FABNdIxbiNn1wQox38stjIswkk1wPeOgoYJXMsNU,23
+kalavai_client/__main__.py,sha256=WQUfxvRsBJH5gsCJg8pLz95QnZIj7Ol8psTO77m0QE0,73
+kalavai_client/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kalavai_client/assets/apps.yaml,sha256=Qe3RtY4kQbzZnF9K724FUbtqnkuCGfNUfK-WWtamATg,6365
+kalavai_client/assets/apps_values.yaml,sha256=WRew3bS1MztjzcJfphuJcKn0n2T1ICRupPpr_Csjt_s,1644
+kalavai_client/assets/docker-compose-gui.yaml,sha256=shqN78YLw0QP7bqTKveI4ppz5E-5b1JowmsSB4OG3nA,778
+kalavai_client/assets/docker-compose-template.yaml,sha256=KHIwJ2WWX7Y7wQKiXRr82Jqd3IKRyls5zhTyl8mSmrc,1805
+kalavai_client/assets/nginx.conf,sha256=drVVCg8GHucz7hmt_BI6giAhK92OV71257NTs3LthwM,225
+kalavai_client/assets/pool_config_template.yaml,sha256=fFz4w2-fMKD5KvyzFdfcWD_jSneRlmnjLc8hCctweX0,576
+kalavai_client/assets/pool_config_values.yaml,sha256=VrM3XHQfQo6QLZ68qvagooUptaYgl1pszniY_JUtemk,233
+kalavai_client/assets/user_workspace.yaml,sha256=wDvlMYknOPABAEo0dsQwU7bac8iubjAG9tdkFbJZ5Go,476
+kalavai_client/assets/user_workspace_values.yaml,sha256=G0HOzQUxrDMCwuW9kbWUZaKMzDDPVwDwzBHCL2Xi2ZM,542
+kalavai_client/auth.py,sha256=EB3PMvKUn5_KAQkezkEHEt-OMZXyfkZguIQlUFkEHcA,3243
+kalavai_client/bridge_api.py,sha256=O65aIh5lUl0KldRekHzLC-xdv1YJmrR14kt5-3UgCco,15351
+kalavai_client/bridge_models.py,sha256=5ALGbkb6cxKwXbrzeTa9ja0kiZkJBvnY3J1IsmXTn0U,2540
+kalavai_client/cli.py,sha256=_LK5OrCM5PYcYZo7lwXyfI3mlNzLFhL-BicKYbJkxeY,47123
+kalavai_client/cluster.py,sha256=Z2PIXbZuSAv9xmw-MyZP1M41BpVMpirLzG51bqGA-zc,13548
+kalavai_client/core.py,sha256=R8UBTTzMHVPHuM9nB70cIxUxVCHyBspEq1cAWH1OyOQ,34304
+kalavai_client/env.py,sha256=YsfZj7LWf6ABquDsoIFFkXCFYwenpDk8zVnGsf7qv98,2823
+kalavai_client/utils.py,sha256=kGtfEuXVG5LgMJk289ksFgYrsMHwKXN7yvS5wCIou8s,12781
+kalavai_client-0.6.16.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kalavai_client-0.6.16.dist-info/METADATA,sha256=K5mzqy8pSDdK6WWFSt8YZNTJLENfeV3OOGELq417dYs,12655
+kalavai_client-0.6.16.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+kalavai_client-0.6.16.dist-info/entry_points.txt,sha256=9T6D45gxwzfVbglMm1r6XPdXuuZdHfy_7fCeu2jUphc,50
+kalavai_client-0.6.16.dist-info/RECORD,,

kalavai_client-0.6.13.dist-info/RECORD

@@ -1,25 +0,0 @@
-kalavai_client/__init__.py,sha256=RtAfZnVOn5ru1jOt5ukVyb0s2GiJ7s39Qp5_KBjCL-A,23
-kalavai_client/__main__.py,sha256=WQUfxvRsBJH5gsCJg8pLz95QnZIj7Ol8psTO77m0QE0,73
-kalavai_client/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kalavai_client/assets/apps.yaml,sha256=AhTA3VZI27y05xHoHJCA9nvGnk8sWMhFDruBI2is3LM,6365
-kalavai_client/assets/apps_values.yaml,sha256=WRew3bS1MztjzcJfphuJcKn0n2T1ICRupPpr_Csjt_s,1644
-kalavai_client/assets/docker-compose-gui.yaml,sha256=DGCyGYzz1kH6kkMbo62FJHe3F9vcAmA8DOHw-c_o0Kw,752
-kalavai_client/assets/docker-compose-template.yaml,sha256=Nz_JzeBnQCzPCyWP5cEQHFeZzPwQqqBJ3C_xrToWlMA,1654
-kalavai_client/assets/nginx.conf,sha256=drVVCg8GHucz7hmt_BI6giAhK92OV71257NTs3LthwM,225
-kalavai_client/assets/pool_config_template.yaml,sha256=fFz4w2-fMKD5KvyzFdfcWD_jSneRlmnjLc8hCctweX0,576
-kalavai_client/assets/pool_config_values.yaml,sha256=VrM3XHQfQo6QLZ68qvagooUptaYgl1pszniY_JUtemk,233
-kalavai_client/assets/user_workspace.yaml,sha256=wDvlMYknOPABAEo0dsQwU7bac8iubjAG9tdkFbJZ5Go,476
-kalavai_client/assets/user_workspace_values.yaml,sha256=G0HOzQUxrDMCwuW9kbWUZaKMzDDPVwDwzBHCL2Xi2ZM,542
-kalavai_client/auth.py,sha256=EB3PMvKUn5_KAQkezkEHEt-OMZXyfkZguIQlUFkEHcA,3243
-kalavai_client/bridge_api.py,sha256=ZLyFOOz_o4agm-7DrHzoSBFrH65y__hZUoEe4diBTOA,7557
-kalavai_client/bridge_models.py,sha256=GbIaqGFAVs-3ikVUQZldwTTc06SsxmP6iAifH0oVDro,1219
-kalavai_client/cli.py,sha256=mmwLqqSYfl9k6vqveMcbHTq7g5FFd84YUUQCSH4J0k0,46967
-kalavai_client/cluster.py,sha256=Z2PIXbZuSAv9xmw-MyZP1M41BpVMpirLzG51bqGA-zc,13548
-kalavai_client/core.py,sha256=u8a4uYqGS0mMJh0ArcXG2hwp2uDUSuwM5ROGXRQkHZg,34051
-kalavai_client/env.py,sha256=YsfZj7LWf6ABquDsoIFFkXCFYwenpDk8zVnGsf7qv98,2823
-kalavai_client/utils.py,sha256=yHz9n4hGwhpGUTc1ZcG5JHtesoUEzSngmOSTvu2jDic,12674
-kalavai_client-0.6.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kalavai_client-0.6.13.dist-info/METADATA,sha256=YUeJh_a81RDslXa8QNlgNwmXfQLHxAbqcCK2HWP6t-4,13354
-kalavai_client-0.6.13.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-kalavai_client-0.6.13.dist-info/entry_points.txt,sha256=9T6D45gxwzfVbglMm1r6XPdXuuZdHfy_7fCeu2jUphc,50
-kalavai_client-0.6.13.dist-info/RECORD,,