Interfaz de LLM de Ultralytics#

LLM es una pequeña interfaz para llamar a modelos de lenguaje y visión a través de una API compatible con OpenAI. Prepara entradas de texto o imagen, reenvía los argumentos de la solicitud al SDK oficial de Python de OpenAI y devuelve el objeto de respuesta nativo del SDK. Esto facilita añadir razonamiento de lenguaje o visión junto a una canalización de YOLO sin necesidad de envolver tipos de respuesta específicos de cada proveedor.

La API predeterminada es responses; usa api="chat.completions" para proveedores que solo implementan Chat Completions.

Instalación#

Instala Ultralytics con la dependencia opcional de LLM:

pip install "ultralytics[llm]"

Para OpenAI, configura la clave de API en el entorno:

export OPENAI_API_KEY="your-api-key"

API de respuestas#

La API de respuestas es la predeterminada. Pasa un mensaje y lee output_text:

from ultralytics import LLM

llm = LLM("gpt-5.6-luna")
response = llm("What is YOLO?")
print(response.output_text)

Entrada multimodal#

Pasa una ruta, URL HTTP, URI de datos, matriz de NumPy o imagen PIL a través de image:

from ultralytics import LLM

llm = LLM("gpt-5.6-luna")
response = llm("What is happening in this image?", image="https://ultralytics.com/images/bus.jpg")
print(response.output_text)

Los archivos locales y los objetos de imagen se codifican como URI de datos JPEG. Las matrices de NumPy utilizan el orden de canales BGR de OpenCV. Una cadena pasada como source, como llm("bus.jpg"), se trata como texto; usa el argumento image para enviar una imagen.

Usa prompt para una instrucción compartida por cada solicitud:

llm = LLM("gpt-5.6-luna", prompt="Answer in one sentence.")
response = llm("Describe this image.", image="bus.jpg")

Chat Completions#

Selecciona Chat Completions cuando lo requiera el extremo y lee su estructura de respuesta nativa:

from ultralytics import LLM

llm = LLM("gpt-5.6-luna", api="chat.completions")
response = llm("What is non-maximum suppression?")
print(response.choices[0].message.content)

La misma interfaz acepta entradas multimodales:

response = llm("Describe this image.", image="bus.jpg")
print(response.choices[0].message.content)

Pasa objetos de mensajes nativos cuando necesites el historial de conversación. Se reenvían sin cambios.

Streaming y llamadas asíncronas#

Los argumentos de solicitud del SDK se pasan sin cambios, incluido stream=True:

llm = LLM("gpt-5.6-luna")
for event in llm("Explain object detection.", stream=True):
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Usa async_call para solicitudes concurrentes:

import asyncio

from ultralytics import LLM

llm = LLM("gpt-5.6-luna")

async def main():
    response = await llm.async_call("What is YOLO?")
    print(response.output_text)

asyncio.run(main())

Proveedores compatibles con OpenAI#

LLM funciona con proveedores que exponen una API de Respuestas o Chat Completions compatible con OpenAI, incluidos DeepSeek, Kimi, Z.AI GLM y OpenRouter. Configura el parámetro base_url, el nombre del modelo y la clave de API del proveedor:

from ultralytics import LLM

llm = LLM(
    "provider-model",
    api="chat.completions",
    base_url="https://provider.example/v1",
    api_key="your-api-key",
)
response = llm("What tasks does YOLO support?")
print(response.choices[0].message.content)

La misma configuración funciona con servidores locales compatibles. Los nombres de los modelos, la compatibilidad con imágenes, los argumentos de solicitud y las API admitidas varían según el proveedor, así que consulta su documentación vinculada.

Combina YOLO y un LLM#

Ejecuta YOLO primero y luego llama al LLM únicamente cuando se detecte una persona:

from ultralytics import LLM, YOLO

yolo = YOLO("yolo26n.pt")
llm = LLM("gpt-5.6-luna")
image = "https://ultralytics.com/images/bus.jpg"

result = yolo(image)[0]
# Call the LLM only when YOLO detects a person.
if any(result.names[int(cls)] == "person" for cls in result.boxes.cls):
    response = llm("Describe the scene.", image=image)
    print(response.output_text)

Referencia de la API#

source acepta texto, una lista de mensajes nativos o un objeto de imagen. image acepta una URL de imagen, URI de datos, ruta, matriz de NumPy o imagen PIL. Llamar a model() con un prompt configurado envía el mensaje por sí solo.

LLM es solo para inferencia y no se expone a través de la CLI de yolo. No implementa train, val, export, track ni benchmark.

FAQ#