LiteRT-LM Python API

Die Python API von LiteRT-LM für Linux und macOS (Windows-Unterstützung folgt). Funktionen wie Multimodalität, Toolnutzung und GPU Beschleunigung werden unterstützt.

Einführung

Hier ist eine Beispiel-Terminal-Chat-App, die mit der Python API erstellt wurde:

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)

Erste Schritte

LiteRT-LM ist als Python-Bibliothek verfügbar. Sie können die Nightly-Version von PyPI installieren:

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

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

Engine initialisieren

Die Engine ist der Einstiegspunkt zur API. Sie verarbeitet das Laden von Modellen und die Ressourcenverwaltung. Wenn Sie sie als Kontextmanager verwenden (mit der Anweisung with), werden native Ressourcen umgehend freigegeben.

Hinweis:Das Initialisieren der Engine kann einige Sekunden dauern, da das Modell geladen werden muss.

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

Unterhaltung erstellen

Eine Conversation verwaltet den Status und den Verlauf Ihrer Interaktion mit dem Modell.

# 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

Nachrichten senden

Sie können Nachrichten synchron oder asynchron (Streaming) senden.

Synchrones Beispiel :

# 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": "..."})

Asynchrones (Streaming-)Beispiel :

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

🔴 Neu: Multi-Token Prediction (MTP)

Multi-Token Prediction (MTP) ist eine Leistungsoptimierung, die die Decodierungsgeschwindigkeit erheblich beschleunigt. MTP wird universell für alle Aufgaben auf GPU-Back-Ends empfohlen.

Wenn Sie MTP verwenden möchten, aktivieren Sie die spekulative Decodierung beim Initialisieren der Engine.

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ät

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

Tools definieren und verwenden

Sie können Python-Funktionen als Tools definieren, die vom Modell automatisch aufgerufen werden können.

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 verwendet den Docstring und die Typ-Hinweise der Funktion, um das Toolschema für das Modell zu generieren.