ទិដ្ឋភាពទូទៅ
តើ Nebo ជាអ្វី
Nebo គឺជាជំនួយការ AI ផ្ទាល់ខ្លួននៅលើកុំព្យូទ័រ — ជាបុគ្គលិក AI ដែលដំណើរការជានិច្ច ដែលគ្រប់គ្រងជីវិតឌីជីថលរបស់អ្នក។ សូមគិតអំពី Nebo ដូចដែលអ្នកគិតអំពីស្មាតហ្វូន៖ វេទិកាដ៏មានឥទ្ធិពលមួយ ដែលក្លាយជាការផ្លាស់ប្ដូរដ៏ធំតាមរយៈកម្មវិធីរបស់វា។
ដោយខ្លួនវាផ្ទាល់ Nebo គឺជាបុគ្គលិក AI ដែលមានសមត្ថភាព ជាមួយការចងចាំ ការកំណត់កាលវិភាគ ការរុករកគេហទំព័រ ការគ្រប់គ្រងឯកសារ និងសិទ្ធិចូលប្រើ shell។ ប៉ុន្តែអ្វីដែលដោះសោសក្ដានុពលពិតប្រាកដ គឺកម្មវិធី។ ដូចដែលអំណាចរបស់ស្មាតហ្វូនមកពីប្រព័ន្ធអេកូកម្មវិធីរបស់វា អំណាចរបស់ Nebo មកពីកម្មវិធីដែលពង្រីកអ្វីដែលវាអាចធ្វើបាន។
តើកម្មវិធីជាអ្វី
កម្មវិធី Nebo គឺជាឯកតាដែលមានមុខងារដ៏អស្ចារ្យ ដាច់ដោយឡែក និងបាន compile ជាមុន។ កម្មវិធីនីមួយៗផ្ដល់មហាអំណាចថ្មីដល់ Nebo — ការគ្រប់គ្រងប្រតិទិន ការចាត់ថ្នាក់អ៊ីមែល ការតាមដានគម្រោង ស្វ័យប្រវត្តិកម្មផ្ទះ ការវិភាគហិរញ្ញវត្ថុ — អ្វីក៏ដោយដែលអ្នកអភិវឌ្ឍន៍អាចស្រមៃបាន។
កម្មវិធីផ្ដល់អំណាចដ៏អស្ចារ្យ តាមរបៀបដែលមានសុវត្ថិភាពខ្ពស់។ កម្មវិធីនីមួយៗដំណើរការក្នុង sandbox ដែលមានការអនុញ្ញាតបដិសេធតាមលំនាំដើម។ វាអាចចូលប្រើបានតែអ្វីដែល manifest របស់វាប្រកាស និងអ្នកប្រើយល់ព្រមប៉ុណ្ណោះ។
ចំណុចប្រទាក់គឺជាការសន្ទនា 100%។ អ្នកប្រើមិនធ្វើអន្តរកម្មជាមួយកម្មវិធីតាមរយៈអេក្រង់ ឬផ្ទាំងគ្រប់គ្រងដាច់ដោយឡែកទេ។ ពួកគេនិយាយជាមួយ Nebo ហើយ Nebo ប្រើឧបករណ៍របស់កម្មវិធីដើម្បីបំពេញការងារ។ "តើថ្ងៃស្អែកមានអ្វីនៅក្នុងប្រតិទិនរបស់ខ្ញុំ?" — Nebo ហៅកម្មវិធីប្រតិទិន។ "បង្កើតការប្រជុំជាមួយ Sarah នៅម៉ោង 3 រសៀល" — Nebo ហៅកម្មវិធីប្រតិទិន។ អ្នកប្រើមិនដែលចាកចេញពីការសន្ទនាទេ។
កម្មវិធីអាចផ្ដល់ជាជម្រើសនូវ UI ការកំណត់ — ផ្ទាំងកំណត់រចនាសម្ព័ន្ធមួយ ដែលបើកនៅក្នុងបង្អួចកម្មវិធីរុករកដែលមានស្រាប់របស់ Nebo។ នេះជាកន្លែងដែលអ្នកប្រើបញ្ចូលសោ API បើកបិទមុខងារ និងកំណត់រចនាសម្ព័ន្ធកម្មវិធី។ UI ការកំណត់ត្រូវបានគ្រប់គ្រងដោយអារេ settings នៅក្នុង manifest (Nebo បង្ហាញទម្រង់ដោយស្វ័យប្រវត្តិ) ឬកម្មវិធីអាចផ្ដល់ UI តាមបំណងពេញលេញផ្ទាល់ខ្លួនតាមរយៈសមត្ថភាព ui។
កម្មវិធីជំនួស និងពង្រីកសមត្ថភាពដែលមានស្រាប់របស់ Nebo។ Nebo មកជាមួយឧបករណ៍វេទិកាមូលដ្ឋាន (ការចូលប្រើប្រតិទិនក្នុងម៉ាស៊ីន រូបថតអេក្រង់ ។ល។)។ នៅពេលអ្នកដំឡើងកម្មវិធីប្រតិទិន វាជំនួសឧបករណ៍ប្រតិទិនដែលមានស្រាប់ ហើយក្លាយជាសំណុំធំជាង — ក្នុងម៉ាស៊ីន + ពពក + ការប្រមូលផ្ដុំ + ការពិនិត្យពេលទំនេរ។
គោលការណ៍តែ Compile ប៉ុណ្ណោះ
Nebo អនុវត្តគោលការណ៍យ៉ាងតឹងរ៉ឹងថា ឯកសារប្រព័ន្ធគោលពីរត្រូវតែ compile ប៉ុណ្ណោះ។ កម្មវិធីទាំងអស់ត្រូវតែជាកម្មវិធីប្រតិបត្តិដើមដែលបាន compile។
| ស្ថានភាព | ភាសា |
|---|---|
| គាំទ្រ | Go (ណែនាំ), Rust, C/C++, Zig |
| បដិសេធ | Python, Node.js, Ruby, Java, .NET, shell scripts |
ហេតុផល៖
- ការការពារ AI មិនឱ្យកែប្រែខ្លួនឯង — បុគ្គលិក AI ដែលមានសិទ្ធិចូលប្រើ shell អាចកែប្រែឥរិយាបថរបស់ script ដែលបកប្រែពេលដំណើរការ។ ឯកសារប្រព័ន្ធគោលពីរដែលបាន compile មិនអាចផ្លាស់ប្ដូរបានទេបន្ទាប់ពីចុះហត្ថលេខា។
- ភាពត្រឹមត្រូវនៃហត្ថលេខា — ហត្ថលេខា Ed25519 គ្របដណ្ដប់លើបៃដើមនៃឯកសារប្រព័ន្ធគោលពីរ។ ឯកសារប្រព័ន្ធគោលពីរដែលបានចុះហត្ថលេខា មិនអាចកែប្រែបានដោយមិនធ្វើឱ្យហត្ថលេខាអសុពលភាពនោះទេ។
- ការអនុវត្ត sandbox — ការផ្ទៀងផ្ទាត់ទម្រង់ឯកសារប្រព័ន្ធគោលពីរ (magic bytes ELF/Mach-O/PE) គឺជាច្រកត្រួតពិនិត្យដែលលឿន និងអាចទុកចិត្តបាន។
ការចាប់ផ្ដើមរហ័ស
ដំឡើង SDK
SDK ផ្លូវការដោះស្រាយការរៀបចំម៉ាស៊ីនមេ gRPC ទាំងអស់ ការគ្រប់គ្រងសញ្ញា និងការភ្ជាប់ពិធីការ។ អ្នកគ្រាន់តែអនុវត្ត handler interfaces ប៉ុណ្ណោះ។
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) - អនុវត្ត handler interface សម្រាប់សមត្ថភាពរបស់អ្នក (
ToolHandler,ChannelHandler។ល។) - ចុះឈ្មោះ handler ហើយហៅ
app.Run() - Build ឯកសារប្រព័ន្ធគោលពីរដើម (
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 proxy |
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 | ការប្រតិបត្តិពាក្យបញ្ជា shell |
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 | ប្រតិបត្តិការ sub-agent |
lane: | lane:enqueue | ប្រតិបត្តិការ lane |
notification: | notification:send | ការជូនដំណឹងរុញ |
embedding: | embedding:search | សិទ្ធិចូលប្រើ vector embedding |
skill: | skill:invoke | ការហៅជំនាញ |
advisor: | advisor:consult | សិទ្ធិចូលប្រើប្រព័ន្ធទីប្រឹក្សា |
mcp: | mcp:connect | សិទ្ធិចូលប្រើម៉ាស៊ីនមេ MCP |
voice: | voice:record | សិទ្ធិចូលប្រើសំឡេង/អូឌីយ៉ូ |
browser: | browser:navigate | ស្វ័យប្រវត្តិកម្មកម្មវិធីរុករក |
oauth: | oauth:google, oauth:* | សិទ្ធិចូលប្រើ token OAuth |
settings: | settings:read | សិទ្ធិចូលប្រើការកំណត់ |
capability: | capability:register | ការចុះឈ្មោះសមត្ថភាព |
ការអនុញ្ញាតជាតួអក្សរជំនួស (wildcard) ត្រូវបានគាំទ្រ៖ network:* ត្រូវនឹងការពិនិត្យការអនុញ្ញាត network: ណាមួយ។
ការកំណត់
ការកំណត់បង្ហាញនៅក្នុង UI របស់ Nebo ក្រោមផ្ទាំងការកំណត់របស់កម្មវិធី។ Nebo រក្សាទុកពួកវានៅក្នុងមូលដ្ឋានទិន្នន័យ ហើយផ្ញើពួកវាទៅកម្មវិធីរបស់អ្នកតាមរយៈ RPC Configure នៅពេលពួកវាផ្លាស់ប្ដូរ។
schema ការកំណត់របស់អ្នកត្រូវបានរួមបញ្ចូលក្នុងបញ្ជីហាងកម្មវិធី NeboAI។ កម្មវិធីដែលមានការកំណត់ចាំបាច់ដែលមិនទាន់កំណត់រចនាសម្ព័ន្ធ បង្ហាញស្លាក "ត្រូវការការរៀបចំ" នៅក្នុង UI។
| ប្រភេទ | ការពិពណ៌នា |
|---|---|
text | ការបញ្ចូលអក្សរមួយបន្ទាត់ |
password | ការបញ្ចូលអក្សរដែលលាក់ |
toggle | កុងតាក់បើក/បិទ Boolean |
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 broker របស់ Nebo ដោះស្រាយលំហូរទាំងមូល — កម្មវិធីទទួលបាន token ដោយស្វ័យប្រវត្តិតាមរយៈ RPC Configure។
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | វាល | ការពិពណ៌នា |
|---|---|
provider | អ្នកផ្ដល់ OAuth៖ "google", "microsoft", "github" |
scopes | អារេនៃ OAuth scopes ដែលកម្មវិធីត្រូវការ |
នៅពេលអ្នកប្រើដំឡើងកម្មវិធី Nebo សុំឱ្យពួកគេផ្ដល់សិទ្ធិលើ OAuth scopes ដែលត្រូវការ។ កម្មវិធីទទួលបាន token ដែលបានធ្វើឱ្យស្រស់តាមរយៈ RPC Configure ដោយមិនចាំបាច់ដោះស្រាយលំហូរ OAuth ដោយខ្លួនឯង។
អថេរបរិស្ថាន
ដំណើរការកម្មវិធីរបស់អ្នកទទួលបានបរិស្ថានដែលបានសម្អាត។ អាថ៌កំបាំងទាំងអស់ត្រូវបានដកចេញ។ អ្នកទទួលបាន៖
| អថេរ | តម្លៃ |
|---|---|
NEBO_APP_DIR | ថតដំឡើងរបស់កម្មវិធី |
NEBO_APP_SOCK | ផ្លូវទៅកាន់ Unix socket ដែលត្រូវបង្កើត |
NEBO_APP_ID | App 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 រង់ចាំរហូតដល់ 10 វិនាទី ដើម្បីឱ្យ socket នេះលេចឡើង។
លំដាប់ការចាប់ផ្ដើមកម្មវិធី
- Nebo អាន
manifest.jsonហើយផ្ទៀងផ្ទាត់វា - ស្វែងរកកម្មវិធីប្រតិបត្តិ
binaryឬappនៅក្នុងថតកម្មវិធី - ពិនិត្យរកសញ្ញាសម្គាល់
.quarantined(បដិសេធមិនចាប់ផ្ដើមកម្មវិធីដែលត្រូវបានដាក់ឱ្យនៅដាច់ដោយឡែក) - ការពិនិត្យការដកហូត (សម្រាប់តែកម្មវិធីដែលចែកចាយដោយ NeboAI ប៉ុណ្ណោះ)
- ការផ្ទៀងផ្ទាត់ហត្ថលេខា (សម្រាប់តែកម្មវិធីដែលចែកចាយដោយ NeboAI ប៉ុណ្ណោះ រំលងក្នុងរបៀប dev)
- ការផ្ទៀងផ្ទាត់ឯកសារប្រព័ន្ធគោលពីរ (បដិសេធ symlinks, scripts, ឯកសារដែលមិនអាចប្រតិបត្តិបាន ឯកសារធំពេក)
- សម្អាត socket ចាស់ពីការដំណើរការមុន
- បង្កើតថត
data/សម្រាប់ទំហំផ្ទុកក្នុង sandbox - រៀបចំឯកសារកំណត់ហេតុសម្រាប់កម្មវិធីនីមួយៗ (
logs/stdout.log,logs/stderr.log) - ចាប់ផ្ដើមឯកសារប្រព័ន្ធគោលពីរជាមួយបរិស្ថានដែលបានសម្អាត និងការញែកក្រុមដំណើរការ
- រង់ចាំឱ្យ Unix socket លេចឡើង (exponential backoff អតិបរមា 10 វិនាទី)
- តភ្ជាប់តាមរយៈ gRPC លើ Unix socket
- បង្កើត gRPC clients ជាក់លាក់តាមសមត្ថភាព ដោយផ្អែកលើ
provides - ដំណើរការការពិនិត្យសុខភាព
- ចុះឈ្មោះសមត្ថភាពជាមួយបុគ្គលិក AI (ឧបករណ៍ gateway comm ។ល។)
កម្មវិធីឧបករណ៍
ប្រកាស "provides": ["tool:my_tool_name"] នៅក្នុង manifest របស់អ្នក។
លំនាំ STRAP
កម្មវិធីឧបករណ៍ Nebo ទាំងអស់ ត្រូវតែ ប្រើ STRAP (Single Tool Resource Action Pattern) សម្រាប់ schema និងការបញ្ជូនការប្រតិបត្តិរបស់ពួកវា។ នេះគឺជាលំនាំដដែលដែល 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") ច្បាប់ schema៖
- ត្រូវរួមបញ្ចូលវាល
actionជានិច្ច ជា string enum ដែលត្រូវការ - បន្ថែមវាល
resource(string enum ដែលត្រូវការ) លុះត្រាតែឧបករណ៍របស់អ្នកគ្រប់គ្រងប្រភេទធនធានខុសៗគ្នាច្រើន - វាលផ្សេងទៀតទាំងអស់ គឺជាប៉ារ៉ាម៉ែត្រជាក់លាក់តាមសកម្មភាព
- ការពិពណ៌នា enum
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": []
} Build និងដំឡើង៖
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()— កម្មវិធីរបស់អ្នកផ្ញើសារចូល រាល់ពេលដែលអ្នកប្រើផ្ញើសារទៅបូត - សារចូលត្រូវបានបញ្ជូនទៅកាន់ lane ការសន្ទនាចម្បងរបស់បុគ្គលិក AI
- នៅពេលបុគ្គលិក AI ចង់ផ្ញើសារ Nebo ហៅ
Send()ជាមួយស្រោមសារ v1 - នៅពេលបិទ Nebo ហៅ
Disconnect()
ស្រោមសារ v1
សារឆានែលទាំងអស់ — ចូល និងចេញ — ប្រើស្រោមសាររួម៖
{
"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 — Plugin របស់អ្នកផ្គូផ្គងពួកវាទៅ/ពីទម្រង់ដើមរបស់វេទិកា។
ស្ទ្រីមការសន្ទនា
សារឆានែលត្រូវបានបញ្ជូនតាមស្ទ្រីមការសន្ទនាដាច់ដោយឡែកសម្រាប់ឆានែលនីមួយៗ ដើម្បីភាពដាច់ដោយឡែក៖
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 តែមួយប៉ុណ្ណោះដែលសកម្មក្នុងពេលតែមួយ
កម្មវិធី Gateway
កម្មវិធី gateway បញ្ជូនសំណើ LLM ទៅកាន់ម៉ូដែល។ ប្រកាស "provides": ["gateway"] និង "permissions": ["network:outbound", "user:token"]។
GatewayRequest មានសារ ឧបករណ៍ system prompt ចំនួន token អតិបរមា temperature និង UserContext (token JWT ប្រសិនបើការអនុញ្ញាត user:token ត្រូវបានផ្ដល់)។
ប្រភេទ GatewayEvent៖
| ប្រភេទ | ខ្លឹមសារ | ការពិពណ៌នា |
|---|---|---|
"text" | ផ្នែកអក្សរ | token អក្សរដែលកំពុងស្ទ្រីម |
"tool_call" | JSON | ម៉ូដែលចង់ហៅឧបករណ៍ |
"thinking" | ផ្នែកអក្សរ | ការគិត/ការវែកញែកបន្ថែម |
"error" | សារកំហុស | មានអ្វីមួយខុសប្រក្រតី |
"done" | ទទេ | ស្ទ្រីមបានបញ្ចប់ |
កម្មវិធី UI
កម្មវិធី UI ផ្ដល់ចំណុចប្រទាក់កំណត់រចនាសម្ព័ន្ធតាមបំណង ដែលបើកនៅក្នុងបង្អួចកម្មវិធីរុករកដែលមានស្រាប់របស់ Nebo។ ប្រកាស "provides": ["ui"]។ ខុសពីទម្រង់ការកំណត់ស្វ័យប្រវត្តិ (ដែល Nebo បង្ហាញពី manifest settings របស់អ្នក) កម្មវិធី UI ផ្ដល់ frontend HTML/CSS/JS ពេញលេញផ្ទាល់ខ្លួន។
កម្មវិធីរបស់អ្នកមកជាមួយថត ui/ ដែលមានធនធានគេហទំព័រឋិតិវន្ត (HTML, CSS, JS — ជាធម្មតាជា SPA ជាមួយ index.html)។ Nebo ផ្ដល់ឯកសារទាំងនេះដោយផ្ទាល់ ហើយបញ្ជូនបន្តការហៅ API ទៅកម្មវិធីរបស់អ្នកតាមរយៈ gRPC។
| ផ្លូវ | យន្តការ | គោលបំណង |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | ម៉ាស៊ីនមេឯកសារឋិតិវន្ត | ផ្ដល់ឯកសារពីថត ui/ របស់អ្នក (SPA ត្រឡប់ទៅ index.html) |
ANY /api/v1/apps/{id}/api/* | gRPC proxy | បញ្ជូនបន្តសំណើ HTTP ទៅ UIService.HandleRequest() របស់កម្មវិធីអ្នក |
SDK រុំ net/http.ServeMux ស្ដង់ដារ ដូច្នេះអ្នកសរសេរ Go HTTP handlers ធម្មតា — 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 មិនរក្សាទុកកាលវិភាគក្នុង DB ផ្ទាល់ខ្លួនទេ នៅពេលកម្មវិធីកាលវិភាគសកម្ម
- 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 |
ច្បាប់សុវត្ថិភាពពេលពន្លា៖
- គ្មានការឆ្លងផ្លូវ (
../ត្រូវបានបដិសេធ) - គ្មាន symlinks (ត្រូវបានបដិសេធ)
- គ្មានផ្លូវដាច់ខាត (ត្រូវបានបដិសេធ)
- ទទួលយកតែឈ្មោះឯកសារដែលមាននៅក្នុងបញ្ជីអនុញ្ញាតប៉ុណ្ណោះ
ហត្ថលេខា
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>"
} ក្នុងរបៀប dev (មិនបានកំណត់ URL NeboAI) ការផ្ទៀងផ្ទាត់ហត្ថលេខាត្រូវបានរំលងទាំងស្រុង។ អ្នកមិនត្រូវការ signatures.json សម្រាប់ការអភិវឌ្ឍក្នុងម៉ាស៊ីនទេ។
ការបោះផ្សាយ
នៅពេលកម្មវិធីរបស់អ្នកដំណើរការក្នុងម៉ាស៊ីនរួច សូមបោះផ្សាយវាតាមរយៈ NeboAI ដើម្បីចែកចាយដល់អ្នកប្រើ Nebo ទាំងអស់។
ការរៀបចំគណនីអ្នកអភិវឌ្ឍន៍
- ចុះឈ្មោះគណនី NeboAI នៅ
POST /api/v1/owners/register - ចូលដើម្បីទទួលបាន token 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 ឡើងវិញ)
- បន្ទាប់ពីផ្លាស់ប្ដូរកូដ សូម build ឯកសារប្រព័ន្ធគោលពីរឡើងវិញ — កម្មវិធីតាមដានឯកសារនឹងចាប់ផ្ដើមកម្មវិធីឡើងវិញ
ការមើលកំណត់ហេតុ
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។ គ្មានការ compile គ្មានឯកសារប្រព័ន្ធគោលពីរ គ្មាន gRPC។ ជំនាញមួយគឺជាឯកសារ SKILL.md នៅក្នុងថតមួយ។ គ្រាន់តែប៉ុណ្ណឹង។
ជំនាញអាស្រ័យលើបរិបទ និងជាបណ្ដោះអាសន្ន។ វាសកម្មនៅពេលពាក់ព័ន្ធ (តាមរយៈការផ្គូផ្គងកត្តាចាប់ផ្ដើម ឬការផ្ទុកដោយដៃ) នៅបន្តពីរបីវេន ហើយផុតកំណត់នៅពេលលែងត្រូវការ។ នេះរក្សាបរិបទរបស់បុគ្គលិក AI ឱ្យស្ដើង — មានតែការណែនាំដែលសំខាន់នៅពេលនេះប៉ុណ្ណោះនៅក្នុង prompt។
ជំនាញបំពេញបន្ថែមលើកម្មវិធី។ កម្មវិធីផ្ដល់សមត្ថភាពដែលអាចប្រតិបត្តិបាន (ឧបករណ៍ ឆានែល gateway)។ ជំនាញផ្ដល់ការណែនាំពីការរៀបចំ — របៀបប្រើឧបករណ៍ទាំងនោះឱ្យមានប្រសិទ្ធភាព។ កម្មវិធីប្រតិទិនផ្ដល់ឱ្យ Nebo នូវសមត្ថភាពអាន និងសរសេរព្រឹត្តិការណ៍។ ជំនាញ "រៀបចំការប្រជុំ" ប្រាប់ Nebo ពីរបៀបរៀបចំសម្រាប់ការប្រជុំ ដោយប្រើកម្មវិធីប្រតិទិននោះ អ៊ីមែល និងការស្វែងរកលើគេហទំព័ររួមគ្នា។
ជំនាញ ធៀបនឹង កម្មវិធី
| ជំនាញ | កម្មវិធី | |
|---|---|---|
| ទម្រង់ | Markdown (SKILL.md) | ឯកសារប្រព័ន្ធគោលពីរដែលបាន compile (.napp) |
| ពេលដំណើរការ | បញ្ចូលទៅក្នុង system prompt | ដំណើរការក្នុង sandbox តាមរយៈ gRPC |
| ផ្ដល់ | ការណែនាំឥរិយាបថ វិធីសាស្ត្រ | ឧបករណ៍ ឆានែល ផ្ទាំង UI |
| អាយុកាល | កំណត់តាមវគ្គ ផុតកំណត់តាម TTL | ដំណើរការជានិច្ច |
| ការបង្កើត | សរសេរឯកសារ markdown | សរសេរ compile ចុះហត្ថលេខា វេចខ្ចប់ |
| សុវត្ថិភាព | មិនត្រូវការការអនុញ្ញាត | Sandbox បដិសេធតាមលំនាំដើម |
ការចាប់ផ្ដើមរហ័ស
បង្កើតថតមួយនៅក្នុងថតជំនាញ 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 ក្នុងមួយវគ្គ
- ថវិកា token៖ ខ្លឹមសារជំនាញសកម្មរួមបញ្ចូលគ្នា មានកម្រិតត្រឹម 16,000 តួអក្សរ
ការគ្រប់គ្រងជំនាញ
បុគ្គលិក AI អាចគ្រប់គ្រងជំនាញតាមរយៈឧបករណ៍ skill៖
| សកម្មភាព | ការពិពណ៌នា | ឧទាហរណ៍ |
|---|---|---|
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 | ការរចនាមូលដ្ឋានទិន្នន័យ queries ការធ្វើឱ្យប្រសើរ |
git-workflow | 10 | Git branching, commits, លំហូរការងារ 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_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | ID សាររបស់វេទិកាសម្រាប់ការដាក់ជាខ្សែស្រឡាយ |
InboundMessage | ស្រោមសារចូល ជាមួយវាលរួមទាំងអស់ + timestamp |
MessageSender | អត្តសញ្ញាណបូត (name, role, botId) — បំពេញបន្ថែមដោយ broker |
Attachment | ឯកសារភ្ជាប់ ឯកសារ/រូបភាព/អូឌីយ៉ូ (type, url, filename, size) |
MessageAction | សកម្មភាពប៊ូតុង/ក្ដារចុចអន្តរកម្ម (label, callback_id) |
អត្តសញ្ញាណ និងតួនាទីបូត
បូត Nebo មានគំរូអត្តសញ្ញាណបីអ័ក្ស៖
- creature — អ្វីដែលបូតជា (គំរូដើម)៖ "អ្នកយុទ្ធសាស្ត្រដែលឆ្លាតវៃរហ័ស" "អ្នកស្រាវជ្រាវដែលហ្មត់ចត់"
- role — របៀបដែលវាទាក់ទងនឹងអ្នកប្រើ (ទំនាក់ទំនង)៖ "មិត្ត" "COO" "អ្នកណែនាំ"
- vibe — ថាមពលរបស់វា (រចនាប័ទ្មទំនាក់ទំនង)៖ "ស្ងប់ស្ងាត់ ប៉ុន្តែមានមតិផ្ទាល់ខ្លួន" "កក់ក្ដៅ និងលើកទឹកចិត្ត"
នៅពេល Plugin ឆានែលរបស់អ្នកទទួលបានសារចេញ វាល sender មាន name និង role របស់បូត។ ប្រើវាដើម្បីធ្វើទ្រង់ទ្រាយឈ្មោះបង្ហាញសម្រាប់វេទិការបស់អ្នក។ តួនាទីមិនមែនជាមុខតំណែងការងារទេ — វាជាការពិពណ៌នាទំនាក់ទំនង។ "មិត្ត" "កូនប្រុស" និង "អ្នកណែនាំ" គឺជាតួនាទីត្រឹមត្រូវ រួមជាមួយ "COO" និង "DevLead"។