ઝાંખી
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) ન્યૂનતમ ઍપ ચેકલિસ્ટ
id,name,version,providesસાથેmanifest.jsonબનાવો- AI કર્મચારીએ તમારા સાધનનો ઉપયોગ કેવી રીતે કરવો તે વર્ણવતી
TOOL.mdલખો - SDK ઇન્સ્ટૉલ કરો (
go get github.com/neboloop/nebo-sdk-go) - તમારી ક્ષમતા માટે હૅન્ડલર ઇન્ટરફેસ અમલમાં મૂકો (
ToolHandler,ChannelHandlerવગેરે) - હૅન્ડલર રજિસ્ટર કરો અને
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 | [] | રૂપરેખાંકિત કરી શકાય તેવાં સેટિંગ (Settings UI માં બતાવાય છે) |
oauth | [] | OAuth પ્રોવાઇડરની જરૂરિયાતો (નીચે OAuth વિભાગ જુઓ) |
ક્ષમતાઓ
તમારી ઍપ શું આપે છે તે જાહેર કરો:
| ક્ષમતા | gRPC સેવા | વર્ણન |
|---|---|---|
gateway | GatewayService | LLM મૉડલ રૂટિંગ |
tool:<name> | ToolService | AI કર્મચારી માટે નામ ધરાવતું સાધન |
channel:<name> | ChannelService | મેસેજિંગ ચૅનલ |
comm | CommService | AI કર્મચારીઓ વચ્ચે સંચાર |
ui | UIService | HTTP પ્રૉક્સી સાથે કસ્ટમ UI |
schedule | ScheduleService | કસ્ટમ સમયપત્રક |
vision | ToolService | વિઝન પ્રોસેસિંગ |
browser | ToolService | બ્રાઉઝર ઑટોમેશન |
એક ઍપ અનેક ક્ષમતાઓ આપી શકે છે. ઉદાહરણ તરીકે, ઍપ સાધન અને UI પૅનલ બંને આપી શકે છે.
પરવાનગીઓ
પરવાનગીઓ નક્કી કરે છે કે ઍપ શું ઍક્સેસ કરી શકે. ડિફૉલ્ટ રૂપે નકાર — જાહેર ન કર્યું હોય, તો ઍપ તેનો ઉપયોગ કરી શકતી નથી.
| પ્રિફિક્સ | ઉદાહરણો | વર્ણન |
|---|---|---|
network: | network:outbound, network:* | નેટવર્ક ઍક્સેસ |
filesystem: | filesystem:read, filesystem:write | ફાઇલ સિસ્ટમ ઍક્સેસ |
memory: | memory:read, memory:write | AI કર્મચારીની મેમરીનો ઍક્સેસ |
session: | session:read | વાતચીત સત્રો |
tool: | tool:shell, tool:file | બીજાં સાધનો વાપરવાં |
shell: | shell:exec | શેલ કમાન્ડનો અમલ |
channel: | channel:send, channel:* | ચૅનલ કામગીરી |
comm: | comm:send, comm:* | AI કર્મચારીઓ વચ્ચે સંચાર |
model: | model:chat | AI મૉડલ ઍક્સેસ |
user: | user:token | વિનંતીઓમાં વપરાશકર્તાનો JWT મેળવવો |
schedule: | schedule:create | Cron જૉબ મૅનેજમેન્ટ |
database: | database:query | ડેટાબેઝ ઍક્સેસ |
storage: | storage:read, storage:write | કાયમી સ્ટોરેજ |
context: | context:read | AI કર્મચારીના સંદર્ભનો ઍક્સેસ |
subagent: | subagent:spawn | સબ-એજન્ટ કામગીરી |
lane: | lane:enqueue | લેન કામગીરી |
notification: | notification:send | પુશ નોટિફિકેશન |
embedding: | embedding:search | વેક્ટર એમ્બેડિંગ ઍક્સેસ |
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 | ક્ષમતાની નોંધણી |
વાઇલ્ડકાર્ડ પરવાનગીઓ સપોર્ટેડ છે: 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"]
}
]
} | ફીલ્ડ | વર્ણન |
|---|---|
provider | OAuth પ્રોવાઇડર: "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 સેકન્ડ સુધી રાહ જુએ છે.
ઍપ શરૂ થવાનો ક્રમ
- Nebo
manifest.jsonવાંચે છે અને તેની ચકાસણી કરે છે - ઍપ ડિરેક્ટરીમાં
binaryઅથવાappએક્ઝિક્યુટેબલ શોધે છે .quarantinedમાર્કર તપાસે છે (ક્વૉરન્ટાઇન કરેલી ઍપ્સ શરૂ કરવાનો ઇનકાર કરે છે)- રદબાતલ તપાસ (ફક્ત NeboAI દ્વારા વિતરિત ઍપ્સ)
- સહીની ચકાસણી (ફક્ત NeboAI દ્વારા વિતરિત ઍપ્સ, dev માં છોડી દેવાય છે)
- બાઇનરીની ચકાસણી (સિમલિંક, સ્ક્રિપ્ટ, નૉન-એક્ઝિક્યુટેબલ, વધુ પડતી મોટી ફાઇલો નકારે છે)
- અગાઉના રનનું જૂનું સૉકેટ સાફ કરે છે
- સૅન્ડબૉક્સ સ્ટોરેજ માટે
data/ડિરેક્ટરી બનાવે છે - દરેક ઍપ માટે લૉગ ફાઇલો સેટ કરે છે (
logs/stdout.log,logs/stderr.log) - સાફ કરેલા એન્વાયર્નમેન્ટ અને પ્રોસેસ ગ્રુપ આઇસોલેશન સાથે બાઇનરી શરૂ કરે છે
- Unix સૉકેટ દેખાય તેની રાહ જુએ છે (એક્સ્પોનેન્શિયલ બૅકઑફ, વધુમાં વધુ 10 સેકન્ડ)
- Unix સૉકેટ પર gRPC દ્વારા જોડાય છે
providesના આધારે ક્ષમતા-વિશિષ્ટ gRPC ક્લાયન્ટ બનાવે છે- હેલ્થ ચેક ચલાવે છે
- 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") સ્કીમાના નિયમો:
- હંમેશાં જરૂરી સ્ટ્રિંગ enum તરીકે
actionફીલ્ડ સામેલ કરો resourceફીલ્ડ (જરૂરી સ્ટ્રિંગ 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 ના AI કર્મચારી સાથે જોડે છે. જ્યારે વપરાશકર્તા બહારના પ્લૅટફૉર્મ પર મેસેજ મોકલે, ત્યારે તમારી ઍપ તેને Receive દ્વારા Nebo ને સ્ટ્રીમ કરે છે. જ્યારે AI કર્મચારી જવાબ આપવા માંગે, ત્યારે Nebo તમારી ઍપનું Send કૉલ કરે છે.
તે કેવી રીતે કામ કરે છે
- તમારી ચૅનલનો અનન્ય ઓળખકર્તા મેળવવા Nebo
ID()કૉલ કરે છે - Nebo તમારી ઍપનાં સેટિંગમાંથી રૂપરેખાંકન સાથે
Connect()કૉલ કરે છે - Nebo
Receive()સ્ટ્રીમ ખોલે છે — વપરાશકર્તા બૉટને મેસેજ કરે ત્યારે તમારી ઍપ આવતા મેસેજ મોકલે છે - આવતા મેસેજ AI કર્મચારીની મુખ્ય વાતચીત લેન પર રૂટ થાય છે
- જ્યારે AI કર્મચારી મેસેજ મોકલવા માંગે, ત્યારે 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 | બૉટની ઓળખ — name, role, 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 ઍપ્સ 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.json | 1 MB | ઍપ મેટાડેટા |
binary અથવા app | 500 MB | એક્ઝિક્યુટેબલ |
signatures.json | 1 MB | Ed25519 સહીઓ |
TOOL.md | 1 MB | AI કર્મચારી માટે સાધનની સૂચનાઓ |
એક્સ્ટ્રૅક્શન દરમિયાન સુરક્ષાના નિયમો:
- પાથ ટ્રાવર્સલ નહીં (
../નકારાય છે) - સિમલિંક નહીં (નકારાય છે)
- સંપૂર્ણ પાથ નહીં (નકારાય છે)
- ફક્ત માન્ય યાદીમાંનાં ફાઇલનામ સ્વીકારાય છે
સહીઓ
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 દ્વારા પ્રકાશિત કરો.
ડેવલપર એકાઉન્ટ સેટઅપ
POST /api/v1/owners/registerપર NeboAI એકાઉન્ટ રજિસ્ટર કરો- 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 તરીકે પણ ઉપલબ્ધ છે) વાપરો. આ ડિરેક્ટરી ઍપ અપડેટ અને ક્વૉરન્ટાઇન પછી પણ ટકી રહે છે.
ડીબગિંગ ટિપ્સ
- જો તમારી ઍપ શરૂ ન થાય, તો ભૂલો માટે
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") |
સારાં કૌશલ્યો લખવાં
સારા કૌશલ્ય નમૂનામાં આ હોય છે:
- સ્પષ્ટ શીર્ષક — AI કર્મચારીને જણાવે છે કે તે કયા મોડમાં છે
- મુખ્ય સિદ્ધાંતો — વર્તનના અટલ નિયમો
- પદ્ધતિ — સામાન્ય પરિસ્થિતિઓ માટે પગલાવાર અભિગમ
- ઉદાહરણો — વપરાશકર્તાના મેસેજથી જવાબ સુધીની નક્કર પૅટર્ન
- ખોટી પૅટર્ન — શું ન કરવું (મૉડલ નકારાત્મક ઉદાહરણોમાંથી સારી રીતે શીખે છે)
ટિપ: દરેક કૌશલ્યે એક કામ સારી રીતે કરવું જોઈએ. "સામાન્ય પ્રોગ્રામિંગ" કૌશલ્ય ન બનાવો — code-review, debugging, api-design અલગ કૌશલ્યો તરીકે બનાવો. AI કર્મચારીનાં એકસાથે અનેક કૌશલ્યો સક્રિય હોઈ શકે છે.
સાથે આવતાં કૌશલ્યો
Nebo સામાન્ય ઉપયોગોને આવરી લેતાં કૌશલ્યો સાથે આવે છે:
| કૌશલ્ય | પ્રાથમિકતા | વર્ણન |
|---|---|---|
onboarding | 100 | નવા વપરાશકર્તાનું સ્વાગત અને પ્રોફાઇલ માહિતી એકઠી કરવી |
best-friend | 50 | વ્યક્તિત્વ કૌશલ્ય — હળવું, વફાદાર, સાચી વાત |
debugging | 25 | વ્યવસ્થિત ડીબગિંગ પદ્ધતિ |
api-design | 15 | RESTful API ડિઝાઇનની શ્રેષ્ઠ પદ્ધતિઓ |
code-review | 10 | ગંભીરતાનાં સ્તરો સાથે માળખાગત કોડ સમીક્ષા |
database-expert | 10 | ડેટાબેઝ ડિઝાઇન, ક્વેરી, ઑપ્ટિમાઇઝેશન |
git-workflow | 10 | Git બ્રાન્ચિંગ, કમિટ, 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) — બ્રોકર દ્વારા સમૃદ્ધ કરેલી |
Attachment | ફાઇલ/છબી/ઑડિયો જોડાણ (type, url, filename, size) |
MessageAction | ઇન્ટરૅક્ટિવ બટન/કીબોર્ડ ક્રિયા (label, callback_id) |
બૉટની ઓળખ અને ભૂમિકાઓ
Nebo બૉટનું ત્રણ-અક્ષીય ઓળખ મૉડલ છે:
- creature — બૉટ શું છે (મૂળ પ્રકાર): "ચપળ બુદ્ધિવાળો વ્યૂહરચનાકાર", "ઝીણવટભર્યો સંશોધક"
- role — તે વપરાશકર્તા સાથે કેવી રીતે સંબંધિત છે (સંબંધ): "મિત્ર", "COO", "માર્ગદર્શક"
- vibe — તેની ઊર્જા (વાતચીતની શૈલી): "શાંત પણ મક્કમ મતવાળો", "આત્મીય અને પ્રોત્સાહક"
જ્યારે તમારા ચૅનલ પ્લગઇનને જતો મેસેજ મળે, ત્યારે sender ફીલ્ડમાં બૉટનું name અને role હોય છે. તમારા પ્લૅટફૉર્મ માટે ડિસ્પ્લે નામ ફૉર્મેટ કરવા આનો ઉપયોગ કરો. ભૂમિકા કોઈ હોદ્દો નથી — તે સંબંધનું વર્ણન છે. "COO" અને "DevLead" ની સાથે "મિત્ર", "દીકરો" અને "માર્ગદર્શક" પણ માન્ય ભૂમિકાઓ છે.