DEV Community: Sai Ritvik Mallela

DecisionDrop: An Open-Weight AI Agent That Researches, Compares, and Recommends Decisions

Sai Ritvik Mallela — Sun, 25 Oct 2026 16:58:39 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

DecisionDrop is an AI-powered decision-making agent that helps users research alternatives, compare trade-offs, and make informed decisions without spending hours gathering information manually.

Instead of providing only a chatbot response, DecisionDrop combines AI-assisted analysis, research integrations, and deterministic Multi-Criteria Decision Analysis (MCDA) to produce structured recommendations.

Key features include:

AI-assisted decision analysis using open-weight models.
Research integration to gather supporting information.
Transparent, criteria-based scoring and ranking.
Alternative comparisons and trade-off visualizations.
Sensitivity analysis to explore how changing priorities affects recommendations.
SQLite-based decision history.
Local model inference through Ollama.

The goal is to reduce repetitive research and comparison work while keeping the decision-making process transparent.

Demo

🎥 Video demonstration:

Watch the DecisionDrop demo

If the video doesn't open, check that Google Drive sharing is set to “Anyone with the link” and that viewers have permission to access it.

Code

💻 GitHub Repository:

https://github.com/msairitvik/DecisionDrop

How I Built It

DecisionDrop uses a modular full-stack architecture:

Frontend: React 19 and Vite
Backend: Python and FastAPI
Database: SQLite
Local inference: Ollama
Open-weight models: Qwen3 4B, Gemma 2 2B, and Qwen3 0.6B
Testing: Pytest

The agent pipeline organizes the decision-making workflow, from understanding the user's problem to analyzing alternatives and presenting recommendations.

Open-weight models assist with analysis and structuring information, while a deterministic MCDA scoring engine calculates rankings based on evaluation criteria. This separation helps make recommendations more transparent and easier to inspect.

Why Does Open Innovation Matter?

Open innovation makes it possible to build AI applications without depending entirely on closed, proprietary model APIs.

Using open-weight models with Ollama gives users greater control over inference and enables experimentation with different models. The modular architecture also creates opportunities for contributors to improve the research pipeline, scoring engine, and user experience.

The aim is to build an AI system that people can inspect, adapt, and extend rather than treating AI as a black box.

My Agent Session

DecisionDrop was developed with AI-assisted coding.

Optional: Add your shareable DevRelay session link here if you saved one. Otherwise, remove this section.

The Lazy Payoff

DecisionDrop aims to reduce the manual effort involved in researching options, comparing alternatives, and calculating weighted scores.

By bringing research, scoring, and trade-off analysis into one workflow, it helps users spend less time organizing comparisons and more time evaluating the results.

I haven't measured the actual time saved yet, so I won't claim a specific number. Benchmarking manual decision-making against the agent's workflow would be a useful next step.

Prize Categories

Add the exact eligible prize categories from the official challenge rules that apply to this project. Remove this section if it isn't required.

Built for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

JobGuard AI: Detecting Recruitment Scams with Local AI and Open-Weight Models

Sai Ritvik Mallela — Sun, 18 Oct 2026 20:40:07 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

JobGuard AI — Local AI-Powered Recruitment Scam Detector 🛡️

Job hunting is already challenging, and recruitment scams make it even harder. Fake job offers, phishing messages, requests for upfront payments, and fraudulent interview processes can put job seekers at risk.

I built JobGuard AI, a web application that analyzes recruitment messages and job offers to identify potential scam indicators and help people make more informed decisions before trusting an offer.

What it does:

Analyzes job advertisements, recruitment messages, and suspicious offers.
Uses a rule-based engine to identify warning signs.
Uses a locally running AI model to help analyze the message and explain potential risks.
Presents risk assessments and indicators through a web dashboard.
Is designed to run AI inference locally rather than relying on a paid external AI API.

The intended users include job seekers, students, fresh graduates, and career communities. Placement cells and recruitment-support communities could also benefit from this type of tool.

The project is currently a prototype, and its accuracy and potential business model need further real-world validation.

Demo

🎥 Watch the JobGuard AI demo video:

▶ Watch the Demo on Google Drive

The video demonstrates the application running locally.

Code

💻 GitHub Repository:

https://github.com/msairitvik/jobguard-ai

The repository contains the frontend, backend, application configuration, documentation, and tests.

Contributions, suggestions, bug reports, and improvements are welcome!

How I Built It

I built JobGuard AI using a full-stack architecture combining web development, local AI inference, and deterministic rule-based analysis.

Technology stack:

Frontend: React and Vite
Backend: Java and Spring Boot
AI inference: Ollama running locally
Open-weight model: Qwen3 4B
Testing: JUnit-based backend tests and API testing with Postman
Containerization: Docker and Docker Compose
Database support: MySQL-related configuration and persistence options, with persistence disabled in the current local setup

The application combines a rule-based safety layer with local AI analysis. The rules help identify known warning signs, while the AI model provides additional contextual analysis.

Using Ollama allows the application to run inference on my own machine without depending on a paid external AI inference API. This gives me more control over costs, data handling, and experimentation.

Why Does Open Innovation Matter?

Open innovation made it possible for me to build an AI-powered application without depending entirely on proprietary AI services.

Open-weight models and tools such as Ollama let developers experiment with local inference, inspect their application architecture, and build around models that can run on their own hardware.

For a project that analyzes potentially sensitive recruitment messages, local processing can also reduce the need to send message contents to an external AI provider, depending on how the application is configured and used.

Open-source frameworks such as React and Spring Boot made it possible to connect the user interface, backend services, and AI inference into one application.

Most importantly, open innovation gives individual developers and students the opportunity to experiment, learn, build, and share useful tools with the community.

Touch Grass AI — An Open-Source AI Companion That Gets You Outdoors 🌱

Sai Ritvik Mallela — Sun, 11 Oct 2026 12:19:24 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

🌱 Touch Grass AI — An AI companion that helps people spend less time on screens and more time outdoors.

Touch Grass AI is a full-stack application that recommends outdoor activities based on a user's check-in and encourages them to take meaningful breaks from their screens.

Instead of using AI to keep people glued to their devices, this project uses AI to help them step away from technology and reconnect with the real world.

Key features:

🌿 Personalized outdoor activity recommendations.
🤖 Local AI inference using the Gemma model through Ollama.
📍 Outdoor place discovery using OpenStreetMap.
⏱️ Screen-free sessions to encourage real-world activities.
📊 An impact dashboard to track completed sessions.
🛡️ Deterministic safety rules for recommendations.
🔒 A privacy-conscious design using local AI inference.

The project is designed for anyone who wants to reduce screen time, discover outdoor activities, and build healthier digital habits.

Demo

🎥 Demo Video: Watch Touch Grass AI

The demo showcases the application interface, activity recommendations, screen-free sessions, and the impact dashboard.

Code

💻 GitHub Repository: https://github.com/msairitvik/touch-grass-ai

The repository includes the React frontend, FastAPI backend, AI integration, configuration files, tests, and setup instructions.

How I Built It

I built Touch Grass AI using React and Vite for the frontend and Python with FastAPI for the backend.

The core AI component uses Gemma, an open-weight model running locally through Ollama. The backend integrates the model into the recommendation workflow, while deterministic safety rules provide additional control over application behavior.

I used OpenStreetMap to discover outdoor places and built screen-free session functionality and an impact dashboard to help users track their outdoor activities.

The main technologies are:

Frontend: React, Vite, CSS
Backend: Python, FastAPI
AI: Gemma through Ollama
Location data: OpenStreetMap
Testing: Pytest

The project brings these components together to create an AI experience whose purpose is to encourage users to spend more time away from screens.

Why Does Open Innovation Matter?

Open innovation made it possible for me to explore AI beyond a conventional chatbot.

By using an open-weight model that can run locally, Touch Grass AI can generate recommendations without depending entirely on a closed, hosted AI API. Local inference can also reduce the need to send personal check-in information to an external AI provider.

Open-source tools make the project easier for other developers to inspect, learn from, modify, and extend.

I especially like the idea that AI can be used not just to increase digital engagement, but to encourage people to disconnect, explore their surroundings, and experience the world outside their screens.

For me, this project demonstrates how open-source AI can support a practical, human-centered use case.

ResumeForge AI: A Local AI Project Advisor Built for a Friend

Sai Ritvik Mallela — Sat, 03 Oct 2026 21:32:06 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built ResumeForge AI for a friend who was having difficulty deciding what project to build based on their skills, career goals, experience level, and available time.

ResumeForge AI is a personalized AI project advisor. A student enters their branch or domain, skills, experience level, career goal, and available time. The system then generates three project recommendations tailored to that profile.

Each recommendation includes:

The real-world problem
Proposed solution
Technologies and tools
Main features
Technical concepts involved
Why the project matches the student
Estimated difficulty and development time
Resume description
Ideas for making the project stronger

I built and tested the application with a friend. Their feedback was:

"these are useful projects for me"

That feedback helped confirm that the project recommendations were useful for the problem I was trying to solve.

Demo

Demo video:

ResumeForge-AI - Google Drive

drive.google.com

The application runs locally and generates project recommendations using a locally running open-weight AI model.

Code

GitHub repository:

https://github.com/msairitvik/ResumeForge-AI

How I Built It

ResumeForge AI is built using:

React + Vite for the frontend
Java + Spring Boot for the backend REST API
Ollama for local AI inference
Qwen3 0.6B, an open-weight model, for project recommendation generation

The architecture is:

React frontend
→ Spring Boot API
→ Ollama
→ Qwen3 0.6B

The student's profile is sent to the local Spring Boot backend, which builds a structured prompt and sends it to the locally running Qwen model through Ollama.

The model generates exactly three project recommendations using the student's branch, skills, experience level, career goal, and available time.

I also tested the application with the internet disconnected after the required software, dependencies, and model had already been installed. The application was still able to generate recommendations locally.

Why Does Open Innovation Matter?

Using an open-weight model running locally made this project possible without depending on a proprietary AI API.

For ResumeForge AI, this is important because the information entered by a student can remain on their own computer instead of being sent to a third-party AI service.

It also gives the project more flexibility. The AI model can be changed or upgraded without redesigning the entire application.

Local inference also makes it possible to continue generating recommendations without an internet connection after the required model and dependencies have been installed.

Most importantly, open AI tools allowed me to experiment with the model, prompting, and application architecture while keeping the AI component under my control.

What I Learned

This project helped me understand how a locally running open-weight AI model can be integrated into a real application rather than being used only through a chatbot interface.

I learned how to connect a React frontend to a Spring Boot backend, send structured user information to an AI model, design prompts for consistent output, and turn the model's response into a usable application experience.

I also learned that making an AI application useful is not only about generating text. The input structure, prompt design, output format, and user experience all matter.

Build for a Friend

The project was built around a real problem faced by my friend: deciding what project would be realistic and useful for their skills, career direction, and available time.

Instead of giving a generic project list, ResumeForge AI tries to make the recommendations specific to the individual.

After trying the application, my friend said:

"these are useful projects for me"

That was the feedback I wanted to validate the idea with.

Future Improvements

Some improvements I would like to add in the future include:

A step-by-step project roadmap
A feature to make an existing project stronger
Project evaluation and improvement suggestions
Resume-ready project documentation
More specialized recommendations for different academic domains

Conclusion

ResumeForge AI is my attempt to build a practical AI tool around a real problem faced by a friend, while keeping the AI component local and based on open-weight technology.

The goal is simple: instead of asking a student to search through hundreds of generic project ideas, help them find a few realistic projects that actually match who they are and what they want to do.

My Hactoberfest 2026 Journey

Sai Ritvik Mallela — Thu, 01 Oct 2026 11:13:30 +0000

I'm excited to participate in Hacktoberfest 2026 and begin my journey into open source.

I'm currently exploring Full-Stack Development, Machine Learning, AI, and Git/GitHub. My goal this month is to learn more about open-source collaboration, build useful projects, and contribute to the developer community.

I'm looking forward to learning from other developers, taking part in challenges, and making meaningful contributions throughout Hacktoberfest.

Let's build, learn, and contribute together!