Interfaz LLM de Ultralytics#

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

La API predeterminada es responses; usa api="chat.completions" con proveedores que solo implementen 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"

Responses API#

Responses API es la opción predeterminada. Pasa un prompt 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, una URL HTTP, un URI de datos, una matriz de NumPy o una imagen de PIL mediante 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 incluir una instrucción compartida por todas las solicitudes:

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 el endpoint lo requiera 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 admite entradas multimodales:

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

Pasa objetos de mensaje nativos cuando necesites el historial de la 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 realizar solicitudes simultáneas:

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 ofrecen una API de Responses o Chat Completions compatible con OpenAI, incluidos DeepSeek, Kimi, Z.AI GLM y OpenRouter. Configura el base_url del proveedor, el nombre del modelo y la clave de API:

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 modelo, la compatibilidad con imágenes, los argumentos de solicitud y las API compatibles varían según el proveedor, así que consulta su documentación enlazada.

Combina YOLO y un LLM#

Ejecuta YOLO primero y llama al LLM solo 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, un URI de datos, una ruta, una matriz de NumPy o una imagen de PIL. Llamar a model() con un prompt configurado envía el prompt por sí solo.

LLM solo permite inferencia y no se expone mediante la CLI yolo. No implementa train, val, export, track ni benchmark.

Preguntas frecuentes#