Construyendo un Agente de IA Nativo con C y Llama.cpp (II)

Nos metemos ya en harina con el código del ejemplo Base, que podemos encontrar en https://github.com/pinguytaz/IA/tree/main/Llama.cpp/src/Base

Para poder usar el programa deberemos descargarnos un modelo preentrenado en formato GGUF,

La estructura base del programa es:

                                    [Inicializar Backend]
                                            │ llama_backend_init();
                                            ▼
                                    [Cargar Modelo]
                                            Define parámetros de ejecución del modelo
                                            Lee archivo .gguf y carga su vocabulario y pesos.
                                            |   llama_model_load_from_file(pathModelo, parametrosModelo);
                                            ▼
                                    [Crear Contexto]
                                             Reserva la memoria RAM dinámica, donde guardamos historia.
                                            │   llama_init_from_model(modelo, parametrosContexto);
                                            ▼
                                    [Tokenizar Prompt]
                                            llama_model_get_vocab(model); Obtenemos el vocabulario del modelo para tokenizar.
                                            llama_tokenize() pasa el texto a numero que son los TOKENs
                                            │
                                            ▼
                                    [sampler] Filtro de seleccion de probabilidades
                                            │
                                            ▼
                                    [batch] Procesamiento por lotes
                                            │
                                            ▼
                                    [Bucle de Inferencia] Es el bucle de generación

La programación la realizaremos usando el API de llama.h, con alto nivel «llama» aunque también podriamos utilizar las librerías de bajo nivel «GGML» por describimos brevemente que es cada uno:

• GGML: Librería de bajo nivel. Se encarga de la matemática pura (multiplicación de matrices y cuantización).
• LLAMA: Capa de abstracción de alto nivel. Maneja el modelo, los tokens y el estado del KV Cache.

Lo primero que hacemos es cargar Backend, antes de comenzar con el programa, que nos permitirá inicializar los recursos de CPU/GPU.

Después cargaremos el modelo en memoria, mapeara el archivo .gguf en memoria, definiendo los parámetros que nos interesen.

paramModelo_t parametrosModelo = llama_model_default_params();   // Carga de los parametros por defecto
parametrosModelo.n_gpu_layers = 0;     //  Forzar ejecución en CPU
parametrosModelo.progress_callback = mi_progreso; //Ponemos función de progeso de carga.

 modelo_t *modelo = llama_model_load_from_file(pathModelo, parametrosModelo);   // Carga modelo.

Con el modelo cargado crearemos el contexto, Crear el espacio de «pensamiento» donde se guardarán los tokens, para disponer de historia y podamos procesar bien los TOKENs, este contexto se va llenando en un chat normal y existen varias formas de borrarlo, esto lo hablaremos más adelante cuando veamos el ejemplo Agente.

    paramContext_t parametrosContexto = llama_context_default_params();
    parametrosContexto.n_ctx = 2048;  // Tamaño contexto

    context_t *contexto = llama_init_from_model(modelo, parametrosContexto);      // Crear el contexto ligado al modelo

Con la base creada en el próximo POST hablaremos de la tokenización de de la inferencia que es la llamada al LLM para que nos de respuestas.