Media (Images, Speech, Transcription)

Image Generation

Generate images from text prompts:

Basic image generation with a text prompt

import asyncio
import os
from liter_llm import create_client
from liter_llm._internal_bindings import CreateImageRequest

async def main() -> None:
    client = create_client(api_key=os.environ["API_KEY"])
    req = CreateImageRequest.from_json("{\"model\":\"dall-e-3\",\"n\":1,\"prompt\":\"A white cat sitting on a windowsill\",\"size\":\"1024x1024\"}")
    result = await client.image_generate(req)
    print(result.data)
    print(result.data[0].url)

asyncio.run(main())

Basic image generation with a text prompt

import { createClient } from "@xberg-io/liter-llm";
async function main() {
  const client = createClient("your-api-key");
  const result = await client.imageGenerate({ model: "dall-e-3", n: 1, prompt: "A white cat sitting on a windowsill", size: "1024x1024" });
  console.log(result.data);
  console.log(result.data?.[0]?.url);
}

void main();

Basic image generation with a text prompt

use liter_llm::BatchClient;
use liter_llm::FileClient;
use liter_llm::LlmClient;
use liter_llm::ResponseClient;

#[tokio::main]
async fn main() {
    let req_json: serde_json::Value = serde_json::from_str(r#"{"model":"dall-e-3","n":1,"prompt":"A white cat sitting on a windowsill","size":"1024x1024"}"#).unwrap();
    let req = serde_json::from_value(req_json).unwrap();
    let client = liter_llm::create_client(std::env::var("API_KEY").expect("API_KEY must be set"), None, None, None, None).unwrap();
    let result = client.image_generate(req).await.expect("call failed");
    println!("{:?}", result.data);
    println!("{:?}", result.data[0].url);
}

Basic image generation with a text prompt

package main

import (
  "fmt"
  pkg "github.com/xberg-io/liter-llm/packages/go/v2"
)

func ptr[T any](value T) *T { return &value }
func main() {
  req := pkg.CreateImageRequest{
    Prompt: `A white cat sitting on a windowsill`,
    Model:  ptr(`dall-e-3`),
    N:      ptr(uint32(1)),
    Size:   ptr(`1024x1024`),
  }
    client, clientErr := pkg.CreateClient("your-api-key", nil, nil, nil, nil)
  if clientErr != nil {
    panic(clientErr)
  }
  defer client.Free()
  result, err := client.ImageGenerate(req)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result.Data)
  fmt.Printf("%+v\n", result.Data[0].URL)
}

Basic image generation with a text prompt

import io.xberg.literllm.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var reqJson = "{\"model\":\"dall-e-3\",\"n\":1,\"prompt\":\"A white cat sitting on a windowsill\",\"size\":\"1024x1024\"}";
        var req = JsonUtil.fromJson(reqJson, CreateImageRequest.class);
        var apiKey = System.getenv("API_KEY");
        if (apiKey == null || apiKey.isEmpty()) throw new IllegalStateException("API_KEY must be set");
        try (var client = LiterLlm.createClient(apiKey, null, null, null, null)) {
        var result = client.imageGenerate(req);
        System.out.println(result.data());
        System.out.println(result.data().get(0).url());
        }
    }
}

Basic image generation with a text prompt

using System;
using LiterLlm;

var apiKey = Environment.GetEnvironmentVariable("API_KEY") ??
  throw new InvalidOperationException("API_KEY must be set");
  using var client = LiterLlmConverter.CreateClient(apiKey, null, null, null, null);
var result = await client.ImageGenerateAsync(new CreateImageRequest { Model = "dall-e-3", N = 1, Prompt = "A white cat sitting on a windowsill", Size = "1024x1024" });
Console.WriteLine(result.Data);
Console.WriteLine(result.Data[0].Url);

Basic image generation with a text prompt

require "liter_llm"
result = LiterLlm.image_generate(LiterLlm::CreateImageRequest.new(model: 'dall-e-3', n: 1, prompt: 'A white cat sitting on a windowsill', size: '1024x1024'))
puts result.data.inspect
puts result.data[0].url.inspect

Basic image generation with a text prompt

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Liter\Llm\LiterLlm;
use Liter\Llm\CreateImageRequest;
use Liter\Llm\Image;
$result = LiterLlm::imageGenerate(new \Liter\Llm\CreateImageRequest(prompt: "A white cat sitting on a windowsill",
model: "dall-e-3",
n: 1,
size: "1024x1024"));
var_dump($result->getData());
var_dump($result->getData()[0]->url);

Basic image generation with a text prompt

api_key = System.fetch_env!("API_KEY")
{:ok, client} = LiterLlm.create_client(api_key)
result = LiterLlm.defaultclient_image_generate_async(client, "{\"model\":\"dall-e-3\",\"n\":1,\"prompt\":\"A white cat sitting on a windowsill\",\"size\":\"1024x1024\"}")
IO.inspect(result.data)
IO.inspect(Enum.at(result.data, 0).url)

Basic image generation with a text prompt

import { WasmCreateImageRequest, createClient } from "@xberg-io/liter-llm-wasm";
async function main() {
  const req: WasmCreateImageRequest = (() => { const _u0 = WasmCreateImageRequest.default(); _u0.model = "dall-e-3"; _u0.n = 1; _u0.prompt = "A white cat sitting on a windowsill"; _u0.size = "1024x1024"; return _u0; })();
  const client = createClient("your-api-key");
  try {
    const result = await client.imageGenerate(req);
    console.log(result.data);
    console.log(result.data[0].url);
  } finally {
    client.free();
  }
}

void main();