En la entrada anterior conseguimos que un modelo de IA respondiera desde LM Studio en nuestro portátil de pruebas (ROCKY), sin GPU y sin depender de servicios de pago. Pero ahí el modelo solo hablaba con nosotros a través de la ventana de chat de LM Studio.

El siguiente paso, según la arquitectura por capas del proyecto, es la capa de API: un punto de entrada propio y sencillo por el que cualquier aplicación futura (una web, una app de alumnado, un proyecto de Technovation) pueda hacerle una pregunta a nuestra IA, sin tener que saber nada de LM Studio ni de cómo está montado por dentro.

¿Por qué no conectar las aplicaciones directamente a LM Studio?

LM Studio ya trae de fábrica un servidor que imita la API de OpenAI (el mismo formato que usan ChatGPT y muchas herramientas de IA). Técnicamente, podríamos apuntar cualquier aplicación directamente ahí y ya tendríamos algo funcionando.

No lo vamos a hacer así, por una razón de diseño, no de funcionamiento: si todas nuestras aplicaciones futuras hablan directamente con LM Studio, el día que cambiemos de motor de inferencia (por ejemplo, si pasamos a un servidor más potente con otro programa) tendríamos que modificar todas y cada una de esas aplicaciones.

En vez de eso, ponemos una API propia en medio, muy sencilla, que:

• de cara afuera, ofrece un endpoint simple tipo “pregunta → respuesta”;
• por dentro, es la única pieza que sabe hablar con LM Studio.

Si mañana cambiamos de motor, solo tocamos esta pieza intermedia. Las aplicaciones que la usan no se enteran del cambio. Esto es exactamente el principio de modularidad del proyecto.

Para esta API usamos FastAPI: un framework de Python ligero, gratuito, muy usado en proyectos educativos y con documentación automática incluida (lo veremos en un momento), sin necesidad de bases de datos ni infraestructura compleja.

Paso 1 — Activar el servidor local en LM Studio

1. Abre LM Studio.
2. En el menú lateral izquierdo, busca el icono de Developer (parece un símbolo </>).
3. Dentro de esa pestaña, activa el interruptor “Start server”.
4. Por defecto arranca en el puerto 1234. Puedes comprobar que funciona abriendo esta dirección en el navegador:

   http://localhost:1234/v1/models

Debería devolverte un texto con el nombre del modelo que tienes cargado (algo como llama-3.2-3b-instruct). Apunta ese nombre exacto, lo necesitamos en el siguiente paso.

Importante: esto solo escucha en tu propio ordenador (localhost). No estamos abriendo nada a Internet ni exponiendo el equipo del instituto — coherente con el principio de privacidad y seguridad del proyecto. Eso vendrá, si acaso, mucho más adelante y con las precauciones correspondientes.

Paso 2 — Crear la carpeta del proyecto

Crea una carpeta, por ejemplo ia-monterroso-api, con estos dos archivos dentro:

Archivo: ia-monterroso-api/requirements.txt

fastapi
uvicorn[standard]
requests

Archivo: ia-monterroso-api/main.py

python

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import requests

# --- Configuración ---
# Dirección del servidor local de LM Studio (API compatible con OpenAI)
LM_STUDIO_URL = "http://localhost:1234/v1/chat/completions"

# Identificador exacto del modelo cargado en LM Studio.
# Compruébalo en http://localhost:1234/v1/models si cambias de modelo.
MODEL_NAME = "llama-3.2-3b-instruct"

# Tiempo máximo de espera por respuesta, en segundos.
# En hardware sin GPU, las respuestas pueden tardar bastante.
TIMEOUT_SEGUNDOS = 120

app = FastAPI(title="IA Monterroso - API")


class Pregunta(BaseModel):
    pregunta: str


class Respuesta(BaseModel):
    respuesta: str


@app.post("/preguntar", response_model=Respuesta)
def preguntar(datos: Pregunta):
    """
    Recibe una pregunta en español, se la pasa al modelo cargado
    en LM Studio, y devuelve la respuesta generada.
    """
    cuerpo_peticion = {
        "model": MODEL_NAME,
        "messages": [
            {"role": "user", "content": datos.pregunta}
        ],
        "temperature": 0.7,
    }

    try:
        respuesta_lm_studio = requests.post(
            LM_STUDIO_URL,
            json=cuerpo_peticion,
            timeout=TIMEOUT_SEGUNDOS,
        )
        respuesta_lm_studio.raise_for_status()
    except requests.exceptions.ConnectionError:
        raise HTTPException(
            status_code=503,
            detail="No se puede conectar con LM Studio. ¿Está abierto y con el servidor activado?",
        )
    except requests.exceptions.Timeout:
        raise HTTPException(
            status_code=504,
            detail="El modelo ha tardado demasiado en responder.",
        )

    datos_respuesta = respuesta_lm_studio.json()
    texto_generado = datos_respuesta["choices"][0]["message"]["content"]

    return Respuesta(respuesta=texto_generado)


@app.get("/salud")
def salud():
    """Endpoint simple para comprobar que la API está viva."""
    return {"estado": "ok"}

Paso 3 — Instalar dependencias y arrancar la API

Desde una terminal, dentro de la carpeta ia-monterroso-api:

bash

pip install -r requirements.txt --break-system-packages
uvicorn main:app --reload --port 8000

Si todo va bien, verás un mensaje indicando que el servidor está corriendo en http://127.0.0.1:8000.

Paso 4 — Probarlo sin escribir código

FastAPI genera automáticamente una página de pruebas interactiva. Con la API arrancada, abre en el navegador:

http://localhost:8000/docs

Ahí puedes desplegar el endpoint /preguntar, pulsar en “Try it out”, escribir una pregunta en el campo pregunta, y ejecutarla. La respuesta del modelo aparecerá justo debajo.

Si prefieres probarlo por terminal:

bash

curl -X POST "http://localhost:8000/preguntar" \
  -H "Content-Type: application/json" \
  -d '{"pregunta": "Explícame qué es una API en una frase"}'

Ten paciencia: con nuestro hardware actual (sin GPU), cada respuesta puede tardar unos segundos — es exactamente el mismo modelo y la misma velocidad que ya vimos probando directamente en LM Studio.

Qué hemos conseguido con esto

Ahora tenemos una API propia, sencilla y documentada, que hace de puente entre “quien pregunta” y “el modelo que responde”. Es una pieza pequeña a propósito: todavía no tiene autenticación, ni límites de uso, ni memoria de conversación, ni conocimiento propio del centro. Eso es intencionado — de momento estamos validando que la capa de API funciona, antes de añadir nada más encima.

Próximos pasos posibles desde aquí: una interfaz mínima de pregunta-respuesta más amigable que la página de pruebas de FastAPI, o empezar a introducir el conocimiento propio del centro. Lo iremos decidiendo entrada a entrada, según lo que vaya funcionando.

José Luis Usero — Profesor de Informática, IES Monterroso (Estepona)