function

Functions in BAML define the contract between your application and AI models, providing type-safe interfaces for AI operations.

Overview

A BAML function consists of:

• Input parameters with explicit types
• A return type specification
• An LLM client
• A prompt (as a block string)

function FunctionName(param: Type) -> ReturnType {
    client ModelName
    prompt #"
        Template content
    "#
}

Function Declaration

Syntax

function name(parameters) -> return_type {
    client llm_specification
    prompt block_string_specification
}

Parameters

• name: The function identifier (must start with a capital letter!)
• parameters: One or more typed parameters (e.g., text: string, data: CustomType)
• return_type: The type that the function guarantees to return (e.g., string | MyType)
• llm_specification: The LLM to use (e.g., "openai/gpt-5-mini", GPT5, Claude4)
• block_string_specification: The prompt template using Jinja syntax

Type System

Functions leverage BAML’s strong type system, supporting:

Built-in Types

• string: Text data
• int: Integer numbers
• float: Decimal numbers
• bool: True/false values
• array: Denoted with [] suffix (e.g., string[])
• map: Key-value pairs (e.g., map<string, int>)
• literal: Specific values (e.g., "red" | "green" | "blue")
• See all

Custom Types

Custom types can be defined using class declarations:

class CustomType {
    field1 string
    field2 int
    nested NestedType
}
function ProcessCustomType(data: CustomType) -> ResultType {
    // ...
}

Prompt Templates

Jinja Syntax

BAML uses Jinja templating for dynamic prompt generation:

prompt #"
    Input data: {{ input_data }}
    
    {% if condition %}
        Conditional content
    {% endif %}
    
    {{ ctx.output_format }}
"#

Special Variables

• ctx.output_format: Automatically generates format instructions based on return type
• ctx.client: Selected client and model name
• _.role: Define the role of the message chunk

Error Handling

Functions automatically handle common AI model errors and provide type validation:

• JSON parsing errors are automatically corrected
• Type mismatches are detected and reported
• Network and rate limit errors are propagated to the caller

Usage Examples

Basic Function

function ExtractEmail(text: string) -> string {
    client GPT4Turbo
    prompt #"
        Extract the email address from the following text:
        {{ text }}
        
        {{ ctx.output_format }}
    "#
}

Complex Types

class Person {
    name string
    age int
    contacts Contact[]
}
class Contact {
    type "email" | "phone"
    value string
}
function ParsePerson(data: string) -> Person {
    client "openai/gpt-5"
    prompt #"
        {{ ctx.output_format }}
        
        {{ _.role('user') }}
        {{ data }}
    "#
}

baml_client Integration

from baml_client import b
from baml_client.types import Person
async def process() -> Person:
    result = b.ParsePerson("John Doe, 30 years old...")
    print(result.name)  # Type-safe access
    return result