Projects

ColombiAsk (Coming Soon!)

Developed a robust Query History Logger for ColombiAsk, a natural language interface for the CÓDIGO genetic variant database, to enable systematic benchmarking and performance auditing of LLM-generated queries. Using Python logging and json, the system captures a comprehensive audit trail of the Llama 3.1-driven pipeline, including generated PostgreSQL syntax, execution rationale, and retrieval metrics such as row counts and latency. This infrastructure is critical for delivering researcher-grade genomic insights, since it supports side-by-side accuracy comparisons across model scales (for example, 8B vs. 70B) and improves transparency for complex joins executed on Georgia Tech's PACE supercomputing cluster. By centralizing model configurations and SQL outputs into structured, date-stamped logs, I streamlined debugging for multi-turn SQL generation and created a scalable foundation for a known-good test set that ensures fully auditable interactions with high-stakes genetic data.

Built with: Python, Llama 3.1, PostgreSQL, JSON Logging

BrokerCheck-Scraper

FINRA BrokerCheck API Scraper is a high-performance data extraction utility developed in Go that reverse-engineers the internal BrokerCheck API to gather comprehensive individual broker data. By targeting the https://api.brokercheck.finra.org/search/individual endpoint, the script performs searches based on latitude and longitude coordinates rather than zip codes, fetching results within a defined search radius. The implementation uses a concurrent worker-pool architecture with Go sync and channel primitives to scale data collection across multiple geographic points loaded from uszips.csv. To manage large-scale scraping, the code handles automatic pagination based on API hits, includes retry with backoff for HTTP 429 rate limits and 5xx server errors, and deduplicates records with a Go map keyed by unique CRD identifiers. The final dataset is exported in both JSON and CSV formats for flexible downstream analysis, while maintaining a minimal footprint by relying exclusively on the Go standard library for networking, JSON unmarshaling, and CSV serialization.

Built with: Go, Go stdlib, HTTP/JSON, CSV

Qwerty

Qwerty is a compiler modernization effort where I upgraded the core LLVM dependency and designed a new MLIR dialect, Ccirc, to natively represent classical circuits-fully replacing the deprecated Tweedledum library with a compiler-native pipeline. The dialect introduces strong typing with custom types like WireType and CircuitType (e.g., WireType is only valid with classical gates), provides first-class operations for classical logic such as AndOp, OrOp, XorOp, and NotOp, and includes canonicalization that simplifies expressions; for instance, two consecutive ccirc.not operations collapse back to the original value. The new backend flow lowers classical code into Ccirc, optimizes directly on that representation, and then lowers through LLVM IR to produce QIR, eliminating the previous black-box handoff to Tweedledum and making the system faster and easier to debug.

Built with: MLIR, LLVM, CMake, C++

diBELLA Transitive Reduction Algorithm

The implementation of the diBELLA transitive reduction algorithm within the Sparse Application Benchmark project serves as a high-fidelity workload for evaluating sparse array programming frameworks. Written in a minimalist array-programming style, the algorithm maps complex graph simplification into linear algebra operations over 2D distributed sparse matrices. It uses a custom stack built around the Array API and a specialized tensor-expression compiler with a Lark-based parser for flexible einsum execution. At its core, the method performs sparse matrix-matrix multiplication (SpGEMM) over a (min, +) semiring, squaring the matrix (N = R^2) to find shortest two-hop paths and remove redundant overlaps. This iterative reduction is central to benchmarking auto-scheduling decisions because it stresses both communication-heavy execution and geometrically decreasing sparsity. Performance results show near-linear scaling, over 80% parallel efficiency on large datasets such as the human genome, and speedups of 10.5x to 29x versus traditional distributed-memory graph processing implementations.

Built with: Array API, SpGEMM (min,+), Lark Parser, Tensor Expression Compiler

Finch-Python

I have developed an einsum-style macro for the Finch tensor system in Python. The project involves designing a custom parser and grammar for Einstein summation notation, enabling expressive, optimized array and tensor operations that compile directly to Finch’s backend. This work bridges mathematical expressiveness with high-performance computation.

Built with: Python, Julia

Nomad

For the Nomad project, a mobile app designed to make trip planning and navigation easier, I worked on three key features: route time calculations, voice‑guided directions, and a smart address search tool. For route time calculations, I created a function in the MapManager that takes each step of a journey (like “turn left in 0.2 miles”), looks at its expected travel time, and aggregates durations to give users a clear ETA. To make navigation safer and hands‑free, I built a voice guidance system using Apple’s AVFoundation framework—this manager turns route instructions into spoken directions and adds a simple toggle in the map view so users can switch voice commands on or off. I also developed an address search engine that makes it easy to find places quickly. By combining MapKit and CoreLocation, the app suggests locations as users type, autocompletes addresses, and converts map coordinates into full address strings. Altogether, these features make Nomad more accurate, intuitive, and user‑friendly for anyone planning a trip.

Built with: Swift, MapKit

Agricultural Productivity Forecast

This system forecasts agricultural productivity end‑to‑end: a Google Maps–based frontend lets users draw a bounding box, which the backend converts into tile intersections before querying the Copernicus Data Catalogue (via OData) for imagery filtered by area, date (including day‑level filters), and cloud cover. With temporary S3 credentials issued by the S3 Keys Manager Service and CDSE identity, the pipeline downloads the matching EO products from S3 using boto3, optionally runs ML analysis over the results, and organizes the data locally by year, month, and tile for downstream processing. Core modules include tiling (tiling.py), product querying (productquery.py), and an S3 download stage; key external services include the Copernicus catalogue, authentication, keys management, and EO data storage.

Built with: Python, AWS, EOData API