SmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!

[מאיר יפה]

@א.מ.ד. מטורף מה שהולך פה
אולי תוסיף גם פקודת קול כמו “היי סמרטי”, שיפתח ישר הקלטה גם כשהחלון סגור. זה יהיה נדיר. וגם במקום להתחיל הקלטה וללחוץ על המיקרפון, היי סמרטי”, שיפתח ישר הקלטה

[המלאך]

@מאיר-יפה דובר כבר.
לא אפשרי.
זה דורש שימוש תמידי בNPU והמערכת מגבילה.
גם זה לא קיים בכל מחשב..

[YAHBDK]

@המלאך כתב בSmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!:

לא אפשרי.

למה אתה אומר שלא אפשרי?
לא אפשרי לעשות מודל שיעבוד על דיבור?
שיקשיב לשם שלו ויענה?

[צול גאה]

@YAHBDK

למה לא לקרוא עד הסוף?

@המלאך כתב בSmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!:

זה דורש שימוש תמידי בNPU והמערכת מגבילה.

[המלאך]

@YAHBDK כתב בSmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!:

למה אתה אומר שלא אפשרי?
לא אפשרי לעשות מודל שיעבוד על דיבור?
שיקשיב לשם שלו ויענה?

זה ידרוש מהמודל לעבוד כל הזמן ברקע.
האופציה היחידה לעשות את זה בלי שיקריס את המחשב זה רק שימוש בNPU.
לא כל המחשבים תומכים,
וגם אלה שתומכים המערכות הפעלה מגבילות את השימוש לתוכנות חיצוניות בNPU.
לצערי..

[aass]

נראה מדהים!

[א.מ.ד.]

@חכם-בלילה-1 כתב בSmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!:

אולי כדאי להוסיף אפשרות להדביק צילום מסך ואולי אפילו מסמך
זה מאוד יעזור

בעקרון אתה יכול לבקש ממנו לצלם מסך, או לומר לו איפה נמצאת התמונה שאתה רוצה שהוא יראה.

[YAHBDK]

@המלאך

Spoiler

אני מביא מAI אבל אצלי בכל אופן זה עובד לא בדקתי לעומק

"""
SmartiAI - Wake Word Detection

מקשיב כל הזמן לשם "סמרטי" / "SmartiAI"
ברגע שמזהה - מתעורר ומקשיב לפקודה

התקנה (הרץ פעם אחת):
pip install SpeechRecognition pyaudio pyttsx3

הרצה:
python smarti_wakeword.py
"""

import speech_recognition as sr
import pyttsx3
import threading
import time
import logging

logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(message)s", datefmt="%H:%M:%S")
log = logging.getLogger("SmartiAI")

─── הגדרות ───────────────────────────────────────────────

WAKE_WORDS = ["סמרטי", "smarti", "smarty", "סמארטי", "smartiai", "סמרטיאי"]
LANGUAGE_PRIMARY = "he-IL"
LANGUAGE_SECONDARY = "en-US"
LISTEN_TIMEOUT = 4 # שניות להאזנה לפקודה אחרי זיהוי שם
WAKE_TIMEOUT = 2 # שניות להאזנה לשם (קצר = קליל על ה-CPU)

──────────────────────────────────────────────────────────

class SmartiWakeWord:
def init(self):
self.recognizer = sr.Recognizer()
self.recognizer.energy_threshold = 300
self.recognizer.dynamic_energy_threshold = True
self.recognizer.pause_threshold = 0.6
self.mic = None
self.engine = pyttsx3.init()
self._active = False
self._stop = threading.Event()
self._setup_voice()
self._init_mic()

def _setup_voice(self):
    """הגדרת קול בעברית אם אפשר"""
    voices = self.engine.getProperty("voices")
    for v in voices:
        if "hebrew" in v.name.lower() or "he" in v.id.lower():
            self.engine.setProperty("voice", v.id)
            break
    self.engine.setProperty("rate", 160)

def _init_mic(self):
    try:
        self.mic = sr.Microphone()
        with self.mic as source:
            self.recognizer.adjust_for_ambient_noise(source, duration=0.5)
        log.info("✅ מיקרופון מוכן")
    except Exception as e:
        log.error(f"❌ שגיאת מיקרופון: {e}")

def speak(self, text: str):
    """מדבר בקול"""
    log.info(f"🔊 {text}")
    self.engine.say(text)
    self.engine.runAndWait()

def _recognize(self, audio, lang=LANGUAGE_PRIMARY) -> str | None:
    """זיהוי דיבור - מנסה עברית ואנגלית"""
    for language in [lang, LANGUAGE_SECONDARY if lang == LANGUAGE_PRIMARY else LANGUAGE_PRIMARY]:
        try:
            text = self.recognizer.recognize_google(audio, language=language)
            if text:
                return text.strip()
        except sr.UnknownValueError:
            continue
        except sr.RequestError as e:
            log.error(f"שגיאת שרת: {e}")
            return None
    return None

def _is_wake_word(self, text: str) -> bool:
    """בודק אם הטקסט מכיל את שם ההפעלה"""
    text_lower = text.lower().strip()
    for word in WAKE_WORDS:
        if word.lower() in text_lower:
            return True
    return False

def _listen_for_command(self) -> str | None:
    """מקשיב לפקודה אחרי זיהוי שם"""
    try:
        with self.mic as source:
            log.info("👂 מקשיב לפקודה...")
            audio = self.recognizer.listen(
                source,
                timeout=LISTEN_TIMEOUT,
                phrase_time_limit=10
            )
        return self._recognize(audio)
    except sr.WaitTimeoutError:
        return None

def _process_command(self, command: str):
    """
    *** כאן תכניס את הלוגיקה של הבינה המלאכותית שלך ***
    לעכשיו - רק מדגים שזה עובד
    """
    log.info(f"⚡ פקודה התקבלה: {command}")

    # דוגמה בסיסית - תחליף בקריאה למודל שלך
    if any(w in command.lower() for w in ["שלום", "hello", "hi"]):
        self.speak("שלום! אני כאן, מה אפשר לעשות בשבילך?")
    elif any(w in command.lower() for w in ["שעה", "זמן", "time"]):
        t = time.strftime("%H:%M")
        self.speak(f"השעה היא {t}")
    elif any(w in command.lower() for w in ["תודה", "thanks", "thank you"]):
        self.speak("בבקשה! אני תמיד כאן")
    else:
        self.speak(f"קיבלתי: {command}")

    # ─── כאן תוסיף קריאה ל-AI שלך, למשל: ───
    # response = my_ai_model.process(command)
    # self.speak(response)

def run(self):
    """הלולאה הראשית - מקשיבה לשם ההפעלה"""
    if not self.mic:
        log.error("אין מיקרופון - עצור")
        return

    log.info("=" * 50)
    log.info("🤖 SmartiAI פעיל!")
    log.info(f"📢 אמור '{WAKE_WORDS[0]}' להפעלה")
    log.info(f"🔑 מילות הפעלה: {', '.join(WAKE_WORDS)}")
    log.info("=" * 50)

    # סטטיסטיקות
    checks = 0
    detections = 0

    while not self._stop.is_set():
        try:
            # ─── שלב 1: האזנה קצרה לשם בלבד ───
            with self.mic as source:
                audio = self.recognizer.listen(
                    source,
                    timeout=WAKE_TIMEOUT,
                    phrase_time_limit=WAKE_TIMEOUT
                )

            checks += 1
            text = self._recognize(audio)

            if not text:
                continue

            log.debug(f"שמעתי: {text}")

            # ─── שלב 2: האם זו מילת ההפעלה? ───
            if self._is_wake_word(text):
                detections += 1
                log.info(f"✨ זוהה! ({detections} פעמים) | שמעתי: '{text}'")
                self.speak("כן?")

                # ─── שלב 3: מקשיב לפקודה ───
                command = self._listen_for_command()

                if command:
                    threading.Thread(
                        target=self._process_command,
                        args=(command,),
                        daemon=True
                    ).start()
                else:
                    self.speak("לא שמעתי פקודה, קרא לי שוב")

        except sr.WaitTimeoutError:
            # לא נאמר כלום - ממשיך להאזין
            pass
        except KeyboardInterrupt:
            break
        except Exception as e:
            log.error(f"שגיאה: {e}")
            time.sleep(0.5)

    log.info("👋 SmartiAI כובה")

def stop(self):
    self._stop.set()

─── הרצה ─────────────────────────────────────────────────

if name == "main":
smarti = SmartiWakeWord()
try:
smarti.run()
except KeyboardInterrupt:
print("\nנסגר...")
smarti.stop()

[א.מ.ד.]

@YAHBDK זולל המון חשמל. קראתי לא מזמן על מודל זעיר חסכוני בחשמל, אני ייבדוק אם זה רלוונטי, אבל בגדול זה למתוח את הגבול...

[שניאור שמח]

@א.מ.ד. איך במחשבי אפל זה עובד?
זה כנראה לא יהיה דוגמה, כי הם אלו שיצרו את המחשב והמערכת ההפעלה, אבל מעניין..

עריכה: ג׳ימני פירט לי על הנושא, וגם הביא חצי פתרון, מעניין אם זה באמת נכון ויעיל..
התשובה שלו בספוילר:

Spoiler

זה נראה כמו קסם – המחשב סגור או נמצא בצד, וברגע שאתה אומר "היי סירי", הוא מתעורר לחיים. מאחורי הקסם הזה עומדת הנדסת חומרה ותוכנה מאוד חכמה שמטרתה המובילה היא חיסכון באנרגיה.

כך המערכת הזו עובדת, וזה מה שצריך לדעת אם רוצים ליישם משהו דומה בווינדוס:

איך זה עובד ואיך זה לא זולל את הסוללה?

הסוד טמון בארכיטקטורה דו-שלבית (Two-Stage Architecture) שמפרידה בין "הקשבה למילת ההפעלה" לבין "הבנת הפקודה".

שלב 1: המעבד הקטן והחסכוני (החלק שלא זולל סוללה)

במחשבי אפל (במיוחד אלו עם מעבדי Apple Silicon כמו M1, M2 וכו'), המעבד הראשי (ה-CPU) והחזק פשוט ישן כשאתה לא משתמש במחשב. מי שמקשיב לך הוא שבב קטנטן, ייעודי ודל-הספק שמקבל זרם חשמלי מינימלי ביותר.

• המיקרופון מקליט את השניות האחרונות בלופ קבוע לתוך זיכרון זמני קטן ומבודד (Audio Buffer).
• המעבד הקטן מריץ מודל בינה מלאכותית פשוט מאוד שמכיר רק דבר אחד: את גלי הקול של המילים "היי סירי" בקול שלך.
• בגלל שהשבב הזה כל כך קטן והמשימה שלו ספציפית, הוא צורך מיליוואטים בודדים – כמות אנרגיה אפסית שלא מורגשת בסוללה.

שלב 2: ההתעוררות של המעבד הראשי

רק כאשר המעבד הקטן מזהה בוודאות גבוהה את מילת ההפעלה, הוא שולח אות "התעוררות" (Interrupt) למעבד הראשי (ה-CPU) ולמנוע הבינה המלאכותית החזק (Apple Neural Engine). רק אז המחשב באמת נדלק, מתחיל להקשיב להמשך המשפט ומפעיל את המערכות הכבדות שמנתחות את השפה ומבצעות את הפקודה.

איך נקראת המערכת הזאת?

באפל, רכיב החומרה האחראי על המשימות האלו נקרא AOP (Always-On Processor) – מעבד שנמצא תמיד במצב פעיל.
הקונספט התוכנתי הכללי בתעשייה נקרא Wake-Word Detection (זיהוי מילת הפעלה) או Voice Activation.

האם אפשר לעשות את אותה שיטה במחשבי ווינדוס?

התשובה הקצרה היא: כן, אבל עם אתגר משמעותי בגזרת הסוללה.
כשאתה בונה תוכנה משלך בווינדוס (למשל בפייתון או C#), אתה נתקל בשתי בעיות מרכזיות שאין לאפל (כי אפל מייצרת גם את החומרה וגם את התוכנה):

1. בעיית ה-CPU (זלילת הסוללה)

אם תכתוב תוכנה סטנדרטית שרצה ברקע ומקשיבה למיקרופון, היא תרוץ על המעבד הראשי של המחשב (Intel / AMD / Snapdragon). ברגע שהתוכנה שלך דורשת מהמעבד הראשי לנתח סאונד בכל שנייה, היא מונעת ממנו להיכנס למצבי שינה עמוקים (C-States). התוצאה: המעבד יישאר "ער" והסוללה של הלפטופ תתרוקן במהירות.

2. גישה לחומרה ייעודית

במחשבי ווינדוס מודרניים (במיוחד החדשים עם מעבדי Intel Core Ultra, AMD Ryzen סדרה 8000, או שבבי Snapdragon X Elite) יש רכיבי חומרה ייעודיים בדיוק לזה: NPU (יחידת עיבוד עצבית) או שבבי DSP (מעבדי אותות דיגיטליים) של כרטיס הקול. מיקרוסופט משתמשת בהם עבור הפיצ'רים שלה.
הבעיה היא שלמפתחים עצמאיים קשה מאוד לקבל גישה ישירה ברמת החומרה (Low-level driver) לשבבים החסכוניים האלה כדי להריץ עליהם קוד מותאם אישית בזמן שהמחשב ישן.

איך בכל זאת עושים את זה בצורה הכי יעילה בווינדוס?

כדי לבנות עוזרת קולית משלך שלא תגמור את הסוללה לחלוטין, אתה צריך להשתמש בספריות Local Wake-Word Detection מתקדמות וממוטבות במיוחד, שמסוגלות לרוץ במינימום אחוזי ניצול מעבד (CPU Usage).
האפשרויות המובילות בתעשייה כיום הן:

• Picovoice Porcupine: ספרייה מעולה ומסחרית (עם מסלול חינמי למפתחים) שנחשבת לחסכונית ביותר באנרגיה ומיועדת בדיוק לזיהוי מילת הפעלה מקומית על המעבד בלי לזלול משאבים.
• OpenWakeWord: ספריית קוד פתוח מבוססת Python, יעילה מאוד ומיועדת למערכות כמו Home Assistant.
• Snowboy או PocketSphinx: פתרונות ותיקים יותר, אך פחות מדויקים או חסכוניים מהחדשים.

באיזו שפת תכנות או ספרייה אתה מתכנן להשתמש כדי לבנות את העוזרת הקולית שלך בווינדוס?

[א.מ.ד.]

@שניאור-שמח כתב בSmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!:

זה כנראה לא יהיה דוגמה, כי הם אלו שיצרו את המחשב והמערכת ההפעלה, אבל מעניין..

זו אכן התשובה. הם מקצים חומרה מיוחדת וחסכונית שנועדה אך ורק לזה. יש את זה כמעט בהרבה מכשירים היום, לדוגמא ל-"OK גוגל", אבל זה בשימוש רק ע"י מערכת ההפעלה.

[י.ר.ק]

@א.מ.ד. לא קראתי את כל ה140 פוסטים ויכול להיות שכתבו את זה אבל תוכל להגיד לי כמה ג'יגה ראם צריך מינימום בשביל הדבר הזה

[א.מ.ד.]

@י.ר.ק כתב בSmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!:

@א.מ.ד. לא קראתי את כל ה140 פוסטים ויכול להיות שכתבו את זה אבל תוכל להגיד לי כמה ג'יגה ראם צריך מינימום בשביל הדבר הזה

התוכנה עצמה צורכת עד 500MB RAM. רוב הזמן צורכת כ-30-50MB RAM.

[עזיז]

@א.מ.ד.

מה הבעיה שלי (נטפרי)

[א.מ.ד.]

@עזיז תנסה שוב, אולי זה חד פעמי.
אם לא עוזר, תחליף מודל.
תבדוק אם אישרת תאימות SSL בהגדרות מתקדמות כמובא למעלה.

[tc]

@א.מ.ד.
ניסיתי להתקין את https://clawhub.ai/ivangdavila/playwright

[עזיז]

@א.מ.ד.
החלפתי לגיפיטי

[א.מ.ד.]

@עזיז או שאין מפתח API תקין, או שחסום לך בהגדרת נטפרי.

[א.מ.ד.]

@tc כתב בSmartiAI לווינדוס, סוכן AI שיכול לעשות הכל!:

@א.מ.ד.
ניסיתי להתקין את https://clawhub.ai/ivangdavila/playwright

הוא כותב שזה לא בטוח לפי המידע ששרת הסקילים מספק. בינתיים חסמתי כל התקנה לא בטוחה.

[tc]

@א.מ.ד. מה כן אפשר להתקין משם