MemoriaForge: Wrapper ligero de llama.cpp en C++

un Wrapper ligero en C++ de llama.cpp

MemoriaForge: Memoria Persistente para llama.cpp en C++

Necesitaba integrar un asistente IA liviano en un sistema contable que todavía debe correr en PCs antiguas, así que construí un wrapper sobre llama.cpp para simplificar la integración y reutilizar contexto procesado

Cuando empecé a trabajar con modelos locales usando llama.cpp, me encontré con un problema recurrente: cada vez que la aplicación arrancaba, tenía que volver a procesar exactamente la misma información.

Si el modelo necesitaba trabajar con un manual técnico, documentación extensa o una base de conocimiento, el flujo era siempre el mismo:

Cargar modelo
    ↓
Leer documentación
    ↓
Tokenizar
    ↓
Procesar contexto
    ↓
Comenzar a conversar

Esto funciona, pero se vuelve ineficiente cuando la información no cambia entre ejecuciones.

Ahí nació MemoriaForge.

¿Qué es MemoriaForge?

MemoriaForge es una biblioteca escrita en C++ que funciona como una capa de abstracción sobre llama.cpp.

Su objetivo principal es permitir la persistencia de sesiones, haciendo posible guardar y restaurar el estado interno de un modelo local en formato GGUF.

En lugar de reconstruir el contexto desde cero cada vez que la aplicación se inicia, MemoriaForge permite procesarlo una sola vez y reutilizarlo posteriormente.

El problema que intenta resolver

Supongamos que queremos crear un asistente capaz de responder preguntas sobre un manual de 500 páginas.

Sin persistencia de contexto, cada ejecución requiere:

• Leer el documento.
• Convertirlo en tokens.
• Insertarlo en el contexto.
• Procesarlo nuevamente.

Aunque el documento sea exactamente el mismo.

En aplicaciones reales esto implica tiempos de inicio más largos y un consumo innecesario de recursos.

La idea detrás de MemoriaForge es simple:

1. Cargar el documento una sola vez.
2. Inyectarlo en el contexto del modelo.
3. Guardar el estado resultante.
4. Restaurarlo instantáneamente cuando vuelva a ser necesario.

El flujo pasa a ser:

Primera ejecución

Cargar modelo
    ↓
Procesar documentación
    ↓
Guardar estado


Ejecuciones posteriores

Cargar modelo
    ↓
Restaurar estado
    ↓
Comenzar a conversar

¿Cómo funciona?

Internamente MemoriaForge utiliza las capacidades de serialización de estado proporcionadas por llama.cpp.

La biblioteca expone una interfaz sencilla basada en una clase principal:

MemoriaForge::LLMSession

Esta clase encapsula:

• Carga de modelos GGUF.
• Conversaciones.
• Inyección de contexto.
• Guardado de sesiones.
• Restauración de sesiones.

Ejemplo básico

Crear una sesión es tan simple como:

MemoriaForge::LLMSession llm("models/qwen.gguf");

Enviar un mensaje:

std::string respuesta = llm.chat("Hola");

Inyectar contexto externo:

std::string manual = LeerArchivo("manual.txt");

llm.context_injector(manual);

Guardar el estado actual:

llm.save_state("manual_tecnico");

Y restaurarlo más adelante:

llm.load_state("manual_tecnico");

Una vez restaurada la sesión, el modelo puede continuar trabajando con el contexto previamente procesado sin necesidad de reconstruirlo.

Ejemplo simple de chat persistente con MemoriaForge

MemoriaForge puede utilizarse como un wrapper de llama.cpp, agilizando la incorporacion de un modelo de IA de forma fácil a nuestro proyecto en c++.

Aquí dejo un ejemplo sencillo de chat con persistencia:

#include "MemoriaForge.h"
#include <iostream>

int main() {
    //Cargamos el modelo
     MemoriaForge::LLMSession llm("model_path/model.gguf");
    //Cargamos el estado
    llm.load_state("state.bin");
    //Iniciamos el chat
    while (true) {
        std::string input;
        std::cout << "> ";
        std::getline(std::cin, input);

        if (input.empty()) break;
        //Mandamos el Prompt y obtenemos la respuesta del modelo
        llm.chat(input);
    }
    //Guardamos el estado
    llm.save_state("state.bin");

    return 0;
}

Casos de uso

MemoriaForge resulta especialmente útil para:

• Asistentes basados en documentación técnica.
• Manuales interactivos.
• Bases de conocimiento locales.
• Chatbots con memoria persistente.
• Herramientas de soporte técnico.
• Aplicaciones de IA offline.
• Proyectos que reutilizan grandes cantidades de contexto estático.

Lo que MemoriaForge no intenta ser

El proyecto está enfocado exclusivamente en persistencia de sesiones y reutilización de contexto.

No incluye:

• Bases de datos vectoriales.
• Embeddings.
• Sistemas RAG.
• Búsqueda semántica.
• Gestión automática de contexto.

La idea es mantenerse simple y liviano, dejando esas responsabilidades a capas superiores cuando sean necesarias.

Arquitectura

Aplicación
      │
      ▼
MemoriaForge
      │
      ▼
LLMSession
      │
      ▼
llama.cpp
      │
      ▼
Modelo GGUF
      │
      ▼
KV Cache
      │
 ┌────┴────┐
 ▼         ▼
chat()  save_state()

Conclusión

MemoriaForge nació para resolver un problema concreto: evitar reprocesar la misma información una y otra vez al trabajar con modelos locales.

Su propuesta es sencilla: cargar una vez, guardar el estado y restaurarlo cuando sea necesario.

El resultado es una API pequeña, escrita en C++, que aprovecha la potencia de llama.cpp mientras agrega una característica fundamental para muchas aplicaciones reales: memoria persistente.

El proyecto es completamente abierto bajo licencia GPL-3.0 y está disponible para experimentación y contribuciones.

https://github.com/canuconde/MemoriaForge