values.yaml

# Default values for the langsmith helm chart. Refer to documentation on individual values for help with configuration.

# -- Provide a name in place of `langsmith`
nameOverride: ""
# -- String to fully override `"langsmith.fullname"`
fullnameOverride: ""
# -- Namespace to install the chart into. If not set, will use the namespace of the current context.
namespace: ""
# -- Prerequisite manifests rendered as Helm pre-install / pre-upgrade hooks so they
# -- are applied before the rest of the chart's resources. Typical use case is an
# -- ExternalSecret that produces a Secret consumed via `config.existingSecretName`.
# -- See `templates/pre-install-manifests.yaml` for entry forms, injected
# -- annotations, ExternalSecret-only validation, idempotency rules, and caveats.
# Example:
# preInstallManifests:
#   - apiVersion: external-secrets.io/v1beta1
#     kind: ExternalSecret
#     metadata:
#       name: langsmith-app
#     spec:
#       refreshInterval: 1h
#       secretStoreRef:
#         name: vault-backend
#         kind: ClusterSecretStore
#       target:
#         name: langsmith-app-secret
#         creationPolicy: Orphan
#       data:
#         - secretKey: langsmith_license_key
#           remoteRef:
#             key: secret/langsmith/app
#             property: langsmith_license_key
preInstallManifests: []
# -- Annotations that will be applied to all resources created by the chart
commonAnnotations: {}
# -- Annotations that will be applied to all pods created by the chart
commonPodAnnotations: {}
# -- Labels that will be applied to all resources created by the chart
commonLabels: {}
# -- Common environment variables that will be applied to all deployments/statefulsets except for the playground/aceBackend services (which are sandboxed). Be careful not to override values already specified by the chart.
commonEnv: []
# -- Common volumes added to all deployments/statefulsets except for the playground/aceBackend services (which are sandboxed).
commonVolumes: []
# -- Common volume mounts added to all deployments/statefulsets except for the playground/aceBackend services (which are sandboxed).
commonVolumeMounts: []
# -- Common init containers added to all deployments/statefulsets except for the playground/aceBackend services (which are sandboxed).
commonInitContainers: []
# -- Common pod security context applied to all pods. Component-specific podSecurityContext values will be merged on top of this (component values take precedence).
commonPodSecurityContext: {}
# -- Common DNS configuration applied to all pods. Reduces DNS query amplification in Kubernetes by
# -- ensuring service FQDNs (which have 4 dots) are resolved directly without search domain expansion.
# -- Set to null to disable and use Kubernetes defaults (ndots: 5).
commonDnsConfig:
  options:
    - name: ndots
      value: "4"
# -- Kubernetes cluster domain. Only change if not using 'cluster.local'
clusterDomain: "cluster.local"

images:
   # -- If supplied, all children <image_name>.repository values will be prepended with this registry name + `/`
  registry: ""
   # -- Secrets with credentials to pull images from a private registry. Specified as name: value.
  imagePullSecrets: []
  aceBackendImage:
    repository: "docker.io/langchain/langsmith-ace-backend"
    pullPolicy: IfNotPresent
    tag: "0.17.15rc1"
  backendImage:
    repository: "docker.io/langchain/langsmith-backend"
    pullPolicy: IfNotPresent
    tag: "0.17.15rc1"
  # Serves both the `insights` and `engine` graphs; insights.enabled and
  # engine.enabled pick which of them run.
  engineInsightsAgentImage:
    repository: "docker.io/langchain/langsmith-insights-engine"
    pullPolicy: IfNotPresent
    tag: "0.17.15rc1"
  frontendImage:
    repository: "docker.io/langchain/langsmith-frontend"
    pullPolicy: IfNotPresent
    tag: "0.17.15rc1"
  operatorImage:
    repository: "docker.io/langchain/langgraph-operator"
    pullPolicy: IfNotPresent
    tag: "0.1.47"
  # For production environments, we strongly recommend connecting to a managed PostgreSQL instance instead of using the one provided by the chart.
  # Docs: https://docs.langchain.com/langsmith/self-host-external-postgres
  postgresImage:
    repository: "docker.io/postgres"
    pullPolicy: IfNotPresent
    tag: "14.7"
  # For production environments, we strongly recommend connecting to a managed Redis instance instead of using the one provided by the chart.
  # Docs: https://docs.langchain.com/langsmith/self-host-external-redis
  redisImage:
    repository: "docker.io/redis"
    pullPolicy: IfNotPresent
    tag: "7"
  clickhouseImage:
    repository: "docker.io/clickhouse/clickhouse-server"
    pullPolicy: Always
    tag: "25.12"
  agentBuilderImage:
    repository: "docker.io/langchain/agent-builder-deep-agent"
    pullPolicy: IfNotPresent
    tag: "0.17.15rc1"
  pollyAgentImage:
    repository: "docker.io/langchain/langsmith-polly"
    pullPolicy: IfNotPresent
    tag: "0.17.15rc1"
  smithdbImage:
    repository: "docker.io/langchain/smithdb"
    pullPolicy: IfNotPresent
    tag: "0.17.15rc1"
  # Optional: only mirror/pull when presidioAnalyzer.enabled is true
  presidioAnalyzerImage:
    repository: "mcr.microsoft.com/presidio-analyzer"
    pullPolicy: IfNotPresent
    tag: "2.2.354"
  # -- sandbox-host image. Only used when sandboxes.enabled is true.
  sandboxHostImage:
    repository: "docker.io/langchain/sandbox-host"
    pullPolicy: IfNotPresent
    tag: ""

ingress:
  enabled: false
  ingressClassName: ""
  annotations: {}
  labels: {}
  tls: []

# Whether to use the Gateway API for ingress. Will create an HTTPRoute for LangSmith and an HTTPRoute for each LangSmith Deployment.
gateway:
  enabled: false
  name: ""
  namespace: ""
  sectionName: ""
  annotations: {}
  labels: {}

# Whether to use Istio Gateway for ingress. Will create a VirtualService for LangSmith and a VirtualService for each LangSmith Deployment.
istioGateway:
  enabled: false
  name: "istio-gateway"
  namespace: "istio-system"
  annotations: {}
  labels: {}


# -- LangSmith Sandboxes. Same-cluster sandbox-host architecture on AWS/EKS or GCP/GKE. sandbox-host mounts JuiceFS directly, and a singleton Job formats fresh JuiceFS metadata before hosts start serving.
sandboxes:
  enabled: false
  # -- Private JWK signing sandbox callbacks, or key `sandbox_callback_signing_jwk` in config.existingSecretName. Needs config.hostname for the issuer, or signing fails closed.
  callbackSigningJwk: ""
  # -- Base URL for reaching HTTP services inside sandboxes. Needs wildcard DNS and TLS for `*.<host>`; with ingress.enabled the chart adds the wildcard rule. http(s) origin only, no path.
  serviceUrlBaseUrl: ""
  quotas:
    maxCpuCores: 16
    maxMemoryGb: 64
    minEphemeralStorageGb: 1
    maxEphemeralStorageGib: 100
    maxSandboxes: 1000
  proxyCa:
    # -- generatedSecret creates a self-signed CA Secret with Helm and reuses it on live upgrades via lookup. In pure render/GitOps workflows where lookup cannot read the cluster, generatedSecret produces different cert material on each render; use existingSecret for deterministic manifests.
    mode: "generatedSecret"
    secretName: "smithbox-proxy-ca"
    # -- Existing TLS Secret containing tls.crt and tls.key for the sandbox proxy CA. This Secret can be created manually, by cert-manager, or by another external process.
    existingSecretName: ""
  juicefs:
    # -- JuiceFS volume name. Use a flat DNS-label-style name only; slashes and object-store subpaths are not supported here. JuiceFS stores objects under `<name>/` inside the configured bucket.
    name: "sandbox-juicefs"
    # -- Object storage backend used by JuiceFS for sandboxes. Currently supported values are `s3` for AWS/EKS and `gs` for GCP/GKE. Azure-backed sandbox storage is not supported yet.
    storage: "s3"
    # -- Object storage bucket/root URL used by JuiceFS. For AWS S3, use a region-explicit endpoint such as `https://bucket-name.s3.us-west-2.amazonaws.com`; do not use the `s3://bucket-name` shorthand because JuiceFS then infers region with GetBucketLocation. For GCS, use `gs://bucket-name`. Use `sandboxes.juicefs.name` for JuiceFS volume isolation instead of deployment-specific bucket paths.
    bucket: ""
    redis:
      # -- JuiceFS Redis metadata URL. Redis metadata engines must use maxmemory-policy noeviction. For Redis Cluster, the `/DB` path is used by JuiceFS as a hash-tag key prefix rather than a Redis logical database.
      metaURL: ""
    # -- Existing Secret containing JuiceFS config keys `name`, `metaurl`, `storage`, and `bucket`. The formatter Job reads all four keys; sandbox-host receives only `metaurl`. When set, the chart does not create the config Secret and the corresponding values above are ignored. Rotate the Secret name to rerun formatting; roll sandbox-host after changing data in place.
    existingSecretName: ""
    hostMount:
      # -- Node host paths used for the JuiceFS cache. Each path is mounted into sandbox-host and combined into one JuiceFS cache-dir option. Back these paths with node-local storage; their contents survive pod rollouts on the same node but not node replacement.
      cacheDirs:
        - /var/cache/juicefs
      # -- Additional JuiceFS CLI options passed to sandbox-host. The chart derives cache-dir from cacheDirs; do not set it here. The default cache-size is a conservative 50 GiB shared across the configured directories.
      mountOptions:
        - --cache-size=51200
        - --cache-large-write
  juicefsFormatJob:
    # -- Additional labels applied to the JuiceFS formatter pod.
    labels: {}
    # -- Additional annotations applied to the JuiceFS formatter Job and pod.
    annotations: {}
    # -- Pod security context for the JuiceFS formatter pod.
    podSecurityContext: {}
    # -- Container security context for the JuiceFS formatter container.
    securityContext:
      allowPrivilegeEscalation: false
      capabilities:
        drop:
          - ALL
    # -- Resource requests and limits for the JuiceFS formatter container.
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
    # -- Node selector for the JuiceFS formatter pod. Defaults to the sandbox-host node selector when empty.
    nodeSelector: {}
    # -- Tolerations for the JuiceFS formatter pod. Defaults to the sandbox-host tolerations when empty.
    tolerations: []
    # -- Affinity rules for the JuiceFS formatter pod.
    affinity: {}
  sandboxHost:
    # -- Component name for sandbox-host. Resources are named `<release-fullname>-<name>`, which the chart passes to the host as SANDBOX_HOST_DEPLOYMENT_NAME.
    name: "sandbox-host"
    deployment:
      labels: {}
      annotations: {}
      podAnnotations: {}
      # -- Number of sandbox-host replicas, i.e. sandbox nodes backing the pool. One host per node, so do not exceed the node count. Ignored when autoscaling is enabled.
      replicas: 1
      terminationGracePeriodSeconds: 300
      priorityClassName: ""
      # -- Node selector for sandbox-host pods. Required: host pods must land on KVM-capable nodes, and a toleration alone does not attract them there.
      nodeSelector: {}
      # -- Tolerations for sandbox-host pods. The default expects sandbox-host nodes tainted `sandbox.langsmith.com/host=true:NoSchedule`; override this if your sandbox node pool uses different taints.
      tolerations:
        - key: sandbox.langsmith.com/host
          operator: Equal
          value: "true"
          effect: NoSchedule
      # -- Resource requests and limits for sandbox-host. Include the CPU and memory required by its JuiceFS mount process.
      resources:
        requests:
          cpu: "2"
          memory: 2Gi
      # -- Container security context. Must stay privileged, with a writable root: the host needs netns, iptables and mount propagation, and unpacks the guest tools image.
      securityContext:
        privileged: true
      podSecurityContext: {}
      extraEnv: []
      volumes: []
      volumeMounts: []
      initContainers: []
      sidecars: []
      # -- Readiness probe. The host binds its listener last, so accepting connections gates the rollout. No liveness probe: a restart mid-suspend destroys running microVMs.
      readinessProbe:
        tcpSocket:
          port: http
        initialDelaySeconds: 5
        periodSeconds: 10
        timeoutSeconds: 3
        failureThreshold: 3
    # -- Sandbox host pool autoscaling. There is no HPA or KEDA object: the elected sandbox-host resizes the Deployment itself. Unmanaged `sandbox-host.smith.langchain.com/autoscale-*` annotations override these live.
    autoscaling:
      enabled: false
      minReplicas: 1
      maxReplicas: 10
      # -- Target share of pool CPU capacity committed to sandboxes before scaling up.
      targetUtilizationPercent: 70
      # -- Spare empty hosts kept above current demand so a sandbox create rarely waits for a cold node.
      headroomHosts: 1
      # -- Hold the replica target at its recent peak this long before shrinking, so load dips do not thrash the pool.
      scaleDownStabilizationSeconds: 300
    # -- Disruption budget for sandbox-host, capping concurrent evictions since each drain suspends every microVM on that host. maxUnavailable keeps a small pool drainable; setting minAvailable overrides it.
    pdb:
      enabled: false
      maxUnavailable: 1
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      # -- Annotations applied to the sandbox-host ServiceAccount. Attach the AWS IRSA or GCP Workload Identity that grants access to the JuiceFS object-storage bucket here.
      annotations: {}
      automountServiceAccountToken: true
    rbac:
      create: true
      labels: {}
      annotations: {}

fleet:
  enabled: false
  namePrefix: "standalone-fleet"
  enableTracing: true
  encryptionKey: ""
  oauth:
    providerOrgId: ""
    googleOAuthProvider: ""
    slackOAuthProvider: ""
    linkedinOAuthProvider: ""
    linearOAuthProvider: ""
    githubOAuthProvider: ""
    microsoftOAuthProvider: ""
    salesforceOAuthProvider: ""
    slackSigningSecret: ""
    slackBotId: ""
  apiServer:
    name: "api-server"
    containerPort: 8000
    deployment:
      replicaCount: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      extraEnv: []
      envFrom: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      initContainers: []
      startupProbe:
        httpGet:
          path: /ok?check_db=1
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      readinessProbe:
        httpGet:
          path: /ok?check_db=0
          port: 8000
        failureThreshold: 3
        periodSeconds: 10
        timeoutSeconds: 1
      livenessProbe:
        httpGet:
          path: /ok?check_db=0
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
    autoscaling:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 80
      keda:
        enabled: false
        pollingInterval: 30
        cooldownPeriod: 300
        scaleDownStabilizationWindowSeconds: 300
    service:
      type: ClusterIP
      httpPort: 80
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  queue:
    enabled: true
    name: "queue"
    containerPort: 8000
    numberOfJobsPerWorker: 10
    deployment:
      replicaCount: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      extraEnv: []
      envFrom: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      startupProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      readinessProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      livenessProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
    autoscaling:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 80
      keda:
        enabled: false
        pollingInterval: 30
        cooldownPeriod: 300
        scaleDownStabilizationWindowSeconds: 300
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  postgres:
    name: "postgres"
    containerPort: 5432
    external:
      enabled: false
      iamProvider: ""
      host: ""
      port: "5432"
      user: "postgres"
      password: "postgres"
      database: "postgres"
      schema: "public"
      connectionUrl: ""
      existingSecretName: ""
    statefulSet:
      # -- Optional StatefulSet update strategy for the in-chart Fleet PostgreSQL instance.
      # Leave unset to keep the Kubernetes default RollingUpdate behavior.
      updateStrategy: {}
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      command: []
      extraContainerConfig: {}
      extraEnv: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      persistentVolumeClaimRetentionPolicy: {}
      persistence:
        enabled: true
        size: 8Gi
        storageClassName: ""
    service:
      type: ClusterIP
      port: 5432
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  redis:
    name: "redis"
    containerPort: 6379
    external:
      enabled: false
      iamProvider: ""
      connectionUrl: ""
      existingSecretName: ""
    statefulSet:
      # -- Optional StatefulSet update strategy for the in-chart Fleet Redis instance.
      # Leave unset to keep the Kubernetes default RollingUpdate behavior.
      updateStrategy: {}
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      command: []
      extraContainerConfig: {}
      extraEnv: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      persistentVolumeClaimRetentionPolicy: {}
      persistence:
        enabled: true
        size: 8Gi
        storageClassName: ""
    service:
      type: ClusterIP
      port: 6379
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
engine:
  # -- Enable the LangSmith Engine. See the Engine section of this README for what it requires.
  enabled: false
  # -- LangSmith Intelligence gateway for Engine model calls, authenticated with the
  # license key. Required when engine.enabled. Use https://beacon.aws.langchain.com/intelligence.
  intelligenceBaseUrl: ""
  # -- Fernet key for the payloads smith-go passes to the Engine. Required when
  # engine.enabled, and must match smith-go's ISSUES_AGENT_ENCRYPTION_KEY.
  encryptionKey: ""
  # Prior key, accepted for decryption only, so encryptionKey can be rotated.
  encryptionKeyPrevious: ""
  # -- Workspace that owns Engine sandboxes. Optional: smith-go resolves the install's
  # workspace unless there is more than one non-personal org. Prefer one reserved for
  # the Engine — its sandboxes are visible to anyone with access to it.
  sandboxTenantId: ""

insights:
  enabled: true
  encryptionKey: ""
  encryptionKeyPrevious: ""

# Shared Engine/Insights deployment. Rendered when either is enabled.
engineInsightsAgent:
  namePrefix: "standalone-insights"
  apiServer:
    name: "api-server"
    containerPort: 8000
    deployment:
      replicaCount: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      extraEnv: []
      envFrom: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      initContainers: []
      startupProbe:
        exec: null
        httpGet:
          path: /ok?check_db=1
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      readinessProbe:
        exec: null
        httpGet:
          path: /ok?check_db=0
          port: 8000
        failureThreshold: 3
        periodSeconds: 10
        timeoutSeconds: 1
      livenessProbe:
        exec: null
        httpGet:
          path: /ok?check_db=0
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
    autoscaling:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 80
      keda:
        enabled: false
        pollingInterval: 30
        cooldownPeriod: 300
        scaleDownStabilizationWindowSeconds: 300
    service:
      type: ClusterIP
      httpPort: 80
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  queue:
    enabled: true
    name: "queue"
    containerPort: 8000
    numberOfJobsPerWorker: 10
    deployment:
      replicaCount: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      extraEnv: []
      envFrom: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      startupProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      readinessProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      livenessProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
    autoscaling:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 80
      keda:
        enabled: false
        pollingInterval: 30
        cooldownPeriod: 300
        scaleDownStabilizationWindowSeconds: 300
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  postgres:
    name: "postgres"
    containerPort: 5432
    external:
      enabled: false
      iamProvider: ""
      host: ""
      port: "5432"
      user: "postgres"
      password: "postgres"
      database: "postgres"
      schema: "public"
      connectionUrl: ""
      existingSecretName: ""
    statefulSet:
      # -- Optional StatefulSet update strategy for the in-chart Insights PostgreSQL instance.
      # Leave unset to keep the Kubernetes default RollingUpdate behavior.
      updateStrategy: {}
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      command: []
      extraContainerConfig: {}
      extraEnv: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      persistentVolumeClaimRetentionPolicy: {}
      persistence:
        enabled: true
        size: 8Gi
        storageClassName: ""
    service:
      type: ClusterIP
      port: 5432
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  redis:
    name: "redis"
    containerPort: 6379
    external:
      enabled: false
      iamProvider: ""
      connectionUrl: ""
      existingSecretName: ""
    statefulSet:
      # -- Optional StatefulSet update strategy for the in-chart Insights Redis instance.
      # Leave unset to keep the Kubernetes default RollingUpdate behavior.
      updateStrategy: {}
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      command: []
      extraContainerConfig: {}
      extraEnv: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      persistentVolumeClaimRetentionPolicy: {}
      persistence:
        enabled: true
        size: 8Gi
        storageClassName: ""
    service:
      type: ClusterIP
      port: 6379
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1

polly:
  enabled: true
  namePrefix: "standalone-polly"
  enableTracing: true
  encryptionKey: ""
  apiServer:
    name: "api-server"
    containerPort: 8000
    deployment:
      replicaCount: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      extraEnv: []
      envFrom: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      initContainers: []
      startupProbe:
        httpGet:
          path: /ok?check_db=1
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      readinessProbe:
        httpGet:
          path: /ok?check_db=0
          port: 8000
        failureThreshold: 3
        periodSeconds: 10
        timeoutSeconds: 1
      livenessProbe:
        httpGet:
          path: /ok?check_db=0
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
    autoscaling:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 80
      keda:
        enabled: false
        pollingInterval: 30
        cooldownPeriod: 300
        scaleDownStabilizationWindowSeconds: 300
    service:
      type: ClusterIP
      httpPort: 80
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  queue:
    enabled: true
    name: "queue"
    containerPort: 8000
    numberOfJobsPerWorker: 10
    deployment:
      replicaCount: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      extraEnv: []
      envFrom: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      startupProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      readinessProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
      livenessProbe:
        httpGet:
          path: "/ok"
          port: 8000
        failureThreshold: 6
        periodSeconds: 10
        timeoutSeconds: 1
    autoscaling:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 80
      keda:
        enabled: false
        pollingInterval: 30
        cooldownPeriod: 300
        scaleDownStabilizationWindowSeconds: 300
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  postgres:
    name: "postgres"
    containerPort: 5432
    external:
      enabled: false
      iamProvider: ""
      host: ""
      port: "5432"
      user: "postgres"
      password: "postgres"
      database: "postgres"
      schema: "public"
      connectionUrl: ""
      existingSecretName: ""
    statefulSet:
      # -- Optional StatefulSet update strategy for the in-chart Polly PostgreSQL instance.
      # Leave unset to keep the Kubernetes default RollingUpdate behavior.
      updateStrategy: {}
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      command: []
      extraContainerConfig: {}
      extraEnv: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      persistentVolumeClaimRetentionPolicy: {}
      persistence:
        enabled: true
        size: 8Gi
        storageClassName: ""
    service:
      type: ClusterIP
      port: 5432
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1
  redis:
    name: "redis"
    containerPort: 6379
    external:
      enabled: false
      iamProvider: ""
      connectionUrl: ""
      existingSecretName: ""
    statefulSet:
      # -- Optional StatefulSet update strategy for the in-chart Polly Redis instance.
      # Leave unset to keep the Kubernetes default RollingUpdate behavior.
      updateStrategy: {}
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      lifecycle: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 30
      resources: {}
      command: []
      extraContainerConfig: {}
      extraEnv: []
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      volumes: []
      volumeMounts: []
      persistentVolumeClaimRetentionPolicy: {}
      persistence:
        enabled: true
        size: 8Gi
        storageClassName: ""
    service:
      type: ClusterIP
      port: 6379
      labels: {}
      annotations: {}
    serviceAccount:
      create: true
      name: ""
      labels: {}
      annotations: {}
      automountServiceAccountToken: true
    pdb:
      enabled: false
      minAvailable: 1

config:
  # -- Skip validation checks in validate.yaml. Used by AWS Marketplace for helm template verification.
  skipValidation: false
  existingSecretName: ""
  disableSecretCreation: false
  langsmithLicenseKey: ""
  # -- Configuration for LangSmith Deployments features
  deployment:
      # -- Optional. Used to enable the LangSmith Deployments feature. Requires additional setup. Refer to the documentation for more information.
    enabled: false
    # -- Base path for LangSmith Deployments routes managed by the operator.
    basePath: ""
    tlsEnabled: true
    # Disable this if there is restricted access to the external facing ingress endpoint for your agent(s) from inside of your kubernetes cluster.
    ingressHealthCheckEnabled: true
    # -- Lift the SaaS CPU/memory caps on LangSmith Deployment resource specs. Opt-in for self-hosted.
    uncappedResourcesEnabled: false


  # DEPRECATED: use the top-level fleet block (fleet/fleetToolServer/
  # fleetTriggerServer) instead. These keys are retained only as fallback
  # defaults for the fleet block and may be removed in a future chart version.
  # Agent Builder configuration - UI for creating and managing agents
  # Requires config.deployment.enabled to be true
  agentBuilder:
    enabled: false
    # Fernet encryption key for Agent Builder secrets. Required when enabled.
    # Generate with: python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
    encryptionKey: ""
    # Organization ID that owns OAuth providers for Agent Builder.
    # Required for OAuth tools/triggers to work.
    oauthProviderOrgId: ""
    # OAuth provider IDs - set to enable corresponding tools and triggers.
    # Leave empty to disable. Each provider enables specific integrations:
    # - googleOAuthProvider: Gmail, Google Calendar, Google Sheets, BigQuery tools + Gmail trigger
    # - slackOAuthProvider: Slack tools + Slack trigger
    # - linkedinOAuthProvider: LinkedIn tools
    # - linearOAuthProvider: Linear tools
    # - githubOAuthProvider: GitHub tools
    # - microsoftOAuthProvider: Outlook, Teams, SharePoint tools + Outlook trigger
    # - salesforceOAuthProvider: Salesforce tools
    oauth:
      googleOAuthProvider: ""
      linkedinOAuthProvider: ""
      linearOAuthProvider: ""
      githubOAuthProvider: ""
      microsoftOAuthProvider: ""
      salesforceOAuthProvider: ""
      slackOAuthProvider: ""
      slackSigningSecret: ""
      slackBotId: ""
    agent:
      resources:
        cpu: 2
        cpuLimit: 4
        memoryMb: 4096
        memoryLimitMb: 8192
        minScale: 1
        maxScale: 5
      extraEnv: {}

  # -- Salt used to generate the API key. Should be a random string.
  apiKeySalt: ""
  logLevel: "info"
  # -- Must be 'oauth' for OAuth with PKCE, 'mixed' for basic auth or OAuth without PKCE
  authType: ""
  initialOrgAdminEmail: ""
  # -- Initial org name to be provisioned.
  initialOrgName: "Default"
  # -- Default workspace name to be provisioned when org is created.
  defaultWorkspaceName: "Workspace 1"

  basicAuth:
    enabled: false
    # Either set the password and JWT secret in plaintext, or set in the secret specified by existingSecretName above.
    initialOrgAdminPassword: ""
    jwtSecret: ""
  # -- Email addresses of super admins who can export usage data.
  # These are the only users allowed to use the usage backfill export
  # unless orgAdminsInstallationUsageExportEnabled is set.
  superAdmins: []
  # -- When true, any org admin can use the usage backfill export.
  orgAdminsInstallationUsageExportEnabled: false

  # -- Prevent organization creation by users. This includes admins.
  userOrgCreationDisabled: true
  # -- Disable personal orgs.
  personalOrgsDisabled: true
  # -- Enable Workspace Admins to invite users to the org and workspace.
  workspaceScopeOrgInvitesEnabled: false
  # -- Require authentication on the GET /info endpoint. When enabled, unauthenticated
  # requests to /info will receive a 401 and must supply a valid API key. The LangSmith
  # SDK handles this automatically by retrying with credentials. Useful for deployments
  # that must not expose instance configuration (version, feature flags, batch ingest
  # config) to unauthenticated callers.
  infoEndpointAuthRequired: false

  # -- hostname of the LangSmith installation. Used for redirects and LangSmith deployments. Required for OAuth and LangSmith Deployments. E.g langsmith.com
  hostname: ""
  # -- Frontend origin for user-facing redirects (LANGSMITH_URL); defaults to hostname. Set only when the UI is served from a different origin than this deployment's API.
  frontendHostname: ""
  # -- Base path for the LangSmith installation. Used to serve the app under a subpath like example.com/langsmith.
  # WARNING: Changing basePath after LangSmith Deployments have been created will break existing deployments.
  # Existing deployments will need to be recreated for the new basePath to take effect.
  basePath: ""

  telemetry:
    # -- Optional. These values are used to send telemetry to the LangChain team to assist with troubleshooting.
    logs: true
    metrics: true
    traces: true

  oauth:
    enabled: false
    oauthClientId: ""
    # -- Client secret requires authType to be 'mixed' and hostname to be present
    oauthClientSecret: ""
    oauthIssuerUrl: ""
    oauthScopes: "email,profile,openid"  # Comma-separated list of scopes. We require at least 'email', 'profile', and 'openid'. Some OIDC providers require the 'offline_access' scope for refresh tokens.
    oauthSessionMaxSec: "86400"  # 24 hours. Maximum age of a session in seconds. Your session will attempt to refresh until the max age at which point you will be logged out.
    # -- When true, percent-encode spaces in the OIDC authorization request as %20 instead of '+'. Enable for IdPs (e.g. SiteMinder) that reject '+'-encoded scope lists. Requires authType 'mixed' with an OAuth client secret.
    urlEncodeScopeSpaces: false

  # -- Ed25519/OKP JWKS (JSON) signing the OAuth AS / remote MCP (and LLM-auth-proxy)
  # tokens; public keys are served at /.well-known/jwks.json. Set it here (stored in the
  # chart secret) or as key `langsmith_signing_jwks` in config.existingSecretName. The
  # remote MCP server / OAuth AS stay inert until this is set.
  signingJwks: ""
  # -- Optional issuer (iss claim) for tokens minted by the LLM auth proxy. Maps to
  # LLM_AUTH_PROXY_ISSUER. Must match the jwtIssuer configured in the auth proxy chart.
  # Left empty by default (not emitted); set it when using the LLM auth proxy.
  llmAuthProxyIssuer: ""
  # -- TTL configuration
  # Optional. Used to set TTLS for longlived and shortlived objects.
  ttl:
    enabled: true
    ttl_period_seconds:
      # -- 400 day longlived and 14 day shortlived
      longlived: "34560000"
      shortlived: "1209600"

  # Blob storage configuration
  # Optional. Used to store inputs, outputs, and errors in Blob Storage.
  # We currently support S3, GCS, Minio, and Azure as Blob Storage providers.
  blobStorage:
    enabled: false
    engine: "S3"
    # If you are using langsmith-managed-clickhouse, you may not want inputs to be stored in clickhouse for search.
    # Set this as false to ensure that inputs/outputs/errors are not stored in clickhouse.
    # 'clickhouse.external.hybrid: true' overrides this to false.
    chSearchEnabled: true
    # Set this to change the threshold for payloads to be stored in blob storage
    # 'clickhouse.external.hybrid: true' overrides this to 0
    minBlobStorageSizeKb: "20"
    # The following blob storage configuration values are for S3 and GCS and require blobStorage.engine = "S3" or "GCS"
    # If you are using workload identity, you may not need to store the credentials in the secrets.
    # Instead, you will need to add the workload identity annotation to the backend and queue service accounts.
    # For GCS with workload identity, leave accessKey and accessKeySecret empty to use Application Default Credentials.
    # For GCS with HMAC keys, set accessKey and accessKeySecret to your GCS HMAC credentials.
    accessKey: ""
    accessKeySecret: ""
    bucketName: ""
    # For GCS, set this to "https://storage.googleapis.com"
    apiURL: "https://s3.us-west-2.amazonaws.com"
    # Set this to true to use path style addressing for S3. This is required for some S3 compatible storage providers like MinIO.
    # If set to true, endpoint will be s3.<region>.amazonaws.com/bucket-name. If false, endpoint will be bucket-name.s3.<region>.amazonaws.com
    s3UsePathStyle: false
    # S3 Users: use this to enable passing KMS key header, as well as an ARN of the KMS key to use.
    kmsEncryptionEnabled: false
    kmsKeyArn: ""
    # The following blob storage configuration values are for Azure and require blobStorage.engine = "Azure"
    # -- Optional. Set this along with azureStorageAccountKey to use a storage account and access key. Higher precedence than azureStorageConnectionString.
    azureStorageAccountName: ""
    azureStorageAccountKey: ""
    # -- Required if using Azure blob storage
    azureStorageContainerName: ""
    # -- Optional. Use this to specify the full connection string including any authentication params.
    azureStorageConnectionString: ""
    # -- Optional. Use this to customize the service URL, which by default is 'https://<storage_account_name>.blob.core.windows.net/'
    azureStorageServiceUrlOverride: ""

  # -- Application Settings. These are used to tune the application
  settings:
    # -- Optional. Be very careful when lowering this value as it can result in runs being lost if your queue is down/not processing items fast enough.
    redisRunsExpirySeconds: "21600"  # 6 hours

  # -- Custom logo configuration.
  # If enabled, the logoUrl and coBrandingEnabled values must be provided.
  # The logoUrl must be a valid URL to an image like png, jpg, or svg. Co-branding will show LangSmith and customer logos side by side.
  customLogo:
    enabled: false
    logoUrl: ""
    coBrandingEnabled: true

  # -- Custom error support message displayed on error pages (plain text).
  # If empty, defaults to the built-in support messages linking to our Support Portal (https://support.langchain.com).
  customErrorSupportMessage: ""

  # -- Enables Google IAP (Identity-Aware Proxy) session handling in the frontend.
  # When true, the frontend adds required IAP headers, uses credentialed fetches,
  # and handles 401 re-auth via GCP's session refresh mechanism.
  googleIapEnabled: false

  observability:
    tracing:
      enabled: false
      # Replace this with the endpoint of your trace collector. If you are using the LangSmith Observability helm chart, this will be the endpoint of the OTEL Gateway collector.
      endpoint: ""
      # -- Use TLS for OTLP export.
      useTls: true
      env: "ls_self_hosted"
      exporter: "http"

  customCa:
    # -- Optional. Used to set a file containing trusted CA certificates. Make sure to also include a public CA to access beacon and playground.
    secretName: ""
    secretKey: ""

  # -- Security configuration for CORS, headers, and other security-related settings. These settings control cross-origin access and help protect against common web vulnerabilities.
  security:
    # -- CORS (Cross-Origin Resource Sharing) configuration.
    # Controls which origins can make requests to the LangSmith API.
    # By default, CORS is permissive. For production deployments, you should restrict this.
    cors:
      # -- Comma-separated list of allowed origins. Use "*" to allow all origins (not recommended for production).
      # Example: "https://app.example.com,https://admin.example.com"
      # If allowedOriginsRegex is set, this value is ignored.
      allowedOrigins: "*"
      # -- Regular expression pattern for allowed origins. Takes precedence over allowedOrigins if set.
      # Example: "https://.*\\.example\\.com" to allow all subdomains of example.com.
      # Leave empty to use allowedOrigins instead.
      allowedOriginsRegex: ""
      # -- Regular expression pattern for paths that should always allow CORS from any origin.
      # Useful for public endpoints like webhooks or public API endpoints.
      # Example: ".*(/feedback/tokens/|/public/).*"
      alwaysAllowPathsRegex: ""

aceBackend:
  name: "ace-backend"
  containerPort: 1987
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2
        memory: 4000Mi
      requests:
        cpu: 1
        memory: 2000Mi
    command:
      - "./entrypoint.sh"
    startupProbe:
      httpGet:
        path: /ok
        port: 1987
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /ok
        port: 1987
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /ok
        port: 1987
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 1
      maxReplicaCount: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 1987
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

smithdb:
  # -- Deploy the in-chart SmithDB workloads.
  # -- V16 supports SmithDB in beta. We do not support or recommend customers setting this up on their own.
  # -- Please express interest (https://www.langchain.com/smithdb-early-access-waitlist) and we will reach out promptly to ensure we can set you up for success with SmithDB.
  enabled: false
  # -- LangSmith configuration for SmithDB.
  langsmith:
    ingestion:
      # -- Enables LangSmith run ingestion via SmithDB. When ClickHouse is enabled, ingestion writes to both backends. Requires smithdb.enabled.
      enabled: false
    migration:
      # -- Runs the SmithDB migration phase and renders the one-shot migrate-all Job plus taskdb Postgres resources.
      # -- Detailed migration and taskdb configuration lives under smithdb.migration.
      enabled: false
    query:
      # -- Enables SmithDB-powered queries. Requires smithdb.enabled.
      enabled: false
  # -- Name segment used for SmithDB resources.
  name: "smithdb"
  # -- Shared ServiceAccount for SmithDB workloads.
  serviceAccount:
    create: true
    # -- Defaults to <release>-<smithdb.name>.
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true
  # -- Extra env vars for every SmithDB workload.
  commonEnv: []
  # -- Common init containers added to every SmithDB component Deployment and Job.
  # Set restartPolicy: Always to configure a Kubernetes sidecar container.
  commonInitContainers: []

  config:
    # -- Existing secret containing SmithDB metastore credentials.
    existingSecretName: ""
    metastore:
      hostSecretKey: ""
      databaseSecretKey: ""
      usernameSecretKey: ""
      passwordSecretKey: ""
      iamAuthProvider: ""
      iamUsername: ""
      port: "5432"
      useSsl: false
    objectStore:
      # -- Supported values: s3, gcs.
      type: "s3"
      bucket: ""
      s3:
        # -- Defaults to the SmithDB S3 client default when empty.
        region: ""
        endpoint: ""
        # -- Keys in smithdb.config.existingSecretName for static S3 credentials.
        # Set both to "" when using ambient cloud identity, such as IRSA.
        accessKeyIdSecretKey: ""
        secretAccessKeySecretKey: ""

  query:
    name: "query"
    containerPort: 8060
    containerGrpcPort: 8080
    deployment:
      replicas: 1
      strategy:
        type: RollingUpdate
        rollingUpdate:
          maxSurge: 1
          maxUnavailable: 0
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      priorityClassName: ""
      resources:
        requests:
          cpu: "4"
          memory: "8Gi"
          ephemeral-storage: "200Gi"
        limits:
          cpu: "4"
          memory: "8Gi"
          ephemeral-storage: "200Gi"
      probes:
        startupProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        livenessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        readinessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
      command:
        - "./smithdb"
        - "query"
      extraEnv: []
      extraContainerConfig: {}
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      topologySpreadConstraints: []
      volumes:
        - name: local-ssd-storage
          emptyDir:
            sizeLimit: 200Gi
      volumeMounts:
        - name: local-ssd-storage
          mountPath: /data
      initContainers: []
    service:
      port: 8080
      labels: {}
      annotations: {}
    pdb:
      enabled: false
      minAvailable: 1
      labels: {}
      annotations: {}
    autoscaling:
      enabled: true
      minReplicas: 1
      maxReplicas: 10
      targetCPUUtilizationPercentage: 40
      scaleUpStabilizationWindowSeconds: 300
      scaleDownStabilizationWindowSeconds: 900
      scalePodCount: 1

  ingestion:
    name: "ingestion"
    containerPort: 8050
    containerGrpcPort: 8082
    deployment:
      replicas: 1
      strategy:
        type: RollingUpdate
        rollingUpdate:
          maxSurge: 1
          maxUnavailable: 0
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      priorityClassName: ""
      resources:
        requests:
          cpu: "4"
          memory: "8Gi"
          ephemeral-storage: "100Gi"
        limits:
          cpu: "4"
          memory: "8Gi"
          ephemeral-storage: "100Gi"
      probes:
        startupProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        livenessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        readinessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
      command:
        - "./smithdb"
        - "ingestion"
      terminationGracePeriodSeconds: 300
      extraEnv:
        - name: SMITHDB_INGESTION__PROCESSOR__FLUSH__DATA_DIR
          value: "/data"
        - name: SMITHDB_INGESTION__RUN_SEGMENT_MANAGER__FLUSH__DATA_DIR
          value: "/data"
      extraContainerConfig: {}
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      topologySpreadConstraints: []
      volumes:
        - name: local-ssd-storage
          emptyDir:
            sizeLimit: 100Gi
      volumeMounts:
        - name: local-ssd-storage
          mountPath: /data
      initContainers: []
    service:
      port: 8082
      labels: {}
      annotations: {}
    pdb:
      enabled: false
      minAvailable: 1
      labels: {}
      annotations: {}
    autoscaling:
      enabled: true
      minReplicas: 1
      maxReplicas: 10
      targetCPUUtilizationPercentage: 45
      scaleUpStabilizationWindowSeconds: 300
      scaleDownStabilizationWindowSeconds: 900
      scalePodCount: 1

  compaction:
    name: "compaction"
    containerPort: 8070
    containerGrpcPort: 8071
    deployment:
      replicas: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      priorityClassName: ""
      resources:
        requests:
          cpu: "2"
          memory: "4Gi"
        limits:
          cpu: "2"
          memory: "4Gi"
      probes:
        startupProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        livenessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        readinessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
      command:
        - "./smithdb"
        - "compaction"
        - "scheduler"
      extraEnv: []
      extraContainerConfig: {}
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      topologySpreadConstraints: []
      volumes: []
      volumeMounts: []
      initContainers: []
    service:
      port: 8071
      labels: {}
      annotations: {}
    pdb:
      enabled: false
      minAvailable: 1
      labels: {}
      annotations: {}

  compactionWorker:
    name: "compaction-worker"
    containerPort: 9000
    # -- Maximum concurrent jobs per compaction worker. Empty uses the SmithDB default.
    maxConcurrentJobs: ""
    deployment:
      replicas: 2
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      priorityClassName: ""
      terminationGracePeriodSeconds: 120
      resources:
        requests:
          cpu: "8"
          memory: "16Gi"
          ephemeral-storage: "100Gi"
        limits:
          cpu: "8"
          memory: "16Gi"
          ephemeral-storage: "100Gi"
      probes:
        startupProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        livenessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        readinessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
      command:
        - "./smithdb"
        - "compaction"
        - "worker"
      extraEnv: []
      extraContainerConfig: {}
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      topologySpreadConstraints: []
      volumes:
        - name: local-ssd-storage
          emptyDir:
            sizeLimit: 100Gi
      volumeMounts:
        - name: local-ssd-storage
          mountPath: /data
      initContainers: []
    pdb:
      enabled: false
      minAvailable: 1
      labels: {}
      annotations: {}
    autoscaling:
      enabled: true
      minReplicas: 1
      maxReplicas: 10
      targetCPUUtilizationPercentage: 60
      scaleUpStabilizationWindowSeconds: 120
      scaleDownStabilizationWindowSeconds: 300
      scalePodCount: 1

  clusterManager:
    name: "cluster-manager"
    containerPort: 8090
    containerGrpcPort: 8091
    deployment:
      replicas: 1
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      priorityClassName: ""
      resources:
        requests:
          cpu: "250m"
          memory: "256Mi"
        limits:
          cpu: "250m"
          memory: "256Mi"
      probes:
        startupProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        livenessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
        readinessProbe:
          httpGet:
            path: /health
            port: http
          failureThreshold: 6
          periodSeconds: 10
          timeoutSeconds: 1
      command:
        - "./smithdb"
        - "clustermanager"
      extraEnv: []
      extraContainerConfig: {}
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      topologySpreadConstraints: []
      volumes: []
      volumeMounts: []
      initContainers: []
    service:
      port: 8091
      labels: {}
      annotations: {}
    pdb: {}

  migration:
    name: "migration"
    containerPort: 9040
    # -- Optional RFC3339 start bound for migrate-all (half-open window). Empty uses end - 400 days.
    startTime: ""
    # -- Optional RFC3339 end bound for migrate-all (half-open window). Empty uses now.
    endTime: ""
    job:
      # -- Keep finished migrate-all Jobs around for seven days so operators can inspect status/logs.
      ttlSecondsAfterFinished: 604800
      # -- Maximum number of migration pods that run concurrently.
      # -- Above ~20, prefer scaling TaskDB vertically (CPU/memory) rather than adding more
      # -- migration pods.
      parallelism: 1
      # -- Retry failed migrate-all pods up to this many times before marking the Job failed.
      backoffLimit: 3
      # -- Optional hard deadline for the Job. Leave unset for long-running full migrations.
      activeDeadlineSeconds: null
      restartPolicy: Never
    taskdb:
      postgres:
        # -- Enable Postgres for SmithDB migration task state. This is a separate database from
        # -- both the main LangSmith Postgres and the SmithDB metastore.
        enabled: true
        # -- Maximum TaskDB connections opened by each migration pod. Sized for concurrent short
        # -- Postgres ops, not worker count. The chart-managed Postgres server allows this many
        # -- connections for every parallel pod plus one pod of headroom.
        maxConnectionsPerMigrationPod: 10
        name: "taskdb-postgres"
        containerPort: 5433
        # -- Credentials for the in-chart taskdb Postgres instance. Used only when external.enabled is false.
        auth:
          database: "smithdb_migration"
          username: "postgres"
          # -- Password for the chart-managed taskdb Postgres instance. Required unless existingSecretName is set.
          password: ""
          # -- Existing secret containing taskdb Postgres credentials. If set, the chart does not create one.
          existingSecretName: ""
          passwordSecretKey: "postgres_password"
        # -- External Postgres configuration for SmithDB migration task state. Use this when taskdb
        # -- should run outside the chart. Do not point this at the main LangSmith Postgres or
        # -- the SmithDB metastore.
        external:
          enabled: false
          host: ""
          port: "5433"
          database: "smithdb_migration"
          username: "postgres"
          password: ""
          useSsl: false
          # -- Existing secret containing external taskdb Postgres connection fields. If set, the chart does not create one.
          existingSecretName: ""
          hostSecretKey: "postgres_host"
          databaseSecretKey: "postgres_db"
          usernameSecretKey: "postgres_user"
          passwordSecretKey: "postgres_password"
        service:
          port: 5433
          labels: {}
          annotations: {}
        statefulSet:
          # -- Optional priority class for the in-chart SmithDB taskdb Postgres pod.
          priorityClassName: ""
          # -- Optional StatefulSet update strategy for the in-chart SmithDB taskdb Postgres instance.
          updateStrategy: {}
          labels: {}
          annotations: {}
          podSecurityContext: {}
          securityContext: {}
          terminationGracePeriodSeconds: 30
          resources:
            requests:
              cpu: "2"
              memory: "4Gi"
            limits:
              cpu: "4"
              memory: "8Gi"
          startupProbe:
            exec:
              command:
                - /bin/sh
                - -c
                - exec pg_isready -d "$POSTGRES_DB" -U "$POSTGRES_USER"
            failureThreshold: 6
            periodSeconds: 10
            timeoutSeconds: 1
          readinessProbe:
            exec:
              command:
                - /bin/sh
                - -c
                - exec pg_isready -d "$POSTGRES_DB" -U "$POSTGRES_USER"
            failureThreshold: 6
            periodSeconds: 10
            timeoutSeconds: 1
          livenessProbe:
            exec:
              command:
                - /bin/sh
                - -c
                - exec pg_isready -d "$POSTGRES_DB" -U "$POSTGRES_USER"
            failureThreshold: 6
            periodSeconds: 10
            timeoutSeconds: 1
          command: []
          extraEnv: []
          extraContainerConfig: {}
          sidecars: []
          nodeSelector: {}
          tolerations: []
          affinity: {}
          topologySpreadConstraints: []
          volumes: []
          volumeMounts: []
          initContainers: []
          # -- Delete the migration-scoped taskdb PVC when its StatefulSet is removed.
          persistentVolumeClaimRetentionPolicy:
            whenDeleted: Delete
            whenScaled: Retain
          persistence:
            enabled: true
            size: 50Gi
            storageClassName: ""
    deployment:
      labels: {}
      annotations: {}
      podSecurityContext: {}
      securityContext: {}
      terminationGracePeriodSeconds: 120
      resources:
        requests:
          cpu: "8"
          memory: "32Gi"
          ephemeral-storage: "100Gi"
        limits:
          cpu: "8"
          memory: "32Gi"
          ephemeral-storage: "100Gi"
      # -- Runs taskdb schema migrations, then one-shot self-hosted migrate-all: discover tenants,
      # -- register non-overlapping jobs, drain the global queue, and exit. Override for another migration mode.
      command:
        - "/usr/local/bin/smithdb-with-taskdb-migrations-entrypoint.sh"
      extraEnv: []
      extraContainerConfig: {}
      sidecars: []
      nodeSelector: {}
      tolerations: []
      affinity: {}
      topologySpreadConstraints: []
      volumes: []
      volumeMounts: []
      initContainers: []

  metastoreMigration:
    name: "metastore-migration"
    command:
      - "./smithdb"
      - "metastore-migrate"
    job:
      ttlSecondsAfterFinished: 3600
      backoffLimit: 0
      activeDeadlineSeconds: 600
      restartPolicy: Never
      labels: {}
      annotations: {}
      podAnnotations: {}
      podSecurityContext: {}
      securityContext: {}
      resources: {}
      extraEnv: []
      nodeSelector: {}
      tolerations: []
      affinity: {}

backend:
  name: "backend"
  containerPort: 1984
  existingConfigMapName: ""
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 2
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    command:
      - "./entrypoint.sh"
    startupProbe:
      httpGet:
        path: /health
        port: 1984
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 10
    livenessProbe:
      httpGet:
        path: /health
        port: 1984
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 10
    readinessProbe:
      httpGet:
        path: /health
        port: 1984
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 10
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  migrations:
    enabled: true
    # Helpful when running using helm template to avoid the job name conflict
    randomizeName: false
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    resources:
      limits:
        cpu: 1000m
        memory: 1Gi
      requests:
        cpu: 200m
        memory: 500Mi
    command:
      - "./pg_migration_entrypoint.sh"
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    # You can set this to null to disable the TTL for the migrations job. Useful for some deployment setups.
    ttlSecondsAfterFinished: 600
  # Pre-upgrade check that blocks an upgrade if any asynq backfill jobs are
  # still running.  Runs as a Helm pre-upgrade hook (ArgoCD PreSync) so that
  # it executes BEFORE Alembic migrations on every upgrade attempt.
  # Set enabled: false only if you need to bypass the check entirely.
  backfillCheck:
    enabled: true
    # Helpful when running using helm template to avoid the job name conflict
    randomizeName: false
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    resources:
      limits:
        cpu: 500m
        memory: 512Mi
      requests:
        cpu: 100m
        memory: 256Mi
    command:
      - "./backfill_check_entrypoint.sh"
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    # You can set this to null to disable the TTL for the backfill check job.
    ttlSecondsAfterFinished: 600
  authBootstrap:
    # Helpful when running using helm template to avoid the job name conflict
    randomizeName: false
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    resources:
      limits:
        cpu: 1000m
        memory: 1Gi
      requests:
        cpu: 200m
        memory: 500Mi
    command:
      - "./auth_bootstrap_entrypoint.sh"
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    # You can set this to null to disable the TTL for the migrations job. Useful for some deployment setups.
    ttlSecondsAfterFinished: 600
  clickhouseMigrations:
    enabled: true
    # Helpful when running using helm template to avoid the job name conflict
    randomizeName: false
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    resources:
      limits:
        cpu: 1000m
        memory: 1Gi
      requests:
        cpu: 200m
        memory: 500Mi
    command:
      - "./ch_migration_entrypoint.sh"
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    # You can set this to null to disable the TTL for the migrations job. Useful for some deployment setups.
    ttlSecondsAfterFinished: 600
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 2
      maxReplicas: 6
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      additionalMetrics: []
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 2
      maxReplicaCount: 6
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 1984
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true
  e2eTest:
    name: "e2e-test"
    enabled: true
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    resources:
      limits:
        cpu: 500m
        memory: 1Gi
      requests:
        cpu: 200m
        memory: 500Mi
    command:
      - "python"
      - "scripts/test_e2e_trace.pyc"
    extraEnv: []
    extraContainerConfig: {}
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    ttlSecondsAfterFinished: 10

clickhouse:
  # -- Enable ClickHouse for ingestion and queries. Keep enabled when using external ClickHouse.
  #
  # WARNING: Disabling ClickHouse or switching to an external instance DELETES the chart-managed
  # workload on upgrade. Back up its data first; PVCs may be deleted or left orphaned.
  enabled: true
  name: "clickhouse"
  disableSecretCreation: false
  config:
    allowSimdjson: true
    logLevel: "warning"
  external:
    # If enabled, use the following values to connect to an external database. This will also disable the
    # creation of a clickhouse stateful-set and service.
    enabled: false
    # -- Must be set to true if using managed ClickHouse
    hybrid: false
    host: ""
    hostSecretKey: "clickhouse_host"
    port: "8123"
    portSecretKey: "clickhouse_port"
    nativePort: "9000"
    nativePortSecretKey: "clickhouse_native_port"
    user: "default"
    userSecretKey: "clickhouse_user"
    password: "password"
    passwordSecretKey: "clickhouse_password"
    database: "default"
    databaseSecretKey: "clickhouse_db"
    tls: false
    tlsSecretKey: "clickhouse_tls"
    cluster: ""
    existingSecretName: ""
    # mTLS client certificate configuration for ClickHouse connections. Provide a secret name to enable mTLS authentication.
    # For server certificate validation with a custom CA, use config.customCa.secretName and config.customCa.secretKey instead.
    clientCert:
      secretName: ""
      certSecretKey: "tls.crt"
      keySecretKey: "tls.key"
  containerHttpPort: 8123
  containerNativePort: 9000
  statefulSet:
    labels: {}
    annotations: {}
    # -- Optional priority class for the in-chart ClickHouse pod.
    priorityClassName: ""
    # -- Optional StatefulSet update strategy for the in-chart ClickHouse instance.
    # -- Leave unset to keep the Kubernetes default RollingUpdate behavior.
    updateStrategy: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    terminationGracePeriodSeconds: 30
    resources:
# For a production environment, we recommend increasing the CPU and memory limits to something like 16 cores and 64Gi.
#      limits:
#        cpu: 16000m
#        memory: 64Gi
#      requests:
#        cpu: 8000m
#        memory: 32Gi
      limits:
        cpu: 8000m
        memory: 32Gi
      requests:
        cpu: 3500m
        memory: 12Gi
    command:
      - "/bin/bash"
      - "-c"
      - "sed 's/id -g/id -gn/' /entrypoint.sh > /tmp/entrypoint.sh; exec bash /tmp/entrypoint.sh"
    startupProbe:
      httpGet:
        path: /ping
        port: 8123
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /ping
        port: 8123
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /ping
        port: 8123
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    persistentVolumeClaimRetentionPolicy: {}
    # We recommend using a persistent volume and increasing the storage size to something like 50Gi when using in a production environment!
    persistence:
      enabled: true
      size: 50Gi
      storageClassName: ""
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    httpPort: 8123
    nativePort: 9000
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true
  metrics:
    port: 9363

frontend:
  enabled: true
  name: "frontend"
  containerPort: 8080
  existingConfigMapName: ""
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  # Nginx Max Body Size. Refer to https://nginx.org/en/docs/http/ngx_http_core_module.html#client_max_body_size for more information.
  maxBodySize: "25M"
  # Custom CSP Header. Refer to https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP.
  # If includeNonce is true, use nginx built-in $request_id as nonce (cryptographically secure because compiled with OpenSSL)
  # Sample compatible CSP header with includeNonce: true: "script-src 'nonce-$request_id' 'strict-dynamic'; style-src 'nonce-$request_id' 'strict-dynamic'; frame-ancestors 'self'; object-src 'none'"
  cspHeader: "frame-ancestors 'self'; object-src 'none'"
  includeNonce: false
  proxyReadTimeout: "300"
  proxyWriteTimeout: "300"
  proxyConnectTimeout: "60"
  # Keep-Alive timeout in seconds. Depending on load balancer used for ingress, this may need to be increased to reduce intermittent connection issues.
  # For example for GCP Classic ALB, this should be set to between 600 and 610 (exclusive). https://cloud.google.com/load-balancing/docs/https#timeouts_and_retries
  keepAliveTimeout: "75"
  ipv6Enabled: true
  ssl:
    # If enabled, the frontend will listen on HTTPS and require a certificate and key to be mounted.
    enabled: false
    # This is the port the frontend will listen on for HTTPS traffic.
    port: 8443
    # This is the path the certificate must be mounted to in the container.
    certificatePath: ""
    # This is the path the key must be mounted to in the container.
    keyPath: ""
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 1000m
        memory: 2Gi
      requests:
        cpu: 500m
        memory: 1Gi
    command:
      - "/entrypoint.sh"
    startupProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 10
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 10
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 10
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      additionalMetrics: []
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 1
      maxReplicaCount: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: LoadBalancer
    httpPort: 80
    httpsPort: 443
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

hostBackend:
  enabled: false
  name: "host-backend"
  containerPort: 1985
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 1000m
        memory: 2Gi
      requests:
        cpu: 200m
        memory: 1000Mi
    command:
      - "host_backend_entrypoint.sh"
    startupProbe:
      httpGet:
        path: /ok
        port: 1985
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /ok
        port: 1985
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /ok
        port: 1985
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 1
      maxReplicaCount: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 1985
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true
  rbac:
    create: true
    labels: {}
    annotations: {}

listener:
  name: "listener"
  containerPort: 8080
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    command:
      - "host_backend_entrypoint.sh"
      - "./listener_entrypoint.sh"
    startupProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 10
    readinessProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 10
    livenessProbe:
      exec:
        command:
          - "saq"
          - "app.workers.queues.host_worker.settings"
          - "--check"
      failureThreshold: 6
      periodSeconds: 60
      timeoutSeconds: 60
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 1
      maxReplicas: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 1
      maxReplicaCount: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      queueTargetSize: "5"
      fallback:
        failureThreshold: 3
        replicas: 2
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true
  rbac:
    create: true
    labels: {}
    annotations: {}

platformBackend:
  name: "platform-backend"
  containerPort: 1986
  existingConfigMapName: ""
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 3
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    command:
      - "smith_go_entrypoint.sh"
    startupProbe:
      httpGet:
        path: /ok
        port: 1986
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /ok
        port: 1986
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /ok
        port: 1986
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 3
      maxReplicas: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      additionalMetrics: []
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 3
      maxReplicaCount: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 1986
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

operator:
  name: "operator"
  enabled: true
  createCRDs: true
  watchNamespaces: ""
  kedaEnabled: true
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true
  rbac:
    create: true
    labels: {}
    annotations: {}
  # These templates are used by the operator as the base spec for creating resources.
  templates:
    deployment: |
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: ${name}
        namespace: ${namespace}
      spec:
        replicas: ${replicas}
        revisionHistoryLimit: 10
        selector:
          matchLabels:
            app: ${name}
        template:
          metadata:
            labels:
              app: ${name}
          spec:
            enableServiceLinks: false
            containers:
            - name: api-server
              image: ${image}
              ports:
              - name: api-server
                containerPort: 8000
                protocol: TCP
              livenessProbe:
                httpGet:
                  path: /ok
                  port: 8000
                periodSeconds: 15
                timeoutSeconds: 5
                failureThreshold: 6
              readinessProbe:
                httpGet:
                  path: /ok
                  port: 8000
                periodSeconds: 15
                timeoutSeconds: 5
                failureThreshold: 6
    service: |
      apiVersion: v1
      kind: Service
      metadata:
        name: ${name}
        namespace: ${namespace}
      spec:
        type: ClusterIP
        selector:
          app: ${name}
        ports:
        - name: api-server
          protocol: TCP
          port: 8000
          targetPort: 8000
    redis: |
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: ${service_name}
        namespace: ${namespace}
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: ${service_name}
        template:
          metadata:
            labels:
              app: ${service_name}
          spec:
            enableServiceLinks: false
            containers:
            - name: redis
              image: docker.io/redis:7
              ports:
              - containerPort: 6379
                name: redis
              livenessProbe:
                exec:
                  command:
                  - redis-cli
                  - ping
                initialDelaySeconds: 30
                periodSeconds: 10
              readinessProbe:
                tcpSocket:
                  port: 6379
                initialDelaySeconds: 10
                periodSeconds: 5
    db: |
      apiVersion: apps/v1
      kind: StatefulSet
      metadata:
        name: ${service_name}
      spec:
        serviceName: ${service_name}
        selector:
          matchLabels:
            app: ${service_name}
        persistentVolumeClaimRetentionPolicy:
          whenDeleted: Delete
          whenScaled: Retain
        template:
          metadata:
            labels:
              app: ${service_name}
          spec:
            containers:
            - name: postgres
              image: pgvector/pgvector:pg15
              ports:
              - containerPort: 5432
              command: ["docker-entrypoint.sh"]
              args:
                - postgres
                - -c
                - max_connections=${max_connections}
              env:
              - name: PGDATA
                value: /var/lib/postgresql/data/pgdata
              volumeMounts:
              - name: postgres-data
                mountPath: /var/lib/postgresql/data
            enableServiceLinks: false
        volumeClaimTemplates:
        - metadata:
            name: postgres-data
          spec:
            accessModes: ["ReadWriteOnce"]
            resources:
              requests:
                storage: "${storage_gi}Gi"

playground:
  name: "playground"
  containerPort: 1988
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 1000m
        memory: 8Gi
      requests:
        cpu: 500m
        memory: 1Gi
    command:
      - "smith_playground_entrypoint.sh"
    startupProbe:
      httpGet:
        path: /ok
        port: 1988
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /ok
        port: 1988
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /ok
        port: 1988
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 1
      maxReplicas: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      additionalMetrics: []
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 1
      maxReplicaCount: 5
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 1988
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

postgres:
  name: "postgres"
  disableSecretCreation: false
  external:
    # If enabled, use the following values to connect to an external database. This will also disable the
    # creation of a postgres stateful-set and service.
    enabled: false
    host: ""
    port: "5432"
    user: "postgres"
    password: "postgres"
    database: "postgres"
    schema: "public"
    # If connection string is specified, we will ignore all above values and use the connection string instead.
    # Do not include the driver name(something like "postgres://" in the connection string.
    connectionUrl: ""
    connectionUrlSecretKey: "connection_url"
    existingSecretName: ""
    # IAM authentication provider. If set, the application will use workload identity to authenticate.
    # Valid values: "gcp", "aws", "azure". Leave empty to disable IAM authentication.
    iamAuthProvider: ""
    # Use this to enable TLS using a custom CA (non-public) certificate.
    customTls: false
    # mTLS client certificate configuration for Postgres connections. Provide a secret name to enable mTLS authentication.
    # For server certificate validation with a custom CA, use config.customCa.secretName and config.customCa.secretKey instead.
    clientCert:
      secretName: ""
      certSecretKey: "tls.crt"
      keySecretKey: "tls.key"
  containerPort: 5432
  statefulSet:
    # -- Optional priority class for the in-chart PostgreSQL pod.
    priorityClassName: ""
    # -- Optional StatefulSet update strategy for the in-chart PostgreSQL instance.
    # Leave unset to keep the Kubernetes default RollingUpdate behavior.
    updateStrategy: {}
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    terminationGracePeriodSeconds: 30
    resources:
      # In a production environment, we strongly recommend an external Postgres database.
      limits:
        cpu: 4000m
        memory: 16Gi
      requests:
        cpu: 2000m
        memory: 8Gi
    command: []
    startupProbe:
      exec:
        command:
          - /bin/sh
          - -c
          - exec pg_isready -d postgres -U postgres
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      exec:
        command:
          - /bin/sh
          - -c
          - exec pg_isready -d postgres -U postgres
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      exec:
        command:
          - /bin/sh
          - -c
          - exec pg_isready -d postgres -U postgres
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    persistentVolumeClaimRetentionPolicy: {}
    persistence:
      enabled: true
      size: 8Gi
      storageClassName: ""
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 5432
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

queue:
  name: "queue"
  containerPort: 8080
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    command:
      - "./queue_entrypoint.sh"
    startupProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 10
    readinessProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 10
    livenessProbe:
      exec:
        command:
          - "saq"
          - "app.workers.queues.single_queue_worker.settings"
          - "--check"
      failureThreshold: 6
      periodSeconds: 60
      timeoutSeconds: 60
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 1
      maxReplicas: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 1
      maxReplicaCount: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      queueTargetSize: "10"
      fallback:
        failureThreshold: 3
        replicas: 3
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

ingestQueue:
  enabled: true
  name: "ingest-queue"
  containerPort: 1989
  # -- ArgoCD Rollouts configuration. If enabled, will create a Rollout resource instead of a Deployment. See https://argo-rollouts.readthedocs.io/
  rollout:
    enabled: false
    # -- Rollout strategy configuration. See https://argo-rollouts.readthedocs.io/en/stable/features/specification/
    strategy:
      canary:
        steps:
          - setWeight: 100
  deployment:
    replicas: 3
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    command:
      - "asynq_worker_entrypoint.sh"
    startupProbe:
      httpGet:
        path: /health
        port: 1989
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /health
        port: 1989
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /health
        port: 1989
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  # Autoscaling configuration. Either HPA or KEDA can be enabled, not both.
  autoscaling:
    # HPA-specific configuration
    hpa:
      enabled: false
      minReplicas: 3
      maxReplicas: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
    # KEDA ScaledObject configuration. See https://keda.sh/docs/2.18/reference/scaledobject-spec
    # These are some recommended default values. You can tweak them to your needs, using the docs above.
    keda:
      enabled: false
      labels: {}
      annotations: {}
      pollingInterval: 30
      cooldownPeriod: 300
      initialCooldownPeriod: 0
      minReplicaCount: 3
      maxReplicaCount: 10
      targetCPUUtilizationPercentage: 50
      targetMemoryUtilizationPercentage: 80
      queueTargetSize: "10"
      fallback:
        failureThreshold: 3
        replicas: 3
      scaleDownStabilizationWindowSeconds: 1800
      scaleDownPolicy:
        value: 100
        periodSeconds: 300
      scaleUpPolicy:
        value: 100
        periodSeconds: 15
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

redis:
  name: "redis"
  disableSecretCreation: false
  external:
    # If enabled, use the following values to connect to an external redis instance. This will also disable the
    # creation of a redis stateful-set and service.
    enabled: false
    connectionUrl: ""
    connectionUrlSecretKey: "connection_url"
    existingSecretName: ""
    # IAM authentication provider. If set, the application will use workload identity to authenticate.
    # Valid values: "gcp", "aws", "azure". Leave empty to disable IAM authentication.
    iamAuthProvider: ""
    # mTLS client certificate configuration for Redis connections. Provide a secret name to enable mTLS authentication.
    # For server certificate validation with a custom CA, use config.customCa.secretName and config.customCa.secretKey instead.
    clientCert:
      secretName: ""
      certSecretKey: "tls.crt"
      keySecretKey: "tls.key"
    # This flag disables cluster-unsafe operations. Needed for Azure EnterpriseCluster, which connects with the standalone client, but requires cluster-safe operations
    clusterSafeMode: false
    # Redis cluster configuration.
    cluster:
      enabled: false
      # Node URIs and password can also be set in the secret above (existingSecretName).
      # Node URIs should be in the format: '["redis://host:port", "redis://host:port", "redis://host:port"]'
      nodeUris: []
      nodeUrisSecretKey: "redis_cluster_node_uris"
      password: ""
      passwordSecretKey: "redis_cluster_password"
      tlsEnabled: true
  containerPort: 6379
  statefulSet:
    # -- Optional priority class for the in-chart Redis pod.
    priorityClassName: ""
    # -- Optional StatefulSet update strategy for the in-chart Redis instance.
    # Leave unset to keep the Kubernetes default RollingUpdate behavior.
    updateStrategy: {}
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    terminationGracePeriodSeconds: 30
    # In a production environment, we strongly recommend an external Redis database.
    resources:
      limits:
        cpu: 4000m
        memory: 8Gi
      requests:
        cpu: 2000m
        memory: 4Gi
    command: []
    startupProbe:
      exec:
        command:
          - /bin/sh
          - -c
          - exec redis-cli ping
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      exec:
        command:
          - /bin/sh
          - -c
          - exec redis-cli ping
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      exec:
        command:
          - /bin/sh
          - -c
          - exec redis-cli ping
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    persistentVolumeClaimRetentionPolicy: {}
    persistence:
      enabled: true
      size: 8Gi
      storageClassName: ""
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 6379
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

# Fleet Tool Server - provides MCP tool execution capabilities
fleetToolServer:
  enabled: true
  name: "fleet-tool-server"
  containerPort: 1989
  deployment:
    command:
      - "agent_builder_tool_server_entrypoint.sh"
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    startupProbe:
      httpGet:
        path: /health
        port: 1989
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    livenessProbe:
      httpGet:
        path: /health
        port: 1989
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    readinessProbe:
      httpGet:
        path: /health
        port: 1989
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  autoscaling:
    enabled: false
    createHpa: true
    minReplicas: 1
    maxReplicas: 3
    targetCPUUtilizationPercentage: 70
    targetMemoryUtilizationPercentage: 70
  pdb:
    enabled: false
    minAvailable: 1
    labels: {}
    annotations: {}
  service:
    type: ClusterIP
    port: 1989
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

# Fleet Trigger Server - handles cron, Slack, and Gmail triggers
# NOTE: Currently only supports a single replica to prevent duplicate trigger executions
fleetTriggerServer:
  enabled: true
  name: "fleet-trigger-server"
  containerPort: 1990
  deployment:
    command:
      - "agent_builder_trigger_server_entrypoint.sh"
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 2000m
        memory: 4Gi
      requests:
        cpu: 1000m
        memory: 2Gi
    startupProbe:
      httpGet:
        path: /health
        port: 1990
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    livenessProbe:
      httpGet:
        path: /health
        port: 1990
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    readinessProbe:
      httpGet:
        path: /health
        port: 1990
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 1
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    topologySpreadConstraints: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  service:
    type: ClusterIP
    port: 1990
    labels: {}
    annotations: {}
    loadBalancerSourceRanges: []
    loadBalancerIP: ""
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

# Agent Gateway - proxy for agent traffic with guardrails (NER redaction via Presidio)
# Optional, disabled by default. Not required for core LangSmith functionality. Private beta.
agentGateway:
  enabled: false
  name: "agent-gateway"
  containerPort: 8083
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 500m
        memory: 512Mi
      requests:
        cpu: 100m
        memory: 256Mi
    command:
      - "agent_gateway_entrypoint.sh"
    startupProbe:
      httpGet:
        path: /health
        port: 8083
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    livenessProbe:
      httpGet:
        path: /health
        port: 8083
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    readinessProbe:
      httpGet:
        path: /health
        port: 8083
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  autoscaling:
    enabled: false
    createHpa: true
    minReplicas: 1
    maxReplicas: 5
    targetCPUUtilizationPercentage: 50
  service:
    type: ClusterIP
    port: 8083
    labels: {}
    annotations: {}
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true

# Presidio Analyzer - Microsoft Presidio NER service for PII detection, used by the Agent Gateway
# Optional, disabled by default. Not required for core LangSmith functionality. Private beta.
presidioAnalyzer:
  enabled: false
  name: "presidio-analyzer"
  containerPort: 3000
  deployment:
    replicas: 1
    labels: {}
    annotations: {}
    podSecurityContext: {}
    securityContext: {}
    lifecycle: {}
    priorityClassName: ""
    resources:
      limits:
        cpu: 1
        memory: 4Gi
      requests:
        cpu: 250m
        memory: 2Gi
    startupProbe:
      httpGet:
        path: /health
        port: 3000
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    livenessProbe:
      httpGet:
        path: /health
        port: 3000
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    readinessProbe:
      httpGet:
        path: /health
        port: 3000
      failureThreshold: 6
      periodSeconds: 10
      timeoutSeconds: 3
    extraContainerConfig: {}
    extraEnv: []
    sidecars: []
    initContainers: []
    nodeSelector: {}
    tolerations: []
    affinity: {}
    volumes: []
    volumeMounts: []
    terminationGracePeriodSeconds: 30
  autoscaling:
    enabled: false
    minReplicas: 1
    maxReplicas: 10
    targetCPUUtilizationPercentage: 80
  service:
    type: ClusterIP
    port: 3000
    labels: {}
    annotations: {}
  serviceAccount:
    create: true
    name: ""
    labels: {}
    annotations: {}
    automountServiceAccountToken: true