class AIEngineer:
name : str = "Enock Mumo"
location : str = " Nairobi, Kenya"
role : str = "AI Engineer | Systems Architect"
background : str = "Transitioned from MERN stack into full AI engineering"
focus : list = [
"End-to-End AI Pipelines",
"Computer Vision — Floor Plan Intelligence",
"RAG Systems with Local LLMs",
"Custom Transformer Architectures",
"FastAPI x React x Mobile Integration",
]
philosophy : str = "I don't just train models — I build systems that think."
def build(self, problem: str) -> str:
return f"Input({problem}) -> Model() -> Processing() -> Output() -> UI()""A model alone is not a product.
A system that ingests, reasons, and delivers — that is engineering."
I design and ship AI systems where every layer is intentional. Raw data pipelines feed battle-tested ML models, results surface through clean APIs, and users interact through polished interfaces. The gap between a Jupyter notebook and a real-world AI system is exactly where I operate — and where I thrive.
Architects and engineers produce thousands of floor plan drawings that exist as raw images — unstructured, unsearchable, and disconnected from modern Building Information Modeling pipelines. Manually extracting spatial data such as rooms, doors, windows, and walls is expensive, slow, and deeply error-prone. This system eliminates that bottleneck entirely.
The pipeline ingests raw floor plan images from the CubiCasa5K dataset — over 5,000 professionally annotated architectural drawings — and passes them through the FloorTrans model, a transformer-based segmentation architecture designed specifically for the structured geometric complexity of architectural drawings. Unlike traditional CNNs, FloorTrans preserves spatial relationships across walls, corridors, and rooms, making segmentation far more accurate at scale.
Output is emitted as structured JSON encoded with room polygons, connectivity graphs, and element classifications — fully compatible with IFC (Industry Foundation Classes) for direct BIM ingestion. A Matplotlib visualization layer renders labeled overlays on top of the original image, and a cross-platform Tkinter desktop GUI gives non-technical architects the ability to run inference locally with zero command-line exposure.
Stack — Python · PyTorch · FloorTrans · CubiCasa5K · OpenCV · PIL · Matplotlib · Tkinter · JSON/SVG
Standard large language models hallucinate. They have knowledge cutoffs. They cannot reason over private documents. RAG solves all three simultaneously: by grounding generation in retrieved, verified context from your own data, responses become accurate, auditable, and domain-specific — without sending a single byte to an external server.
This system is built with LangChain as the orchestration layer and Ollama to run large language models fully offline — Llama 3, Mistral, and Phi-3 depending on the task. Documents in PDF, Markdown, or plain text are chunked using a recursive semantic splitter, embedded with nomic-embed-text running locally via Ollama, and stored in a persistent FAISS or ChromaDB vector index on disk.
At query time, the user's question is embedded and compared against the vector index using cosine similarity. Top-K candidate chunks are retrieved, re-ranked using a cross-encoder to eliminate noise, and injected into the prompt context before the local LLM generates its grounded response. The entire loop — from query to answer — runs on a single machine with zero internet dependency.
A FastAPI backend exposes streaming endpoints so the frontend receives tokens in real time, matching the feel of cloud-hosted systems while remaining completely private. This architecture is production-deployable for enterprise knowledge bases, legal document Q&A, offline medical reference, and secure government document processing.
Stack — Python · LangChain · Ollama · FAISS · ChromaDB · FastAPI · nomic-embed-text · Llama 3 · Mistral
The only way to truly engineer on top of large language models is to understand what happens inside them at every layer. This project implements a decoder-only transformer — the GPT architecture — from scratch using pure PyTorch, with no Hugging Face wrappers, no shortcuts, and no abstraction hiding the mechanics.
The implementation covers a custom BPE tokenizer trained on the target corpus, multi-head causal self-attention with masking, GELU-activated feed-forward blocks, residual connections, layer normalization, and a full language model head for next-token prediction. The training loop includes cosine learning rate scheduling with linear warmup, mixed-precision training via PyTorch AMP, and gradient checkpointing for memory efficiency on constrained hardware.
Text generation supports temperature scaling, top-k sampling, and nucleus (top-p) sampling — giving precise control over creativity versus coherence. Every component is hand-implemented and documented so the architecture is fully auditable and extensible for fine-tuning, distillation, and domain adaptation experiments.
Stack — Python · PyTorch · Custom BPE Tokenizer · Mixed Precision AMP · Cosine LR Scheduler
A production-grade inference system that connects trained PyTorch models to a live API backend and multiple client surfaces — React web, Flutter mobile, and React Native — through a single unified FastAPI server. This is where ML engineering meets software engineering at full scale.
The FastAPI server loads the model once at startup via dependency injection, exposing async endpoints validated by Pydantic schemas. Long-running inference jobs are offloaded to a background task queue so the API remains non-blocking under load. WebSocket support enables real-time streaming predictions to connected clients, delivering token-by-token or frame-by-frame output without polling overhead.
The React frontend displays live inference feedback with a clean interface, Flutter handles on-device UI with native performance, and the whole stack is containerized with Docker for reproducible, portable deployment across any environment.
Stack — Python · PyTorch · FastAPI · Pydantic · WebSockets · React · Flutter · React Native · Docker
# enock@Nairobi:~$ cat current_objectives.log
[DONE] Floor Plan Intelligence System — v1 shipped, BIM export in progress
[WIP ] RAG System — hybrid search + cross-encoder re-ranking
[WIP ] Custom GPT — scaling architecture, tokenizer improvements
[NEXT] Multi-modal AI Pipeline — vision + language unified system
[NEXT] AI-powered Mobile App — Flutter + on-device inference
