My Projects
1.
This portfolio is a project written in pure TypeScript. No front-end framework was used. It is a server-based full-stack project that uses Elysia.js, the framework's HTML renderer, and HTMX for front-end interactions.
By the time you got here, you shouldn't have received even 80 kilobytes of JavaScript!
All the interactivity and the Single Page App simulation is done through HTMX's swap mechanism, which, using the parameters collected on the page, triggers the Elysia server to render the HTML and transfer the page contents in full.

For comparison: while a site built in React makes you download at least 2 megabytes of JavaScript (that's the Bundle), on this portfolio's site you download just 50 kilobytes, coming from HTMX.
On top of the optimization, the developer experience is comparable to developing in React, since JSX is used, but in a simpler approach that avoids all the bloat of React or front-end frameworks.
Code from src/core/render.ts: the render function, used as the JSX factory, creates the element with typed-html and minifies the HTML
The JSX factory: every component compiles to a call to this function and comes out as minified HTML, no React
Code of the NavItem component in src/components/Navbar.tsx: a JSX link with the hx-get, hx-swap, hx-target and hx-push-url attributes
A JSX component with HTMX attributes: navigation without page reloads and without a front-end framework
Code from src/pages/index.tsx: the list of pages and pageRouter, which registers one Elysia route per language rendering the page in JSX
Each language's routes render the JSX pages straight on the server, with Elysia
2.
cli-authenticator is a TOTP (2FA) authenticator for the terminal, written in plain Node.js. Codes show up as soon as the CLI opens, and new accounts come in from a QR code screenshot, a file or the camera, including Google Authenticator exports, which arrive split across several QR codes.

The focus was security: secrets live in a vault encrypted with AES-256-GCM, with the key derived from the master password via scrypt and never written to disk. Everything coming in is treated as untrusted input: legacy files are parsed as text (never executed), names from QR codes are sanitized against terminal escape-sequence injection, and copied codes are kept out of clipboard history.

The interface is drawn with plain ANSI sequences, no TUI framework, including the camera preview, rendered with Unicode half-blocks. QR decoding uses ZXing compiled to WebAssembly, running locally, and the camera is accessed through ffmpeg on Windows, macOS and Linux.
cli-authenticator demo: live TOTP codes, copying a code and adding an account from a QR code screenshot
Live codes, copying and importing from the clipboard
Scanning a Google Authenticator export with the camera
Accounts and codes are fake, generated for the demo.
3.
Multi-Agent Fluid Conversation Manager is a platform for creating conversational agents trained on your own content, integrated with multiple LLMs and written in Elixir, with Phoenix and OTP. It brings together my back-end and AI experience, and it is a simpler version of the chatbot management and deployment system I built for Elife.

The architecture is event-driven: everything that happens in the system (an answered message, a model call, training progress) becomes an event on Phoenix PubSub. Persistence, token accounting, webhooks and a live WebSocket channel are independent subscribers, and a failure in one of them does not affect the others.

Each conversation runs in its own supervised process: messages from the same user are handled in order, different users in parallel, the history stays in memory, and inactivity notices are the process's own timers, with no cron. If the server goes down mid-training, the coordinator rebuilds its queue from the database when it comes back up.

Answering and training are composable pipelines, declared as a list of steps. Each step can be conditional, retried, time-boxed in a supervised task or run in parallel with others (language detection and semantic search run at the same time), and steps can be replaced, inserted or removed at runtime or through configuration.

Models are swappable: each one is addressed as provider:model (OpenAI, Anthropic, Gemini or local models through Ollama), and switching an agent's model is a single PATCH, even mid-conversation. Each provider can have its own rate limiting, with retries that respect the API's limits.

RAG runs semantic search over embeddings in PostgreSQL with pgvector, and agents can call tools, local ones or from any MCP server (over stdio or HTTP). Conversations can be handed off to a human agent when integrated with an external system, and the test suite runs without a database or network, using in-memory storage and a fake model provider.

Technologies: Elixir, Phoenix, PostgreSQL + pgvector, Ollama and MCP.
ai-agent-manager demo: a conversation with a trained agent that answers from its own content, uses the conversation history and calls a tool to get the time
Chatting with a trained agent: RAG, history and a tool
ai-agent-manager demo: events published live during training, the pipeline steps, the model calls, a tool call and a model swap mid-conversation
Under the hood: live events, pipeline steps and a model swap
Real recordings with local models (qwen2.5 and embeddinggemma through Ollama, on CPU); waits for the model were shortened.
4.
Public Administration Protocol Control System is a project that resulted from two undergraduate research scholarships and was finished and deployed as the outcome of my capstone project at IFPB.
In this project I was able to use the knowledge I had at the time, which was based on the newest technologies available for the language and data structures. The system had to handle high traffic and high processing performance due to the software's heavy usage. Every department/office of the city administration can integrate with the tool to process protocols quickly and efficiently.

The system was built using the MERN stack. MongoDB, Express, Angular and Node.js. At the time of the software's initial development I got to work with the early version of Angular.js (1.8.x, beta-2.x), and this project was where I improved a lot as a full-stack developer, since it was the first time I built front-end and back-end together for the same project, at the same time.
5.
Online General Word Meaning System was a project for which I was awarded an undergraduate research scholarship, where the focus was clustering linguistic meanings.
It was a system built for complex linguistic research, which collects information from several sites and automatically organizes it into a leaner report for the researcher. It also emphasized making research easier for deaf researchers, using the V-Libras system, which turns the generated report into a video of a character translating the text into Brazilian Sign Language (Libras).

This project was fundamentally a front-end that ran a series of optimized scraping routines across several sites. It used plain JavaScript for page routing, and Puppeteer e Cheerio for scraping.
More projects
Let's talk about my other projects and new ones! You can find ways to reach me in the Contact section.
Get in touch:
Website made with by Pedro Casado
© 2026