What is Intelliglow Ai Voice Mcp Iot Platform

IntelliGlow-AI-Voice-MCP-IoT-Platform is an AI-powered smart lighting system that enables voice-controlled management of real smart bulbs through a Model Context Protocol (MCP) server. It utilizes UDP network communication to provide seamless interaction between AI assistants and smart lighting hardware.

Use cases

Use cases include voice-activated lighting control in homes, automated lighting adjustments based on user preferences, integration with other AI workflows for enhanced smart home experiences, and real-time monitoring of lighting systems.

How to use

To use IntelliGlow, simply connect your smart bulbs to the network and configure the server to communicate via UDP. You can then issue voice commands to control the lighting, such as turning on/off, adjusting brightness, or changing colors. The system also provides text-to-speech feedback for user interactions.

Key features

Key features include real hardware support with UDP communication, natural voice command recognition, AI integration for context understanding, smart bulb control for power, brightness, and color, as well as network features like multi-bulb support and automatic discovery.

Where to use

IntelliGlow is ideal for smart homes, offices, and any environment where automated lighting control is desired. It can be used in residential settings, commercial spaces, and even in smart city applications.

💡 IntelliGlow - AI-Powered Smart Lighting

“Smart lighting, brilliantly simple”

IntelliGlow is a Model Context Protocol (MCP) server that allows AI assistants like Claude and ChatGPT to control real smart bulbs via UDP network communication. This Python implementation features voice commands, AI reasoning, and direct hardware control.

🏗️ Architecture

Voice/AI ──> IntelliGlow MCP ──> UDP Network ──> Smart Bulb (192.168.1.45:4000)

The smart bulb system that actually thinks!!

🌟 Features

🔴 Real Hardware Support

• UDP Network Communication: Direct communication with real smart bulbs
• Default Bulb Configuration: Connects to 192.168.1.45:4000 by default
• Network Discovery: Automatically find smart bulbs on your network
• Connection Management: Persistent connections with auto-reconnect

🎤 Voice Intelligence

• Natural Voice Commands: “Turn on lights”, “Set brightness to 75”, “Make it blue”
• AI-Powered Parsing: Understands context and natural language
• Text-to-Speech Feedback: Speaks responses back to you
• Smart Color Recognition: Recognizes color names and descriptive terms

🧠 AI Integration

• MCP Protocol: Works with Claude, GPT, and other AI models
• Context Understanding: AI can reason about lighting needs
• Workflow Integration: Bulbs become part of larger AI workflows
• Learning Capability: Can adapt to user patterns and preferences

🔧 Smart Bulb Control

• Power Control: Turn bulbs on/off via UDP commands
• Brightness Control: Adjust brightness levels (0-100%)
• Color Control: Full RGB control with hex color codes (#FF0000)
• Status Monitoring: Get real-time bulb status
• Ping/Connectivity: Test network connectivity to bulbs

🌐 Network Features

• Multi-bulb Support: Connect to multiple bulbs simultaneously
• Discovery: Scan network for available smart bulbs
• Environment Configuration: Set bulb IP/port via environment variables

🚀 Quick Start

Installation

1. Install IntelliGlow:

   # Core system
   pip install -e .
   
   # With voice capabilities
   pip install -e .[voice]
   

2. Configure your bulb (optional):

   export BULB_IP=192.168.1.45    # Your bulb's IP
   export BULB_PORT=4000          # Your bulb's port
   

Running IntelliGlow

# 1. MCP server only (for AI integration)
mcp-server-smartbulb

# 2. Voice interface only
mcp-server-smartbulb-voice

# 3. Complete IntelliGlow system (voice + AI + MCP)
python voice_enabled_server.py

Testing Network Connectivity

# Test UDP communication with your real bulb
python test_network_bulbs.py

🔧 AI Integration (Claude Desktop)

Add this to your Claude Desktop claude_desktop_config.json:

{
  "mcpServers": {
    "intelliglow": {
      "command": "python",
      "args": [
        "-m",
        "mcp_server_smartbulb.network_server"
      ],
      "cwd": "/path/to/your/IntelliGlow",
      "env": {
        "BULB_IP": "192.168.1.45",
        "BULB_PORT": "4000"
      }
    }
  }
}

🛠️ Available Commands

🎤 Voice Commands

• “Turn on the lights” - Power control
• “Set brightness to 75 percent” - Brightness with smart parsing
• “Make it blue” - Color recognition
• “How are the lights?” - Status inquiry
• “Find smart bulbs” - Network discovery

🤖 MCP Tools (for AI)

• discover_bulbs() - Find smart bulbs on the network
• connect_to_bulb(ip, port) - Connect to a specific bulb
• turn_on_bulb(ip, port) - Turn on a bulb via UDP
• turn_off_bulb(ip, port) - Turn off a bulb via UDP
• set_bulb_brightness(brightness, ip, port) - Set brightness (0-100)
• set_bulb_color(color, ip, port) - Set color using hex codes
• get_bulb_status(ip, port) - Get current bulb status
• ping_bulb(ip, port) - Test connectivity to a bulb

📡 Network Configuration

Default Bulb Setup

IntelliGlow connects to 192.168.1.45:4000 by default. You can override this:

export BULB_IP=192.168.1.100
export BULB_PORT=4001

Bulb Configuration File

Create bulb_config.json:

{
  "default_bulb": {
    "ip": "192.168.1.45",
    "port": 4000,
    "timeout": 5
  },
  "discovery": {
    "enabled": true,
    "timeout": 10,
    "port_range": {
      "start": 4000,
      "end": 4010
    }
  }
}

🔍 IntelliGlow vs Traditional Solutions

Result: IntelliGlow = Convenience of Alexa + Intelligence of AI + Freedom of Open Source! 🎉

🧪 Testing

# Test real UDP communication with your bulb
python test_network_bulbs.py

This will:

1. 🔌 Test direct connection to 192.168.1.45:4000
2. 🔍 Scan network for other bulbs
3. 🤖 Simulate AI/MCP commands
4. 🎤 Test voice command processing

🐛 Troubleshooting

No Bulb Found

• Ensure your smart bulb is on the same network
• Check that the bulb is listening on port 4000
• Try network discovery: python -c "import asyncio; from mcp_server_smartbulb.bulb_discovery import BulbDiscovery; asyncio.run(BulbDiscovery().discover_bulbs())"

Voice Not Working

• Install voice dependencies: pip install -e .[voice]
• Check microphone permissions
• Test with: python -m mcp_server_smartbulb.voice_interface

Connection Timeout

• Check firewall settings
• Verify bulb IP address
• Increase timeout in bulb_config.json

📁 Project Structure

IntelliGlow/
├── mcp_server_smartbulb/
│   ├── __init__.py              # Package initialization 
│   ├── network_server.py        # Main UDP-enabled MCP server
│   ├── udp_client.py           # UDP networking client
│   ├── bulb_discovery.py       # Network discovery
│   └── voice_interface.py      # Voice command processing
├── bulb_config.json            # Network configuration
├── test_network_bulbs.py       # UDP testing script
├── voice_enabled_server.py     # Complete IntelliGlow system
├── README.md                   # This file
└── pyproject.toml              # Project configuration

Clean, focused, and intelligent! 🧠💡

🎯 What Makes IntelliGlow Special

IntelliGlow isn’t just another smart bulb controller - it’s the bridge between AI intelligence and physical hardware.

🔥 Key Innovations:

• AI-Native Design: Built for AI reasoning, not just voice commands
• Open Protocol: Works with any AI model, not locked to one vendor
• Local Processing: Privacy-focused, no cloud dependency required
• Hybrid Interface: Voice + AI chat + MCP protocol
• Developer Freedom: Full customization and extensibility

🌟 Real-World Magic:

User: "I'm working late and need focus lighting"
IntelliGlow: 
→ AI understands context
→ Sets cool white light (5000K)
→ Optimal brightness (85%)
→ Direct UDP communication
→ Responds with confirmation

This is the future of smart homes - lighting that truly understands and adapts to your needs! 🚀

Made with ❤️ for the next generation of intelligent home automation