ภาพรวม
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) รายการตรวจสอบสำหรับแอปขั้นต่ำ
- สร้าง
manifest.jsonที่มีid,name,version,provides - เขียน
TOOL.mdอธิบายว่าพนักงาน AI ควรใช้เครื่องมือของคุณอย่างไร - ติดตั้ง SDK (
go get github.com/neboloop/nebo-sdk-go) - implement อินเทอร์เฟซ handler สำหรับความสามารถของคุณ (
ToolHandler,ChannelHandlerฯลฯ) - ลงทะเบียน handler แล้วเรียก
app.Run() - บิลด์ไบนารีแบบเนทีฟ (
go build -o binary .) - วางไบนารี + manifest.json + TOOL.md ไว้ในไดเรกทอรี
apps/<your-app-id>/ - 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 | คำอธิบาย |
|---|---|---|
gateway | GatewayService | การกำหนดเส้นทางโมเดล LLM |
tool:<name> | ToolService | เครื่องมือที่มีชื่อสำหรับพนักงาน AI |
channel:<name> | ChannelService | แชนเนลรับส่งข้อความ |
comm | CommService | การสื่อสารระหว่างพนักงาน AI |
ui | UIService | UI แบบกำหนดเองพร้อมพร็อกซี HTTP |
schedule | ScheduleService | การจัดตารางเวลาแบบกำหนดเอง |
vision | ToolService | การประมวลผลภาพ |
browser | ToolService | การทำงานอัตโนมัติบนเบราว์เซอร์ |
แอปหนึ่งแอปมีได้หลายความสามารถ เช่น แอปหนึ่งอาจมีทั้งเครื่องมือและแผง 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_ID | ID ของแอปจาก manifest |
NEBO_APP_NAME | ชื่อแอปจาก manifest |
NEBO_APP_VERSION | เวอร์ชันของแอปจาก manifest |
NEBO_APP_DATA | พาธไปยังไดเรกทอรี data/ ของแอป |
PATH | PATH ของระบบ (ส่งผ่าน) |
HOME | ไดเรกทอรีโฮมของผู้ใช้ (ส่งผ่าน) |
TMPDIR | ไดเรกทอรีชั่วคราว (ส่งผ่าน) |
สำคัญ: ไบนารีของคุณต้องสร้างเซิร์ฟเวอร์ gRPC ที่รอรับการเชื่อมต่อบน Unix socket ที่ NEBO_APP_SOCK Nebo จะรอให้ socket นี้ปรากฏสูงสุด 10 วินาที
ลำดับการเปิดใช้งานแอป
- Nebo อ่าน
manifest.jsonและตรวจสอบความถูกต้อง - ค้นหาไฟล์ปฏิบัติการ
binaryหรือappในไดเรกทอรีของแอป - ตรวจหาเครื่องหมาย
.quarantined(ปฏิเสธการเปิดแอปที่ถูกกักกัน) - ตรวจสอบการเพิกถอน (เฉพาะแอปที่เผยแพร่ผ่าน NeboAI)
- ตรวจสอบลายเซ็น (เฉพาะแอปที่เผยแพร่ผ่าน NeboAI ข้ามในโหมดพัฒนา)
- ตรวจสอบไบนารี (ปฏิเสธ symlink สคริปต์ ไฟล์ที่ไม่ใช่ไฟล์ปฏิบัติการ และไฟล์ที่มีขนาดใหญ่เกิน)
- ล้าง socket ค้างจากการรันครั้งก่อน
- สร้างไดเรกทอรี
data/สำหรับพื้นที่จัดเก็บในแซนด์บ็อกซ์ - ตั้งค่าไฟล์บันทึกแยกต่อแอป (
logs/stdout.log,logs/stderr.log) - เริ่มไบนารีด้วยสภาพแวดล้อมที่ผ่านการกรองและแยกกลุ่มโปรเซส
- รอให้ Unix socket ปรากฏ (exponential backoff สูงสุด 10 วินาที)
- เชื่อมต่อผ่าน gRPC บน Unix socket
- สร้างไคลเอนต์ gRPC เฉพาะความสามารถตาม
provides - รันการตรวจสุขภาพ
- ลงทะเบียนความสามารถกับพนักงาน 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") กฎของสคีมา:
- ใส่ฟิลด์
actionเป็น string enum ที่จำเป็นเสมอ - เพิ่มฟิลด์
resource(string enum ที่จำเป็น) เฉพาะเมื่อเครื่องมือของคุณจัดการทรัพยากรหลายประเภทที่แตกต่างกัน - ฟิลด์อื่นทั้งหมดเป็นพารามิเตอร์เฉพาะของแต่ละ action
- คำอธิบายของ 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 ของแอปคุณ
วิธีการทำงาน
- Nebo เรียก
ID()เพื่อรับตัวระบุเฉพาะของแชนเนลคุณ - Nebo เรียก
Connect()พร้อมค่ากำหนดจากการตั้งค่าของแอปคุณ - Nebo เปิดสตรีม
Receive()แอปของคุณส่งข้อความขาเข้าทุกครั้งที่ผู้ใช้ส่งข้อความถึงบอท - ข้อความขาเข้าจะถูกส่งไปยังเลนบทสนทนาหลักของพนักงาน AI
- เมื่อพนักงาน AI ต้องการส่งข้อความ Nebo จะเรียก
Send()พร้อม message envelope v1 - เมื่อปิดระบบ 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_id | UUID v7 | ID เฉพาะที่เรียงตามเวลา |
channel_id | {type}:{platform_id} | ตัวระบุแชนเนลที่กำหนดเส้นทางได้ |
sender | object | ตัวตนของบอท ได้แก่ name, role, botId |
text | string | เนื้อหาข้อความ |
attachments | array | ไฟล์ รูปภาพ ออดิโอ |
reply_to | UUID v7 | ID ของข้อความต้นทางสำหรับเธรด |
actions | array | ปุ่ม/คีย์บอร์ดแบบโต้ตอบ |
platform_data | bytes | ข้อมูลส่งผ่านแบบทึบสำหรับฟีเจอร์เฉพาะแพลตฟอร์ม |
timestamp | ISO 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 สื่อสารกันได้
| ฟิลด์ | คำอธิบาย |
|---|---|
from | ID ของพนักงานผู้ส่ง |
to | ID ของพนักงานผู้รับ |
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.json | 1 MB | ข้อมูลเมตาของแอป |
binary หรือ app | 500 MB | ไฟล์ปฏิบัติการ |
signatures.json | 1 MB | ลายเซ็น Ed25519 |
TOOL.md | 1 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 ทุกคน
การตั้งค่าบัญชีนักพัฒนา
- ลงทะเบียนบัญชี NeboAI ที่
POST /api/v1/owners/register - เข้าสู่ระบบเพื่อรับโทเค็น JWT:
POST /api/v1/owners/login - สร้างบัญชีนักพัฒนา:
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" กระบวนการตรวจสอบ
- การสแกนอัตโนมัติ ไบนารีจะถูกสแกนผ่าน VirusTotal
- การตรวจสอบโดยผู้ดูแล ทีม NeboAI ตรวจสอบข้อมูลเมตา manifest และผลการสแกน
- เมื่อได้รับอนุมัติ NeboAI ลงนามแอปด้วย Ed25519 และเผยแพร่
- เมื่อถูกปฏิเสธ คุณจะได้รับเหตุผล และแก้ไขแล้วส่งใหม่ได้
เวลาตรวจสอบเป้าหมาย: <24 ชั่วโมง
การส่งอัปเดต
- อัปเดตเวอร์ชันของแอป:
PUT /api/v1/developer/apps/{id}พร้อมเวอร์ชันใหม่ - อัปโหลดไบนารีใหม่สำหรับแต่ละแพลตฟอร์ม
- ส่งเข้ารับการตรวจสอบอีกครั้ง
ทุกการอัปเดตผ่านกระบวนการตรวจสอบเดียวกัน เวอร์ชันก่อนหน้ายังใช้งานได้จนกว่าเวอร์ชันใหม่จะได้รับอนุมัติ
ข้อมูลเมตาในสโตร์
| ฟิลด์ | คำอธิบาย |
|---|---|
category | เช่น productivity, communication, developer-tools |
icon | URL ไอคอนของแอป |
visibility | public หรือ private |
description | ยาวและละเอียดกว่าคำอธิบายใน manifest ได้ |
เวิร์กโฟลว์การพัฒนา
การพัฒนาในเครื่อง
ไม่ต้องแพ็กเกจสำหรับการพัฒนาในเครื่อง:
- สร้างไดเรกทอรีของแอป:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - เขียน
manifest.jsonและโค้ดของคุณ - บิลด์ไบนารีของคุณ:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo ตรวจพบไดเรกทอรีใหม่โดยอัตโนมัติ (หรือรีสตาร์ต Nebo)
- หลังแก้ไขโค้ด ให้บิลด์ไบนารีใหม่ ตัวเฝ้าดูไฟล์จะรีสตาร์ตแอปให้
การดูบันทึก
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") |
การเขียนทักษะที่ดี
เทมเพลตทักษะที่ดีมี:
- หัวเรื่องที่ชัดเจน บอกพนักงาน AI ว่ากำลังอยู่ในโหมดใด
- หลักการสำคัญ กฎด้านพฤติกรรมที่ต่อรองไม่ได้
- วิธีการ แนวทางทีละขั้นตอนสำหรับสถานการณ์ทั่วไป
- ตัวอย่าง รูปแบบที่เป็นรูปธรรมจากข้อความผู้ใช้ถึงคำตอบ
- รูปแบบที่ควรหลีกเลี่ยง สิ่งที่ไม่ควรทำ (โมเดลเรียนรู้ได้ดีจากตัวอย่างเชิงลบ)
เคล็ดลับ: แต่ละทักษะควรทำสิ่งเดียวให้ดี อย่าสร้างทักษะ "การเขียนโปรแกรมทั่วไป" แต่ให้สร้าง code-review, debugging, api-design แยกเป็นทักษะต่างหาก พนักงาน AI เปิดใช้หลายทักษะพร้อมกันได้
ทักษะที่มาพร้อมระบบ
Nebo มาพร้อมทักษะที่ครอบคลุมกรณีการใช้งานทั่วไป:
| ทักษะ | ลำดับความสำคัญ | คำอธิบาย |
|---|---|---|
onboarding | 100 | ทักทายผู้ใช้ใหม่และเก็บข้อมูลโปรไฟล์ |
best-friend | 50 | ทักษะด้านบุคลิกภาพ เป็นกันเอง ภักดี พูดตรง |
debugging | 25 | วิธีการดีบักอย่างเป็นระบบ |
api-design | 15 | แนวปฏิบัติที่ดีในการออกแบบ RESTful API |
code-review | 10 | การรีวิวโค้ดแบบมีโครงสร้างพร้อมระดับความรุนแรง |
database-expert | 10 | การออกแบบฐานข้อมูล คิวรี และการปรับประสิทธิภาพ |
git-workflow | 10 | การแตกสาขา Git คอมมิต และเวิร์กโฟลว์ PR |
security-audit | 10 | การวิเคราะห์ความปลอดภัยและการตรวจหาช่องโหว่ |
ทักษะเหล่านี้เป็นทั้งค่าเริ่มต้นที่มีประโยชน์และตัวอย่างอ้างอิงสำหรับการสร้างทักษะของคุณเอง
ข้อมูลอ้างอิง
ไฟล์ Proto
ไฟล์ Proto อยู่ใน proto/apps/v0/ SDK มาพร้อมโค้ดที่สร้างไว้ล่วงหน้า คุณจึงไม่ต้องใช้ protoc สำหรับการพัฒนาตามปกติ
| ไฟล์ | บริการ | RPC หลัก |
|---|---|---|
v0/common.proto | (เฉพาะข้อความ) | HealthCheckRequest/Response, SettingsMap, UserContext, Empty |
v0/tool.proto | ToolService | Name, Description, Schema, Execute, RequiresApproval, Configure |
v0/channel.proto | ChannelService | ID, Connect, Disconnect, Send, Receive (stream), Configure |
v0/comm.proto | CommService | Name, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure |
v0/gateway.proto | GatewayService | HealthCheck, Stream (stream), Poll, Cancel, Configure |
v0/ui.proto | UIService | HealthCheck, HandleRequest, Configure |
v0/schedule.proto | ScheduleService | HealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure |
ทุกบริการมี RPC HealthCheck และ Configure SDK จัดการทั้งสองให้โดยอัตโนมัติ
ประเภท Proto ของแชนเนล
| ประเภทข้อความ | คำอธิบาย |
|---|---|
ChannelSendRequest | message envelope ขาออกที่มี message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | ID ข้อความของแพลตฟอร์มสำหรับเธรด |
InboundMessage | message envelope ขาเข้าที่มีฟิลด์ทั่วไปทั้งหมด + timestamp |
MessageSender | ตัวตนของบอท (name, role, botId) เติมข้อมูลโดยตัวกลาง |
Attachment | ไฟล์แนบประเภทไฟล์/รูปภาพ/ออดิโอ (type, url, filename, size) |
MessageAction | action ของปุ่ม/คีย์บอร์ดแบบโต้ตอบ (label, callback_id) |
ตัวตนและบทบาทของบอท
บอทของ Nebo มีโมเดลตัวตนสามมิติ:
- creature บอทคืออะไร (ต้นแบบ): "นักวางกลยุทธ์หัวไว", "นักวิจัยผู้พิถีพิถัน"
- role บอทเกี่ยวข้องกับผู้ใช้อย่างไร (ความสัมพันธ์): "เพื่อน", "COO", "ที่ปรึกษา"
- vibe พลังของบอท (สไตล์การสื่อสาร): "สบาย ๆ แต่มีความเห็นชัดเจน", "อบอุ่นและให้กำลังใจ"
เมื่อปลั๊กอินแชนเนลของคุณได้รับข้อความขาออก ฟิลด์ sender จะมี name และ role ของบอท ใช้ข้อมูลนี้จัดรูปแบบชื่อที่แสดงบนแพลตฟอร์มของคุณ role ไม่ใช่ตำแหน่งงาน แต่เป็นคำบอกความสัมพันธ์ "เพื่อน", "ลูกชาย" และ "ที่ปรึกษา" เป็น role ที่ใช้ได้เช่นเดียวกับ "COO" และ "DevLead"