API de Python de LiteRT-LM

La API de Python de LiteRT-LM para Linux y macOS (próximamente se admitirá Windows) Se admiten funciones como la multimodalidad, el uso de herramientas y la aceleración por GPU.

Introducción

Aquí tienes una app de chat de terminal de ejemplo compilada con la API de 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)

Comenzar

LiteRT-LM está disponible como biblioteca de Python. Puedes instalar la versión nocturna desde PyPI:

# Using pip
pip install litert-lm-api-nightly

# Using uv
uv pip install litert-lm-api-nightly

Inicializa el motor

Engine es el punto de entrada a la API. Se encarga de la carga de modelos y la administración de recursos. Usarlo como administrador de contexto (con la instrucción with) garantiza que los recursos nativos se liberen de inmediato.

Nota: La inicialización del motor puede tardar varios segundos en cargar el modelo.

import litert_lm

# Initialize with the model path and optionally specify the backend.
# backend can be Backend.CPU (default) or Backend.GPU.
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

Cómo crear una conversación

Un Conversation administra el estado y el historial de tu interacción con el modelo.

# Optional: Configure system instruction and initial messages
messages = [
    {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant."}]},
]

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

Envío de mensajes

Puedes enviar mensajes de forma síncrona o asíncrona (transmisión).

Ejemplo síncrono:

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

# Or with full message structure
# response = conversation.send_message({"role": "user", "content": "..."})

Ejemplo asíncrono (transmisión):

# 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()

🔴 Novedad: Multi-Token Prediction (MTP)

La predicción de varios tokens (MTP) es una optimización del rendimiento que acelera significativamente las velocidades de decodificación. Se recomienda el MTP de forma universal para todas las tareas en los backends de GPU.

Para usar MTP, habilita la decodificación especulativa cuando inicialices el motor.

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"])

Multimodalidad

# 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:
        user_message = {
            "role": "user",
            "content": [
                {"type": "audio", "path": "/path/to/audio.wav"},
                {"type": "text", "text": "Describe this audio."},
            ],
        }
        response = conversation.send_message(user_message)
        print(response["content"][0]["text"])

Cómo definir y usar herramientas

Puedes definir funciones de Python como herramientas a las que el modelo puede llamar automáticamente.

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 usa la cadena de documentación y las sugerencias de tipo de la función para generar el esquema de la herramienta para el modelo.