Gatherly — Personalized AI Event Studio

Sasi-019 — Sun, 18 Oct 2026 14:49:03 +0000

✨ Introducing Gatherly — Personalized AI Event Studio! 🎉

Planning an event is more than organizing tasks — it's about bringing your ideas to life. Gatherly is designed to be your personalized AI assistant, adapting to your event, theme, preferences, and budget.

🎨 Explore creative themes and decoration ideas

📋 Plan events, schedules, and activities

✍️ Generate speeches, invitations, and promotional content

📸 Get photography ideas and shot lists

💰 Organize budgets, materials, and practical alternatives

Our vision is to make event planning more creative, organized, and personalized with AI.

Built with React, Tailwind CSS, FastAPI, and LangGraph, Gatherly is a step toward making event planning smarter and more accessible. 🚀
🔗 GitHub Repository: https://github.com/Sasi-019/Gatherly
🎥 Project video: https://youtu.be/cvuzhuVIbNs

I'd love to hear your feedback and suggestions as I continue developing Gatherly!

Gatherly #AI #devchallengesvg #hf26challengesvg

TouchGrass 🌿 — A Personalized AI Agent That Gets You Off the Screen

Sasi-019 — Sun, 11 Oct 2026 06:54:09 +0000

The screen should be the shortest part of the experience.

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

What if your AI assistant didn't try to keep you chatting with it, but instead helped you step away from your screen and do something meaningful in the real world?

That's the idea behind TouchGrass — a personalized AI agent that learns what you enjoy, considers your current situation, and gives you one realistic offline challenge.

Instead of overwhelming you with random activity suggestions, TouchGrass learns from your interests, preferences, previous activities, and feedback to make future recommendations more relevant.

🌱 What I Built

TouchGrass is a full-stack application designed to reduce passive screen time and encourage real-world experiences.

The user journey is simple:

Sign Up → Discover Your Interests → Ask the Agent → Get One Challenge → Go Outside → Share Feedback → Get Better Recommendations

Users can tell the agent things like:

"I have 30 minutes free."

"Suggest something outdoors."

"Give me something completely new."

"Surprise me!"

The agent uses the available profile information and relevant context to suggest one activity that fits the user's situation.

For example, someone who enjoys photography and nature might receive a challenge to spend 30 minutes observing interesting natural textures and capturing one final photograph.

The objective isn't to maximize engagement with the app. It's to help users leave the screen behind.

🚀 Demo

Live application: https://touchgrass-project.onrender.com/

Video demonstration: https://youtu.be/y7RaCb7b4W8

The video demonstrates the application and its interface. Try the live deployment to explore the available features.

💻 Code

GitHub repository: [Insert your public GitHub repository URL here]

The project is organized into a React frontend and a Python backend, with dedicated modules for authentication, profile discovery, agent orchestration, activity generation, and feedback-driven personalization.

The repository includes the application source code and supporting configuration and tests.

🛠️ How I Built It

Technology stack

Frontend: React, Vite, Tailwind CSS

Backend: Python, FastAPI, SQLAlchemy

Database: PostgreSQL

Agent orchestration: LangGraph

Language model: Specify the model and inference provider actually used in the deployed version

Authentication: JWT and bcrypt

Context tools: Weather information, time, and optional browser geolocation

User authentication and profile discovery

Users create accounts and sign in before accessing their personalized experience. Passwords are hashed rather than stored in plaintext, and authenticated requests are authorized using JWTs.

During onboarding, users describe their interests, activities they want to explore, dislikes, available time, and social preferences.

The application converts these responses into structured profile information that can be used by the agent.

Persistent memory

PostgreSQL stores user profiles, preferences, activity history, and feedback.

This means the application can use relevant information from previous sessions rather than treating every request as a completely new conversation.

For example, if a user repeatedly enjoys nature-related activities, future challenges can reflect that preference while still introducing new experiences.

The agent workflow

LangGraph orchestrates the agent's multi-step workflow. It is responsible for coordinating the model, stored profile information, context tools, and validation steps.

The intended workflow is:

Load the user's profile and recent activity history.

Understand the user's request and available time.

Retrieve relevant context, such as weather, when needed.

Generate a personalized offline activity.

Validate the activity against practical constraints and previous activities.

Regenerate the suggestion if it fails validation.

Return one clear challenge to the user.

This separates the agent's workflow from the language model itself.

Feedback-driven personalization

After completing an activity, users can rate their experience and optionally explain what they liked or disliked.

That feedback updates their stored preferences and helps guide future recommendations.

The system improves personalization through memory updates; this does not mean the language model is automatically fine-tuned after each interaction.

Privacy and user control

TouchGrass is designed to minimize unnecessary data collection.

Passwords are hashed.

Authenticated endpoints enforce user-specific access.

Location access is optional and initiated by the user.

Users can continue using the application without granting location access.

API keys and other secrets belong in backend environment variables rather than frontend code.

🌍 Why Does Open Innovation Matter?

An application like TouchGrass benefits from open-source tools because its workflow requires more than a single model call.

An open-source agent framework such as LangGraph makes it possible to inspect and customize the workflow that coordinates profile memory, context retrieval, activity generation, and validation.

Open tools also make the architecture easier to extend. Developers can experiment with different language models, replace individual components, improve validation rules, and adapt the application without rebuilding the entire system.

For a project focused on personalization, transparency and experimentation matter. The system should be understandable and adaptable rather than locked into a single implementation.

My goal is to keep the project modular so that open-weight models and additional open-source components can be integrated as the application evolves.

🔄 My Agent Session

The agent workflow is designed to connect user preferences, current context, activity generation, validation, and feedback-driven memory updates.

Agent session: [Add a DevRelay session link if you have one]

This section is optional. If you haven't recorded a session using DevRelay, you can remove it.

🏆 Prize Categories

Potential category: Best Use of Render

TouchGrass is deployed on Render, and the live application is available at:

https://touchgrass-project.onrender.com/

Include this category only if the deployment meets the challenge's requirements for using Render.

Remove other partner categories unless you have actually integrated their qualifying products or services.

🔮 What's Next?

Some possible future improvements include:

Google Calendar integration for activity planning around a user's schedule.

Better nearby-place discovery.

More diverse activity exploration based on learned interests.

Further evaluation of open-weight language models.

Improved agent tracing and validation metrics.

These are future goals rather than claims about features already implemented.

Final Thoughts

TouchGrass started with a simple question:

Can we build AI that helps people spend less time using AI?

I believe a useful assistant should sometimes give you the answer you need and then get out of your way.

Ask for a challenge. Put the phone down. Experience the real world. Come back only when you have something to share.

The screen should be the shortest part of the experience. 🌿

MemoMate: An AI Personal Assistant Built for a Friend

Sasi-019 — Sun, 04 Oct 2026 18:25:07 +0000

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

What I Built

I built MemoMate, an AI-powered personal productivity assistant for a friend who wanted a simpler way to manage everyday tasks, reminders, lists, and important information.

Instead of opening different apps for different tasks, the user can interact with MemoMate using natural language.

For example:

"Remind me to submit my assignment tomorrow at 10 AM."
"Create a shopping list."
"Add milk to my shopping list."
"Show my lists."
"What do I have tomorrow?"
"Remember that my project deadline is next Friday."

MemoMate understands these requests and turns them into actions such as creating reminders, managing lists and list items, saving memories, and retrieving information.

The goal was to build something that feels more like talking to a personal assistant rather than filling out forms.

Main Features

AI-powered natural-language interaction
Reminders and recurring reminders
Shopping and custom lists
Add, complete, and remove list items
Calendar and upcoming events
Personal memory
Notifications
Voice interaction
User-specific data and actions
Deployed web application

Demo

Try the live application:

🚀 Try MemoMate Live

Code

The complete source code is available on GitHub:

💻 View MemoMate on GitHub

The repository contains both the React frontend and FastAPI backend.

How I Built It

MemoMate is built as a full-stack application.

Frontend

React
Vite
JavaScript
CSS

The frontend provides the assistant interface along with pages for reminders, lists, calendar information, and notifications.

Backend

Python
FastAPI
SQLAlchemy
PostgreSQL / SQLite
JWT-based authentication

The backend handles users, reminders, lists, list items, memories, and AI-powered assistant requests.

AI

For the AI layer, I used Hugging Face with an open-weight Qwen model.

The AI is not given unrestricted control over the database. Instead, MemoMate uses an action-based architecture.

The basic flow is:


text
User request
     ↓
AI / Intent Recognition
     ↓
Structured Action
     ↓
Validation
     ↓
Action Engine
     ↓
Database
     ↓
Response to User

DEV Community: Sasi-019