What is Mcpserver Smartbulb Python

IntelliGlow is an AI-Powered Smart Lighting system that integrates a Model Context Protocol (MCP) server allowing AI assistants to control physical smart bulbs through UDP network communication. It combines hardware control, voice commands, and AI reasoning to create an interactive smart lighting experience.

Use cases

IntelliGlow can be used in various scenarios such as automatically adjusting lighting based on user preferences, creating ambient lighting for different activities (e.g., reading, relaxing, working), and enhancing home automation systems where lighting responds to voice commands or AI-driven workflows.

How to use

To get started, install IntelliGlow via pip and configure the smart bulb’s IP address and port if needed. Run the server for MCP or voice interface, or both. Users can issue voice commands to control the bulbs or interact with the AI for more complex lighting adjustments. Test network connectivity with a provided script.

Key features

IntelliGlow features real hardware support with UDP communication, natural voice command processing, and AI integration for contextual lighting control. It supports multiple bulbs, offers network discovery, and allows for brightness and color control with a user-friendly interface.

Where to use

IntelliGlow is suitable for use in residential homes, offices, and any smart environment where lighting plays a crucial role. It is particularly effective in settings that benefit from customizable and adaptive lighting solutions, enhancing both convenience and user experience.

💡 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

Feature	Alexa/Google	IntelliGlow
Voice Control	✅ Basic commands	✅ Natural language + AI reasoning
AI Integration	❌ Limited ecosystem	✅ Works with any AI model (Claude, GPT, etc.)
Hardware Control	❌ Cloud-dependent	✅ Direct UDP networking
Customization	❌ Vendor limitations	✅ Full control over protocol
Context Understanding	❌ Simple keywords	✅ AI understands context and workflows
Privacy	❌ Cloud processing	✅ Local processing
Developer Freedom	❌ Closed ecosystem	✅ Open protocol, extensible

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