DEV Community: Asmodeus

LifeLens AI – Ghost in the Machine 👻 | Your Memories Never Disappear

Asmodeus — Fri, 30 Oct 2026 16:20:28 +0000

LifeLens AI – Ghost in the Machine 👻

An AI That Remembers What You Thought You'd Lost

What if your memories didn't disappear… but simply waited for you to ask about them?

That's the idea behind LifeLens AI, my personal AI memory assistant built for the Hacktoberfest 2026 Week 4 challenge: Ghost in the Machine.

Instead of creating a traditional chatbot that forgets everything after a conversation, I wanted to build something that could help preserve personal experiences and bring them back when needed.

🧠 What I Built

LifeLens AI is a personal memory assistant powered by Gemma.

The idea is simple: save an experience, let AI analyze it, and retrieve it later using natural language.

For example, imagine uploading a fee receipt today. A few weeks later, instead of searching through hundreds of photos, you can simply ask:

"What do you know about my Nebula Fee Receipt?"

LifeLens searches saved experiences, retrieves relevant information, and provides an answer with references to the original memory.

Current features:

AI-powered conversations using Gemma.
Persistent conversation history.
Save and manage personal memories.
Upload photos, receipts, and other experiences.
Search saved experiences using natural language.
AI-powered experience analysis.
Return references to the memories used in an answer.

👻 The Ghost in the Machine Moment

One of my favourite tests was uploading a receipt titled Nebula Fee Receipt.

Later, I asked LifeLens:

"What do you know about my Nebula Fee Receipt? Tell me its amount, recipient, and transaction date."

LifeLens retrieved the saved experience and returned:

Amount: ₹600
Recipient: Yash Umakant Gavali
Transaction date: 26 September 2026, 1:04 PM

It also returned the reference to the original saved experience.

That was the moment the idea started feeling real. I wasn't just asking an AI a general question. I was asking it about something from my own stored experiences.

🛠️ How I Built It

I used technologies I was already working with:

Python – Backend development
FastAPI – REST API
PostgreSQL – Persistent data storage
SQLAlchemy – Database operations
Gemma – AI-powered responses
Pydantic – Request and response validation

The basic workflow looks like this:

Upload an experience such as a photo or receipt.
Store its details in the database.
Analyze the experience using AI.
Search saved experiences when a user asks a question.
Pass relevant memory context to Gemma.
Return the response along with references to the retrieved experiences.

The backend exposes these capabilities through API endpoints, which I tested using FastAPI's Swagger documentation.

🔓 Why Does Open Innovation Matter?

For a personal memory assistant, the AI model matters because it is handling information that can be meaningful and private.

Using Gemma gives the project an open-weight model foundation. It also gives me more flexibility to experiment with models, providers, and deployment approaches instead of building the entire experience around one proprietary model.

I'm currently using a hosted model API rather than running inference locally, so I am not claiming that the current version works offline.

For me, open innovation means having the freedom to understand, adapt, and extend the technology behind a project.

🔗 Demo & Source Code

GitHub Repository:

https://github.com/MUBARAK-53/Lifelens

Demo Video:

[ADD YOUR LIFELENS DEMO VIDEO LINK]

The current demonstration focuses on the backend APIs and the memory-retrieval workflow. A dedicated user-facing frontend is still part of the future development.

🧩 A Note About Development

This Week 4 submission builds on my earlier LifeLens backend work. I created a new public repository for this challenge and extended the project with its Gemma-powered memory retrieval workflow and source references in chat.

I wanted to be transparent about reusing and extending my existing work rather than presenting the entire codebase as newly written during this challenge week.

🌼 The Spirit of It

Halloween is usually about ghosts, but this project made me think about a different kind of ghost.

The little things we forget:

A receipt from an important day.
A photograph from a trip.
A moment we thought we'd remember forever.
A small experience that becomes meaningful later.

Maybe the most interesting thing an AI can do isn't just generate something new.

Maybe it's help us remember something old.

LifeLens AI — Your memories never disappear. They wait to be remembered. 👻

Built for: Hacktoberfest 2026 – Week 4: Ghost in the Machine

devchallenge #hf26challenge #Hacktoberfest #Gemma #OpenSourceAI #Python #FastAPI #AI

Building Inbox Sloth v3.1: Zero-Dependency Local Chat Triage Engine

Asmodeus — Fri, 23 Oct 2026 13:56:23 +0000

*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady](https://dev.to/challenges/hacktoberfest-week3-2026-10-19)*

## What I Built
**Inbox Sloth** is a lightweight, pure-Python local chat triage engine and CLI utility designed to save developers and open-source maintainers from messy inbox overwhelm. 

In **v3.1**, Inbox Sloth evolves from a stateless CLI tool into a persistent local assistant. It automatically digests chat logs, classifies messages into actionable operational states (🚨 **Urgent**, 📅 **Moderate**, 🌴 **Chill**), generates instant suggested replies, and now **automatically persists historical execution metrics locally using SQLite** (`sloth_history.db`) with full **Sentry Agent Tracing** telemetry tracking. 

It gets busy developers a little lazier by eliminating manual chat scanning and keeping a historical log of communication patterns right on their local machine—zero heavy container overhead or mandatory cloud API keys required.

## Demo
You can check out the open-source repository and codebase here:
- **GitHub Repository:** [MUBARAK-53/inbox-sloth](https://github.com/MUBARAK-53/inbox-sloth)

Quick CLI execution demo:

powershell
python sloth.py emergency.txt


## Code

Here is the core logic driving the SQLite persistence, heuristic triage engine, and Sentry telemetry tracing (`sloth.py`):

python
import os, sys, sqlite3, datetime, sentry_sdk

sentry_sdk.init(
dsn="https://88429cf795513cefa27646afd2a586ff@o4512305399398400.ingest.us.sentry.io/4512305423581184",
traces_sample_rate=1.0,
environment="hacktoberfest-pure-local"
)

DB_FILE = "sloth_history.db"

def init_db():
conn = sqlite3.connect(DB_FILE)
cursor = conn.cursor()
cursor.execute("""
CREATE TABLE IF NOT EXISTS triage_logs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT,
filename TEXT,
urgency_level TEXT,
line_count INTEGER,
question_count INTEGER
)
""")
conn.commit()
conn.close()

def log_triage(filename, urgency, lines_count, questions_count):
init_db()
conn = sqlite3.connect(DB_FILE)
cursor = conn.cursor()
cursor.execute("""
INSERT INTO triage_logs (timestamp, filename, urgency_level, line_count, question_count)
VALUES (?, ?, ?, ?, ?)
""", (datetime.datetime.now().isoformat(), filename, urgency, lines_count, questions_count))
conn.commit()
conn.close()

def triage_chat(text):
lines = [l.strip() for l in text.splitlines() if l.strip()]
tl = text.lower()
if any(w in tl for w in ["bug", "fix", "error", "down", "broken", "asap", "production"]):
u, r = "URGENT - ACTION REQUIRED", ["I can look into this right away."]
elif any(w in tl for w in ["tomorrow", "today", "when", "who", "meet", "time", "still on"]):
u, r = "MODERATE", ["Sounds good, see you then!", "Works for me!"]
else:
u, r = "CHILL - IGNORE", ["Got it, thanks!", "Love that."]
qs = [l for l in lines if "?" in l]
return {"urgency_level": u, "morning_briefing": f"Processed {len(lines)} message lines. Found {len(qs)} question(s).", "suggested_replies": r, "lines": len(lines), "questions": len(qs)}

def run(fp):
if not os.path.exists(fp): return print("File not found")
with open(fp, "r", encoding="utf-8") as f: data = f.read()
print(f"\n🦥 Inbox Sloth digesting '{fp}'...")
with sentry_sdk.start_transaction(op="agent.execution", name="local_triage_with_db"):
res = triage_chat(data)
log_triage(fp, res["urgency_level"], res["lines"], res["questions"])
print("\n" + "="*40 + "\n 📋 INBOX SLOTH MORNING BRIEFING (Logged) \n" + "="*40)
print(f"🚨 Urgency Level : {res['urgency_level']}")
print(f"📝 Summary : {res['morning_briefing']}")
print(f"💡 Suggested Reply: {res['suggested_replies'][0]}")
print("="*40 + "\n")

if name == "main":
run(sys.argv[1] if len(sys.argv)>1 else "sample_chat.txt")


## How I Built It

Inbox Sloth is built around pure, standard-library Python (`os`, `sys`, `sqlite3`, `datetime`) combined with **Sentry SDK** for robust execution tracing and performance monitoring (`agent.execution`).

For Week 3's *Slow and Steady* theme, the architecture emphasizes durability and local persistence. Instead of relying on volatile memory or expensive cloud AI wrappers, `v3.1` implements an embedded SQLite database (`sloth_history.db`) that silently records execution metadata, line densities, and urgency classifications during every run.

## Why Does Open Innovation Matter?

Open innovation and open-source tooling make it possible to build software that respects user privacy and runs entirely offline. When dealing with private communication logs, messages, and internal team threads, relying on closed commercial APIs introduces security risks and ongoing subscription costs. Inbox Sloth proves that powerful automation, local telemetry, and state persistence can be achieved transparently using standard libraries and open standards.

## My Agent Session

* **Telemetry & Tracing:** Integrated directly with Sentry Agent Tracing (`agent.execution` transactions) to track execution health, timing, performance, and telemetry during local file processing.

## The Lazy Payoff

Instead of manually opening and reading through raw chat exports every morning to figure out what's on fire and what can wait, Inbox Sloth digests logs in milliseconds, logs historical trends locally, and instantly hands you the exact urgency breakdown and suggested reply. It saves valuable mental bandwidth and cuts morning inbox triage time down to zero.

## Prize Categories

* **Best Use of Sentry Agent Tracing**
* **Open Source Track / Hacktoberfest Challenge**

TrailLens AI: Building an AI-Powered Outdoor Exploration Companion

Asmodeus — Sat, 10 Oct 2026 17:37:25 +0000

🌿 TrailLens AI — Discover the Outdoors with AI

TrailLens AI is an AI-powered outdoor exploration companion designed to make hiking and trekking more interactive, informative, and rewarding.

Instead of simply following a trail, users can explore their surroundings, submit outdoor observations, discover interesting things, and engage with discovery missions.

🔗 Hacktoberfest Challenge: https://dev.to/challenges/hacktoberfest-week1-2026-10-05

🎥 Demo Video: https://youtu.be/B-CeQoTyNXg

💻 GitHub Repository: https://github.com/MUBARAK-53/TraiLens--AI

🌱 The Problem

Hiking and trekking offer opportunities to learn about nature, notice surroundings, and discover unfamiliar places. However, many digital outdoor tools primarily focus on navigation, routes, and destinations.

TrailLens AI explores a different approach: combining AI, location awareness, and gamification to make outdoor exploration more engaging.

🚀 What TrailLens AI Does

AI-powered exploration: Processes submitted outdoor observations through an AI-powered backend workflow.
Location-aware discovery: Uses GPS coordinates to provide geographic context for outdoor observations.
Discovery missions: Introduces exploration challenges that encourage users to engage with their surroundings.
Mission verification: Provides a separate backend endpoint for checking mission submissions.
Interactive outdoor experiences: Explores how discovery-based activities can make hiking and trekking more engaging.

The vision is to make the outdoors feel less like a route to follow and more like a world to discover.

🛠️ Tech Stack

Android application: Java and XML
Backend: Python and FastAPI
API communication: REST APIs and multipart file uploads
Location: GPS coordinates
AI integration: Google GenAI SDK (google-genai)
AI model: Gemma, using the model ID configured in the application

🧠 How I Built It

I built TrailLens AI using an Android client connected to a Python FastAPI backend.

The backend accepts outdoor observations containing an image and latitude/longitude coordinates. The AI integration supports the exploration workflow, while a separate mission-verification endpoint handles mission checking independently.

During development, I worked through practical integration challenges, including connecting the Android application to the backend, handling image uploads, and resolving mismatches between JSON arrays and objects.

These experiences helped me understand the importance of consistent API schemas and reliable communication between mobile applications and AI-powered backend services.

The project is still under development. The demo focuses on functionality available in the current implementation, while additional ideas remain part of the roadmap.

🤖 AI Model and Inference Setup

TrailLens AI integrates Gemma through the Google GenAI SDK (google-genai).

Current inference approach: API-based inference.

The application communicates with the model provider over the internet. The model is not currently running locally inside the Android application or through a self-hosted inference server.

This setup allows the backend to access Gemma-powered capabilities without requiring users to run a large model on their own devices.

Local or self-hosted inference is a potential future direction. It would require evaluating hardware requirements, response latency, privacy, deployment complexity, and operating costs.

🌍 Why Open Innovation Matters

Open innovation allows developers to experiment with AI models and explore practical applications beyond traditional chat interfaces.

With TrailLens AI, I am exploring how Gemma can contribute to outdoor discovery experiences by connecting AI capabilities with location information, user observations, and exploration missions.

The project has also helped me learn about model integration, backend API design, mobile-to-server communication, and the practical considerations involved in deploying AI-powered applications.

🧪 Challenges and Learnings

Some of the main challenges during development were:

Connecting the Android application to the FastAPI backend.
Sending images and location information through API requests.
Keeping request and response schemas consistent.
Separating observation processing from mission verification.
Integrating AI into an application workflow rather than building only a standalone chatbot.
Distinguishing API-based inference from local or self-hosted model execution.

These challenges strengthened my understanding of how AI integrations work in real software projects.

🔮 What's Next?

Planned improvements include:

More context-aware outdoor discovery suggestions.
Better geographic relevance for observations.
More interactive missions for hikers and trekkers.
Improved mission feedback and progress tracking.
Exploration of local or self-hosted inference.
More engaging discovery mechanics inspired by location-based exploration games.

These are future goals, not claims about features already completed.

🏆 Challenge Category

Target category: Best Use of Gemma

TrailLens AI uses the Google GenAI SDK to integrate Gemma into an outdoor exploration application.

The implementation currently uses API-based inference rather than local inference. Final eligibility depends on the official challenge rules, including the permitted model-access methods and submission requirements.

🙌 Final Thoughts

TrailLens AI is my attempt to combine AI, location awareness, and gamification to make outdoor exploration more engaging.

Building it has been a valuable learning experience in connecting AI models to real application workflows and turning an idea into a working project.

I look forward to improving the experience for hikers and trekkers and exploring how Gemma-powered applications can make the world around us more interesting to discover.

Built with curiosity, code, and a love for exploration. 🌿

devchallenge #hf26challenge