Systems I have designed and built

The POC is a Python pipeline of decoupled stages, each reading and writing JSON. The request produces a structured prompt for an LLM, which returns only the specification — the model does no calculation. Sizing is deterministic: capacity rules define how many production lines and how many machines of each type the demand requires. The factory is modeled as a discrete 3D grid of cells; each machine occupies a block of cells according to its dimensions and declares typed inputs and outputs on specific faces, like Lego pieces — same type on opposite faces means a compatible connection.

Placement is solved with Google OR-Tools CP-SAT: cell and rotation variables (0°, 90°, 180°, 270°) for every machine, constraints for non-overlap, site limits and mandatory connectivity of every port to a compatible port on another machine; when no arrangement exists, the solver proves infeasibility. This version targets feasibility only — minimizing area, distances and cost is the next stage. A Three.js web interface lets the layout be reviewed and adjusted with magnetic snapping and port validation, and exporters generate a Ruby script for the SketchUp API and an STL file.

CogniFox separates engine from interface: every entity is a JSON document with a Pydantic contract (structural validation) and business rules in dedicated validators (semantic validation) — read-only SQL, a closed node palette and DFS cycle detection, the same algorithm reused for pipelines, for signals between widgets and for dependencies between pipelines. Pipelines are graphs executed by Ibis on DuckDB, with static schema propagation node by node, which feeds the visual editor's autocomplete. Every dataset is materialized, the previous version becomes a backup and the health status (OK, BACKUP, FAILURE) propagates down the chain; an orchestrator infers execution order from data dependencies and APScheduler triggers cron runs.

The web layer is Flask, with projects and files in MinIO and sources in MySQL, PostgreSQL, SQLite, CSV or GeoJSON. Dashboards use Gridstack, ECharts and Leaflet, with signals between widgets that recompute only what is affected, and can be embedded in other systems through a Shadow-DOM Web Component with scoped, revocable JWT tokens. The AI assistant (LiteLLM, provider-agnostic) generates entities from the source's real schema; the answer goes through the same validators as the visual editor and, if it fails, the exact error is sent back to the model for up to three attempts — and the result always lands as a draft, subject to the same human approval. Custom code only enters as a catalogued, approved Script, and pipelines can be covered by JSON test cases without writing Python.

Patas is a Django application on PostgreSQL with PostGIS, for geographic queries such as the distance between sightings, and pgvector, for similarity search between descriptions. Photos live in S3-compatible storage (MinIO, via django-storages); heavy processing runs in the background with Celery and Redis, and celery-beat schedules the periodic match scans. Google sign-in (django-allauth), a Telegram bot with a webhook for volunteers reporting from their phones, hierarchical roles from Level 0 to 5, an audit trail, volunteer scoring, and deployment with Docker Compose and continuous integration on GitHub Actions.

The AI pipeline uses a vision model through LiteLLM — compatible with local models served by Ollama — to check whether the photo is usable and to generate an identification-oriented description. Color and size are extracted with a controlled vocabulary and a Portuguese spaCy dependency parser, which tells apart, for instance, coat color from eye color. The description becomes an embedding, and matching combines cosine similarity, geographic proximity, time proximity and feature overlap (Jaccard) into a weighted score whose breakdown is stored to calibrate the weights with real data. People validate every step: Level 3 reviews descriptions, Level 4 confirms the match and verifies identity by phone before releasing contact, and the public map shows only an approximate area.

GeoProcess is a distributed framework built around a question-and-answer model, split into three decoupled modules: the Portal (Django, with a Bootstrap/AdminLTE, Plotly and OpenLayers front end), the Gateway (FastAPI on Uvicorn) and the Consumers, Python services that actually answer the questions. Portal and Gateway talk over a web API; Gateway and Consumers exchange JSON messages through RabbitMQ (AMQP), in independent, asynchronous flows. Each consumer registers with the Gateway, announcing its project, questions and parameters — new analyses join the system without touching the Portal, and several instances of the same consumer can run in parallel for horizontal scalability.

The Gateway owns security and traceability: users sign in through Single Sign-On (OIDC), the Portal forwards the JWT and the Gateway decides which projects and questions each profile can see, logging every request and answer in PostgreSQL — which is where the history comes from. A shared library provides the consumers' base class and an answer contract that abstracts maps, charts, tables and messages; developers write only the query and the result assembly, while distribution, formatting and access control are handled by the platform. Alerts are scheduled questions that notify only when the answer is not empty, and a Visual Builder lets the answer screen be prototyped with the client (Wizard of Oz technique) and generates the consumer skeleton in Python. Spatial data lives in PostGIS and GeoServer, and operations are monitored with Prometheus and Grafana.

Atena is a Django application on MySQL/MariaDB, served by Gunicorn behind Nginx and authenticated through the university's CAS. The data model is built around learning objects: texts, videos, slides, notebooks, image maps, quizzes and problems inherit from a common base type, and each learning path is a graph in which every node points to the next one according to the result of the answer — correct, partial, incorrect, or the option chosen in a quiz. Paths can be drawn in a visual editor and are validated before publishing. Problems accept Python, Java, C and C++ and run in three modes: in the browser with Pyodide, as blocks with Blockly, or on the server inside an AppArmor-confined sandbox, with an execution pool controlled by locks and time limits.

Graded activities compare output against test cases — with similarity algorithms such as Levenshtein and Smith-Waterman — and inspect the syntax tree to require specific functions and parameters; exams can be restricted by IP and unlocked with a TOTP code. Atena Tutor is a separate service (Flask, SQLAlchemy/Alembic, PostgreSQL, Docker) with federated login through signed JWTs. An LLM generates reference solutions that are accepted only after passing the test cases, retrying from the detailed error; the flowchart is derived from the AST without AI, and the LLM only labels blocks already delimited by the parser — it never rewrites the code. Comprehension checks compare the student's answer using local embeddings, hints unlock by attempts and elapsed time, and analytics dashboards are integrated with CogniFox.

Home devices — lamps, outlets and appliances — are driven by ESP8266 microcontrollers that talk to a central broker over MQTT, a lightweight publish/subscribe protocol suited to home networks. Every interface publishes commands using the same topic scheme, so new interaction methods can be added without touching the devices. The first version is a Java (JSP) web application with per-room pages designed for screen readers; the latest version was rewritten in Python with Django.

End-user programming uses Blockly, with custom trigger blocks (time, sensors, appliance state) and action blocks, translated into rules run by the hub. The glove pairs an ESP8266 with the MPU-6050 accelerometer and gyroscope to recognize hand gestures; camera control uses TensorFlow.js with transfer learning on a pre-trained network, trained in the browser from a few of the user's own examples; and voice commands go through CoGrOO, a Portuguese language analyzer that extracts the action and the device from the sentence before it becomes an MQTT message. For people with severe motor limitations, an Emotiv EPOC+ EEG headset (14 channels, over Bluetooth) captures per-user trained mental commands that become home actions over the same MQTT bus; usability was evaluated with 30 participants using a think-aloud protocol and video analysis.

Each collar has an ESP8266 microcontroller with an MPU-6050 accelerometer and gyroscope, measuring angles and accelerations on three axes; a Kalman filter fuses both readings to estimate tilt with less noise. Collars exchange messages over ESP-NOW, a peer-to-peer protocol that needs no Wi-Fi router, and a collector node forwards the data over MQTT or serial to a Raspberry Pi station. Bluetooth links and direct collection on a phone were also tested, with a Flutter app used to label the behavior observed in the field.

For classification, each sample is a window of 100 readings of each signal; features are standardized and reduced with PCA and LDA, and logistic regression, linear and RBF-kernel SVM, decision tree, Random Forest and KNN were compared with cross-validation and hyperparameter search in scikit-learn pipelines. In the tests with dogs, the best models reached about 77% accuracy on the test set, on a still small dataset. A Streamlit dashboard reads the data in real time and fits polynomial regression curves to visualize each movement.

In each vehicle, an Android phone provides the GPS position to an ESP8266 microcontroller node, which talks to the others over ESP-NOW, a low-latency peer-to-peer protocol that needs no router. Nodes periodically exchange position, speed and a trust index for each neighbor, and relay messages with hop-count and retransmission control, with rules for disseminating accident alerts without flooding the network. The firmware also implements a mode following the European ETSI standard for cooperative vehicular messages, used as a comparison baseline.

A Java desktop application receives node data over sockets, shows vehicles on a map, generates reports and can emulate nodes, and integrates with the SUMO traffic simulator to test the protocol with vehicle flows on routes at 20 to 60 km/h. In field tests, each node logs its own and its neighbors' positions in JSON; Python scripts compare what each car knew about the others with their real positions, compute error and trust per node pair, and export GeoJSON and KML for visualization. Android and Flutter apps let the nodes be followed on a phone.