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 انسٹال کریں

باضابطہ SDKs تمام 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[]قابلِ ترتیب سیٹنگز (ترتیبات 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 میں "سیٹ اپ درکار" کا بیج دکھاتی ہیں۔

قسمتفصیل
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"
scopesOAuth اسکوپس کا ارے جو ایپ کو درکار ہیں

جب صارف ایپ انسٹال کرتا ہے، تو 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. بائنری کی توثیق (symlinks، اسکرپٹس، غیر ایگزیکیوٹیبل اور حد سے بڑی فائلیں مسترد کرتا ہے)
  7. پچھلے رن کا پرانا ساکٹ صاف کرتا ہے
  8. سینڈ باکس اسٹوریج کے لیے data/ ڈائریکٹری بناتا ہے
  9. ہر ایپ کے لیے لاگ فائلیں سیٹ کرتا ہے (logs/stdout.log، logs/stderr.log)
  10. صاف کیے ہوئے ماحول اور پروسیس گروپ کی علیحدگی کے ساتھ بائنری شروع کرتا ہے
  11. Unix ساکٹ کے ظاہر ہونے کا انتظار کرتا ہے (exponential backoff، زیادہ سے زیادہ 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. باقی تمام فیلڈز کارروائی سے مخصوص پیرامیٹرز ہیں
  4. action enum کی تفصیل میں تمام دستیاب کارروائیوں کی فہرست ہونی چاہیے

STRAP کیوں اہم ہے:

  • LLMs action روٹنگ کا پیٹرن ایک بار سیکھ کر تمام کارروائیوں پر لاگو کر لیتے ہیں
  • ٹول کی تعریفیں سیاق و سباق کا ~6% استعمال کرتی ہیں — STRAP اسے 80% کم کر دیتا ہے
  • نئی کارروائیاں صرف enum میں اضافے ہیں، نئے ٹول کی رجسٹریشن نہیں
  • ہوسٹڈ اور مقامی ماڈلز پر یکساں کام کرتا ہے

Go مثال — کیلکولیٹر ٹول

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    nebo "github.com/neboloop/nebo-sdk-go"
)

type Calculator struct{}

func (c *Calculator) Name() string        { return "calculator" }
func (c *Calculator) Description() string { return "Performs arithmetic calculations." }

func (c *Calculator) Schema() json.RawMessage {
    return nebo.NewSchema("add", "subtract", "multiply", "divide").
        Number("a", "First operand", true).
        Number("b", "Second operand", true).
        Build()
}

func (c *Calculator) Execute(_ context.Context, input json.RawMessage) (string, error) {
    var in struct {
        Action string  `json:"action"`
        A      float64 `json:"a"`
        B      float64 `json:"b"`
    }
    if err := json.Unmarshal(input, &in); err != nil {
        return "", fmt.Errorf("invalid input: %w", err)
    }

    var result float64
    switch in.Action {
    case "add":
        result = in.A + in.B
    case "subtract":
        result = in.A - in.B
    case "multiply":
        result = in.A * in.B
    case "divide":
        if in.B == 0 {
            return "", fmt.Errorf("division by zero")
        }
        result = in.A / in.B
    default:
        return "", fmt.Errorf("unknown action: %s", in.Action)
    }

    return fmt.Sprintf("%g %s %g = %g", in.A, in.Action, in.B, result), nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterTool(&Calculator{})
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.calculator",
    "name": "Calculator",
    "version": "1.0.0",
    "description": "Arithmetic calculator tool for the agent",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["tool:calculator"],
    "permissions": []
}

بلڈ اور انسٹال کریں:

go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/

Rust مثال

use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;

struct Calculator;

#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }

#[async_trait]
impl ToolHandler for Calculator {
    fn name(&self) -> &str { "calculator" }
    fn description(&self) -> &str { "Performs arithmetic calculations." }
    fn schema(&self) -> Value {
        SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
            .number("a", "First operand", true)
            .number("b", "Second operand", true)
            .build()
    }
    async fn execute(&self, input: Value) -> Result<String, NeboError> {
        let i: Input = serde_json::from_value(input)
            .map_err(|e| NeboError::Execution(e.to_string()))?;
        let r = match i.action.as_str() {
            "add" => i.a + i.b,
            "subtract" => i.a - i.b,
            "multiply" => i.a * i.b,
            "divide" => {
                if i.b == 0.0 {
                    return Err(NeboError::Execution("division by zero".into()));
                }
                i.a / i.b
            }
            other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
        };
        Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    NeboApp::new()?.register_tool(Calculator).run().await?;
    Ok(())
}

C مثال

#include <nebo/nebo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int calculator_execute(const char *input_json, char **output, int *is_error) {
    /* Parse JSON, compute result, set *output */
    *output = strdup("2 add 3 = 5");
    *is_error = 0;
    return 0;
}

int main(void) {
    const char *actions[] = {"add", "subtract", "multiply", "divide", NULL};
    nebo_schema_builder_t *sb = nebo_schema_new(actions);
    nebo_schema_number(sb, "a", "First operand", 1);
    nebo_schema_number(sb, "b", "Second operand", 1);
    char *schema = nebo_schema_build(sb);
    nebo_schema_free(sb);

    nebo_tool_handler_t calculator = {
        .name = "calculator",
        .description = "Performs arithmetic calculations.",
        .schema = schema,
        .execute = calculator_execute,
    };

    nebo_app_t *app = nebo_app_new();
    nebo_app_register_tool(app, &calculator);
    int ret = nebo_app_run(app);
    free(schema);
    return ret;
}

چینل ایپس

"provides": ["channel:my_channel"] اور "permissions": ["channel:send"] ظاہر کریں۔

چینل ایپس بیرونی پیغام رسانی پلیٹ فارمز (Telegram، Discord، Slack، وغیرہ) کو Nebo کے AI ملازم سے جوڑتی ہیں۔ جب کوئی صارف بیرونی پلیٹ فارم پر پیغام بھیجتا ہے، تو آپ کی ایپ اسے Receive کے ذریعے Nebo تک اسٹریم کرتی ہے۔ جب AI ملازم جواب دینا چاہتا ہے، تو Nebo آپ کی ایپ کا Send کال کرتا ہے۔

یہ کیسے کام کرتا ہے

  1. Nebo آپ کے چینل کا منفرد شناخت کنندہ حاصل کرنے کے لیے ID() کال کرتا ہے
  2. Nebo آپ کی ایپ کی ترتیبات سے کنفیگریشن کے ساتھ Connect() کال کرتا ہے
  3. Nebo ایک Receive() اسٹریم کھولتا ہے — جب بھی کوئی صارف بوٹ کو پیغام بھیجے، آپ کی ایپ آنے والے پیغامات بھیجتی ہے
  4. آنے والے پیغامات AI ملازم کی مرکزی گفتگو کی لین تک پہنچائے جاتے ہیں
  5. جب AI ملازم پیغام بھیجنا چاہتا ہے، تو Nebo v1 پیغام لفافے کے ساتھ Send() کال کرتا ہے
  6. بند ہونے پر Nebo Disconnect() کال کرتا ہے

v1 پیغام لفافہ

تمام چینل پیغامات — آنے والے اور جانے والے — مشترکہ پیغام لفافہ استعمال کرتے ہیں:

{
  "message_id": "01953f8a-...",
  "channel_id": "telegram:12345",
  "sender": { "name": "Alex", "role": "COO", "bot_id": "uuid" },
  "text": "Q3 numbers look good...",
  "attachments": [{ "type": "image", "url": "https://...", "filename": "chart.png", "size": 45000 }],
  "reply_to": "01953f89-...",
  "actions": [{ "label": "Approve", "callback_id": "approve_q3" }],
  "platform_data": null,
  "timestamp": "2026-02-12T15:10:00Z"
}
فیلڈقسمتفصیل
message_idUUID v7وقت کی ترتیب والی منفرد ID
channel_id{type}:{platform_id}روٹ کیا جا سکنے والا چینل شناخت کنندہ
senderobjectبوٹ کی شناخت — name، role، botId
textstringپیغام کا متن
attachmentsarrayفائلیں، تصاویر، آڈیو
reply_toUUID v7تھریڈنگ کے لیے والد پیغام کی ID
actionsarrayانٹرایکٹو بٹنز/کی بورڈز
platform_databytesپلیٹ فارم کے مخصوص فیچرز کے لیے مبہم پاس تھرو
timestampISO 8601پبلشر اسے مقرر کرتا ہے

دو تہوں والا ڈیزائن: مشترکہ فیلڈز (text، attachments، reply_to، actions) ملازم کی طرف سے شروع کیے گئے 90% پیغامات کا احاطہ کرتی ہیں۔ پلیٹ فارم کے مخصوص فیچرز platform_data میں جاتے ہیں — آپ کا پلگ ان انہیں نیٹو پلیٹ فارم فارمیٹ میں اور اس سے میپ کرتا ہے۔

گفتگو کی اسٹریمز

علیحدگی کے لیے چینل کے پیغامات ہر چینل کی الگ گفتگو اسٹریم پر بھیجے جاتے ہیں:

neboai/bot/{botID}/channels/{channelType}/inbound    # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound   # messages from agent → channel

Go مثال — Telegram چینل

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "time"

    "github.com/google/uuid"
    tgbot "github.com/go-telegram/bot"
    nebo "github.com/neboloop/nebo-sdk-go"
)

type Telegram struct {
    bot      *tgbot.Bot
    messages chan nebo.ChannelEnvelope
    cancel   context.CancelFunc
}

func (t *Telegram) ID() string { return "telegram" }

func (t *Telegram) Connect(_ context.Context, config map[string]string) error {
    token := config["bot_token"]
    if token == "" {
        return fmt.Errorf("bot_token is required")
    }

    botCtx, cancel := context.WithCancel(context.Background())
    t.cancel = cancel

    bot, err := tgbot.New(token, tgbot.WithDefaultHandler(
        func(bCtx context.Context, b *tgbot.Bot, update *tgbot.Update) {
            if update.Message == nil {
                return
            }
            env := nebo.ChannelEnvelope{
                MessageID: uuid.Must(uuid.NewV7()).String(),
                ChannelID: fmt.Sprintf("telegram:%d", update.Message.Chat.ID),
                Text:      update.Message.Text,
                Timestamp: time.Unix(int64(update.Message.Date), 0).UTC(),
            }
            t.messages <- env
        },
    ))
    if err != nil {
        return err
    }

    t.bot = bot
    go bot.Start(botCtx)
    return nil
}

func (t *Telegram) Send(ctx context.Context, env nebo.ChannelEnvelope) (string, error) {
    if t.bot == nil {
        return "", fmt.Errorf("not connected")
    }
    chatID := env.ChannelID[len("telegram:"):]
    params := &tgbot.SendMessageParams{
        ChatID: chatID,
        Text:   env.Text,
    }
    msg, err := t.bot.SendMessage(ctx, params)
    if err != nil {
        return "", err
    }
    return fmt.Sprintf("%d", msg.MessageID), nil
}

func (t *Telegram) Receive(_ context.Context) (<-chan nebo.ChannelEnvelope, error) {
    return t.messages, nil
}

func (t *Telegram) Disconnect(_ context.Context) error {
    if t.cancel != nil {
        t.cancel()
    }
    return nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterChannel(&Telegram{
        messages: make(chan nebo.ChannelEnvelope, 100),
    })
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.telegram",
    "name": "Telegram",
    "version": "1.0.0",
    "description": "Telegram messaging channel for Nebo",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["channel:telegram"],
    "permissions": ["channel:send", "network:outbound"],
    "settings": [
        {
            "key": "bot_token",
            "title": "Bot Token",
            "type": "password",
            "required": true,
            "description": "Telegram bot token from @BotFather",
            "secret": true
        }
    ]
}

مزید صلاحیتیں

Comm ایپ

"provides": ["comm"] اور "permissions": ["comm:*"] ظاہر کریں۔ Comm ایپس AI ملازمین کے درمیان رابطہ ممکن بناتی ہیں۔

فیلڈتفصیل
fromبھیجنے والے ملازم کی ID
toوصول کنندہ ملازم کی ID
topicپیغام کا موضوع/چینل
type"message"، "mention"، "proposal"، "command"، "info"، "task"
contentپیغام کا متن

اہم رویے:

  • Register اس AI ملازم کو اس کی صلاحیتوں کے ساتھ نیٹ ورک پر متعارف کراتا ہے
  • Subscribe/Unsubscribe موضوعات کی سبسکرپشنز سنبھالتے ہیں
  • Receive آنے والے پیغامات اسٹریم کرتا ہے (server-streaming، چینلز کی طرح)
  • ایک وقت میں صرف ایک 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 ہینڈلرز لکھیں — 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 ایک server-streaming 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 ملازم کے لیے ٹول کی ہدایات

نکالتے وقت سکیورٹی کے اصول:

  • راستے سے باہر جانے کی اجازت نہیں (../ مسترد)
  • symlinks کی اجازت نہیں (مسترد)
  • مطلق راستوں کی اجازت نہیں (مسترد)
  • صرف منظور شدہ فہرست والے فائل نام قبول کیے جاتے ہیں

دستخط

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/ میں ہوتی ہیں۔ SDKs پہلے سے تیار شدہ کوڈ کے ساتھ آتے ہیں، اس لیے عام ڈویلپمنٹ کے لیے آپ کو protoc کی ضرورت نہیں۔

فائلسروساہم RPCs
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 RPCs شامل ہیں۔ 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" کے ساتھ ساتھ درست کردار ہیں۔