API Python LiteRT-LM

L'API Python de LiteRT-LM pour Linux, macOS et Windows. Les fonctionnalités telles que la multimodalité, l'utilisation d'outils et l'accélération GPU et NPU sont compatibles.

Introduction

Voici un exemple d'application de chat en terminal créée avec l'API Python :

import litert_lm

litert_lm.set_min_log_severity(litert_lm.LogSeverity.ERROR) # Hide log for TUI app

with litert_lm.Engine("path/to/model.litertlm") as engine:
  with engine.create_conversation() as conversation:
    while True:
      user_input = input("\n>>> ")
      for chunk in conversation.send_message_async(user_input):
        print(chunk["content"][0]["text"], end="", flush=True)

Premiers pas

LiteRT-LM est disponible en tant que bibliothèque Python. Vous pouvez installer le package à partir de PyPI :

# Using pip
pip install litert-lm-api

# Using uv
uv pip install litert-lm-api

Initialiser le moteur

Engine est le point d'entrée de l'API. Il gère le chargement des modèles et la gestion des ressources. L'utiliser comme gestionnaire de contexte (avec l'instruction with) garantit que les ressources sont libérées rapidement.

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

import litert_lm

# Initialize with the model path and optionally specify the backend.
# backend can be Backend.CPU() (default), Backend.GPU() or Backend.NPU().
with litert_lm.Engine(
    "path/to/your/model.litertlm",
    backend=litert_lm.Backend.GPU(),
    # Optional: Pick a writable dir for caching compiled artifacts.
    # cache_dir="/tmp/litert-lm-cache"
) as engine:
    # ... Use the engine to create a conversation ...
    pass

Créer une conversation

Une Conversation gère l'état et l'historique de votre interaction avec le modèle.

# Optional: Configure system instruction and initial messages
messages = [litert_lm.Message.system("You are a helpful assistant.")]

# Create the conversation
with engine.create_conversation(messages=messages) as conversation:
    # ... Interact with the conversation ...
    pass

Envoyer des messages

Vous pouvez envoyer des messages de manière synchrone ou asynchrone (streaming).

Les méthodes send_message et send_message_async acceptent les éléments suivants :

  • Un str (encapsulé automatiquement en tant que message utilisateur).
  • Un objet litert_lm.Contents (pour les entrées multimodales).
  • Un objet litert_lm.Message (pour la structure complète du message).
  • Un objet de dictionnaire de type JSON comme entrée de modèle d'invite.

Exemple synchrone :

# Simple string input
response = conversation.send_message("What is the capital of France?")
print(response["content"][0]["text"])

# Or with a Message object
# response = conversation.send_message(litert_lm.Message.user("What is the capital of France?"))

Exemple asynchrone (streaming) :

# sendMessageAsync returns an iterator of response chunks
stream = conversation.send_message_async("Tell me a long story.")
for chunk in stream:
    # Chunks are dictionaries containing pieces of the response
    for item in chunk.get("content", []):
      if item.get("type") == "text":
        print(item["text"], end="", flush=True)
print()

🔴 Nouveau : Prédiction de plusieurs jetons (MTP)

La prédiction de plusieurs jetons (MTP) est une optimisation des performances qui accélère considérablement les vitesses de décodage. La MTP est universellement recommandée pour toutes les tâches sur les backends GPU.

Pour utiliser la MTP, activez le décodage spéculatif lors de l'initialisation du moteur.

import litert_lm

# Enable MTP by setting enable_speculative_decoding=True
with litert_lm.Engine(
    "path/to/your/model.litertlm",
    backend=litert_lm.Backend.GPU(),
    enable_speculative_decoding=True,
) as engine:
    with engine.create_conversation() as conversation:
        response = conversation.send_message("What is the capital of France?")
        print(response["content"][0]["text"])

Multimodalité

# Initialize with vision and/or audio backends if needed
with litert_lm.Engine(
    "path/to/multimodal_model.litertlm",
    audio_backend=litert_lm.Backend.CPU(),
    vision_backend=litert_lm.Backend.GPU(),
) as engine:
    with engine.create_conversation() as conversation:
        response = conversation.send_message(
            litert_lm.Contents.of(
                "Describe this audio.",
                litert_lm.Content.AudioFile(absolute_path="/path/to/audio.wav"),
            )
        )
        print(response["content"][0]["text"])

Définir et utiliser des outils

Vous pouvez définir des fonctions Python comme outils que le modèle peut appeler automatiquement.

def add_numbers(a: float, b: float) -> float:
    """Adds two numbers.

    Args:
        a: The first number.
        b: The second number.
    """
    return a + b

# Register the tool in the conversation
tools = [add_numbers]
with engine.create_conversation(tools=tools) as conversation:
    # The model will call add_numbers automatically if it needs to sum values
    response = conversation.send_message("What is 123 + 456?")
    print(response["content"][0]["text"])

LiteRT-LM utilise la docstring et les indications de type de la fonction pour générer le schéma d'outil du modèle.