Products & Engineering Projects

Project overview

Awaita is a private, production-oriented AI guide for Menorca. My work focuses on the conversational product layer: grounded answers, RAG logic, retrieval quality, evaluation, safety controls, observability, deployment flow, and continuous improvement from real usage. The public landing, events experience, and broader web presentation are team-owned areas, with another teammate leading much of that outward-facing work.

My Contribution

• Owned the chatbot logic that turns curated Menorca knowledge into useful, grounded, multilingual answers
• Designed and tuned the retrieval workflow so the assistant can answer from controlled sources instead of generic model memory
• Built evaluation loops for retrieval quality, reranking decisions, prompt behavior, and generated-answer quality before product changes reach users
• Implemented safety and abuse controls around sessions, protected requests, user identity, feedback, rate limits, and public error handling
• Connected feedback, analytics, latency, cost, and quality signals so production conversations can be improved from evidence
• Maintained staged CI/CD workflows and operational checks for controlled releases to staging and production
• Collaborated with teammate-led web areas such as landing, events, and public content presentation while focusing on AI/backend reliability

Public Technical Scope

Real-world application

Awaita aims to become a virtual tourist guide for Menorca: a practical companion that helps visitors discover places, understand local context, plan better routes, and ask natural questions before or during their trip. The goal is to make island knowledge easier to access through a conversational experience that feels useful, local, and trustworthy.

Project overview

SoloGangas is a live deal-discovery platform that I designed and operate end to end. It runs a public website alongside a Telegram community of 2K+ subscribers, with automated processing, AI-assisted content workflows, a database-backed backend, monitoring and CI/CD.

Engineering Highlights

• Runs continuously in production across its website and a Telegram community with 2K+ subscribers
• Automates the full deal lifecycle — processing, enrichment, publication and maintenance across channels
• Database-backed backend as the operational source of truth for reliable asynchronous workflows
• Containerized, staged CI/CD with automated validation, health checks and recovery safeguards
• Monitoring, alerting, backups and maintenance built for unattended operation
• AI treated as one component inside a larger system, with validation and graceful failure paths around external dependencies

Technical Implementation

Real-world application

SoloGangas helps a real audience discover and follow online deals through its web catalogue and Telegram. For me it is a long-running production environment where automation, reliability and maintainability matter as much as the AI parts of the pipeline.

Project overview

OpenCode Permission Reviewer is an unofficial community plugin for OpenCode that reviews every `ask` permission instead of waiting for a keystroke on safe, routine actions. A dedicated, tool-free child session reads the pending request, bounded transcript evidence, recovered user intent, and a review policy you control, then allows once, denies with rationale, or escalates to the human. Critical risk is never auto-approved, and anything broken or uncertain fails safe to manual review.

Safety Model

• Intercepts `permission.asked` events and reviews only actions already classified as `ask` — `allow` and `deny` policy never reaches the model
• Runs a deterministic emergency brake before any model call: quote-aware, wrapper-aware shell analysis catches root destruction and direct credential export patterns
• Builds bounded, redacted evidence from recent transcript, recovered user intent, and optional read-only SSH / local-script / Git enrichment without modifying the filesystem
• Invokes a tool-free child reviewer session that cannot call tools or request permissions recursively, then enforces hard decision invariants in code
• Auto-approvals are always `once` (never `always`), with rationale annotated onto the tool result; denials return feedback the agent can use
• Lets a human keystroke mid-review supersede the automatic decision without double replies or stale annotations
• Optional SolidJS TUI overlay shows reviewing / approved / blocked state with confidence and rationale, while a broken TUI transport never changes the safety outcome
• Writes one JSONL audit record per review (mode 0600), hashing remote SSH commands as SHA-256 instead of storing plaintext

Technical Implementation

Real-world application

The plugin is useful when you run OpenCode with a real permission policy and get tired of pressing Enter on safe, reversible actions — while still wanting destructive, networked, or poorly justified commands to stay blocked or surfaced. It is a defense-in-depth aid for daily agent work, not a sandbox substitute: the point is fewer interruptions on routine asks without handing the agent a blank check.

Project overview

OMP Guardian is an unofficial community extension for Oh My Pi (OMP) that shadows Bash and inspects sensitive tool calls, asking a separate tool-free model process for one structured decision: allow, deny, or escalate. Routine reads, bounded workspace writes, and recognized local tests take a cheap deterministic route, while network access, deletion, Git mutation, package lifecycle execution, privilege changes, remote operations, protected-path access, and unknown tools go through model review or an emergency brake.

Safety Model

• Shadows OMP's Bash tool and delegates to native Bash exactly once, only after an allow decision — it does not implement an independent shell
• Routes routine reads, bounded workspace writes, and recognized local tests through a cheap deterministic fast path instead of the model
• Runs a deterministic emergency brake before any model call: unmistakable root destruction, destructive block-device operations, fork bombs, configured executables, and obvious credential exfiltration are rejected outright
• Reviews network access, deletion, Git mutation, package lifecycle execution, privilege changes, remote operations, protected-path access, browser input, Python/notebook execution, MCP tools, and unknown tools
• Spawns a fresh `omp -p` child reviewer with tools, saved sessions, skills, rules, LSP, PTY, title generation, and prewalk disabled, inheriting only the selected model and thinking level
• Fails closed on invalid output, timeout, provider failure, missing model, or unavailable manual review — broken never becomes an approval
• Writes append-only mode-`0600` JSONL audit records with an action hash instead of the raw command; secrets are redacted before they ever reach the reviewer provider
• Per-session circuit breaker stops the active turn after three consecutive or twenty cumulative denials

Technical Implementation

Real-world application

The extension is useful when you run OMP with real approval boundaries and want fewer interruptions on safe, reversible actions — while still forcing destructive, networked, remote, or poorly justified operations through an independent review or a hard block. It is explicitly defense in depth, not a sandbox or a replacement for operating-system isolation: the point is safer auto-approval behavior without handing the agent a blank check.

Project overview

Contextarium is a local-first context, memory, and RAG layer for coding agents. It runs a FastAPI web panel and an MCP-compatible HTTP/JSON-RPC endpoint so agents can search indexed documentation, retrieve source chunks, and manage durable project memory without relying on a hosted service.

Core Capabilities

• Runs a local control panel for dashboard status, RAG ingestion, MCP tool toggles, project memory, configuration, and logs
• Ingests documentation from a sitemap or a `txt/` URL list, then crawls, chunks, embeds, and atomically replaces the DuckDB RAG index
• Exposes MCP tools for `hybrid_search`, `chunks_by_url`, and project-scoped item management through HTTP/JSON-RPC
• Stores long-lived project memory, docs, bugs, and todos in SQLite with typed metadata, statuses, direct editing, search, and diff-based doc patching
• Combines dense and lexical retrieval with MMR, optional reranking, output schemas, and graceful degradation when local extensions or rerankers are unavailable
• Provides ready-to-copy integration snippets for Codex CLI, Claude Code, and GitHub Copilot in VS Code
• Supports local and cloud embedding modes, Docker deployment, repository checks, and explicit local-only security guidance

Technical Implementation

Real-world application

Contextarium is useful when a developer wants coding agents to keep project context, decisions, docs, bugs, and todos close to the local workspace. The point is controlled context: choose what to index, choose which tools an MCP client can call, and avoid turning private project memory into an external hosted dependency.

Project overview

XLFusion is an open-source Python toolkit for reproducible SDXL checkpoint merging. It replaces ad-hoc local scripts with repeatable CLI, GUI, batch, analysis, metadata recovery, and checkpoint algebra workflows, with a strong focus on validation before long-running local work and metadata that explains how each checkpoint was produced.

What It Does

• Merges SDXL-derived `.safetensors` checkpoints through legacy, per-resolution, and hybrid merge modes
• Bakes compatible LoRA weights into UNet and text-encoder targets with an auditable report
• Runs preflight validation before execution, covering memory estimates, backbone compatibility, affected blocks, locks, component scope, warnings, and risk alerts
• Supports interactive CLI, GUI, and YAML batch execution from the same validation and runtime contracts
• Saves reusable presets, batch-compatible YAML, embedded metadata, and recovery folders so previous runs can be inspected and recreated
• Adds analysis utilities for checkpoint similarity, compatibility, dominance by region/submodule, merge recommendations, and checkpoint algebra
• Keeps behavior protected with fast unittest coverage, synthetic safetensors fixtures, a smoke-test path, and GitHub Actions CI

Technical Implementation

Real-world application

The project is aimed at SDXL users and maintainers who need repeatable local experiments. Instead of relying on one-off merge scripts and undocumented outputs, XLFusion makes the merge plan, execution settings, source models, metadata, and recovery path explicit enough to review later or rerun from a batch config.

Project overview

Mas Palabras is a personal vocabulary app for collecting words while studying, reading, working, or living in another language. It turns scattered notes, spreadsheets, screenshots, and chat messages into a structured personal lexicon with language and tag organization, search, JSON import/export, and adaptive quiz practice for words that need review.

Core Workflows

• Create vocabulary entries with source word, translation, explanation, language, and tag
• Normalize source words to prevent duplicates within the same language
• Browse the lexicon with search, language filters, tag filters, pagination, sorting, editing, deletion, and bulk deletion
• Practice through quiz sessions targeting all words, new words, or entries that need review based on attempts and accuracy
• Import JSON vocabulary lists with duplicate handling, missing-language/tag options, flexible date parsing, and per-item incident reporting
• Export the full vocabulary as JSON so study data stays portable
• Switch the interface between English, Spanish, and Catalan through a cookie-backed language selector

Technical Implementation

Real-world application

The app is built for local study and data ownership. Its value is not just adding words, but keeping vocabulary searchable, reviewable, exportable, and organized enough to become a living personal dictionary rather than another scattered notes file.

Project overview

Examino is a local-first Flask app for building and practicing multiple-choice exams from private question banks. I originally built it in 2023 while studying DAW, so it is intentionally presented as an earlier-stage project with a simpler codebase than my more recent work. In 2026 I revisited it to fix bugs, improve the public repository, add bilingual UI support, harden the local workflow, and prepare it as an app that anyone can clone and run locally.

Current Capabilities

• Generate multiple-choice tests by subject, topic, and number of questions
• Choose between deferred correction and immediate correction mode
• Shuffle answer options while preserving the correct-answer mapping
• Grade answers with omitted-question handling and standard penalty logic
• Browse loaded questions by subject and topic before creating a test
• Add custom questions from the web UI for local study databases
• Customize the base subject/topic catalog from YAML and reload ignored private question-set scripts
• Switch the interface between English and Spanish

Technical Implementation

Real-world application

Examino is useful when a student wants to keep their own question bank private and practice locally without accounts or cloud storage. The repository ships only a neutral sample catalog; real subjects and questions are expected to stay in the user’s local database or ignored local scripts.

Project overview

MIDAS (Multi-agent Intelligent Data Automation System) was my Master’s Thesis Project: a modular multi-agent platform for automating the data science lifecycle. The project combines synthetic dataset generation, natural-language chart creation, automated ML training, model evaluation, deployment helpers, and RAG-based documentation assistants into an eight-component ecosystem.

Key Features

• Eight specialized modules covering Dataset, Plot, Touch, Test, Deploy, Assistant, Architect, and Help workflows
• Synthetic dataset generation with AG2 agents, Faker, Spanish localization, editable outputs, and CSV/Excel export
• Automated ML workflow that loads CSV, Excel, Parquet, or JSON files and infers target column and problem type from natural language
• Adaptive preprocessing, model selection between RandomForest and GradientBoosting, cross-validation, metrics, serialized models, and generated notebooks
• Natural-language chart generation with CrewAI Flow, matplotlib code generation, and secure execution through an E2B sandbox
• RAG assistants for technical documentation, framework guidance, and project support using LlamaIndex, reranking, and model routing

Technical Implementation

Real-world application

The project was built as a complete TFM showcase rather than a single demo app. Its goal was to make ML workflows more accessible by turning common data science tasks into guided, conversational modules that can be inspected, adapted, and run independently from the source code.

Project overview

LLM StoryTeller is a Streamlit app for generating stories through a guided three-step LLM workflow: outline, narrative writing, and final review. It includes a local version for OpenAI-compatible model endpoints and a Streamlit Cloud version backed by OpenRouter free models.

Features

• Structured three-step generation pipeline: outline creation, story writing, and review/refinement
• Separate model selection for each generation step
• Local mode for OpenAI-compatible endpoints running at `localhost:7860`
• OpenRouter cloud mode for Streamlit deployment using free hosted models
• Fallback system that tries alternative OpenRouter models when the selected one is unavailable
• User controls for characters, setting, key action, language, story length, genre, and temperature
• Story cleanup, HTML escaping before render, and one-click `.txt` download

Technical Implementation

Project overview

Chatbot CV implements two Flask chatbot versions for querying my curriculum: a RAG implementation with LlamaIndex and a full-context implementation using Gemini. The project compares retrieval-based answers against loading the complete CV into a large context window, while also experimenting with automatic prompt classification.

Dual Architecture

• RAG approach: LlamaIndex with Groq Llama 3.3 70B, DeepInfra BGE-M3 embeddings, and persistent vector storage built from the CV markdown file.
• Context-window approach: Gemini 2.0 Flash / Flash-Lite through LiteLLM, with the full CV loaded into the system prompt instead of retrieving chunks.
• Prompt classifier: Spanish BERT sequence classifier that routes simple, complex, and out-of-scope questions to the appropriate handling path.
• Session-aware API: Flask backend with localStorage session IDs, conversation history, concurrent-request protection, and a clear-history endpoint.

Technical Implementation

Key findings

RAG keeps token usage lower and scales better to larger knowledge bases, but depends heavily on chunking and retrieval quality. The full-context version is simpler and more globally aware of the CV, but depends more directly on model context limits and API cost.

Project overview

Fox-Detector is a binary image-classification project built with Keras and a fine-tuned DenseNet121 backbone. It prepares a labeled dataset of fox and non-fox images, trains a transfer-learning model, and classifies new image batches into fox / non-fox folders.

Key Features

• Dataset normalization script that resizes images to 256x256 and converts them to RGB
• CSV generation mapping each image filename to a binary fox / non-fox label
• Class balancing through oversampling before the train/validation split
• Transfer learning with DenseNet121 ImageNet weights and custom dense/dropout layers
• Data augmentation with rotation, shifts, shear, horizontal flip, and brightness changes
• Inference script that sorts images from `todas_imagenes` into `si_es_zorro` or `no_es_zorro`

Technical Implementation

Project overview

Hard Drive Failure Prediction is a binary classification project built on Backblaze hard-drive reports from 2018 through Q2 2024. It predicts whether a drive is likely to fail using normalized SMART attributes, storage capacity, and manufacturer information extracted from model names.

Key Features

• Backblaze quarterly data ingestion covering 2018 to Q2 2024
• Failure-row aggregation to reduce the severe class imbalance in daily HDD reports
• Feature selection focused on 13 normalized SMART attributes plus capacity and manufacturer
• Manufacturer extraction from HDD model names using Llama 3.1 70B through Groq
• RandomForest and XGBoost training with GridSearchCV optimization
• Weighted ensemble thresholds tuned separately for F1 score, precision, and recall
• Alert-style test script that turns ensemble outputs into practical maintenance recommendations

Technical Implementation

Project overview

XLSX to JSONL is a small Python utility for turning Excel datasets into JSONL files ready for ChatGPT fine-tuning. It reads one or more sheets from an `.xlsx` file, treats the first column as user prompts and the second column as assistant responses, then writes role-based training and validation files.

Key Features

• Automatic `.xlsx` discovery with interactive file selection when several spreadsheets exist
• Multi-sheet processing with separate JSONL outputs for each sheet
• System role prompt applied to every generated conversation example
• Configurable train/validation split from the command line
• Optional row shuffling before dataset splitting

Technical Implementation

Project overview

Gather-Tracker is a lightweight browser script for monitoring a Gather Town office from the web client. After configuring a target user, Telegram bot token, and chat IDs, it reports connection status, movement between office zones, and new chat messages in real time.

Key Features

• Two script variants for Gather's old chat UI and beta/new chat UI
• Telegram alerts for initial state, connect/disconnect events, and room changes
• Configurable coordinate-based zones for mapping office rooms
• Chat forwarding for public, local, and private messages using separate Telegram chats
• Helper functions to discover player IDs and current map coordinates from the browser console

Technical Implementation