DEV Community: Mayank Tiwari

TrailMate AI — Your AI Companion for the Trail

Mayank Tiwari — Thu, 08 Oct 2026 15:26:13 +0000

What if AI could help you explore the world instead of keeping you glued to a screen?

That's the idea behind TrailMate AI — an AI-powered outdoor companion designed to help people understand and interact with their surroundings while hiking, walking, or exploring nature.

Instead of using AI to generate another piece of content to consume, TrailMate uses AI to make the real world itself the content.

🥾 What is TrailMate AI?

TrailMate AI helps outdoor explorers learn more about what they encounter on their journey.

Take a picture of something you find on a trail and TrailMate can help you understand it — whether it's a plant, landmark, natural feature, or something else interesting around you.

The goal is simple:

Take your phone outside. Use AI. Then put the phone away and explore. 🌱

🧠 How It Works

The basic experience is:

📱 Capture → 🤖 Analyze → 🌲 Explore

Capture
Take a photo of something interesting during your walk or hike.

Analyze
TrailMate's AI analyzes the image and identifies what you're looking at.

Learn
Get useful information about the object, its characteristics, and why it is interesting.

Explore
Put the phone away and continue exploring your surroundings.

The AI is designed to be a companion to the outdoor experience, not the experience itself.

🌍 Why Open-Source AI?

Open-source and open-weight AI is at the core of TrailMate.

Instead of relying completely on a closed AI service, the project explores how open models can be used for real-world applications.

This gives the project more control over:

🔓 Model selection

🧩 Customization

🔒 Privacy

💻 Local inference

🔄 Switching between models

💰 Reducing dependence on paid APIs

For an outdoor application, this is particularly interesting because the long-term goal is to make TrailMate increasingly useful even when internet connectivity is limited.

🏕️ Designed for the Real World

TrailMate isn't meant to become another app that you constantly stare at.

The ideal interaction looks like this:

Open TrailMate → Identify something → Learn → Lock your phone → Keep walking.

That's what makes the project fit the "Touch Grass" theme.

The technology should make people more curious about their surroundings, not more dependent on their screens.

⚙️ Tech Stack

AI / ML

Open-weight vision model

Image classification / visual understanding

🔓 Why Not Just Use a Closed AI API?

A closed API would certainly make building a prototype easier.

But using open AI gives TrailMate something more valuable: control.

The model can potentially be changed, optimized, fine-tuned, or eventually run locally without redesigning the entire application.

That matters for an outdoor tool where connectivity, privacy, latency, and operating cost can all become important.

🌲 What I Want TrailMate to Become

This prototype is only the beginning.

Future versions could include:

🐦 Bird identification from calls

🌿 Plant and tree identification

🏔️ Landmark recognition

🗺️ Trail information

📍 Offline exploration

🎒 Personalized hiking recommendations

📸 Nature journaling

🏆 Outdoor challenges and achievements

🤖 A fully local AI companion

The ultimate goal is an AI assistant that knows when to stop talking and let you enjoy the trail.

🚀 Try It

GitHub: https://github.com/mayank-aiml/Email-Spam-Classifier

💡 What I Learned

The biggest lesson from this project was that building an AI application doesn't always mean finding another reason for users to spend more time on a screen.

AI can also be used to make people more curious about the physical world around them.

TrailMate started with a simple question:

What if AI helped us explore more instead of scroll more?

That's what I'm experimenting with.

🌱 Final Thought

Technology doesn't always have to bring us deeper into the digital world.

Sometimes, the best AI experience is the one that gives you a reason to put the phone down and keep walking.

TrailMate AI — Explore more. Scroll less. 🌲🥾

devchallenge #hf26challenge #opensource #ai

StudyBuddy: A Private AI Study Assistant Built for a Friend

Mayank Tiwari — Sun, 04 Oct 2026 16:15:46 +0000

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

StudyBuddy: A Private AI Study Assistant Built for a Friend

What I Built

I built StudyBuddy, a simple AI-powered study assistant for a friend who spends a lot of time going through lengthy lecture notes and PDFs before exams.

Instead of repeatedly searching through hundreds of pages, they can upload their study material to StudyBuddy and interact with it like a personal study assistant.

The app can:

📚 Upload and process PDF notes
💬 Ask questions about the uploaded material
🧠 Explain difficult concepts in simpler language
📝 Generate multiple-choice quizzes from the notes
⚡ Create quick revision notes before an exam
🔎 Show the relevant information retrieved from the uploaded documents

The main idea was simple:

Turn the notes my friend already has into something they can actually talk to.

I wanted to build something small enough to finish in a weekend, but useful enough that my friend could actually use it.

Demo

🚀 Live Demo: https://studybuddy-hackoctober-mkt.streamlit.app/

The basic workflow is:

Upload PDF → Process Notes → Ask a Question → Retrieve Relevant Content → Generate Answer

Code

💻 GitHub Repository: https://github.com/mayank-aiml/HackOctober-Study-Buddy

The project is intentionally kept small and easy to understand.

StudyBuddy/
│
├── app.py
├── rag.py
├── pdf_processor.py
├── prompts.py
├── requirements.txt
├── README.md
└── .gitignore

The goal wasn't to create a huge AI framework. I wanted every part of the application to be understandable and replaceable.

How I Built It

The most important part of StudyBuddy is that the AI isn't simply a call to a closed AI API.

I built the application around open-weight AI and open-source tools.

Tech Stack

🐍 Python
🎈 Streamlit
🦙 Ollama/Grok
🤖 Open-weight LLM
🔗 LangChain
🧠 Hugging Face embeddings
🗄️ ChromaDB
📄 PDF processing
🔍 Retrieval-Augmented Generation (RAG)

The application follows a relatively simple RAG pipeline:

                 PDF Notes
                    │
                    ▼
             Extract Text
                    │
                    ▼
              Split into Chunks
                    │
                    ▼
            Generate Embeddings
                    │
                    ▼
               ChromaDB
                    │
          ┌─────────┴─────────┐
          │                   │
     User Question       Retrieved Chunks
          │                   │
          └─────────┬─────────┘
                    ▼
             Open-weight LLM
                    │
                    ▼
               AI Response

When my friend asks a question, StudyBuddy doesn't simply ask the model to answer from its general knowledge.

Instead, it:

Converts the question into an embedding.
Searches the local vector database.
Retrieves the most relevant sections from the uploaded notes.
Gives those sections to the open-weight model.
Generates an answer based on the retrieved information.

This makes the application much more useful for questions that are specific to the friend's own study material.

Why Does Open Innovation Matter?

This is probably the most important part of the project for me.

I could have built the entire application around a closed AI API.

It would have been easier.

But using open-weight AI made the project more interesting and more useful for this particular problem.

🔒 Privacy

Study notes can contain personal information, assignments, internal college material, or other documents that someone may not want to upload to a third-party AI service.

With a local setup using Ollama and an open-weight model, the documents can stay on the user's machine.

Traditional API approach:

PDF → Cloud Service → AI Model → Response


StudyBuddy local approach:

PDF → Local RAG → Local Model → Response

🔄 Models Can Be Swapped

I'm not locked into one model.

If a better open-weight model becomes available, I can replace the model without redesigning the entire application.

The same application can experiment with different models based on:

Speed
Accuracy
Hardware
Model size
Reasoning capability

Prize Categories

I'm entering the categories that best match the project:

Open Innovation / Open Source AI
Build for a Friend

If there are specific partner categories required by the challenge, I'll update this section accordingly.

What I Learned

The biggest takeaway from this project wasn't building another chatbot.

It was seeing how much can be built with relatively small open-source components.

A few building blocks:

PDF parsing + embeddings + vector search + an open-weight model + Streamlit

can become a genuinely useful personal application.

And because those pieces are open and replaceable, the project can continue evolving.

My friend doesn't need another generic AI chatbot.

They needed something that understands their notes.

So that's what I built.

Built for a friend.

Built with open AI.

Built to be modified. 🚀

Hacktoberfest #AI #OpenSource #RAG #LLM #Streamlit #Python #GenAI #BuildForAFriend