Every Way To Get Structured Output From LLMs

from baml_client import b
 
resume = """John Doe [...] Experience: Software Engineer Intern [...]"""
 
async def async_call():
  parsed = await b.ExtractResume(resume)
 
async def streamed_call():
  stream = b.stream.ExtractResume(resume)
  async for partial in stream:
    print(partial) # This is an object with auto complete for the partial Resume type
  response = await stream.get_final_result() # auto complete here to the full Resume type
 

class Resume {
  name string
  education Education[]
  skills string[]
}
 
class Education {
  school string
  degree string
  year int
}
 
function ExtractResume(raw_text: string) -> Resume {
  client GPT4
  prompt #"
    Parse the following resume and return a structured representation of the data in the schema below.
 
    Resume:
    ---
    {{raw_text}}
    ---
 
    Output JSON format (only include these fields, and no others):
    {{ ctx.output_format(prefix=null) }}
 
    Output JSON:
  "#
}

import b from './baml_client'
import { Role } from './baml_client/types';
 
// Async call
const result = await b.ClassifyMessage({
    convo: [
        {
            role: Role.Customer,
            content: "I want to cancel my subscription"
        }
    ]
});
 
// Streamed call
const stream = b.stream.ClassifyMessage({
    convo: [
        {
            role: Role.Customer,
            content: "I want to cancel my subscription"
        }
    ]
});
 
for await (const partial of stream) {
    console.log(partial); // Autocompletes to a Category[]
}
const final = await stream.get_final_result(); // Autocompletes to a Category[]

enum Category {
    Refund
    CancelOrder
    TechnicalSupport
    AccountIssue
    Question
}
 
class Message {
  role Role
  content string
}
 
enum Role {
  Customer
  Assistant
}
 
template_string PrintMessage(msg: Message, prefix: string?) #"
  {{ _.role('user' if msg.role == "Customer" else 'assistant') }}
  {% if prefix %}
  {{ prefix }}
  {% endif %}
  {{ msg.content }}
"#
 
function ClassifyMessage(convo: Message[]) -> Category[] {
  client GPT4
  prompt #"
    {# 
      Prompts are auto-dedented and trimmed.
      We use JINJA for our prompt syntax
      (but we added some static analysis to make sure it's valid!)
    #}
 
    {{ ctx.output_format(prefix="Classify with the following json:") }}
 
    {% for c in convo %}
    {{ PrintMessage(c, 
      'This is the message to classify:' if loop.last and convo|length > 1 else null
    ) }}
    {% endfor %}
 
    {{ _.role('assistant') }}
    JSON array of categories that match:
  "#
}

require_relative "baml_client/client"
 
b = Baml::BamlClient.from_directory("baml_src")
 
input = "Can't access my account using my usual login credentials"
classified = b.ClassifyMessage(input: input)
 
puts classified.categories

enum Category {
    Refund
    CancelOrder
    TechnicalSupport
    AccountIssue
    Question
}
 
class MessageFeatures {
    categories Category[]
}
 
function ClassifyMessage(input: string) -> MessageFeatures {
  client GPT4Turbo
 
  prompt #"
    {# _.role("system") starts a system message #}
    {{ _.role("system") }}
 
    Classify the following INPUT.
 
    {{ ctx.output_format }}
 
    {# This starts a user message #}
    {{ _.role("user") }}
 
    INPUT: {{ input }}
 
    Response:
  "#
}

class Labels(str, enum.Enum):
    SPAM = "spam"
    NOT_SPAM = "not_spam"
 
class SinglePrediction(BaseModel):
    """
    Correct class label for the given text
    """
 
    class_label: Labels
 
def classify(data: str) -> SinglePrediction:
    return client.chat.completions.create(
        model="gpt-3.5-turbo-0613",
        response_model=SinglePrediction,
        messages=[
            {
                "role": "user",
                "content": f"Classify the following text: {data}",
            },
        ],
    )  # type: ignore
 
prediction = classify("Hello there I'm a nigerian prince and I want to give you money")
assert prediction.class_label == Labels.SPAM

import { z } from "zod"
 
enum CLASSIFICATION_LABELS {
  "SPAM" = "SPAM",
  "NOT_SPAM" = "NOT_SPAM"
}
 
const SimpleClassificationSchema = z.object({
  class_label: z.nativeEnum(CLASSIFICATION_LABELS)
})
 
const createClassification = async (data: string) => {
  const classification = await client.chat.completions.create({
    messages: [{ role: "user", content: `"Classify the following text: ${data}` }],
    model: "gpt-3.5-turbo",
    response_model: { schema: SimpleClassificationSchema, name: "SimpleClassification" },
    max_retries: 3,
    seed: 1
  })
 
  return classification
}
 
const classification = await createClassification(
  "Hello there I'm a nigerian prince and I want to give you money"
)
// OUTPUT: { class_label: 'SPAM' }
 
console.log({ classification })
 
assert(
  classification?.class_label === CLASSIFICATION_LABELS.SPAM,
  `Expected ${classification?.class_label} to be ${CLASSIFICATION_LABELS.SPAM}`
)

import asyncio
 
import sys
from dotenv import dotenv_values
import schema as sentiment
from typechat import Failure, TypeChatJsonTranslator, TypeChatValidator, create_language_model, process_requests
 
async def main():    
    env_vals = dotenv_values()
    model = create_language_model(env_vals)
    validator = TypeChatValidator(sentiment.Sentiment)
    translator = TypeChatJsonTranslator(model, validator, sentiment.Sentiment)
 
    async def request_handler(message: str):
        result = await translator.translate(message)
        if isinstance(result, Failure):
            print(result.message)
        else:
            result = result.value
            print(f"The sentiment is {result.sentiment}")
 
    file_path = sys.argv[1] if len(sys.argv) == 2 else None
    await process_requests("😀> ", file_path, request_handler)
 
 
if __name__ == "__main__":
    asyncio.run(main())

from dataclasses import dataclass
from typing_extensions import Literal, Annotated, Doc
 
@dataclass
class Sentiment:
    """
    The following is a schema definition for determining the sentiment of a some user input.
    """
 
    sentiment: Annotated[Literal["negative", "neutral", "positive"],
                         Doc("The sentiment for the text")]

import { createJsonTranslator, createLanguageModel } from "typechat";
import { processRequests } from "typechat/interactive";
import { createTypeScriptJsonValidator } from "typechat/ts";
import { SentimentResponse } from "./sentimentSchema";
 
const dotEnvPath = findConfig(".env");
assert(dotEnvPath, ".env file not found!");
dotenv.config({ path: dotEnvPath });
 
const model = createLanguageModel(process.env);
const schema = fs.readFileSync(path.join(__dirname, "sentimentSchema.ts"), "utf8");
const validator = createTypeScriptJsonValidator<SentimentResponse>(schema, "SentimentResponse");
const translator = createJsonTranslator(model, validator);
 
// Process requests interactively or from the input file specified on the command line
processRequests("😀> ", process.argv[2], async (request) => {
    const response = await translator.translate(request);
    if (!response.success) {
        console.log(response.message);
        return;
    }
    console.log(`The sentiment is ${response.data.sentiment}`);
});

export interface SentimentResponse {
    sentiment: "negative" | "neutral" | "positive";  // The sentiment of the text
}

using Microsoft.TypeChat;
 
namespace Sentiment;
 
public class SentimentApp : ConsoleApp
{
    JsonTranslator<SentimentResponse> _translator;
 
    public SentimentApp()
    {
        OpenAIConfig config = Config.LoadOpenAI();
        // Although this sample uses config files, you can also load config from environment variables
        // OpenAIConfig config = OpenAIConfig.LoadFromJsonFile("your path");
        // OpenAIConfig config = OpenAIConfig.FromEnvironment();
        _translator = new JsonTranslator<SentimentResponse>(new LanguageModel(config));
    }
 
    public override async Task ProcessInputAsync(string input, CancellationToken cancelToken)
    {
        SentimentResponse response = await _translator.TranslateAsync(input, cancelToken);
        Console.WriteLine($"The sentiment is {response.Sentiment}");
    }
}

using System.Text.Json.Serialization;
using Microsoft.TypeChat.Schema;
 
namespace Sentiment;
 
public class SentimentResponse
{
    [JsonPropertyName("sentiment")]
    [JsonVocab("negative | neutral | positive")]
    public string Sentiment { get; set; }
}

import marvin
from pydantic import BaseModel
 
class Recipe(BaseModel):
    name: str
    cook_time_minutes: int
    ingredients: list[str]
    steps: list[str]
 
@marvin.fn
def recipe(
    ingredients: list[str], 
    max_cook_time: int = 15, 
    cuisine: str = "North Italy", 
    experience_level:str = "beginner"
) -> Recipe:
    """
    Returns a complete recipe that uses all the `ingredients` and 
    takes less than `max_cook_time`  minutes to prepare. Takes 
    `cuisine` style and the chef's `experience_level` into account 
    as well.
    """