Àkópọ̀
Kí Ni Nebo Jẹ́
Nebo jẹ́ olùrànlọ́wọ́ AI ti ara ẹni lórí kọ̀ǹpútà — òṣìṣẹ́ AI tí ń ṣiṣẹ́ nígbà gbogbo tí ó ń ṣàkóso ìgbésí ayé oní-nọ́ńbà rẹ. Ronú nípa Nebo bí o ṣe ń ronú nípa fóònù alágbèéká: pẹpẹ alágbára tí ó ń di ohun ìyípadà ńlá nípasẹ̀ àwọn áàpù rẹ̀.
Fúnra rẹ̀, Nebo jẹ́ òṣìṣẹ́ AI tí ó mọṣẹ́ pẹ̀lú ìrántí, ìṣètò àkókò, lílọ kiri wẹ́ẹ̀bù, ìṣàkóso fáìlì, àti ààyè sí shell. Ṣùgbọ́n kọ́kọ́rọ́ gidi ni Àwọn áàpù. Gẹ́gẹ́ bí agbára fóònù alágbèéká ṣe ń wá láti inú àyíká áàpù rẹ̀, agbára Nebo ń wá láti inú àwọn áàpù tí ó ń fẹ ohun tí ó lè ṣe lójú.
Kí Ni Àwọn Áàpù Jẹ́
Àwọn áàpù Nebo jẹ́ ẹ̀ka tí ó dá dúró, tí a ti ṣàkójọ tẹ́lẹ̀, tí ó ní iṣẹ́ àrà ọ̀tọ̀. Áàpù kọ̀ọ̀kan ń fún Nebo ní agbára àrà tuntun — ìṣàkóso kàlẹ́ńdà, ìṣètò ímeèlì, títọpa iṣẹ́ àkànṣe, ìṣiṣẹ́ ilé aládàáṣe, àtúpalẹ̀ ìṣúná — ohunkóhun tí olùgbéejáde lè ronú kàn.
Àwọn áàpù ń pèsè agbára àrà ní ọ̀nà tí ó ní ààbò gidigidi. Gbogbo áàpù ń ṣiṣẹ́ nínú sandbox pẹ̀lú àwọn àṣẹ tí a kọ̀ ní ìpìlẹ̀. Ó lè dé ohun tí manifest rẹ̀ kéde tí olùlò sì fọwọ́ sí nìkan.
Ìbáṣepọ̀ náà jẹ́ ìjíròrò ní 100%. Àwọn olùlò kì í lo àwọn áàpù nípasẹ̀ ojú-ìwé tàbí dashboard ọ̀tọ̀. Wọ́n ń bá Nebo sọ̀rọ̀, Nebo sì ń lo àwọn irinṣẹ́ áàpù náà láti ṣe iṣẹ́. "Kí ló wà lórí kàlẹ́ńdà mi lọ́la?" — Nebo pe áàpù kàlẹ́ńdà. "Ṣẹ̀dá ìpàdé pẹ̀lú Sarah ní 3pm" — Nebo pe áàpù kàlẹ́ńdà. Olùlò kì í kúrò nínú ìjíròrò rárá.
Àwọn áàpù lè pèsè UI ètò bí wọ́n bá fẹ́ — pánẹ́ẹ̀lì ìṣètò tí ó ń ṣí nínú fèrèsé aṣàwákiri tí a kọ́ sínú Nebo. Ibẹ̀ ni àwọn olùlò ti ń tẹ àwọn kọ́kọ́rọ́ API, tan tàbí pa àwọn ẹ̀yà, tí wọ́n sì ń ṣètò áàpù náà. Àkójọ settings nínú manifest ló ń darí UI ètò náà (Nebo ń ṣe fọ́ọ̀mù náà fúnra rẹ̀), tàbí kí áàpù náà pèsè UI àdáni tirẹ̀ ní kíkún nípasẹ̀ agbára ui.
Àwọn áàpù ń rọ́pò àwọn agbára tí a kọ́ sínú Nebo, wọ́n sì ń fẹ̀ wọ́n lójú. Nebo ń jáde pẹ̀lú àwọn irinṣẹ́ pẹpẹ ìpìlẹ̀ (ààyè sí kàlẹ́ńdà orí ẹ̀rọ, àwòrán ojú-ìwé, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ). Nígbà tí o bá fi áàpù kàlẹ́ńdà sórí ẹ̀rọ, yóò rọ́pò irinṣẹ́ kàlẹ́ńdà tí a kọ́ sínú rẹ̀, yóò sì di èyí tí ó ní gbogbo rẹ̀ àti jù bẹ́ẹ̀ lọ — orí ẹ̀rọ + cloud + àkójọpọ̀ + ṣíṣàyẹ̀wò àyè.
Ìlànà Ṣíṣàkójọ Nìkan
Nebo ń mú ìlànà binary tí a ṣàkójọ nìkan ṣẹ ní kíkankíkan. Gbogbo áàpù gbọ́dọ̀ jẹ́ fáìlì aláṣẹ àbínibí tí a ṣàkójọ.
| Ipò | Àwọn èdè |
|---|---|
| Tí a ṣe àtìlẹ́yìn fún | Go (tí a dámọ̀ràn), Rust, C/C++, Zig |
| Tí a kọ̀ | Python, Node.js, Ruby, Java, .NET, àwọn script shell |
Ìdí:
- Dídènà AI láti yí ara rẹ̀ padà — Òṣìṣẹ́ AI tí ó ní ààyè sí shell lè yí ìwà script tí a ń túmọ̀ padà nígbà tí ó ń ṣiṣẹ́. Àwọn binary tí a ṣàkójọ kò ṣeé yí padà lẹ́yìn ìfọwọ́sí.
- Ìdúróṣinṣin ìfọwọ́sí — Àwọn ìfọwọ́sí Ed25519 ń bo àwọn báìtì binary gidi. A kò lè yí binary tí a fọwọ́ sí padà láìsọ ìfọwọ́sí náà di asán.
- Ìmúṣẹ sandbox — Ìfọwọ́sí ìrísí binary (àwọn báìtì àmì ELF/Mach-O/PE) jẹ́ ẹnu-ọ̀nà tí ó yára tí ó sì ṣeé gbẹ́kẹ̀lé.
Ìbẹ̀rẹ̀ kíákíá
Fi SDK sórí ẹ̀rọ
Àwọn SDK oníṣẹ́ ń bójú tó gbogbo ìṣètò sáfà gRPC, ìbójútó àmì, àti afárá ìlànà. Ìwọ kàn ń ṣe àwọn interface handler.
Go (tí a dámọ̀ràn):
go get github.com/neboloop/nebo-sdk-go Rust (ń bọ̀ láìpẹ́):
# Coming soon
[dependencies]
nebo-sdk = "0.1" C/C++ (ń bọ̀ láìpẹ́):
# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/ Ìtòlẹ́sẹẹsẹ Fódà Áàpù
Àwọn áàpù ń gbé inú fódà kékeré apps/ nínú fódà dátà Nebo rẹ:
~/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) Àtòjọ Àyẹ̀wò Áàpù Kékeré Jù
- Ṣẹ̀dá
manifest.jsonpẹ̀lúid,name,version,provides - Kọ
TOOL.mdtí ó ń ṣàpèjúwe bí òṣìṣẹ́ AI ṣe yẹ kí ó lo irinṣẹ́ rẹ - Fi SDK sórí ẹ̀rọ (
go get github.com/neboloop/nebo-sdk-go) - Ṣe interface handler fún agbára rẹ (
ToolHandler,ChannelHandler, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ) - Forúkọ handler náà sílẹ̀ kí o sì pe
app.Run() - Kọ́ binary àbínibí (
go build -o binary .) - Fi binary + manifest.json + TOOL.md sínú fódà
apps/<your-app-id>/ - Nebo yóò ṣàwárí rẹ̀ fúnra rẹ̀, yóò sì ṣí i
Ìṣètò
manifest.json
Gbogbo áàpù nílò 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
}
]
} Àwọn pápá tí ó pọn dandan:
| Pápá | Àpèjúwe |
|---|---|
id | Ìdámọ̀ ìkápá-ìdàkejì (bí àpẹẹrẹ, com.mycompany.myapp) |
name | Orúkọ tí ènìyàn lè kà |
version | Okùn semver |
provides | Ó kéré tán agbára kan (wo nísàlẹ̀) |
Àwọn pápá àṣàyàn:
| Pápá | Ìpìlẹ̀ | Àpèjúwe |
|---|---|---|
runtime | "local" | "local" tàbí "remote" |
protocol | "grpc" | "grpc" nìkan ni a ṣe àtìlẹ́yìn fún |
permissions | [] | Ohun tí áàpù náà nílò ààyè sí |
description | "" | Ó ń hàn nínú UI |
settings | [] | Àwọn ètò tí a lè ṣàtúnṣe (tí a fi hàn nínú UI Ètò) |
oauth | [] | Àwọn ìbéèrè olùpèsè OAuth (wo apá OAuth nísàlẹ̀) |
Àwọn agbára
Kéde ohun tí áàpù rẹ ń pèsè:
| Agbára | Iṣẹ́ gRPC | Àpèjúwe |
|---|---|---|
gateway | GatewayService | Dídarí àwòṣe LLM |
tool:<name> | ToolService | Irinṣẹ́ tí ó ní orúkọ fún òṣìṣẹ́ AI |
channel:<name> | ChannelService | Ìkànnì ìfiránṣẹ́ |
comm | CommService | Ìbánisọ̀rọ̀ láàárín àwọn òṣìṣẹ́ AI |
ui | UIService | UI àdáni pẹ̀lú HTTP proxy |
schedule | ScheduleService | Ìṣètò àkókò àdáni |
vision | ToolService | Ṣíṣe iṣẹ́ lórí àwòrán |
browser | ToolService | Ìṣiṣẹ́ aṣàwákiri aládàáṣe |
Áàpù kan lè pèsè ọ̀pọ̀ agbára. Bí àpẹẹrẹ, áàpù kan lè pèsè irinṣẹ́ àti pánẹ́ẹ̀lì UI papọ̀.
Àwọn àṣẹ
Àwọn àṣẹ ń ṣàkóso ohun tí áàpù náà lè dé. A kọ̀ ọ́ ní ìpìlẹ̀ — bí a kò bá kéde rẹ̀, áàpù náà kò lè lò ó.
| Ìbẹ̀rẹ̀ ọ̀rọ̀ | Àwọn àpẹẹrẹ | Àpèjúwe |
|---|---|---|
network: | network:outbound, network:* | Ààyè sí nẹ́tíwọ́ọ̀kì |
filesystem: | filesystem:read, filesystem:write | Ààyè sí ètò fáìlì |
memory: | memory:read, memory:write | Ààyè sí ìrántí òṣìṣẹ́ AI |
session: | session:read | Àwọn ìgbà ìjíròrò |
tool: | tool:shell, tool:file | Lo àwọn irinṣẹ́ míì |
shell: | shell:exec | Ṣíṣe àṣẹ shell |
channel: | channel:send, channel:* | Àwọn iṣẹ́ ìkànnì |
comm: | comm:send, comm:* | Ìbánisọ̀rọ̀ láàárín àwọn òṣìṣẹ́ AI |
model: | model:chat | Ààyè sí àwòṣe AI |
user: | user:token | Gba JWT olùlò nínú àwọn ìbéèrè |
schedule: | schedule:create | Ìṣàkóso iṣẹ́ cron |
database: | database:query | Ààyè sí ibi ìpamọ́ dátà |
storage: | storage:read, storage:write | Ibi ìpamọ́ tí ó wà pẹ́ |
context: | context:read | Ààyè sí àyíká òṣìṣẹ́ AI |
subagent: | subagent:spawn | Àwọn iṣẹ́ sub-agent |
lane: | lane:enqueue | Àwọn iṣẹ́ lane |
notification: | notification:send | Àwọn ìfitónilétí push |
embedding: | embedding:search | Ààyè sí vector embedding |
skill: | skill:invoke | Pípe ọgbọ́n |
advisor: | advisor:consult | Ààyè sí ètò olùgbaninímọ̀ràn |
mcp: | mcp:connect | Ààyè sí sáfà MCP |
voice: | voice:record | Ààyè sí ohùn/ìró |
browser: | browser:navigate | Ìṣiṣẹ́ aṣàwákiri aládàáṣe |
oauth: | oauth:google, oauth:* | Ààyè sí token OAuth |
settings: | settings:read | Ààyè sí ètò |
capability: | capability:register | Ìforúkọsílẹ̀ agbára |
A ṣe àtìlẹ́yìn fún àwọn àṣẹ wildcard: network:* bá gbogbo àyẹ̀wò àṣẹ network: mu.
Ètò
Àwọn ètò ń hàn nínú UI Nebo lábẹ́ pánẹ́ẹ̀lì ètò áàpù náà. Nebo ń tọ́jú wọn sínú ibi ìpamọ́ dátà, ó sì ń fi wọ́n ránṣẹ́ sí áàpù rẹ nípasẹ̀ RPC Configure nígbà tí wọ́n bá yí padà.
Àwòṣe ètò rẹ wà nínú àkọsílẹ̀ ilé ìtajà áàpù NeboAI. Àwọn áàpù tí ó ní ètò tí ó pọn dandan tí a kò tíì ṣètò ń fi àmì "Needs Setup" hàn nínú UI.
| Irú | Àpèjúwe |
|---|---|
text | Àpótí ọ̀rọ̀ ìlà kan |
password | Àpótí ọ̀rọ̀ tí a fi pamọ́ |
toggle | Bọ́tìnnì tàn/pa Boolean |
select | Àtòjọ ìyànsílẹ̀ pẹ̀lú àwọn àṣàyàn tí a ti ṣètò |
number | Àpótí nọ́mbà |
url | Àpótí URL pẹ̀lú àyẹ̀wò |
{
"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"}
]
} Àwọn Ìbéèrè OAuth
Àwọn áàpù lè kéde àwọn ìbéèrè olùpèsè OAuth. Alágbàtà OAuth ti Nebo ń bójú tó gbogbo ìlànà náà — àwọn áàpù ń gba àwọn token fúnra wọn nípasẹ̀ RPC Configure.
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | Pápá | Àpèjúwe |
|---|---|
provider | Olùpèsè OAuth: "google", "microsoft", "github" |
scopes | Àkójọ àwọn scope OAuth tí áàpù náà nílò |
Nígbà tí olùlò bá fi áàpù náà sórí ẹ̀rọ, Nebo yóò ní kí wọ́n fún àwọn scope OAuth tí ó pọn dandan láṣẹ. Áàpù náà ń gba àwọn token tí a sọ dọ̀tun nípasẹ̀ RPC Configure láìní láti bójú tó ìlànà OAuth fúnra rẹ̀.
Àwọn Àyípadà Àyíká
Ìlànà áàpù rẹ ń gba àyíká tí a ti fọ̀ mọ́. A yọ gbogbo àṣírí kúrò. Ohun tí o ń gbà ni:
| Àyípadà | Iye |
|---|---|
NEBO_APP_DIR | Fódà ìfisórí-ẹ̀rọ áàpù náà |
NEBO_APP_SOCK | Ọ̀nà sí Unix socket tí a ó ṣẹ̀dá |
NEBO_APP_ID | ID áàpù láti inú manifest |
NEBO_APP_NAME | Orúkọ áàpù láti inú manifest |
NEBO_APP_VERSION | Ẹ̀dà áàpù láti inú manifest |
NEBO_APP_DATA | Ọ̀nà sí fódà data/ áàpù náà |
PATH | PATH ètò (tí a gbé kọjá) |
HOME | Fódà ilé olùlò (tí a gbé kọjá) |
TMPDIR | Fódà ìgbà díẹ̀ (tí a gbé kọjá) |
Pàtàkì: Binary rẹ gbọ́dọ̀ ṣẹ̀dá sáfà gRPC tí ń gbọ́ lórí Unix socket ní NEBO_APP_SOCK. Nebo ń dúró títí dé ìṣẹ́jú-àáyá 10 kí socket yìí tó fara hàn.
Ìtòlẹ́sẹẹsẹ Ìṣísílẹ̀ Áàpù
- Nebo ka
manifest.json, ó sì ṣàyẹ̀wò rẹ̀ - Ó wá fáìlì aláṣẹ
binarytàbíappnínú fódà áàpù náà - Ó ṣàyẹ̀wò fún àmì
.quarantined(ó kọ̀ láti ṣí àwọn áàpù tí a yà sọ́tọ̀) - Àyẹ̀wò ìfagilé (àwọn áàpù tí NeboAI pín nìkan)
- Ìfìdímúlẹ̀ ìfọwọ́sí (àwọn áàpù tí NeboAI pín nìkan, a fò ó nínú dev)
- Àyẹ̀wò binary (ó kọ symlink, script, àwọn tí kì í ṣe fáìlì aláṣẹ, àwọn fáìlì tí ó tóbi jù)
- Ó pa socket àtijọ́ láti ìṣiṣẹ́ tó kọjá rẹ́
- Ó ṣẹ̀dá fódà
data/fún ibi ìpamọ́ inú sandbox - Ó ṣètò àwọn fáìlì àkọsílẹ̀ fún áàpù kọ̀ọ̀kan (
logs/stdout.log,logs/stderr.log) - Ó bẹ̀rẹ̀ binary pẹ̀lú àyíká tí a ti fọ̀ mọ́ àti ìyàsọ́tọ̀ ẹgbẹ́ ìlànà
- Ó dúró kí Unix socket fara hàn (exponential backoff, ìṣẹ́jú-àáyá 10 ní pọ̀ jù)
- Ó sopọ̀ nípasẹ̀ gRPC lórí Unix socket
- Ó ṣẹ̀dá àwọn oníbàárà gRPC fún agbára kọ̀ọ̀kan gẹ́gẹ́ bí
provides - Ó ṣe àyẹ̀wò ìlera
- Ó forúkọ àwọn agbára sílẹ̀ pẹ̀lú òṣìṣẹ́ AI (àwọn irinṣẹ́, gateway, comm, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ)
Àwọn Áàpù Irinṣẹ́
Kéde "provides": ["tool:my_tool_name"] nínú manifest rẹ.
Àpẹẹrẹ STRAP
Gbogbo áàpù irinṣẹ́ Nebo gbọ́dọ̀ lo STRAP (Single Tool Resource Action Pattern) fún àwòṣe wọn àti dídarí ìṣiṣẹ́. Èyí ni àpẹẹrẹ kan náà tí Nebo ń lò nínú láti kó irinṣẹ́ ẹyọ-ẹyọ tí ó ju 35 lọ pọ̀ sí irinṣẹ́ ìkápá 4 — ó ń dín ẹrù àyíká LLM kù ní ~80%.
Èrò pàtàkì: Dípò fífi orúkọ ọ̀pọ̀ irinṣẹ́ sílẹ̀ (get_events, check_availability, suggest_slots), forúkọ irinṣẹ́ KAN sílẹ̀ pẹ̀lú àwọn pápá action (àti resource bí o bá fẹ́) tí ó ń darí sí handler tí ó tọ́.
Àpẹẹrẹ ohun-èlò kan (kàlẹ́ńdà):
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") Àpẹẹrẹ ọ̀pọ̀ ohun-èlò (olùṣàkóso iṣẹ́ àkànṣe):
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") Àwọn òfin àwòṣe:
- Máa fi pápá
actionsí i nígbà gbogbo gẹ́gẹ́ bí string enum tí ó pọn dandan - Fi pápá
resource(string enum tí ó pọn dandan) kún un kìkì bí irinṣẹ́ rẹ bá ń ṣàkóso ọ̀pọ̀ irú ohun-èlò tí ó yàtọ̀ - Gbogbo àwọn pápá míì jẹ́ àwọn paramita fún action pàtó
- Àpèjúwe enum
actionyẹ kí ó ṣe àtòjọ gbogbo action tí ó wà
Ìdí tí STRAP fi ṣe pàtàkì:
- Àwọn LLM ń kọ́ àpẹẹrẹ dídarí
actionlẹ́ẹ̀kan, wọ́n sì ń lò ó fún gbogbo iṣẹ́ - Àwọn ìtumọ̀ irinṣẹ́ ń jẹ ~6% àyíká — STRAP ń gé e kù ní 80%
- Àwọn iṣẹ́ tuntun jẹ́ àfikún enum lásán, kì í ṣe ìforúkọsílẹ̀ irinṣẹ́ tuntun
- Ó ń ṣiṣẹ́ bákan náà lórí àwọn àwòṣe tí a gbé sórí ayélujára àti ti orí ẹ̀rọ
Àpẹẹrẹ Go — Irinṣẹ́ Ẹ̀rọ Ìṣirò
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": []
} Kọ́ ọ kí o sì fi sórí ẹ̀rọ:
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/ Àpẹẹrẹ 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(())
} Àpẹẹrẹ 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;
} Àwọn Áàpù Ìkànnì
Kéde "provides": ["channel:my_channel"] àti "permissions": ["channel:send"].
Àwọn áàpù ìkànnì ń so àwọn pẹpẹ ìfiránṣẹ́ òde (Telegram, Discord, Slack, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ) pọ̀ mọ́ òṣìṣẹ́ AI ti Nebo. Nígbà tí olùlò bá fi ìránṣẹ́ ránṣẹ́ lórí pẹpẹ òde náà, áàpù rẹ yóò ṣàn án sí Nebo nípasẹ̀ Receive. Nígbà tí òṣìṣẹ́ AI bá fẹ́ fèsì, Nebo yóò pe Send áàpù rẹ.
Bí ó ṣe ń ṣiṣẹ́
- Nebo pe
ID()láti gba ìdámọ̀ àrà ọ̀tọ̀ ìkànnì rẹ - Nebo pe
Connect()pẹ̀lú ìṣètò láti inú ètò áàpù rẹ - Nebo ṣí ìṣàn
Receive()— áàpù rẹ ń fi àwọn ìránṣẹ́ tí ó wọlé ránṣẹ́ nígbàkígbà tí olùlò bá fi ìránṣẹ́ ránṣẹ́ sí bot náà - A ń darí àwọn ìránṣẹ́ tí ó wọlé sí lane ìjíròrò pàtàkì òṣìṣẹ́ AI
- Nígbà tí òṣìṣẹ́ AI bá fẹ́ fi ìránṣẹ́ ránṣẹ́, Nebo pe
Send()pẹ̀lú àpò-ìwé ìránṣẹ́ v1 - Nígbà tí a bá ń pa á, Nebo pe
Disconnect()
Àpò-ìwé Ìránṣẹ́ v1
Gbogbo ìránṣẹ́ ìkànnì — tí ó wọlé àti tí ó jáde — ń lo àpò-ìwé ìránṣẹ́ àjọlò:
{
"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"
} | Pápá | Irú | Àpèjúwe |
|---|---|---|
message_id | UUID v7 | ID àrà ọ̀tọ̀ tí a tò ní ìtẹ̀léra àkókò |
channel_id | {type}:{platform_id} | Ìdámọ̀ ìkànnì tí a lè darí |
sender | object | Ìdánimọ̀ bot — orúkọ, ipa, botId |
text | string | Ara ìránṣẹ́ |
attachments | array | Àwọn fáìlì, àwòrán, ìró |
reply_to | UUID v7 | ID ìránṣẹ́ òbí fún ìtẹ̀léra ìjíròrò |
actions | array | Àwọn bọ́tìnnì/kíbọ́ọ̀dù ìbáṣepọ̀ |
platform_data | bytes | Ìgbékọjá aláìfojúhàn fún àwọn ẹ̀yà pàtó pẹpẹ |
timestamp | ISO 8601 | Olùtẹ̀jáde ló ń ṣètò èyí |
Àpẹẹrẹ ìpele méjì: Àwọn pápá àjọlò (ọ̀rọ̀, àsomọ́, reply_to, actions) ń bo 90% ìfiránṣẹ́ tí òṣìṣẹ́ bẹ̀rẹ̀. Àwọn ẹ̀yà pàtó pẹpẹ ń lọ sínú platform_data — plugin rẹ ń yí wọn padà sí ìrísí pẹpẹ àbínibí àti láti inú rẹ̀.
Àwọn Ìṣàn Ìjíròrò
A ń darí àwọn ìránṣẹ́ ìkànnì lórí ìṣàn ìjíròrò fún ìkànnì kọ̀ọ̀kan fún ìyàsọ́tọ̀:
neboai/bot/{botID}/channels/{channelType}/inbound # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound # messages from agent → channel Àpẹẹrẹ Go — Ìkànnì 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
}
]
} Àwọn Agbára Míì
Áàpù Comm
Kéde "provides": ["comm"] àti "permissions": ["comm:*"]. Àwọn áàpù comm ń jẹ́ kí ìbánisọ̀rọ̀ ṣeé ṣe láàárín àwọn òṣìṣẹ́ AI.
| Pápá | Àpèjúwe |
|---|---|
from | ID òṣìṣẹ́ olùfiránṣẹ́ |
to | ID òṣìṣẹ́ olùgbà |
topic | Àkòrí/ìkànnì ìránṣẹ́ |
type | "message", "mention", "proposal", "command", "info", "task" |
content | Ara ìránṣẹ́ |
Àwọn ìwà pàtàkì:
Registerń kéde òṣìṣẹ́ AI yìí lórí nẹ́tíwọ́ọ̀kì pẹ̀lú àwọn agbára rẹ̀Subscribe/Unsubscribeń ṣàkóso ìforúkọsílẹ̀ àwọn àkòríReceiveń ṣàn àwọn ìránṣẹ́ tí ó wọlé (server-streaming, bákan náà bí àwọn ìkànnì)- Áàpù comm kan ṣoṣo ló lè ṣiṣẹ́ ní àkókò kan
Áàpù Gateway
Áàpù gateway ń darí àwọn ìbéèrè LLM sí àwọn àwòṣe. Kéde "provides": ["gateway"] àti "permissions": ["network:outbound", "user:token"].
GatewayRequest ní àwọn ìránṣẹ́, irinṣẹ́, ìtọ́ni ètò, iye token tí ó pọ̀ jù, temperature, àti UserContext kan (token JWT bí a bá fún un ní àṣẹ user:token).
Àwọn irú GatewayEvent:
| Irú | Àkóónú | Àpèjúwe |
|---|---|---|
"text" | Apá ọ̀rọ̀ | Token ọ̀rọ̀ tí ń ṣàn |
"tool_call" | JSON | Àwòṣe fẹ́ pe irinṣẹ́ kan |
"thinking" | Apá ọ̀rọ̀ | Ríronú/ìrònú jinlẹ̀ tí ó gbòòrò |
"error" | Ìránṣẹ́ àṣìṣe | Nǹkan kan ti bàjẹ́ |
"done" | Òfo | Ìṣàn ti parí |
Áàpù UI
Áàpù UI ń pèsè interface ìṣètò àdáni tí ó ń ṣí nínú fèrèsé aṣàwákiri tí a kọ́ sínú Nebo. Kéde "provides": ["ui"]. Yàtọ̀ sí fọ́ọ̀mù ètò aládàáṣe (tí Nebo ń ṣe láti inú manifest settings rẹ), áàpù UI ń pèsè frontend HTML/CSS/JS kíkún tirẹ̀.
Áàpù rẹ ń jáde pẹ̀lú fódà ui/ tí ó ní àwọn ohun-ìní wẹ́ẹ̀bù aláìyípadà (HTML, CSS, JS — ní ọ̀pọ̀ ìgbà SPA pẹ̀lú index.html). Nebo ń pèsè àwọn fáìlì wọ̀nyí tààrà, ó sì ń gbé àwọn ìpè API kọjá sí áàpù rẹ nípasẹ̀ gRPC.
| Ọ̀nà | Ọ̀nà ìṣiṣẹ́ | Ète |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Sáfà fáìlì aláìyípadà | Ó ń pèsè àwọn fáìlì láti inú fódà ui/ rẹ (SPA ń padà sí index.html) |
ANY /api/v1/apps/{id}/api/* | gRPC proxy | Ó ń gbé àwọn ìbéèrè HTTP kọjá sí UIService.HandleRequest() áàpù rẹ |
SDK náà ń wé net/http.ServeMux boṣewa kan, nítorí náà o ń kọ àwọn handler HTTP Go déédéé — SDK náà ń bójú tó afárá gRPC fúnra rẹ̀.
Àpẹẹrẹ Go — UI Dashboard:
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 rẹ yóò ṣe àwọn ìpè fetch sí /api/v1/apps/com.example.dashboard/api/status, tí a ó gbé kọjá sí handler mux rẹ.
Áàpù Ètò Àkókò
Áàpù ètò àkókò ń rọ́pò olùṣètò cron tí a kọ́ sínú Nebo. Kéde "provides": ["schedule"] àti "permissions": ["schedule:create"].
Nígbà tí áàpù ètò àkókò rẹ bá bẹ̀rẹ̀, Nebo yóò darí gbogbo ìṣètò àkókò gba inú áàpù rẹ dípò ẹ̀rọ cron ìpìlẹ̀. Bí áàpù rẹ bá dàwó, Nebo yóò padà sí ẹ̀rọ tí a kọ́ sínú rẹ̀ fúnra rẹ̀.
- Áàpù rẹ ló ni ipò ètò àkókò — Nebo kì í tọ́jú àwọn ètò àkókò sínú DB tirẹ̀ nígbà tí áàpù ètò àkókò bá ń ṣiṣẹ́
- CRUD boṣewa:
Create,Get,List,Update,Delete,Enable,Disable Triggersjẹ́ RPC server-streaming — áàpù rẹ ń fi ìránṣẹ́ trigger ránṣẹ́ nígbàkígbà tí ètò àkókò kan bá ṣẹlẹ̀- Áàpù ètò àkókò kan ṣoṣo ló lè ṣiṣẹ́ ní àkókò kan
Àwọn Áàpù Ọ̀pọ̀ Agbára
Áàpù kan lè pèsè ọ̀pọ̀ agbára. Bí àpẹẹrẹ, áàpù dashboard tí ó ní irinṣẹ́ àti UI papọ̀:
{
"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()) Ìdìpọ̀
Ìrísí .napp
Fún pínpín nípasẹ̀ NeboAI, di áàpù rẹ pọ̀ gẹ́gẹ́ bí fáìlì .napp (àpò tar.gz):
cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md Àwọn fáìlì tí ó pọn dandan:
| Fáìlì | Ìwọ̀n tí ó pọ̀ jù | Àpèjúwe |
|---|---|---|
manifest.json | 1 MB | Metadata áàpù |
binary tàbí app | 500 MB | Fáìlì aláṣẹ |
signatures.json | 1 MB | Àwọn ìfọwọ́sí Ed25519 |
TOOL.md | 1 MB | Ìtọ́ni irinṣẹ́ fún òṣìṣẹ́ AI |
Àwọn òfin ààbò nígbà ìyọjáde:
- Kò sí ìrìn-ọ̀nà kọjá ààlà (a kọ
../) - Kò sí symlink (a kọ̀ wọ́n)
- Kò sí ọ̀nà pípé (a kọ̀ wọ́n)
- Àwọn orúkọ fáìlì tí ó wà nínú àtòjọ ìgbàláàyè nìkan ni a gbà
Àwọn ìfọwọ́sí
NeboAI ń fọwọ́ sí àwọn áàpù pẹ̀lú Ed25519. Ìrísí 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>"
} Ní ipò dev (tí a kò ṣètò URL NeboAI), a fo ìfìdímúlẹ̀ ìfọwọ́sí pátápátá. O kò nílò signatures.json fún ìgbéejáde orí ẹ̀rọ.
Ṣíṣe àtẹ̀jáde
Ní kété tí áàpù rẹ bá ti ń ṣiṣẹ́ lórí ẹ̀rọ rẹ, ṣe àtẹ̀jáde rẹ̀ nípasẹ̀ NeboAI fún pínpín sí gbogbo olùlò Nebo.
Ìṣètò Àkọọ́lẹ̀ Olùgbéejáde
- Forúkọ àkọọ́lẹ̀ NeboAI sílẹ̀ ní
POST /api/v1/owners/register - Wọlé láti gba token JWT:
POST /api/v1/owners/login - Ṣẹ̀dá àkọọ́lẹ̀ olùgbéejáde:
POST /api/v1/developer/accounts
Ìlànà Ìfiránṣẹ́
draft → pending_review → [approved] → published
→ [rejected] → draft (fix and resubmit) Ìgbésẹ̀ 1: Ṣẹ̀dá áàpù náà
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"
}' Ìgbésẹ̀ 2: Gbé àwọn binary pẹpẹ sókè
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" Gbé binary kan sókè fún pẹpẹ kọ̀ọ̀kan: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.
Ìgbésẹ̀ 3: Fi ránṣẹ́ fún àyẹ̀wò
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
-H "Authorization: Bearer $TOKEN" Ìlànà Àyẹ̀wò
- Àyẹ̀wò aládàáṣe — a ń yẹ àwọn binary wò nípasẹ̀ VirusTotal
- Àyẹ̀wò alábòójútó — ẹgbẹ́ NeboAI ń yẹ metadata, manifest, àti àbájáde àyẹ̀wò wò
- Nígbà ìfọwọ́sí — NeboAI ń fọwọ́ sí áàpù náà pẹ̀lú Ed25519, ó sì ń ṣe àtẹ̀jáde rẹ̀
- Nígbà ìkọ̀sílẹ̀ — o ń gba ìdí, o sì lè ṣàtúnṣe kí o tún fi ránṣẹ́
Àkókò àyẹ̀wò tí a ń fojú sùn: <24 wákàtí.
Fífi Àwọn Àtúnṣe Ránṣẹ́
- Ṣe àtúnṣe ẹ̀dà ìṣàfilọ́lẹ̀ náà:
PUT /api/v1/developer/apps/{id}pẹ̀lú ẹ̀dà tuntun - Gbé àwọn binary tuntun sókè fún pẹpẹ kọ̀ọ̀kan
- Tún fi ránṣẹ́ fún àyẹ̀wò
Àtúnṣe kọ̀ọ̀kan ń gba inú ìlànà àyẹ̀wò kan náà. Àwọn ẹ̀dà tí ó ti kọjá ń wà síbẹ̀ títí tí a ó fi fọwọ́ sí ẹ̀dà tuntun.
Metadata Ilé Ìtajà
| Pápá | Àpèjúwe |
|---|---|
category | bí àpẹẹrẹ, productivity, communication, developer-tools |
icon | URL àmì áàpù |
visibility | public tàbí private |
description | Ó lè gùn jù tàbí ní ọ̀rọ̀ púpọ̀ ju àpèjúwe manifest lọ |
Ìlànà Iṣẹ́ Dev
Ìgbéejáde Orí Ẹ̀rọ
Kò nílò ìdìpọ̀ fún ìgbéejáde orí ẹ̀rọ:
- Ṣẹ̀dá directory ìṣàfilọ́lẹ̀ rẹ:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - Kọ
manifest.jsonàti kóòdù rẹ - Kọ́ binary rẹ:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo yóò rí fódà tuntun náà fúnra rẹ̀ (tàbí tún Nebo bẹ̀rẹ̀)
- Lẹ́yìn àwọn ìyípadà kóòdù, tún binary náà kọ́ — olùṣọ́ fáìlì yóò tún áàpù náà bẹ̀rẹ̀
Wíwo Àwọn Àkọsílẹ̀
A ń gba stdout/stderr áàpù sínú àwọn fáìlì àkọsílẹ̀ fún áàpù kọ̀ọ̀kan:
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 Dátà Tí Ó Wà Pẹ́
Lo fódà data/ (tí ó tún wà gẹ́gẹ́ bí env var NEBO_APP_DATA) fún àwọn fáìlì èyíkéyìí tí áàpù rẹ nílò láti pa mọ́. Fódà yìí ń là á já nígbà àtúnṣe áàpù àti ìyàsọ́tọ̀.
Àwọn Ìmọ̀ràn Ìtúnṣe Àṣìṣe
- Bí áàpù rẹ kò bá bẹ̀rẹ̀, ṣàyẹ̀wò
logs/stderr.logfún àwọn àṣìṣe - Rí i dájú pé binary náà ṣeé ṣiṣẹ́ (
chmod +x binary) - Rí i dájú pé ò ń gbọ́ lórí ọ̀nà Unix socket láti
NEBO_APP_SOCK - Socket náà gbọ́dọ̀ ṣetán láàárín ìṣẹ́jú-àáyá 10 lẹ́yìn ìṣísílẹ̀
- Lo
NEBO_APP_DATAfún ibi ìpamọ́, kì í ṣe àwọn ọ̀nà tí a kọ sínú kóòdù - Kọ sí stderr fún àkọsílẹ̀ ìtúnṣe àṣìṣe (tí a gbà sínú
logs/stderr.log)
Ìfìdímúlẹ̀
# 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 Yíyọ kúrò lórí ẹ̀rọ
nebo apps uninstall com.example.myapp Àwọn ọgbọ́n
Kí Ni Àwọn Ọgbọ́n Jẹ́
Àwọn ọgbọ́n jẹ́ àkójọ ìtọ́ni tí ó ń ṣe àpẹẹrẹ bí Nebo ṣe ń hùwà nígbà ìjíròrò. Nígbà tí ọgbọ́n kan bá ń ṣiṣẹ́, a ń fi àkóónú rẹ̀ sínú ìtọ́ni ètò tààrà — tí ó ń darí ohùn òṣìṣẹ́ AI, ọ̀nà iṣẹ́ rẹ̀, ìmọ̀ pàtàkì rẹ̀, àti lílo irinṣẹ́ fún ìgbà yẹn.
Àwọn ọgbọ́n kì í ṣe kóòdù. Ìwé markdown ni wọ́n pẹ̀lú metadata YAML. Kò sí ṣíṣàkójọ, kò sí binary, kò sí gRPC. Ọgbọ́n kan jẹ́ fáìlì SKILL.md nínú fódà kan. Ìyẹn ni.
Àwọn ọgbọ́n jẹ́ ti àyíká, wọn kò sì pẹ́. Wọ́n ń ṣiṣẹ́ nígbà tí wọ́n bá yẹ (nípasẹ̀ bíbá trigger mu tàbí gbígbé wọlé fúnra ẹni), wọ́n ń wà fún ìyípo díẹ̀, wọ́n sì ń parí nígbà tí a kò bá nílò wọn mọ́. Èyí ń jẹ́ kí àyíká òṣìṣẹ́ AI fúyẹ́ — ìtọ́sọ́nà tí ó ṣe pàtàkì báyìí nìkan ló wà nínú ìtọ́ni.
Àwọn ọgbọ́n ń ṣàfikún àwọn áàpù. Àwọn áàpù ń pèsè agbára tí ó ṣeé ṣiṣẹ́ (àwọn irinṣẹ́, ìkànnì, gateway). Àwọn ọgbọ́n ń pèsè ìtọ́sọ́nà ìṣètò — bí a ṣe ń lo àwọn irinṣẹ́ wọ̀nyẹn dáadáa. Áàpù kàlẹ́ńdà ń fún Nebo ní agbára láti kà àti kọ àwọn ìṣẹ̀lẹ̀. Ọgbọ́n "ìmúrasílẹ̀ fún ìpàdé" ń sọ fún Nebo bí ó ṣe lè múra sílẹ̀ fún àwọn ìpàdé nípa lílo áàpù kàlẹ́ńdà náà, ímeèlì, àti ìwádìí wẹ́ẹ̀bù papọ̀.
Àwọn Ọgbọ́n àti Àwọn Áàpù
| Àwọn ọgbọ́n | Àwọn áàpù | |
|---|---|---|
| Ìrísí | Markdown (SKILL.md) | Binary tí a ṣàkójọ (.napp) |
| Ìgbà ìṣiṣẹ́ | A fi sínú ìtọ́ni ètò | Ìlànà inú sandbox lórí gRPC |
| Ohun tí ó ń pèsè | Ìtọ́sọ́nà ìwà, ọ̀nà iṣẹ́ | Àwọn irinṣẹ́, ìkànnì, pánẹ́ẹ̀lì UI |
| Ìgbà ayé | Fún ìgbà ìjíròrò kan, ó ń parí gẹ́gẹ́ bí TTL | Ó ń ṣiṣẹ́ nígbà gbogbo |
| Ṣíṣẹ̀dá | Kọ fáìlì markdown kan | Kọ ọ́, ṣàkójọ rẹ̀, fọwọ́ sí i, dì í pọ̀ |
| Ààbò | Kò nílò àṣẹ kankan | Sandbox tí ó kọ̀ ní ìpìlẹ̀ |
Ìbẹ̀rẹ̀ kíákíá
Ṣẹ̀dá fódà kan nínú fódà ọgbọ́n Nebo rẹ pẹ̀lú fáìlì SKILL.md:
~/Library/Application Support/Nebo/skills/ # macOS
~/.config/nebo/skills/ # Linux
%AppData%\Nebo\skills\ # Windows mkdir -p ~/.config/nebo/skills/my-skill Kọ SKILL.md kan:
---
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 ń ṣọ́ fódà ọgbọ́n pẹ̀lú fsnotify. Ọgbọ́n rẹ wà lẹ́sẹ̀kẹsẹ̀ — kò nílò àtúnbẹ̀rẹ̀. Sọ nǹkan kan tí ó bá trigger mu, yóò sì bẹ̀rẹ̀ iṣẹ́ fúnra rẹ̀.
Tàbí béèrè lọ́wọ́ Nebo tààrà: "Ṣẹ̀dá ọgbọ́n kan fún kíkọ àwọn àpilẹ̀kọ búlọ́ọ̀gù" — Nebo yóò kọ fáìlì SKILL.md náà fún ọ.
Ìrísí SKILL.md
Gbogbo ọgbọ́n jẹ́ fáìlì SKILL.md kan ṣoṣo tí ó ní apá méjì: frontmatter YAML láàárín àwọn àmì ---, àti ara markdown (àwọn ìtọ́ni gidi tí a ń fi sínú ìtọ́ni ètò).
| Pápá | Ó pọn dandan | Ìpìlẹ̀ | Àpèjúwe |
|---|---|---|---|
name | Bẹ́ẹ̀ni | — | Ìdámọ̀ àrà ọ̀tọ̀ (ó ń di slug) |
description | Bẹ́ẹ̀ni | — | Àpèjúwe ìlà kan tí ó ń hàn nínú àtòjọ ọgbọ́n |
version | Rárá | "1.0.0" | Semver fún títọpa àwọn àtúnṣe |
author | Rárá | — | Olùkọ̀wé ọgbọ́n |
priority | Rárá | 0 | Tí ó ga jù = a kọ́kọ́ bá a mu (100+ fún àwọn ìrọ́pò pàtàkì) |
max_turns | Rárá | 4 | Ìyípo àìṣiṣẹ́ kí ó tó parí fúnra rẹ̀ |
triggers | Rárá | [] | Àwọn gbólóhùn tí ó ń mú ọgbọ́n yìí ṣiṣẹ́ fúnra rẹ̀ (ìbámu apá ọ̀rọ̀ tí kò ka lẹ́tà ńlá tàbí kékeré sí) |
tools | Rárá | [] | Àwọn irinṣẹ́ tí ọgbọ́n yìí ń retí láti lò (fún ìsọfúnni) |
dependencies | Rárá | [] | Àwọn ọgbọ́n míì tí a gbọ́dọ̀ fi sórí ẹ̀rọ |
tags | Rárá | [] | Fún pínpín sí ẹ̀ka àti ṣíṣàwárí |
platform | Rárá | [] | Àwọn pẹpẹ tí a ṣe àtìlẹ́yìn fún: macos, linux, windows (òfo = gbogbo rẹ̀) |
Bí Àwọn Ọgbọ́n Ṣe Ń Bẹ̀rẹ̀ Iṣẹ́
Àwọn ọgbọ́n ń tẹ̀lé àpẹẹrẹ ìmúṣiṣẹ́ onípele méjì: ìtọ́kasí, lẹ́yìn náà pípè.
Ìpele 1: Bíbá Trigger Mu — Ní gbogbo ìgbà tí olùlò bá fi ìránṣẹ́ ránṣẹ́, Nebo ń yẹ gbogbo ọgbọ́n tí a forúkọ sílẹ̀ wò fún ìbámu trigger. Àwọn ọgbọ́n tí ó bá a mu ń hàn gẹ́gẹ́ bí ìtọ́kasí nínú ìtọ́ni ètò. Òṣìṣẹ́ AI ń rí ìtọ́kasí náà, ó sì ń pinnu bóyá yóò pe ọgbọ́n náà.
Ìpele 2: Pípè — Òṣìṣẹ́ AI ń pe ọgbọ́n kan nípa pípe:
skill(name: "code-review") Èyí ń dá gbogbo àwòṣe SKILL.md padà gẹ́gẹ́ bí àbájáde irinṣẹ́, ó ń ṣe àkọsílẹ̀ pípè náà, ó sì ń tún fi àwòṣe náà sínú ìtọ́ni ètò ní àwọn ìyípo tí ó tẹ̀lé e.
TTL àti Ìparí:
- Àwọn ọgbọ́n tí a bá mu fúnra wọn: ìyípo àìṣiṣẹ́ 4 (a lè ṣàtúnṣe rẹ̀ nípasẹ̀
max_turns) - Àwọn ọgbọ́n tí a gbé wọlé fúnra ẹni: ìyípo àìṣiṣẹ́ 6
- Pípè lẹ́ẹ̀kan sí i ń tún aago náà bẹ̀rẹ̀
- Òdiwọ̀n líle: ọgbọ́n 4 tí ń ṣiṣẹ́ ní pọ̀ jù fún ìgbà ìjíròrò kan
- Ìnáwó token: àkóónú àpapọ̀ àwọn ọgbọ́n tí ń ṣiṣẹ́ kò lè ju àmì 16,000 lọ
Ṣíṣàkóso Àwọn Ọgbọ́n
Òṣìṣẹ́ AI lè ṣàkóso àwọn ọgbọ́n nípasẹ̀ irinṣẹ́ skill:
| Action | Àpèjúwe | Àpẹẹrẹ |
|---|---|---|
catalog | Ṣe àtòjọ gbogbo ọgbọ́n tí ó wà | skill(action: "catalog") |
load | Mú un ṣiṣẹ́ fún ìgbà ìjíròrò yìí | skill(name: "code-review", action: "load") |
unload | Dá ọgbọ́n kan dúró | skill(name: "code-review", action: "unload") |
create | Ṣẹ̀dá ọgbọ́n tuntun sórí disk | skill(action: "create", content: "...") |
update | Ṣe àtúnṣe ọgbọ́n tí ó wà tẹ́lẹ̀ | skill(name: "my-skill", action: "update", content: "...") |
delete | Pa ọgbọ́n kan rẹ́ kúrò lórí disk | skill(name: "my-skill", action: "delete") |
Kíkọ Àwọn Ọgbọ́n Rere
Àwòṣe ọgbọ́n rere ní:
- Àkọlé tí ó ṣe kedere — ó ń sọ fún òṣìṣẹ́ AI ipò tí ó wà
- Àwọn ìlànà pàtàkì — àwọn òfin ìwà tí kò ṣeé dúnàádúrà
- Ọ̀nà iṣẹ́ — ọ̀nà ìgbésẹ̀-ìgbésẹ̀ fún àwọn ipò tí ó wọ́pọ̀
- Àwọn àpẹẹrẹ — àpẹẹrẹ gidi láti ìránṣẹ́ olùlò sí ìdáhùn
- Àwọn àpẹẹrẹ òdì — ohun tí a KÒ gbọ́dọ̀ ṣe (àwọn àwòṣe ń kọ́ ẹ̀kọ́ dáadáa láti inú àpẹẹrẹ òdì)
Ìmọ̀ràn: Ọgbọ́n kọ̀ọ̀kan yẹ kí ó ṣe ohun kan dáadáa. Má ṣe ṣẹ̀dá ọgbọ́n "ìṣètò kọ̀ǹpútà gbogbogbòò" — ṣẹ̀dá code-review, debugging, api-design gẹ́gẹ́ bí ọgbọ́n ọ̀tọ̀ọ̀tọ̀. Òṣìṣẹ́ AI lè ní ọ̀pọ̀ tí ń ṣiṣẹ́ lẹ́ẹ̀kan náà.
Àwọn Ọgbọ́n Tí Ó Wà Pẹ̀lú Rẹ̀
Nebo ń jáde pẹ̀lú àwọn ọgbọ́n tí ó bo àwọn ọ̀nà ìlò tí ó wọ́pọ̀:
| Ọgbọ́n | Ipò àkọ́kọ́ | Àpèjúwe |
|---|---|---|
onboarding | 100 | Kíkí olùlò tuntun àti gbígba ìsọfúnni profaili |
best-friend | 50 | Ọgbọ́n ìwà — ọ̀rọ̀ tí ó rọrùn, olóòótọ́, ojúlówó |
debugging | 25 | Ọ̀nà ìtúnṣe àṣìṣe tí ó létòlétò |
api-design | 15 | Àwọn ìṣe tí ó dára jù fún àpẹẹrẹ RESTful API |
code-review | 10 | Àyẹ̀wò kóòdù tí ó létòlétò pẹ̀lú àwọn ìpele bí ó ṣe le tó |
database-expert | 10 | Àpẹẹrẹ ibi ìpamọ́ dátà, àwọn query, ìmúdára |
git-workflow | 10 | Ẹ̀ka Git, àwọn commit, àwọn ìlànà iṣẹ́ PR |
security-audit | 10 | Àtúpalẹ̀ ààbò àti ṣíṣàwárí àìlágbára |
Àwọn wọ̀nyí jẹ́ ìpìlẹ̀ tí ó wúlò àti àpẹẹrẹ ìtọ́kasí fún ṣíṣẹ̀dá àwọn ọgbọ́n tìrẹ.
Ìtọ́kasí
Àwọn Fáìlì Proto
Àwọn fáìlì proto wà nínú proto/apps/v0/. Àwọn SDK ń jáde pẹ̀lú kóòdù tí a ti ṣẹ̀dá tẹ́lẹ̀, nítorí náà o kò nílò protoc fún ìgbéejáde déédéé.
| Fáìlì | Iṣẹ́ | Àwọn RPC pàtàkì |
|---|---|---|
v0/common.proto | (àwọn ìránṣẹ́ nìkan) | 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 |
Gbogbo iṣẹ́ ní àwọn RPC HealthCheck àti Configure. SDK náà ń bójú tó méjèèjì fúnra rẹ̀.
Àwọn Irú Proto Ìkànnì
| Irú Ìránṣẹ́ | Àpèjúwe |
|---|---|
ChannelSendRequest | Àpò-ìwé ìránṣẹ́ tí ó jáde pẹ̀lú message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | ID ìránṣẹ́ pẹpẹ fún ìtẹ̀léra ìjíròrò |
InboundMessage | Àpò-ìwé ìránṣẹ́ tí ó wọlé pẹ̀lú gbogbo àwọn pápá àjọlò + àkókò |
MessageSender | Ìdánimọ̀ bot (name, role, botId) — alágbàtà ló ń fi kún un |
Attachment | Àsomọ́ fáìlì/àwòrán/ìró (type, url, filename, size) |
MessageAction | Action bọ́tìnnì/kíbọ́ọ̀dù ìbáṣepọ̀ (label, callback_id) |
Ìdánimọ̀ Bot àti Àwọn Ipa
Àwọn bot Nebo ní àpẹẹrẹ ìdánimọ̀ onígun mẹ́ta:
- creature — Ohun tí bot náà jẹ́ (àwòkọ́ṣe): "Onímọ̀ràn tí ọpọlọ rẹ̀ yá", "Olùwádìí tí ó fara balẹ̀"
- role — Bí ó ṣe jọmọ́ olùlò (ìbáṣepọ̀): "Ọ̀rẹ́", "COO", "Olùtọ́nisọ́nà"
- vibe — Agbára rẹ̀ (ọ̀nà ìbánisọ̀rọ̀): "Ó jẹ́ jẹ́jẹ́ ṣùgbọ́n ó ní èrò tirẹ̀", "Ó lọ́yàyà, ó sì ń fúnni ní ìṣírí"
Nígbà tí plugin ìkànnì rẹ bá gba ìránṣẹ́ tí ó jáde, pápá sender ní name àti role bot náà. Lo èyí láti ṣe orúkọ ìfihàn fún pẹpẹ rẹ. Ipa náà kì í ṣe orúkọ ipò iṣẹ́ — ó jẹ́ àpèjúwe ìbáṣepọ̀. "Ọ̀rẹ́", "Ọmọkùnrin", àti "Olùtọ́nisọ́nà" jẹ́ ipa tí ó tọ́ lẹ́gbẹ̀ẹ́ "COO" àti "DevLead".