AI Studio

Yandex AI Studio is a platform for working with generative models and creating AI agents as part of Stackland. With AI Studio, you can execute requests to language models, get embeddings, create assistants, and hook up tools to them.

AI Studio modules do not form part of the standard Stackland package and are licensed separately.

CompositionComposition

AI Studio consists of two components:

• Model Gallery: Launching language models, getting embeddings, and running safety checks on queries and responses (Ethics).
• Agent Atelier: Creating and launching AI agents and assistants based on models from Model Gallery. Allows you to connect tools and prepare datasets. Additionally, you can enable Code Interpreter to execute code.

Infrastructure requirementsInfrastructure requirements

The benchmarks listed below apply to AI Studio in Stackland 26.3. The amount of resources depends on what models are on at the same time and the number of active sessions.

During the cluster deployment stage, enable NVIDIA® GPU support for each worker node with a GPU.

Minimum cluster configurationMinimum cluster configuration

The minimum cluster configuration for AI Studio is designed to support simultaneous operation of one YandexGPT 5 Lite model, Embeddings, and Ethics. The table lists the resources per node.

Total: 136 vCPUs, 648 GB RAM, approximately 4.1 TB of disk space, one A100, and two H100s.

To run other models at the same time with this set, increase the cluster resources. For example, to additionally run a YandexGPT 5.1 Pro, add another node with two H100s.

Resources not related to modelsResources not related to models

When planning your AI Studio resources without models, aim for 24 vCPUs, 54 GB RAM, and 93 GB of persistent disk space. You need additional space in Object Storage for model weights and user data.

These resources are accounted for separately from model resources, Code Interpreter sessions, and other Stackland components. When planning, leave a margin for system processes and peak loads.

Model resourcesModel resources

The resources of each included model are added to the AI Studio resources not related to models.

The CPU and RAM values ​​are provided as a configuration example. A dash means the example does not give the individual disk size. Finalize the requirements marked with To be determined prior to activating the model based on your workload.

For models that require two GPUs, both of them must be on the same node.

Examples of additional modelsExamples of additional models

Examples of resources for Vision-Language Models (VLMs) and Optical Character Recognition (OCR) models are provided below. Their availability depends on AI Studio version. The following table serves as a resource planning guide.

Clarify the missing resource requirements prior to deployment.

Code InterpreterCode Interpreter

Each active Code Interpreter session additionally requires approximately 2.1 vCPUs, 4.1 GB RAM, and 5–10 GB of temporary disk space. No GPU is required. Consider the resources of all simultaneously active sessions.

DependenciesDependencies

To use AI Studio, you also need the following Stackland components:

• Object Storage: Storage of model weights, datasets, and other files.
• Managed Service for PostgreSQL: Metadata and service status storage.
• Identity and Access Management: User authentication, service accounts, and storage access.
• NVIDIA® GPU support: GPU provisioning for models.
• Certificate Manager: Issue of TLS certificates, including for Code Interpreter.
• Disk subsystem: Creation of persistent volumes.

First, enable Object Storage and the other dependencies, then Model Gallery and Agent Atelier.

ConfigurationConfiguration

The components are managed via the custom ModelGalleryConfig and AgentAtelierConfig resources named main. Both resources operate at the cluster level; you do not need to specify a namespace. The spec.enabled parameter enables or disables the relevant component.

Model GalleryModel Gallery

The example includes Embeddings, Ethics, and YandexGPT 5 Lite. The remaining language models are described but disabled. Before you enable them, add resources according to the table or disable unnecessary models.

apiVersion: stackland.yandex.cloud/v1alpha1
kind: ModelGalleryConfig
metadata:
  name: main
spec:
  enabled: true
  settings:
    storageClass: stackland-other

    embeddings:
      enabled: true
      nodeSelector:
        nvidia.com/gpu.product: NVIDIA-A100-SXM4-80GB
      affinity: {}
      resources:
        requests:
          cpu: "8"
          memory: 12Gi
          nvidia.com/gpu: "1"
        limits:
          cpu: "32"
          memory: 48Gi
          nvidia.com/gpu: "1"
      weightsInit:
        resources:
          requests:
            cpu: 500m
            memory: 512Mi
          limits:
            cpu: "2"
            memory: 2Gi

    ethics:
      enabled: true
      nodeSelector: &h100Selector
        nvidia.com/gpu.product: NVIDIA-H100-80GB-HBM3
      affinity: {}
      resources:
        requests:
          cpu: "4"
          memory: 4Gi
          nvidia.com/gpu: "1"
        limits:
          cpu: "16"
          memory: 32Gi
          nvidia.com/gpu: "1"
      weightsInit: &weightsInit
        resources:
          requests:
            cpu: 500m
            memory: 512Mi
          limits:
            cpu: "2"
            memory: 2Gi
    models:
      - name: lite
        modelType: yandexgpt-lite
        enabled: true
        nodeSelector: *h100Selector
        affinity: {}
        modelBackend:
          resources:
            requests:
              cpu: "2"
              memory: 4Gi
              nvidia.com/gpu: "1"
            limits:
              cpu: "8"
              memory: 16Gi
              nvidia.com/gpu: "1"
        grpcBackend: &grpcBackend
          resources:
            requests:
              cpu: "1"
              memory: 2Gi
            limits:
              cpu: "4"
              memory: 8Gi
        weightsInit: *weightsInit

      - name: pro-5-1
        modelType: yandexgpt-pro
        enabled: false
        nodeSelector: *h100Selector
        affinity: {}
        modelBackend:
          resources:
            requests:
              nvidia.com/gpu: "2"
            limits:
              nvidia.com/gpu: "2"
        grpcBackend: *grpcBackend
        weightsInit: *weightsInit

      - name: alice
        modelType: yandexgpt-lite
        enabled: false
        nodeSelector: *h100Selector
        affinity: {}
        modelBackend:
          resources:
            requests:
              cpu: "2"
              nvidia.com/gpu: "1"
            limits:
              cpu: "8"
              nvidia.com/gpu: "1"
        grpcBackend: *grpcBackend
        weightsInit: *weightsInit

      - name: alice-flash
        modelType: yandexgpt-lite
        enabled: false
        nodeSelector: *h100Selector
        affinity: {}
        modelBackend:
          resources:
            requests:
              cpu: "2"
              nvidia.com/gpu: "2"
            limits:
              cpu: "8"
              nvidia.com/gpu: "2"
        grpcBackend: *grpcBackend
        weightsInit: *weightsInit

Where:

• settings.storageClass: Storage class for persistent volumes. If not specified, the default storage class is used, selected during cluster deployment in the spec.cluster.storage.defaultStorageClass field of the StacklandClusterConfig resource.
• settings.embeddings.enabled: Includes getting embeddings.
• settings.ethics.enabled: Includes security checks for requests and responses.
• settings.models: List of language models. To enable the model, set enabled: true; to disable, set enabled: false.
• nodeSelector: Labels of nodes you can place a pod on. The nvidia.com/gpu.product label values ​​must match the GPUs in your cluster.
• affinity: Additional pod placement rules. For example, you can set a preferred node for the model.
• resources.requests: CPU, RAM, and GPU requests Kubernetes consults when placing a container. resources.limits stands for resource limits. For nvidia.com/gpu, specify the same values ​​in requests and limits.

For language models, use the name and modelType values from the following table:

Affinity configuration exampleAffinity configuration example

To specify a preferred node for YandexGPT 5 Lite, replace affinity: {} of the lite model in spec.settings.models with the following section:

affinity:
  nodeAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
            - key: kubernetes.io/hostname
              operator: In
              values:
                - gpu1.stackland.internal

Replace gpu1.stackland.internal with the kubernetes.io/hostname label value of the required node. You can find out the label values ​​using the kubectl get nodes -L kubernetes.io/hostname command.

The rule increases the priority of the specified node during pod placement. Kubernetes can select another node that matches nodeSelector and has free resources. For more details on placement rules, see this Kubernetes guide.

Agent AtelierAgent Atelier

Configuration example with Code Interpreter enabled:

apiVersion: stackland.yandex.cloud/v1alpha1
kind: AgentAtelierConfig
metadata:
  name: main
spec:
  enabled: true
  settings:
    storageClass: stackland-other
    codeInterpreter:
      enabled: true
      sessionIdleTTL: 2h
      sessionHardTTL: 24h

Where:

• settings.storageClass: Storage class for persistent volumes. The default value is stackland-other.
• settings.codeInterpreter.enabled: Enables Code Interpreter. The default value is false.
• settings.codeInterpreter.sessionIdleTTL: Inactive session retention time before deletion. The default value is 2h.
• settings.codeInterpreter.sessionHardTTL: Maximum session lifetime regardless of activity. The default value is 24h.

Useful linksUseful links

• Uploading AI Studio images
• Activate AI Studio
• Disabling AI Studio