Technical Documentation

Managed Hosting

Complete web hosting service with personalized support

General Description

De Anda Tech's Managed Hosting service is a complete solution that lets you manage, create and host websites professionally and without complications. We are currently a one-person team (Daniel de Anda) that provides personalized support and direct attention.

Technical Infrastructure

Deployment platforms:
- AWS (Amazon Web Services) through EC2/VPS instances
Domain registration:
- GoDaddy (domain registration and management)
Supported technologies:
- Static sites (HTML, CSS, JavaScript)
- Dynamic applications (Node.js, Python, PHP)
- Databases (MySQL, PostgreSQL, MongoDB)

Team and Support

Current team: 1 developer / administrator (Daniel de Anda)
Support: Personalized and direct attention
Availability: Monday to Friday, flexible hours

Included Services

Initial setup: Hosting environment configuration
Deployment: Publishing websites and applications
Maintenance: Updates and basic monitoring
Technical support: Assistance to resolve incidents
Domain management: DNS and redirects configuration
SSL certificates: Automatic configuration via Let's Encrypt

Costs

Item	Cost
Monthly base cost (hosting + domain)	$215 MXN/month
with employee costs, maintenance and support included (real cost)		$600 MXN/month

Future Projection

Team growth: Plans to add more employees to scale the service to a dedicated server.
Profitability: The business model is designed to be scalable and profitable as the client portfolio grows.
Expansion: Possibility of offering additional plans with greater capacity and resources.

Workflow

The client requests the hosting service
The infrastructure is configured (AWS)
The domain is registered or transferred (GoDaddy)
The website is deployed
GoDaddy credentials are sent and credentials are provided to access the server administration panel
Continuous maintenance is performed
Support and personalized attention

Technical Requirements

Domain: Must be registered or transferable
Content: Website source code (HTML/CSS/JS, backend)
Access: Credentials for DNS management if applicable

MIpunto - POS System

Point of sale system developed in Python with Tkinter

General Description

MIpunto is a point of sale (POS) system developed in Python with Tkinter for the graphical interface. It is designed for sales, inventory, employee and invoicing management in small and medium-sized businesses.

System Structure

Total files: 13 Python files

File	Function
`dashboard.py`	Manages updates, images and files on startup. Controls the main GUI
`config.py`	Manages updates through the API (mipunto-server.vercel.app/api). Checks update.json
`actualizaciones.py`	Manages updates of the executable (.exe) or package (.deb)
`categoria.py`	Manages product categories
`producto.py`	Manages products and their inventory
`proveedor.py`	Manages suppliers
`empleados.py`	Manages system employees
`ventas.py`	Manages completed sales
`factura.py`	Manages invoicing
`recargas.py`	Manages recharges (if applicable)
`registros.py`	Manages system records and logs
`paths.py`	Defines file and directory paths
`lms.db`	SQLite database - Contains all the information. It is downloaded from the API. Without it, the app fails

System Workflow

Application startup -> dashboard.py loads the GUI and checks for updates
config.py connects to the API (mipunto-server.vercel.app/api)
update.json check -> Checks which files need updating
lms.db download -> If it doesn't exist or is outdated, it is downloaded from the API
actualizaciones.py -> Updates the executable (.exe) or package (.deb) if necessary
Data management -> The modules work with the downloaded database

System Requirements

Requirement	Specification
Operating System	Windows (executable .exe) / Linux (package .deb)
Python	Python 3.x (for development)
Database	SQLite (lms.db file)
Internet connection	Required for updates and database download
API	mipunto-server.vercel.app/api

Modules and Features

Dashboard (dashboard.py)

Loads the main interface
Manages image and file updates
Controls the system's central GUI

Configuration (config.py)

API connection point
Checks update.json for new files
Downloads the lms.db database

Updates (actualizaciones.py)

Updates the executable file (.exe on Windows)
Updates the package (.deb on Linux)

Data Management

categoria.py -> CRUD for product categories
producto.py -> CRUD for products and inventory
proveedor.py -> Supplier management
empleados.py -> Employee management
ventas.py -> Sales registration and management
factura.py -> Invoice issuance and management
recargas.py -> Recharge management
registros.py -> System logs and records

Paths (paths.py)

Defines the system's file and directory paths

Database (lms.db)

Stores all the system information
Downloaded automatically from the API
Critical: Without this file, the application fails

Dependencies

Python 3.x
Tkinter (graphical interface)
SQLite3 (database)
Requests (for API connection)
Internet (for updates and DB download)

Installation

Download the executable (.exe) or package (.deb) from the repository or the API
Run the installer
The application will automatically verify the API connection
It will download the lms.db database if necessary
The system will be ready to use

Nova Alfa - Intelligent Assistant

Offline-first intelligent assistant with local AI, voice and automation

General Description

Nova Alfa is an "Alexa-like" intelligent assistant developed in Python, designed to be 100% offline. The project combines:

A local language model using llama-cpp-python
An intent layer based on a serialized classifier (joblib/pickle)
A voice engine with offline fallback (pyttsx3) and natural voice via edge-tts when there is internet
Local speech recognition via pipeline
Wake word "okay nabu" detection with OpenWakeWord
Daily automation features: music, notes, alarms, lists, agenda, weather, research, translation and device control
Robust bootstrapping with folder creation, configuration, network check, update and recovery

Note:

The project is designed for Linux environments to be used on a Raspberry Pi via GPIO and serial ports.

System Flow

Flow diagram

┌─────────────────────────────────────────────────────────────────────────────────────┐
│                                SYSTEM START                                          │
└─────────────────────────────────────────────────────────────────────────────────────┘
                                          │
                                          ▼
┌─────────────────────────────────────────────────────────────────────────────────────┐
│  inicio.py (BOOTSTRAP)                                                               │
│  • Creates directories (txt/, tmp/, notas/, listas/, calendario/, backup/, sonidos/) │
│  • Initializes configuration files                                                   │
│  • Checks internet connection (DNS: 8.8.8.8, 1.1.1.1)                                │
│  • If there is no network, tries to connect Wi-Fi with nmcli                          │
│  • Checks for updates                                                                │
│  • Updates state files (txt/estado_red.txt, txt/version.txt)                         │
│  • Loads customization (txt/personalizacion.txt)                                     │
└─────────────────────────────────────────────────────────────────────────────────────┘
                                          │
                                          ▼
┌─────────────────────────────────────────────────────────────────────────────────────┐
│  main.py (FASTAPI SERVER - Port 8000)                                                │
│  • Runs in the background (subprocess)                                               │
│  • Endpoints: /v1/completions, /health                                               │
│  • MAIN ORCHESTRATOR - Manages the entire flow                                       │
└─────────────────────────────────────────────────────────────────────────────────────┘
                                          │
                    ┌─────────────────────┴─────────────────────┐
                    │                                           │
                    ▼                                           ▼
    ┌──────────────────────────┐              ┌──────────────────────────────┐
    │  wake.py (DETECTOR)      │              │  cliente.py (INTERFACE)       │
    │  • Listens "okay nabu"   │              │  • Console client             │
    │  • OpenWakeWord + PyAudio│              │  • Sends prompts to server    │
    │  • Sends POST to /wake   │              │  • Shows responses            │
    └──────────────────────────┘              └──────────────────────────────┘
                    │                                           │
                    │ (detection)                               │ (user input)
                    ▼                                           ▼
    ┌──────────────────────────┐              ┌──────────────────────────────┐
    │  POST /wake_detected     │              │  POST /chat                  │
    │  • main.py receives event│              │  • main.py receives text     │
    │  • Activates cliente_voz()│             │  • Text or voice mode        │
    └──────────────────────────┘              └──────────────────────────────┘
                          │                                   │
                          └───────────────┬───────────────────┘
                                          ▼
                    ┌─────────────────────────────────────────────────┐
                    │  intencion.py (CLASSIFIER)                      │
                    │  • Loads models/medin_alfa.pkl (joblib)        │
                    │  • Predicts text intent                         │
                    │  • Returns: time, weather, music, alarm, etc.  │
                    └─────────────────────────────────────────────────┘
                                          │
                                          ▼
                    ┌─────────────────────────────────────────────────┐
                    │  ifs.py (INTENT ROUTER)                         │
                    │  • Switch/case of intents                       │
                    │  • Redirects to a specific function             │
                    │  • Handles errors and fallbacks                 │
                    └─────────────────────────────────────────────────┘
                                          │
                    ┌─────────────────────┼─────────────────────┐
                    │                     │                     │
                    ▼                     ▼                     ▼
        ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
        │  funciones.py   │  │  audio.py       │  │  comunicacion.py│
        │  • USB Music    │  │  • Record       │  │  • Serial       │
        │  • Weather      │  │  • Transcribe   │  │  • GPIO         │
        │  • Notes        │  │  • Local ASR    │  │  • Hardware     │
        │  • Alarms       │  │                 │  │                 │
        │  • Lists        │  └─────────────────┘  └─────────────────┘
        │  • Agenda       │
        │  • Local AI     │
        └─────────────────┘
                    │
                    ▼
        ┌─────────────────────────────────────────────────┐
        │  voz.py (VOICE SYNTHESIS)                       │
        │  • edge-tts (cloud - neural voice)              │
        │  • pyttsx3 (local - fallback)                   │
        │  • Plays the response to the user               │
        └─────────────────────────────────────────────────┘

Project Objective

Nova Alfa acts as a personal assistant that can:

Answer general conversations with a local model
Detect the user's intent to route tasks
Activate by voice with the phrase "okay nabu"
Play music from USB or online streaming
Schedule alarms and reminders
Save, read and manage notes
Manage shopping lists and events
Check the weather and research topics
Translate to English
Produce speech with local synthesis or Microsoft Edge TTS neural voices
Transcribe audio from the microphone using a local model
Control hardware or serial states
Start the system, verify the network and run updates
Run on a Raspberry Pi

General Architecture

files

inicio.py handles startup, directory structure, state files, connection check, Wi-Fi, updates and running the main assistant
main.py runs a FastAPI API on localhost:8000 with a completions endpoint
ifs.py acts as the user intent orchestrator and redirects to specific functions
funciones.py contains the assistant's functional logic: music, notes, weather, conversational AI, alarms, lists, agenda, device control, translation and research
voz.py manages audio playback and the fallback between cloud voice and local voice
intencion.py loads the classification model to infer the user's intent
audio.py manages audio recording and transcription with local ASR models
wake.py detects the "okay nabu" wake word using OpenWakeWord
cliente.py provides an interactive console client that consumes the server API
detener_musica.py monitors external audio to stop playback if there is sound outside the assistant
comunicacion.py sends serial signals to external hardware
hadware.py contains the hardware logic for Raspberry Pi

Features:

Music

musica_usb() plays music from the USB/local
musica_online() uses online services if there is a network
reproduccion_especifica_usb() plays a specific song
detener() stops audio

Notes and reminders

tomar_nota() saves text in notas/
leer_nota() returns the content of notes
programar_alarma() and nota_tiempo() manage alarms and reminders

Lists and agenda

agregar_a_lista(), leer_lista(), quitar_de_lista(), limpiar_lista() for shopping
agregar_evento(), consultar_agenda(), eliminar_evento() for calendar

Weather, research and translation

obtener_clima() checks the weather
investigar_tema() performs research
traductor_ingles() translates content

Voice

voz.py:

Reads the language and preferences from txt/personalizacion.txt
Checks txt/estado_de_red.txt
If there is a network, tries to use edge-tts with a neural voice
If there is no network or the cloud fails, uses local pyttsx3
Plays the audio and cleans up temporary files

Hardware and serial

hadware.py allows integration with Raspberry Pi and physical buttons
comunicacion.py sends serial states (hablando, espera, pensando)
detener_musica.py detects external audio via sounddevice

Author and Scope

Nova Alfa is a local/semi-local assistant project developed to automate daily tasks, integrate voice, intent logic, speech recognition, wake word detection and automatic update support.

Frequently Asked Questions

Managed Hosting

What does the $215 MXN base cost include?

The base cost includes managed hosting, a .com/.mx domain, SSL certificate, initial setup, basic maintenance and technical support.

Can I migrate my existing website?

Yes, we offer migration service. The cost depends on the complexity of the current site.

What happens if the website grows and I need more resources?

Resources can be scaled easily. Contact us to get a quote for a custom plan.

MIpunto POS

Which operating system does MIpunto support?

MIpunto supports Windows (executable .exe) and Linux (package .deb).

Do I need an Internet connection to use MIpunto?

Yes, an Internet connection is required for the initial database download and updates. Once installed, it can work offline for local sales, but it needs to connect periodically to sync data.

What happens if the lms.db file is lost?

The application will automatically download a new copy of the database from the API on startup. However, unsynced local data could be lost.

Nova Assistant

What is Nova Alfa?

Nova Alfa is an offline-first intelligent assistant that combines local AI, speech recognition, wake word detection and home automation.

What hardware does Nova need to work?

Nova is designed for Linux and can run on a regular PC or on a Raspberry Pi for GPIO and serial port integration.

Does Nova require an Internet connection?

It is not required. Nova works in offline-first mode. The Internet connection is only used for optional services such as neural voice (edge-tts), weather, research and updates.

How do I activate Nova by voice?

Nova uses the "okay nabu" wake word with OpenWakeWord. Just say "okay nabu" and the assistant will activate to listen to your command.

What models does Nova need to work?

Nova requires three models: modelos/kamutini-5b.gguf (local LLM), modelos/medin_alfa.pkl (intent classifier) and an ASR model in modelo/ for speech transcription.