NeboAI
NeboAI
Kòmanse

Konstwi aplikasyon pou Nebo

Bay IA w nouvo sipèpouvwa. Zouti, kanal, pasrèl, panèl UI — nenpòt bagay ou ka imajine, konpile an yon binè natif.

Apèsi

Kisa Nebo ye

Nebo se yon asistan IA pèsonèl sou òdinatè — yon anplwaye IA ki toujou ap fonksyone e ki jere lavi dijital ou. Panse a Nebo menm jan ou panse a yon smartphone: yon platfòm pisan ki vin transfòme tout bagay gras ak aplikasyon li yo.

Poukont li, Nebo se yon anplwaye IA kapab ki gen memwa, planifikasyon, navigasyon sou entènèt, jesyon fichye ak aksè nan shell. Men vrè kle a se Aplikasyon yo. Menm jan pouvwa yon smartphone soti nan ekosistèm aplikasyon li, pouvwa Nebo soti nan aplikasyon ki elaji sa li ka fè.

Kisa Aplikasyon yo ye

Aplikasyon Nebo yo se inite endepandan, ki deja konpile, ki gen yon fonksyonalite enkwayab. Chak aplikasyon bay Nebo yon nouvo sipèpouvwa — jesyon kalandriye, triyaj imèl, swivi pwojè, otomatizasyon lakay, analiz finansye — nenpòt bagay yon devlopè ka imajine.

Aplikasyon yo bay yon pouvwa enkwayab yon fason ki an sekirite anpil. Chak aplikasyon fonksyone nan yon sandbox ak pèmisyon ki refize pa defo. Li ka jwenn aksè sèlman nan sa manifès li deklare epi itilizatè a apwouve.

Entèfas la se 100% konvèsasyon. Itilizatè yo pa itilize aplikasyon yo atravè ekran oswa tablo bò apa. Yo pale ak Nebo, epi Nebo itilize zouti aplikasyon an pou fè bagay yo. "Kisa ki sou kalandriye m demen?" — Nebo rele aplikasyon kalandriye a. "Kreye yon reyinyon ak Sarah a 3pm" — Nebo rele aplikasyon kalandriye a. Itilizatè a pa janm kite konvèsasyon an.

Aplikasyon yo ka bay yon UI paramèt si yo vle — yon panèl konfigirasyon ki louvri nan fenèt navigatè entegre Nebo a. Se la itilizatè yo antre kle API, aktive oswa dezaktive fonksyonalite, epi konfigire aplikasyon an. UI paramèt la baze sou tablo settings nan manifès la (Nebo afiche fòmilè a otomatikman), oswa aplikasyon an ka bay pwòp UI pèsonalize konplè pa l atravè kapasite ui a.

Aplikasyon yo ranplase epi elaji kapasite entegre Nebo yo. Nebo vini ak zouti platfòm debaz (aksè kalandriye lokal, kapti ekran, elatriye). Lè w enstale yon aplikasyon kalandriye, li ranplase zouti kalandriye entegre a epi li vin yon vèsyon pi laj — lokal + nwaj + agregasyon + verifikasyon disponiblite.

Politik konpile sèlman

Nebo aplike yon politik strik: binè konpile sèlman. Tout aplikasyon dwe egzekitab natif ki konpile.

EstatiLang
SipòteGo (rekòmande), Rust, C/C++, Zig
RejtePython, Node.js, Ruby, Java, .NET, script shell

Rezon:

  • Anpeche IA modifye tèt li — Yon anplwaye IA ki gen aksè nan shell ta ka modifye konpòtman yon script entèprete pandan l ap fonksyone. Binè konpile pa ka chanje apre yo siyen.
  • Entegrite siyati — Siyati Ed25519 kouvri oktè brit binè a. Yon binè siyen pa ka modifye san sa pa anile siyati a.
  • Aplikasyon sandbox — Validasyon fòma binè (oktè majik ELF/Mach-O/PE) se yon baryè rapid e fyab.

Demaraj rapid

Enstale SDK a

SDK ofisyèl yo okipe tout konfigirasyon sèvè gRPC, jesyon siyal ak pon pwotokòl. Ou jis aplike entèfas handler yo.

Go (rekòmande):

go get github.com/neboloop/nebo-sdk-go

Rust (ap vini byento):

# Coming soon
[dependencies]
nebo-sdk = "0.1"

C/C++ (ap vini byento):

# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/

Estrikti dosye aplikasyon

Aplikasyon yo rete nan sou-dosye apps/ nan dosye done Nebo w la:

~/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)

Lis verifikasyon aplikasyon minimòm

  1. Kreye manifest.json ak id, name, version, provides
  2. Ekri TOOL.md pou dekri kijan anplwaye IA a dwe itilize zouti w la
  3. Enstale SDK a (go get github.com/neboloop/nebo-sdk-go)
  4. Aplike entèfas handler pou kapasite w la (ToolHandler, ChannelHandler, elatriye)
  5. Anrejistre handler a epi rele app.Run()
  6. Konstwi yon binè natif (go build -o binary .)
  7. Mete binè + manifest.json + TOOL.md nan dosye apps/<your-app-id>/
  8. Nebo dekouvri l epi lanse l otomatikman

Konfigirasyon

manifest.json

Chak aplikasyon bezwen yon 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
        }
    ]
}

Chan obligatwa:

ChanDeskripsyon
idIdantifyan domèn alanvè (pa egzanp, com.mycompany.myapp)
nameNon moun ka li
versionChèn semver
providesOmwen yon kapasite (gade anba a)

Chan opsyonèl:

ChanDefoDeskripsyon
runtime"local""local" oswa "remote"
protocol"grpc"Se sèlman "grpc" ki sipòte
permissions[]Sa aplikasyon an bezwen aksè ladan l
description""Parèt nan UI a
settings[]Paramèt ou ka konfigire (afiche nan UI Paramèt la)
oauth[]Egzijans founisè OAuth (gade seksyon OAuth anba a)

Kapasite

Deklare sa aplikasyon w lan bay:

KapasiteSèvis gRPCDeskripsyon
gatewayGatewayServiceRoutaj modèl LLM
tool:<name>ToolServiceYon zouti ki gen non pou anplwaye IA a
channel:<name>ChannelServiceYon kanal mesaj
commCommServiceKominikasyon ant anplwaye IA yo
uiUIServiceUI pèsonalize ak proxy HTTP
scheduleScheduleServicePlanifikasyon pèsonalize
visionToolServiceTretman vizyon
browserToolServiceOtomatizasyon navigatè

Yon aplikasyon ka bay plizyè kapasite. Pa egzanp, yon aplikasyon ka bay ni yon zouti ni yon panèl UI.

Pèmisyon

Pèmisyon kontwole sa aplikasyon an ka jwenn aksè ladan l. Refize pa defo — si l pa deklare, aplikasyon an pa ka itilize l.

PrefiksEgzanpDeskripsyon
network:network:outbound, network:*Aksè rezo
filesystem:filesystem:read, filesystem:writeAksè sistèm fichye
memory:memory:read, memory:writeAksè memwa anplwaye IA
session:session:readSesyon konvèsasyon
tool:tool:shell, tool:fileItilize lòt zouti
shell:shell:execEgzekisyon kòmand shell
channel:channel:send, channel:*Operasyon kanal
comm:comm:send, comm:*Kominikasyon ant anplwaye IA yo
model:model:chatAksè modèl IA
user:user:tokenResevwa JWT itilizatè a nan demann yo
schedule:schedule:createJesyon travay cron
database:database:queryAksè baz done
storage:storage:read, storage:writeDepo pèmanan
context:context:readAksè kontèks anplwaye IA
subagent:subagent:spawnOperasyon sou-ajan
lane:lane:enqueueOperasyon lane
notification:notification:sendNotifikasyon push
embedding:embedding:searchAksè vector embedding
skill:skill:invokeEnvokasyon konpetans
advisor:advisor:consultAksè sistèm konseye
mcp:mcp:connectAksè sèvè MCP
voice:voice:recordAksè vwa/odyo
browser:browser:navigateOtomatizasyon navigatè
oauth:oauth:google, oauth:*Aksè token OAuth
settings:settings:readAksè paramèt
capability:capability:registerAnrejistreman kapasite

Pèmisyon joker sipòte: network:* koresponn ak nenpòt verifikasyon pèmisyon network:.

Paramèt

Paramèt yo parèt nan UI Nebo a anba panèl paramèt aplikasyon an. Nebo sere yo nan baz done a epi voye yo bay aplikasyon w lan atravè RPC Configure lè yo chanje.

Chema paramèt ou a enkli nan fich magazen aplikasyon NeboAI a. Aplikasyon ki gen paramèt obligatwa ki pa konfigire montre yon badj "Bezwen konfigirasyon" nan UI a.

KaliteDeskripsyon
textChan tèks yon sèl liy
passwordChan tèks maske
toggleBouton limen/etenn boolean
selectLis dewoulan ak opsyon ki defini davans
numberChan nimerik
urlChan URL ak validasyon
{
    "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"}
    ]
}

Egzijans OAuth

Aplikasyon yo ka deklare egzijans founisè OAuth. Koutye OAuth Nebo a okipe tout pwosesis la — aplikasyon yo resevwa token otomatikman atravè RPC Configure.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
ChanDeskripsyon
providerFounisè OAuth: "google", "microsoft", "github"
scopesTablo scope OAuth aplikasyon an bezwen

Lè itilizatè a enstale aplikasyon an, Nebo mande l otorize scope OAuth ki nesesè yo. Aplikasyon an resevwa token renouvle atravè RPC Configure san li pa bezwen okipe pwosesis OAuth la li menm.

Varyab anviwònman

Pwosesis aplikasyon w lan resevwa yon anviwònman netwaye. Tout sekrè retire. Ou jwenn:

VaryabValè
NEBO_APP_DIRDosye enstalasyon aplikasyon an
NEBO_APP_SOCKChemen sokèt Unix pou kreye a
NEBO_APP_IDID aplikasyon an nan manifès la
NEBO_APP_NAMENon aplikasyon an nan manifès la
NEBO_APP_VERSIONVèsyon aplikasyon an nan manifès la
NEBO_APP_DATAChemen dosye data/ aplikasyon an
PATHPATH sistèm nan (transmèt jan l ye)
HOMEDosye lakay itilizatè a (transmèt jan l ye)
TMPDIRDosye tanporè (transmèt jan l ye)

Enpòtan anpil: Binè w la dwe kreye yon sèvè gRPC k ap koute sou sokèt Unix ki nan NEBO_APP_SOCK. Nebo tann jiska 10 segonn pou sokèt sa a parèt.

Sekans lansman aplikasyon an

  1. Nebo li manifest.json epi li valide l
  2. Li jwenn egzekitab binary oswa app nan dosye aplikasyon an
  3. Li tcheke si gen makè .quarantined (li refize lanse aplikasyon ki an karantèn)
  4. Verifikasyon revokasyon (aplikasyon NeboAI distribye sèlman)
  5. Verifikasyon siyati (aplikasyon NeboAI distribye sèlman, yo sote l an mòd dev)
  6. Validasyon binè (li rejte lyen senbolik, script, sa ki pa egzekitab, fichye ki twò gwo)
  7. Li netwaye ansyen sokèt egzekisyon anvan an
  8. Li kreye dosye data/ pou depo nan sandbox
  9. Li konfigire fichye jounal pou chak aplikasyon (logs/stdout.log, logs/stderr.log)
  10. Li lanse binè a ak anviwònman netwaye ak izolasyon gwoup pwosesis
  11. Li tann sokèt Unix la parèt (reta eksponansyèl, maksimòm 10 segonn)
  12. Li konekte atravè gRPC sou sokèt Unix la
  13. Li kreye kliyan gRPC espesifik pou chak kapasite selon provides
  14. Li fè yon tès sante
  15. Li anrejistre kapasite yo ak anplwaye IA a (zouti, pasrèl, kominikasyon, elatriye)

Aplikasyon zouti

Deklare "provides": ["tool:my_tool_name"] nan manifès ou.

Modèl STRAP la

Tout aplikasyon zouti Nebo dwe itilize STRAP (Single Tool Resource Action Pattern) pou chema yo ak routaj egzekisyon yo. Se menm modèl Nebo itilize anndan l pou rasanble plis pase 35 zouti endividyèl an 4 zouti domèn — sa diminye chaj kontèks LLM a apeprè 80%.

Ide prensipal la: Olye w anrejistre plizyè zouti (get_events, check_availability, suggest_slots), anrejistre YON sèl zouti ak chan action (epi resource si w vle) ki voye bay bon handler a.

Egzanp ak yon sèl resous (kalandriye):

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

Egzanp ak plizyè resous (jesyonè pwojè):

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

Règ chema:

  1. Toujou mete yon chan action kòm yon enum chèn obligatwa
  2. Ajoute yon chan resource (enum chèn obligatwa) sèlman si zouti w la jere plizyè kalite resous diferan
  3. Tout lòt chan yo se paramèt espesifik pou chak aksyon
  4. Deskripsyon enum action la dwe bay lis tout aksyon ki disponib

Poukisa STRAP enpòtan:

  • LLM yo aprann modèl routaj action la yon sèl fwa epi yo jeneralize l pou tout operasyon
  • Definisyon zouti yo pran apeprè 6% kontèks la — STRAP diminye sa 80%
  • Nouvo operasyon se jis ajou nan enum, pa nouvo anrejistreman zouti
  • Li mache menm jan ak modèl ebèje kou modèl lokal

Egzanp Go — Zouti kalkilatris

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": []
}

Konstwi epi enstale:

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/

Egzanp 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(())
}

Egzanp 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;
}

Aplikasyon kanal

Deklare "provides": ["channel:my_channel"] ak "permissions": ["channel:send"].

Aplikasyon kanal yo fè pon ant platfòm mesaj ekstèn (Telegram, Discord, Slack, elatriye) ak anplwaye IA Nebo a. Lè yon itilizatè voye yon mesaj sou platfòm ekstèn lan, aplikasyon w lan voye l an flo bay Nebo atravè Receive. Lè anplwaye IA a vle reponn, Nebo rele Send aplikasyon w lan.

Kijan sa mache

  1. Nebo rele ID() pou jwenn idantifyan inik kanal ou a
  2. Nebo rele Connect() ak konfigirasyon ki soti nan paramèt aplikasyon w lan
  3. Nebo louvri yon flo Receive() — aplikasyon w lan voye mesaj k ap antre chak fwa yon itilizatè voye mesaj bay bot la
  4. Mesaj k ap antre yo voye nan lane konvèsasyon prensipal anplwaye IA a
  5. Lè anplwaye IA a vle voye yon mesaj, Nebo rele Send() ak anvlòp mesaj v1 la
  6. Lè l ap fèmen, Nebo rele Disconnect()

Anvlòp mesaj v1

Tout mesaj kanal — sa k ap antre ak sa k ap sòti — itilize anvlòp mesaj komen an:

{
  "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"
}
ChanKaliteDeskripsyon
message_idUUID v7ID inik ki klase selon tan
channel_id{type}:{platform_id}Idantifyan kanal ou ka voye mesaj ladan l
senderobjectIdantite bot la — non, wòl, botId
textstringKò mesaj la
attachmentsarrayFichye, imaj, odyo
reply_toUUID v7ID mesaj paran an pou fil diskisyon
actionsarrayBouton/klavye entèaktif
platform_databytesDone opak ki pase tou dwat pou fonksyonalite espesifik platfòm
timestampISO 8601Piblikatè a mete sa

Konsepsyon an de kouch: Chan komen yo (text, attachments, reply_to, actions) kouvri 90% mesaj anplwaye yo voye. Fonksyonalite espesifik platfòm ale nan platform_data — plugin ou a konvèti yo ale/vini nan fòma natif platfòm lan.

Flo konvèsasyon

Mesaj kanal yo voye sou flo konvèsasyon apa pou chak kanal pou izolasyon:

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

Egzanp Go — Kanal 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
        }
    ]
}

Plis kapasite

Aplikasyon kominikasyon

Deklare "provides": ["comm"] ak "permissions": ["comm:*"]. Aplikasyon kominikasyon yo pèmèt kominikasyon ant anplwaye IA yo.

ChanDeskripsyon
fromID anplwaye ki voye a
toID anplwaye ki resevwa a
topicSijè/kanal mesaj la
type"message", "mention", "proposal", "command", "info", "task"
contentKò mesaj la

Konpòtman kle:

  • Register anonse anplwaye IA sa a sou rezo a ak kapasite li yo
  • Subscribe/Unsubscribe jere abònman sijè yo
  • Receive voye mesaj k ap antre an flo (flo bò sèvè, menm jan ak kanal yo)
  • Se yon sèl aplikasyon kominikasyon ki ka aktif alafwa

Aplikasyon pasrèl

Yon aplikasyon pasrèl voye demann LLM bay modèl yo. Deklare "provides": ["gateway"] ak "permissions": ["network:outbound", "user:token"].

GatewayRequest gen mesaj, zouti, prompt sistèm, maksimòm token, tanperati, ak yon UserContext (token JWT si pèmisyon user:token bay).

Kalite GatewayEvent:

KaliteKontniDeskripsyon
"text"Moso tèksToken tèks an flo
"tool_call"JSONModèl la vle rele yon zouti
"thinking"Moso tèksRefleksyon/rezònman pwolonje
"error"Mesaj erèYon bagay pa mache
"done"VidFlo a fini

Aplikasyon UI

Yon aplikasyon UI bay yon entèfas konfigirasyon pèsonalize ki louvri nan fenèt navigatè entegre Nebo a. Deklare "provides": ["ui"]. Kontrèman ak fòmilè paramèt otomatik la (Nebo afiche l apati manifès settings ou a), yon aplikasyon UI sèvi pwòp frontend HTML/CSS/JS konplè pa l.

Aplikasyon w lan vini ak yon dosye ui/ ki gen resous web estatik (HTML, CSS, JS — anjeneral yon SPA ak index.html). Nebo sèvi fichye sa yo dirèkteman epi l voye apèl API yo bay aplikasyon w lan atravè gRPC.

ChemenMekanisObjektif
GET /api/v1/apps/{id}/ui/*Sèvè fichye estatikSèvi fichye ki nan dosye ui/ ou a (SPA retounen sou index.html)
ANY /api/v1/apps/{id}/api/*Proxy gRPCVoye demann HTTP yo bay UIService.HandleRequest() aplikasyon w lan

SDK a vlope yon net/http.ServeMux estanda konsa ou ekri handler HTTP Go nòmal — SDK a okipe pon gRPC a otomatikman.

Egzanp Go — UI tablo:

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 ou a ta fè apèl fetch bay /api/v1/apps/com.example.dashboard/api/status, ki pase atravè proxy a rive nan handler mux ou a.

Aplikasyon planifikasyon

Yon aplikasyon planifikasyon ranplase planifikatè cron entegre Nebo a. Deklare "provides": ["schedule"] ak "permissions": ["schedule:create"].

Lè aplikasyon planifikasyon w lan demare, Nebo voye tout planifikasyon atravè aplikasyon w lan olye motè cron pa defo a. Si aplikasyon w lan kraze, Nebo retounen otomatikman sou motè entegre a.

  • Aplikasyon w lan posede eta planifikasyon an — Nebo pa sere orè yo nan pwòp baz done li lè yon aplikasyon planifikasyon aktif
  • CRUD estanda: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers se yon RPC an flo bò sèvè — aplikasyon w lan voye yon mesaj deklanchman chak fwa yon orè rive
  • Se yon sèl aplikasyon planifikasyon ki ka aktif alafwa

Aplikasyon plizyè kapasite

Yon aplikasyon ka bay plizyè kapasite. Pa egzanp, yon aplikasyon tablo ki gen ni yon zouti ni yon 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())

Anbalaj

Fòma .napp

Pou distribisyon atravè NeboAI, anbale aplikasyon w lan kòm yon fichye .napp (yon achiv tar.gz):

cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md

Fichye obligatwa:

FichyeGwosè maksimòmDeskripsyon
manifest.json1 MBMetadone aplikasyon an
binary oswa app500 MBEgzekitab
signatures.json1 MBSiyati Ed25519
TOOL.md1 MBEnstriksyon zouti pou anplwaye IA a

Règ sekirite pandan ekstraksyon:

  • Pa gen travèse chemen (../ rejte)
  • Pa gen lyen senbolik (rejte)
  • Pa gen chemen absoli (rejte)
  • Se sèlman non fichye ki nan lis otorize ki aksepte

Siyati

NeboAI siyen aplikasyon yo ak Ed25519. Fòma signatures.json la:

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

An mòd dev (pa gen URL NeboAI ki konfigire), verifikasyon siyati a sote nèt. Ou pa bezwen signatures.json pou devlopman lokal.

Piblikasyon

Depi aplikasyon w lan mache lokalman, pibliye l atravè NeboAI pou distribye l bay tout itilizatè Nebo.

Konfigirasyon kont devlopè

  1. Anrejistre yon kont NeboAI nan POST /api/v1/owners/register
  2. Konekte pou w jwenn yon token JWT: POST /api/v1/owners/login
  3. Kreye yon kont devlopè: POST /api/v1/developer/accounts

Pwosesis soumisyon

draft → pending_review → [approved] → published
                       → [rejected] → draft (fix and resubmit)

Etap 1: Kreye aplikasyon an

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

Etap 2: Telechaje binè platfòm yo

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"

Telechaje yon binè pou chak platfòm: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.

Etap 3: Soumèt pou revizyon

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
  -H "Authorization: Bearer $TOKEN"

Pwosesis revizyon

  1. Eskanaj otomatik — binè yo eskane atravè VirusTotal
  2. Revizyon administratè — ekip NeboAI a revize metadone, manifès ak rezilta eskanaj yo
  3. Lè l apwouve — NeboAI siyen aplikasyon an ak Ed25519 epi pibliye l
  4. Lè l rejte — ou resevwa yon rezon epi ou ka korije l epi soumèt li ankò

Tan revizyon nou vize: <24 èdtan.

Voye mizajou

  1. Mete vèsyon aplikasyon an ajou: PUT /api/v1/developer/apps/{id} ak nouvo vèsyon an
  2. Telechaje nouvo binè pou chak platfòm
  3. Soumèt pou revizyon ankò

Chak mizajou pase nan menm pwosesis revizyon an. Vèsyon anvan yo rete disponib jiskaske nouvo vèsyon an apwouve.

Metadone magazen

ChanDeskripsyon
categorypa egzanp, productivity, communication, developer-tools
iconURL ikòn aplikasyon an
visibilitypublic oswa private
descriptionKa pi long/pi rich pase deskripsyon manifès la

Flo travay devlopman

Devlopman lokal

Pa bezwen anbalaj pou devlopman lokal:

  1. Kreye dosye aplikasyon w lan:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Ekri manifest.json ou ak kòd ou
  3. Konpile binè w lan:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo detekte nouvo dosye a otomatikman (oswa rekòmanse Nebo)
  5. Apre chanjman nan kòd la, rekonstwi binè a — siveyan fichye a ap rekòmanse aplikasyon an

Gade jounal yo

stdout/stderr aplikasyon an anrejistre nan fichye jounal pou chak aplikasyon:

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

Done pèmanan

Itilize dosye data/ la (ki disponib tou kòm varyab anviwònman NEBO_APP_DATA) pou nenpòt fichye aplikasyon w lan bezwen kenbe. Dosye sa a rete apre mizajou aplikasyon ak karantèn.

Konsèy pou debogaj

  • Si aplikasyon w lan pa demare, tcheke logs/stderr.log pou erè
  • Asire w binè a egzekitab (chmod +x binary)
  • Asire w w ap koute sou chemen sokèt Unix ki nan NEBO_APP_SOCK
  • Sokèt la dwe pare nan 10 segonn apre lansman an
  • Itilize NEBO_APP_DATA pou depo, pa chemen ki ekri dirèk nan kòd la
  • Ekri sou stderr pou jounal debogaj (anrejistre nan logs/stderr.log)

Verifikasyon

# 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

Dezenstalasyon

nebo apps uninstall com.example.myapp

Konpetans

Kisa Konpetans yo ye

Konpetans yo se seri enstriksyon ki fòme fason Nebo aji pandan yon konvèsasyon. Lè yon konpetans aktif, kontni li enjekte dirèkteman nan prompt sistèm nan — li gide ton anplwaye IA a, metòd li, ekspètiz li nan domèn nan, ak fason li itilize zouti pou sesyon sa a.

Konpetans yo se pa kòd. Yo se dokiman markdown ak metadone YAML. Pa gen konpilasyon, pa gen binè, pa gen gRPC. Yon konpetans se yon fichye SKILL.md nan yon dosye. Se tout.

Konpetans yo depann de kontèks epi yo tanporè. Yo aktive lè yo itil (atravè koresponn deklanchè oswa chajman manyèl), yo rete pou kèk tou, epi yo ekspire lè yo pa nesesè ankò. Sa kenbe kontèks anplwaye IA a lejè — se sèlman gid ki enpòtan kounye a ki nan prompt la.

Konpetans yo konplete aplikasyon yo. Aplikasyon yo bay kapasite ki ka egzekite (zouti, kanal, pasrèl). Konpetans yo bay gid òkestrasyon — kijan pou itilize zouti sa yo byen. Yon aplikasyon kalandriye bay Nebo kapasite pou li epi ekri evènman. Yon konpetans "preparasyon reyinyon" di Nebo kijan pou l prepare reyinyon lè l itilize aplikasyon kalandriye a, imèl, ak rechèch sou entènèt ansanm.

Konpetans kont Aplikasyon

KonpetansAplikasyon
FòmaMarkdown (SKILL.md)Binè konpile (.napp)
EgzekisyonEnjekte nan prompt sistèm nanPwosesis nan sandbox atravè gRPC
BayGid konpòtman, metòdZouti, kanal, panèl UI
DireLimite a sesyon an, ekspire selon TTLToujou ap fonksyone
KreyasyonEkri yon fichye markdownEkri, konpile, siyen, anbale
SekiritePa bezwen pèmisyonSandbox ki refize pa defo

Demaraj rapid

Kreye yon dosye nan dosye konpetans Nebo w la ak yon fichye SKILL.md:

~/Library/Application Support/Nebo/skills/   # macOS
~/.config/nebo/skills/                        # Linux
%AppData%\Nebo\skills\                        # Windows
mkdir -p ~/.config/nebo/skills/my-skill

Ekri yon 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 siveye dosye konpetans yo ak fsnotify. Konpetans ou a disponib touswit — pa bezwen rekòmanse. Di yon bagay ki koresponn ak yon deklanchè, epi li aktive otomatikman.

Oswa mande Nebo dirèkteman: "Kreye yon konpetans pou ekri atik blog" — Nebo ap ekri fichye SKILL.md la pou ou.

Fòma SKILL.md

Chak konpetans se yon sèl fichye SKILL.md ak de pati: frontmatter YAML ant makè --- yo, ak yon kò markdown (enstriksyon tout bon ki enjekte nan prompt sistèm nan).

ChanObligatwaDefoDeskripsyon
nameWi—Idantifyan inik (li vin slug la)
descriptionWi—Deskripsyon yon sèl liy ki parèt nan katalòg konpetans lan
versionNon"1.0.0"Semver pou swiv mizajou yo
authorNon—Otè konpetans lan
priorityNon0Pi wo = koresponn an premye (100+ pou ranplasman kritik)
max_turnsNon4Kantite tou san aktivite anvan ekspirasyon otomatik
triggersNon[]Fraz ki aktive konpetans sa a otomatikman (koresponn pati tèks, san gade majiskil)
toolsNon[]Zouti konpetans sa a prevwa itilize (pou enfòmasyon)
dependenciesNon[]Lòt konpetans ki dwe enstale
tagsNon[]Pou klasman ak dekouvèt
platformNon[]Platfòm ki sipòte: macos, linux, windows (vid = tout)

Kijan Konpetans yo aktive

Konpetans yo swiv yon modèl aktivasyon an de faz: sijesyon apre envokasyon.

Faz 1: Koresponn deklanchè — Chak fwa yon itilizatè voye yon mesaj, Nebo egzamine tout konpetans ki anrejistre pou wè si yon deklanchè koresponn. Konpetans ki koresponn yo parèt kòm sijesyon nan prompt sistèm nan. Anplwaye IA a wè sijesyon an epi li deside si l ap envoke konpetans lan.

Faz 2: Envokasyon — Anplwaye IA a envoke yon konpetans lè l rele:

skill(name: "code-review")

Sa retounen tout modèl SKILL.md la kòm rezilta zouti a, anrejistre envokasyon an, epi re-enjekte modèl la nan prompt sistèm nan nan tou ki vini apre yo.

TTL ak ekspirasyon:

  • Konpetans ki koresponn otomatikman: 4 tou san aktivite (ou ka konfigire l ak max_turns)
  • Konpetans ki chaje manyèlman: 6 tou san aktivite
  • Yon nouvo envokasyon remete revèy la a zewo
  • Limit fèm: maksimòm 4 konpetans aktif pou chak sesyon
  • Bidjè token: kontni total konpetans aktif yo limite a 16,000 karaktè

Jere Konpetans yo

Anplwaye IA a ka jere konpetans atravè zouti skill la:

AksyonDeskripsyonEgzanp
catalogBay lis tout konpetans ki disponibskill(action: "catalog")
loadAktive pou sesyon sa askill(name: "code-review", action: "load")
unloadDezaktive yon konpetansskill(name: "code-review", action: "unload")
createKreye yon nouvo konpetans sou disk laskill(action: "create", content: "...")
updateMete ajou yon konpetans ki egzisteskill(name: "my-skill", action: "update", content: "...")
deleteEfase yon konpetans sou disk laskill(name: "my-skill", action: "delete")

Ekri bon Konpetans

Yon bon modèl konpetans genyen:

  1. Yon tit klè — li di anplwaye IA a nan ki mòd li ye
  2. Prensip debaz — règ konpòtman ki pa negosyab
  3. Metòd — apwòch etap pa etap pou sitiyasyon komen
  4. Egzanp — modèl konkrè mesaj itilizatè ak repons
  5. Move pratik — sa pou PA fè (modèl yo aprann byen ak egzanp negatif)

Konsèy: Chak konpetans ta dwe fè yon sèl bagay byen. Pa kreye yon konpetans "pwogramasyon jeneral" — kreye code-review, debugging, api-design kòm konpetans apa. Anplwaye IA a ka gen plizyè ki aktif an menm tan.

Konpetans ki vini ak Nebo

Nebo vini ak konpetans ki kouvri ka itilizasyon komen:

KonpetansPriyoriteDeskripsyon
onboarding100Akèy nouvo itilizatè ak kolekte pwofil
best-friend50Konpetans pèsonalite — dekontrakte, fidèl, pale franchman
debugging25Metòd debogaj sistematik
api-design15Bon pratik konsepsyon API RESTful
code-review10Revizyon kòd estriktire ak nivo gravite
database-expert10Konsepsyon baz done, rekèt, optimizasyon
git-workflow10Branch Git, commit, flo travay PR
security-audit10Analiz sekirite ak deteksyon vilnerabilite

Sa yo sèvi kòm valè pa defo ki itil ak kòm egzanp referans pou kreye pwòp konpetans pa w.

Referans

Fichye Proto

Fichye proto yo rete nan proto/apps/v0/. SDK yo vini ak kòd ki deja jenere, kidonk ou pa bezwen protoc pou devlopman nòmal.

FichyeSèvisRPC kle
v0/common.proto(mesaj sèlman)HealthCheckRequest/Response, SettingsMap, UserContext, Empty
v0/tool.protoToolServiceName, Description, Schema, Execute, RequiresApproval, Configure
v0/channel.protoChannelServiceID, Connect, Disconnect, Send, Receive (flo), Configure
v0/comm.protoCommServiceName, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (flo), Configure
v0/gateway.protoGatewayServiceHealthCheck, Stream (flo), Poll, Cancel, Configure
v0/ui.protoUIServiceHealthCheck, HandleRequest, Configure
v0/schedule.protoScheduleServiceHealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (flo), Configure

Chak sèvis gen RPC HealthCheck ak Configure. SDK a okipe toude otomatikman.

Kalite Proto Kanal

Kalite mesajDeskripsyon
ChannelSendRequestAnvlòp mesaj k ap sòti ak message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponseID mesaj platfòm lan pou fil diskisyon
InboundMessageAnvlòp mesaj k ap antre ak tout chan komen yo + timestamp
MessageSenderIdantite bot la (name, role, botId) — koutye a anrichi l
AttachmentFichye/imaj/odyo tache (type, url, filename, size)
MessageActionAksyon bouton/klavye entèaktif (label, callback_id)

Idantite ak wòl bot yo

Bot Nebo yo gen yon modèl idantite sou twa aks:

  • creature — Kisa bot la ye (achetip): "Estrateg ki gen lespri vif", "Chèchè ki metikuleu"
  • role — Ki relasyon li genyen ak itilizatè a: "Zanmi", "COO", "Mantò"
  • vibe — Enèji li (stil kominikasyon): "Kalm men li gen opinyon", "Cho e ankourajan"

Lè plugin kanal ou a resevwa yon mesaj k ap sòti, chan sender la gen name ak role bot la. Itilize sa pou fòmate non ki parèt sou platfòm ou a. Wòl la se pa yon tit travay — se yon deskripsyon relasyon. "Zanmi", "Pitit gason", ak "Mantò" se wòl valab menm jan ak "COO" ak "DevLead".