Hey, I’m Himal Gautam

Kozi.REST is an AI-powered bedside sleep companion designed to help users understand and improve their sleep quality through environmental and behavioral data. I led the integration of Raspberry Pi sensors that monitored ambient temperature, humidity, sound levels, and body motion throughout the night. These readings were processed locally and summarized every morning through an AI-generated audio briefing created with Gemini API and ElevenLabs TTS. The system included a lightweight web dashboard that visualized sleep trends, identified anomalies, and delivered insights into how room conditions affect rest quality. Beyond just logging data, Kozi.REST personalized feedback using an adaptive AI model that adjusted its recommendations over time, bridging hardware sensing with ambient intelligence in a compact IoT setup.

Code Snippet (App route)

app.post('/summary', async (req, res) => {
  const data = await db.collection('night_logs').find({ date: today() }).toArray();
  const summary = await gemini.summarize(data);
  const mp3 = await elevenlabs.tts(summary);
  await sendToPi(mp3);
  res.json({ ok: true });
});

Code Snippet (Pi button → backend)

# on the Pi
GPIO.add_event_detect(BUTTON, GPIO.FALLING, bouncetime=250)
GPIO.add_event_callback(BUTTON, lambda ch: requests.post(API + '/summary'))

RunSafe was built to make outdoor running safer by merging geospatial analytics with environmental health data. The app retrieves live AQI (air-quality index) data and computes the “healthiest” route among multiple alternatives provided by Google Maps. I developed the backend pipeline that decodes route polylines, samples coordinate points, synchronizes them with hourly AQI data from Open-Meteo, and computes cumulative exposure scores for each route. The client visualizes these scores as color-graded paths, giving runners real-time comparisons. RunSafe also allows users to log daily symptoms (like coughing or fatigue) and auto-generates weekly health reports in PDF, formatted for physician review. The project was inspired by the Rice IDSO Challenge on Air Quality & Lung Health and aims to connect environmental data with individual health outcomes.

Code Snippet (AQI exposure)

const exposure = points.reduce((sum, p, i) => sum + aqiAt(p.time, p.lat, p.lng) * segLen(points[i-1], p), 0);
const best = routes.sort((a,b) => a.exposure - b.exposure)[0];

Code Snippet (Polyline decode)

import polyline
points = polyline.decode(route.overview_polyline)
# sample every ~50m for AQI lookups
sampled = sample_points(points, step=50)

Baymax is a virtual companion designed to provide accessible mental-health support through natural conversation and personalized recommendations. I handled the backend architecture—building a secure RESTful API, integrating MongoDB Atlas for encrypted session storage, and linking Stripe API for subscription-based access. The app leverages GPT-powered dialogue to simulate empathy-driven conversation while preserving data privacy and maintaining clinical relevance through curated response sets. The project’s goal was to bridge the gap between immediate emotional support and professional therapy access by offering a responsive, human-like interface for early-stage intervention.

Code Snippet (session create)

router.post('/session', async (req, res) => {
  const user = await users.ensure(req.body.email);
  const sess = await db.collection('sessions').insertOne({ userId: user._id, createdAt: new Date() });
  res.json(sess);
});

Code Snippet (Stripe checkout)

const session = await stripe.checkout.sessions.create({
  mode: 'subscription',
  line_items: [{ price: process.env.STRIPE_PRICE_ID, quantity: 1 }],
  success_url: ORIGIN + '/app',
  cancel_url: ORIGIN + '/pricing'
});

Dristi (“vision” in Nepali) is a smart mobility aid designed to enhance independence and safety for visually impaired individuals. Built entirely on Raspberry Pi OS, the prototype uses ultrasonic sensors to detect obstacles and GPS for navigation guidance. I engineered the system logic that triggers haptic feedback when objects are detected within defined proximity thresholds and synchronized alert intensity based on obstacle distance and direction. The project demonstrated how low-cost hardware and intelligent sensor fusion can transform assistive technologies—prioritizing accessibility, affordability, and real-time responsiveness.

Code Snippet (haptics)

if (distance <= 50) {
  motor.vibrate(map(distance, 0, 50, 255, 80));
}

Code Snippet (Ultrasonic read)

def distance_cm():
  GPIO.output(TRIG, True); time.sleep(0.00001); GPIO.output(TRIG, False)
  start, end = pulse_in(ECHO)
  return (end - start) * 17150

Backlog Buddy is a small AI agent hosted on Cloudflare that helps a developer triage and act on their issue backlog. You chat with it in plain English, and it replies with a concrete plan: which issue to work on, what git branch to create, and which commands to run next.

Under the hood, a BacklogAgent Durable Object stores a seeded list of issues plus recent notes. Each message is appended to that state, then the agent builds a prompt with the backlog + conversation and calls @cf/meta/llama-3.3-70b-instruct-fp8-fast via Workers AI. Responses are streamed back through the Worker to the chat UI.

Responsibilities

• Designed the agent’s state model (issues, notes, lastUpdated) on top of Durable Objects.
• Implemented the chat endpoint and session routing so each URL session maps to its own agent.
• Built a minimal but responsive HTML chat UI served directly from the Worker.

Key snippet

// BacklogAgent — handle chat
  const result = await env.AI.run(
    "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
    {
      messages: [
        { role: "system", content: systemPromptWithIssues(issues) },
        { role: "user", content: userMessage }
      ]
    }
  );

  // update notes + lastUpdated, then respond back to the client
  return jsonResponse({ reply: result, state: { issues, notes, lastUpdated } });

MyGarage is a clean and minimal web app I built to keep track of the cars. It lets me add details like the make, model, year, mileage, fuel type, VIN number, and more. If anything changes like mileage or service date; I can update it. And when I no longer need a car in the list, I can easily delete it. What makes it more fun (and useful) is the Scan VIN feature. Instead of typing out the full 17-character VIN, I can just click a button, open my camera, and it reads the VIN directly from the image using Google Vision OCR. It’s quick, accurate, and saves time. The app is built using Node.js, Express, and MongoDB (via MongoDB Compass) running locally to store all the car data. It also uses WebSockets to sync changes across tabs or devices in real time so if I update something on my phone, it instantly updates on my laptop too. The frontend is built with vanilla JavaScript and Tailwind CSS for a simple but sharp retro look.

Code Snippet (tooling)

#!/usr/bin/env bash
# bootstrap a new package
pnpm create vite my-tool --template react
cd my-tool && pnpm i