NeboAI
NeboAI
เริ่มต้นใช้งาน

สร้างแอปสำหรับ Nebo

มอบพลังพิเศษใหม่ให้ AI ของคุณ ทั้งเครื่องมือ แชนเนล เกตเวย์ แผง UI อะไรก็ได้ที่คุณนึกออก คอมไพล์เป็นไบนารีแบบเนทีฟ

ภาพรวม

Nebo คืออะไร

Nebo คือผู้ช่วย AI ส่วนตัวบนเดสก์ท็อป เป็นพนักงาน AI ที่ทำงานตลอดเวลาและจัดการชีวิตดิจิทัลของคุณ ลองนึกถึง Nebo แบบเดียวกับที่คุณนึกถึงสมาร์ทโฟน แพลตฟอร์มทรงพลังที่สร้างการเปลี่ยนแปลงได้ผ่านแอปของมัน

โดยตัวมันเอง Nebo เป็นพนักงาน AI ที่มีความสามารถ ทั้งความทรงจำ การจัดตารางเวลา การท่องเว็บ การจัดการไฟล์ และการเข้าถึงเชลล์ แต่สิ่งที่ปลดล็อกได้จริงคือแอป เช่นเดียวกับที่พลังของสมาร์ทโฟนมาจากระบบนิเวศของแอป พลังของ Nebo ก็มาจากแอปที่ขยายสิ่งที่มันทำได้

แอปคืออะไร

แอปของ Nebo เป็นหน่วยการทำงานที่ครบในตัวและคอมไพล์ไว้ล่วงหน้า พร้อมความสามารถอันน่าทึ่ง แต่ละแอปมอบพลังพิเศษใหม่ให้ Nebo ทั้งการจัดการปฏิทิน การคัดแยกอีเมล การติดตามโปรเจกต์ ระบบบ้านอัตโนมัติ การวิเคราะห์การเงิน อะไรก็ได้ที่นักพัฒนานึกออก

แอปให้พลังอันน่าทึ่งในแบบที่ปลอดภัยอย่างยิ่ง ทุกแอปทำงานในแซนด์บ็อกซ์ที่ปฏิเสธสิทธิ์เป็นค่าเริ่มต้น แอปเข้าถึงได้เฉพาะสิ่งที่ประกาศไว้ใน manifest และผู้ใช้อนุมัติแล้วเท่านั้น

อินเทอร์เฟซเป็นการสนทนา 100% ผู้ใช้ไม่ได้โต้ตอบกับแอปผ่านหน้าจอหรือแดชบอร์ดแยกต่างหาก แต่คุยกับ Nebo แล้ว Nebo ใช้เครื่องมือของแอปเพื่อทำงานให้เสร็จ "พรุ่งนี้ในปฏิทินของฉันมีอะไรบ้าง" Nebo จะเรียกแอปปฏิทิน "สร้างนัดประชุมกับ Sarah เวลาบ่าย 3 โมง" Nebo จะเรียกแอปปฏิทิน ผู้ใช้ไม่ต้องออกจากบทสนทนาเลย

แอปสามารถมีUI การตั้งค่าได้ตามต้องการ ซึ่งเป็นแผงกำหนดค่าที่เปิดในหน้าต่างเบราว์เซอร์ในตัวของ Nebo ที่นี่คือที่ที่ผู้ใช้ป้อนคีย์ API เปิดปิดฟีเจอร์ และกำหนดค่าแอป UI การตั้งค่าขับเคลื่อนด้วยอาร์เรย์ settings ใน manifest (Nebo สร้างฟอร์มให้โดยอัตโนมัติ) หรือแอปจะมี UI แบบกำหนดเองเต็มรูปแบบของตัวเองผ่านความสามารถ ui ก็ได้

แอปแทนที่และขยายความสามารถในตัวของ Nebo Nebo มาพร้อมเครื่องมือพื้นฐานของแพลตฟอร์ม (การเข้าถึงปฏิทินในเครื่อง ภาพหน้าจอ ฯลฯ) เมื่อคุณติดตั้งแอปปฏิทิน แอปนั้นจะแทนที่เครื่องมือปฏิทินในตัวและกลายเป็นชุดความสามารถที่ครอบคลุมกว่า ทั้งในเครื่อง คลาวด์ การรวบรวมข้อมูล และการตรวจสอบเวลาว่าง

นโยบายเฉพาะไบนารีที่คอมไพล์แล้ว

Nebo บังคับใช้นโยบายเข้มงวดว่าต้องเป็นไบนารีที่คอมไพล์แล้วเท่านั้น ทุกแอปต้องเป็นไฟล์ปฏิบัติการแบบเนทีฟที่คอมไพล์แล้ว

สถานะภาษา
รองรับGo (แนะนำ), Rust, C/C++, Zig
ไม่รับPython, Node.js, Ruby, Java, .NET, เชลล์สคริปต์

เหตุผล:

  • ป้องกันไม่ให้ AI แก้ไขตัวเอง พนักงาน AI ที่เข้าถึงเชลล์ได้อาจแก้ไขพฤติกรรมของสคริปต์แบบอินเทอร์พรีตขณะรันได้ ไบนารีที่คอมไพล์แล้วเปลี่ยนแปลงไม่ได้หลังลงนาม
  • ความถูกต้องของลายเซ็น ลายเซ็น Ed25519 ครอบคลุมไบต์ดิบของไบนารี ไบนารีที่ลงนามแล้วจะแก้ไขไม่ได้โดยไม่ทำให้ลายเซ็นใช้ไม่ได้
  • การบังคับใช้แซนด์บ็อกซ์ การตรวจสอบรูปแบบไบนารี (magic bytes ของ ELF/Mach-O/PE) เป็นด่านตรวจที่รวดเร็วและเชื่อถือได้

เริ่มต้นอย่างรวดเร็ว

ติดตั้ง SDK

SDK อย่างเป็นทางการจัดการการตั้งค่าเซิร์ฟเวอร์ gRPC การจัดการสัญญาณ และการเชื่อมต่อโปรโตคอลให้ทั้งหมด คุณเพียงแค่ implement อินเทอร์เฟซของ handler

Go (แนะนำ):

go get github.com/neboloop/nebo-sdk-go

Rust (เร็ว ๆ นี้):

# Coming soon
[dependencies]
nebo-sdk = "0.1"

C/C++ (เร็ว ๆ นี้):

# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/

โครงสร้างไดเรกทอรีของแอป

แอปอยู่ในไดเรกทอรีย่อย apps/ ของไดเรกทอรีข้อมูล Nebo ของคุณ:

~/Library/Application Support/Nebo/apps/   # macOS
~/.config/nebo/apps/                        # Linux
%AppData%\Nebo\apps\                        # Windows

apps/
  com.example.myapp/
    manifest.json       # Required: app metadata
    binary              # Required: executable (or named "app")
    signatures.json     # Required for NeboAI distribution, optional in dev
    TOOL.md             # Required: tool instructions for the agent
    data/               # Auto-created: app's sandboxed storage
    logs/               # Auto-created: stdout.log, stderr.log
    ui/                 # Optional: static UI assets (HTML/CSS/JS)

รายการตรวจสอบสำหรับแอปขั้นต่ำ

  1. สร้าง manifest.json ที่มี id, name, version, provides
  2. เขียน TOOL.md อธิบายว่าพนักงาน AI ควรใช้เครื่องมือของคุณอย่างไร
  3. ติดตั้ง SDK (go get github.com/neboloop/nebo-sdk-go)
  4. implement อินเทอร์เฟซ handler สำหรับความสามารถของคุณ (ToolHandler, ChannelHandler ฯลฯ)
  5. ลงทะเบียน handler แล้วเรียก app.Run()
  6. บิลด์ไบนารีแบบเนทีฟ (go build -o binary .)
  7. วางไบนารี + manifest.json + TOOL.md ไว้ในไดเรกทอรี apps/<your-app-id>/
  8. Nebo จะค้นพบและเปิดใช้งานแอปโดยอัตโนมัติ

การกำหนดค่า

manifest.json

ทุกแอปต้องมี manifest.json:

{
    "id": "com.example.myapp",
    "name": "My App",
    "version": "1.0.0",
    "description": "What this app does",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["tool:my_tool"],
    "permissions": ["network:outbound"],
    "settings": [
        {
            "key": "api_key",
            "title": "API Key",
            "type": "password",
            "required": true,
            "description": "Your API key for the service",
            "secret": true
        }
    ]
}

ฟิลด์ที่จำเป็น:

ฟิลด์คำอธิบาย
idตัวระบุแบบโดเมนย้อนกลับ (เช่น com.mycompany.myapp)
nameชื่อที่มนุษย์อ่านได้
versionสตริง Semver
providesอย่างน้อยหนึ่งความสามารถ (ดูด้านล่าง)

ฟิลด์ที่ไม่บังคับ:

ฟิลด์ค่าเริ่มต้นคำอธิบาย
runtime"local""local" หรือ "remote"
protocol"grpc"รองรับเฉพาะ "grpc"
permissions[]สิ่งที่แอปต้องเข้าถึง
description""แสดงใน UI
settings[]การตั้งค่าที่กำหนดได้ (แสดงใน UI การตั้งค่า)
oauth[]ข้อกำหนดผู้ให้บริการ OAuth (ดูส่วน OAuth ด้านล่าง)

ความสามารถ

ประกาศสิ่งที่แอปของคุณมีให้:

ความสามารถบริการ gRPCคำอธิบาย
gatewayGatewayServiceการกำหนดเส้นทางโมเดล LLM
tool:<name>ToolServiceเครื่องมือที่มีชื่อสำหรับพนักงาน AI
channel:<name>ChannelServiceแชนเนลรับส่งข้อความ
commCommServiceการสื่อสารระหว่างพนักงาน AI
uiUIServiceUI แบบกำหนดเองพร้อมพร็อกซี HTTP
scheduleScheduleServiceการจัดตารางเวลาแบบกำหนดเอง
visionToolServiceการประมวลผลภาพ
browserToolServiceการทำงานอัตโนมัติบนเบราว์เซอร์

แอปหนึ่งแอปมีได้หลายความสามารถ เช่น แอปหนึ่งอาจมีทั้งเครื่องมือและแผง UI

สิทธิ์

สิทธิ์ควบคุมสิ่งที่แอปเข้าถึงได้ ปฏิเสธเป็นค่าเริ่มต้น หากไม่ได้ประกาศไว้ แอปจะใช้ไม่ได้

คำนำหน้าตัวอย่างคำอธิบาย
network:network:outbound, network:*การเข้าถึงเครือข่าย
filesystem:filesystem:read, filesystem:writeการเข้าถึงระบบไฟล์
memory:memory:read, memory:writeการเข้าถึงความทรงจำของพนักงาน AI
session:session:readเซสชันการสนทนา
tool:tool:shell, tool:fileใช้เครื่องมืออื่น
shell:shell:execการรันคำสั่งเชลล์
channel:channel:send, channel:*การดำเนินการกับแชนเนล
comm:comm:send, comm:*การสื่อสารระหว่างพนักงาน AI
model:model:chatการเข้าถึงโมเดล AI
user:user:tokenรับ JWT ของผู้ใช้ในคำขอ
schedule:schedule:createการจัดการงาน Cron
database:database:queryการเข้าถึงฐานข้อมูล
storage:storage:read, storage:writeพื้นที่จัดเก็บถาวร
context:context:readการเข้าถึงบริบทของพนักงาน AI
subagent:subagent:spawnการดำเนินการกับเอเจนต์ย่อย
lane:lane:enqueueการดำเนินการกับเลน
notification:notification:sendการแจ้งเตือนแบบพุช
embedding:embedding:searchการเข้าถึงเวกเตอร์ embedding
skill:skill:invokeการเรียกใช้ทักษะ
advisor:advisor:consultการเข้าถึงระบบที่ปรึกษา
mcp:mcp:connectการเข้าถึงเซิร์ฟเวอร์ MCP
voice:voice:recordการเข้าถึงเสียง/ออดิโอ
browser:browser:navigateการทำงานอัตโนมัติบนเบราว์เซอร์
oauth:oauth:google, oauth:*การเข้าถึงโทเค็น OAuth
settings:settings:readการเข้าถึงการตั้งค่า
capability:capability:registerการลงทะเบียนความสามารถ

รองรับสิทธิ์แบบไวลด์การ์ด: network:* ตรงกับการตรวจสิทธิ์ network: ทุกรายการ

การตั้งค่า

การตั้งค่าจะแสดงใน UI ของ Nebo ใต้แผงการตั้งค่าของแอป Nebo จัดเก็บไว้ในฐานข้อมูลและส่งไปยังแอปของคุณผ่าน RPC Configure เมื่อมีการเปลี่ยนแปลง

สคีมาการตั้งค่าของคุณจะรวมอยู่ในรายการของแอปสโตร์ NeboAI แอปที่ยังไม่ได้กำหนดค่าการตั้งค่าที่จำเป็นจะแสดงป้าย "Needs Setup" ใน UI

ประเภทคำอธิบาย
textช่องป้อนข้อความบรรทัดเดียว
passwordช่องป้อนข้อความแบบซ่อนอักขระ
toggleสวิตช์เปิด/ปิดแบบบูลีน
selectดรอปดาวน์พร้อมตัวเลือกที่กำหนดไว้
numberช่องป้อนตัวเลข
urlช่องป้อน URL พร้อมการตรวจสอบความถูกต้อง
{
    "key": "region",
    "title": "Region",
    "type": "select",
    "required": true,
    "default": "us-east-1",
    "options": [
        {"label": "US East", "value": "us-east-1"},
        {"label": "EU West", "value": "eu-west-1"}
    ]
}

ข้อกำหนด OAuth

แอปประกาศข้อกำหนดผู้ให้บริการ OAuth ได้ ตัวกลาง OAuth ของ Nebo จัดการขั้นตอนทั้งหมด แอปได้รับโทเค็นโดยอัตโนมัติผ่าน RPC Configure

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
ฟิลด์คำอธิบาย
providerผู้ให้บริการ OAuth: "google", "microsoft", "github"
scopesอาร์เรย์ของขอบเขต OAuth ที่แอปต้องใช้

เมื่อผู้ใช้ติดตั้งแอป Nebo จะขอให้ผู้ใช้อนุญาตขอบเขต OAuth ที่จำเป็น แอปได้รับโทเค็นที่รีเฟรชแล้วผ่าน RPC Configure โดยไม่ต้องจัดการขั้นตอน OAuth เอง

ตัวแปรสภาพแวดล้อม

โปรเซสของแอปคุณได้รับสภาพแวดล้อมที่ผ่านการกรองแล้ว ข้อมูลลับทั้งหมดถูกตัดออก คุณจะได้รับ:

ตัวแปรค่า
NEBO_APP_DIRไดเรกทอรีที่ติดตั้งแอป
NEBO_APP_SOCKพาธไปยัง Unix socket ที่ต้องสร้าง
NEBO_APP_IDID ของแอปจาก manifest
NEBO_APP_NAMEชื่อแอปจาก manifest
NEBO_APP_VERSIONเวอร์ชันของแอปจาก manifest
NEBO_APP_DATAพาธไปยังไดเรกทอรี data/ ของแอป
PATHPATH ของระบบ (ส่งผ่าน)
HOMEไดเรกทอรีโฮมของผู้ใช้ (ส่งผ่าน)
TMPDIRไดเรกทอรีชั่วคราว (ส่งผ่าน)

สำคัญ: ไบนารีของคุณต้องสร้างเซิร์ฟเวอร์ gRPC ที่รอรับการเชื่อมต่อบน Unix socket ที่ NEBO_APP_SOCK Nebo จะรอให้ socket นี้ปรากฏสูงสุด 10 วินาที

ลำดับการเปิดใช้งานแอป

  1. Nebo อ่าน manifest.json และตรวจสอบความถูกต้อง
  2. ค้นหาไฟล์ปฏิบัติการ binary หรือ app ในไดเรกทอรีของแอป
  3. ตรวจหาเครื่องหมาย .quarantined (ปฏิเสธการเปิดแอปที่ถูกกักกัน)
  4. ตรวจสอบการเพิกถอน (เฉพาะแอปที่เผยแพร่ผ่าน NeboAI)
  5. ตรวจสอบลายเซ็น (เฉพาะแอปที่เผยแพร่ผ่าน NeboAI ข้ามในโหมดพัฒนา)
  6. ตรวจสอบไบนารี (ปฏิเสธ symlink สคริปต์ ไฟล์ที่ไม่ใช่ไฟล์ปฏิบัติการ และไฟล์ที่มีขนาดใหญ่เกิน)
  7. ล้าง socket ค้างจากการรันครั้งก่อน
  8. สร้างไดเรกทอรี data/ สำหรับพื้นที่จัดเก็บในแซนด์บ็อกซ์
  9. ตั้งค่าไฟล์บันทึกแยกต่อแอป (logs/stdout.log, logs/stderr.log)
  10. เริ่มไบนารีด้วยสภาพแวดล้อมที่ผ่านการกรองและแยกกลุ่มโปรเซส
  11. รอให้ Unix socket ปรากฏ (exponential backoff สูงสุด 10 วินาที)
  12. เชื่อมต่อผ่าน gRPC บน Unix socket
  13. สร้างไคลเอนต์ gRPC เฉพาะความสามารถตาม provides
  14. รันการตรวจสุขภาพ
  15. ลงทะเบียนความสามารถกับพนักงาน AI (เครื่องมือ เกตเวย์ comm ฯลฯ)

แอปเครื่องมือ

ประกาศ "provides": ["tool:my_tool_name"] ใน manifest ของคุณ

รูปแบบ STRAP

แอปเครื่องมือของ Nebo ทุกแอปต้องใช้STRAP (Single Tool Resource Action Pattern)สำหรับสคีมาและการกำหนดเส้นทางการทำงาน นี่คือรูปแบบเดียวกับที่ Nebo ใช้ภายในเพื่อรวมเครื่องมือเดี่ยวกว่า 35 รายการให้เหลือเครื่องมือตามโดเมน 4 รายการ ลดภาระบริบทของ LLM ได้ราว 80%

แนวคิดหลัก: แทนที่จะลงทะเบียนหลายเครื่องมือ (get_events, check_availability, suggest_slots) ให้ลงทะเบียนเครื่องมือเดียวที่มีฟิลด์ action (และ resource ถ้าต้องการ) ซึ่งกำหนดเส้นทางไปยัง handler ที่ถูกต้อง

ตัวอย่างทรัพยากรเดียว (ปฏิทิน):

calendar(action: "get_events", start: "2025-01-15T09:00:00Z", end: "2025-01-16T00:00:00Z")
calendar(action: "next_event")
calendar(action: "check_availability", start: "...", end: "...")
calendar(action: "suggest_slots", duration_minutes: 30, preferred_time: "morning")

ตัวอย่างหลายทรัพยากร (ตัวจัดการโปรเจกต์):

project(resource: "task", action: "create", title: "Ship v2", assignee: "alice")
project(resource: "task", action: "list", status: "open")
project(resource: "milestone", action: "create", name: "Beta", deadline: "2025-03-01")
project(resource: "milestone", action: "list")

กฎของสคีมา:

  1. ใส่ฟิลด์ action เป็น string enum ที่จำเป็นเสมอ
  2. เพิ่มฟิลด์ resource (string enum ที่จำเป็น) เฉพาะเมื่อเครื่องมือของคุณจัดการทรัพยากรหลายประเภทที่แตกต่างกัน
  3. ฟิลด์อื่นทั้งหมดเป็นพารามิเตอร์เฉพาะของแต่ละ action
  4. คำอธิบายของ enum action ควรระบุ action ทั้งหมดที่มี

ทำไม STRAP จึงสำคัญ:

  • LLM เรียนรู้รูปแบบการกำหนดเส้นทางด้วย action เพียงครั้งเดียวแล้วนำไปใช้กับทุกการดำเนินการได้
  • คำนิยามเครื่องมือใช้บริบทราว 6% STRAP ลดส่วนนั้นลง 80%
  • การดำเนินการใหม่เป็นเพียงการเพิ่มค่าใน enum ไม่ใช่การลงทะเบียนเครื่องมือใหม่
  • ทำงานเหมือนกันทั้งบนโมเดลที่โฮสต์และโมเดลในเครื่อง

ตัวอย่าง Go — เครื่องมือเครื่องคิดเลข

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    nebo "github.com/neboloop/nebo-sdk-go"
)

type Calculator struct{}

func (c *Calculator) Name() string        { return "calculator" }
func (c *Calculator) Description() string { return "Performs arithmetic calculations." }

func (c *Calculator) Schema() json.RawMessage {
    return nebo.NewSchema("add", "subtract", "multiply", "divide").
        Number("a", "First operand", true).
        Number("b", "Second operand", true).
        Build()
}

func (c *Calculator) Execute(_ context.Context, input json.RawMessage) (string, error) {
    var in struct {
        Action string  `json:"action"`
        A      float64 `json:"a"`
        B      float64 `json:"b"`
    }
    if err := json.Unmarshal(input, &in); err != nil {
        return "", fmt.Errorf("invalid input: %w", err)
    }

    var result float64
    switch in.Action {
    case "add":
        result = in.A + in.B
    case "subtract":
        result = in.A - in.B
    case "multiply":
        result = in.A * in.B
    case "divide":
        if in.B == 0 {
            return "", fmt.Errorf("division by zero")
        }
        result = in.A / in.B
    default:
        return "", fmt.Errorf("unknown action: %s", in.Action)
    }

    return fmt.Sprintf("%g %s %g = %g", in.A, in.Action, in.B, result), nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterTool(&Calculator{})
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.calculator",
    "name": "Calculator",
    "version": "1.0.0",
    "description": "Arithmetic calculator tool for the agent",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["tool:calculator"],
    "permissions": []
}

บิลด์และติดตั้ง:

go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/

ตัวอย่าง Rust

use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;

struct Calculator;

#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }

#[async_trait]
impl ToolHandler for Calculator {
    fn name(&self) -> &str { "calculator" }
    fn description(&self) -> &str { "Performs arithmetic calculations." }
    fn schema(&self) -> Value {
        SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
            .number("a", "First operand", true)
            .number("b", "Second operand", true)
            .build()
    }
    async fn execute(&self, input: Value) -> Result<String, NeboError> {
        let i: Input = serde_json::from_value(input)
            .map_err(|e| NeboError::Execution(e.to_string()))?;
        let r = match i.action.as_str() {
            "add" => i.a + i.b,
            "subtract" => i.a - i.b,
            "multiply" => i.a * i.b,
            "divide" => {
                if i.b == 0.0 {
                    return Err(NeboError::Execution("division by zero".into()));
                }
                i.a / i.b
            }
            other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
        };
        Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    NeboApp::new()?.register_tool(Calculator).run().await?;
    Ok(())
}

ตัวอย่าง C

#include <nebo/nebo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int calculator_execute(const char *input_json, char **output, int *is_error) {
    /* Parse JSON, compute result, set *output */
    *output = strdup("2 add 3 = 5");
    *is_error = 0;
    return 0;
}

int main(void) {
    const char *actions[] = {"add", "subtract", "multiply", "divide", NULL};
    nebo_schema_builder_t *sb = nebo_schema_new(actions);
    nebo_schema_number(sb, "a", "First operand", 1);
    nebo_schema_number(sb, "b", "Second operand", 1);
    char *schema = nebo_schema_build(sb);
    nebo_schema_free(sb);

    nebo_tool_handler_t calculator = {
        .name = "calculator",
        .description = "Performs arithmetic calculations.",
        .schema = schema,
        .execute = calculator_execute,
    };

    nebo_app_t *app = nebo_app_new();
    nebo_app_register_tool(app, &calculator);
    int ret = nebo_app_run(app);
    free(schema);
    return ret;
}

แอปแชนเนล

ประกาศ "provides": ["channel:my_channel"] และ "permissions": ["channel:send"]

แอปแชนเนลเชื่อมแพลตฟอร์มรับส่งข้อความภายนอก (Telegram, Discord, Slack ฯลฯ) เข้ากับพนักงาน AI ของ Nebo เมื่อผู้ใช้ส่งข้อความบนแพลตฟอร์มภายนอก แอปของคุณจะสตรีมข้อความนั้นไปยัง Nebo ผ่าน Receive เมื่อพนักงาน AI ต้องการตอบกลับ Nebo จะเรียก Send ของแอปคุณ

วิธีการทำงาน

  1. Nebo เรียก ID() เพื่อรับตัวระบุเฉพาะของแชนเนลคุณ
  2. Nebo เรียก Connect() พร้อมค่ากำหนดจากการตั้งค่าของแอปคุณ
  3. Nebo เปิดสตรีม Receive() แอปของคุณส่งข้อความขาเข้าทุกครั้งที่ผู้ใช้ส่งข้อความถึงบอท
  4. ข้อความขาเข้าจะถูกส่งไปยังเลนบทสนทนาหลักของพนักงาน AI
  5. เมื่อพนักงาน AI ต้องการส่งข้อความ Nebo จะเรียก Send() พร้อม message envelope v1
  6. เมื่อปิดระบบ Nebo จะเรียก Disconnect()

Message Envelope v1

ข้อความทั้งหมดในแชนเนล ทั้งขาเข้าและขาออก ใช้ message envelope ร่วมกัน:

{
  "message_id": "01953f8a-...",
  "channel_id": "telegram:12345",
  "sender": { "name": "Alex", "role": "COO", "bot_id": "uuid" },
  "text": "Q3 numbers look good...",
  "attachments": [{ "type": "image", "url": "https://...", "filename": "chart.png", "size": 45000 }],
  "reply_to": "01953f89-...",
  "actions": [{ "label": "Approve", "callback_id": "approve_q3" }],
  "platform_data": null,
  "timestamp": "2026-02-12T15:10:00Z"
}
ฟิลด์ประเภทคำอธิบาย
message_idUUID v7ID เฉพาะที่เรียงตามเวลา
channel_id{type}:{platform_id}ตัวระบุแชนเนลที่กำหนดเส้นทางได้
senderobjectตัวตนของบอท ได้แก่ name, role, botId
textstringเนื้อหาข้อความ
attachmentsarrayไฟล์ รูปภาพ ออดิโอ
reply_toUUID v7ID ของข้อความต้นทางสำหรับเธรด
actionsarrayปุ่ม/คีย์บอร์ดแบบโต้ตอบ
platform_databytesข้อมูลส่งผ่านแบบทึบสำหรับฟีเจอร์เฉพาะแพลตฟอร์ม
timestampISO 8601ผู้เผยแพร่เป็นผู้ตั้งค่านี้

การออกแบบสองชั้น: ฟิลด์ทั่วไป (text, attachments, reply_to, actions) ครอบคลุม 90% ของข้อความที่พนักงานเป็นผู้เริ่ม ฟีเจอร์เฉพาะแพลตฟอร์มใส่ไว้ใน platform_data ปลั๊กอินของคุณจะแปลงข้อมูลเหล่านี้ไปและกลับจากรูปแบบเนทีฟของแพลตฟอร์ม

สตรีมบทสนทนา

ข้อความในแชนเนลจะถูกส่งผ่านสตรีมบทสนทนาแยกต่อแชนเนลเพื่อการแยกส่วน:

neboai/bot/{botID}/channels/{channelType}/inbound    # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound   # messages from agent → channel

ตัวอย่าง Go — แชนเนล Telegram

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "time"

    "github.com/google/uuid"
    tgbot "github.com/go-telegram/bot"
    nebo "github.com/neboloop/nebo-sdk-go"
)

type Telegram struct {
    bot      *tgbot.Bot
    messages chan nebo.ChannelEnvelope
    cancel   context.CancelFunc
}

func (t *Telegram) ID() string { return "telegram" }

func (t *Telegram) Connect(_ context.Context, config map[string]string) error {
    token := config["bot_token"]
    if token == "" {
        return fmt.Errorf("bot_token is required")
    }

    botCtx, cancel := context.WithCancel(context.Background())
    t.cancel = cancel

    bot, err := tgbot.New(token, tgbot.WithDefaultHandler(
        func(bCtx context.Context, b *tgbot.Bot, update *tgbot.Update) {
            if update.Message == nil {
                return
            }
            env := nebo.ChannelEnvelope{
                MessageID: uuid.Must(uuid.NewV7()).String(),
                ChannelID: fmt.Sprintf("telegram:%d", update.Message.Chat.ID),
                Text:      update.Message.Text,
                Timestamp: time.Unix(int64(update.Message.Date), 0).UTC(),
            }
            t.messages <- env
        },
    ))
    if err != nil {
        return err
    }

    t.bot = bot
    go bot.Start(botCtx)
    return nil
}

func (t *Telegram) Send(ctx context.Context, env nebo.ChannelEnvelope) (string, error) {
    if t.bot == nil {
        return "", fmt.Errorf("not connected")
    }
    chatID := env.ChannelID[len("telegram:"):]
    params := &tgbot.SendMessageParams{
        ChatID: chatID,
        Text:   env.Text,
    }
    msg, err := t.bot.SendMessage(ctx, params)
    if err != nil {
        return "", err
    }
    return fmt.Sprintf("%d", msg.MessageID), nil
}

func (t *Telegram) Receive(_ context.Context) (<-chan nebo.ChannelEnvelope, error) {
    return t.messages, nil
}

func (t *Telegram) Disconnect(_ context.Context) error {
    if t.cancel != nil {
        t.cancel()
    }
    return nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterChannel(&Telegram{
        messages: make(chan nebo.ChannelEnvelope, 100),
    })
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.telegram",
    "name": "Telegram",
    "version": "1.0.0",
    "description": "Telegram messaging channel for Nebo",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["channel:telegram"],
    "permissions": ["channel:send", "network:outbound"],
    "settings": [
        {
            "key": "bot_token",
            "title": "Bot Token",
            "type": "password",
            "required": true,
            "description": "Telegram bot token from @BotFather",
            "secret": true
        }
    ]
}

ความสามารถเพิ่มเติม

แอป Comm

ประกาศ "provides": ["comm"] และ "permissions": ["comm:*"] แอป Comm ช่วยให้พนักงาน AI สื่อสารกันได้

ฟิลด์คำอธิบาย
fromID ของพนักงานผู้ส่ง
toID ของพนักงานผู้รับ
topicหัวข้อ/แชนเนลของข้อความ
type"message", "mention", "proposal", "command", "info", "task"
contentเนื้อหาข้อความ

พฤติกรรมหลัก:

  • Register ประกาศพนักงาน AI นี้บนเครือข่ายพร้อมความสามารถของมัน
  • Subscribe/Unsubscribe จัดการการติดตามหัวข้อ
  • Receive สตรีมข้อความขาเข้า (server-streaming เหมือนกับแชนเนล)
  • ใช้งานแอป Comm ได้ครั้งละหนึ่งแอปเท่านั้น

แอปเกตเวย์

แอปเกตเวย์กำหนดเส้นทางคำขอ LLM ไปยังโมเดล ประกาศ "provides": ["gateway"] และ "permissions": ["network:outbound", "user:token"]

GatewayRequest ประกอบด้วยข้อความ เครื่องมือ system prompt จำนวนโทเค็นสูงสุด temperature และ UserContext (โทเค็น JWT หากได้รับสิทธิ์ user:token)

ประเภทของ GatewayEvent:

ประเภทเนื้อหาคำอธิบาย
"text"ส่วนของข้อความโทเค็นข้อความแบบสตรีม
"tool_call"JSONโมเดลต้องการเรียกเครื่องมือ
"thinking"ส่วนของข้อความการคิด/การให้เหตุผลแบบขยาย
"error"ข้อความแสดงข้อผิดพลาดเกิดข้อผิดพลาดบางอย่าง
"done"ว่างสตรีมเสร็จสมบูรณ์

แอป UI

แอป UI ให้อินเทอร์เฟซการกำหนดค่าแบบกำหนดเองที่เปิดในหน้าต่างเบราว์เซอร์ในตัวของ Nebo ประกาศ "provides": ["ui"] ต่างจากฟอร์มการตั้งค่าอัตโนมัติ (ซึ่ง Nebo สร้างจาก settings ใน manifest ของคุณ) แอป UI จะให้บริการฟรอนต์เอนด์ HTML/CSS/JS เต็มรูปแบบของตัวเอง

แอปของคุณมาพร้อมไดเรกทอรี ui/ ที่มีไฟล์เว็บแบบสแตติก (HTML, CSS, JS โดยทั่วไปเป็น SPA ที่มี index.html) Nebo ให้บริการไฟล์เหล่านี้โดยตรงและส่งต่อการเรียก API ไปยังแอปของคุณผ่าน gRPC

พาธกลไกวัตถุประสงค์
GET /api/v1/apps/{id}/ui/*เซิร์ฟเวอร์ไฟล์สแตติกให้บริการไฟล์จากไดเรกทอรี ui/ ของคุณ (SPA fallback ไปยัง index.html)
ANY /api/v1/apps/{id}/api/*พร็อกซี gRPCส่งต่อคำขอ HTTP ไปยัง UIService.HandleRequest() ของแอปคุณ

SDK ครอบ net/http.ServeMux มาตรฐานไว้ คุณจึงเขียน HTTP handler ของ Go ได้ตามปกติ SDK จะจัดการการเชื่อมต่อ gRPC ให้โดยอัตโนมัติ

ตัวอย่าง Go — UI แดชบอร์ด:

package main

import (
    "encoding/json"
    "log"
    "net/http"

    nebo "github.com/neboloop/nebo-sdk-go"
)

type Dashboard struct {
    mux *http.ServeMux
}

func NewDashboard() *Dashboard {
    d := &Dashboard{mux: http.NewServeMux()}

    d.mux.HandleFunc("GET /status", func(w http.ResponseWriter, r *http.Request) {
        json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
    })

    d.mux.HandleFunc("POST /action", func(w http.ResponseWriter, r *http.Request) {
        var req map[string]string
        json.NewDecoder(r.Body).Decode(&req)
        json.NewEncoder(w).Encode(map[string]string{"result": "done"})
    })

    return d
}

func (d *Dashboard) Handler() *http.ServeMux { return d.mux }

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterUI(NewDashboard())
    log.Fatal(app.Run())
}

ui/index.html ของคุณจะเรียก fetch ไปที่ /api/v1/apps/com.example.dashboard/api/status ซึ่งจะถูกส่งต่อไปยัง handler mux ของคุณ

แอปตารางเวลา

แอปตารางเวลาแทนที่ตัวจัดตารางเวลา cron ในตัวของ Nebo ประกาศ "provides": ["schedule"] และ "permissions": ["schedule:create"]

เมื่อแอปตารางเวลาของคุณเริ่มทำงาน Nebo จะส่งการจัดตารางเวลาทั้งหมดผ่านแอปของคุณแทนเอนจิน cron เริ่มต้น หากแอปของคุณล่ม Nebo จะกลับไปใช้เอนจินในตัวโดยอัตโนมัติ

  • แอปของคุณเป็นเจ้าของสถานะตารางเวลา Nebo จะไม่เก็บตารางเวลาไว้ในฐานข้อมูลของตัวเองเมื่อมีแอปตารางเวลาทำงานอยู่
  • CRUD มาตรฐาน: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers เป็น RPC แบบ server-streaming แอปของคุณส่งข้อความทริกเกอร์ทุกครั้งที่ตารางเวลาถึงกำหนด
  • ใช้งานแอปตารางเวลาได้ครั้งละหนึ่งแอปเท่านั้น

แอปที่มีหลายความสามารถ

แอปหนึ่งแอปมีได้หลายความสามารถ เช่น แอปแดชบอร์ดที่มีทั้งเครื่องมือและ UI:

{
    "id": "com.example.dashboard",
    "name": "Dashboard",
    "version": "1.0.0",
    "provides": ["tool:dashboard_query", "ui"],
    "permissions": ["network:outbound"]
}
app, _ := nebo.New()
app.RegisterTool(&dashboardTool{})
app.RegisterUI(&dashboardUI{})
log.Fatal(app.Run())

การแพ็กเกจ

รูปแบบ .napp

สำหรับการเผยแพร่ผ่าน NeboAI ให้แพ็กเกจแอปของคุณเป็นไฟล์ .napp (ไฟล์บีบอัด tar.gz):

cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md

ไฟล์ที่จำเป็น:

ไฟล์ขนาดสูงสุดคำอธิบาย
manifest.json1 MBข้อมูลเมตาของแอป
binary หรือ app500 MBไฟล์ปฏิบัติการ
signatures.json1 MBลายเซ็น Ed25519
TOOL.md1 MBคำแนะนำการใช้เครื่องมือสำหรับพนักงาน AI

กฎความปลอดภัยระหว่างการแตกไฟล์:

  • ห้าม path traversal (ปฏิเสธ ../)
  • ห้าม symlink (ปฏิเสธ)
  • ห้ามพาธแบบสัมบูรณ์ (ปฏิเสธ)
  • ยอมรับเฉพาะชื่อไฟล์ที่อยู่ในรายการที่อนุญาต

ลายเซ็น

NeboAI ลงนามแอปด้วย Ed25519 รูปแบบของ signatures.json:

{
    "key_id": "a1b2c3d4",
    "algorithm": "ed25519",
    "manifest_signature": "<base64 signature of raw manifest.json bytes>",
    "binary_sha256": "<hex SHA256 of binary>",
    "binary_signature": "<base64 signature of raw binary bytes>"
}

ในโหมดพัฒนา (ไม่ได้กำหนด URL ของ NeboAI) จะข้ามการตรวจสอบลายเซ็นทั้งหมด คุณไม่จำเป็นต้องมี signatures.json สำหรับการพัฒนาในเครื่อง

การเผยแพร่

เมื่อแอปของคุณทำงานได้ในเครื่องแล้ว ให้เผยแพร่ผ่าน NeboAI เพื่อส่งถึงผู้ใช้ Nebo ทุกคน

การตั้งค่าบัญชีนักพัฒนา

  1. ลงทะเบียนบัญชี NeboAI ที่ POST /api/v1/owners/register
  2. เข้าสู่ระบบเพื่อรับโทเค็น JWT: POST /api/v1/owners/login
  3. สร้างบัญชีนักพัฒนา: POST /api/v1/developer/accounts

ขั้นตอนการส่ง

draft → pending_review → [approved] → published
                       → [rejected] → draft (fix and resubmit)

ขั้นตอนที่ 1: สร้างแอป

curl -X POST https://neboai.com/api/v1/developer/apps \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My App",
    "version": "1.0.0",
    "description": "What it does",
    "category": "productivity",
    "visibility": "public"
  }'

ขั้นตอนที่ 2: อัปโหลดไบนารีของแต่ละแพลตฟอร์ม

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/binaries \
  -H "Authorization: Bearer $TOKEN" \
  -F "binary=@myapp-darwin-arm64" \
  -F "platform=darwin-arm64"

อัปโหลดไบนารีหนึ่งไฟล์ต่อแพลตฟอร์ม: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64

ขั้นตอนที่ 3: ส่งเข้ารับการตรวจสอบ

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
  -H "Authorization: Bearer $TOKEN"

กระบวนการตรวจสอบ

  1. การสแกนอัตโนมัติ ไบนารีจะถูกสแกนผ่าน VirusTotal
  2. การตรวจสอบโดยผู้ดูแล ทีม NeboAI ตรวจสอบข้อมูลเมตา manifest และผลการสแกน
  3. เมื่อได้รับอนุมัติ NeboAI ลงนามแอปด้วย Ed25519 และเผยแพร่
  4. เมื่อถูกปฏิเสธ คุณจะได้รับเหตุผล และแก้ไขแล้วส่งใหม่ได้

เวลาตรวจสอบเป้าหมาย: <24 ชั่วโมง

การส่งอัปเดต

  1. อัปเดตเวอร์ชันของแอป: PUT /api/v1/developer/apps/{id} พร้อมเวอร์ชันใหม่
  2. อัปโหลดไบนารีใหม่สำหรับแต่ละแพลตฟอร์ม
  3. ส่งเข้ารับการตรวจสอบอีกครั้ง

ทุกการอัปเดตผ่านกระบวนการตรวจสอบเดียวกัน เวอร์ชันก่อนหน้ายังใช้งานได้จนกว่าเวอร์ชันใหม่จะได้รับอนุมัติ

ข้อมูลเมตาในสโตร์

ฟิลด์คำอธิบาย
categoryเช่น productivity, communication, developer-tools
iconURL ไอคอนของแอป
visibilitypublic หรือ private
descriptionยาวและละเอียดกว่าคำอธิบายใน manifest ได้

เวิร์กโฟลว์การพัฒนา

การพัฒนาในเครื่อง

ไม่ต้องแพ็กเกจสำหรับการพัฒนาในเครื่อง:

  1. สร้างไดเรกทอรีของแอป:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. เขียน manifest.json และโค้ดของคุณ
  3. บิลด์ไบนารีของคุณ:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo ตรวจพบไดเรกทอรีใหม่โดยอัตโนมัติ (หรือรีสตาร์ต Nebo)
  5. หลังแก้ไขโค้ด ให้บิลด์ไบนารีใหม่ ตัวเฝ้าดูไฟล์จะรีสตาร์ตแอปให้

การดูบันทึก

stdout/stderr ของแอปจะถูกบันทึกไว้ในไฟล์บันทึกแยกต่อแอป:

tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stdout.log
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stderr.log

ข้อมูลถาวร

ใช้ไดเรกทอรี data/ (ใช้ได้ผ่านตัวแปรสภาพแวดล้อม NEBO_APP_DATA ด้วย) สำหรับไฟล์ใด ๆ ที่แอปของคุณต้องเก็บไว้ถาวร ไดเรกทอรีนี้คงอยู่แม้มีการอัปเดตแอปหรือการกักกัน

เคล็ดลับการดีบัก

  • หากแอปของคุณไม่เริ่มทำงาน ให้ตรวจดูข้อผิดพลาดใน logs/stderr.log
  • ตรวจสอบว่าไบนารีเป็นไฟล์ปฏิบัติการได้ (chmod +x binary)
  • ตรวจสอบว่าคุณรอรับการเชื่อมต่ออยู่บนพาธ Unix socket จาก NEBO_APP_SOCK
  • socket ต้องพร้อมภายใน 10 วินาทีหลังเปิดใช้งาน
  • ใช้ NEBO_APP_DATA สำหรับพื้นที่จัดเก็บ ไม่ใช่พาธที่กำหนดตายตัว
  • พิมพ์ออกทาง stderr เพื่อบันทึกการดีบัก (บันทึกไว้ใน logs/stderr.log)

การตรวจสอบ

# List installed apps
nebo apps list

# Check running apps via the web UI Settings > Apps
# Or check the apps directory for running sockets
ls ~/Library/Application\ Support/Nebo/apps/*/app.sock

การถอนการติดตั้ง

nebo apps uninstall com.example.myapp

ทักษะ

ทักษะคืออะไร

ทักษะคือชุดคำแนะนำที่กำหนดพฤติกรรมของ Nebo ระหว่างการสนทนา เมื่อทักษะทำงานอยู่ เนื้อหาของทักษะจะถูกแทรกเข้าไปใน system prompt โดยตรง เพื่อชี้นำน้ำเสียง วิธีการ ความเชี่ยวชาญเฉพาะด้าน และการใช้เครื่องมือของพนักงาน AI ในเซสชันนั้น

ทักษะไม่ใช่โค้ด แต่เป็นเอกสาร markdown ที่มีข้อมูลเมตาแบบ YAML ไม่ต้องคอมไพล์ ไม่มีไบนารี ไม่มี gRPC ทักษะคือไฟล์ SKILL.md ในไดเรกทอรี แค่นั้นเอง

ทักษะขึ้นกับบริบทและเป็นแบบชั่วคราว ทักษะจะทำงานเมื่อเกี่ยวข้อง (ผ่านการจับคู่ทริกเกอร์หรือการโหลดด้วยตนเอง) คงอยู่ไม่กี่รอบการสนทนา และหมดอายุเมื่อไม่จำเป็นอีกต่อไป วิธีนี้ทำให้บริบทของพนักงาน AI กระชับ มีเพียงคำแนะนำที่สำคัญในตอนนี้เท่านั้นที่อยู่ใน prompt

ทักษะเสริมแอป แอปให้ความสามารถที่ทำงานได้จริง (เครื่องมือ แชนเนล เกตเวย์) ทักษะให้คำแนะนำในการประสานงาน คือวิธีใช้เครื่องมือเหล่านั้นอย่างมีประสิทธิภาพ แอปปฏิทินให้ Nebo อ่านและเขียนกิจกรรมได้ ทักษะ "เตรียมประชุม" บอก Nebo ว่าต้องเตรียมการประชุมอย่างไรโดยใช้แอปปฏิทิน อีเมล และการค้นหาเว็บร่วมกัน

ทักษะกับแอป

ทักษะแอป
รูปแบบMarkdown (SKILL.md)ไบนารีที่คอมไพล์แล้ว (.napp)
รันไทม์แทรกเข้าไปใน system promptโปรเซสในแซนด์บ็อกซ์ผ่าน gRPC
ให้อะไรคำแนะนำด้านพฤติกรรม วิธีการเครื่องมือ แชนเนล แผง UI
อายุการใช้งานอยู่ในขอบเขตเซสชัน หมดอายุตาม TTLทำงานตลอดเวลา
การสร้างเขียนไฟล์ markdownเขียน คอมไพล์ ลงนาม แพ็กเกจ
ความปลอดภัยไม่ต้องใช้สิทธิ์แซนด์บ็อกซ์ที่ปฏิเสธเป็นค่าเริ่มต้น

เริ่มต้นอย่างรวดเร็ว

สร้างไดเรกทอรีในโฟลเดอร์ทักษะของ Nebo พร้อมไฟล์ SKILL.md:

~/Library/Application Support/Nebo/skills/   # macOS
~/.config/nebo/skills/                        # Linux
%AppData%\Nebo\skills\                        # Windows
mkdir -p ~/.config/nebo/skills/my-skill

เขียน SKILL.md:

---
name: my-skill
description: One-line description of what this skill does
version: "1.0.0"
triggers:
  - keyword that activates this skill
  - another trigger phrase
---

# My Skill

Instructions for Nebo when this skill is active.

Tell the agent what to do, how to approach problems,
what tools to use, and what tone to take.

Nebo เฝ้าดูไดเรกทอรีทักษะด้วย fsnotify ทักษะของคุณใช้งานได้ทันที ไม่ต้องรีสตาร์ต พูดสิ่งที่ตรงกับทริกเกอร์ แล้วทักษะจะทำงานโดยอัตโนมัติ

หรือขอให้ Nebo ทำโดยตรง: "สร้างทักษะสำหรับเขียนบล็อกโพสต์" Nebo จะเขียนไฟล์ SKILL.md ให้คุณ

รูปแบบ SKILL.md

ทุกทักษะเป็นไฟล์ SKILL.md ไฟล์เดียวที่มีสองส่วน คือ YAML frontmatter ระหว่างเครื่องหมาย --- และเนื้อหา markdown (คำแนะนำจริงที่ถูกแทรกเข้าไปใน system prompt)

ฟิลด์จำเป็นค่าเริ่มต้นคำอธิบาย
nameใช่—ตัวระบุเฉพาะ (กลายเป็น slug)
descriptionใช่—คำอธิบายหนึ่งบรรทัดที่แสดงในแคตตาล็อกทักษะ
versionไม่"1.0.0"Semver สำหรับติดตามการอัปเดต
authorไม่—ผู้สร้างทักษะ
priorityไม่0สูงกว่า = จับคู่ก่อน (100+ สำหรับการแทนที่ที่สำคัญ)
max_turnsไม่4จำนวนรอบที่ไม่มีการใช้งานก่อนหมดอายุอัตโนมัติ
triggersไม่[]วลีที่เปิดใช้งานทักษะนี้โดยอัตโนมัติ (จับคู่สตริงย่อยแบบไม่สนตัวพิมพ์เล็กใหญ่)
toolsไม่[]เครื่องมือที่ทักษะนี้คาดว่าจะใช้ (เพื่อเป็นข้อมูล)
dependenciesไม่[]ทักษะอื่นที่ต้องติดตั้ง
tagsไม่[]สำหรับการจัดหมวดหมู่และการค้นพบ
platformไม่[]แพลตฟอร์มที่รองรับ: macos, linux, windows (ว่าง = ทั้งหมด)

ทักษะเปิดใช้งานอย่างไร

ทักษะใช้รูปแบบการเปิดใช้งานสองขั้น: บอกใบ้ แล้วจึงเรียกใช้

ขั้นที่ 1: การจับคู่ทริกเกอร์ ทุกครั้งที่ผู้ใช้ส่งข้อความ Nebo จะสแกนทักษะที่ลงทะเบียนไว้ทั้งหมดเพื่อหาทริกเกอร์ที่ตรงกัน ทักษะที่ตรงกันจะปรากฏเป็นคำใบ้ใน system prompt พนักงาน AI เห็นคำใบ้แล้วตัดสินใจว่าจะเรียกใช้ทักษะหรือไม่

ขั้นที่ 2: การเรียกใช้ พนักงาน AI เรียกใช้ทักษะโดยเรียก:

skill(name: "code-review")

คำสั่งนี้จะคืนเทมเพลต SKILL.md ทั้งหมดเป็นผลลัพธ์ของเครื่องมือ บันทึกการเรียกใช้ และแทรกเทมเพลตกลับเข้าไปใน system prompt ในรอบถัด ๆ ไป

TTL และการหมดอายุ:

  • ทักษะที่จับคู่อัตโนมัติ: ไม่มีการใช้งาน 4 รอบ (กำหนดได้ผ่าน max_turns)
  • ทักษะที่โหลดด้วยตนเอง: ไม่มีการใช้งาน 6 รอบ
  • การเรียกใช้ซ้ำจะรีเซ็ตตัวจับเวลา
  • ขีดจำกัดสูงสุด: ทักษะที่ทำงานอยู่ได้สูงสุด 4 รายการต่อเซสชัน
  • งบโทเค็น: เนื้อหาของทักษะที่ทำงานอยู่รวมกันได้ไม่เกิน 16,000 ตัวอักษร

การจัดการทักษะ

พนักงาน AI จัดการทักษะได้ผ่านเครื่องมือ skill:

Actionคำอธิบายตัวอย่าง
catalogแสดงรายการทักษะทั้งหมดที่มีskill(action: "catalog")
loadเปิดใช้งานสำหรับเซสชันนี้skill(name: "code-review", action: "load")
unloadปิดใช้งานทักษะskill(name: "code-review", action: "unload")
createสร้างทักษะใหม่บนดิสก์skill(action: "create", content: "...")
updateอัปเดตทักษะที่มีอยู่skill(name: "my-skill", action: "update", content: "...")
deleteลบทักษะออกจากดิสก์skill(name: "my-skill", action: "delete")

การเขียนทักษะที่ดี

เทมเพลตทักษะที่ดีมี:

  1. หัวเรื่องที่ชัดเจน บอกพนักงาน AI ว่ากำลังอยู่ในโหมดใด
  2. หลักการสำคัญ กฎด้านพฤติกรรมที่ต่อรองไม่ได้
  3. วิธีการ แนวทางทีละขั้นตอนสำหรับสถานการณ์ทั่วไป
  4. ตัวอย่าง รูปแบบที่เป็นรูปธรรมจากข้อความผู้ใช้ถึงคำตอบ
  5. รูปแบบที่ควรหลีกเลี่ยง สิ่งที่ไม่ควรทำ (โมเดลเรียนรู้ได้ดีจากตัวอย่างเชิงลบ)

เคล็ดลับ: แต่ละทักษะควรทำสิ่งเดียวให้ดี อย่าสร้างทักษะ "การเขียนโปรแกรมทั่วไป" แต่ให้สร้าง code-review, debugging, api-design แยกเป็นทักษะต่างหาก พนักงาน AI เปิดใช้หลายทักษะพร้อมกันได้

ทักษะที่มาพร้อมระบบ

Nebo มาพร้อมทักษะที่ครอบคลุมกรณีการใช้งานทั่วไป:

ทักษะลำดับความสำคัญคำอธิบาย
onboarding100ทักทายผู้ใช้ใหม่และเก็บข้อมูลโปรไฟล์
best-friend50ทักษะด้านบุคลิกภาพ เป็นกันเอง ภักดี พูดตรง
debugging25วิธีการดีบักอย่างเป็นระบบ
api-design15แนวปฏิบัติที่ดีในการออกแบบ RESTful API
code-review10การรีวิวโค้ดแบบมีโครงสร้างพร้อมระดับความรุนแรง
database-expert10การออกแบบฐานข้อมูล คิวรี และการปรับประสิทธิภาพ
git-workflow10การแตกสาขา Git คอมมิต และเวิร์กโฟลว์ PR
security-audit10การวิเคราะห์ความปลอดภัยและการตรวจหาช่องโหว่

ทักษะเหล่านี้เป็นทั้งค่าเริ่มต้นที่มีประโยชน์และตัวอย่างอ้างอิงสำหรับการสร้างทักษะของคุณเอง

ข้อมูลอ้างอิง

ไฟล์ Proto

ไฟล์ Proto อยู่ใน proto/apps/v0/ SDK มาพร้อมโค้ดที่สร้างไว้ล่วงหน้า คุณจึงไม่ต้องใช้ protoc สำหรับการพัฒนาตามปกติ

ไฟล์บริการRPC หลัก
v0/common.proto(เฉพาะข้อความ)HealthCheckRequest/Response, SettingsMap, UserContext, Empty
v0/tool.protoToolServiceName, Description, Schema, Execute, RequiresApproval, Configure
v0/channel.protoChannelServiceID, Connect, Disconnect, Send, Receive (stream), Configure
v0/comm.protoCommServiceName, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure
v0/gateway.protoGatewayServiceHealthCheck, Stream (stream), Poll, Cancel, Configure
v0/ui.protoUIServiceHealthCheck, HandleRequest, Configure
v0/schedule.protoScheduleServiceHealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure

ทุกบริการมี RPC HealthCheck และ Configure SDK จัดการทั้งสองให้โดยอัตโนมัติ

ประเภท Proto ของแชนเนล

ประเภทข้อความคำอธิบาย
ChannelSendRequestmessage envelope ขาออกที่มี message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponseID ข้อความของแพลตฟอร์มสำหรับเธรด
InboundMessagemessage envelope ขาเข้าที่มีฟิลด์ทั่วไปทั้งหมด + timestamp
MessageSenderตัวตนของบอท (name, role, botId) เติมข้อมูลโดยตัวกลาง
Attachmentไฟล์แนบประเภทไฟล์/รูปภาพ/ออดิโอ (type, url, filename, size)
MessageActionaction ของปุ่ม/คีย์บอร์ดแบบโต้ตอบ (label, callback_id)

ตัวตนและบทบาทของบอท

บอทของ Nebo มีโมเดลตัวตนสามมิติ:

  • creature บอทคืออะไร (ต้นแบบ): "นักวางกลยุทธ์หัวไว", "นักวิจัยผู้พิถีพิถัน"
  • role บอทเกี่ยวข้องกับผู้ใช้อย่างไร (ความสัมพันธ์): "เพื่อน", "COO", "ที่ปรึกษา"
  • vibe พลังของบอท (สไตล์การสื่อสาร): "สบาย ๆ แต่มีความเห็นชัดเจน", "อบอุ่นและให้กำลังใจ"

เมื่อปลั๊กอินแชนเนลของคุณได้รับข้อความขาออก ฟิลด์ sender จะมี name และ role ของบอท ใช้ข้อมูลนี้จัดรูปแบบชื่อที่แสดงบนแพลตฟอร์มของคุณ role ไม่ใช่ตำแหน่งงาน แต่เป็นคำบอกความสัมพันธ์ "เพื่อน", "ลูกชาย" และ "ที่ปรึกษา" เป็น role ที่ใช้ได้เช่นเดียวกับ "COO" และ "DevLead"