class IntelligentRouter {
private:
    float complexityThreshold = 0.7;
    
public:
    ProcessingMethod routeRequest(const VoiceCommand& cmd) {
        float complexity = analyzeComplexity(cmd);
        
        if (complexity < complexityThreshold) {
            return ProcessingMethod::LOCAL_EDGE;
        } else {
            return ProcessingMethod::DEEPSEEK_CLOUD;
        }
    }
    
    float analyzeComplexity(const VoiceCommand& cmd) {
        // Complexity evaluation algorithm
        return cmd.hasMultipleEntities() * 0.3 +
               cmd.requiresReasoning() * 0.4 +
               cmd.needsContextHistory() * 0.3;
    }
};

class DeepSeekIntegration {
private:
    static constexpr char* API_ENDPOINT = "https://api.deepseek.com/v1/chat/completions";
    static constexpr int MAX_RETRIES = 3;
    static constexpr int TIMEOUT_MS = 3000;
    
public:
    std::string processWithDeepSeek(const std::string& userInput) {
        json request = {
            {"model", "deepseek-chat"},
            {"messages", {
                {{"role", "system"}, {"content", getSystemPrompt()}},
                {{"role", "user"}, {"content", userInput}}
            }},
            {"max_tokens", 500},
            {"temperature", 0.7}
        };
        
        return sendAPIRequest(request);
    }
    
private:
    std::string getSystemPrompt() {
        return "You are XiaoZhi AI assistant, specialized in providing control and information services for smart home devices. "
               "Please reply with concise, friendly language and provide device control commands when needed.";
    }
};

# Download XiaoZhi AI pre-compiled firmware
wget https://github.com/xiaozhidev/xiaozhi-firmware/releases/latest/xiaozhi-ai-deepseek.bin

# Flash to ESP32-S3
esptool.py --chip esp32s3 --port /dev/ttyUSB0 --baud 921600 \
  write_flash -z 0x0 xiaozhi-ai-deepseek.bin

{
  "wifi": {
    "ssid": "YourWiFiName",
    "password": "YourPassword"
  },
  "deepseek": {
    "api_key": "sk-xxxxxxxxxxxxxxxxxxxxx",
    "model": "deepseek-chat",
    "max_tokens": 500,
    "temperature": 0.7
  },
  "voice": {
    "wake_word": "Hello XiaoZhi",
    "language": "en-us",
    "tts_voice": "female_warm"
  }
}

# Voice wake-up test
Say: "Hello XiaoZhi"
Expected: LED lights up, response tone

# Simple command test (local processing)
User: "Turn on living room light"
System: [Local recognition] → [MQTT control] → "Sure, I've turned on the living room light"

# Complex dialogue test (DeepSeek processing)
User: "Is today's weather suitable for drying clothes?"
System: [DeepSeek analysis] → "Today's weather is sunny with low humidity, very suitable for drying clothes"

struct CommandComplexity {
    float entityCount;      // Entity count weight (0.0-1.0)
    float syntaxComplexity; // Syntax complexity weight (0.0-1.0)  
    float contextDependency; // Context dependency weight (0.0-1.0)
    float domainSpecific;   // Domain-specific weight (0.0-1.0)
    
    float getOverallComplexity() const {
        return (entityCount * 0.25 + 
                syntaxComplexity * 0.35 + 
                contextDependency * 0.25 + 
                domainSpecific * 0.15);
    }
};

class EdgeIntelligenceEngine {
public:
    ProcessingDecision analyze(const VoiceCommand& cmd) {
        CommandComplexity complexity = evaluateComplexity(cmd);
        
        if (complexity.getOverallComplexity() < 0.4) {
            return {ProcessingMethod::LOCAL, "Simple device control command"};
        } else if (complexity.getOverallComplexity() < 0.7) {
            return {ProcessingMethod::HYBRID, "Requires lightweight cloud assistance"};
        } else {
            return {ProcessingMethod::DEEPSEEK_FULL, "Complex reasoning requires DeepSeek processing"};
        }
    }
};

class LocalKnowledgeCache {
private:
    LRUCache<std::string, AIResponse> responseCache;
    BloomFilter knownPatterns;
    
public:
    bool tryLocalResponse(const std::string& input, AIResponse& response) {
        // 1. Exact match cache
        if (responseCache.contains(input)) {
            response = responseCache.get(input);
            return true;
        }
        
        // 2. Pattern matching
        if (knownPatterns.contains(extractPattern(input))) {
            response = generateTemplateResponse(input);
            return true;
        }
        
        return false; // Requires cloud processing
    }
    
    void updateCache(const std::string& input, const AIResponse& response) {
        responseCache.put(input, response);
        knownPatterns.add(extractPattern(input));
    }
};

class PromptOptimizer {
private:
    std::string deviceContext;
    std::vector<std::string> recentHistory;
    
public:
    std::string generateContextualPrompt(const std::string& userInput) {
        std::string systemPrompt = R"(
You are XiaoZhi AI assistant, currently controlling devices including: )" + deviceContext + R"(

User's recent interaction history:
)";
        
        for (const auto& history : recentHistory) {
            systemPrompt += "- " + history + "\n";
        }
        
        systemPrompt += R"(
Please provide useful, accurate responses based on context, generating device control commands when necessary.
Response format: {response: "Response content", commands: ["Command1", "Command2"]}
)";
        
        return systemPrompt;
    }
};

class PerformanceMonitor {
private:
    struct Metrics {
        uint32_t responseTime;
        float cpuUsage;
        uint32_t memoryUsage;
        bool networkStatus;
    };
    
    CircularBuffer<Metrics, 100> metricsHistory;
    
public:
    void logInteraction(const Metrics& metrics) {
        metricsHistory.push(metrics);
        
        if (metrics.responseTime > 5000) { // 5 second timeout
            optimizePerformance();
        }
    }
    
private:
    void optimizePerformance() {
        // Dynamically adjust local/cloud processing strategy
        if (getAverageResponseTime() > 3000) {
            increaseLocalProcessingRatio();
        }
    }
};