ओवरव्यू
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) न्यूनतम ऐप चेकलिस्ट
id,name,version,providesके साथmanifest.jsonबनाएँTOOL.mdलिखें, जिसमें बताया गया हो कि AI कर्मचारी को आपका टूल कैसे इस्तेमाल करना चाहिए- 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 | क्रॉन जॉब प्रबंधन |
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 में "सेटअप ज़रूरी" बैज दिखता है।
| टाइप | विवरण |
|---|---|
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 से वितरित ऐप्स के लिए, डेव मोड में छोड़ दिया जाता है)
- बाइनरी की जाँच (सिमलिंक, स्क्रिप्ट, गैर-एक्ज़िक्यूटेबल और बहुत बड़ी फ़ाइलें अस्वीकार करता है)
- पिछले रन का पुराना सॉकेट साफ़ करता है
- सैंडबॉक्स स्टोरेज के लिए
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") स्कीमा के नियम:
- हमेशा एक
actionफ़ील्ड ज़रूरी स्ट्रिंग enum के रूप में शामिल करें resourceफ़ील्ड (ज़रूरी स्ट्रिंग enum) तभी जोड़ें जब आपका टूल कई अलग-अलग रिसोर्स टाइप संभालता हो- बाकी सभी फ़ील्ड action-विशिष्ट पैरामीटर हैं
actionenum के विवरण में सभी उपलब्ध 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 कॉल करता है।
यह कैसे काम करता है
- 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 | बॉट की पहचान — नाम, भूमिका, 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 ऐप सक्रिय हो सकता है
गेटवे ऐप
गेटवे ऐप 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.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>"
} डेव मोड में (कोई NeboAI URL कॉन्फ़िगर नहीं), सिग्नेचर सत्यापन पूरी तरह छोड़ दिया जाता है। लोकल डेवलपमेंट के लिए आपको signatures.json की ज़रूरत नहीं है।
पब्लिश करना
जब आपका ऐप लोकल रूप से काम करने लगे, तो उसे NeboAI के ज़रिए पब्लिश करें ताकि वह सभी Nebo उपयोगकर्ताओं तक पहुँचे।
डेवलपर अकाउंट सेटअप
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 फ़्रंटमैटर, और एक 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 | (सिर्फ़ messages) | 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 होता है। अपने प्लेटफ़ॉर्म के लिए डिस्प्ले नेम फ़ॉर्मेट करने में इसका इस्तेमाल करें। role कोई पद नहीं है — यह रिश्ते का वर्णन है। "COO" और "DevLead" के साथ-साथ "दोस्त", "बेटा" और "मार्गदर्शक" भी मान्य भूमिकाएँ हैं।