Technical documentation

The complete architecture behind Nyeera.

Hardware, operating system, inference engine, RAG orchestration and the languages behind every layer — all in one place, with the repository open for inspection.

Illustration of the Nyeera Project: a figure exhales a breath that turns into symbols of knowledge and digital circuits

The forgotten machine

The only component that was added was the SSD drive. The goal of the study was to measure what this specific configuration can actually sustain.

Processor
Intel Core i5 (legacy)
An office-grade generation, without modern vector instructions relevant to inference.
RAM
16 GB
Shared between the OS, the vector index and the loaded model — the most contested resource in the system.
GPU
No dedicated GPU
Graphics integrated into the processor, with no usable VRAM for inference acceleration.
Storage
Local HDD + SSD
Holds the quantized model weights and the vector index persisted to disk.
Network
Optional / offline-first
The pipeline works without an internet connection after the initial document indexing.
Machine profile
Ordinary office workstation
Represents the hardware already available in small operations, not a dedicated test machine.

Software layers chosen by weight, not by trend

Every component was evaluated by what it consumes at rest and under load. Wherever there was a choice between "more complete" and "lighter", the lighter one won by default.

Operating system

Linux, minimalist distribution

A lean install, with no mandatory graphical environment, cutting the system's own idle RAM usage before the pipeline even starts.

Inference engine

llama.cpp (via Python bindings)

A C/C++ runtime specialized in CPU inference for quantized LLMs, with no dependency on CUDA or GPU drivers.

Vector store

Local index (FAISS / Chroma)

Storage and similarity search running embedded in the process, with no external database server.

Service layer

Local API in FastAPI

A lightweight HTTP service exposing the RAG pipeline, letting the model be integrated into other applications without rewriting the inference logic.

From the HTTP request to the generated token

The stack in layers, top to bottom — from the interface the user touches to the hardware that actually runs the model.

Presentation
Static frontend

HTML/CSS/JS pages — like this one — for documentation, demos and direct consumption of the service.

HTML5CSS3JavaScript
API
Application service

Query and document-ingestion endpoints, with input validation and streamed responses.

PythonFastAPIUvicorn
RAG orchestration
Retrieval & generation pipeline

Chunking, query routing, prompt assembly with retrieved context, and the call to the inference engine.

PythonLangChain / LlamaIndex
Embeddings
Text vectorization

A compact embedding model that turns documents and queries into comparable vectors.

sentence-transformersONNX Runtime
Vector index
Similarity search

Local storage of vectors with approximate nearest-neighbor retrieval.

FAISSChroma
Inference
Quantized model execution

Loading and running the LLM in GGUF format, with explicit control over CPU threads.

llama.cppC / C++
System
Oerating System

Ubuntu Server. 7.0.0-29-generic #29-Ubuntu

LinuxUbuntu
Hardware
Mac Mini late 2012

CPU Intel Core i5-3210M (dual-core, 4 threads). Memory RAM 16GB PC3-12800 DDR3. Integrated GPU Intel HD Graphics 4000 (not being used). Storage: SATA HD 5400-rpm. Kingston NV3 NVMe M.2 on external case

CPU-onlyNVMe
Technology Category Role in the project
Python 3.xMain languagePipeline orchestration, the API, and indexing scripts.
C / C++Low-level languageCore of the inference engine (llama.cpp), critical for CPU performance.
llama.cppInference engineRuns the quantized LLM (GGUF) without depending on a GPU.
LangChain / LlamaIndexRAG orchestrationChains context retrieval and response generation.
sentence-transformersEmbeddingsGenerates the vectors used in similarity search.
FAISS / ChromaVector storeLocal indexing and search of the context vectors.
FastAPI + UvicornAPIExposes the pipeline as a local HTTP service.
HTML / CSS / JavaScriptFrontendDocumentation and demo interface for the project.

The repository is open for inspection

The entire pipeline — indexing scripts, inference-engine configuration, and the API — is versioned publicly.

github.com/elmironeto/nyeera/

Case study and reference implementation for local RAG on constrained hardware: no dedicated GPU, 16GB of RAM, legacy CPU.

MIT License Python 3.x CPU-only llama.cpp
# clone the repository git clone https://github.com/elmironeto/nyeera/ cd nyeera # install dependencies pip install -r requirements.txt # start the local API docker compose up -d

An architecture built to be audited, not just demoed.

Every layer of this stack exists for a reason tied to cost — memory, latency, or network dependency. The code in the repository is the proof.