TrueFoundry

https://www.truefoundry.com/docs
Admin
TrueFoundry is an enterprise-grade AI platform that provides a unified gateway to access 1000+ LLMs,...
Tokens:1,765,452
Snippets:15,764
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example deploy.py File Structure

Source: https://www.truefoundry.com/docs/deploy-first-service

A brief look at the imports and logging setup within the generated deploy.py file.

```python
import logging
from truefoundry.deploy import (
    Resources,
    Build,
    LocalSource,
    DockerFileBuild,
    Port,
    Service,
    NodeSelector,
)
# Set up logging to display informational messages
logging.basicConfig(level=logging.INFO)
```

--------------------------------

### Install and Run aitori on a Single Machine

Source: https://www.truefoundry.com/docs/ai-gateway/govern-traffic-through-ai-gateway

Commands to install aitori, start the agent with a live UI, and revert system proxy settings.

```bash
# Install (macOS / Linux)
curl -fsSL https://raw.githubusercontent.com/truefoundry/aitori/main/install.sh | sh

# Govern this machine and open the live view at http://127.0.0.1:9100
sudo aitori up --ui

# When you're done, revert the system proxy and settings
sudo aitori down
```

--------------------------------

### Define Code to Docker Image Build Instructions

Source: https://www.truefoundry.com/docs/deploy-job-using-python-sdk

This example shows the full setup including imports and logging configuration required to define build instructions and deploy a job.

```python
import argparse
import logging
from servicefoundry import Build, Job, PythonBuild, Resources

# Set up logging to display informational messages
logging.basicConfig(level=logging.INFO)

# Create a TrueFoundry **Job** object to configure your service
job = Job(
  # Specify the name of the job
  name="iris-train-job",
  # Define how to build your code into a Docker image
  image=Build(
    # `PythonBuild` helps specify the details of your Python Code.
    # These details will be used to templatize a DockerFile to build your Docker Image
    build_spec=PythonBuild(
      # Define the command to run the training script
      command="python train.py",
      # Specify the path to requirements file
      requirements_path="requirements.txt",
    )
  ),
  # Define the resource constraints.
  #
  # Requests are the minimum amount of resources that a container needs to run.
  # Limits are the maximum amount of resources that a container can use.
  #
  # If a container tries to use more resources than its limits, it will be throttled or killed.
  resources=Resources(
    # CPU is specified as a number. 1 CPU unit is equivalent to 1 physical CPU core, or 1 virtual core.
    cpu_request=0.2,
    cpu_limit=0.5,

    # Memory is defined as an integer and the unit is Megabytes.
    memory_request=200,
    memory_limit=500,

    # Ephemeral storage is defined as an integer and the unit is Megabytes.
    ephemeral_storage_request=1000,
    ephemeral_storage_limit=2000,
  ),
  # Define environment variables that your Job will have access to
  env={
    "ENVIRONMENT": "dev"
  }
)


# Deploy the job to the specified workspace, copy workspace FQN using the following guide
# https://docs.truefoundry.com/docs/creating-a-workspace#workspace-fully-qualified-name-fqn
job.deploy(workspace_fqn="your-workspace-fqn")
```

--------------------------------

### Complete OpenTelemetry Application Example

Source: https://www.truefoundry.com/docs/tracing/distributed-tracing/golang-opentelemetry

A full example demonstrating OpenTelemetry SDK setup, automatic HTTP instrumentation, custom span creation, and attribute management in a Go server.

```go
package main

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"os"
	"time"

	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/sdk/trace"
	oteltrace "go.opentelemetry.io/otel/trace"
)

// setupOTelSDK bootstraps the OpenTelemetry pipeline.
// If it does not return an error, make sure to call shutdown for proper cleanup.
func setupOTelSDK(ctx context.Context) (shutdown func(context.Context) error, err error) {
	// set up env variables
	os.Setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "<enter_your_api_endpoint>")
	os.Setenv("OTEL_EXPORTER_OTLP_HEADERS", fmt.Sprintf("Authorization=Bearer %s,TFY-Tracing-Project=%s", "<Enter your api key here>", "<Enter your tracing project fqn>"))
	os.Setenv("OTEL_SERVICE_NAME", "<enter_your_tracing_application_name>")
	
	// Set up propagator.
	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
		propagation.TraceContext{},
		propagation.Baggage{},
	))

	// set up exporter
	exporter, err := otlptracehttp.New(context.Background())
	if err != nil {
		return nil, err
	}

	tracerProvider := trace.NewTracerProvider(
		trace.WithBatcher(exporter),
	)

	otel.SetTracerProvider(tracerProvider)

	return tracerProvider.Shutdown, nil
}

var tracer = otel.Tracer("truefoundry.com/open-telemetry/demo/golang/")

func main() {
	// Set up OpenTelemetry.
	otelShutdown, err := setupOTelSDK(context.Background())
	if err != nil {
		return
	}

	defer func() {
		err = errors.Join(err, otelShutdown(context.Background()))
	}()

	mockFetchOrder := func(ctx context.Context, id string) string {
		_, span := tracer.Start(ctx, "db.query")
		defer span.End()
		span.SetAttributes(attribute.StringSlice("order.items", []string{"item1", "item2", "item3"})) // this will be added to the span
		span.SetAttributes(attribute.String("order.id", id))                                          // this will be added to the span
		return fmt.Sprintf("order.id: %s, items: %v", id, []string{"item1", "item2", "item3"})
	}

	// This is a workaround to add attributes to the span.
	handler := func(w http.ResponseWriter, r *http.Request) {

		orderId := r.URL.Query().Get("id")
		if orderId == "" {
			orderId = "123"
		}

		// Update existing span attributes
		span := oteltrace.SpanFromContext(r.Context())
		span.SetAttributes(attribute.String("order.id", orderId)) // this will be added to the span

		order := mockFetchOrder(r.Context(), orderId)
		w.Write([]byte(order))
	}

	otelHandler := otelhttp.NewHandler(http.HandlerFunc(handler), "order-service")

	http.ListenAndServe(":8080", otelHandler)
}
```

--------------------------------

### Setup upload script environment

Source: https://www.truefoundry.com/docs/infrastructure/deploy-compute-plane

Clone the infra-charts repository and install the necessary Python dependencies for the upload script.

```shell
git clone https://github.com/truefoundry/infra-charts.git
python3 -m venv venv && source venv/bin/activate
pip install -r infra-charts/scripts/upload-artifacts/requirements.txt
```

--------------------------------

### Install CrewAI

Source: https://www.truefoundry.com/docs/ai-gateway/crewai

Install the CrewAI package via pip to get started.

```bash
pip install crewai
```

--------------------------------

### MCP Gateway SDK Quickstart

Source: https://www.truefoundry.com/docs/ai-gateway/mcp-gateway-sdk-usage

Demonstrates how to initialize the client, list available tools, and call a specific tool using the MCP Gateway SDK. Ensure you replace the placeholders for the URL, integration ID, and API token before execution.

```python
token = "<tfy-api-token>" # Replace with your actual TFY API token (PAT or VA Token)
async def main():
    url = "{GATEWAY_BASE_URL}/mcp/<integrationId>/server"
    async with Client(url, auth=token) as client:
        tools = await client.list_tools()
        for tool in tools:
            print(f"Tool: {tool.name}")
            print(f"Description: {tool.description}")
            print(f"Parameters: {tool.inputSchema}")
        print("--------------------------------")
        tool_name = "echo"  # Replace with your actual tool name
        tool_args = {"message": "hello"}  # Replace with your actual tool arguments
        results = await client.call_tool(tool_name, tool_args)
        print(f"Result: {results}")
        print("--------------------------------")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())
```

--------------------------------

### Basic DSPy Setup with TrueFoundry

Source: https://www.truefoundry.com/docs/ai-gateway/dspy

Demonstrates how to configure the TrueFoundry-enabled client and perform a simple completion.

```python
import dspy

# Set up the TrueFoundry-enabled client
lm = dspy.LM(
    model="openai/anthropic-account/claude-4",
    api_key="your-truefoundry-api-key",
    api_base="{GATEWAY_BASE_URL}"
)
dspy.configure(lm=lm)

# Simple completion
response = lm("Say this is a test!", temperature=0.7)
print(response)  # => ['This is a test!']
```

--------------------------------

### Dockerfile for CUDA 11.8 and cuDNN 8 Installation

Source: https://www.truefoundry.com/docs/launch-an-ssh-server

Example of configuring a custom image with specific CUDA and cuDNN versions. This setup requires root privileges to install NVIDIA toolkit components and updates the environment variables accordingly.

```dockerfile
FROM public.ecr.aws/truefoundrycloud/ssh-server:0.4.6-py3.11.14
ENV TORCH_CUDA_ARCH_LIST="7.0 7.5 8.0 8.6 9.0+PTX"
ENV DEBIAN_FRONTEND=noninteractive
USER root
# Install CUDA 11.8
RUN apt update && \
    apt install -y --no-install-recommends git curl wget htop && \
    wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-keyring_1.1-1_all.deb -O /tmp/cuda-keyring_1.1-1_all.deb && \
    dpkg -i /tmp/cuda-keyring_1.1-1_all.deb && \
    apt update && \
    apt install -y --no-install-recommends cuda-toolkit-11-8 libcudnn8=8.9.7.29-1+cuda11.8 libcudnn8-dev=8.9.7.29-1+cuda11.8
USER jovyan
```

--------------------------------

### Install Persistent apt Packages

Source: https://www.truefoundry.com/docs/launch-an-ssh-server

Example build script to install the ffmpeg package persistently on an SSH server.

```bash
sudo apt update
sudo apt install ffmpeg
```

--------------------------------

### Complete Monitoring Configuration Example

Source: https://www.truefoundry.com/docs/platform/controlplane-monitoring

A full example configuration that enables monitoring, installs dedicated Prometheus and VictoriaLogs, and configures Grafana.

```yaml
truefoundryMonitoring:
  enabled: true
  prometheus:
    enabled: true
  logs:
    enabled: true
  grafana:
    grafana.ini:
      auth.jwt:
        jwk_set_url: >-
          https://app.example.com/api/svc/v1/keys/<tenant-name>/jwks
```

--------------------------------

### Import Modules and Setup Logging

Source: https://www.truefoundry.com/docs/deploy-job-using-python-sdk

Initial setup for the deployment script, including importing necessary modules and configuring logging.

```python
import argparse
import logging
from servicefoundry import Build, Job, PythonBuild, Resources

# Set up logging to display informational messages
logging.basicConfig(level=logging.INFO)
```

--------------------------------

### Install and Run Aitori Proxy

Source: https://www.truefoundry.com/docs/ai-gateway/claude-code

Commands to install the aitori agent, start it to govern machine traffic through the AI Gateway, and revert the system proxy settings.

```bash
# Install (macOS / Linux)
curl -fsSL https://raw.githubusercontent.com/truefoundry/aitori/main/install.sh | sh

# Govern this machine and open the live view at http://127.0.0.1:9100
sudo aitori up --ui \
  --gateway-url "https://gateway.truefoundry.ai/api/llm/ai-proxy/" \
  --token-file ~/.aitori/tf_token

# Revert the system proxy when you're done
sudo aitori down
```

--------------------------------

### Clone and Navigate to Example Directory

Source: https://www.truefoundry.com/docs/deploy-first-service

Commands to clone the example repository and enter the specific directory for the FastAPI service deployment.

```bash
git clone https://github.com/truefoundry/getting-started-examples.git
cd getting-started-examples/deploy-model-with-fastapi
```

--------------------------------

### Initialize and Log with TrueFoundry ML Client

Source: https://www.truefoundry.com/docs/truefoundry-ml-reference/index

Demonstrates initializing the client, creating a run within a specific repository, logging metrics and parameters, and closing the run.

```python
from truefoundry.ml import get_client

# Initialize the client
client = get_client()

# Create a run
run = client.create_run(
    ml_repo="my-classification-project",
    run_name="svm-with-rbf-kernel"
)

# Log metrics and parameters
run.log_metrics({"accuracy": 0.95, "loss": 0.1})
run.log_params({"learning_rate": 0.01, "epochs": 100})

# End the run
run.end()
```

--------------------------------

### turn.created Event Payload

Source: https://www.truefoundry.com/docs/agent-platform/agent-harness/sdk/overview

Example payload for the turn.created event indicating the start of a turn.

```json
{ "type": "turn.created", "turn_id": "turn-001", "thread_id": null }
```

--------------------------------

### Install dependencies and deploy the wrapper

Source: https://www.truefoundry.com/docs/ai-gateway/deepkeep

Install the necessary Python packages and execute the deployment script for the wrapper service.

```bash
pip install -r requirements-deploy.txt
python deploy.py --workspace_fqn <cluster>:<workspace>
```

--------------------------------

### Run Calculator MCP Server Locally

Source: https://www.truefoundry.com/docs/ai-gateway/mcp/create-calculator-mcp-server

Commands to install the required dependencies and start the MCP server.

```bash
# Install dependencies
pip install -r requirements.txt

# Run the server
python server.py
```

--------------------------------

### Main Entry Point

Source: https://www.truefoundry.com/docs/agent-platform/agent-harness/sdk/complete-example

Initializes the client by validating required environment variables for the gateway URL and API key.

```python
  def main() -> None:
      args = parse_args()

      base_url = os.environ.get("TFY_GATEWAY_URL")
      api_key = os.environ.get("TFY_API_KEY")
      if not base_url or not api_key:
          print("Set TFY_GATEWAY_URL and TFY_API_KEY environment variables.")
          sys.exit(1)
```

--------------------------------

### Deploy the wrapper service

Source: https://www.truefoundry.com/docs/ai-gateway/nvidia-nemo

Install the TrueFoundry CLI, authenticate, and deploy the service. Verify the deployment using the health check endpoint.

```bash
pip install -U truefoundry
tfy login
python deploy.py --wait
```

```bash
curl -s https://ml.<cluster>.truefoundry.cloud/nemo-guardrails-tfy/health
# {"status":"ok"}
```

--------------------------------

### Install truefoundry-gateway-sdk

Source: https://www.truefoundry.com/docs/agent-platform/agent-harness/sdk/use-agent

Install the required gateway SDK package using pip.

```bash
pip install -U truefoundry-gateway-sdk
```

--------------------------------

### Local Server Execution Commands

Source: https://www.truefoundry.com/docs/ai-gateway/custom-guardrails

Commands to install dependencies and start the server locally using Python or Uvicorn.

```bash
# Install dependencies
pip install -r requirements.txt

# Run the server
python main.py

# Or using uvicorn directly
uvicorn main:app --host 0.0.0.0 --port 8000 --reload
```

--------------------------------

### Install and Login with TrueFoundry CLI

Source: https://www.truefoundry.com/docs/deploying-an-llm-model-from-the-model-catalogue

Install the TrueFoundry Python SDK and authenticate with your platform URL to begin managing models.

```shell
pip install -U truefoundry
tfy login --host <Your TrueFoundry Platform Url>
```

--------------------------------

### GET /api/svc/v1/clusters/{id}/get-addons

Source: https://www.truefoundry.com/docs/api-reference/clusters/list-cluster-addons

Retrieves a list of addons installed on the specified cluster, supporting pagination and attribute filtering.

```APIDOC
## GET /api/svc/v1/clusters/{id}/get-addons

### Description
List addons installed on the cluster.

### Method
GET

### Endpoint
/api/svc/v1/clusters/{id}/get-addons

### Parameters
#### Path Parameters
- **id** (string) - Required - Unique identifier of the cluster.

#### Query Parameters
- **limit** (integer) - Optional - Number of items per page (default: 100, range: 1-1000).
- **offset** (integer) - Optional - Number of items to skip (default: 0).
- **attributes** (array) - Optional - Comma-separated list of attributes to return (e.g. id,name).

### Response
#### Success Response (200)
- **data** (array) - List of addons installed on the cluster.
- **pagination** (object) - Pagination metadata.
```

--------------------------------

### Install OpenTelemetry packages

Source: https://www.truefoundry.com/docs/tracing/distributed-tracing/golang-opentelemetry

Use the go get command to add the OpenTelemetry SDK and necessary instrumentation packages to your Go module.

```bash
go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp
go get go.opentelemetry.io/otel/exporters/stdout/stdouttrace
go get go.opentelemetry.io/otel/sdk
go get go.opentelemetry.io/otel/trace
```

--------------------------------

### Configure environment variables

Source: https://www.truefoundry.com/docs/ai-gateway/coreweave-weave-guardrails

Copy .env.example to .env and populate the required configuration values.

```bash
# Wrapper auth - the AI Gateway sends this as `Authorization: Bearer ...` when calling the wrapper.
WRAPPER_API_KEY=<generate with `python -c "import secrets; print(secrets.token_urlsafe(32))"`>

# Server runtime
PORT=8000
LOG_LEVEL=info

# Weave scorer runtime (cpu by default; "cuda" on a GPU node)
WEAVE_TOXICITY_DEVICE=cpu

# Deploy-time only
TFY_SERVICE_NAME=coreweave-weave-guardrails-tfy
TFY_WORKSPACE_FQN=<cluster>:<workspace>
TFY_PUBLIC_HOST=ml.<cluster>.truefoundry.cloud
TFY_PUBLIC_PATH=/coreweave-weave-guardrails-tfy
# Tenant-scoped, colon-separated form: tfy-secret://<tenant>:<secret-group>:<secret-key>
WRAPPER_API_KEY_SECRET_FQN=tfy-secret://<tenant>:coreweave-weave-guardrails-tfy:wrapper-api-key
```

--------------------------------

### Linux Deployment Script for Claude Code

Source: https://www.truefoundry.com/docs/ai-gateway/mcp/enterprise-security-claude

A bash script to load configuration, install the tfy-local-ai-setup binary, and execute the setup with appropriate flags.

```bash
# ---------------------------------------------------------------------------
    # Load + save config (before binary install)
    # ---------------------------------------------------------------------------
    # Fill in any placeholder values from the saved config file
    if [[ -f "${CONFIG_FILE}" ]]; then
      while IFS='=' read -r _key _value; do
        [[ -z "${_key}" || "${_key}" == \#* ]] && continue
        _key="${_key// /}"; _value="${_value%\"}"; _value="${_value#\"}"
        case "${_key}" in
          GATEWAY_URL)       [[ "${GATEWAY_URL}"       == "<your-gateway-url>" ]]       && GATEWAY_URL="${_value}" ;;
          CONTROL_PLANE_URL) [[ "${CONTROL_PLANE_URL}" == "<your-control-plane-url>" ]] && CONTROL_PLANE_URL="${_value}" ;;
          TENANT_NAME)       [[ "${TENANT_NAME}"       == "<your-tenant-name>" ]]       && TENANT_NAME="${_value}" ;;
        esac
      done < "${CONFIG_FILE}"
    fi

    [[ "${GATEWAY_URL}"       == "<your-gateway-url>" ]]       && { log "ERROR: GATEWAY_URL not set — fill it in above or check ${CONFIG_FILE}."; exit 1; }
    [[ "${CONTROL_PLANE_URL}" == "<your-control-plane-url>" ]] && { log "ERROR: CONTROL_PLANE_URL not set — fill it in above or check ${CONFIG_FILE}."; exit 1; }
    [[ "${TENANT_NAME}"       == "<your-tenant-name>" ]]       && { log "ERROR: TENANT_NAME not set — fill it in above or check ${CONFIG_FILE}."; exit 1; }

    # Persist config for future runs (root-owned, 644 — developers cannot edit)
    mkdir -p "$(dirname "${CONFIG_FILE}")"
    cat > "${CONFIG_FILE}" <<CONF
    GATEWAY_URL="${GATEWAY_URL}"
    CONTROL_PLANE_URL="${CONTROL_PLANE_URL}"
    TENANT_NAME="${TENANT_NAME}"
    CONF
    chown root:root "${CONFIG_FILE}" && chmod 644 "${CONFIG_FILE}"
    log "Config saved to ${CONFIG_FILE}."

    BINARY_PATH="/usr/local/bin/tfy-local-ai-setup"
    RELEASE_TAG="v1.3.3"
    BINARY_URL="https://github.com/truefoundry/tfy-local-ai-setup/releases/download/${RELEASE_TAG}/tfy-local-ai-setup-linux-amd64"
    VERSION_FILE="${BINARY_PATH}.version"

    # ---------------------------------------------------------------------------
    # Install binary (skip if already on the correct release tag)
    # ---------------------------------------------------------------------------
    INSTALLED_TAG="$([[ -f "${VERSION_FILE}" ]] && cat "${VERSION_FILE}" || echo '')"

    if [[ ! -f "${BINARY_PATH}" ]] || [[ "${INSTALLED_TAG}" != "${RELEASE_TAG}" ]]; then
      log "Installing tfy-local-ai-setup ${RELEASE_TAG} (linux-amd64)..."
      curl -fsSL "${BINARY_URL}" -o "${BINARY_PATH}" && chmod +x "${BINARY_PATH}"
      echo "${RELEASE_TAG}" > "${VERSION_FILE}"
      log "tfy-local-ai-setup installed at ${BINARY_PATH}."
    else
      log "tfy-local-ai-setup ${RELEASE_TAG} already installed — skipping download."
    fi

    # ---------------------------------------------------------------------------
    # Run
    # ---------------------------------------------------------------------------
    exec "${BINARY_PATH}" \
      --claude-code \
      --url="${CONTROL_PLANE_URL}" \
      --tenant="${TENANT_NAME}" \
      --gateway="${GATEWAY_URL}" \
      ${CLAUDE_GATEWAY_URL:+--claude-gateway="${CLAUDE_GATEWAY_URL}"} \
      ${CODEX_GATEWAY_URL:+--codex-gateway="${CODEX_GATEWAY_URL}"} \
      ${OPUS_MODEL:+--opus-model="${OPUS_MODEL}"} \
      ${SONNET_MODEL:+--sonnet-model="${SONNET_MODEL}"} \
      ${HAIKU_MODEL:+--haiku-model="${HAIKU_MODEL}"} \
      ${SETTINGS_FILE:+--settings-file="${SETTINGS_FILE}"} \
      ${CODEX_SETTINGS_FILE:+--codex-settings-file="${CODEX_SETTINGS_FILE}"}
```

--------------------------------

### Log Parameters and Metrics

Source: https://www.truefoundry.com/docs/job-runs-and-logging

Basic example of initializing a run and logging parameters and metrics using the TrueFoundry ML client.

```python
from truefoundry.ml import get_client

client = get_client()
run = client.create_run(ml_repo="iris-demo", run_name="svm-model")
run.log_params({"cache_size": 200.0, "kernel": "linear"})
run.log_metrics(metric_dict={"accuracy": 0.7, "loss": 0.6})

run.end()
```

--------------------------------

### Example URL with configuration values

Source: https://www.truefoundry.com/docs/ai-gateway/io-net

A concrete example of the URL structure using 'ionet' as the account name and 'model' as the endpoint name.

```text
{GATEWAY_BASE_URL}/proxy-api/ionet/model/v1/chat/completions
```

--------------------------------

### Run AWS AgentCore MCP Server Locally

Source: https://www.truefoundry.com/docs/ai-gateway/aws-agentcore-mcp

Install the required dependencies and start the server locally. The server will be accessible at http://localhost:3000/mcp.

```bash
# Install dependencies
pip install -r requirements.txt

# Run the server
python main.py
```

--------------------------------

### Clone and Navigate to Repository

Source: https://www.truefoundry.com/docs/deploy-job-from-a-public-github-repository

Commands to clone the example repository and enter the directory containing the job code.

```bash
git clone https://github.com/truefoundry/getting-started-examples.git
cd getting-started-examples/train-model
```

--------------------------------

### Dockerfile for Custom Spark Notebook Image

Source: https://www.truefoundry.com/docs/launch-notebook-with-spark

Example of extending the pre-built base image to install additional pip and apt packages. Do not overwrite the ENTRYPOINT or CMD instructions as they are critical for operation.

```dockerfile
FROM public.ecr.aws/truefoundrycloud/jupyter-spark:0.4.10-py3.11.14-sc2.12-spark3.5.7-delta3.3.2-sudo

# Install additional pip packages
RUN python3 -m pip install --no-cache-dir \
    koalas \
    mlflow \
    scikit-learn

# Install apt packages
USER root
RUN DEBIAN_FRONTEND=noninteractive apt-get update && \
    apt-get install -y --no-install-recommends graphviz && \
    apt-get clean && rm -rf /var/lib/apt/lists/*
USER jovyan
```

--------------------------------

### List applications with TrueFoundry SDK

Source: https://www.truefoundry.com/docs/truefoundry_sdk/applications

Demonstrates how to initialize the TrueFoundry client and use the list method to retrieve applications with various filters. Includes examples for iterating through results and paginating page by page.

```python
from truefoundry import TrueFoundry

client = TrueFoundry(
    api_key="YOUR_API_KEY",
    base_url="https://yourhost.com/path/to/api",
)

client.applications.list(
    limit=10,
    offset=10,
    application_id="application_id_value",
    workspace_id="workspace_id_value",
    application_name="value",
    fqn="value",
    workspace_fqn="value",
    application_type="value",
    name_search_query="value",
    environment_id="value",
    cluster_id="cluster_id_value",
    application_set_id="value",
    paused="value",
    device_type_filter="value",
    last_deployed_by_subjects="value",
    lifecycle_stage="value",
    is_recommendation_present_and_visible="value",
)

# Iterate through results
for item in response:
    print(item.name)

# Or paginate page by page
for page in response.iter_pages():
    for item in page:
        print(item.name)
```
Tokens:
Raw