สร้าง Smart Clipboard Agent: ดักจับและคัดแยกข้อความที่คัดลอกระหว่างวัน บันทึกเข้า Obsidian อัตโนมัติด้วย Python + Ollama

ในแต่ละวันของการทำงานหน้าคอมพิวเตอร์ ลองสังเกตดูว่าคุณกดปุ่ม Ctrl+C (หรือ Cmd+C) ไปกี่ครั้ง?

เรามักจะคัดลอกสิ่งน่าสนใจอยู่ตลอดเวลา ไม่ว่าจะเป็นโค้ดสั้นๆ ที่แก้บั๊กได้, ประโยคคมคายจากบทความ, ลิงก์เครื่องมือใหม่, ข้อความสั่งงานด่วนจากแชต หรือตัวเลขสถิติที่น่าสนใจ แต่ปัญหาส่วนใหญ่คือ "เราลืมนำมันไปบันทึก"

เมื่อเราคัดลอกข้อความใหม่ ข้อความเดิมก็จะถูกเขียนทับและสูญหายไปในประวัติคลิปบอร์ด หรือถ้าเราพยายามจะเปิด Obsidian สลับหน้าจอมาแปะข้อความทุกครั้ง โฟกัสและสมาธิในการทำงาน (Flow State) ก็จะสะดุดทันที นี่คือตัวอย่างคลาสสิกของ Capture Friction หรือความฝืดในการดักจับความคิดลงสู่ Second Brain

ในบทความนี้ เราจะมาประยุกต์ใช้ Cognitive Automation สร้าง Smart Clipboard Agent ด้วย Python และรันโมเดลภาษาในเครื่องผ่าน Ollama ที่จะคอยเฝ้าดูสิ่งที่คุณคัดลอก เมื่อพบข้อความที่มีประโยชน์ มันจะช่วยคิด วิเคราะห์ประเภท และนำไปบันทึกลงใน Daily Note ของ Obsidian ให้คุณอัตโนมัติ โดยที่ข้อมูลส่วนตัวทั้งหมดไม่รั่วไหลออกสู่อินเทอร์เน็ตแม้แต่บิตเดียว

สถาปัตยกรรมของ Smart Clipboard Agent

ระบบนี้ไม่ได้เป็นแค่ Clipboard History ทั่วไปที่เก็บข้อความดิบๆ แต่ทำงานในฐานะ Cognitive Assistant ที่ช่วยกรองและสังเคราะห์ข้อมูล:

1. Background Listener: สคริปต์ Python มอนิเตอร์คลิปบอร์ดของระบบในเบื้องหลัง
2. Security & Privacy Guard: ระบบคัดกรองเบื้องต้นเพื่อตัดข้อความที่มีความเสี่ยง เช่น รหัสผ่าน, API Token, หรือข้อความส่วนตัวสั้นๆ ไม่ให้ถูกบันทึก
3. Local LLM Analysis: ส่งข้อความที่น่าสนใจไปให้โมเดลภาษาขนาดเล็ก (เช่น llama3.2 หรือ qwen2.5) ช่วยจัดประเภท (Category) สกัดบริบท และใส่แท็ก Markdown
4. Obsidian Auto-Append: แนบเนื้อหาที่ประมวลผลแล้วลงในหัวข้อ ## Captured Thoughts ของ Daily Note วันนั้นๆ ทันที

ขั้นตอนที่ 1: ติดตั้งเครื่องมือและดาวน์โหลดโมเดล

งานจัดหมวดหมู่และสรุปข้อความคลิปบอร์ดต้องการความเร็วและการตอบสนองแบบเกือบเรียลไทม์ โมเดลอย่าง Llama 3.2 (3B) หรือ Qwen 2.5 (3B) จึงเหมาะสมที่สุดเพราะใช้แรมน้อยและประมวลผลเร็วมาก

เปิด Terminal แล้วดึงโมเดลผ่าน Ollama:

ollama run llama3.2:3b

จากนั้นติดตั้งไลบรารี Python สำหรับจัดการคลิปบอร์ดและยิง API:

pip install pyperclip requests

หมายเหตุสำหรับผู้ใช้ Linux: หากใช้ Linux (X11 หรือ Wayland) อาจต้องติดตั้งเครื่องมือคลิปบอร์ดของระบบเพิ่มเติม เช่น sudo apt install xclip หรือ wl-clipboard

ขั้นตอนที่ 2: เขียนสคริปต์ Smart Clipboard Agent

สร้างไฟล์ smart_clipboard_agent.py และใส่โค้ดการทำงานดังนี้:

import os
import time
import json
import re
from datetime import datetime
import pyperclip
import requests

# กำหนดเส้นทางโฟลเดอร์ Daily Notes ใน Obsidian Vault ของคุณ
OBSIDIAN_VAULT_PATH = os.path.expanduser("~/Documents/ObsidianVault/Dailies")
OLLAMA_API_URL = "http://localhost:11434/api/generate"
MODEL_NAME = "llama3.2:3b"

# กรองข้อความที่ไม่ต้องการประมวลผล (ความปลอดภัยและการลดภาระ AI)
def is_sensitive_or_trivial(text: str) -> bool:
    clean_text = text.strip()
    if len(clean_text) < 15 or len(clean_text) > 4000:
        return True

    # ดักจับรูปแบบที่เป็นไปได้ของ Token, Secret Key หรือ Password
    sensitive_patterns = [
        r"(ghp|gho|ghu)_[a-zA-Z0-9]{36,}", # GitHub Token
        r"eyJh[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+", # JWT Token
        r"sk-[a-zA-Z0-9]{20,}", # API Key ทั่วไป
        r"password\s*[:=]\s*\S+", # ข้อความรหัสผ่าน
    ]
    for pattern in sensitive_patterns:
        if re.search(pattern, clean_text, re.IGNORECASE):
            return True
    return False

# ให้ Local LLM วิเคราะห์และแปลงข้อความเป็น Markdown ที่มีโครงสร้าง
def analyze_clipboard_content(text: str) -> dict:
    prompt = f"""คุณเป็น AI ช่วยจัดระเบียบคลิปบอร์ดสำหรับบันทึกลง Second Brain (Obsidian)
วิเคราะห์ข้อความต่อไปนี้ แล้วจัดหมวดหมู่โดยตอบเป็น JSON เท่านั้น โครงสร้าง:
{{
  "category": "Code" หรือ "Quote" หรือ "Link_Resource" หรือ "Task" หรือ "Quick_Idea",
  "summary": "สรุปสั้นๆ 1 ประโยคว่าเกี่ยวกับอะไร",
  "tags": ["tag1", "tag2"]
}}

ข้อความที่คัดลอก:
\"\"\"{text}\"\"\"
"""
    payload = {
        "model": MODEL_NAME,
        "prompt": prompt,
        "format": "json",
        "stream": False
    }
    try:
        response = requests.post(OLLAMA_API_URL, json=payload, timeout=30)
        response.raise_for_status()
        data = response.json()
        return json.loads(data["response"])
    except Exception as e:
        print(f"เกิดข้อผิดพลาดในการวิเคราะห์ LLM: {e}")
        return {
            "category": "Quick_Idea",
            "summary": "บันทึกคลิปบอร์ดอัตโนมัติ",
            "tags": ["clipboard"]
        }

# บันทึกข้อความลง Daily Note ประจำวัน
def append_to_daily_note(raw_text: str, metadata: dict):
    today = datetime.now().strftime("%Y-%m-%d")
    note_path = os.path.join(OBSIDIAN_VAULT_PATH, f"{today}.md")
    timestamp = datetime.now().strftime("%H:%M:%S")

    tags_formatted = " ".join([f"#{t}" for t in metadata.get("tags", [])])
    category = metadata.get("category", "General")
    summary = metadata.get("summary", "")

    entry = f"""
### [{timestamp}] {category}: {summary}
{tags_formatted}

{raw_text.strip()}

---
"""
    # ตรวจสอบว่ามีไฟล์ Daily Note หรือยัง ถ้ายังให้สร้างใหม่พร้อมหัวข้อ
    if not os.path.exists(note_path):
        os.makedirs(os.path.dirname(note_path), exist_ok=True)
        with open(note_path, "w", encoding="utf-8") as f:
            f.write(f"# Daily Note: {today}\n\n## Smart Clipboard Inbox\n")

    with open(note_path, "a", encoding="utf-8") as f:
        f.write(entry)
    print(f"บันทึกข้อมูลสำเร็จ: [{category}] {summary}")

def main():
    print("🚀 Smart Clipboard Agent กำลังทำงานในเบื้องหลัง...")
    last_clipboard_value = pyperclip.paste()

    while True:
        try:
            time.sleep(1) # ตรวจสอบคลิปบอร์ดทุกๆ 1 วินาที
            current_value = pyperclip.paste()

            if current_value != last_clipboard_value:
                last_clipboard_value = current_value
                if is_sensitive_or_trivial(current_value):
                    continue

                print(f"\nตรวจพบข้อความใหม่ ({len(current_value)} ตัวอักษร) กำลังให้ AI วิเคราะห์...")
                meta = analyze_clipboard_content(current_value)
                append_to_daily_note(current_value, meta)

        except KeyboardInterrupt:
            print("\nหยุดการทำงานของ Agent")
            break
        except Exception as e:
            print(f"เกิดข้อผิดพลาด: {e}")
            time.sleep(2)

if __name__ == "__main__":
    main()

ขั้นตอนที่ 3: ตั้งค่าให้สคริปต์รันเบื้องหลังอัตโนมัติ

เพื่อให้ผู้ช่วยนี้ทำงานได้ตลอดเวลาโดยที่คุณไม่ต้องเปิดหน้าต่าง Terminal ค้างไว้ คุณสามารถสร้าง Background Service บนระบบของคุณได้:

สำหรับ Linux (Systemd User Service)

สร้างไฟล์ ~/.config/systemd/user/smart-clipboard.service:

[Unit]
Description=Smart Clipboard AI Agent for Obsidian
After=graphical-session.target

[Service]
ExecStart=/usr/bin/python3 /home/linn/smart_clipboard_agent.py
Restart=always
RestartSec=5

[Install]
WantedBy=default.target

จากนั้นเปิดใช้งานคำสั่ง:

systemctl --user daemon-reload
systemctl --user enable --now smart-clipboard.service

สำหรับ macOS หรือการรันด้วย nohup

หากต้องการเปิดรันอย่างง่ายในเบื้องหลัง สามารถสั่งผ่านคำสั่ง:

nohup python3 smart_clipboard_agent.py > ~/clipboard_agent.log 2>&1 &

ผลลัพธ์ใน Obsidian Daily Note

เมื่อคุณท่องเว็บ อ่านหนังสือ หรือเขียนโค้ด แล้วกด Ctrl+C ข้อความที่คุณคัดลอกจะปรากฏใน Obsidian Daily Note ประจำวันอย่างสวยงาม เช่น:

### [14:25:10] Code: คำสั่ง Docker ในการเคลียร์ Container ที่ค้างอยู่
#docker #devops #cli

docker rm -vf $(docker ps -aq)

---
### [15:40:02] Quote: ข้อคิดเรื่องความสำคัญของความสม่ำเสมอในการสร้างนิสัย
#productivity #habits

"You do not rise to the level of your goals. You fall to the level of your systems."

---

คุณสามารถใช้ปลั๊กอิน Dataview ใน Obsidian ดึงข้อมูลเหล่านี้ไปรวมเป็นสรุปประจำสัปดาห์ หรือเปลี่ยนข้อความที่เป็น Task ให้กลายเป็นสิ่งที่ต้องทำต่อได้ในทันที

ข้อแนะนำด้านความปลอดภัยและความเป็นส่วนตัว

1. ประมวลผล Local 100%: สคริปต์ยิง API เข้าที่ localhost:11434 เท่านั้น ข้อมูลคลิปบอร์ดจึงไม่หลุดออกสู่อินเทอร์เน็ต
2. ขยาย RegEx คัดกรองรหัสผ่าน: ปรับแต่งฟังก์ชัน is_sensitive_or_trivial() ให้เข้ากับรูปแบบของเครื่องมือที่คุณใช้ประจำ เพื่อป้องกันการเผลอบันทึกรหัสผ่าน
3. ไม่ใช้กับข้อความขนาดใหญ่เกินไป: ควรกำหนดขีดจำกัดความยาวเพื่อไม่ให้คอมพิวเตอร์ของคุณต้องรันโมเดลหนักเกินไปเมื่อเผลอคัดลอกไฟล์ก้อนใหญ่

บทสรุป

การสร้าง Second Brain ไม่ควรเป็นภาระที่เพิ่มขึ้นในชีวิตประจำวัน แนวคิดของ Cognitive Automation คือการตัดงานที่ซ้ำซากออกไป เพื่อให้สมองจริงของคุณมีพลังงานเหลือไปใช้กับการคิดสร้างสรรค์และการตัดสินใจเรื่องสำคัญ

เพียงแค่สคริปต์ Python เล็กๆ คู่กับ Local LLM บนเครื่อง คุณก็เปลี่ยนการกด Ctrl+C ธรรมดาๆ ให้กลายเป็นกลไกบันทึกความรู้อัจฉริยะที่ทำงานเงียบๆ อยู่เบื้องหลังได้อย่างสมบูรณ์แบบ