NeboAI
NeboAI
શરૂ કરો

Nebo માટે ઍપ્સ બનાવો

તમારા AI ને નવી સુપરપાવર આપો. સાધનો, ચૅનલ્સ, ગેટવે, UI પૅનલ — તમે કલ્પી શકો તે કંઈ પણ, નેટિવ બાઇનરીમાં કમ્પાઇલ કરેલું.

ઝાંખી

Nebo શું છે

Nebo એક અંગત ડેસ્કટૉપ AI સહાયક છે — સતત ચાલતો AI કર્મચારી જે તમારું ડિજિટલ જીવન સંભાળે છે. Nebo વિશે એ રીતે વિચારો જે રીતે તમે સ્માર્ટફોન વિશે વિચારો છો: એક શક્તિશાળી પ્લૅટફૉર્મ જે તેની ઍપ્સ દ્વારા પરિવર્તનકારી બને છે.

પોતાની રીતે, Nebo મેમરી, સમયપત્રક, વેબ બ્રાઉઝિંગ, ફાઇલ મૅનેજમેન્ટ અને શેલ ઍક્સેસ સાથેનો સક્ષમ AI કર્મચારી છે. પણ ખરી ચાવી ઍપ્સ છે. જેમ સ્માર્ટફોનની શક્તિ તેની ઍપ ઇકોસિસ્ટમમાંથી આવે છે, તેમ Nebo ની શક્તિ તે શું કરી શકે તેનો વિસ્તાર કરતી ઍપ્સમાંથી આવે છે.

ઍપ્સ શું છે

Nebo ઍપ્સ અદ્ભુત કાર્યક્ષમતાના સ્વતંત્ર, પહેલેથી કમ્પાઇલ કરેલા એકમો છે. દરેક ઍપ Nebo ને નવી સુપરપાવર આપે છે — કૅલેન્ડર મૅનેજમેન્ટ, ઇમેઇલ વર્ગીકરણ, પ્રોજેક્ટ ટ્રૅકિંગ, હોમ ઑટોમેશન, નાણાકીય વિશ્લેષણ — ડેવલપર કલ્પી શકે તે કંઈ પણ.

ઍપ્સ ખૂબ સુરક્ષિત રીતે અદ્ભુત શક્તિ આપે છે. દરેક ઍપ ડિફૉલ્ટ રૂપે નકારતી પરવાનગીઓ સાથે સૅન્ડબૉક્સમાં ચાલે છે. તે ફક્ત એ જ ઍક્સેસ કરી શકે છે જે તેનું મેનિફેસ્ટ જાહેર કરે અને વપરાશકર્તા મંજૂર કરે.

ઇન્ટરફેસ 100% વાતચીત આધારિત છે. વપરાશકર્તાઓ અલગ સ્ક્રીન કે ડૅશબોર્ડ દ્વારા ઍપ્સ સાથે કામ કરતા નથી. તેઓ Nebo સાથે વાત કરે છે, અને Nebo કામ પૂરું કરવા ઍપનાં સાધનો વાપરે છે. "કાલે મારા કૅલેન્ડરમાં શું છે?" — Nebo કૅલેન્ડર ઍપને કૉલ કરે છે. "Sarah સાથે 3pm પર મીટિંગ બનાવો" — Nebo કૅલેન્ડર ઍપને કૉલ કરે છે. વપરાશકર્તા ક્યારેય વાતચીત છોડતા નથી.

ઍપ્સ વૈકલ્પિક રીતે સેટિંગ UI આપી શકે છે — એક રૂપરેખાંકન પૅનલ જે Nebo ની બિલ્ટ-ઇન બ્રાઉઝર વિન્ડોમાં ખૂલે છે. અહીં વપરાશકર્તાઓ API કી દાખલ કરે છે, સુવિધાઓ ચાલુ-બંધ કરે છે, અને ઍપનું રૂપરેખાંકન કરે છે. સેટિંગ UI મેનિફેસ્ટમાંના settings એરે દ્વારા ચાલે છે (Nebo ફૉર્મ આપમેળે બનાવે છે), અથવા ઍપ ui ક્ષમતા દ્વારા પોતાનું સંપૂર્ણ કસ્ટમ UI આપી શકે છે.

ઍપ્સ Nebo ની બિલ્ટ-ઇન ક્ષમતાઓનું સ્થાન લે છે અને તેમનો વિસ્તાર કરે છે. Nebo મૂળભૂત પ્લૅટફૉર્મ સાધનો સાથે આવે છે (સ્થાનિક કૅલેન્ડર ઍક્સેસ, સ્ક્રીનશૉટ વગેરે). જ્યારે તમે કૅલેન્ડર ઍપ ઇન્સ્ટૉલ કરો, ત્યારે તે બિલ્ટ-ઇન કૅલેન્ડર સાધનનું સ્થાન લે છે અને તેનો વ્યાપક સમૂહ બને છે — સ્થાનિક + ક્લાઉડ + એકત્રીકરણ + ઉપલબ્ધતા તપાસ.

ફક્ત-કમ્પાઇલ્ડ નીતિ

Nebo ફક્ત કમ્પાઇલ કરેલી બાઇનરીની કડક નીતિ લાગુ કરે છે. બધી ઍપ્સ નેટિવ કમ્પાઇલ કરેલી એક્ઝિક્યુટેબલ હોવી જોઈએ.

સ્થિતિભાષાઓ
સપોર્ટેડGo (ભલામણ કરેલ), Rust, C/C++, Zig
નકારેલPython, Node.js, Ruby, Java, .NET, શેલ સ્ક્રિપ્ટ

કારણ:

  • AI દ્વારા સ્વ-ફેરફાર અટકાવવો — શેલ ઍક્સેસ ધરાવતો AI કર્મચારી રનટાઇમ પર ઇન્ટરપ્રિટેડ સ્ક્રિપ્ટનું વર્તન બદલી શકે છે. કમ્પાઇલ કરેલી બાઇનરી સહી પછી બદલી શકાતી નથી.
  • સહીની અખંડિતતા — Ed25519 સહીઓ કાચી બાઇનરી બાઇટ્સને આવરી લે છે. સહી કરેલી બાઇનરી સહીને અમાન્ય કર્યા વિના બદલી શકાતી નથી.
  • સૅન્ડબૉક્સનો અમલ — બાઇનરી ફૉર્મેટની ચકાસણી (ELF/Mach-O/PE magic bytes) ઝડપી અને ભરોસાપાત્ર દરવાજો છે.

ઝડપી શરૂઆત

SDK ઇન્સ્ટૉલ કરો

અધિકૃત SDK બધું gRPC સર્વર સેટઅપ, સિગ્નલ હૅન્ડલિંગ અને પ્રોટોકૉલ બ્રિજિંગ સંભાળે છે. તમારે ફક્ત હૅન્ડલર ઇન્ટરફેસ અમલમાં મૂકવાના છે.

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. id, name, version, provides સાથે manifest.json બનાવો
  2. AI કર્મચારીએ તમારા સાધનનો ઉપયોગ કેવી રીતે કરવો તે વર્ણવતી TOOL.md લખો
  3. SDK ઇન્સ્ટૉલ કરો (go get github.com/neboloop/nebo-sdk-go)
  4. તમારી ક્ષમતા માટે હૅન્ડલર ઇન્ટરફેસ અમલમાં મૂકો (ToolHandler, ChannelHandler વગેરે)
  5. હૅન્ડલર રજિસ્ટર કરો અને 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માણસ વાંચી શકે તેવું નામ
versionSemver સ્ટ્રિંગ
providesઓછામાં ઓછી એક ક્ષમતા (નીચે જુઓ)

વૈકલ્પિક ફીલ્ડ:

ફીલ્ડડિફૉલ્ટવર્ણન
runtime"local""local" અથવા "remote"
protocol"grpc"ફક્ત "grpc" સપોર્ટેડ છે
permissions[]ઍપને શેના ઍક્સેસની જરૂર છે
description""UI માં બતાવાય છે
settings[]રૂપરેખાંકિત કરી શકાય તેવાં સેટિંગ (Settings UI માં બતાવાય છે)
oauth[]OAuth પ્રોવાઇડરની જરૂરિયાતો (નીચે OAuth વિભાગ જુઓ)

ક્ષમતાઓ

તમારી ઍપ શું આપે છે તે જાહેર કરો:

ક્ષમતાgRPC સેવાવર્ણન
gatewayGatewayServiceLLM મૉડલ રૂટિંગ
tool:<name>ToolServiceAI કર્મચારી માટે નામ ધરાવતું સાધન
channel:<name>ChannelServiceમેસેજિંગ ચૅનલ
commCommServiceAI કર્મચારીઓ વચ્ચે સંચાર
uiUIServiceHTTP પ્રૉક્સી સાથે કસ્ટમ UI
scheduleScheduleServiceકસ્ટમ સમયપત્રક
visionToolServiceવિઝન પ્રોસેસિંગ
browserToolServiceબ્રાઉઝર ઑટોમેશન

એક ઍપ અનેક ક્ષમતાઓ આપી શકે છે. ઉદાહરણ તરીકે, ઍપ સાધન અને UI પૅનલ બંને આપી શકે છે.

પરવાનગીઓ

પરવાનગીઓ નક્કી કરે છે કે ઍપ શું ઍક્સેસ કરી શકે. ડિફૉલ્ટ રૂપે નકાર — જાહેર ન કર્યું હોય, તો ઍપ તેનો ઉપયોગ કરી શકતી નથી.

પ્રિફિક્સઉદાહરણોવર્ણન
network:network:outbound, network:*નેટવર્ક ઍક્સેસ
filesystem:filesystem:read, filesystem:writeફાઇલ સિસ્ટમ ઍક્સેસ
memory:memory:read, memory:writeAI કર્મચારીની મેમરીનો ઍક્સેસ
session:session:readવાતચીત સત્રો
tool:tool:shell, tool:fileબીજાં સાધનો વાપરવાં
shell:shell:execશેલ કમાન્ડનો અમલ
channel:channel:send, channel:*ચૅનલ કામગીરી
comm:comm:send, comm:*AI કર્મચારીઓ વચ્ચે સંચાર
model:model:chatAI મૉડલ ઍક્સેસ
user:user:tokenવિનંતીઓમાં વપરાશકર્તાનો JWT મેળવવો
schedule:schedule:createCron જૉબ મૅનેજમેન્ટ
database:database:queryડેટાબેઝ ઍક્સેસ
storage:storage:read, storage:writeકાયમી સ્ટોરેજ
context:context:readAI કર્મચારીના સંદર્ભનો ઍક્સેસ
subagent:subagent:spawnસબ-એજન્ટ કામગીરી
lane:lane:enqueueલેન કામગીરી
notification:notification:sendપુશ નોટિફિકેશન
embedding:embedding:searchવેક્ટર એમ્બેડિંગ ઍક્સેસ
skill:skill:invokeકૌશલ્યનો ઉપયોગ
advisor:advisor:consultસલાહકાર સિસ્ટમ ઍક્સેસ
mcp:mcp:connectMCP સર્વર ઍક્સેસ
voice:voice:recordઅવાજ/ઑડિયો ઍક્સેસ
browser:browser:navigateબ્રાઉઝર ઑટોમેશન
oauth:oauth:google, oauth:*OAuth ટોકન ઍક્સેસ
settings:settings:readસેટિંગ ઍક્સેસ
capability:capability:registerક્ષમતાની નોંધણી

વાઇલ્ડકાર્ડ પરવાનગીઓ સપોર્ટેડ છે: network:* કોઈ પણ network: પરવાનગી તપાસ સાથે મેળ ખાય છે.

સેટિંગ

સેટિંગ Nebo UI માં ઍપની સેટિંગ પૅનલ હેઠળ દેખાય છે. Nebo તેમને ડેટાબેઝમાં સાચવે છે અને તે બદલાય ત્યારે Configure RPC દ્વારા તમારી ઍપને મોકલે છે.

તમારી સેટિંગ સ્કીમા NeboAI ઍપ સ્ટોર લિસ્ટિંગમાં સામેલ થાય છે. જરૂરી સેટિંગ રૂપરેખાંકિત ન હોય તેવી ઍપ્સ UI માં "Needs Setup" બૅજ બતાવે છે.

પ્રકારવર્ણન
textએક લાઇનનું ટેક્સ્ટ ઇનપુટ
passwordછુપાવેલું ટેક્સ્ટ ઇનપુટ
toggleબુલિયન ચાલુ/બંધ સ્વિચ
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 બ્રોકર આખો ફ્લો સંભાળે છે — ઍપ્સને Configure RPC દ્વારા આપમેળે ટોકન મળે છે.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
ફીલ્ડવર્ણન
providerOAuth પ્રોવાઇડર: "google", "microsoft", "github"
scopesઍપને જરૂરી OAuth સ્કોપનો એરે

જ્યારે વપરાશકર્તા ઍપ ઇન્સ્ટૉલ કરે, ત્યારે Nebo તેમને જરૂરી OAuth સ્કોપ અધિકૃત કરવા કહે છે. ઍપ પોતે OAuth ફ્લો સંભાળ્યા વિના Configure RPC દ્વારા તાજા ટોકન મેળવે છે.

એન્વાયર્નમેન્ટ વેરિએબલ

તમારી ઍપ પ્રોસેસને સાફ કરેલું એન્વાયર્નમેન્ટ મળે છે. બધાં સિક્રેટ દૂર કરવામાં આવે છે. તમને આ મળે છે:

વેરિએબલમૂલ્ય
NEBO_APP_DIRઍપની ઇન્સ્ટૉલેશન ડિરેક્ટરી
NEBO_APP_SOCKબનાવવાના Unix સૉકેટનો પાથ
NEBO_APP_IDમેનિફેસ્ટમાંથી ઍપ ID
NEBO_APP_NAMEમેનિફેસ્ટમાંથી ઍપનું નામ
NEBO_APP_VERSIONમેનિફેસ્ટમાંથી ઍપ વર્ઝન
NEBO_APP_DATAઍપની data/ ડિરેક્ટરીનો પાથ
PATHસિસ્ટમ PATH (જેમનું તેમ)
HOMEવપરાશકર્તાની હોમ ડિરેક્ટરી (જેમનું તેમ)
TMPDIRટેમ્પ ડિરેક્ટરી (જેમનું તેમ)

અત્યંત મહત્ત્વનું: તમારી બાઇનરીએ NEBO_APP_SOCK પરના Unix સૉકેટ પર સાંભળતું gRPC સર્વર બનાવવું જોઈએ. આ સૉકેટ દેખાય તેની Nebo 10 સેકન્ડ સુધી રાહ જુએ છે.

ઍપ શરૂ થવાનો ક્રમ

  1. Nebo manifest.json વાંચે છે અને તેની ચકાસણી કરે છે
  2. ઍપ ડિરેક્ટરીમાં binary અથવા app એક્ઝિક્યુટેબલ શોધે છે
  3. .quarantined માર્કર તપાસે છે (ક્વૉરન્ટાઇન કરેલી ઍપ્સ શરૂ કરવાનો ઇનકાર કરે છે)
  4. રદબાતલ તપાસ (ફક્ત NeboAI દ્વારા વિતરિત ઍપ્સ)
  5. સહીની ચકાસણી (ફક્ત NeboAI દ્વારા વિતરિત ઍપ્સ, dev માં છોડી દેવાય છે)
  6. બાઇનરીની ચકાસણી (સિમલિંક, સ્ક્રિપ્ટ, નૉન-એક્ઝિક્યુટેબલ, વધુ પડતી મોટી ફાઇલો નકારે છે)
  7. અગાઉના રનનું જૂનું સૉકેટ સાફ કરે છે
  8. સૅન્ડબૉક્સ સ્ટોરેજ માટે data/ ડિરેક્ટરી બનાવે છે
  9. દરેક ઍપ માટે લૉગ ફાઇલો સેટ કરે છે (logs/stdout.log, logs/stderr.log)
  10. સાફ કરેલા એન્વાયર્નમેન્ટ અને પ્રોસેસ ગ્રુપ આઇસોલેશન સાથે બાઇનરી શરૂ કરે છે
  11. Unix સૉકેટ દેખાય તેની રાહ જુએ છે (એક્સ્પોનેન્શિયલ બૅકઑફ, વધુમાં વધુ 10 સેકન્ડ)
  12. Unix સૉકેટ પર gRPC દ્વારા જોડાય છે
  13. provides ના આધારે ક્ષમતા-વિશિષ્ટ gRPC ક્લાયન્ટ બનાવે છે
  14. હેલ્થ ચેક ચલાવે છે
  15. AI કર્મચારી સાથે ક્ષમતાઓ રજિસ્ટર કરે છે (સાધનો, ગેટવે, comm વગેરે)

સાધન ઍપ્સ

તમારા મેનિફેસ્ટમાં "provides": ["tool:my_tool_name"] જાહેર કરો.

STRAP પૅટર્ન

બધી Nebo સાધન ઍપ્સે તેમની સ્કીમા અને અમલ રૂટિંગ માટે STRAP (Single Tool Resource Action Pattern) વાપરવી જ જોઈએ. આ એ જ પૅટર્ન છે જેનો Nebo આંતરિક રીતે 35+ અલગ સાધનોને 4 ડોમેન સાધનોમાં એકત્ર કરવા ઉપયોગ કરે છે — LLM સંદર્ભનો ભાર ~80% ઘટાડે છે.

મુખ્ય વિચાર: અનેક સાધનો (get_events, check_availability, suggest_slots) રજિસ્ટર કરવાને બદલે, 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")

સ્કીમાના નિયમો:

  1. હંમેશાં જરૂરી સ્ટ્રિંગ enum તરીકે action ફીલ્ડ સામેલ કરો
  2. resource ફીલ્ડ (જરૂરી સ્ટ્રિંગ 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 ના AI કર્મચારી સાથે જોડે છે. જ્યારે વપરાશકર્તા બહારના પ્લૅટફૉર્મ પર મેસેજ મોકલે, ત્યારે તમારી ઍપ તેને Receive દ્વારા Nebo ને સ્ટ્રીમ કરે છે. જ્યારે AI કર્મચારી જવાબ આપવા માંગે, ત્યારે Nebo તમારી ઍપનું Send કૉલ કરે છે.

તે કેવી રીતે કામ કરે છે

  1. તમારી ચૅનલનો અનન્ય ઓળખકર્તા મેળવવા Nebo ID() કૉલ કરે છે
  2. Nebo તમારી ઍપનાં સેટિંગમાંથી રૂપરેખાંકન સાથે Connect() કૉલ કરે છે
  3. Nebo Receive() સ્ટ્રીમ ખોલે છે — વપરાશકર્તા બૉટને મેસેજ કરે ત્યારે તમારી ઍપ આવતા મેસેજ મોકલે છે
  4. આવતા મેસેજ AI કર્મચારીની મુખ્ય વાતચીત લેન પર રૂટ થાય છે
  5. જ્યારે AI કર્મચારી મેસેજ મોકલવા માંગે, ત્યારે 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બૉટની ઓળખ — name, role, 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 ઍપ્સ AI કર્મચારીઓ વચ્ચે સંચાર શક્ય બનાવે છે.

ફીલ્ડવર્ણન
fromમોકલનાર કર્મચારીનું ID
toમેળવનાર કર્મચારીનું ID
topicમેસેજનો વિષય/ચૅનલ
type"message", "mention", "proposal", "command", "info", "task"
contentમેસેજનો મુખ્ય ભાગ

મુખ્ય વર્તન:

  • Register આ AI કર્મચારીને તેની ક્ષમતાઓ સાથે નેટવર્ક પર જાહેર કરે છે
  • Subscribe/Unsubscribe વિષયનાં સબ્સ્ક્રિપ્શન સંભાળે છે
  • Receive આવતા મેસેજ સ્ટ્રીમ કરે છે (સર્વર-સ્ટ્રીમિંગ, ચૅનલ જેવું જ)
  • એક સમયે ફક્ત એક 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 ફ્રન્ટએન્ડ આપે છે.

તમારી ઍપ સ્થિર વેબ ઍસેટ (HTML, CSS, JS — સામાન્ય રીતે index.html સાથેનું SPA) ધરાવતી ui/ ડિરેક્ટરી સાથે આવે છે. Nebo આ ફાઇલો સીધી આપે છે અને API કૉલને gRPC દ્વારા તમારી ઍપ સુધી પ્રૉક્સી કરે છે.

પાથપદ્ધતિહેતુ
GET /api/v1/apps/{id}/ui/*સ્થિર ફાઇલ સર્વરતમારી ui/ ડિરેક્ટરીમાંથી ફાઇલો આપે છે (SPA માટે index.html પર ફૉલબૅક)
ANY /api/v1/apps/{id}/api/*gRPC પ્રૉક્સીHTTP વિનંતીઓને તમારી ઍપના UIService.HandleRequest() સુધી પ્રૉક્સી કરે છે

SDK સ્ટાન્ડર્ડ net/http.ServeMux ને આવરી લે છે જેથી તમે સામાન્ય Go HTTP હૅન્ડલર લખો — 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 હૅન્ડલર સુધી પ્રૉક્સી થાય છે.

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 સર્વર-સ્ટ્રીમિંગ 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 MBEd25519 સહીઓ
TOOL.md1 MBAI કર્મચારી માટે સાધનની સૂચનાઓ

એક્સ્ટ્રૅક્શન દરમિયાન સુરક્ષાના નિયમો:

  • પાથ ટ્રાવર્સલ નહીં (../ નકારાય છે)
  • સિમલિંક નહીં (નકારાય છે)
  • સંપૂર્ણ પાથ નહીં (નકારાય છે)
  • ફક્ત માન્ય યાદીમાંનાં ફાઇલનામ સ્વીકારાય છે

સહીઓ

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. POST /api/v1/owners/register પર NeboAI એકાઉન્ટ રજિસ્ટર કરો
  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 તરીકે પણ ઉપલબ્ધ છે) વાપરો. આ ડિરેક્ટરી ઍપ અપડેટ અને ક્વૉરન્ટાઇન પછી પણ ટકી રહે છે.

ડીબગિંગ ટિપ્સ

  • જો તમારી ઍપ શરૂ ન થાય, તો ભૂલો માટે logs/stderr.log તપાસો
  • ખાતરી કરો કે બાઇનરી એક્ઝિક્યુટેબલ છે (chmod +x binary)
  • ખાતરી કરો કે તમે NEBO_APP_SOCK માંના Unix સૉકેટ પાથ પર સાંભળી રહ્યા છો
  • શરૂ થયાની 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 ના વર્તનને આકાર આપે છે. કૌશલ્ય સક્રિય હોય ત્યારે, તેની સામગ્રી સીધી સિસ્ટમ પ્રૉમ્પ્ટમાં ઉમેરાય છે — તે સત્ર માટે AI કર્મચારીના સૂર, પદ્ધતિ, ક્ષેત્રની નિપુણતા અને સાધનોના ઉપયોગને માર્ગદર્શન આપે છે.

કૌશલ્યો કોડ નથી. તે YAML મેટાડેટા સાથેના markdown દસ્તાવેજો છે. કોઈ કમ્પાઇલેશન નહીં, કોઈ બાઇનરી નહીં, કોઈ gRPC નહીં. કૌશલ્ય એટલે ડિરેક્ટરીમાં એક SKILL.md ફાઇલ. બસ એટલું જ.

કૌશલ્યો સંદર્ભ આધારિત અને કામચલાઉ હોય છે. તે સુસંગત હોય ત્યારે સક્રિય થાય છે (ટ્રિગર મેચિંગ અથવા મૅન્યુઅલ લોડ દ્વારા), થોડા વારા સુધી ટકે છે, અને જરૂર ન રહે ત્યારે સમાપ્ત થાય છે. આનાથી AI કર્મચારીનો સંદર્ભ હળવો રહે છે — પ્રૉમ્પ્ટમાં ફક્ત અત્યારે મહત્ત્વનું માર્ગદર્શન જ હોય છે.

કૌશલ્યો ઍપ્સને પૂરક છે. ઍપ્સ અમલ કરી શકાય તેવી ક્ષમતાઓ આપે છે (સાધનો, ચૅનલ્સ, ગેટવે). કૌશલ્યો સંકલનનું માર્ગદર્શન આપે છે — એ સાધનો અસરકારક રીતે કેવી રીતે વાપરવાં. કૅલેન્ડર ઍપ Nebo ને ઇવેન્ટ વાંચવાની અને લખવાની ક્ષમતા આપે છે. "મીટિંગની તૈયારી" કૌશલ્ય Nebo ને જણાવે છે કે એ કૅલેન્ડર ઍપ, ઇમેઇલ અને વેબ શોધને સાથે વાપરીને મીટિંગની તૈયારી કેવી રીતે કરવી.

કૌશલ્યો વિરુદ્ધ ઍપ્સ

કૌશલ્યોઍપ્સ
ફૉર્મેટMarkdown (SKILL.md)કમ્પાઇલ કરેલી બાઇનરી (.napp)
રનટાઇમસિસ્ટમ પ્રૉમ્પ્ટમાં ઉમેરાય છેgRPC પર સૅન્ડબૉક્સ કરેલી પ્રોસેસ
શું આપે છેવર્તન માટે માર્ગદર્શન, પદ્ધતિસાધનો, ચૅનલ્સ, UI પૅનલ
આયુષ્યસત્ર પૂરતું, TTL આધારિત સમાપ્તિહંમેશાં ચાલુ
રચનાmarkdown ફાઇલ લખોલખો, કમ્પાઇલ કરો, સહી કરો, પૅકેજ કરો
સુરક્ષાકોઈ પરવાનગીની જરૂર નથીડિફૉલ્ટ રૂપે નકારતું સૅન્ડબૉક્સ

ઝડપી શરૂઆત

તમારા 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 ટ્રિગર મેચ માટે બધાં રજિસ્ટર્ડ કૌશલ્યો સ્કૅન કરે છે. મેળ ખાતાં કૌશલ્યો સિસ્ટમ પ્રૉમ્પ્ટમાં સંકેત તરીકે દેખાય છે. AI કર્મચારી સંકેત જુએ છે અને કૌશલ્યનો ઉપયોગ કરવો કે નહીં તે નક્કી કરે છે.

તબક્કો 2: ઉપયોગ — AI કર્મચારી આ કૉલ કરીને કૌશલ્યનો ઉપયોગ કરે છે:

skill(name: "code-review")

આ સાધનના પરિણામ તરીકે આખો SKILL.md નમૂનો પાછો આપે છે, ઉપયોગની નોંધ કરે છે, અને પછીના વારામાં નમૂનાને ફરી સિસ્ટમ પ્રૉમ્પ્ટમાં ઉમેરે છે.

TTL અને સમાપ્તિ:

  • આપમેળે મેળ ખાતાં કૌશલ્યો: 4 નિષ્ક્રિય વારા (max_turns દ્વારા રૂપરેખાંકિત)
  • મૅન્યુઅલ રીતે લોડ કરેલાં કૌશલ્યો: 6 નિષ્ક્રિય વારા
  • ફરી ઉપયોગ ટાઇમરને રીસેટ કરે છે
  • કડક મર્યાદા: સત્ર દીઠ વધુમાં વધુ 4 સક્રિય કૌશલ્યો
  • ટોકન બજેટ: સક્રિય કૌશલ્યોની કુલ સામગ્રીની મર્યાદા 16,000 અક્ષર

કૌશલ્યોનું સંચાલન

AI કર્મચારી skill સાધન દ્વારા કૌશલ્યોનું સંચાલન કરી શકે છે:

ક્રિયાવર્ણનઉદાહરણ
catalogબધાં ઉપલબ્ધ કૌશલ્યોની યાદીskill(action: "catalog")
loadઆ સત્ર માટે સક્રિય કરોskill(name: "code-review", action: "load")
unloadકૌશલ્ય નિષ્ક્રિય કરોskill(name: "code-review", action: "unload")
createડિસ્ક પર નવું કૌશલ્ય બનાવોskill(action: "create", content: "...")
updateહાલનું કૌશલ્ય અપડેટ કરોskill(name: "my-skill", action: "update", content: "...")
deleteડિસ્ક પરથી કૌશલ્ય ડિલીટ કરોskill(name: "my-skill", action: "delete")

સારાં કૌશલ્યો લખવાં

સારા કૌશલ્ય નમૂનામાં આ હોય છે:

  1. સ્પષ્ટ શીર્ષક — AI કર્મચારીને જણાવે છે કે તે કયા મોડમાં છે
  2. મુખ્ય સિદ્ધાંતો — વર્તનના અટલ નિયમો
  3. પદ્ધતિ — સામાન્ય પરિસ્થિતિઓ માટે પગલાવાર અભિગમ
  4. ઉદાહરણો — વપરાશકર્તાના મેસેજથી જવાબ સુધીની નક્કર પૅટર્ન
  5. ખોટી પૅટર્ન — શું ન કરવું (મૉડલ નકારાત્મક ઉદાહરણોમાંથી સારી રીતે શીખે છે)

ટિપ: દરેક કૌશલ્યે એક કામ સારી રીતે કરવું જોઈએ. "સામાન્ય પ્રોગ્રામિંગ" કૌશલ્ય ન બનાવો — code-review, debugging, api-design અલગ કૌશલ્યો તરીકે બનાવો. AI કર્મચારીનાં એકસાથે અનેક કૌશલ્યો સક્રિય હોઈ શકે છે.

સાથે આવતાં કૌશલ્યો

Nebo સામાન્ય ઉપયોગોને આવરી લેતાં કૌશલ્યો સાથે આવે છે:

કૌશલ્યપ્રાથમિકતાવર્ણન
onboarding100નવા વપરાશકર્તાનું સ્વાગત અને પ્રોફાઇલ માહિતી એકઠી કરવી
best-friend50વ્યક્તિત્વ કૌશલ્ય — હળવું, વફાદાર, સાચી વાત
debugging25વ્યવસ્થિત ડીબગિંગ પદ્ધતિ
api-design15RESTful API ડિઝાઇનની શ્રેષ્ઠ પદ્ધતિઓ
code-review10ગંભીરતાનાં સ્તરો સાથે માળખાગત કોડ સમીક્ષા
database-expert10ડેટાબેઝ ડિઝાઇન, ક્વેરી, ઑપ્ટિમાઇઝેશન
git-workflow10Git બ્રાન્ચિંગ, કમિટ, 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 પ્રકારો

મેસેજ પ્રકારવર્ણન
ChannelSendRequestmessage_id, channelId, sender, text, attachments, reply_to, actions, platform_data સાથેનું જતા મેસેજનું એન્વેલપ
ChannelSendResponseથ્રેડિંગ માટે પ્લૅટફૉર્મ મેસેજ ID
InboundMessageબધાં સામાન્ય ફીલ્ડ + timestamp સાથેનું આવતા મેસેજનું એન્વેલપ
MessageSenderબૉટની ઓળખ (name, role, botId) — બ્રોકર દ્વારા સમૃદ્ધ કરેલી
Attachmentફાઇલ/છબી/ઑડિયો જોડાણ (type, url, filename, size)
MessageActionઇન્ટરૅક્ટિવ બટન/કીબોર્ડ ક્રિયા (label, callback_id)

બૉટની ઓળખ અને ભૂમિકાઓ

Nebo બૉટનું ત્રણ-અક્ષીય ઓળખ મૉડલ છે:

  • creature — બૉટ શું છે (મૂળ પ્રકાર): "ચપળ બુદ્ધિવાળો વ્યૂહરચનાકાર", "ઝીણવટભર્યો સંશોધક"
  • role — તે વપરાશકર્તા સાથે કેવી રીતે સંબંધિત છે (સંબંધ): "મિત્ર", "COO", "માર્ગદર્શક"
  • vibe — તેની ઊર્જા (વાતચીતની શૈલી): "શાંત પણ મક્કમ મતવાળો", "આત્મીય અને પ્રોત્સાહક"

જ્યારે તમારા ચૅનલ પ્લગઇનને જતો મેસેજ મળે, ત્યારે sender ફીલ્ડમાં બૉટનું name અને role હોય છે. તમારા પ્લૅટફૉર્મ માટે ડિસ્પ્લે નામ ફૉર્મેટ કરવા આનો ઉપયોગ કરો. ભૂમિકા કોઈ હોદ્દો નથી — તે સંબંધનું વર્ણન છે. "COO" અને "DevLead" ની સાથે "મિત્ર", "દીકરો" અને "માર્ગદર્શક" પણ માન્ય ભૂમિકાઓ છે.