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.
| Estati | Lang |
|---|---|
| Sipòte | Go (rekòmande), Rust, C/C++, Zig |
| Rejte | Python, 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
- Kreye
manifest.jsonakid,name,version,provides - Ekri
TOOL.mdpou dekri kijan anplwaye IA a dwe itilize zouti w la - Enstale SDK a (
go get github.com/neboloop/nebo-sdk-go) - Aplike entèfas handler pou kapasite w la (
ToolHandler,ChannelHandler, elatriye) - Anrejistre handler a epi rele
app.Run() - Konstwi yon binè natif (
go build -o binary .) - Mete binè + manifest.json + TOOL.md nan dosye
apps/<your-app-id>/ - 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:
| Chan | Deskripsyon |
|---|---|
id | Idantifyan domèn alanvè (pa egzanp, com.mycompany.myapp) |
name | Non moun ka li |
version | Chèn semver |
provides | Omwen yon kapasite (gade anba a) |
Chan opsyonèl:
| Chan | Defo | Deskripsyon |
|---|---|---|
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:
| Kapasite | Sèvis gRPC | Deskripsyon |
|---|---|---|
gateway | GatewayService | Routaj modèl LLM |
tool:<name> | ToolService | Yon zouti ki gen non pou anplwaye IA a |
channel:<name> | ChannelService | Yon kanal mesaj |
comm | CommService | Kominikasyon ant anplwaye IA yo |
ui | UIService | UI pèsonalize ak proxy HTTP |
schedule | ScheduleService | Planifikasyon pèsonalize |
vision | ToolService | Tretman vizyon |
browser | ToolService | Otomatizasyon 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.
| Prefiks | Egzanp | Deskripsyon |
|---|---|---|
network: | network:outbound, network:* | Aksè rezo |
filesystem: | filesystem:read, filesystem:write | Aksè sistèm fichye |
memory: | memory:read, memory:write | Aksè memwa anplwaye IA |
session: | session:read | Sesyon konvèsasyon |
tool: | tool:shell, tool:file | Itilize lòt zouti |
shell: | shell:exec | Egzekisyon kòmand shell |
channel: | channel:send, channel:* | Operasyon kanal |
comm: | comm:send, comm:* | Kominikasyon ant anplwaye IA yo |
model: | model:chat | Aksè modèl IA |
user: | user:token | Resevwa JWT itilizatè a nan demann yo |
schedule: | schedule:create | Jesyon travay cron |
database: | database:query | Aksè baz done |
storage: | storage:read, storage:write | Depo pèmanan |
context: | context:read | Aksè kontèks anplwaye IA |
subagent: | subagent:spawn | Operasyon sou-ajan |
lane: | lane:enqueue | Operasyon lane |
notification: | notification:send | Notifikasyon push |
embedding: | embedding:search | Aksè vector embedding |
skill: | skill:invoke | Envokasyon konpetans |
advisor: | advisor:consult | Aksè sistèm konseye |
mcp: | mcp:connect | Aksè sèvè MCP |
voice: | voice:record | Aksè vwa/odyo |
browser: | browser:navigate | Otomatizasyon navigatè |
oauth: | oauth:google, oauth:* | Aksè token OAuth |
settings: | settings:read | Aksè paramèt |
capability: | capability:register | Anrejistreman 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.
| Kalite | Deskripsyon |
|---|---|
text | Chan tèks yon sèl liy |
password | Chan tèks maske |
toggle | Bouton limen/etenn boolean |
select | Lis dewoulan ak opsyon ki defini davans |
number | Chan nimerik |
url | Chan 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"]
}
]
} | Chan | Deskripsyon |
|---|---|
provider | Founisè OAuth: "google", "microsoft", "github" |
scopes | Tablo 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:
| Varyab | Valè |
|---|---|
NEBO_APP_DIR | Dosye enstalasyon aplikasyon an |
NEBO_APP_SOCK | Chemen sokèt Unix pou kreye a |
NEBO_APP_ID | ID aplikasyon an nan manifès la |
NEBO_APP_NAME | Non aplikasyon an nan manifès la |
NEBO_APP_VERSION | Vèsyon aplikasyon an nan manifès la |
NEBO_APP_DATA | Chemen dosye data/ aplikasyon an |
PATH | PATH sistèm nan (transmèt jan l ye) |
HOME | Dosye lakay itilizatè a (transmèt jan l ye) |
TMPDIR | Dosye 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
- Nebo li
manifest.jsonepi li valide l - Li jwenn egzekitab
binaryoswaappnan dosye aplikasyon an - Li tcheke si gen makè
.quarantined(li refize lanse aplikasyon ki an karantèn) - Verifikasyon revokasyon (aplikasyon NeboAI distribye sèlman)
- Verifikasyon siyati (aplikasyon NeboAI distribye sèlman, yo sote l an mòd dev)
- Validasyon binè (li rejte lyen senbolik, script, sa ki pa egzekitab, fichye ki twò gwo)
- Li netwaye ansyen sokèt egzekisyon anvan an
- Li kreye dosye
data/pou depo nan sandbox - Li konfigire fichye jounal pou chak aplikasyon (
logs/stdout.log,logs/stderr.log) - Li lanse binè a ak anviwònman netwaye ak izolasyon gwoup pwosesis
- Li tann sokèt Unix la parèt (reta eksponansyèl, maksimòm 10 segonn)
- Li konekte atravè gRPC sou sokèt Unix la
- Li kreye kliyan gRPC espesifik pou chak kapasite selon
provides - Li fè yon tès sante
- 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:
- Toujou mete yon chan
actionkòm yon enum chèn obligatwa - Ajoute yon chan
resource(enum chèn obligatwa) sèlman si zouti w la jere plizyè kalite resous diferan - Tout lòt chan yo se paramèt espesifik pou chak aksyon
- Deskripsyon enum
actionla dwe bay lis tout aksyon ki disponib
Poukisa STRAP enpòtan:
- LLM yo aprann modèl routaj
actionla 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
- Nebo rele
ID()pou jwenn idantifyan inik kanal ou a - Nebo rele
Connect()ak konfigirasyon ki soti nan paramèt aplikasyon w lan - Nebo louvri yon flo
Receive()— aplikasyon w lan voye mesaj k ap antre chak fwa yon itilizatè voye mesaj bay bot la - Mesaj k ap antre yo voye nan lane konvèsasyon prensipal anplwaye IA a
- Lè anplwaye IA a vle voye yon mesaj, Nebo rele
Send()ak anvlòp mesaj v1 la - 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"
} | Chan | Kalite | Deskripsyon |
|---|---|---|
message_id | UUID v7 | ID inik ki klase selon tan |
channel_id | {type}:{platform_id} | Idantifyan kanal ou ka voye mesaj ladan l |
sender | object | Idantite bot la — non, wòl, botId |
text | string | Kò mesaj la |
attachments | array | Fichye, imaj, odyo |
reply_to | UUID v7 | ID mesaj paran an pou fil diskisyon |
actions | array | Bouton/klavye entèaktif |
platform_data | bytes | Done opak ki pase tou dwat pou fonksyonalite espesifik platfòm |
timestamp | ISO 8601 | Piblikatè 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.
| Chan | Deskripsyon |
|---|---|
from | ID anplwaye ki voye a |
to | ID anplwaye ki resevwa a |
topic | Sijè/kanal mesaj la |
type | "message", "mention", "proposal", "command", "info", "task" |
content | Kò mesaj la |
Konpòtman kle:
Registeranonse anplwaye IA sa a sou rezo a ak kapasite li yoSubscribe/Unsubscribejere abònman sijè yoReceivevoye 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:
| Kalite | Kontni | Deskripsyon |
|---|---|---|
"text" | Moso tèks | Token tèks an flo |
"tool_call" | JSON | Modèl la vle rele yon zouti |
"thinking" | Moso tèks | Refleksyon/rezònman pwolonje |
"error" | Mesaj erè | Yon bagay pa mache |
"done" | Vid | Flo 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.
| Chemen | Mekanis | Objektif |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Sèvè fichye estatik | Sèvi fichye ki nan dosye ui/ ou a (SPA retounen sou index.html) |
ANY /api/v1/apps/{id}/api/* | Proxy gRPC | Voye 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 Triggersse 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:
| Fichye | Gwosè maksimòm | Deskripsyon |
|---|---|---|
manifest.json | 1 MB | Metadone aplikasyon an |
binary oswa app | 500 MB | Egzekitab |
signatures.json | 1 MB | Siyati Ed25519 |
TOOL.md | 1 MB | Enstriksyon 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è
- Anrejistre yon kont NeboAI nan
POST /api/v1/owners/register - Konekte pou w jwenn yon token JWT:
POST /api/v1/owners/login - 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
- Eskanaj otomatik — binè yo eskane atravè VirusTotal
- Revizyon administratè — ekip NeboAI a revize metadone, manifès ak rezilta eskanaj yo
- Lè l apwouve — NeboAI siyen aplikasyon an ak Ed25519 epi pibliye l
- 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
- Mete vèsyon aplikasyon an ajou:
PUT /api/v1/developer/apps/{id}ak nouvo vèsyon an - Telechaje nouvo binè pou chak platfòm
- 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
| Chan | Deskripsyon |
|---|---|
category | pa egzanp, productivity, communication, developer-tools |
icon | URL ikòn aplikasyon an |
visibility | public oswa private |
description | Ka pi long/pi rich pase deskripsyon manifès la |
Flo travay devlopman
Devlopman lokal
Pa bezwen anbalaj pou devlopman lokal:
- Kreye dosye aplikasyon w lan:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - Ekri
manifest.jsonou ak kòd ou - Konpile binè w lan:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo detekte nouvo dosye a otomatikman (oswa rekòmanse Nebo)
- 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.logpou 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_DATApou 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
| Konpetans | Aplikasyon | |
|---|---|---|
| Fòma | Markdown (SKILL.md) | Binè konpile (.napp) |
| Egzekisyon | Enjekte nan prompt sistèm nan | Pwosesis nan sandbox atravè gRPC |
| Bay | Gid konpòtman, metòd | Zouti, kanal, panèl UI |
| Dire | Limite a sesyon an, ekspire selon TTL | Toujou ap fonksyone |
| Kreyasyon | Ekri yon fichye markdown | Ekri, konpile, siyen, anbale |
| Sekirite | Pa bezwen pèmisyon | Sandbox 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).
| Chan | Obligatwa | Defo | Deskripsyon |
|---|---|---|---|
name | Wi | — | Idantifyan inik (li vin slug la) |
description | Wi | — | Deskripsyon yon sèl liy ki parèt nan katalòg konpetans lan |
version | Non | "1.0.0" | Semver pou swiv mizajou yo |
author | Non | — | Otè konpetans lan |
priority | Non | 0 | Pi wo = koresponn an premye (100+ pou ranplasman kritik) |
max_turns | Non | 4 | Kantite tou san aktivite anvan ekspirasyon otomatik |
triggers | Non | [] | Fraz ki aktive konpetans sa a otomatikman (koresponn pati tèks, san gade majiskil) |
tools | Non | [] | Zouti konpetans sa a prevwa itilize (pou enfòmasyon) |
dependencies | Non | [] | Lòt konpetans ki dwe enstale |
tags | Non | [] | Pou klasman ak dekouvèt |
platform | Non | [] | 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:
| Aksyon | Deskripsyon | Egzanp |
|---|---|---|
catalog | Bay lis tout konpetans ki disponib | skill(action: "catalog") |
load | Aktive pou sesyon sa a | skill(name: "code-review", action: "load") |
unload | Dezaktive yon konpetans | skill(name: "code-review", action: "unload") |
create | Kreye yon nouvo konpetans sou disk la | skill(action: "create", content: "...") |
update | Mete ajou yon konpetans ki egziste | skill(name: "my-skill", action: "update", content: "...") |
delete | Efase yon konpetans sou disk la | skill(name: "my-skill", action: "delete") |
Ekri bon Konpetans
Yon bon modèl konpetans genyen:
- Yon tit klè — li di anplwaye IA a nan ki mòd li ye
- Prensip debaz — règ konpòtman ki pa negosyab
- Metòd — apwòch etap pa etap pou sitiyasyon komen
- Egzanp — modèl konkrè mesaj itilizatè ak repons
- 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:
| Konpetans | Priyorite | Deskripsyon |
|---|---|---|
onboarding | 100 | Akèy nouvo itilizatè ak kolekte pwofil |
best-friend | 50 | Konpetans pèsonalite — dekontrakte, fidèl, pale franchman |
debugging | 25 | Metòd debogaj sistematik |
api-design | 15 | Bon pratik konsepsyon API RESTful |
code-review | 10 | Revizyon kòd estriktire ak nivo gravite |
database-expert | 10 | Konsepsyon baz done, rekèt, optimizasyon |
git-workflow | 10 | Branch Git, commit, flo travay PR |
security-audit | 10 | Analiz 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.
| Fichye | Sèvis | RPC kle |
|---|---|---|
v0/common.proto | (mesaj sèlman) | HealthCheckRequest/Response, SettingsMap, UserContext, Empty |
v0/tool.proto | ToolService | Name, Description, Schema, Execute, RequiresApproval, Configure |
v0/channel.proto | ChannelService | ID, Connect, Disconnect, Send, Receive (flo), Configure |
v0/comm.proto | CommService | Name, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (flo), Configure |
v0/gateway.proto | GatewayService | HealthCheck, Stream (flo), 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 (flo), Configure |
Chak sèvis gen RPC HealthCheck ak Configure. SDK a okipe toude otomatikman.
Kalite Proto Kanal
| Kalite mesaj | Deskripsyon |
|---|---|
ChannelSendRequest | Anvlòp mesaj k ap sòti ak message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | ID mesaj platfòm lan pou fil diskisyon |
InboundMessage | Anvlòp mesaj k ap antre ak tout chan komen yo + timestamp |
MessageSender | Idantite bot la (name, role, botId) — koutye a anrichi l |
Attachment | Fichye/imaj/odyo tache (type, url, filename, size) |
MessageAction | Aksyon 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".