•

Published December 28, 2025 © MIT

Mentor Mitra AI: Edge-Powered Robotic Mentor for Kids

Privacy first robotic companion running edge AI locally. Combines vision, voice & emotion detection, no cloud dependency, 101% privacy.

IntermediateWork in progress5 days20

Mentor Mitra AI: Edge-Powered Robotic Mentor for Kids

Things used in this project

Hardware components

Raspberry Pi 5

Raspberry PI AI Camera

Espressif ESP32 Development Board - Developer Edition

GC9A01 - Round Displays 1.28

LDR, 5 Mohm

Seeed Studio EMax 12g ES08MD high Sensitive servo

DFRobot Gravity: Analog Sound Sensor For Arduino

Speaker: 3W, 4 ohms

Desktop Microphone, Unidirectional

Seeed Studio Grove - I2C Touch Sensor(MPR121)

RFduino Battery Shield

Li-Ion Battery 1000mAh

DC/DC Converter, Buck Regulator

Jumper wires (generic)

Software apps and online services

Arduino IDE

Ollama

Raspberry Pi Raspbian

Home Assistant

Ubuntu

Llama 3.2

Whisper

Home Assistant Wyoming Protocol

Piper

OpenCV

Face Recognition

Emotion Recognition

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

PCBWay 3D Printing

Story

Mentor Mitra AI : Edge-Powered Robotic Mentor for Kids

Mentor Mitra AI — Live Demonstration & System Walkthrough

YouTube video showcasing Mentor Mitra AI — system overview, live interaction, and edge-AI capabilities

What Is Mentor Mitra AI?

Mentor Mitra AI is a privacy-first, edge-powered robotic companion designed to act as a child’s mentor, friend, and adaptive learning partner. It is not a toy, and it is not a cloud chatbot disguised as one. Mentor Mitra is a fully embodied AI system that lives entirely within your home, runs on hardware you control, and keeps a child’s data exactly where it belongs: offline and private.

At its core, Mentor Mitra AI operates using locally hosted artificial intelligence, including a self-hosted large language model (LLaMA 3.2B parameters) running on a dedicated on-premises server. No conversations are uploaded, no emotions are analyzed in the cloud, and no learning profiles are shared with third parties.

Recognition & Early Validation (Mentor Mitra V1)

https://www.elecrow.com/sharepj/mentor-mitra-ai-interactive-toy-with-voice-and-emotions-818.html?srsltid=AfmBOorMbmfbNiDp6HVuuFPJYk4rY3E1e3TDS91qZfahgLEpdFnqaIu

2nd Place — Elecrow Electronic Design Contest | Mentor Mitra V1

Image showing 2nd place win at the Elecrow Electronic Design Contest (Mentor Mitra V1)

Mentor Mitra began as an experimental idea and quickly gained recognition in national and international innovation forums. Early validation came when Mentor Mitra V1 secured 2nd position in the Elecrow Electronic Design Contest, reinforcing the technical and conceptual strength of the project.

Note: This repository primarily documents Mentor Mitra V2, the evolved and significantly enhanced version of the system.

Why We Built It

Mentor Mitra began with a simple but powerful realization:Children need more than screens. They need understanding.

As generative AI advanced rapidly, most solutions became increasingly cloud-dependent—raising serious concerns around privacy, latency, reliability, and control, especially for children.

Mentor Mitra was built on three core beliefs:

Privacy First: A child’s emotions and learning data should never leave the home
Intelligence at the Edge: Edge hardware is powerful enough to run modern AI locally
Embodied Learning: Physical presence creates deeper engagement and trust

Evolution of Mentor Mitra (7-Month Development Journey)

Mentor Mitra — 7 Months of Iterative Development (V1 → V2)

Image showing the evolution of Mentor Mitra over the last 7 months — hardware, architecture, embodiment

Over seven months, Mentor Mitra evolved from a basic embedded prototype into a fully embodied, multimodal, privacy-preserving AI system, incorporating robotics, vision, voice, and emotion intelligence.

How Mentor Mitra AI Works

Mentor Mitra AI is structured across three tightly integrated layers:

Layer 1: Multimodal Sensing

(Voice, vision, emotion, touch, temperature, light)

Layer 2: Edge Intelligence

(Local LLMs, orchestration, automation, offline inference)

Layer 3: Expressive Embodiment

(Animated eyes, face tracking, sound-reactive motion, physical presence)

Community & Industry Engagement

https://www.linkedin.com/posts/ankur-majumdar-487824278_mitra-v2-our-first-working-prototype-is-activity-7365297769256845313

Image showing LinkedIn reach, reactions, impressions, and engagement

Mentor Mitra AI sparked strong engagement across professional and maker communities, validating the growing interest in privacy-first edge AI and robotics.

Achievements Timeline

Mentor Mitra AI — Recognition & Milestones Timeline

Timeline image showing key milestones, prizes, and recognitions

Key highlights include:

E-Toycathon 2025 — 2nd Position (C-DAC, MeitY, Govt. of India)
5G Hackathon Pragati — Top 50 Nationwide (DoT, India)
₹1, 00, 000 + ₹1, 00, 000 seed funding
India Mobile Congress 2025 Fin

Media & Public Spotlight

Mentor Mitra AI — Media & Public Showcase

Image showing media mentions, event showcases, or public demonstrations

Mentor Mitra AI has been demonstrated across government innovation forums, hackathons, and public exhibitions, highlighting the real-world viability of edge AI in education.

Why This Project Matters

Mentor Mitra AI challenges the assumption that all intelligence must live in the cloud. It demonstrates that:

Edge AI is production-ready
Privacy and intelligence are not trade-offs
Emotionally aware AI can exist without surveillance
Robotics and AI become meaningful when thoughtfully integrated

Vision Forward

Mentor Mitra AI represents the intersection of:

Embedded Systems
Edge AI
Human–Robot Interaction
Educational Technology
Privacy-First Design

Future directions include deeper emotion understanding, gesture-based interaction, multi-device collaboration, and institutional deployment.

Mentor Mitra AI

Because every child deserves a private, intelligent companion.

Wanna Read and Learn more -

https://indiasgotintelligence.com/IGI-Stories/Post/3175/Meet-Mentor-Mitra-AI-A-friend-a-companion-a-mentor-every-child-deserves

Custom parts and enclosures

Sketchfab still processing.

Schematics

Code

ESP32-Based Head & Hand Control Architecture

#include <ESP32Servo.h>

// ----- Sound trigger config -----
#define SOUND_SENSOR_PIN 18        // digital OUT from sound module (active LOW)
unsigned long lastEventMs = 0;
const unsigned long refractoryMs = 300; // ignore retriggers within this window

// ----- Servo objects -----
Servo panServo;    // Pan (GPIO12)
Servo tiltServo;   // Tilt (GPIO13)
Servo servoA;      // Extra servo A (GPIO32)
Servo servoB;      // Extra servo B (GPIO33)

// ----- GPIO assignments -----
const int panPin   = 12;  // Pan
const int tiltPin  = 13;  // Tilt
const int servoAPin = 32; // extra 1
const int servoBPin = 33; // extra 2

// ----- Center positions -----
const int panCenter  = 130;
const int tiltCenter = 80;

// ----- Position tracking -----
int currentPanAngle  = 90;
int currentTiltAngle = 90;

// ----- Function declarations -----
void runDemo();
void centerServos();
void processCommand(String command);
void showCommands();
void smoothMove(Servo &servo, int startAngle, int endAngle, int &currentPos, int delayMs = 15);

void setup() {
  Serial.begin(115200);
  Serial.println("ESP32 4-Servo + Sound Controller Ready");

  // Sound input
  pinMode(SOUND_SENSOR_PIN, INPUT_PULLUP);

  // Allocate timers and set servo frequency
  ESP32PWM::allocateTimer(0);
  ESP32PWM::allocateTimer(1);
  ESP32PWM::allocateTimer(2);
  ESP32PWM::allocateTimer(3);

  panServo.setPeriodHertz(50);
  tiltServo.setPeriodHertz(50);
  servoA.setPeriodHertz(50);
  servoB.setPeriodHertz(50);

  // Attach with explicit pulse widths
  panServo.attach(panPin,   500, 2400);
  tiltServo.attach(tiltPin, 500, 2400);
  servoA.attach(servoAPin,  500, 2400);
  servoB.attach(servoBPin,  500, 2400);

  // Initialize at tracked positions
  panServo.write(currentPanAngle);
  tiltServo.write(currentTiltAngle);
  servoA.write(0);
  servoB.write(0);

  Serial.println("Pins: Pan=GPIO12, Tilt=GPIO13, A=GPIO32, B=GPIO33; Sound=GPIO18 (LOW=event)");
  Serial.println("Enter 'help' for commands; sound will randomize A/B servos 090");
}

void loop() {
  // ----- Sound-triggered random moves for servoA/servoB -----
  int soundState = digitalRead(SOUND_SENSOR_PIN); // LOW = sound detected
  unsigned long now = millis();
  if (soundState == LOW && (now - lastEventMs) > refractoryMs) {
    int a = random(0, 91); // 0..90 inclusive
    int b = random(0, 91);

    servoA.write(a);
    servoB.write(b);

    Serial.print(" Sound! A=");
    Serial.print(a);
    Serial.print(", B=");
    Serial.print(b);
    Serial.println("");

    lastEventMs = now;
  }

  // ----- Serial command handling for pan/tilt -----
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    command.toLowerCase();
    if (command.length() > 0) {
      processCommand(command);
    }
  }

  delay(10);
}

// Smooth movement with position tracking
void smoothMove(Servo &servo, int startAngle, int endAngle, int &currentPos, int delayMs) {
  if (startAngle == endAngle) return;
  int step = (startAngle < endAngle) ? 1 : -1;
  Serial.print("Moving: " + String(startAngle) + "  " + String(endAngle) + " ");
  for (int angle = startAngle; angle != endAngle + step; angle += step) {
    servo.write(angle);
    currentPos = angle;
    delay(delayMs);
    if (abs(angle - startAngle) % 10 == 0) Serial.print(".");
  }
  Serial.println(" ");
}

void runDemo() {
  Serial.println(" [DEMO] Starting smooth 180x180 demonstration...");
  Serial.println(" Moving to start position (0, 0)");
  smoothMove(panServo,  currentPanAngle,  0, currentPanAngle, 10);
  smoothMove(tiltServo, currentTiltAngle, 0, currentTiltAngle, 10);
  delay(1000);
  Serial.println("  Pan sweep: 0  180");
  smoothMove(panServo, currentPanAngle, 180, currentPanAngle, 12);
  delay(500);
  Serial.println("  Tilt sweep: 0  180");
  smoothMove(tiltServo, currentTiltAngle, 180, currentTiltAngle, 12);
  delay(500);
  Serial.println("  Pan return: 180  0");
  smoothMove(panServo, currentPanAngle, 0, currentPanAngle, 12);
  delay(500);
  Serial.println("  Tilt return: 180  0");
  smoothMove(tiltServo, currentTiltAngle, 0, currentTiltAngle, 12);
  delay(500);
  Serial.println(" [DEMO] Complete! Current position: Pan=" + String(currentPanAngle) + ", Tilt=" + String(currentTiltAngle) + "");
  Serial.println();
}

void centerServos() {
  Serial.println(" [CENTER] Moving to center positions...");
  Serial.println("   Pan: " + String(currentPanAngle) + "  " + String(panCenter) + "");
  Serial.println("   Tilt: " + String(currentTiltAngle) + "  " + String(tiltCenter) + "");
  smoothMove(panServo,  currentPanAngle,  panCenter,  currentPanAngle, 15);
  smoothMove(tiltServo, currentTiltAngle, tiltCenter, currentTiltAngle, 15);
  Serial.println(" [CENTER] Complete! Servos centered at Pan=" + String(panCenter) + ", Tilt=" + String(tiltCenter) + "");
  Serial.println();
}

void processCommand(String command) {
  Serial.println(" Command received: '" + command + "'");
  if (command == "center") {
    centerServos();
  } else if (command == "demo") {
    runDemo();
  } else if (command.startsWith("pan ")) {
    int angle = command.substring(4).toInt();
    if (angle >= 0 && angle <= 180) {
      Serial.println("  [PAN] " + String(currentPanAngle) + "  " + String(angle) + "");
      smoothMove(panServo, currentPanAngle, angle, currentPanAngle, 15);
      Serial.println(" [PAN] Complete! Pan servo at " + String(angle) + "");
    } else {
      Serial.println(" ERROR: Pan angle must be 0-180");
    }
  } else if (command.startsWith("tilt ")) {
    int angle = command.substring(5).toInt();
    if (angle >= 0 && angle <= 180) {
      Serial.println("  [TILT] " + String(currentTiltAngle) + "  " + String(angle) + "");
      smoothMove(tiltServo, currentTiltAngle, angle, currentTiltAngle, 15);
      Serial.println(" [TILT] Complete! Tilt servo at " + String(angle) + "");
    } else {
      Serial.println(" ERROR: Tilt angle must be 0-180");
    }
  } else if (command.startsWith("both ")) {
    int spaceIndex = command.indexOf(' ', 5);
    if (spaceIndex > 0) {
      int panAngle  = command.substring(5, spaceIndex).toInt();
      int tiltAngle = command.substring(spaceIndex + 1).toInt();
      if (panAngle >= 0 && panAngle <= 180 && tiltAngle >= 0 && tiltAngle <= 180) {
        Serial.println(" [BOTH] Moving simultaneously:");
        Serial.println("   Pan: " + String(currentPanAngle) + "  " + String(panAngle) + "");
        Serial.println("   Tilt: " + String(currentTiltAngle) + "  " + String(tiltAngle) + "");
        int panSteps  = abs(panAngle  - currentPanAngle);
        int tiltSteps = abs(tiltAngle - currentTiltAngle);
        int maxSteps  = max(panSteps, tiltSteps);
        if (maxSteps > 0) {
          Serial.print("Moving both servos ");
          for (int step = 0; step <= maxSteps; step++) {
            int newPanAngle  = map(step, 0, maxSteps, currentPanAngle,  panAngle);
            int newTiltAngle = map(step, 0, maxSteps, currentTiltAngle, tiltAngle);
            panServo.write(newPanAngle);
            tiltServo.write(newTiltAngle);
            delay(15);
            if (step % 10 == 0) Serial.print(".");
          }
          Serial.println(" ");
          currentPanAngle  = panAngle;
          currentTiltAngle = tiltAngle;
        }
        Serial.println(" [BOTH] Complete! Pan=" + String(panAngle) + ", Tilt=" + String(tiltAngle) + "");
      } else {
        Serial.println(" ERROR: Both angles must be 0-180");
      }
    } else {
      Serial.println(" ERROR: Usage: both <pan_angle> <tilt_angle>");
    }
  } else if (command.startsWith("speed ")) {
    int speed = command.substring(6).toInt();
    if (speed >= 5 && speed <= 50) {
      Serial.println(" [SPEED TEST] Testing with " + String(speed) + "ms delay");
      Serial.println("   Pan: 0  90  180  center");
      smoothMove(panServo, currentPanAngle, 0,   currentPanAngle, speed);
      smoothMove(panServo, currentPanAngle, 90,  currentPanAngle, speed);
      smoothMove(panServo, currentPanAngle, 180, currentPanAngle, speed);
      smoothMove(panServo, currentPanAngle, panCenter, currentPanAngle, speed);
      Serial.println(" [SPEED TEST] Complete!");
    } else {
      Serial.println(" ERROR: Speed must be 5-50ms delay");
    }
  } else if (command == "status") {
    Serial.println(" [STATUS] Current servo positions:");
    Serial.println("   Pan (GPIO12):  " + String(currentPanAngle)  + "");
    Serial.println("   Tilt (GPIO13): " + String(currentTiltAngle) + "");
    Serial.println("   Pan center:    " + String(panCenter)  + "");
    Serial.println("   Tilt center:   " + String(tiltCenter) + "");
  } else if (command == "help" || command == "commands") {
    showCommands();
  } else {
    Serial.println(" Unknown command: '" + command + "'");
    Serial.println(" Type 'help' for available commands");
  }
  Serial.println();
}

void showCommands() {
  Serial.println("");
  Serial.println("           AVAILABLE COMMANDS         ");
  Serial.println("");
  Serial.println(" center            - Move to center   ");
  Serial.println(" demo              - Run 180x180 demo ");
  Serial.println(" pan <angle>       - Set pan (0-180)  ");
  Serial.println(" tilt <angle>      - Set tilt (0-180) ");
  Serial.println(" both <pan> <tilt> - Set both angles  ");
  Serial.println(" speed <5-50>      - Test speed       ");
  Serial.println(" status            - Show positions   ");
  Serial.println(" help              - Show this help   ");
  Serial.println("");
  Serial.println();
  Serial.println("Examples:");
  Serial.println("  pan 90        Move pan to 90");
  Serial.println("  tilt 45       Move tilt to 45");
  Serial.println("  both 130 80   Move to center positions");
  Serial.println("  speed 10      Test with 10ms delay");
  Serial.println();
}