Lucy 2.1 Realtime

// Change to a new character
await realtimeClient.set({
  prompt: "Substitute the character in the video with the person in the reference image.",
  image: newCharacterImage,
  enhance: true,
});

// Set a new image only (clears any previous prompt)
await realtimeClient.set({ image: newCharacterImage });

// Set a new prompt only (clears any previous image)
await realtimeClient.set({ prompt: "Add dark sunglasses to the person's face." });

// Clear the reference image (fall back to text-only editing)
await realtimeClient.set({ image: null });

# Change to a new character
with open("new_character.jpg", "rb") as f:
    await realtime.set(
        prompt="Substitute the character in the video with the person in the reference image.",
        image=f,
        enhance=True,
    )

# Set a new image only (clears any previous prompt)
with open("another.jpg", "rb") as f:
    await realtime.set(image=f)

# Set a new prompt only (clears any previous image)
await realtime.set(prompt="Add dark sunglasses to the person's face.")

// Change to a new character
val newCharacterBase64 = Base64.encodeToString(newCharacterBytes, Base64.NO_WRAP)
client.realtime.setImage(
    imageBase64 = newCharacterBase64,
    prompt = "Substitute the character in the video with the person in the reference image.",
    enhance = true
)

// Set a new image only
client.realtime.setImage(imageBase64 = newCharacterBase64)

// Set a new prompt only (text-only editing)
client.realtime.setPrompt("Add dark sunglasses to the person's face.")

// Clear the reference image (fall back to text-only editing)
client.realtime.setImage(imageBase64 = null)

// No reference image needed for text-only edits
await realtimeClient.set({ prompt: "Add a small dog running around in the background." });
await realtimeClient.set({ prompt: "Change the background to a sandy beach with clear blue water." });
await realtimeClient.set({ prompt: "Change the person's hair color to bright blonde." });

# No reference image needed for text-only edits
await realtime.set(prompt="Add a small dog running around in the background.")
await realtime.set(prompt="Change the background to a sandy beach with clear blue water.")
await realtime.set(prompt="Change the person's hair color to bright blonde.")

// No reference image needed for text-only edits
client.realtime.setPrompt("Add a small dog running around in the background.")
client.realtime.setPrompt("Change the background to a sandy beach with clear blue water.")
client.realtime.setPrompt("Change the person's hair color to bright blonde.")

import { createDecartClient, models, type DecartSDKError } from "@decartai/sdk";

async function setupLucy2() {
  const model = models.realtime("lucy-2.1");

  const stream = await navigator.mediaDevices.getUserMedia({
    video: {
      frameRate: model.fps,
      width: model.width,
      height: model.height,
    },
  });

  // Show the local camera feed
  document.getElementById("input-video").srcObject = stream;

  const client = createDecartClient({
    apiKey: process.env.DECART_API_KEY,
  });

  const realtimeClient = await client.realtime.connect(stream, {
    model,
    onRemoteStream: (transformedStream) => {
      document.getElementById("output-video").srcObject = transformedStream;
    },
  });

  // Track connection state
  realtimeClient.on("connectionChange", (state) => {
    document.getElementById("status").textContent = state;
  });

  // Track billing
  realtimeClient.on("generationTick", ({ seconds }) => {
    document.getElementById("usage").textContent = `${seconds}s`;
  });

  // Handle errors
  realtimeClient.on("error", (error: DecartSDKError) => {
    console.error("Lucy 2.1 error:", error.code, error.message);
  });

  // Character selection
  document.getElementById("character-input").addEventListener("change", async (e) => {
    const file = (e.target as HTMLInputElement).files[0];
    if (file) {
      await realtimeClient.set({
        prompt: "Substitute the character in the video with the person in the reference image.",
        image: file,
        enhance: true,
      });
    }
  });

  // Cleanup
  window.addEventListener("beforeunload", () => {
    realtimeClient.disconnect();
    stream.getTracks().forEach((track) => track.stop());
  });

  return realtimeClient;
}

setupLucy2();

import asyncio
from decart import DecartClient, models

async def main():
    async with DecartClient(api_key="your-api-key-here") as client:
        model = models.realtime("lucy-2.1")

        realtime = await client.realtime.connect(
            stream=media_stream,
            model=model,
            on_remote_stream=lambda s: display(s),
        )

        # Track connection state
        @realtime.on("connection_change")
        def on_state(state):
            print(f"Connection: {state}")

        # Track billing
        @realtime.on("generation_tick")
        def on_tick(seconds):
            print(f"Usage: {seconds}s")

        # Handle errors
        @realtime.on("error")
        def on_error(error):
            print(f"Lucy 2.1 error: {error.code} {error.message}")

        # Upload a reference image and transform
        with open("character.jpg", "rb") as f:
            await realtime.set(
                prompt="Substitute the character in the video with the person in the reference image.",
                image=f,
                enhance=True,
            )

asyncio.run(main())

import ai.decart.sdk.*
import ai.decart.sdk.realtime.*
import org.webrtc.*

val model = RealtimeModels.LUCY_2_1
val client = DecartClient(context, DecartClientConfig(apiKey = "your-api-key"))
client.realtime.initialize(eglBase)

// Create camera track
val videoSource = client.realtime.createVideoSource(false)!!
val videoTrack = client.realtime.createVideoTrack("camera", videoSource)!!
val enumerator = Camera2Enumerator(context)
val capturer = enumerator.createCapturer(
    enumerator.deviceNames.first { enumerator.isFrontFacing(it) }, null
)
capturer.initialize(
    SurfaceTextureHelper.create("CaptureThread", client.realtime.getEglBaseContext()),
    context, videoSource.capturerObserver
)
capturer.startCapture(model.width, model.height, model.fps)

// Connect to Lucy 2.1
client.realtime.connect(
    localVideoTrack = videoTrack,
    options = ConnectOptions(
        model = model,
        onRemoteVideoTrack = { track -> remoteRenderer.addSink(track) }
    )
)

// Track connection state
lifecycleScope.launch {
    client.realtime.connectionState.collect { state ->
        statusText.text = state.name
    }
}

// Track billing
lifecycleScope.launch {
    client.realtime.generationTicks.collect { tick ->
        usageText.text = "${tick.seconds}s"
    }
}

// Handle errors
lifecycleScope.launch {
    client.realtime.errors.collect { error ->
        Log.e("Lucy2", "Error: ${error.code} ${error.message}")
    }
}

// Character selection — encode the picked image and send it
fun onCharacterSelected(imageBytes: ByteArray) {
    val base64 = Base64.encodeToString(imageBytes, Base64.NO_WRAP)
    client.realtime.setImage(
        imageBase64 = base64,
        prompt = "Substitute the character in the video with the person in the reference image.",
        enhance = true
    )
}

// Cleanup
capturer.stopCapture()
client.realtime.disconnect()
client.release()
eglBase.release()

// Backend: generate a short-lived token
const token = await client.tokens.create();

// Frontend: connect with the token
const frontendClient = createDecartClient({ apiKey: token.apiKey });

# Backend: generate a short-lived token
token = await client.tokens.create()

# Frontend: connect with the token
frontend_client = DecartClient(api_key=token.api_key)

// Fetch a short-lived token from your backend
val ephemeralKey = fetchTokenFromBackend()

// Connect with the token
val client = DecartClient(context, DecartClientConfig(apiKey = ephemeralKey))