Generate Structured Recipes with Constrained Output

View Source Code

This example demonstrates constrained generation with LeapSDK on Android. Instead of generating free-form text, the RecipeGenerator app produces structured JSON output that follows a predefined schema, ensuring consistent and parseable results. Constrained generation is essential for building reliable AI-powered applications where the output needs to integrate with downstream systems or databases. This example shows how to enforce structure while maintaining creative and useful AI-generated content.

What’s inside?

The RecipeGenerator demonstrates advanced LeapSDK capabilities:

Structured Output Generation - Enforce JSON schema constraints on model outputs
Automatic Model Downloading - Models download automatically via LeapDownloader on first run
Constrained Decoding - Guide the model to produce valid, parseable data structures
Schema Validation - Ensure generated recipes follow a specific format
Type Safety - Parse AI outputs directly into Kotlin data classes with kotlinx.serialization
@Generatable Annotation - Use LeapSDK’s annotation for simplified structured output generation
Production-ready Pattern - Integrate AI outputs with databases and business logic
Practical Use Case - Generate recipes with ingredients, steps, and metadata

This pattern is applicable to many use cases beyond recipes: generating product catalogs, form data, API responses, database entries, and more.

What is constrained generation?

Constrained generation refers to the ability to enforce specific formatting or structural requirements on model outputs. Instead of generating free-form text, the model produces outputs that conform to a predefined schema or pattern. Benefits:

Reliability - Guaranteed parseable output every time
Type Safety - Direct integration with typed programming languages
Validation - Automatic schema compliance
Downstream Integration - Feed structured data into databases, APIs, or UIs
Error Reduction - Eliminate parsing errors from inconsistent formats

Common use cases:

JSON API responses
Database records
Form submissions
Product catalogs
Configuration files
Structured reports

Learn More About Constrained Generation

Read the complete guide in the official Leap documentation

Environment setup

Before running this example, ensure you have the following:

Android Studio Installation

Download and install Android Studio (latest stable version recommended).Make sure you have:

Android SDK installed
An Android device or emulator configured
USB debugging enabled (for physical devices)

Minimum SDK Requirements

This example requires:

Minimum SDK: API 24 (Android 7.0)
Target SDK: API 34 or higher
Kotlin: 1.9.0 or higher
LeapSDK: 0.9.4 or higher
Internet connectivity: Required for first-time model download

Model Setup - Automatic Download

This example uses LeapSDK 0.9.4+ with automatic model downloading capabilities.Automatic Model ManagementThe app uses LeapDownloader to automatically download and cache the LFM2-700M model on first run:

On first launch, the model downloads automatically from Leap Model Library
Models are cached locally for subsequent app launches
No manual ADB push or file transfer required
Internet connectivity is required only for the initial download

First Run Experience:

Launch the app (internet connection required)
The model downloads automatically (may take 2-5 minutes depending on connection)
Once cached, subsequent launches work offline
The model persists across app restarts

Manual Deployment (Alternative)If you prefer manual deployment or need offline-first installation, you can still use ADB:

# Push the model bundle to device storage
adb push LFM2-700M.bundle /data/local/tmp/liquid/

# Update app code to load from this path instead of using LeapDownloader

Dependencies Setup

Add the required dependencies to your app-level build.gradle.kts:

dependencies {
    // LeapSDK for constrained generation (0.9.4+)
    implementation("ai.liquid.leap:leap-sdk:0.9.7")

    // Kotlin serialization for type-safe parsing
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")

    // Jetpack Compose (if using Compose UI)
    implementation(platform("androidx.compose:compose-bom:2024.01.00"))
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.material3:material3")

    // ViewModel
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0")
}

Also enable the Kotlin serialization plugin in your app-level build.gradle.kts:

plugins {
    id("org.jetbrains.kotlin.plugin.serialization") version "1.9.0"
}

How to run it

Follow these steps to generate structured recipes:

Clone the repository

git clone https://github.com/Liquid4All/LeapSDK-Examples.git
cd LeapSDK-Examples/Android/RecipeGenerator

Open in Android Studio
- Launch Android Studio
- Select “Open an existing project”
- Navigate to the RecipeGenerator folder and open it
Gradle sync
- Wait for Gradle to sync all dependencies
- Ensure LeapSDK 0.9.7 is downloaded
Run the app
- Connect your Android device or start an emulator
- Ensure internet connectivity (required for first-time model download)
- Click “Run” or press Shift + F10
- Select your target device
First launch - model download
- On first run, the app will automatically download the LFM2-700M model
- This may take 2-5 minutes depending on your connection
- A loading indicator will show download progress
- The model is cached for future use
Generate recipes
- Enter ingredients or a dish name (e.g., “pasta carbonara”, “chocolate chip cookies”)
- Tap “Generate Recipe”
- The app will produce a structured recipe with ingredients, steps, and metadata
- All output will be valid JSON conforming to the recipe schema

After First Run: The model is cached locally. Subsequent app launches work offline and start immediately without downloading.

Code walkthrough

The core business logic is implemented in MainActivityViewModel.kt. Here’s how it works:

Define the Recipe Schema

First, define the data structure you want the AI to generate:

@Serializable
data class Recipe(
    val name: String,
    val description: String,
    val servings: Int,
    val prepTime: String,
    val cookTime: String,
    val difficulty: String,
    val ingredients: List<Ingredient>,
    val instructions: List<String>,
    val tags: List<String>
)

@Serializable
data class Ingredient(
    val item: String,
    val amount: String,
    val unit: String
)

Configure Constrained Generation

Set up the LeapSDK to enforce the schema:

class MainActivityViewModel : ViewModel() {
    private lateinit var model: LeapModel

    fun initializeModel() {
        viewModelScope.launch {
            // Download and load the model automatically (LeapSDK 0.9.4+)
            model = LeapDownloader.downloadAndLoadModel(
                modelName = "lfm2-700m",
                onProgress = { progress ->
                    // Update UI with download progress
                    _downloadProgress.value = progress
                }
            )

            // Alternative: Load from local bundle if already cached
            // model = LeapSDK.loadModelFromBundle(
            //     path = "/data/local/tmp/liquid/lfm2-700m.bundle"
            // )

            configureConstraints()
        }
    }

    private fun configureConstraints() {
        // Define the JSON schema for recipes
        val recipeSchema = """
        {
          "type": "object",
          "properties": {
            "name": {"type": "string"},
            "description": {"type": "string"},
            "servings": {"type": "integer"},
            "prepTime": {"type": "string"},
            "cookTime": {"type": "string"},
            "difficulty": {"type": "string", "enum": ["easy", "medium", "hard"]},
            "ingredients": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "item": {"type": "string"},
                  "amount": {"type": "string"},
                  "unit": {"type": "string"}
                },
                "required": ["item", "amount", "unit"]
              }
            },
            "instructions": {
              "type": "array",
              "items": {"type": "string"}
            },
            "tags": {
              "type": "array",
              "items": {"type": "string"}
            }
          },
          "required": ["name", "description", "servings", "ingredients", "instructions"]
        }
        """.trimIndent()

            // Configure constrained generation
            model.setConstraint(
                type = ConstraintType.JSON_SCHEMA,
                schema = recipeSchema
            )
        }
    }
}