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. TOOL.md लिखें, जिसमें बताया गया हो कि AI कर्मचारी को आपका टूल कैसे इस्तेमाल करना चाहिए
  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:createक्रॉन जॉब प्रबंधन
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 में "सेटअप ज़रूरी" बैज दिखता है।

टाइपविवरण
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 से वितरित ऐप्स के लिए, डेव मोड में छोड़ दिया जाता है)
  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. हमेशा एक action फ़ील्ड ज़रूरी स्ट्रिंग enum के रूप में शामिल करें
  2. resource फ़ील्ड (ज़रूरी स्ट्रिंग enum) तभी जोड़ें जब आपका टूल कई अलग-अलग रिसोर्स टाइप संभालता हो
  3. बाकी सभी फ़ील्ड action-विशिष्ट पैरामीटर हैं
  4. action enum के विवरण में सभी उपलब्ध actions की सूची होनी चाहिए

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 फ़्रंटएंड खुद देता है।

आपका ऐप एक ui/ डायरेक्टरी के साथ आता है जिसमें स्टैटिक वेब एसेट (HTML, CSS, JS — आमतौर पर index.html वाला एक SPA) होते हैं। 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 हैंडलर लिखें — gRPC ब्रिजिंग SDK अपने आप संभालता है।

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 के बिल्ट-इन क्रॉन शेड्यूलर की जगह लेता है। "provides": ["schedule"] और "permissions": ["schedule:create"] घोषित करें।

जब आपका शेड्यूल ऐप लॉन्च होता है, तो Nebo डिफ़ॉल्ट क्रॉन इंजन के बजाय सारी शेड्यूलिंग आपके ऐप से रूट करता है। अगर आपका ऐप क्रैश हो जाए, तो 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 कर्मचारी के लिए टूल निर्देश

एक्सट्रैक्शन के दौरान सुरक्षा नियम:

  • पाथ ट्रैवर्सल नहीं (../ अस्वीकृत)
  • सिमलिंक नहीं (अस्वीकृत)
  • एब्सोल्यूट पाथ नहीं (अस्वीकृत)
  • सिर्फ़ अनुमति-सूची वाले फ़ाइल नाम स्वीकार किए जाते हैं

सिग्नेचर

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>"
}

डेव मोड में (कोई NeboAI URL कॉन्फ़िगर नहीं), सिग्नेचर सत्यापन पूरी तरह छोड़ दिया जाता है। लोकल डेवलपमेंट के लिए आपको signatures.json की ज़रूरत नहीं है।

पब्लिश करना

जब आपका ऐप लोकल रूप से काम करने लगे, तो उसे NeboAI के ज़रिए पब्लिश करें ताकि वह सभी Nebo उपयोगकर्ताओं तक पहुँचे।

डेवलपर अकाउंट सेटअप

  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 फ़्रंटमैटर, और एक 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(सिर्फ़ messages)HealthCheckRequest/Response, SettingsMap, UserContext, Empty
v0/tool.protoToolServiceName, Description, Schema, Execute, RequiresApproval, Configure
v0/channel.protoChannelServiceID, Connect, Disconnect, Send, Receive (stream), Configure
v0/comm.protoCommServiceName, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure
v0/gateway.protoGatewayServiceHealthCheck, Stream (stream), Poll, Cancel, Configure
v0/ui.protoUIServiceHealthCheck, HandleRequest, Configure
v0/schedule.protoScheduleServiceHealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure

हर सर्विस में HealthCheck और Configure RPC शामिल हैं। SDK दोनों को अपने आप संभालता है।

चैनल Proto टाइप

मैसेज टाइपविवरण
ChannelSendRequestजाने वाले संदेश का एनवेलप, जिसमें message_id, channelId, sender, text, attachments, reply_to, actions, platform_data होते हैं
ChannelSendResponseथ्रेडिंग के लिए प्लेटफ़ॉर्म संदेश ID
InboundMessageआने वाले संदेश का एनवेलप, जिसमें सभी साझा फ़ील्ड + timestamp होते हैं
MessageSenderबॉट की पहचान (name, role, botId) — ब्रोकर द्वारा पूरी की जाती है
Attachmentफ़ाइल/इमेज/ऑडियो अटैचमेंट (type, url, filename, size)
MessageActionइंटरैक्टिव बटन/कीबोर्ड एक्शन (label, callback_id)

बॉट की पहचान और भूमिकाएँ

Nebo बॉट्स की पहचान तीन धुरियों वाले मॉडल पर आधारित है:

  • creature — बॉट क्या है (आदिरूप): "तेज़-तर्रार रणनीतिकार", "बारीकी से काम करने वाला शोधकर्ता"
  • role — उपयोगकर्ता से उसका रिश्ता क्या है: "दोस्त", "COO", "मार्गदर्शक"
  • vibe — उसकी ऊर्जा (बातचीत का अंदाज़): "बेफ़िक्र पर अपनी राय रखने वाला", "गर्मजोशी भरा और हौसला बढ़ाने वाला"

जब आपके चैनल प्लगइन को कोई जाने वाला संदेश मिलता है, तो sender फ़ील्ड में बॉट का name और role होता है। अपने प्लेटफ़ॉर्म के लिए डिस्प्ले नेम फ़ॉर्मेट करने में इसका इस्तेमाल करें। role कोई पद नहीं है — यह रिश्ते का वर्णन है। "COO" और "DevLead" के साथ-साथ "दोस्त", "बेटा" और "मार्गदर्शक" भी मान्य भूमिकाएँ हैं।