NeboAI
NeboAI
ይጀምሩ

ለNebo መተግበሪያዎችን ይገንቡ

ለእርስዎ ኤአይ አዳዲስ ልዕለ ኃይሎችን ይስጡት። መሣሪያዎች፣ ቻናሎች፣ መግቢያ በሮች፣ የUI ፓነሎች፤ የሚያስቡት ማንኛውም ነገር፣ ወደ ቤተኛ ተፈጻሚ ፋይል የተጠናቀረ።

አጠቃላይ እይታ

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)

የአነስተኛ መተግበሪያ ማረጋገጫ ዝርዝር

  1. manifest.jsonን ከid፣ name፣ version፣ provides ጋር ይፍጠሩ
  2. የኤአይ ሰራተኛው መሣሪያዎን እንዴት መጠቀም እንዳለበት የሚገልጽ TOOL.md ይጻፉ
  3. SDKውን ይጫኑ (go get github.com/neboloop/nebo-sdk-go)
  4. ለችሎታዎ የhandler በይነገጹን ይተግብሩ (ToolHandler፣ ChannelHandler፣ ወዘተ)
  5. handlerውን ያስመዝግቡና app.Run()ን ይጥሩ
  6. ቤተኛ ተፈጻሚ ፋይል ይገንቡ (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ለኤአይ ሰራተኛው ስም ያለው መሣሪያ
channel:<name>ChannelServiceየመልዕክት ቻናል
commCommServiceበኤአይ ሰራተኞች መካከል ግንኙነት
uiUIServiceከHTTP proxy ጋር ብጁ UI
scheduleScheduleServiceብጁ ፕሮግራም ማውጣት
visionToolServiceየምስል ማስኬጃ
browserToolServiceየአሳሽ ራስ-ሰር አሠራር

አንድ መተግበሪያ በርካታ ችሎታዎችን ሊያቀርብ ይችላል። ለምሳሌ፣ አንድ መተግበሪያ መሣሪያንም የ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 ሰከንዶች ይጠብቃል።

የመተግበሪያ ማስጀመሪያ ቅደም ተከተል

  1. Nebo manifest.jsonን ያነባል፣ ያረጋግጠዋልም
  2. በመተግበሪያ ማውጫው ውስጥ binary ወይም app ተፈጻሚ ፋይልን ያገኛል
  3. የ.quarantined ምልክትን ይፈትሻል (በquarantine ያሉ መተግበሪያዎችን ለማስጀመር እምቢ ይላል)
  4. የመሻሪያ ፍተሻ (በNeboAI ለሚሰራጩ መተግበሪያዎች ብቻ)
  5. የፊርማ ማረጋገጫ (በNeboAI ለሚሰራጩ መተግበሪያዎች ብቻ፣ በdev ሁነታ ይዘለላል)
  6. የተፈጻሚ ፋይል ማረጋገጫ (symlinksን፣ ስክሪፕቶችን፣ ተፈጻሚ ያልሆኑትንና ከመጠን በላይ ትላልቅ ፋይሎችን ውድቅ ያደርጋል)
  7. ከቀድሞው ሩጫ የቀረውን የቆየ socket ያጸዳል
  8. ለsandbox ማከማቻ data/ ማውጫን ይፈጥራል
  9. ለእያንዳንዱ መተግበሪያ የምዝግብ ማስታወሻ ፋይሎችን ያዘጋጃል (logs/stdout.log፣ logs/stderr.log)
  10. ተፈጻሚ ፋይሉን በጸዳ አካባቢና በሂደት ቡድን ማግለል ያስጀምራል
  11. የUnix socket እስኪታይ ይጠብቃል (exponential backoff፣ ቢበዛ 10 ሰከንዶች)
  12. በUnix socket ላይ በgRPC በኩል ይገናኛል
  13. በprovides ላይ ተመሥርቶ ለችሎታዎቹ የተለዩ የgRPC ደንበኞችን ይፈጥራል
  14. የጤና ፍተሻ ያካሂዳል
  15. ችሎታዎቹን ከኤአይ ሰራተኛው ጋር ያስመዘግባል (መሣሪያዎች፣ 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 ደንቦች፡

  1. ሁልጊዜ action መስክን እንደ አስፈላጊ የstring enum ያካትቱ
  2. resource መስክን (አስፈላጊ የstring enum) ያክሉ መሣሪያዎ በርካታ የተለያዩ የሀብት ዓይነቶችን የሚያስተዳድር ከሆነ ብቻ
  3. ሌሎቹ መስኮች ሁሉ ለየድርጊቱ የተለዩ መለኪያዎች ናቸው
  4. የaction enum መግለጫ ሁሉንም ያሉትን ድርጊቶች መዘርዘር አለበት

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 ይጠራል።

እንዴት እንደሚሠራ

  1. Nebo የቻናልዎን ልዩ መለያ ለማግኘት ID()ን ይጠራል
  2. Nebo ከመተግበሪያዎ ቅንብሮች በተገኘ ውቅር Connect()ን ይጠራል
  3. Nebo የReceive() ዥረት ይከፍታል፤ ተጠቃሚ ለቦቱ መልዕክት በላከ ቁጥር መተግበሪያዎ ገቢ መልዕክቶችን ይልካል
  4. ገቢ መልዕክቶች ወደ ኤአይ ሰራተኛው ዋና የውይይት lane ይተላለፋሉ
  5. የኤአይ ሰራተኛው መልዕክት መላክ ሲፈልግ፣ Nebo ከv1 የመልዕክት ኤንቨሎፕ ጋር Send()ን ይጠራል
  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 v7በጊዜ የተደረደረ ልዩ ID
channel_id{type}:{platform_id}ሊተላለፍ የሚችል የቻናል መለያ
senderobjectየቦት ማንነት፤ ስም፣ ሚና፣ botId
textstringየመልዕክት አካል
attachmentsarrayፋይሎች፣ ምስሎች፣ ኦዲዮ
reply_toUUID v7ለክር የወላጅ መልዕክት ID
actionsarrayበይነተገናኝ አዝራሮች/ቁልፍ ሰሌዳዎች
platform_databytesለመድረክ-ተኮር ባህሪያት የሚተላለፍ ግልጽ ያልሆነ ውሂብ
timestampISO 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
  • Triggers server-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.json1 MBየመተግበሪያ ሜታዳታ
binary ወይም app500 MBተፈጻሚ ፋይል
signatures.json1 MBየEd25519 ፊርማዎች
TOOL.md1 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 በኩል ያትሙት።

የገንቢ መለያ ማዋቀር

  1. የNeboAI መለያ በPOST /api/v1/owners/register ያስመዝግቡ
  2. የ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 ቡድን ሜታዳታውን፣ ማኒፌስቱንና የቅኝት ውጤቶቹን ይገመግማል
  3. ሲጸድቅ — NeboAI መተግበሪያውን በEd25519 ይፈርማል፣ ያትመዋልም
  4. ውድቅ ሲደረግ — ምክንያት ይደርስዎታል፣ አስተካክለውም እንደገና ማስገባት ይችላሉ

የታለመ የግምገማ ጊዜ፡ <24 ሰዓታት።

ማሻሻያዎችን መግፋት

  1. የመተግበሪያውን ስሪት ያዘምኑ፦ PUT /api/v1/developer/apps/{id} ከአዲሱ ስሪት ጋር
  2. ለእያንዳንዱ መድረክ አዳዲስ ተፈጻሚ ፋይሎችን ይስቀሉ
  3. እንደገና ለግምገማ ያስገቡ

እያንዳንዱ ማሻሻያ በያው የግምገማ ሂደት ያልፋል። አዲሱ ስሪት እስኪጸድቅ ድረስ የቀድሞ ስሪቶች እንደተገኙ ይቆያሉ።

የመደብር ሜታዳታ

መስክመግለጫ
categoryለምሳሌ፣ productivity፣ communication፣ developer-tools
iconየመተግበሪያ አዶ URL
visibilitypublic ወይም private
descriptionከማኒፌስቱ መግለጫ የበለጠ ረጅም/የበለጸገ ሊሆን ይችላል

የልማት የሥራ ፍሰት

የአካባቢ ልማት

ለአካባቢ ልማት ማሸግ አያስፈልግም፡

  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. ከኮድ ለውጦች በኋላ ተፈጻሚ ፋይሉን እንደገና ይገንቡ፤ የፋይል ተመልካቹ መተግበሪያውን እንደገና ያስጀምረዋል

የምዝግብ ማስታወሻዎችን መመልከት

የመተግበሪያው 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")

ጥሩ ክህሎቶችን መጻፍ

ጥሩ የክህሎት አብነት የሚከተሉት አሉት፡

  1. ግልጽ ርዕስ — የኤአይ ሰራተኛው በምን ሁነታ ላይ እንዳለ ይነግረዋል
  2. ዋና መርሆዎች — የማይደራደሩባቸው የባህሪ ደንቦች
  3. ዘዴ — ለተለመዱ ሁኔታዎች ደረጃ በደረጃ አቀራረብ
  4. ምሳሌዎች — ተጨባጭ ከተጠቃሚ መልዕክት ወደ ምላሽ ቅጦች
  5. መወገድ ያለባቸው ቅጦች — ምን ማድረግ እንደሌለበት (ሞዴሎች ከአሉታዊ ምሳሌዎች በደንብ ይማራሉ)

ምክር፡ እያንዳንዱ ክህሎት አንድን ነገር በደንብ መሥራት አለበት። "አጠቃላይ ፕሮግራሚንግ" ክህሎት አይፍጠሩ፤ code-review፣ debugging፣ api-designን እንደ የተለያዩ ክህሎቶች ይፍጠሩ። የኤአይ ሰራተኛው በርካታዎቹን በአንድ ጊዜ ንቁ ማድረግ ይችላል።

አብረው የሚመጡ ክህሎቶች

Nebo የተለመዱ የአጠቃቀም ሁኔታዎችን ከሚሸፍኑ አብረው የሚመጡ ክህሎቶች ጋር ይመጣል፡

ክህሎትቅድሚያመግለጫ
onboarding100የአዲስ ተጠቃሚ ሰላምታና የመገለጫ መረጃ መሰብሰብ
best-friend50የስብዕና ክህሎት፤ ዘና ያለ፣ ታማኝ፣ ግልጽ ንግግር
debugging25ስልታዊ የማረሚያ ዘዴ
api-design15የRESTful API ንድፍ ምርጥ ልምዶች
code-review10ከክብደት ደረጃዎች ጋር የተዋቀረ የኮድ ግምገማ
database-expert10የውሂብ ጎታ ንድፍ፣ መጠይቆች፣ ማመቻቸት
git-workflow10የGit ቅርንጫፍ፣ 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

እያንዳንዱ አገልግሎት 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" ጎን ትክክለኛ ሚናዎች ናቸው።