አጠቃላይ እይታ
Nebo ምንድን ነው
Nebo የግል የኮምፒውተር ኤአይ ረዳት ነው፤ ዲጂታል ሕይወትዎን የሚያስተዳድር ሁልጊዜ የሚሠራ የኤአይ ሰራተኛ። Neboን ስለ ስማርትፎን በሚያስቡበት መንገድ ያስቡት፤ በመተግበሪያዎቹ አማካኝነት ሕይወትን የሚለውጥ ጠንካራ መድረክ።
በራሱ፣ Nebo ትውስታ፣ ፕሮግራም ማውጣት፣ ድረ ገጽ ማሰስ፣ የፋይል አስተዳደርና የshell መዳረሻ ያለው ብቁ የኤአይ ሰራተኛ ነው። እውነተኛው ቁልፍ ግን መተግበሪያዎች ናቸው። የስማርትፎን ኃይል ከመተግበሪያ ሥነ ምህዳሩ እንደሚመጣ፣ የNebo ኃይልም ሊሠራ የሚችለውን ከሚያሰፉት መተግበሪያዎች ይመጣል።
መተግበሪያዎች ምንድን ናቸው
የNebo መተግበሪያዎች ራሳቸውን የቻሉ፣ አስቀድመው የተጠናቀሩ አስደናቂ ተግባራዊነት ያላቸው ክፍሎች ናቸው። እያንዳንዱ መተግበሪያ ለNebo አዲስ ልዕለ ኃይል ይሰጠዋል፤ የቀን መቁጠሪያ አስተዳደር፣ ኢሜይሎችን መለየት፣ የፕሮጀክት ክትትል፣ የቤት ራስ-ሰር አሠራር፣ የፋይናንስ ትንታኔ፤ ገንቢ የሚያስበው ማንኛውም ነገር።
መተግበሪያዎች አስደናቂ ኃይልን በጣም ደህንነቱ በተጠበቀ መንገድ ይሰጣሉ። እያንዳንዱ መተግበሪያ በነባሪ ሁሉን በሚከለክሉ ፈቃዶች በsandbox ውስጥ ይሠራል። ሊደርስበት የሚችለው ማኒፌስቱ ያወጀውንና ተጠቃሚው ያጸደቀውን ብቻ ነው።
በይነገጹ 100% በውይይት ላይ የተመሠረተ ነው። ተጠቃሚዎች ከመተግበሪያዎች ጋር በተለዩ ማያ ገጾች ወይም ዳሽቦርዶች አይገናኙም። Neboን ያነጋግራሉ፣ Nebo ደግሞ ነገሮችን ለማከናወን የመተግበሪያውን መሣሪያዎች ይጠቀማል። "ነገ በቀን መቁጠሪያዬ ላይ ምን አለ?" — Nebo የቀን መቁጠሪያ መተግበሪያውን ይጠራል። "ከSarah ጋር በ3 ሰዓት ስብሰባ ፍጠር" — Nebo የቀን መቁጠሪያ መተግበሪያውን ይጠራል። ተጠቃሚው ከውይይቱ በፍጹም አይወጣም።
መተግበሪያዎች እንደ አማራጭ የቅንብሮች UI ሊሰጡ ይችላሉ፤ በNebo አብሮገነብ የአሳሽ መስኮት ውስጥ የሚከፈት የማዋቀሪያ ፓነል። ተጠቃሚዎች የAPI ቁልፎችን የሚያስገቡት፣ ባህሪያትን የሚያበሩና የሚያጠፉት፣ መተግበሪያውንም የሚያዋቅሩት እዚህ ነው። የቅንብሮች UI የሚመራው በማኒፌስቱ ውስጥ ባለው settings ድርድር ነው (Nebo ቅጹን በራሱ ያሳያል)፣ ወይም መተግበሪያው በui ችሎታ አማካኝነት የራሱን ሙሉ ብጁ UI ሊሰጥ ይችላል።
መተግበሪያዎች የNeboን አብሮገነብ ችሎታዎች ይተካሉ፣ ያሰፋሉም። Nebo ከመሠረታዊ የመድረክ መሣሪያዎች ጋር ይመጣል (የአካባቢ የቀን መቁጠሪያ መዳረሻ፣ ቅጽበታዊ ገጽ እይታዎች፣ ወዘተ)። የቀን መቁጠሪያ መተግበሪያ ሲጭኑ፣ አብሮገነቡን የቀን መቁጠሪያ መሣሪያ ይተካና የበለጠ ሰፊ ይሆናል፤ አካባቢያዊ + ክላውድ + ማሰባሰብ + የተገኝነት ፍተሻ።
የተጠናቀረ-ብቻ ፖሊሲ
Nebo ጥብቅ የተጠናቀረ-ብቻ የተፈጻሚ ፋይል ፖሊሲን ያስፈጽማል። ሁሉም መተግበሪያዎች ቤተኛ የተጠናቀሩ ተፈጻሚ ፋይሎች መሆን አለባቸው።
| ሁኔታ | ቋንቋዎች |
|---|---|
| የሚደገፉ | Go (የሚመከር)፣ Rust፣ C/C++፣ Zig |
| ውድቅ የተደረጉ | Python፣ Node.js፣ Ruby፣ Java፣ .NET፣ የshell ስክሪፕቶች |
ምክንያት፡
- ኤአይ ራሱን እንዳያሻሽል መከላከል — የshell መዳረሻ ያለው የኤአይ ሰራተኛ በሚሠራበት ጊዜ የተተረጎመ ስክሪፕትን ባህሪ ሊለውጥ ይችላል። የተጠናቀሩ ተፈጻሚ ፋይሎች ከተፈረሙ በኋላ ሊለወጡ አይችሉም።
- የፊርማ ታማኝነት — የEd25519 ፊርማዎች ጥሬ የተፈጻሚ ፋይል ባይቶችን ይሸፍናሉ። የተፈረመ ተፈጻሚ ፋይል ፊርማውን ሳያበላሽ ሊለወጥ አይችልም።
- የsandbox አፈጻጸም — የተፈጻሚ ፋይል ቅርጸት ማረጋገጫ (የELF/Mach-O/PE magic bytes) ፈጣንና አስተማማኝ በር ነው።
ፈጣን ጅምር
SDKውን ይጫኑ
ይፋዊ SDKዎች የgRPC አገልጋይ ማዋቀርን፣ የሲግናል አያያዝንና የፕሮቶኮል ድልድይን ሁሉ ይይዛሉ። እርስዎ የhandler በይነገጾችን መተግበር ብቻ ነው የሚጠበቅብዎ።
Go (የሚመከር)፡
go get github.com/neboloop/nebo-sdk-go Rust (በቅርቡ)፡
# Coming soon
[dependencies]
nebo-sdk = "0.1" C/C++ (በቅርቡ)፡
# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/ የመተግበሪያ ማውጫ መዋቅር
መተግበሪያዎች በNebo የውሂብ ማውጫዎ ውስጥ ባለው apps/ ንዑስ ማውጫ ውስጥ ይኖራሉ፡
~/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ይጻፉ - SDKውን ይጫኑ (
go get github.com/neboloop/nebo-sdk-go) - ለችሎታዎ የhandler በይነገጹን ይተግብሩ (
ToolHandler፣ChannelHandler፣ ወዘተ) - handlerውን ያስመዝግቡና
app.Run()ን ይጥሩ - ቤተኛ ተፈጻሚ ፋይል ይገንቡ (
go build -o binary .) - ተፈጻሚ ፋይሉን + manifest.json + TOOL.mdን በ
apps/<your-app-id>/ማውጫ ውስጥ ያስቀምጡ - Nebo በራሱ ያገኘዋል፣ ያስጀምረዋልም
ማዋቀር
manifest.json
እያንዳንዱ መተግበሪያ manifest.json ያስፈልገዋል፡
{
"id": "com.example.myapp",
"name": "My App",
"version": "1.0.0",
"description": "What this app does",
"runtime": "local",
"protocol": "grpc",
"provides": ["tool:my_tool"],
"permissions": ["network:outbound"],
"settings": [
{
"key": "api_key",
"title": "API Key",
"type": "password",
"required": true,
"description": "Your API key for the service",
"secret": true
}
]
} የሚያስፈልጉ መስኮች፡
| መስክ | መግለጫ |
|---|---|
id | የተገላቢጦሽ የጎራ መለያ (ለምሳሌ፣ com.mycompany.myapp) |
name | ሰው ሊያነበው የሚችል ስም |
version | የSemver ሕብረ ቁምፊ |
provides | ቢያንስ አንድ ችሎታ (ከታች ይመልከቱ) |
አማራጭ መስኮች፡
| መስክ | ነባሪ | መግለጫ |
|---|---|---|
runtime | "local" | "local" ወይም "remote" |
protocol | "grpc" | የሚደገፈው "grpc" ብቻ ነው |
permissions | [] | መተግበሪያው መዳረሻ የሚያስፈልገው |
description | "" | በUI ውስጥ ይታያል |
settings | [] | ሊዋቀሩ የሚችሉ ቅንብሮች (በቅንብሮች UI ውስጥ ይታያሉ) |
oauth | [] | የOAuth አቅራቢ መስፈርቶች (ከታች ያለውን የOAuth ክፍል ይመልከቱ) |
ችሎታዎች
መተግበሪያዎ የሚያቀርበውን ያውጁ፡
| ችሎታ | የgRPC አገልግሎት | መግለጫ |
|---|---|---|
gateway | GatewayService | የLLM ሞዴል ማስተላለፊያ |
tool:<name> | ToolService | ለኤአይ ሰራተኛው ስም ያለው መሣሪያ |
channel:<name> | ChannelService | የመልዕክት ቻናል |
comm | CommService | በኤአይ ሰራተኞች መካከል ግንኙነት |
ui | UIService | ከHTTP proxy ጋር ብጁ UI |
schedule | ScheduleService | ብጁ ፕሮግራም ማውጣት |
vision | ToolService | የምስል ማስኬጃ |
browser | ToolService | የአሳሽ ራስ-ሰር አሠራር |
አንድ መተግበሪያ በርካታ ችሎታዎችን ሊያቀርብ ይችላል። ለምሳሌ፣ አንድ መተግበሪያ መሣሪያንም የUI ፓነልንም ሊያቀርብ ይችላል።
ፈቃዶች
ፈቃዶች መተግበሪያው ምን ሊደርስበት እንደሚችል ይቆጣጠራሉ። በነባሪ ይከለከላል፤ ካልታወጀ መተግበሪያው ሊጠቀምበት አይችልም።
| ቅድመ ቅጥያ | ምሳሌዎች | መግለጫ |
|---|---|---|
network: | network:outbound፣ network:* | የአውታረ መረብ መዳረሻ |
filesystem: | filesystem:read፣ filesystem:write | የፋይል ሥርዓት መዳረሻ |
memory: | memory:read፣ memory:write | የኤአይ ሰራተኛ ትውስታ መዳረሻ |
session: | session:read | የውይይት ክፍለ ጊዜዎች |
tool: | tool:shell፣ tool:file | ሌሎች መሣሪያዎችን መጠቀም |
shell: | shell:exec | የshell ትዕዛዝ ማስኬድ |
channel: | channel:send፣ channel:* | የቻናል ክዋኔዎች |
comm: | comm:send፣ comm:* | በኤአይ ሰራተኞች መካከል ግንኙነት |
model: | model:chat | የኤአይ ሞዴል መዳረሻ |
user: | user:token | በጥያቄዎች ውስጥ የተጠቃሚ JWT መቀበል |
schedule: | schedule:create | የcron ሥራ አስተዳደር |
database: | database:query | የውሂብ ጎታ መዳረሻ |
storage: | storage:read፣ storage:write | ቋሚ ማከማቻ |
context: | context:read | የኤአይ ሰራተኛ አውድ መዳረሻ |
subagent: | subagent:spawn | የንዑስ ኤጀንት ክዋኔዎች |
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:* | የOAuth ቶከን መዳረሻ |
settings: | settings:read | የቅንብሮች መዳረሻ |
capability: | capability:register | የችሎታ ምዝገባ |
የwildcard ፈቃዶች ይደገፋሉ፤ network:* ማንኛውንም የnetwork: ፈቃድ ፍተሻ ያሟላል።
ቅንብሮች
ቅንብሮች በNebo UI ውስጥ በመተግበሪያው የቅንብሮች ፓነል ስር ይታያሉ። Nebo በውሂብ ጎታው ውስጥ ያከማቻቸዋል፣ ሲለወጡም በConfigure RPC በኩል ወደ መተግበሪያዎ ይልካቸዋል።
የቅንብሮችዎ 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 አቅራቢ መስፈርቶችን ማወጅ ይችላሉ። የNebo OAuth broker ሙሉውን ሂደት ይይዛል፤ መተግበሪያዎች ቶከኖችን በConfigure RPC በኩል በራሳቸው ይቀበላሉ።
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | መስክ | መግለጫ |
|---|---|
provider | የOAuth አቅራቢ፡ "google"፣ "microsoft"፣ "github" |
scopes | መተግበሪያው የሚያስፈልጉት የOAuth scopes ድርድር |
ተጠቃሚው መተግበሪያውን ሲጭን Nebo የሚያስፈልጉትን የOAuth scopes እንዲፈቅድ ይጠይቀዋል። መተግበሪያው የOAuth ሂደቱን ራሱ ሳይይዝ የታደሱ ቶከኖችን በConfigure RPC በኩል ይቀበላል።
የአካባቢ ተለዋዋጮች
የመተግበሪያዎ ሂደት የጸዳ አካባቢ ይቀበላል። ሁሉም ምስጢሮች ይወገዳሉ። የሚያገኙት፡
| ተለዋዋጭ | እሴት |
|---|---|
NEBO_APP_DIR | የመተግበሪያው የመጫኛ ማውጫ |
NEBO_APP_SOCK | የሚፈጠረው የUnix socket ዱካ |
NEBO_APP_ID | ከማኒፌስቱ የመተግበሪያ ID |
NEBO_APP_NAME | ከማኒፌስቱ የመተግበሪያ ስም |
NEBO_APP_VERSION | ከማኒፌስቱ የመተግበሪያ ስሪት |
NEBO_APP_DATA | ወደ መተግበሪያው data/ ማውጫ የሚወስድ ዱካ |
PATH | የሥርዓት PATH (እንዳለ የሚተላለፍ) |
HOME | የተጠቃሚ መነሻ ማውጫ (እንዳለ የሚተላለፍ) |
TMPDIR | ጊዜያዊ ማውጫ (እንዳለ የሚተላለፍ) |
ወሳኝ፡ ተፈጻሚ ፋይልዎ በNEBO_APP_SOCK ላይ ባለው Unix socket ላይ የሚያዳምጥ የgRPC አገልጋይ መፍጠር አለበት። Nebo ይህ socket እስኪታይ ድረስ እስከ 10 ሰከንዶች ይጠብቃል።
የመተግበሪያ ማስጀመሪያ ቅደም ተከተል
- Nebo
manifest.jsonን ያነባል፣ ያረጋግጠዋልም - በመተግበሪያ ማውጫው ውስጥ
binaryወይምappተፈጻሚ ፋይልን ያገኛል - የ
.quarantinedምልክትን ይፈትሻል (በquarantine ያሉ መተግበሪያዎችን ለማስጀመር እምቢ ይላል) - የመሻሪያ ፍተሻ (በNeboAI ለሚሰራጩ መተግበሪያዎች ብቻ)
- የፊርማ ማረጋገጫ (በNeboAI ለሚሰራጩ መተግበሪያዎች ብቻ፣ በdev ሁነታ ይዘለላል)
- የተፈጻሚ ፋይል ማረጋገጫ (symlinksን፣ ስክሪፕቶችን፣ ተፈጻሚ ያልሆኑትንና ከመጠን በላይ ትላልቅ ፋይሎችን ውድቅ ያደርጋል)
- ከቀድሞው ሩጫ የቀረውን የቆየ socket ያጸዳል
- ለsandbox ማከማቻ
data/ማውጫን ይፈጥራል - ለእያንዳንዱ መተግበሪያ የምዝግብ ማስታወሻ ፋይሎችን ያዘጋጃል (
logs/stdout.log፣logs/stderr.log) - ተፈጻሚ ፋይሉን በጸዳ አካባቢና በሂደት ቡድን ማግለል ያስጀምራል
- የUnix socket እስኪታይ ይጠብቃል (exponential backoff፣ ቢበዛ 10 ሰከንዶች)
- በUnix socket ላይ በgRPC በኩል ይገናኛል
- በ
providesላይ ተመሥርቶ ለችሎታዎቹ የተለዩ የgRPC ደንበኞችን ይፈጥራል - የጤና ፍተሻ ያካሂዳል
- ችሎታዎቹን ከኤአይ ሰራተኛው ጋር ያስመዘግባል (መሣሪያዎች፣ gateway፣ comm፣ ወዘተ)
የመሣሪያ መተግበሪያዎች
በማኒፌስትዎ ውስጥ "provides": ["tool:my_tool_name"]ን ያውጁ።
የSTRAP ቅጥ
ሁሉም የNebo የመሣሪያ መተግበሪያዎች ለschemaቸውና ለአፈጻጸም ማስተላለፊያቸው STRAP (Single Tool Resource Action Pattern)ን መጠቀም አለባቸው። Nebo ከ35 በላይ የተለያዩ መሣሪያዎችን ወደ 4 የዘርፍ መሣሪያዎች ለማጠቃለል በውስጥ የሚጠቀመው ያው ቅጥ ነው፤ የLLM አውድ ጫናን በ~80% ይቀንሳል።
ዋናው ሐሳብ፡ በርካታ መሣሪያዎችን (get_events፣ check_availability፣ suggest_slots) ከማስመዝገብ ይልቅ፣ ወደ ትክክለኛው handler የሚያስተላልፉ action (እና እንደ አማራጭ resource) መስኮች ያሉት አንድ መሣሪያ ያስመዝግቡ።
ባለአንድ ሀብት ምሳሌ (የቀን መቁጠሪያ)፡
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) ያክሉ መሣሪያዎ በርካታ የተለያዩ የሀብት ዓይነቶችን የሚያስተዳድር ከሆነ ብቻ- ሌሎቹ መስኮች ሁሉ ለየድርጊቱ የተለዩ መለኪያዎች ናቸው
- የ
actionenum መግለጫ ሁሉንም ያሉትን ድርጊቶች መዘርዘር አለበት
STRAP ለምን አስፈላጊ ነው፡
- LLMዎች የ
actionማስተላለፊያ ቅጥን አንድ ጊዜ ይማራሉ፣ ለሁሉም ክዋኔዎችም ያጠቃልሉታል - የመሣሪያ ትርጓሜዎች ~6% አውድ ይበላሉ፤ STRAP ያንን በ80% ይቀንሰዋል
- አዳዲስ ክዋኔዎች የenum ጭማሪዎች ብቻ ናቸው እንጂ አዳዲስ የመሣሪያ ምዝገባዎች አይደሉም
- በተስተናገዱም ሆነ በአካባቢ ሞዴሎች ላይ በተመሳሳይ ይሠራል
የGo ምሳሌ — የካልኩሌተር መሣሪያ
package main
import (
"context"
"encoding/json"
"fmt"
"log"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Calculator struct{}
func (c *Calculator) Name() string { return "calculator" }
func (c *Calculator) Description() string { return "Performs arithmetic calculations." }
func (c *Calculator) Schema() json.RawMessage {
return nebo.NewSchema("add", "subtract", "multiply", "divide").
Number("a", "First operand", true).
Number("b", "Second operand", true).
Build()
}
func (c *Calculator) Execute(_ context.Context, input json.RawMessage) (string, error) {
var in struct {
Action string `json:"action"`
A float64 `json:"a"`
B float64 `json:"b"`
}
if err := json.Unmarshal(input, &in); err != nil {
return "", fmt.Errorf("invalid input: %w", err)
}
var result float64
switch in.Action {
case "add":
result = in.A + in.B
case "subtract":
result = in.A - in.B
case "multiply":
result = in.A * in.B
case "divide":
if in.B == 0 {
return "", fmt.Errorf("division by zero")
}
result = in.A / in.B
default:
return "", fmt.Errorf("unknown action: %s", in.Action)
}
return fmt.Sprintf("%g %s %g = %g", in.A, in.Action, in.B, result), nil
}
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterTool(&Calculator{})
log.Fatal(app.Run())
} manifest.json፡
{
"id": "com.example.calculator",
"name": "Calculator",
"version": "1.0.0",
"description": "Arithmetic calculator tool for the agent",
"runtime": "local",
"protocol": "grpc",
"provides": ["tool:calculator"],
"permissions": []
} ይገንቡና ይጫኑ፡
go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/ የRust ምሳሌ
use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;
struct Calculator;
#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }
#[async_trait]
impl ToolHandler for Calculator {
fn name(&self) -> &str { "calculator" }
fn description(&self) -> &str { "Performs arithmetic calculations." }
fn schema(&self) -> Value {
SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
.number("a", "First operand", true)
.number("b", "Second operand", true)
.build()
}
async fn execute(&self, input: Value) -> Result<String, NeboError> {
let i: Input = serde_json::from_value(input)
.map_err(|e| NeboError::Execution(e.to_string()))?;
let r = match i.action.as_str() {
"add" => i.a + i.b,
"subtract" => i.a - i.b,
"multiply" => i.a * i.b,
"divide" => {
if i.b == 0.0 {
return Err(NeboError::Execution("division by zero".into()));
}
i.a / i.b
}
other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
};
Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
NeboApp::new()?.register_tool(Calculator).run().await?;
Ok(())
} የC ምሳሌ
#include <nebo/nebo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static int calculator_execute(const char *input_json, char **output, int *is_error) {
/* Parse JSON, compute result, set *output */
*output = strdup("2 add 3 = 5");
*is_error = 0;
return 0;
}
int main(void) {
const char *actions[] = {"add", "subtract", "multiply", "divide", NULL};
nebo_schema_builder_t *sb = nebo_schema_new(actions);
nebo_schema_number(sb, "a", "First operand", 1);
nebo_schema_number(sb, "b", "Second operand", 1);
char *schema = nebo_schema_build(sb);
nebo_schema_free(sb);
nebo_tool_handler_t calculator = {
.name = "calculator",
.description = "Performs arithmetic calculations.",
.schema = schema,
.execute = calculator_execute,
};
nebo_app_t *app = nebo_app_new();
nebo_app_register_tool(app, &calculator);
int ret = nebo_app_run(app);
free(schema);
return ret;
} የቻናል መተግበሪያዎች
"provides": ["channel:my_channel"]ን እና "permissions": ["channel:send"]ን ያውጁ።
የቻናል መተግበሪያዎች ውጫዊ የመልዕክት መድረኮችን (Telegram፣ Discord፣ Slack፣ ወዘተ) ከNebo የኤአይ ሰራተኛ ጋር ያገናኛሉ። ተጠቃሚ በውጫዊው መድረክ ላይ መልዕክት ሲልክ፣ መተግበሪያዎ በReceive በኩል ወደ Nebo ያስተላልፈዋል። የኤአይ ሰራተኛው መመለስ ሲፈልግ፣ Nebo የመተግበሪያዎን Send ይጠራል።
እንዴት እንደሚሠራ
- Nebo የቻናልዎን ልዩ መለያ ለማግኘት
ID()ን ይጠራል - Nebo ከመተግበሪያዎ ቅንብሮች በተገኘ ውቅር
Connect()ን ይጠራል - Nebo የ
Receive()ዥረት ይከፍታል፤ ተጠቃሚ ለቦቱ መልዕክት በላከ ቁጥር መተግበሪያዎ ገቢ መልዕክቶችን ይልካል - ገቢ መልዕክቶች ወደ ኤአይ ሰራተኛው ዋና የውይይት lane ይተላለፋሉ
- የኤአይ ሰራተኛው መልዕክት መላክ ሲፈልግ፣ Nebo ከv1 የመልዕክት ኤንቨሎፕ ጋር
Send()ን ይጠራል - ሲዘጋ፣ 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 | የቦት ማንነት፤ ስም፣ ሚና፣ botId |
text | string | የመልዕክት አካል |
attachments | array | ፋይሎች፣ ምስሎች፣ ኦዲዮ |
reply_to | UUID v7 | ለክር የወላጅ መልዕክት ID |
actions | array | በይነተገናኝ አዝራሮች/ቁልፍ ሰሌዳዎች |
platform_data | bytes | ለመድረክ-ተኮር ባህሪያት የሚተላለፍ ግልጽ ያልሆነ ውሂብ |
timestamp | ISO 8601 | አሳታሚው ያዘጋጀዋል |
ባለሁለት ንብርብር ንድፍ፡ የጋራ መስኮቹ (text፣ attachments፣ reply_to፣ actions) በሰራተኛ የሚጀመሩ መልዕክቶችን 90% ይሸፍናሉ። መድረክ-ተኮር ባህሪያት ወደ platform_data ይገባሉ፤ ተሰኪዎ ወደ ቤተኛው የመድረክ ቅርጸትና ከእሱ ያዛምዳቸዋል።
የውይይት ዥረቶች
የቻናል መልዕክቶች ለማግለል በየቻናሉ የውይይት ዥረቶች ላይ ይተላለፋሉ፡
neboai/bot/{botID}/channels/{channelType}/inbound # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound # messages from agent → channel የGo ምሳሌ — የTelegram ቻናል
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"time"
"github.com/google/uuid"
tgbot "github.com/go-telegram/bot"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Telegram struct {
bot *tgbot.Bot
messages chan nebo.ChannelEnvelope
cancel context.CancelFunc
}
func (t *Telegram) ID() string { return "telegram" }
func (t *Telegram) Connect(_ context.Context, config map[string]string) error {
token := config["bot_token"]
if token == "" {
return fmt.Errorf("bot_token is required")
}
botCtx, cancel := context.WithCancel(context.Background())
t.cancel = cancel
bot, err := tgbot.New(token, tgbot.WithDefaultHandler(
func(bCtx context.Context, b *tgbot.Bot, update *tgbot.Update) {
if update.Message == nil {
return
}
env := nebo.ChannelEnvelope{
MessageID: uuid.Must(uuid.NewV7()).String(),
ChannelID: fmt.Sprintf("telegram:%d", update.Message.Chat.ID),
Text: update.Message.Text,
Timestamp: time.Unix(int64(update.Message.Date), 0).UTC(),
}
t.messages <- env
},
))
if err != nil {
return err
}
t.bot = bot
go bot.Start(botCtx)
return nil
}
func (t *Telegram) Send(ctx context.Context, env nebo.ChannelEnvelope) (string, error) {
if t.bot == nil {
return "", fmt.Errorf("not connected")
}
chatID := env.ChannelID[len("telegram:"):]
params := &tgbot.SendMessageParams{
ChatID: chatID,
Text: env.Text,
}
msg, err := t.bot.SendMessage(ctx, params)
if err != nil {
return "", err
}
return fmt.Sprintf("%d", msg.MessageID), nil
}
func (t *Telegram) Receive(_ context.Context) (<-chan nebo.ChannelEnvelope, error) {
return t.messages, nil
}
func (t *Telegram) Disconnect(_ context.Context) error {
if t.cancel != nil {
t.cancel()
}
return nil
}
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterChannel(&Telegram{
messages: make(chan nebo.ChannelEnvelope, 100),
})
log.Fatal(app.Run())
} manifest.json፡
{
"id": "com.example.telegram",
"name": "Telegram",
"version": "1.0.0",
"description": "Telegram messaging channel for Nebo",
"runtime": "local",
"protocol": "grpc",
"provides": ["channel:telegram"],
"permissions": ["channel:send", "network:outbound"],
"settings": [
{
"key": "bot_token",
"title": "Bot Token",
"type": "password",
"required": true,
"description": "Telegram bot token from @BotFather",
"secret": true
}
]
} ተጨማሪ ችሎታዎች
የComm መተግበሪያ
"provides": ["comm"]ን እና "permissions": ["comm:*"]ን ያውጁ። የComm መተግበሪያዎች በኤአይ ሰራተኞች መካከል ግንኙነትን ያስችላሉ።
| መስክ | መግለጫ |
|---|---|
from | የላኪው ሰራተኛ ID |
to | የተቀባዩ ሰራተኛ ID |
topic | የመልዕክት ርዕስ/ቻናል |
type | "message"፣ "mention"፣ "proposal"፣ "command"፣ "info"፣ "task" |
content | የመልዕክት አካል |
ዋና ባህሪያት፡
Registerይህን የኤአይ ሰራተኛ ከችሎታዎቹ ጋር በአውታረ መረቡ ላይ ያሳውቃልSubscribe/Unsubscribeየርዕስ ምዝገባዎችን ያስተዳድራሉReceiveገቢ መልዕክቶችን ያስተላልፋል (server-streaming፣ ልክ እንደ ቻናሎች)- በአንድ ጊዜ ንቁ ሊሆን የሚችለው አንድ የcomm መተግበሪያ ብቻ ነው
የGateway መተግበሪያ
የgateway መተግበሪያ የLLM ጥያቄዎችን ወደ ሞዴሎች ያስተላልፋል። "provides": ["gateway"]ን እና "permissions": ["network:outbound", "user:token"]ን ያውጁ።
GatewayRequest መልዕክቶችን፣ መሣሪያዎችን፣ የሥርዓት ትዕዛዝን፣ ከፍተኛ ቶከኖችን፣ temperatureን እና UserContextን (የuser:token ፈቃድ ከተሰጠ የJWT ቶከን) ይዟል።
የGatewayEvent ዓይነቶች፡
| ዓይነት | ይዘት | መግለጫ |
|---|---|---|
"text" | የጽሑፍ ቁራጭ | በዥረት የሚመጣ የጽሑፍ ቶከን |
"tool_call" | JSON | ሞዴሉ መሣሪያ መጥራት ይፈልጋል |
"thinking" | የጽሑፍ ቁራጭ | የተራዘመ ማሰብ/ምክንያታዊነት |
"error" | የስህተት መልዕክት | የሆነ ችግር ተፈጥሯል |
"done" | ባዶ | ዥረቱ ተጠናቋል |
የUI መተግበሪያ
የUI መተግበሪያ በNebo አብሮገነብ የአሳሽ መስኮት ውስጥ የሚከፈት ብጁ የማዋቀሪያ በይነገጽ ያቀርባል። "provides": ["ui"]ን ያውጁ። ከራስ-ሰሩ የቅንብሮች ቅጽ በተለየ (Nebo ከsettings ማኒፌስትዎ የሚያሳየው)፣ የUI መተግበሪያ የራሱን ሙሉ HTML/CSS/JS frontend ያቀርባል።
መተግበሪያዎ ቋሚ የድረ ገጽ ንብረቶችን (HTML፣ CSS፣ JS፤ በተለምዶ index.html ያለው SPA) የያዘ ui/ ማውጫ ይዞ ይመጣል። Nebo እነዚህን ፋይሎች በቀጥታ ያቀርባል፣ የAPI ጥሪዎችንም በgRPC በኩል ወደ መተግበሪያዎ ያስተላልፋል።
| ዱካ | ዘዴ | ዓላማ |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | ቋሚ የፋይል አገልጋይ | ፋይሎችን ከui/ ማውጫዎ ያቀርባል (የSPA fallback ወደ 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 ወደ /api/v1/apps/com.example.dashboard/api/status የfetch ጥሪዎችን ያደርጋል፣ እነሱም ወደ mux handlerዎ ይተላለፋሉ።
የSchedule መተግበሪያ
የschedule መተግበሪያ የNeboን አብሮገነብ የcron ፕሮግራም አውጪ ይተካል። "provides": ["schedule"]ን እና "permissions": ["schedule:create"]ን ያውጁ።
የschedule መተግበሪያዎ ሲጀምር፣ Nebo ሁሉንም ፕሮግራም ማውጣት ከነባሪው የcron ሞተር ይልቅ በመተግበሪያዎ በኩል ያስተላልፋል። መተግበሪያዎ ከተበላሸ፣ Nebo በራሱ ወደ አብሮገነቡ ሞተር ይመለሳል።
- መተግበሪያዎ የፕሮግራሙን ሁኔታ በባለቤትነት ይይዛል፤ የschedule መተግበሪያ ንቁ ሲሆን Nebo ፕሮግራሞችን በራሱ DB ውስጥ አያከማችም
- መደበኛ CRUD፡
Create፣Get፣List፣Update፣Delete፣Enable፣Disable Triggersserver-streaming RPC ነው፤ ፕሮግራም በተቀሰቀሰ ቁጥር መተግበሪያዎ የቀስቃሽ መልዕክት ይልካል- በአንድ ጊዜ ንቁ ሊሆን የሚችለው አንድ የschedule መተግበሪያ ብቻ ነው
ባለብዙ ችሎታ መተግበሪያዎች
አንድ መተግበሪያ በርካታ ችሎታዎችን ሊያቀርብ ይችላል። ለምሳሌ፣ መሣሪያም 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 | ለኤአይ ሰራተኛው የመሣሪያ መመሪያዎች |
በማውጣት ጊዜ የደህንነት ደንቦች፡
- የዱካ መሻገር የለም (
../ውድቅ ይደረጋል) - 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 ሁነታ (የNeboAI URL ካልተዋቀረ)፣ የፊርማ ማረጋገጫ ሙሉ በሙሉ ይዘለላል። ለአካባቢ ልማት signatures.json አያስፈልግዎትም።
ማተም
መተግበሪያዎ በአካባቢ ከሠራ በኋላ፣ ለሁሉም የNebo ተጠቃሚዎች እንዲሰራጭ በNeboAI በኩል ያትሙት።
የገንቢ መለያ ማዋቀር
- የNeboAI መለያ በ
POST /api/v1/owners/registerያስመዝግቡ - የJWT ቶከን ለማግኘት ይግቡ፡
POST /api/v1/owners/login - የገንቢ መለያ ይፍጠሩ፡
POST /api/v1/developer/accounts
የማስገቢያ ሂደት
draft → pending_review → [approved] → published
→ [rejected] → draft (fix and resubmit) ደረጃ 1፡ መተግበሪያውን ይፍጠሩ
curl -X POST https://neboai.com/api/v1/developer/apps \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"name": "My App",
"version": "1.0.0",
"description": "What it does",
"category": "productivity",
"visibility": "public"
}' ደረጃ 2፡ የመድረክ ተፈጻሚ ፋይሎችን ይስቀሉ
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/binaries \
-H "Authorization: Bearer $TOKEN" \
-F "binary=@myapp-darwin-arm64" \
-F "platform=darwin-arm64" ለእያንዳንዱ መድረክ አንድ ተፈጻሚ ፋይል ይስቀሉ፡ darwin-arm64፣ darwin-amd64፣ linux-amd64፣ linux-arm64።
ደረጃ 3፡ ለግምገማ ያስገቡ
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
-H "Authorization: Bearer $TOKEN" የግምገማ ሂደት
- ራስ-ሰር ቅኝት — ተፈጻሚ ፋይሎች በVirusTotal ይቃኛሉ
- የአስተዳዳሪ ግምገማ — የNeboAI ቡድን ሜታዳታውን፣ ማኒፌስቱንና የቅኝት ውጤቶቹን ይገመግማል
- ሲጸድቅ — NeboAI መተግበሪያውን በEd25519 ይፈርማል፣ ያትመዋልም
- ውድቅ ሲደረግ — ምክንያት ይደርስዎታል፣ አስተካክለውም እንደገና ማስገባት ይችላሉ
የታለመ የግምገማ ጊዜ፡ <24 ሰዓታት።
ማሻሻያዎችን መግፋት
- የመተግበሪያውን ስሪት ያዘምኑ፦
PUT /api/v1/developer/apps/{id}ከአዲሱ ስሪት ጋር - ለእያንዳንዱ መድረክ አዳዲስ ተፈጻሚ ፋይሎችን ይስቀሉ
- እንደገና ለግምገማ ያስገቡ
እያንዳንዱ ማሻሻያ በያው የግምገማ ሂደት ያልፋል። አዲሱ ስሪት እስኪጸድቅ ድረስ የቀድሞ ስሪቶች እንደተገኙ ይቆያሉ።
የመደብር ሜታዳታ
| መስክ | መግለጫ |
|---|---|
category | ለምሳሌ፣ productivity፣ communication፣ developer-tools |
icon | የመተግበሪያ አዶ URL |
visibility | public ወይም private |
description | ከማኒፌስቱ መግለጫ የበለጠ ረጅም/የበለጸገ ሊሆን ይችላል |
የልማት የሥራ ፍሰት
የአካባቢ ልማት
ለአካባቢ ልማት ማሸግ አያስፈልግም፡
- የመተግበሪያዎን ማውጫ ይፍጠሩ፦
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp manifest.jsonዎንና ኮድዎን ይጻፉ- ፋይልዎን ይገንቡ፦
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo አዲሱን ማውጫ በራሱ ያገኛል (ወይም Neboን እንደገና ያስጀምሩ)
- ከኮድ ለውጦች በኋላ ተፈጻሚ ፋይሉን እንደገና ይገንቡ፤ የፋይል ተመልካቹ መተግበሪያውን እንደገና ያስጀምረዋል
የምዝግብ ማስታወሻዎችን መመልከት
የመተግበሪያው stdout/stderr በየመተግበሪያው የምዝግብ ማስታወሻ ፋይሎች ውስጥ ይያዛሉ፡
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stdout.log
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stderr.log ቋሚ ውሂብ
መተግበሪያዎ ማቆየት ለሚያስፈልገው ማንኛውም ፋይል data/ ማውጫን (እንደ NEBO_APP_DATA env var ጭምር ይገኛል) ይጠቀሙ። ይህ ማውጫ ከመተግበሪያ ማሻሻያዎችና ከquarantine በኋላም ይቆያል።
የማረሚያ ምክሮች
- መተግበሪያዎ ካልጀመረ፣ ለስህተቶች
logs/stderr.logን ይፈትሹ - ተፈጻሚ ፋይሉ ተፈጻሚ መሆኑን ያረጋግጡ (
chmod +x binary) - ከ
NEBO_APP_SOCKበሚገኘው የUnix socket ዱካ ላይ እያዳመጡ መሆንዎን ያረጋግጡ - 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 በውይይት ጊዜ እንዴት እንደሚሠራ የሚቀርጹ የመመሪያ ስብስቦች ናቸው። ክህሎት ንቁ ሲሆን ይዘቱ በቀጥታ ወደ ሥርዓት ትዕዛዙ ይገባል፤ ለዚያ ክፍለ ጊዜ የኤአይ ሰራተኛውን ቃና፣ ዘዴ፣ የዘርፍ ዕውቀትና የመሣሪያ አጠቃቀም ይመራል።
ክህሎቶች ኮድ አይደሉም። የYAML ሜታዳታ ያላቸው የmarkdown ሰነዶች ናቸው። ማጠናቀር የለም፣ ተፈጻሚ ፋይል የለም፣ gRPC የለም። ክህሎት በአንድ ማውጫ ውስጥ ያለ SKILL.md ፋይል ነው። ያ ብቻ።
ክህሎቶች አውዳዊና ጊዜያዊ ናቸው። አግባብ ሲሆኑ ይነቃሉ (በቀስቃሽ ማዛመድ ወይም በእጅ በመጫን)፣ ለጥቂት ዙሮች ይቆያሉ፣ ሳያስፈልጉም ሲቀሩ ጊዜያቸው ያልፋል። ይህ የኤአይ ሰራተኛውን አውድ ቀጭን ያደርገዋል፤ በትዕዛዙ ውስጥ የሚገኘው አሁን አስፈላጊ የሆነው መመሪያ ብቻ ነው።
ክህሎቶች መተግበሪያዎችን ያሟላሉ። መተግበሪያዎች ተፈጻሚ ችሎታዎችን (መሣሪያዎች፣ ቻናሎች፣ gateways) ይሰጣሉ። ክህሎቶች የማቀናበሪያ መመሪያ ይሰጣሉ፤ እነዚያን መሣሪያዎች በብቃት እንዴት መጠቀም እንደሚቻል። የቀን መቁጠሪያ መተግበሪያ ለNebo ክስተቶችን የማንበብና የመጻፍ ችሎታ ይሰጠዋል። የ"ለስብሰባ መዘጋጀት" ክህሎት ደግሞ ያንን የቀን መቁጠሪያ መተግበሪያ፣ ኢሜይልንና የድረ ገጽ ፍለጋን አብሮ በመጠቀም ለስብሰባዎች እንዴት እንደሚዘጋጅ ለNebo ይነግረዋል።
ክህሎቶች ከመተግበሪያዎች ጋር ሲነጻጸሩ
| ክህሎቶች | መተግበሪያዎች | |
|---|---|---|
| ቅርጸት | Markdown (SKILL.md) | የተጠናቀረ ተፈጻሚ ፋይል (.napp) |
| የአሂድ ጊዜ | ወደ ሥርዓት ትዕዛዙ ይገባል | በgRPC ላይ በsandbox የተገደበ ሂደት |
| የሚያቀርበው | የባህሪ መመሪያ፣ ዘዴ | መሣሪያዎች፣ ቻናሎች፣ የUI ፓነሎች |
| የሕይወት ዘመን | ለክፍለ ጊዜው የተወሰነ፣ በTTL ላይ የተመሠረተ ማብቂያ | ሁልጊዜ የሚሠራ |
| አፈጣጠር | የmarkdown ፋይል ይጻፉ | ይጻፉ፣ ያጠናቅሩ፣ ይፈርሙ፣ ያሽጉ |
| ደህንነት | ፈቃዶች አያስፈልጉም | በነባሪ ሁሉን የሚከለክል 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 አካል (ወደ ሥርዓት ትዕዛዙ የሚገቡት ትክክለኛዎቹ መመሪያዎች)።
| መስክ | የሚያስፈልግ | ነባሪ | መግለጫ |
|---|---|---|---|
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 ሁሉንም የተመዘገቡ ክህሎቶች ለቀስቃሽ ተዛማጆች ይቃኛል። የሚዛመዱ ክህሎቶች በሥርዓት ትዕዛዙ ውስጥ እንደ ፍንጮች ይታያሉ። የኤአይ ሰራተኛው ፍንጩን አይቶ ክህሎቱን ይጥራ ወይም አይጥራ ይወስናል።
ደረጃ 2፡ መጥራት — የኤአይ ሰራተኛው ክህሎትን የሚጠራው እንዲህ በመጥራት ነው፡
skill(name: "code-review") ይህ ሙሉውን የSKILL.md አብነት እንደ መሣሪያ ውጤት ይመልሳል፣ ጥሪውን ይመዘግባል፣ በሚቀጥሉት ዙሮችም አብነቱን እንደገና ወደ ሥርዓት ትዕዛዙ ያስገባል።
TTL እና ማብቂያ፡
- በራሳቸው የተዛመዱ ክህሎቶች፡ 4 ያለ እንቅስቃሴ ዙሮች (በ
max_turnsሊዋቀር ይችላል) - በእጅ የተጫኑ ክህሎቶች፡ 6 ያለ እንቅስቃሴ ዙሮች
- እንደገና መጥራት ሰዓት ቆጣሪውን ዳግም ያስጀምራል
- ጥብቅ ገደብ፡ በአንድ ክፍለ ጊዜ ቢበዛ 4 ንቁ ክህሎቶች
- የቶከን በጀት፡ የተጣመረ ንቁ የክህሎት ይዘት በ16,000 ቁምፊዎች የተገደበ
ክህሎቶችን ማስተዳደር
የኤአይ ሰራተኛው ክህሎቶችን በ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") |
ጥሩ ክህሎቶችን መጻፍ
ጥሩ የክህሎት አብነት የሚከተሉት አሉት፡
- ግልጽ ርዕስ — የኤአይ ሰራተኛው በምን ሁነታ ላይ እንዳለ ይነግረዋል
- ዋና መርሆዎች — የማይደራደሩባቸው የባህሪ ደንቦች
- ዘዴ — ለተለመዱ ሁኔታዎች ደረጃ በደረጃ አቀራረብ
- ምሳሌዎች — ተጨባጭ ከተጠቃሚ መልዕክት ወደ ምላሽ ቅጦች
- መወገድ ያለባቸው ቅጦች — ምን ማድረግ እንደሌለበት (ሞዴሎች ከአሉታዊ ምሳሌዎች በደንብ ይማራሉ)
ምክር፡ እያንዳንዱ ክህሎት አንድን ነገር በደንብ መሥራት አለበት። "አጠቃላይ ፕሮግራሚንግ" ክህሎት አይፍጠሩ፤ code-review፣ debugging፣ api-designን እንደ የተለያዩ ክህሎቶች ይፍጠሩ። የኤአይ ሰራተኛው በርካታዎቹን በአንድ ጊዜ ንቁ ማድረግ ይችላል።
አብረው የሚመጡ ክህሎቶች
Nebo የተለመዱ የአጠቃቀም ሁኔታዎችን ከሚሸፍኑ አብረው የሚመጡ ክህሎቶች ጋር ይመጣል፡
| ክህሎት | ቅድሚያ | መግለጫ |
|---|---|---|
onboarding | 100 | የአዲስ ተጠቃሚ ሰላምታና የመገለጫ መረጃ መሰብሰብ |
best-friend | 50 | የስብዕና ክህሎት፤ ዘና ያለ፣ ታማኝ፣ ግልጽ ንግግር |
debugging | 25 | ስልታዊ የማረሚያ ዘዴ |
api-design | 15 | የRESTful API ንድፍ ምርጥ ልምዶች |
code-review | 10 | ከክብደት ደረጃዎች ጋር የተዋቀረ የኮድ ግምገማ |
database-expert | 10 | የውሂብ ጎታ ንድፍ፣ መጠይቆች፣ ማመቻቸት |
git-workflow | 10 | የGit ቅርንጫፍ፣ 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 |
እያንዳንዱ አገልግሎት HealthCheck እና Configure RPCዎችን ያካትታል። 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 — ጉልበቱ (የአነጋገር ዘይቤ)፡ "ዘና ያለ ግን የራሱ አስተያየት ያለው"፣ "ሞቅ ያለና የሚያበረታታ"
የቻናል ተሰኪዎ የወጪ መልዕክት ሲቀበል፣ የsender መስኩ የቦቱን name እና role ይይዛል። ለመድረክዎ የሚታየውን ስም ለመቅረጽ ይህን ይጠቀሙ። ሚናው የሥራ ማዕረግ አይደለም፤ የግንኙነት ገላጭ ነው። "ጓደኛ"፣ "ልጅ" እና "አማካሪ" ከ"COO" እና "DevLead" ጎን ትክክለኛ ሚናዎች ናቸው።