DEV Community: RAGHUL P

TRAILMATE

RAGHUL P — Thu, 15 Oct 2026 18:10:24 +0000

TrailMate AI: An Open-Source AI Companion for Outdoor Adventures 🌿🤖

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

What I Built

TrailMate AI is an AI-powered outdoor companion designed to help people spend less time planning and more time exploring the world outside.

Many people want to go hiking, walking, or explore new places but don't know where to start. TrailMate AI aims to make outdoor planning easier by helping users discover activities, prepare for trips, and get personalized suggestions based on their interests and experience.

Who could benefit from it?

Students looking for outdoor activities on a budget.
Beginners who want to explore nature safely.
Travelers who need help planning outdoor adventures.
Outdoor communities that want a simple AI-powered planning assistant.

The long-term side-hustle opportunity is to offer premium trip-planning features, personalized itineraries, and tools for outdoor communities while keeping the core project open source.

Demo

Live Demo: [Add your deployed demo link]
Demo Video: [Add your video link]

Code

GitHub Repository: [Add your repository link]

Contributions, feedback, and suggestions are welcome!

How I Built It

The project is designed around an open-source AI approach, with a web interface connected to a backend that handles user requests and AI-generated recommendations.

Planned technology stack:

Frontend: React.js
Backend: Python and FastAPI
AI: An open-weight language model
Local inference: Ollama or another compatible local inference runtime
Version control: Git and GitHub

The goal is to keep the architecture modular so that the AI model can be changed without rebuilding the entire application.

I'll list the final model, frameworks, and tools here once they're confirmed in the implementation.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible to students, independent developers, and small teams.

For a project like TrailMate AI, open-weight models and open-source tools can provide several advantages:

More control: Developers can choose a model that suits their application.
Privacy options: Local inference can reduce the need to send user prompts to an external AI provider.
Lower barriers to experimentation: Developers can test different approaches without depending entirely on a proprietary AI API.
Community collaboration: Other developers can contribute features, improve the code, report bugs, and suggest new ideas.

For me, open source is not just about publishing code. It's about making technology easier to understand, improve, and build upon together.

My Agent Session

[Add your DevRelay agent session link if available.]

Prize Categories

[Add the applicable partner categories from the official challenge page.]

What's Next?

My next steps are to improve the planning experience, test the application with real users, and gather feedback to identify which features are genuinely useful.

I'd love to hear your suggestions!

Hacktoberfest #OpenSourceAI #SideHustle #AI #BuildInPublic

🌱 TrailMate AI: An Open-Source AI Companion to Touch Grass

RAGHUL P — Thu, 08 Oct 2026 13:32:08 +0000

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

What I Built

I built TrailMate AI, an open-source AI-powered outdoor companion that encourages people to spend less time on screens and more time exploring the real world.

TrailMate helps users decide what outdoor activity they can do based on their available time, interests, and surroundings.

For example, a user can enter:

"I have 1 hour this evening and want to relax outside."

TrailMate can suggest activities such as:

🌳 Nature walking
🐦 Bird watching
🌱 Plant observation
📸 Nature photography
🏃 Walking or jogging
🌅 Sunset activities

The main idea is simple:

Use AI to plan the experience, then put the phone away and go outside.

TrailMate is designed for students, developers, families, runners, hikers, and anyone who wants a simple push to spend more time outdoors.

Demo

🎥 Demo Video: [Add your demo video link here]

🌐 Live Demo: [Add your deployed application link here]

Code

💻 GitHub Repository: [Add your GitHub repository link here]

The project is open-source, so developers can inspect the implementation, experiment with the AI model, and extend the application with their own ideas.

How I Built It

TrailMate AI is built around an open-weight AI model, rather than depending entirely on a closed AI API.

Technology Stack

🧠 Open-weight AI model – natural-language understanding and outdoor activity planning
🐍 Python – AI and backend logic
⚡ FastAPI – backend API
⚛️ React – frontend
🤗 Hugging Face / open-source AI ecosystem – model integration
🦙 [Ollama / llama.cpp / Transformers – use the one actually used] – local model execution
🐙 GitHub – open-source development

Basic Architecture

User
  ↓
Outdoor Goal / Question
  ↓
TrailMate AI
  ↓
Open-Weight AI Model
  ↓
Activity Planning
  ↓
Outdoor Recommendation
  ↓
User Goes Outside 🌳

The open model is an important part of the application rather than simply being an optional add-on.

The system can interpret the user's request and generate practical outdoor activity suggestions.

Why Does Open Innovation Matter?

Open innovation was important for TrailMate because I wanted the AI experience to be more transparent, customizable, and privacy-friendly.

🔐 Privacy

An outdoor application may involve personal preferences and potentially location-related information.

With local AI inference, the application can be designed so that sensitive information does not have to be sent to a third-party AI provider for every request.

🧠 Model Freedom

Using an open-weight model gives developers the freedom to experiment with different models instead of being locked into a single closed API.

I can replace the model, test different models, and optimize the system for the specific requirements of the application.

🛠️ Customization

The AI behavior can be adapted specifically for outdoor activities.

Instead of building another general-purpose chatbot, TrailMate focuses the AI on helping users discover activities and spend time outside.

📡 Offline Potential

One of the biggest possibilities of open AI is local inference.

A future version of TrailMate could run directly on a laptop or mobile/edge device and continue working in locations with poor or no internet connectivity.

This is especially useful for hiking, camping, and other outdoor activities.

💰 Cost

Local open-weight models can reduce dependence on paid API calls, making experimentation more accessible to students and independent developers.

For me, open innovation means having the freedom to run, modify, experiment with, and build on the AI technology itself.

My Agent Session

I used DevRelay to document the development process and capture the agent-assisted building session.

🔗 DevRelay Agent Session: [Add your DevRelay session link here]

The session shows how the project was developed and how AI-assisted development was used during the implementation.

Prize Categories

🧠 Open-Source AI
🤖 AI Agents
🌱 Touch Grass / Outdoor Experience
🔓 Open-Weight Models

What's Next?

I would like to extend TrailMate AI with:

🐦 Offline bird-call identification
🌱 Plant identification
🗺️ Outdoor route planning
🌦️ Weather-aware activity recommendations
📍 Local nature exploration
📱 A fully offline mobile version
🧠 Smaller AI models optimized for edge devices

The goal is not to make people spend more time talking to AI.

It is the opposite:

Use AI for a few seconds → get a plan → put the phone away → go outside. 🌱

Final Thought

AI doesn't always have to keep us behind a screen.

Sometimes the best AI experience is the one that helps us close the laptop, put down the phone, and touch grass. 🌿

🚀 DEV Post — Ready-to-use conten

RAGHUL P — Fri, 02 Oct 2026 18:32:42 +0000

🚀 DEV Post — Ready-to-use content
You can use this as your DEV article structure:
I Built StudyBuddy AI for a Friend Who Struggles With Exam Preparation
The Problem
One of my friends was having trouble organizing their exam preparation.
They knew what they needed to study, but the difficult part was deciding what to study first, how much time to spend on each topic, and how to practice effectively.
Instead of building another generic AI chatbot, I wanted to build something specifically around their study routine.
So I built StudyBuddy AI, a small AI-powered study assistant designed for one real person.
💡 The Idea
The goal was simple:
Give my friend a personal study companion that can turn their available time and topics into a practical study plan.

The application allows them to enter their subjects, difficult topics, available study time and exam schedule.
StudyBuddy then generates a personalized plan and can also help them practice what they learned.
🤖 Open-Source AI at the Core
For this project, I wanted the AI component to be based on open technology rather than depending entirely on a closed AI API.
The application uses an open-weight language model for generating study plans, explanations and practice questions.
The open approach makes it possible to:

Experiment with different models
Run inference locally
Keep personal study information on the user's machine
Change the model without redesigning the entire application
Experiment with prompts and AI behavior This was one of the main reasons I chose an open-based approach for this project. 🏗️ How I Built It The basic architecture looks like this: Friend's Input ↓ React Web Interface ↓ Backend / AI Service ↓ Open-Weight Language Model ↓ AI-Generated Study Plan ↓ Practice / Quiz / Explanation

Technology Stack
Frontend

React
JavaScript
CSS Backend
Python
FastAPI AI
Open-weight LLM
Local inference Other
Git
GitHub ✨ Main Features
Personalized Study Plan The user provides their subjects, available time and exam date. The application generates a structured study schedule.
Topic Explanation My friend can enter a difficult topic and ask the AI to explain it in simpler language.
Practice Questions StudyBuddy can generate questions based on the selected topic.
Quick Quiz The user can test themselves after studying a topic.
Personalized Interaction Instead of giving the same generic response to everyone, the application uses the user's study information to make the interaction more relevant. 🔓 Why Open Innovation Matters Using an open model was an important part of this project. With a closed AI service, I would be depending on a specific provider and its API. With an open-based approach, I can experiment with the model itself and potentially run it locally. For this particular project, that matters because study schedules and personal learning information can be sensitive. The ability to experiment, switch models and potentially keep the data local gives me more control over the application. 👨‍💻 Building It for a Real Person The most important part of this challenge wasn't the technology. It was building something for one specific person. I first asked my friend what they found difficult about studying and used that feedback to decide what features to build. Instead of starting with: “What AI application can I build?”

I started with:
“What problem does my friend actually have?”

That changed the way I approached the project.
🧪 What I Learned
While building StudyBuddy AI, I learned that building an AI application isn't only about choosing a model.
The surrounding product matters just as much.
I had to think about:

How the user provides information
How prompts should be structured
How AI responses should be presented
How to make the output actually useful
How an open model can fit into a real application ❤️ The Result The final goal wasn't to build the biggest AI application. It was to build something small that solves a real problem for someone I know. That was the most interesting part of Build for a Friend.

🚀 DEV Post — Ready-to-use content

RAGHUL P — Fri, 02 Oct 2026 18:31:10 +0000

Experiment with different models
Run inference locally
Keep personal study information on the user's machine
Change the model without redesigning the entire application
Experiment with prompts and AI behavior This was one of the main reasons I chose an open-based approach for this project. 🏗️ How I Built It The basic architecture looks like this: Friend's Input ↓ React Web Interface ↓ Backend / AI Service ↓ Open-Weight Language Model ↓ AI-Generated Study Plan ↓ Practice / Quiz / Explanation

Technology Stack
Frontend

React
JavaScript
CSS Backend
Python
FastAPI AI
Open-weight LLM
Local inference Other
Git
GitHub ✨ Main Features
Personalized Study Plan The user provides their subjects, available time and exam date. The application generates a structured study schedule.
Topic Explanation My friend can enter a difficult topic and ask the AI to explain it in simpler language.
Practice Questions StudyBuddy can generate questions based on the selected topic.
Quick Quiz The user can test themselves after studying a topic.
Personalized Interaction Instead of giving the same generic response to everyone, the application uses the user's study information to make the interaction more relevant. 🔓 Why Open Innovation Matters Using an open model was an important part of this project. With a closed AI service, I would be depending on a specific provider and its API. With an open-based approach, I can experiment with the model itself and potentially run it locally. For this particular project, that matters because study schedules and personal learning information can be sensitive. The ability to experiment, switch models and potentially keep the data local gives me more control over the application. 👨‍💻 Building It for a Real Person The most important part of this challenge wasn't the technology. It was building something for one specific person. I first asked my friend what they found difficult about studying and used that feedback to decide what features to build. Instead of starting with: “What AI application can I build?”

I started with:
“What problem does my friend actually have?”

How the user provides information
How prompts should be structured
How AI responses should be presented
How to make the output actually useful
How an open model can fit into a real application ❤️ The Result The final goal wasn't to build the biggest AI application. It was to build something small that solves a real problem for someone I know. That was the most interesting part of Build for a Friend.

Building Samar: My 10-Day Voice AI Agent Journey with Murf Falcon

RAGHUL P — Sat, 15 Aug 2026 06:22:37 +0000

Building Samar: My 10-Day Voice AI Agent Journey with Murf Falcon

Over the past 10 days, I built Samar, a multilingual AI voice agent for a Bharat Digital Bank use case as part of the 10 Days of Voice Agents – VoiceForBharat Edition challenge.

The project started as a simple voice assistant and gradually evolved into a more complete Voice AI system capable of remembering users, using real-time tools, making outbound calls, escalating sensitive situations to humans, analyzing calls, and handing specialized conversations to another AI agent.

🎯 The Problem

Banking can sometimes be difficult to navigate, especially when users need quick information or assistance without going through multiple screens and menus.

I wanted to build a voice-first banking assistant that could provide natural conversations while also maintaining security and knowing when it should involve a human.

That's where Samar comes in.

🤖 What is Samar?

Samar is a multilingual banking voice agent designed to help users with general banking-related queries.

It can:

Answer general banking questions
Provide financial information
Remember returning users with consent
Fetch real-time information using tools
Find nearby branches
Provide exchange-rate information
Make outbound reminder calls
Escalate sensitive issues to human support
Track call analytics
Hand specialized conversations to a specialist agent

The voice experience is powered by Murf Falcon, the fastest TTS API used in this challenge.

🏗️ How the System Works

At a high level, the voice interaction follows this flow:

User Speech
↓
Speech-to-Text
↓
LLM / Agent Logic
↓
Memory or Tool Calling
↓
Text-to-Speech
↓
User hears the response

The system uses real-time voice communication through LiveKit, an LLM for reasoning and conversation, speech recognition for understanding the user, and Murf Falcon for natural voice generation.

🚀 Important Features

1. Voice AI with Guardrails

Samar has a clear banking role and follows safety rules.

It does not ask users for sensitive information such as:

PIN
OTP
CVV
Passwords
Full account credentials

For sensitive requests, it knows its limits instead of pretending it can access protected information.

2. Multilingual Conversations

Samar supports multilingual conversations and follows native-script requirements.

For example:

Hindi → Devanagari

English → Latin script

This helped improve the naturalness and correctness of multilingual responses.

3. Persistent Memory

Samar can remember returning users after receiving explicit permission.

The system stores useful profile information and retrieves it during future conversations.

This allows the experience to become more personalized instead of starting from zero every time.

4. Real-Time Tools

I added tools that allow Samar to access useful information instead of relying only on the LLM.

For example:

Exchange-rate lookup
Nearby branch lookup
Banking-related information

The agent decides when a tool is needed and presents the result naturally to the user.

5. Outbound Calls

Samar can initiate outbound calls instead of only waiting for users to contact the agent.

One use case is a banking reminder where Samar proactively contacts the user with an important update.

6. Human Escalation

A good AI agent should know when it cannot safely handle something.

For example, if a user reports potential fraud, Samar can ask for permission to create a support request and escalate the issue to human assistance.

7. Call Analytics

I built a Call Analytics Dashboard to understand how the voice agent is performing.

The dashboard can provide insights such as:

Total calls
Completed calls
Human escalations
Average call duration
Tool usage
Call trends
Language distribution
Recent escalations

This makes it easier to understand user interactions and improve the agent.

8. Specialist Agent Handoff

Finally, Samar does not have to be an expert in everything.

For specialized questions, the main agent can hand the conversation to a specialist agent.

For example:

User → Samar → Loan Specialist

The specialist can then continue the conversation with more focused knowledge.

🧩 A Major Challenge I Faced

One of the challenges I faced was multilingual voice handling.

The agent could understand Hindi, but the generated voice could sound like an English-accented response when the language configuration was not handled correctly.

I addressed this by configuring multilingual speech recognition and dynamic voice/locale handling, while also enforcing the correct native script for each language.

This taught me that multilingual Voice AI is not just about understanding different languages. Speech recognition, language detection, script generation, and voice synthesis all need to work together.

🛠️ How to Run the Project

Clone the repository:


bash
git clone YOUR_GITHUB_REPOSITORY_URL
Backend
cd backend
uv sync
uv run python src/agent.py dev
Frontend

Open another terminal:

cd frontend
pnpm install
pnpm dev

Then open:

http://localhost:3000

Connect to Samar and start a conversation.

🔐 Environment Variables

Never publish API keys directly in your source code or GitHub repository.

Store credentials in environment variables such as:

MURF_API_KEY=your_key
DEEPGRAM_API_KEY=your_key
GOOGLE_API_KEY=your_key
LIVEKIT_API_KEY=your_key
LIVEKIT_API_SECRET=your_secret
LIVEKIT_URL=your_url