En esta serie de artículos vimos diferentes formas de poder utilizar modelos de Inteligencia Artificial desde el escritoro de Ubuntu. Ahora lo haremos usado API’S de Inteligencia Artificial en Ubuntu.

Esta forma, aunque requiere algo más de esfuerzo para aprenderla tiene como ventajas un ahorro de costos y un mayor control sobre los resultados.

Definiciones de conceptos claves

API

Es una serie de mecanismos y reglas establecidos para que dos sistemas de software se comuniquen entre sí de una manera controlable y predecible. De esta forma pueden intercambiar datos sin necesidad de saber cómo están construídos.

Token

Aunque cuando trabajamos desde la página web de una plataforma de Inteligencia Artificial no necesitamos saberlo, cuando nos conectamos mediante una API deberémos estar atentos a los tokens. Un token es la unidad mínima en que el modelo divide la información para poder procesarla.

El proceso de transformar la información en tokens se llama «tokenización» y se hace mediante algoritmos especiales entrenados con grandes cantidades de información para saber cuáles son las divisiones más eficientes.

Un token puede ser:

• Una palabra completa por ejemplo «Casa»
• Parte de una palabra por ejemplo «Incre» «ible» serían dos tokens
• Los signos de puntuación y los espacios también equivales a un token
• Un fragmento de imagen equivale a un token.

En general se calcula para el idioma español una relación de 100 tokens = 75 palabras.

Hay 3 motivos principales para que se usen tokens en lugar de palabras.

1. Hace más fácil la adaptación del modelo a múltiples idiomas
2. Permite incorporar nuevas palabras.
3. Permite un uso más eficiente de la potencia de procesamiento

Cada token se convierte en una secuencia numérica equivalente con la que trabajará el modelo.

Una analogía del funcionamiento de los tokens son los ladrillos Lego porque:

• Cada bloque tiene una forma específica que determinará como encaja con los otros.
• Cuanto más veces se lo utiliza más fácil es saber mejor como encajan las piezas.
• Cuanto mayor cantidad de piezas se dispongan mejor saldrá la construcción

Usando API’S de Inteligencia Artificial en Ubuntu

Para que nuestra aplicación se conecte al modelo necesitamos lo siguiente:

• Cliente: Puede ser una aplicaión, un script automatizado o la terminal de Linux. Es donde se construye el promot, se envía el requerimiento y se procesa la respuesta.
• Clave de autenticación de la API: Se obtiene en la web para desarrolladores del modelo. Permite identificarse como usuario legítimo por lo que debe permanecer secreta. La usa el modelo para controlar límites de uso.
• Endpoint: Es una dirección específica dentro de la API en la que se define la acción a realizar, que datos se requiere y cuál es la respuesta esperada

El proceso es el siguiente:

1. 1. La aplicación envía el promt con un mensaje parecido a este:
      {
"model": "gpt-5.2",Indica que modelo usar
      "messages": [
{ "role": "system", "content": "Eres un experto en Linux" }, Le dice que papel debe adoptar en su respuesta
      { "role": "user", "content": "Explica los principales comandos de la terminal con un ejemplo" } Indica que debe responder.
]
}
   2. El mensaje se envía usando el protocolo http. Sería algo cómo esto:
      POST /v1/chat/completions
      Authorization: Bearer TU_API_KEY
      Content-Type: application/json
   3. La API recibe el mensaje, revisa la validez de la clave de validación y los límites disponibles, normaliza la entrada y la envía al modelo
   4. El modelo tokeniza el texto, predice el siguiente token siguiendo sus pautas de entrenamiento y repite el proceso hasta completar la respuesta.

1. La API devuelve la respuesta en un formato parecido a este:
   {
   «choices»: [
   {
   «message»: {
   «role»: «assistant»,
   «content»: «Eres un experto en…»
   }
   }
   ],
   «usage»: {
   «prompt_tokens»: 120,
   «completion_tokens»: 180
   }
   }
2. La aplicación muestra la respuesta y hace lo que se le indique en la programación (Guardarla, incluirla en otra pregunta, almacenarla en una base de datos)

Aunque cualquier lenguaje de programación puede usarse en conjunto con las APIś propias de cada modelo. Vamos a concentrarnos en el uso de la terminal de Linux y de Python.

Por razones de seguridad, en Ubuntu los programas en Python no se ejecutandirectamente sino que debemos crear un entorno virtual. Se trata de un espacio aislado para que proyecto usa su propio intérprete de Python, gestor de paquetes y sus propias bibliotecas, No afectará al sistema ni a otros proyectos.

Instalamos los programas necesarios con:

sudo apt update
sudo apt install python3 python3-venv python3-pip
Creamos en nuestra carpeta principal una carpeta en donde va a estar la aplicación

cd ~/mi_programa
Creamos el entorno virtual
python3 -m venv venv
Activamos el entorno
source venv/bin/activate
Cuanto terminamos desactivamos el entorno con:

deactivate

OpenAI provee de una completa documentación para desarrolladores

Ejemplo práctico con ChatGPT

1. Generamos la clave de autenticación desde este enlace.
2. La agregamos como variable del entorno desde la terminal (Requiere reinicio) export OPENAI_API_KEY=»tu_clave_api_generada»
3. Sigue los pasos indicados para ccrear el entorno virtual de python hasta la etapa de acttivación.
4. instala la bibliotecas necesarias con el comando:
   pip install openai
5. Abre el editor de texto y pega el siguiente código:
   from openai import OpenAI
   client = OpenAI()response = client.responses.create(
   model=»gpt-5.2″,
   input=»Escribe una frase de una línea que explique qué es Linux.»
   )print(response.output_text)
6. Guardamos el archivo en la carpeta de trabajo con el nombre ejemplo1.py
7. Lo ejecutamos con el comando python3 ejemplo1.py

Debes recordar que el uso de la API es de pago por lo que deberás ingresar un mínimo de 5 dólares, Puedes hacerlo desde este enlace.

En este otro ejemplo le pedimos al modelo que genere una imagen. Una vez generada la aplicaicón la guarda en la carepta del proyecto
from openai import OpenAI
import base64
import os

# ===============================
# CONFIGURACIÓN
# ===============================

PROMPT = «Un imagen realista de un pingüino programando »
IMAGE_NAME = «imagen_generada.png»
IMAGE_SIZE = «1024×768″

# ===============================
# CLIENTE OPENAI
# ===============================

client = OpenAI() # Usa la variable de entorno OPENAI_API_KEY

# ===============================
# GENERAR IMAGEN
# ===============================

result = client.images.generate(
model=»gpt-image-1»,
prompt=PROMPT,
size=IMAGE_SIZE
)

# ===============================
# GUARDAR IMAGEN EN DISCO
# ===============================

with open(IMAGE_NAME, «wb») as f:
f.write(image_bytes)

# ===============================
# CONFIRMACIONES EN CONSOLA
# ===============================

print(« Imagen generada correctamente»)
print(f» Archivo guardado como: {IMAGE_NAME}»)

Recuerda que apenas arañamos la superficie de lo que se puede hacer con Python y la API. Y que otros modelsos como Claude o DeepSeek también las tienen. Además, como vimos en el primer artículo existen diferentes parámetros que se pueden utilizar para lograr loos resultados que queremos.

La documentación de la API de OpenAi podemos encontrarla aquí.