DEV Community: Vipin Kumar

FiloAI

Vipin Kumar — Mon, 26 Oct 2026 06:04:06 +0000

This is a project write-up inspired by the Hacktoberfest Open-Source AI Challenge: Week 3 — Slow and Steady.

What I Built

Have you ever opened your Downloads folder and found hundreds of files you no longer remember downloading? Documents, images, duplicate files, and random files accumulate until organizing everything feels like a project of its own.

That's why I built filoAI — a privacy-first AI-powered digital decluttering agent.

Its tagline is simple: Less digital clutter. More peace of mind.

filoAI helps users understand and organize their files without handing control of their filesystem to an autonomous AI. Instead of manually checking every file, users can scan a folder, identify duplicates, receive organization recommendations, and review proposed file moves before approving them.

The project includes:

Folder scanning: Inspect file metadata within a configured, approved directory.
Duplicate detection: Identify duplicate files using streaming SHA-256 hashing.
Local AI recommendations: Use Ollama with a configurable Gemma model to suggest sensible file organization.
User-approved organization: Preview proposed moves before executing them.
Undo and operation history: Review completed operations and reverse supported moves.
Recovery journal: Record file-operation states and flag interrupted operations for manual recovery.

The goal isn't to let AI take over your computer. It's to reduce repetitive work while keeping the user in control.

Demo

Project repository: https://github.com/VipinKumar04/FiloAI

The demo should show a folder scan, duplicate detection, AI recommendations, a user-approved file move, operation history, and undo.

The application is designed to run locally at http://localhost:3000. The local AI workflow depends on Ollama and the configured model being installed and running.

Code

Explore the source code on GitHub:

https://github.com/VipinKumar04/FiloAI

The repository includes the Express application, scanning and duplicate-detection services, local AI recommendations, organization and recovery workflows, automated tests, and project documentation.

How I Built It

I built filoAI with a focus on local processing, explicit user approval, and safe filesystem operations.

Technology stack

Node.js and Express: Backend application and API routes.
Vanilla JavaScript, HTML, and CSS: Frontend interface.
Ollama and Gemma: Local inference for file-organization recommendations.
SHA-256: Content-based duplicate detection.
JSON Lines recovery journal: Persistent tracking of organization operations.
Node.js test runner: Automated unit and end-to-end tests.
GitHub Actions: Continuous integration.

The AI receives a limited catalog of file metadata rather than the contents of users' documents. Its recommendations are validated against known files, and it cannot directly execute a move simply because the model suggested one.

The organization workflow separates preview from execution. Approval tokens expire, paths are revalidated, destination conflicts are checked, and the application records operation states so interrupted work can be flagged for review.

The project also includes automated tests for scanning, duplicate detection, organization workflows, replay prevention, and recovery scenarios. The latest development report recorded 66 passing tests; this should be confirmed against the final repository before publication.

Why Does Open Innovation Matter?

Digital organization can involve deeply personal information: financial documents, photographs, work files, and private records.

I wanted filoAI to explore an approach where users can run AI locally instead of automatically sending their file metadata to a third-party AI service.

Using an open-weight model through Ollama gives the project flexibility. Users can choose a compatible model, inspect the application code, and adapt the system to their needs.

Local inference also provides a way to reduce dependence on remote AI APIs. When the model and runtime are already installed, recommendations can be generated locally without requiring a cloud AI provider.

Open innovation matters here because privacy, transparency, and user control should be part of the design—not features added after the product is built.

The Lazy Payoff

The most repetitive part of organizing files is not necessarily moving them. It's figuring out what is there, finding duplicates, deciding where things belong, and checking that nothing important gets overwritten.

filoAI brings those steps into one workflow.

Instead of inspecting every file manually, a user can scan an approved folder, review duplicate groups, receive suggestions, and approve selected moves.

"🌿 LinkUp: Touch Grass, Find Your People, Make Real Connections"

Vipin Kumar — Mon, 12 Oct 2026 06:14:08 +0000

🌿 LinkUp: Touch Grass, Find Your People, Make Real Connections

Less scrolling. More exploring. More people. More life. 🌱

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

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

🌳 The Idea Behind LinkUp

Imagine a sunny Sunday morning. You feel like going cycling, exploring a nature trail, playing cricket, visiting a local café, taking photographs outdoors, or simply walking in a park.

There is just one problem: you have nobody to go with.

Friends are busy, plans fall through, and sometimes finding people with the same interests feels harder than the activity itself.

That is why I built LinkUp.

LinkUp is a community-driven platform designed to help people turn everyday plans into real-world experiences by connecting with others who want to do the same things.

Inspired by the idea of touching grass and spending more time outside, LinkUp encourages people to step away from their screens, discover activities, meet like-minded people, and create memories together.

Because sometimes, the best connection is the one that starts with a simple question:

“Anyone up for a walk?” 🌿

🍃 What Can You Do with LinkUp?

🌱 1. Plant the Seed of an Idea

Have an activity in mind? Create a plan by choosing an activity, setting the date and time, specifying a general location, defining the available spots, and adding a budget if needed.

Your simple idea can become an invitation for someone else to join.

🤝 2. Find Your People

Discover people who share your interests, whether you enjoy cycling, photography, sports, outdoor adventures, creative activities, or relaxed social meetups.

You do not need an existing group of friends to get started. You just need an idea and a willingness to connect.

🗺️ 3. Explore What's Happening Around You

Discover activities based on interests, categories, skill levels, budgets, schedules, and a selected geographic radius of 1–25 km.

The goal is to make finding something to do — and someone to do it with — easier.

🌼 4. Turn Invitations into Experiences

Send requests to join activities and let organizers manage incoming requests and available spots.

Backend capacity controls help prevent overbooking, making activity coordination more reliable.

🎒 5. Plan Your Next Adventure with AI Assistance

Sometimes you have the idea but are unsure how to organize it.

LinkUp's AI-assisted activity planner helps turn a rough concept into a structured draft with an activity description, an agenda, a packing checklist, and relevant safety guidance.

For example:

“A beginner-friendly cycling morning.”
“A photography walk in a green park.”
“An outdoor sketching session for creative people.”
“A relaxed weekend nature walk.”

The AI assistant helps with the planning, while the organizer stays in control of reviewing and publishing the activity.

🌍 6. Spend More Time in the Real World

LinkUp is built around a simple belief: technology should help us experience more of life, not just spend more time looking at screens.

It is for students, newcomers to a city, hobby enthusiasts, outdoor explorers, and anyone who wants to meet people through shared experiences.

The idea is not to replace online connections. It is to give those connections a chance to grow into something real.

🌿 Try LinkUp

🌐 Live Demo: https://meetup-pulse.netlify.app/

Explore the live application and see how LinkUp brings activity discovery, planning, and participation together.

💻 GitHub Repository: https://github.com/Aryan544-arch/Link-Up

Explore the source code, learn about the implementation, and follow the project's development.

Contributions, suggestions, and feedback are welcome!

🌲 How I Built It

LinkUp is a full-stack web application with a separate frontend and backend. This structure keeps the user interface separate from server-side logic and makes the application easier to maintain and extend.

🌿 Technology Stack

Frontend: React 18, JavaScript, Vite, Tailwind CSS, and Lucide Icons.
Backend: Node.js and Express.js REST API.
Database: MongoDB and Mongoose, including GeoJSON geospatial indexing.
Authentication: Cookie-based sessions using "express-session" and a MongoDB session store.
Security: Helmet security headers, rate limiting, and CORS validation.
API Communication: Axios with credentialed requests.
Core Features: Activity discovery, geographic radius filtering, privacy-aware location display, join requests, organizer management, and a My Plans dashboard.
Testing: More than 330 reported automated tests across backend and frontend suites, covering areas such as session persistence, capacity protection, and API contract integrity.

🔐 Privacy Matters

Meeting new people should come with thoughtful privacy protections.

LinkUp uses session-based authentication with secure HttpOnly cookies instead of storing sensitive authentication tokens in browser local storage.

The application also masks precise GPS coordinates for non-organizers, showing general neighborhood information instead to help protect participants' privacy.

The aim is to make discovering activities easier while treating user information responsibly.

🤖 Bringing Open-Source AI into the Outdoors

AI is not the destination of LinkUp. It is a tool to help people get there.

An Extensible AI Architecture

The activity-planning engine is implemented in "apps/api/src/services/ai.service.js" and uses a provider-based architecture.

The project has been designed around Google's Gemma model family and Gemini API integration, with model selection configurable through environment variables.

The backend exposes a dedicated planning endpoint:

"POST /api/ai/plan-activity"

The external provider must be configured and verified for live model-generated responses. When an external provider is unavailable or unconfigured, the application can use its built-in fallback.

From a Simple Thought to a Structured Plan

An organizer can describe an activity in natural language and use the planning assistant to draft:

An engaging activity title.
A description with a suggested agenda and flow.
A tailored packing checklist.
Activity-specific safety guidelines.

This can reduce the effort involved in organizing an activity and help people get from an idea to an actionable plan.

A Fallback That Keeps Planning Available

LinkUp includes a deterministic planning engine that uses rules and heuristics to create activity-specific suggestions.

It covers categories such as hiking, photography, cycling, running, sports, yoga, board games, creative arts, nature exploration, and social meetups.

This fallback can operate without an external AI API key. It is not an LLM, and its output is distinguished from AI-provider output through response metadata.

People Stay in Control

AI-generated plans are drafts, not decisions.

The organizer reviews and edits the content before publishing. The AI does not automatically publish activities or confirm attendance.

This human-in-the-loop approach keeps the technology in a supporting role while people make the final decisions.

🌻 What's Next for AI in LinkUp?

Future enhancements could include:

Browser-based Gemma inference using WebGPU or ONNX Runtime.
Conversational activity discovery and natural-language search.
Better activity recommendations based on interests.
Compatibility-based attendee matching.
More personalized suggestions for outdoor activities and community events.

I want to explore AI in ways that make real-world participation easier rather than adding technology without a meaningful purpose.

🌎 Why Open Innovation Matters

Nature thrives on diversity, collaboration, and interconnected ecosystems. I see a similar opportunity in open-source software.

Open innovation allows developers to explore the code, learn from the architecture, suggest improvements, and contribute new ideas.

LinkUp offers opportunities to experiment with:

Better activity recommendations and matching algorithms.
Natural-language planning and voice-based activity creation.
Accessibility, internationalization, and multilingual support.
Improved safety, privacy, and community moderation.
New activity categories and neighborhood-level community features.
Alternative open-weight AI models and improved evaluation methods.

Open-source AI gives developers more flexibility to experiment with different models and build solutions around real needs.

For LinkUp, that means exploring how technology can help people discover shared interests, coordinate plans, and build stronger communities.

🛠️ My Agent Session

I used AI-assisted pair programming to help design the system architecture, implement authentication flows, develop automated tests, investigate integration issues, and reconcile changes across Git branches.

Working with an AI coding partner helped accelerate development and testing while keeping attention on product requirements, database consistency, and user privacy.

The experience also reinforced an important lesson: generated code still needs to be reviewed, tested, and verified. Building a working application requires more than generating code — it requires understanding how its parts fit together.

🌿 Team and Credits

LinkUp was developed collaboratively across four core functional areas:
@aryan_9852
@vipin00004
@princesharma00007
@shivalika_f3c425e435190b9

Frontend and UX: Responsive React/Vite interface, activity discovery cards, location pickers, and the My Plans dashboard.
Backend and Marketplace: Express REST API, Mongoose schemas, capacity protection for join requests, and matching services.
Authentication and AI Foundation: Session-based authentication, rate limiting, and the AI-assisted activity-planning engine with deterministic fallback.
Integration, QA, and Deployment: API contract reconciliation, automated testing, safety features, and deployment verification.

Thanks to the open-source community, Google for its Gemma model family, and the DEV team for organizing the Touch Grass challenge.

🌱 Final Thoughts: Let's Touch Grass

We spend so much of our lives online, yet some of our best memories happen outdoors — on a cycling trail, during a spontaneous walk, over a game of cricket, or while discovering a new place with people we have just met.

Sometimes, all it takes is one person sharing a plan for someone else to say, “I'm in!”

LinkUp is my attempt to make that first step easier.

Create a plan. Find your people. Step outside. Make memories.

🌐 Live Demo: https://meetup-pulse.netlify.app/

💻 GitHub: https://github.com/Aryan544-arch/Link-Up

Less scrolling. More exploring. More connections. More life. 🌿

Let's touch grass, meet people, and turn plans into experiences. 🌱