API Web LiteRT-LM

API Web de LiteRT-LM pour JavaScript et TypeScript dans le navigateur. Il s'agit d'un aperçu en avant-première qui prend en charge l'exécution de l'entrée et de la sortie de texte dans WebGPU.

Modèles compatibles

L'API JS LiteRT-LM est actuellement compatible avec un ensemble limité de modèles Web. Nous nous efforçons d'étendre cette fonctionnalité aux fichiers de modèle .litertlm généraux, mais pour l'instant, les modèles suivants sont compatibles :

Introduction

Voici un exemple d'application de chat REPL conçue avec l'API JavaScript :

<div id="out" style="white-space: pre-wrap; font-family: monospace;"></div>
<input id="in" onkeydown="if(event.key === 'Enter') repl(this)">

<script type="module">
  import { Engine } from 'https://cdn.jsdelivr.net/npm/@litert-lm/core/+esm';
  const engine = await Engine.create({
    // Load the Gemma 4 E2B model
    model: 'https://huggingface.co/litert-community/gemma-4-E2B-it-litert-lm/resolve/main/gemma-4-E2B-it-web.litertlm'
    // Or use the E4B model by swapping in this line
    // model: 'https://huggingface.co/litert-community/gemma-4-E4B-it-litert-lm/resolve/main/gemma-4-E4B-it-web.litertlm'
  });
  const chat = await engine.createConversation();

  window.repl = async (el) => {
    const text = el.value;
    el.value = ''; // Clear immediately
    out.append(`\n>>> ${text}\nAI: `);

    for await (const chunk of chat.sendMessageStreaming(text)) {
      out.append(chunk.content[0].text);
    }
  };
</script>

Premiers pas

LiteRT-LM est disponible en tant que package npm. Vous pouvez installer la dernière version à partir de npm ou l'importer directement depuis un CDN :

# From npm
npm i --save @litert-lm/core

# From a CDN (in your JavaScript file)
import * as litertlm from 'https://cdn.jsdelivr.net/npm/@litert-lm/core/+esm';

Initialiser le moteur

Engine est le point d'entrée de l'API. Il gère le chargement des modèles, la création de sessions et la gestion des ressources. N'oubliez pas de delete le moteur pour libérer des ressources lorsque le modèle n'est plus nécessaire.

Remarque : L'initialisation du moteur peut prendre plusieurs secondes pour charger le modèle.

import {Engine, EngineSettings} from '@litert-lm/core';

const engineSettings = {
  model: 'url/path/to/model.litertlm', // or a ReadableStream, or a Blob

  // You can configure context length and other settings here
  mainExecutorSettings: {
    maxNumTokens: 8192,
  },
} satisfies EngineSettings;

const engine = await Engine.create(engineSettings);

// ... Use the engine to create a conversation ...

// Delete the engine when done.
await engine.delete();

Créer une conversation

Une fois le moteur initialisé, créez une instance Conversation. Vous pouvez fournir un ConversationConfig pour personnaliser son comportement.

const conversation = await engine.createConversation({
  preface: {
    messages: [
      {role: 'system', content: 'You are a helpful assistant'}
    ]
  }
});

conversation.sendMessage({
  role: 'user',
  content: 'Write a poem',
});

Envoyer des messages

Vous pouvez envoyer des messages avec ou sans streaming.

Exemple de contenu non diffusé en streaming

// Simple string input
let response = await conversation.sendMessage("What is the capital of France?");
console.log(response.content[0].text);

// Or with full message structure
response = await conversation.sendMessage({role: 'user', content: '...'});

Exemple de streaming

// sendMessageStreaming returns a ReadableStream of response chunks
const stream = conversation.sendMessageStreaming('Tell me a long story.');

for await (const chunk of stream) {
  // Chunks are Records containing pieces of the response
  for (const item of chunk.content) {
    if (item.type === 'text') {
      console.log(item.text);
    }
  }
}

Annuler la génération

Vous pouvez annuler explicitement une génération en cours en appelant cancel() sur l'instance Conversation :

// Cancel any ongoing generation
conversation.cancel();

Si vous diffusez la réponse en streaming, la sortie anticipée de la boucle for await...of (par exemple, avec break) annulera également automatiquement la génération en cours :

for await (const chunk of stream) {
  if (shouldStop()) {
    break; // Cancels the stream and underlying generation
  }
}