NeboAI
NeboAI
ចាប់ផ្ដើម

បង្កើតកម្មវិធីសម្រាប់ Nebo

ផ្ដល់មហាអំណាចថ្មីដល់ AI របស់អ្នក។ ឧបករណ៍ ឆានែល gateway ផ្ទាំង UI — អ្វីក៏ដោយដែលអ្នកអាចស្រមៃបាន ដែលបាន compile ទៅជាឯកសារប្រព័ន្ធគោលពីរដើម។

ទិដ្ឋភាពទូទៅ

តើ 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)

បញ្ជីត្រួតពិនិត្យកម្មវិធីអប្បបរមា

  1. បង្កើត manifest.json ជាមួយ id, name, version, provides
  2. សរសេរ TOOL.md ដែលពិពណ៌នាពីរបៀបដែលបុគ្គលិក AI គួរប្រើឧបករណ៍របស់អ្នក
  3. ដំឡើង SDK (go get github.com/neboloop/nebo-sdk-go)
  4. អនុវត្ត handler interface សម្រាប់សមត្ថភាពរបស់អ្នក (ToolHandler, ChannelHandler ។ល។)
  5. ចុះឈ្មោះ handler ហើយហៅ app.Run()
  6. Build ឯកសារប្រព័ន្ធគោលពីរដើម (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 proxy
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ការប្រតិបត្តិពាក្យបញ្ជា 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_IDApp ID ពី manifest
NEBO_APP_NAMEឈ្មោះកម្មវិធីពី manifest
NEBO_APP_VERSIONកំណែកម្មវិធីពី manifest
NEBO_APP_DATAផ្លូវទៅកាន់ថត data/ របស់កម្មវិធី
PATHPATH របស់ប្រព័ន្ធ (បញ្ជូនបន្តដដែល)
HOMEថតផ្ទះរបស់អ្នកប្រើ (បញ្ជូនបន្តដដែល)
TMPDIRថតបណ្ដោះអាសន្ន (បញ្ជូនបន្តដដែល)

សំខាន់បំផុត៖ ឯកសារប្រព័ន្ធគោលពីររបស់អ្នកត្រូវតែបង្កើតម៉ាស៊ីនមេ gRPC ដែលស្ដាប់នៅលើ Unix socket នៅ NEBO_APP_SOCK។ Nebo រង់ចាំរហូតដល់ 10 វិនាទី ដើម្បីឱ្យ socket នេះលេចឡើង។

លំដាប់ការចាប់ផ្ដើមកម្មវិធី

  1. Nebo អាន manifest.json ហើយផ្ទៀងផ្ទាត់វា
  2. ស្វែងរកកម្មវិធីប្រតិបត្តិ binary ឬ app នៅក្នុងថតកម្មវិធី
  3. ពិនិត្យរកសញ្ញាសម្គាល់ .quarantined (បដិសេធមិនចាប់ផ្ដើមកម្មវិធីដែលត្រូវបានដាក់ឱ្យនៅដាច់ដោយឡែក)
  4. ការពិនិត្យការដកហូត (សម្រាប់តែកម្មវិធីដែលចែកចាយដោយ NeboAI ប៉ុណ្ណោះ)
  5. ការផ្ទៀងផ្ទាត់ហត្ថលេខា (សម្រាប់តែកម្មវិធីដែលចែកចាយដោយ NeboAI ប៉ុណ្ណោះ រំលងក្នុងរបៀប dev)
  6. ការផ្ទៀងផ្ទាត់ឯកសារប្រព័ន្ធគោលពីរ (បដិសេធ symlinks, scripts, ឯកសារដែលមិនអាចប្រតិបត្តិបាន ឯកសារធំពេក)
  7. សម្អាត socket ចាស់ពីការដំណើរការមុន
  8. បង្កើតថត data/ សម្រាប់ទំហំផ្ទុកក្នុង sandbox
  9. រៀបចំឯកសារកំណត់ហេតុសម្រាប់កម្មវិធីនីមួយៗ (logs/stdout.log, logs/stderr.log)
  10. ចាប់ផ្ដើមឯកសារប្រព័ន្ធគោលពីរជាមួយបរិស្ថានដែលបានសម្អាត និងការញែកក្រុមដំណើរការ
  11. រង់ចាំឱ្យ Unix socket លេចឡើង (exponential backoff អតិបរមា 10 វិនាទី)
  12. តភ្ជាប់តាមរយៈ gRPC លើ Unix socket
  13. បង្កើត gRPC clients ជាក់លាក់តាមសមត្ថភាព ដោយផ្អែកលើ provides
  14. ដំណើរការការពិនិត្យសុខភាព
  15. ចុះឈ្មោះសមត្ថភាពជាមួយបុគ្គលិក 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៖

  1. ត្រូវរួមបញ្ចូលវាល action ជានិច្ច ជា string enum ដែលត្រូវការ
  2. បន្ថែមវាល resource (string enum ដែលត្រូវការ) លុះត្រាតែឧបករណ៍របស់អ្នកគ្រប់គ្រងប្រភេទធនធានខុសៗគ្នាច្រើន
  3. វាលផ្សេងទៀតទាំងអស់ គឺជាប៉ារ៉ាម៉ែត្រជាក់លាក់តាមសកម្មភាព
  4. ការពិពណ៌នា 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 របស់កម្មវិធីអ្នក។

របៀបដែលវាដំណើរការ

  1. Nebo ហៅ ID() ដើម្បីទទួលបានឧបករណ៍សម្គាល់តែមួយគត់នៃឆានែលរបស់អ្នក
  2. Nebo ហៅ Connect() ជាមួយការកំណត់រចនាសម្ព័ន្ធពីការកំណត់របស់កម្មវិធីអ្នក
  3. Nebo បើកស្ទ្រីម Receive() — កម្មវិធីរបស់អ្នកផ្ញើសារចូល រាល់ពេលដែលអ្នកប្រើផ្ញើសារទៅបូត
  4. សារចូលត្រូវបានបញ្ជូនទៅកាន់ lane ការសន្ទនាចម្បងរបស់បុគ្គលិក AI
  5. នៅពេលបុគ្គលិក AI ចង់ផ្ញើសារ Nebo ហៅ Send() ជាមួយស្រោមសារ v1
  6. នៅពេលបិទ 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_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 — 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។

វាលការពិពណ៌នា
fromID បុគ្គលិកអ្នកផ្ញើ
toID បុគ្គលិកអ្នកទទួល
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.json1 MBទិន្នន័យមេតារបស់កម្មវិធី
binary ឬ app500 MBកម្មវិធីប្រតិបត្តិ
signatures.json1 MBហត្ថលេខា Ed25519
TOOL.md1 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 ទាំងអស់។

ការរៀបចំគណនីអ្នកអភិវឌ្ឍន៍

  1. ចុះឈ្មោះគណនី NeboAI នៅ POST /api/v1/owners/register
  2. ចូលដើម្បីទទួលបាន token 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. បន្ទាប់ពីផ្លាស់ប្ដូរកូដ សូម 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")

ការសរសេរជំនាញល្អ

គំរូជំនាញល្អមាន៖

  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ការរចនាមូលដ្ឋានទិន្នន័យ queries ការធ្វើឱ្យប្រសើរ
git-workflow10Git branching, commits, លំហូរការងារ 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 របស់ឆានែល

ប្រភេទសារការពិពណ៌នា
ChannelSendRequestស្រោមសារចេញ ជាមួយ message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponseID សាររបស់វេទិកាសម្រាប់ការដាក់ជាខ្សែស្រឡាយ
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"។