Este artículo detalla la implementación de un asistente de escritorio basado en Qt, que integra el modelo de lenguaje MiniCPM-o-4.5-nvidia-FlagOS para ejecución local. El objetivo es desarrollar una herramienta multiplataforma que permita interaciones privadas y offline, como análisis de documentos o gestión de notas.

La combinación de Qt y el modelo optimizado para NVIDIA GPU ofrece un entorno robusto: Qt proporciona una interfaz gráfica portable con alto rendimiento en C++, mientras que MiniCPM-o-4.5-nvidia-FlagOS habilita inferencia eficiente en hardware local, eliminando dependencias de servicios en la nube y mejorando la seguridad de datos.

Configuración inicial del proyecto Qt

Se recomienda crear un proyecto Qt Widgets Application utilizando Qt Creator. Los archivos clave incluyen main.cpp, ventanaprincipal.h, ventanaprincipal.cpp y ventanaprincipal.ui. La interfaz debe diseñarse con Qt Designer, incorporando un QTextEdit para el historial de conversaciones, un QPlainTextEdit para la entrada del usuario, y botones para acciones como enviar o limpiar. Utilice gestores de diseño como QVBoxLayout para una adaptación responsiva.

Diseño del módulo de comunicación

Para interactuar con el modelo, se implementa una clase ConectorModelo que maneja solicitudes HTTP a la API del modelo, asumiendo un endpoint compatible con OpenAI (por ejemplo, http://localhost:8080/v1/chat/completions). Esta clase gestiona respuestas en flujo (streaming) para mejorar la experiencia del usuario.

Ejemplo de código con lógica y variables modificadas:

// ConectorModelo.h
#include <qobject>
#include <qnetworkaccessmanager>
#include <qnetworkreply>

class ConectorModelo : public QObject {
    Q_OBJECT
public:
    explicit ConectorModelo(QObject *padre = nullptr);
    void enviarConsulta(const QString &consulta);
    void anularSolicitud();

signals:
    void nuevoFragmento(const QString &fragmento);
    void respuestaCompleta();
    void error(const QString &mensaje);

private slots:
    void leerDatosFlujo();

private:
    QNetworkAccessManager *administradorRed;
    QNetworkReply *solicitudActual = nullptr;
    QString urlEndpoint;
};

// ConectorModelo.cpp
void ConectorModelo::enviarConsulta(const QString &consulta) {
    if (solicitudActual) {
        solicitudActual->abort();
    }
    QUrl url(urlEndpoint + "/v1/chat/completions");
    QNetworkRequest peticion(url);
    peticion.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
    peticion.setRawHeader("Accept", "text/event-stream");

    QJsonObject cuerpoJson;
    cuerpoJson["model"] = "minicpm-o-4.5";
    cuerpoJson["stream"] = true;
    QJsonArray mensajes;
    QJsonObject mensajeUsuario;
    mensajeUsuario["role"] = "user";
    mensajeUsuario["content"] = consulta;
    mensajes.append(mensajeUsuario);
    cuerpoJson["messages"] = mensajes;

    QJsonDocument documento(cuerpoJson);
    solicitudActual = administradorRed->post(peticion, documento.toJson());
    connect(solicitudActual, &QNetworkReply::readyRead, this, &ConectorModelo::leerDatosFlujo);
    connect(solicitudActual, &QNetworkReply::finished, this, [this]() {
        if (solicitudActual->error() != QNetworkReply::NoError && solicitudActual->error() != QNetworkReply::OperationCanceledError) {
            emit error(solicitudActual->errorString());
        }
        solicitudActual->deleteLater();
        solicitudActual = nullptr;
        emit respuestaCompleta();
    });
}

void ConectorModelo::leerDatosFlujo() {
    if (!solicitudActual) return;
    QString datos = solicitudActual->readAll();
    QStringList lineas = datos.split('\n');
    for (const QString &linea : lineas) {
        if (linea.startsWith("data: ") && linea != "data: [DONE]") {
            QString textoJson = linea.mid(6);
            QJsonDocument doc = QJsonDocument::fromJson(textoJson.toUtf8());
            if (!doc.isNull()) {
                QJsonObject obj = doc.object();
                QJsonObject eleccion = obj["choices"].toArray().first().toObject();
                QJsonObject delta = eleccion["delta"].toObject();
                if (delta.contains("content")) {
                    QString fragmento = delta["content"].toString();
                    emit nuevoFragmento(fragmento);
                }
            }
        }
    }
}
</qnetworkreply></qnetworkaccessmanager></qobject>

Integración de la interfaz con el flujo de datos

En la clase VentanaPrincipal, se vinculan los señales del ConectorModelo a slots que actualizan la interfaz. Para optimizar el rendimiento, se usa un búfer intermedio que acumula tokens antes de refrescar el QTextEdit, evitando bloqueos en la enterfaz.

// VentanaPrincipal.cpp
VentanaPrincipal::VentanaPrincipal(QWidget *padre) : QMainWindow(padre), ui(new Ui::VentanaPrincipal) {
    ui->setupUi(this);
    conector = new ConectorModelo(this);
    connect(ui->botonEnviar, &QPushButton::clicked, this, &VentanaPrincipal::alEnviar);
    connect(conector, &ConectorModelo::nuevoFragmento, this, &VentanaPrincipal::alRecibirFragmento);
    connect(conector, &ConectorModelo::respuestaCompleta, this, &VentanaPrincipal::alFinalizarRespuesta);
    ui->areaConversacion->setReadOnly(true);
}

void VentanaPrincipal::alEnviar() {
    QString entrada = ui->campoEntrada->toPlainText().trimmed();
    if (entrada.isEmpty()) return;
    agregarMensaje("Usuario", entrada);
    ui->campoEntrada->clear();
    ui->botonEnviar->setEnabled(false);
    ui->barraEstado->showMessage("Procesando...");
    conector->enviarConsulta(entrada);
    bufferRespuesta.clear();
}

void VentanaPrincipal::alRecibirFragmento(const QString &fragmento) {
    bufferRespuesta.append(fragmento);
    static int contador = 0;
    contador++;
    if (contador >= 5 || fragmento.contains('.') || fragmento.contains('\n')) {
        actualizarVisualizacion();
        contador = 0;
    }
}

void VentanaPrincipal::actualizarVisualizacion() {
    if (bufferRespuesta.isEmpty()) return;
    QTextCursor cursor(ui->areaConversacion->document());
    cursor.movePosition(QTextCursor::End);
    cursor.insertText(bufferRespuesta);
    bufferRespuesta.clear();
    ui->areaConversacion->verticalScrollBar()->setValue(ui->areaConversacion->verticalScrollBar()->maximum());
}

Mejoras funcionales

Para enriquecer la aplicación, considere agregar gestión de historial de conversaciones con estructuras como QList de pares, renderizado Markdown mediante librerías externas o resaltado de sintaxis, manejo de errores con tiempos de espera configurables, y un panel de ajustes para parámetros del modelo. La integración de iconos en la bandeja del sistema y atajos globales puede mejorar la accesibilidad.

Este enfoque permite desarrollar aplicaciones de escritorio multiplataforma con capacidades de IA local, asegurando privacidad y bajo costo operativo. La modularidad de Qt facilita la extensión según necesidades específicas.