NeboAI
NeboAI
सुरू करा

Nebo साठी ॲप्स तयार करा

तुमच्या AI ला नवीन महाशक्ती द्या. साधने, चॅनेल, गेटवे, UI पॅनेल — तुम्ही कल्पना करू शकता ते काहीही, नेटिव्ह बायनरीमध्ये कंपाइल केलेले.

आढावा

Nebo काय आहे

Nebo हा वैयक्तिक डेस्कटॉप AI सहाय्यक आहे — तुमचे डिजिटल आयुष्य सांभाळणारा, सतत चालू असलेला AI कर्मचारी. Nebo कडे तुम्ही स्मार्टफोनकडे पाहता तसे पहा: एक शक्तिशाली प्लॅटफॉर्म, जो त्याच्या ॲप्समुळे परिवर्तनकारी ठरतो.

स्वतःहून, Nebo स्मृती, वेळापत्रक, वेब ब्राउझिंग, फाइल व्यवस्थापन आणि शेल प्रवेश असलेला सक्षम AI कर्मचारी आहे. पण खरी किल्ली ॲप्स आहेत. जसे स्मार्टफोनची ताकद त्याच्या ॲप इकोसिस्टममधून येते, तसेच Nebo ची ताकद तो काय करू शकतो ते वाढवणाऱ्या ॲप्समधून येते.

ॲप्स काय आहेत

Nebo ॲप्स हे स्वयंपूर्ण, आधीच कंपाइल केलेले, अफाट कार्यक्षमतेचे घटक आहेत. प्रत्येक ॲप Nebo ला नवीन महाशक्ती देते — कॅलेंडर व्यवस्थापन, ईमेलचे वर्गीकरण, प्रकल्पांचा माग, होम ऑटोमेशन, आर्थिक विश्लेषण — डेव्हलपर कल्पना करू शकेल ते काहीही.

ॲप्स अतिशय सुरक्षित पद्धतीने अफाट ताकद देतात. प्रत्येक ॲप डिफॉल्टनुसार नकार असलेल्या परवानग्यांसह सँडबॉक्समध्ये चालते. त्याच्या मॅनिफेस्टमध्ये घोषित केलेले आणि वापरकर्त्याने मंजूर केलेलेच ते वापरू शकते.

इंटरफेस 100% संभाषणात्मक आहे. वापरकर्ते वेगळ्या स्क्रीन किंवा डॅशबोर्डमधून ॲप्स वापरत नाहीत. ते Nebo शी बोलतात, आणि Nebo काम पूर्ण करण्यासाठी ॲपची साधने वापरतो. "उद्या माझ्या कॅलेंडरवर काय आहे?" — Nebo कॅलेंडर ॲपला कॉल करतो. "दुपारी 3 वाजता Sarah सोबत मीटिंग तयार कर" — 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 मॅजिक बाइट्स) हा जलद, विश्वासार्ह दरवाजा आहे.

झटपट सुरुवात

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[]कॉन्फिगर करता येणाऱ्या सेटिंग्ज (सेटिंग्ज 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. बायनरी पडताळणी (symlink, स्क्रिप्ट, एक्झिक्युटेबल नसलेल्या, अतिमोठ्या फाइल्स नाकारते)
  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) वापरलाच पाहिजे. 35+ वैयक्तिक साधने 4 डोमेन साधनांमध्ये एकत्र करण्यासाठी Nebo अंतर्गत हाच पॅटर्न वापरतो — त्यामुळे 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बॉटची ओळख — नाव, भूमिका, 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 ॲप सक्रिय असू शकते

गेटवे ॲप

गेटवे ॲप 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 हँडलरकडे प्रॉक्सी होतात.

वेळापत्रक ॲप

वेळापत्रक ॲप Nebo च्या अंगभूत cron शेड्युलरची जागा घेते. "provides": ["schedule"] आणि "permissions": ["schedule:create"] घोषित करा.

तुमचे वेळापत्रक ॲप सुरू झाल्यावर, Nebo सर्व वेळापत्रक डिफॉल्ट cron इंजिनऐवजी तुमच्या ॲपमार्फत चालवतो. तुमचे ॲप क्रॅश झाल्यास, Nebo आपोआप अंगभूत इंजिनवर परत जातो.

  • तुमचे ॲप वेळापत्रकाच्या स्थितीचे मालक असते — वेळापत्रक ॲप सक्रिय असताना Nebo स्वतःच्या DB मध्ये वेळापत्रके साठवत नाही
  • मानक CRUD: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers हा सर्व्हर-स्ट्रीमिंग RPC आहे — वेळापत्रक सुरू होते तेव्हा तुमचे ॲप ट्रिगर संदेश पाठवते
  • एका वेळी फक्त एकच वेळापत्रक ॲप सक्रिय असू शकते

अनेक क्षमतांची ॲप्स

एक ॲप अनेक क्षमता पुरवू शकते. उदाहरणार्थ, साधन आणि 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 कर्मचाऱ्यासाठी साधनाच्या सूचना

काढताना सुरक्षा नियम:

  • पाथ ट्रॅव्हर्सल नाही (../ नाकारले जाते)
  • symlink नाहीत (नाकारले जातात)
  • पूर्ण (absolute) पाथ नाहीत (नाकारले जातात)
  • फक्त परवानगी यादीतील फाइलनावे स्वीकारली जातात

स्वाक्षऱ्या

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" सोबतच "मित्र", "मुलगा" आणि "मार्गदर्शक" या देखील वैध भूमिका आहेत.