Muhtasari
Nebo Ni Nini
Nebo ni msaidizi binafsi wa AI wa kompyuta — mfanyakazi wa AI anayefanya kazi kila wakati anayesimamia maisha yako ya kidijitali. Ifikirie Nebo jinsi unavyofikiria simu janja: jukwaa lenye nguvu linaloleta mabadiliko makubwa kupitia programu zake.
Peke yake, Nebo ni mfanyakazi wa AI mwenye uwezo, mwenye kumbukumbu, upangaji ratiba, kuvinjari wavuti, usimamizi wa faili, na ufikiaji wa shell. Lakini ufunguo halisi ni Programu. Kama vile nguvu ya simu janja inavyotokana na mfumo ikolojia wa programu zake, nguvu ya Nebo inatokana na programu zinazopanua kile inachoweza kufanya.
Programu Ni Nini
Programu za Nebo ni vitengo vilivyojitosheleza na vilivyokusanywa mapema vyenye utendaji wa ajabu. Kila programu inaipa Nebo nguvu mpya — usimamizi wa kalenda, kupanga barua pepe, kufuatilia miradi, uendeshaji otomatiki wa nyumba, uchambuzi wa fedha — chochote ambacho msanidi programu anaweza kuwaza.
Programu hutoa nguvu kubwa kwa njia salama sana. Kila programu inaendeshwa ndani ya sandbox yenye ruhusa zinazokataliwa kwa chaguo-msingi. Inaweza kufikia tu kile ambacho manifest yake inatangaza na mtumiaji anaidhinisha.
Kiolesura ni cha mazungumzo kwa 100%. Watumiaji hawatumii programu kupitia skrini au dashibodi tofauti. Wanazungumza na Nebo, na Nebo hutumia zana za programu kukamilisha mambo. "Nina nini kwenye kalenda kesho?" — Nebo huita programu ya kalenda. "Unda mkutano na Sarah saa 3 mchana" — Nebo huita programu ya kalenda. Mtumiaji haachi mazungumzo kamwe.
Programu zinaweza kwa hiari kutoa UI ya mipangilio — paneli ya usanidi inayofunguka katika dirisha la kivinjari lililojengwa ndani ya Nebo. Hapa ndipo watumiaji huingiza funguo za API, kuwasha au kuzima vipengele, na kusanidi programu. UI ya mipangilio inaendeshwa na safu ya settings katika manifest (Nebo huchora fomu kiotomatiki), au programu inaweza kutoa UI yake kamili maalum kupitia uwezo wa ui.
Programu huchukua nafasi ya uwezo uliojengwa ndani ya Nebo na kuupanua. Nebo huja na zana za msingi za jukwaa (ufikiaji wa kalenda ya ndani, picha za skrini, n.k.). Unaposakinisha programu ya kalenda, inachukua nafasi ya zana ya kalenda iliyojengwa ndani na kuwa seti kubwa zaidi — ya ndani + wingu + ujumlishaji + ukaguzi wa upatikanaji.
Sera ya Kukusanywa Pekee
Nebo hutekeleza sera kali ya binary zilizokusanywa pekee. Programu zote lazima ziwe faili tekelezi asilia zilizokusanywa.
| Hali | Lugha |
|---|---|
| Zinazotumika | Go (inapendekezwa), Rust, C/C++, Zig |
| Zinazokataliwa | Python, Node.js, Ruby, Java, .NET, skripti za shell |
Sababu:
- Kuzuia AI kujibadilisha yenyewe — Mfanyakazi wa AI mwenye ufikiaji wa shell angeweza kubadilisha tabia ya skripti inayofasiriwa wakati inaendeshwa. Binary zilizokusanywa haziwezi kubadilishwa baada ya kusainiwa.
- Uadilifu wa saini — Saini za Ed25519 hufunika baiti ghafi za binary. Binary iliyosainiwa haiwezi kubadilishwa bila kubatilisha saini.
- Utekelezaji wa sandbox — Uthibitishaji wa muundo wa binary (magic bytes za ELF/Mach-O/PE) ni lango la haraka na la kuaminika.
Kuanza Haraka
Sakinisha SDK
SDK rasmi hushughulikia usanidi wote wa seva ya gRPC, ushughulikiaji wa ishara, na uunganishaji wa itifaki. Wewe unatekeleza tu violesura vya handler.
Go (inapendekezwa):
go get github.com/neboloop/nebo-sdk-go Rust (inakuja hivi karibuni):
# Coming soon
[dependencies]
nebo-sdk = "0.1" C/C++ (inakuja hivi karibuni):
# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/ Muundo wa Saraka ya Programu
Programu huishi katika saraka ndogo ya apps/ ya saraka yako ya data ya Nebo:
~/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) Orodha ya Ukaguzi ya Programu ya Msingi
- Unda
manifest.jsonyenyeid,name,version,provides - Andika
TOOL.mdinayoeleza jinsi mfanyakazi wa AI anavyopaswa kutumia zana yako - Sakinisha SDK (
go get github.com/neboloop/nebo-sdk-go) - Tekeleza kiolesura cha handler kwa uwezo wako (
ToolHandler,ChannelHandler, n.k.) - Sajili handler na uite
app.Run() - Jenga binary asilia (
go build -o binary .) - Weka binary + manifest.json + TOOL.md katika saraka ya
apps/<your-app-id>/ - Nebo huigundua na kuizindua kiotomatiki
Usanidi
manifest.json
Kila programu inahitaji 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
}
]
} Sehemu zinazohitajika:
| Sehemu | Maelezo |
|---|---|
id | Kitambulisho cha domain-kinyume (k.m., com.mycompany.myapp) |
name | Jina linalosomeka na binadamu |
version | Mfuatano wa semver |
provides | Angalau uwezo mmoja (tazama hapa chini) |
Sehemu za hiari:
| Sehemu | Chaguo-msingi | Maelezo |
|---|---|---|
runtime | "local" | "local" au "remote" |
protocol | "grpc" | "grpc" pekee ndiyo inayotumika |
permissions | [] | Kile ambacho programu inahitaji kufikia |
description | "" | Huonyeshwa kwenye UI |
settings | [] | Mipangilio inayoweza kusanidiwa (huchorwa katika UI ya Mipangilio) |
oauth | [] | Mahitaji ya mtoa huduma wa OAuth (tazama sehemu ya OAuth hapa chini) |
Uwezo
Tangaza kile ambacho programu yako inatoa:
| Uwezo | Huduma ya gRPC | Maelezo |
|---|---|---|
gateway | GatewayService | Uelekezaji wa miundo ya LLM |
tool:<name> | ToolService | Zana yenye jina kwa ajili ya mfanyakazi wa AI |
channel:<name> | ChannelService | Chaneli ya ujumbe |
comm | CommService | Mawasiliano kati ya wafanyakazi wa AI |
ui | UIService | UI maalum yenye HTTP proxy |
schedule | ScheduleService | Upangaji ratiba maalum |
vision | ToolService | Uchakataji wa picha |
browser | ToolService | Uendeshaji otomatiki wa kivinjari |
Programu inaweza kutoa uwezo mwingi. Kwa mfano, programu inaweza kutoa zana na paneli ya UI kwa pamoja.
Ruhusa
Ruhusa hudhibiti kile ambacho programu inaweza kufikia. Kukataa kwa chaguo-msingi — ikiwa haijatangazwa, programu haiwezi kuitumia.
| Kiambishi awali | Mifano | Maelezo |
|---|---|---|
network: | network:outbound, network:* | Ufikiaji wa mtandao |
filesystem: | filesystem:read, filesystem:write | Ufikiaji wa mfumo wa faili |
memory: | memory:read, memory:write | Ufikiaji wa kumbukumbu ya mfanyakazi wa AI |
session: | session:read | Vipindi vya mazungumzo |
tool: | tool:shell, tool:file | Tumia zana nyingine |
shell: | shell:exec | Utekelezaji wa amri za shell |
channel: | channel:send, channel:* | Shughuli za chaneli |
comm: | comm:send, comm:* | Mawasiliano kati ya wafanyakazi wa AI |
model: | model:chat | Ufikiaji wa miundo ya AI |
user: | user:token | Pokea JWT ya mtumiaji katika maombi |
schedule: | schedule:create | Usimamizi wa kazi za cron |
database: | database:query | Ufikiaji wa hifadhidata |
storage: | storage:read, storage:write | Hifadhi ya kudumu |
context: | context:read | Ufikiaji wa muktadha wa mfanyakazi wa AI |
subagent: | subagent:spawn | Shughuli za sub-agent |
lane: | lane:enqueue | Shughuli za lane |
notification: | notification:send | Arifa za push |
embedding: | embedding:search | Ufikiaji wa vector embedding |
skill: | skill:invoke | Kuita ujuzi |
advisor: | advisor:consult | Ufikiaji wa mfumo wa ushauri |
mcp: | mcp:connect | Ufikiaji wa seva ya MCP |
voice: | voice:record | Ufikiaji wa sauti |
browser: | browser:navigate | Uendeshaji otomatiki wa kivinjari |
oauth: | oauth:google, oauth:* | Ufikiaji wa tokeni ya OAuth |
settings: | settings:read | Ufikiaji wa mipangilio |
capability: | capability:register | Usajili wa uwezo |
Ruhusa za wildcard zinatumika: network:* inalingana na ukaguzi wowote wa ruhusa ya network:.
Mipangilio
Mipangilio huonekana kwenye UI ya Nebo chini ya paneli ya mipangilio ya programu. Nebo huihifadhi kwenye hifadhidata na kuituma kwa programu yako kupitia RPC ya Configure inapobadilika.
Schema yako ya mipangilio imejumuishwa kwenye tangazo la duka la programu la NeboAI. Programu zenye mipangilio inayohitajika ambayo haijasanidiwa huonyesha beji ya "Inahitaji Kuwekwa" kwenye UI.
| Aina | Maelezo |
|---|---|
text | Kisanduku cha maandishi cha mstari mmoja |
password | Kisanduku cha maandishi kilichofichwa |
toggle | Swichi ya kuwasha/kuzima ya Boolean |
select | Menyu kunjuzi yenye chaguzi zilizobainishwa |
number | Kisanduku cha namba |
url | Kisanduku cha URL chenye uthibitishaji |
{
"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"}
]
} Mahitaji ya OAuth
Programu zinaweza kutangaza mahitaji ya mtoa huduma wa OAuth. OAuth broker ya Nebo hushughulikia mtiririko wote — programu hupokea tokeni kiotomatiki kupitia RPC ya Configure.
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | Sehemu | Maelezo |
|---|---|
provider | Mtoa huduma wa OAuth: "google", "microsoft", "github" |
scopes | Safu ya scopes za OAuth ambazo programu inahitaji |
Mtumiaji anaposakinisha programu, Nebo humwomba aidhinishe scopes za OAuth zinazohitajika. Programu hupokea tokeni zilizoonyeshwa upya kupitia RPC ya Configure bila kushughulikia mtiririko wa OAuth yenyewe.
Vigezo vya Mazingira
Mchakato wa programu yako hupokea mazingira yaliyosafishwa. Siri zote huondolewa. Unapata:
| Kigezo | Thamani |
|---|---|
NEBO_APP_DIR | Saraka ya usakinishaji wa programu |
NEBO_APP_SOCK | Njia ya Unix socket ya kuunda |
NEBO_APP_ID | ID ya programu kutoka manifest |
NEBO_APP_NAME | Jina la programu kutoka manifest |
NEBO_APP_VERSION | Toleo la programu kutoka manifest |
NEBO_APP_DATA | Njia ya saraka ya data/ ya programu |
PATH | PATH ya mfumo (inapitishwa) |
HOME | Saraka ya nyumbani ya mtumiaji (inapitishwa) |
TMPDIR | Saraka ya muda (inapitishwa) |
Muhimu sana: Binary yako lazima iunde seva ya gRPC inayosikiliza kwenye Unix socket iliyo NEBO_APP_SOCK. Nebo husubiri hadi sekunde 10 socket hii ionekane.
Mfuatano wa Kuzindua Programu
- Nebo husoma
manifest.jsonna kuithibitisha - Hutafuta faili tekelezi ya
binaryauappkatika saraka ya programu - Hukagua alama ya
.quarantined(hukataa kuzindua programu zilizotengwa) - Ukaguzi wa ubatilishaji (programu zinazosambazwa na NeboAI pekee)
- Uthibitishaji wa saini (programu zinazosambazwa na NeboAI pekee, hurukwa katika dev)
- Uthibitishaji wa binary (hukataa symlinks, skripti, faili zisizo tekelezi, faili kubwa kupita kiasi)
- Husafisha socket ya zamani kutoka utekelezaji uliopita
- Huunda saraka ya
data/kwa hifadhi iliyo ndani ya sandbox - Huweka faili za kumbukumbu kwa kila programu (
logs/stdout.log,logs/stderr.log) - Huanzisha binary kwa mazingira yaliyosafishwa na utengaji wa kikundi cha michakato
- Husubiri Unix socket ionekane (exponential backoff, upeo wa sekunde 10)
- Huunganisha kupitia gRPC juu ya Unix socket
- Huunda wateja wa gRPC maalum kwa kila uwezo kulingana na
provides - Huendesha ukaguzi wa afya
- Husajili uwezo kwa mfanyakazi wa AI (zana, gateway, comm, n.k.)
Programu za Zana
Tangaza "provides": ["tool:my_tool_name"] katika manifest yako.
Mtindo wa STRAP
Programu zote za zana za Nebo lazima zitumie STRAP (Single Tool Resource Action Pattern) kwa schema yao na uelekezaji wa utekelezaji. Huu ndio mtindo ule ule ambao Nebo hutumia ndani kuunganisha zana 35+ binafsi kuwa zana 4 za nyanja — ikipunguza mzigo wa muktadha wa LLM kwa ~80%.
Wazo kuu: Badala ya kusajili zana nyingi (get_events, check_availability, suggest_slots), sajili zana MOJA yenye sehemu za action (na kwa hiari resource) zinazoelekeza kwa handler sahihi.
Mfano wa rasilimali moja (kalenda):
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") Mfano wa rasilimali nyingi (msimamizi wa miradi):
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") Sheria za schema:
- Jumuisha kila wakati sehemu ya
actionkama string enum inayohitajika - Ongeza sehemu ya
resource(string enum inayohitajika) ikiwa tu zana yako inasimamia aina nyingi tofauti za rasilimali - Sehemu nyingine zote ni vigezo maalum vya kila action
- Maelezo ya enum ya
actionyanapaswa kuorodhesha actions zote zinazopatikana
Kwa nini STRAP ni muhimu:
- LLM hujifunza mtindo wa uelekezaji wa
actionmara moja na kuutumia kwa shughuli zote - Ufafanuzi wa zana hutumia ~6% ya muktadha — STRAP hupunguza hilo kwa 80%
- Shughuli mpya ni nyongeza za enum tu, si usajili mpya wa zana
- Inafanya kazi sawasawa kwenye miundo inayokaribishwa na ya ndani
Mfano wa Go — Zana ya Kikokotoo
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": []
} Jenga na usakinishe:
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/ Mfano wa 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(())
} Mfano wa 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;
} Programu za Chaneli
Tangaza "provides": ["channel:my_channel"] na "permissions": ["channel:send"].
Programu za chaneli huunganisha majukwaa ya nje ya ujumbe (Telegram, Discord, Slack, n.k.) na mfanyakazi wa AI wa Nebo. Mtumiaji anapotuma ujumbe kwenye jukwaa la nje, programu yako huutiririsha kwa Nebo kupitia Receive. Mfanyakazi wa AI anapotaka kujibu, Nebo huita Send ya programu yako.
Jinsi inavyofanya kazi
- Nebo huita
ID()kupata kitambulisho cha kipekee cha chaneli yako - Nebo huita
Connect()pamoja na config kutoka mipangilio ya programu yako - Nebo hufungua mkondo wa
Receive()— programu yako hutuma jumbe zinazoingia kila mtumiaji anapoitumia boti ujumbe - Jumbe zinazoingia huelekezwa kwenye lane kuu ya mazungumzo ya mfanyakazi wa AI
- Mfanyakazi wa AI anapotaka kutuma ujumbe, Nebo huita
Send()pamoja na bahasha ya ujumbe ya v1 - Wakati wa kuzima, Nebo huita
Disconnect()
Bahasha ya Ujumbe ya v1
Jumbe zote za chaneli — zinazoingia na zinazotoka — hutumia bahasha ya pamoja ya ujumbe:
{
"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"
} | Sehemu | Aina | Maelezo |
|---|---|---|
message_id | UUID v7 | ID ya kipekee iliyopangwa kwa wakati |
channel_id | {type}:{platform_id} | Kitambulisho cha chaneli kinachoweza kuelekezwa |
sender | object | Utambulisho wa boti — name, role, botId |
text | string | Kiini cha ujumbe |
attachments | array | Faili, picha, sauti |
reply_to | UUID v7 | ID ya ujumbe mzazi kwa ajili ya mfululizo |
actions | array | Vitufe/kibodi shirikishi |
platform_data | bytes | Upitishaji usioonekana kwa vipengele maalum vya jukwaa |
timestamp | ISO 8601 | Mchapishaji huweka hii |
Muundo wa tabaka mbili: Sehemu za pamoja (text, attachments, reply_to, actions) hufunika 90% ya jumbe zinazoanzishwa na mfanyakazi. Vipengele maalum vya jukwaa huenda katika platform_data — programu-jalizi yako huvigeuza kwenda/kutoka muundo asilia wa jukwaa.
Mikondo ya Mazungumzo
Jumbe za chaneli huelekezwa kupitia mikondo ya mazungumzo ya kila chaneli kwa ajili ya utengaji:
neboai/bot/{botID}/channels/{channelType}/inbound # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound # messages from agent → channel Mfano wa Go — Chaneli ya 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
}
]
} Uwezo Zaidi
Programu ya Comm
Tangaza "provides": ["comm"] na "permissions": ["comm:*"]. Programu za comm huwezesha mawasiliano kati ya wafanyakazi wa AI.
| Sehemu | Maelezo |
|---|---|
from | ID ya mfanyakazi anayetuma |
to | ID ya mfanyakazi anayepokea |
topic | Mada/chaneli ya ujumbe |
type | "message", "mention", "proposal", "command", "info", "task" |
content | Kiini cha ujumbe |
Tabia muhimu:
Registerhumtangaza mfanyakazi huyu wa AI kwenye mtandao pamoja na uwezo wakeSubscribe/Unsubscribehusimamia usajili wa madaReceivehutiririsha jumbe zinazoingia (server-streaming, sawa na chaneli)- Programu moja tu ya comm inaweza kuwa hai kwa wakati mmoja
Programu ya Gateway
Programu ya gateway huelekeza maombi ya LLM kwa miundo. Tangaza "provides": ["gateway"] na "permissions": ["network:outbound", "user:token"].
GatewayRequest ina jumbe, zana, system prompt, max tokens, temperature, na UserContext (tokeni ya JWT ikiwa ruhusa ya user:token imetolewa).
Aina za GatewayEvent:
| Aina | Maudhui | Maelezo |
|---|---|---|
"text" | Kipande cha maandishi | Tokeni ya maandishi inayotiririshwa |
"tool_call" | JSON | Muundo unataka kuita zana |
"thinking" | Kipande cha maandishi | Kufikiri/kutafakari kwa kina |
"error" | Ujumbe wa hitilafu | Kuna tatizo limetokea |
"done" | Tupu | Mkondo umekamilika |
Programu ya UI
Programu ya UI hutoa kiolesura maalum cha usanidi kinachofunguka katika dirisha la kivinjari lililojengwa ndani ya Nebo. Tangaza "provides": ["ui"]. Tofauti na fomu ya mipangilio ya kiotomatiki (ambayo Nebo huichora kutoka kwa manifest yako ya settings), programu ya UI hutoa frontend yake kamili ya HTML/CSS/JS.
Programu yako huja na saraka ya ui/ yenye rasilimali tuli za wavuti (HTML, CSS, JS — kwa kawaida SPA yenye index.html). Nebo hutoa faili hizi moja kwa moja na kupitisha maombi ya API kwa programu yako kupitia gRPC.
| Njia | Utaratibu | Madhumuni |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Seva ya faili tuli | Hutoa faili kutoka saraka yako ya ui/ (SPA hurudi kwa index.html) |
ANY /api/v1/apps/{id}/api/* | gRPC proxy | Hupitisha maombi ya HTTP kwa UIService.HandleRequest() ya programu yako |
SDK hufunika net/http.ServeMux ya kawaida ili uandike HTTP handlers za kawaida za Go — SDK hushughulikia uunganishaji wa gRPC kiotomatiki.
Mfano wa Go — UI ya Dashibodi:
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 yako ingefanya maombi ya fetch kwa /api/v1/apps/com.example.dashboard/api/status, ambayo hupitishwa hadi kwa handler yako ya mux.
Programu ya Ratiba
Programu ya ratiba huchukua nafasi ya kipanga ratiba cha cron kilichojengwa ndani ya Nebo. Tangaza "provides": ["schedule"] na "permissions": ["schedule:create"].
Programu yako ya ratiba inapozinduliwa, Nebo huelekeza upangaji ratiba wote kupitia programu yako badala ya injini ya cron ya chaguo-msingi. Programu yako ikianguka, Nebo hurudi kiotomatiki kwa injini iliyojengwa ndani.
- Programu yako inamiliki hali ya ratiba — Nebo haihifadhi ratiba katika DB yake yenyewe wakati programu ya ratiba iko hai
- CRUD ya kawaida:
Create,Get,List,Update,Delete,Enable,Disable Triggersni RPC ya server-streaming — programu yako hutuma ujumbe wa kichochezi kila ratiba inapotekelezwa- Programu moja tu ya ratiba inaweza kuwa hai kwa wakati mmoja
Programu zenye Uwezo Mwingi
Programu inaweza kutoa uwezo mwingi. Kwa mfano, programu ya dashibodi yenye zana na UI kwa pamoja:
{
"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()) Ufungashaji
Muundo wa .napp
Kwa usambazaji kupitia NeboAI, funga programu yako kama faili ya .napp (kumbukumbu ya tar.gz):
cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md Faili zinazohitajika:
| Faili | Ukubwa wa Juu | Maelezo |
|---|---|---|
manifest.json | 1 MB | Metadata ya programu |
binary au app | 500 MB | Faili tekelezi |
signatures.json | 1 MB | Saini za Ed25519 |
TOOL.md | 1 MB | Maelekezo ya zana kwa mfanyakazi wa AI |
Sheria za usalama wakati wa kufungua:
- Hakuna path traversal (
../inakataliwa) - Hakuna symlinks (zinakataliwa)
- Hakuna njia kamili (zinakataliwa)
- Majina ya faili yaliyo kwenye orodha ya kuruhusiwa pekee ndiyo yanayokubaliwa
Saini
NeboAI husaini programu kwa Ed25519. Muundo wa 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>"
} Katika hali ya dev (hakuna URL ya NeboAI iliyosanidiwa), uthibitishaji wa saini hurukwa kabisa. Huhitaji signatures.json kwa uundaji wa ndani.
Kuchapisha
Programu yako ikishafanya kazi ndani, ichapishe kupitia NeboAI ili isambazwe kwa watumiaji wote wa Nebo.
Kuweka Akaunti ya Msanidi Programu
- Sajili akaunti ya NeboAI kwenye
POST /api/v1/owners/register - Ingia ili kupata tokeni ya JWT:
POST /api/v1/owners/login - Unda akaunti ya msanidi programu:
POST /api/v1/developer/accounts
Mtiririko wa Uwasilishaji
draft → pending_review → [approved] → published
→ [rejected] → draft (fix and resubmit) Hatua ya 1: Unda programu
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"
}' Hatua ya 2: Pakia binary za majukwaa
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" Pakia binary moja kwa kila jukwaa: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.
Hatua ya 3: Wasilisha kwa ukaguzi
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
-H "Authorization: Bearer $TOKEN" Mchakato wa Ukaguzi
- Uchanganuzi wa kiotomatiki — binary huchanganuliwa kupitia VirusTotal
- Ukaguzi wa msimamizi — timu ya NeboAI hukagua metadata, manifest, na matokeo ya uchanganuzi
- Ikiidhinishwa — NeboAI husaini programu kwa Ed25519 na kuichapisha
- Ikikataliwa — unapokea sababu na unaweza kurekebisha na kuwasilisha tena
Muda unaolengwa wa ukaguzi: <24 saa.
Kutuma Masasisho
- Sasisha toleo la programu:
PUT /api/v1/developer/apps/{id}ukiwa na toleo jipya - Pakia binary mpya kwa kila jukwaa
- Wasilisha kwa ukaguzi tena
Kila sasisho hupitia mchakato ule ule wa ukaguzi. Matoleo ya awali yanaendelea kupatikana hadi toleo jipya liidhinishwe.
Metadata ya Duka
| Sehemu | Maelezo |
|---|---|
category | k.m., productivity, communication, developer-tools |
icon | URL ya aikoni ya programu |
visibility | public au private |
description | Inaweza kuwa ndefu/tajiri zaidi kuliko maelezo ya manifest |
Mtiririko wa Uundaji
Uundaji wa Ndani
Hakuna ufungashaji unaohitajika kwa uundaji wa ndani:
- Unda saraka ya programu yako:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - Andika
manifest.jsonyako na msimbo - Jenga faili lako la binary:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo hugundua saraka mpya kiotomatiki (au anzisha upya Nebo)
- Baada ya mabadiliko ya msimbo, jenga upya binary — kifuatiliaji cha faili kitaanzisha upya programu
Kutazama Kumbukumbu
stdout/stderr ya programu hunaswa katika faili za kumbukumbu za kila programu:
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 ya Kudumu
Tumia saraka ya data/ (inapatikana pia kama env var ya NEBO_APP_DATA) kwa faili zozote ambazo programu yako inahitaji kuhifadhi. Saraka hii hudumu hata baada ya masasisho ya programu na kutengwa.
Vidokezo vya Utatuzi
- Ikiwa programu yako haianzi, angalia
logs/stderr.logkwa hitilafu - Hakikisha binary inaweza kutekelezwa (
chmod +x binary) - Hakikisha unasikiliza kwenye njia ya Unix socket kutoka
NEBO_APP_SOCK - Socket lazima iwe tayari ndani ya sekunde 10 baada ya kuzinduliwa
- Tumia
NEBO_APP_DATAkwa hifadhi, si njia zilizoandikwa moja kwa moja kwenye msimbo - Chapisha kwenye stderr kwa kumbukumbu za utatuzi (hunaswa katika
logs/stderr.log)
Kuthibitisha
# 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 Kuondoa usakinishaji
nebo apps uninstall com.example.myapp Ujuzi
Ujuzi Ni Nini
Ujuzi ni seti za maelekezo zinazounda jinsi Nebo inavyotenda wakati wa mazungumzo. Ujuzi unapokuwa hai, maudhui yake huingizwa moja kwa moja kwenye system prompt — yakiongoza sauti, mbinu, utaalamu wa fani, na matumizi ya zana ya mfanyakazi wa AI kwa kipindi hicho.
Ujuzi si msimbo. Ni nyaraka za markdown zenye metadata ya YAML. Hakuna ukusanyaji, hakuna binary, hakuna gRPC. Ujuzi ni faili ya SKILL.md katika saraka. Hiyo tu.
Ujuzi ni wa muktadha na wa muda. Huwashwa unapohusika (kupitia ulinganishaji wa vichochezi au kupakiwa kwa mkono), hudumu kwa zamu chache, na huisha muda usipohitajika tena. Hii huweka muktadha wa mfanyakazi wa AI ukiwa mwepesi — mwongozo unaohusika sasa hivi pekee ndio ulio kwenye prompt.
Ujuzi hukamilisha programu. Programu hutoa uwezo unaotekelezeka (zana, chaneli, gateways). Ujuzi hutoa mwongozo wa uratibu — jinsi ya kutumia zana hizo kwa ufanisi. Programu ya kalenda huipa Nebo uwezo wa kusoma na kuandika matukio. Ujuzi wa "kujiandaa kwa mkutano" huiambia Nebo jinsi ya kujiandaa kwa mikutano ikitumia programu hiyo ya kalenda, barua pepe, na utafutaji wa wavuti kwa pamoja.
Ujuzi dhidi ya Programu
| Ujuzi | Programu | |
|---|---|---|
| Muundo | Markdown (SKILL.md) | Binary iliyokusanywa (.napp) |
| Wakati wa utekelezaji | Huingizwa kwenye system prompt | Mchakato ndani ya sandbox kupitia gRPC |
| Hutoa | Mwongozo wa tabia, mbinu | Zana, chaneli, paneli za UI |
| Muda wa kuishi | Kwa kipindi, huisha muda kwa TTL | Huendeshwa kila wakati |
| Uundaji | Andika faili ya markdown | Andika, kusanya, saini, funga |
| Usalama | Hakuna ruhusa zinazohitajika | Sandbox ya kukataa kwa chaguo-msingi |
Kuanza Haraka
Unda saraka katika folda yako ya ujuzi ya Nebo yenye faili ya SKILL.md:
~/Library/Application Support/Nebo/skills/ # macOS
~/.config/nebo/skills/ # Linux
%AppData%\Nebo\skills\ # Windows mkdir -p ~/.config/nebo/skills/my-skill Andika 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 hufuatilia saraka ya ujuzi kwa fsnotify. Ujuzi wako unapatikana mara moja — hakuna haja ya kuanzisha upya. Sema kitu kinacholingana na kichochezi, na unawashwa kiotomatiki.
Au iulize Nebo moja kwa moja: "Unda ujuzi wa kuandika machapisho ya blogu" — Nebo itakuandikia faili ya SKILL.md.
Muundo wa SKILL.md
Kila ujuzi ni faili moja ya SKILL.md yenye sehemu mbili: frontmatter ya YAML kati ya alama za ---, na kiini cha markdown (maelekezo halisi yanayoingizwa kwenye system prompt).
| Sehemu | Inahitajika | Chaguo-msingi | Maelezo |
|---|---|---|---|
name | Ndiyo | — | Kitambulisho cha kipekee (kinakuwa slug) |
description | Ndiyo | — | Maelezo ya mstari mmoja yanayoonyeshwa kwenye katalogi ya ujuzi |
version | Hapana | "1.0.0" | Semver ya kufuatilia masasisho |
author | Hapana | — | Mwandishi wa ujuzi |
priority | Hapana | 0 | Juu zaidi = hulinganishwa kwanza (100+ kwa mabadiliko muhimu ya kipaumbele) |
max_turns | Hapana | 4 | Zamu za kutokuwa na shughuli kabla ya kuisha muda kiotomatiki |
triggers | Hapana | [] | Vifungu vya maneno vinavyowasha ujuzi huu kiotomatiki (ulinganishaji wa sehemu ya maandishi bila kujali herufi kubwa au ndogo) |
tools | Hapana | [] | Zana ambazo ujuzi huu unatarajia kutumia (kwa taarifa) |
dependencies | Hapana | [] | Ujuzi mwingine ambao lazima usakinishwe |
tags | Hapana | [] | Kwa kupanga katika makundi na ugunduzi |
platform | Hapana | [] | Majukwaa yanayotumika: macos, linux, windows (tupu = yote) |
Jinsi Ujuzi Unavyowashwa
Ujuzi hufuata mtindo wa uwashaji wa awamu mbili: dokezo kisha kuita.
Awamu ya 1: Ulinganishaji wa Vichochezi — Kila mara mtumiaji anapotuma ujumbe, Nebo huchanganua ujuzi wote uliosajiliwa kutafuta vichochezi vinavyolingana. Ujuzi unaolingana huonekana kama madokezo kwenye system prompt. Mfanyakazi wa AI huona dokezo na kuamua kama aite ujuzi huo.
Awamu ya 2: Kuita — Mfanyakazi wa AI huita ujuzi kwa kuita:
skill(name: "code-review") Hii hurudisha kiolezo kamili cha SKILL.md kama tokeo la zana, hurekodi wito huo, na huingiza tena kiolezo kwenye system prompt katika zamu zinazofuata.
TTL na Kuisha Muda:
- Ujuzi unaolinganishwa kiotomatiki: zamu 4 za kutokuwa na shughuli (inasanidiwa kupitia
max_turns) - Ujuzi unaopakiwa kwa mkono: zamu 6 za kutokuwa na shughuli
- Kuita tena huweka upya kipima muda
- Kikomo kikali: upeo wa ujuzi 4 hai kwa kila kipindi
- Bajeti ya tokeni: maudhui ya ujuzi hai kwa pamoja yana kikomo cha herufi 16,000
Kusimamia Ujuzi
Mfanyakazi wa AI anaweza kusimamia ujuzi kupitia zana ya skill:
| Kitendo | Maelezo | Mfano |
|---|---|---|
catalog | Orodhesha ujuzi wote unaopatikana | skill(action: "catalog") |
load | Washa kwa kipindi hiki | skill(name: "code-review", action: "load") |
unload | Zima ujuzi | skill(name: "code-review", action: "unload") |
create | Unda ujuzi mpya kwenye diski | skill(action: "create", content: "...") |
update | Sasisha ujuzi uliopo | skill(name: "my-skill", action: "update", content: "...") |
delete | Futa ujuzi kutoka kwenye diski | skill(name: "my-skill", action: "delete") |
Kuandika Ujuzi Mzuri
Kiolezo kizuri cha ujuzi kina:
- Kichwa kilicho wazi — kinamwambia mfanyakazi wa AI yuko katika hali gani
- Kanuni za msingi — sheria za tabia zisizojadilika
- Mbinu — njia ya hatua kwa hatua kwa hali za kawaida
- Mifano — mifumo halisi ya ujumbe wa mtumiaji hadi jibu
- Mifumo ya kuepuka — kile USICHOPASWA kufanya (miundo hujifunza vizuri kutokana na mifano hasi)
Kidokezo: Kila ujuzi unapaswa kufanya jambo moja vizuri. Usiunde ujuzi wa "programu kwa ujumla" — unda code-review, debugging, api-design kama ujuzi tofauti. Mfanyakazi wa AI anaweza kuwa na mingi hai kwa wakati mmoja.
Ujuzi Uliojumuishwa
Nebo huja na ujuzi uliojumuishwa unaoshughulikia matumizi ya kawaida:
| Ujuzi | Kipaumbele | Maelezo |
|---|---|---|
onboarding | 100 | Kumkaribisha mtumiaji mpya na kukusanya wasifu |
best-friend | 50 | Ujuzi wa haiba — wa kawaida, mwaminifu, mazungumzo ya ukweli |
debugging | 25 | Mbinu ya utatuzi wa kimfumo |
api-design | 15 | Mbinu bora za kubuni API za RESTful |
code-review | 10 | Ukaguzi wa msimbo uliopangwa kwa viwango vya uzito |
database-expert | 10 | Kubuni hifadhidata, maswali, uboreshaji |
git-workflow | 10 | Matawi ya Git, commits, mitiririko ya PR |
security-audit | 10 | Uchambuzi wa usalama na kugundua udhaifu |
Hivi hutumika kama chaguo-msingi muhimu na pia kama mifano ya marejeleo ya kuunda ujuzi wako mwenyewe.
Marejeleo
Faili za Proto
Faili za proto huishi katika proto/apps/v0/. SDK huja na msimbo uliozalishwa mapema, kwa hiyo huhitaji protoc kwa uundaji wa kawaida.
| Faili | Huduma | RPC Muhimu |
|---|---|---|
v0/common.proto | (jumbe pekee) | HealthCheckRequest/Response, SettingsMap, UserContext, Empty |
v0/tool.proto | ToolService | Name, Description, Schema, Execute, RequiresApproval, Configure |
v0/channel.proto | ChannelService | ID, Connect, Disconnect, Send, Receive (stream), Configure |
v0/comm.proto | CommService | Name, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure |
v0/gateway.proto | GatewayService | HealthCheck, Stream (stream), Poll, Cancel, Configure |
v0/ui.proto | UIService | HealthCheck, HandleRequest, Configure |
v0/schedule.proto | ScheduleService | HealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure |
Kila huduma inajumuisha RPC za HealthCheck na Configure. SDK hushughulikia zote mbili kiotomatiki.
Aina za Proto za Chaneli
| Aina ya Ujumbe | Maelezo |
|---|---|
ChannelSendRequest | Bahasha ya ujumbe unaotoka yenye message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | ID ya ujumbe ya jukwaa kwa ajili ya mfululizo |
InboundMessage | Bahasha ya ujumbe unaoingia yenye sehemu zote za pamoja + timestamp |
MessageSender | Utambulisho wa boti (name, role, botId) — huboreshwa na broker |
Attachment | Kiambatisho cha faili/picha/sauti (type, url, filename, size) |
MessageAction | Kitendo cha kitufe/kibodi shirikishi (label, callback_id) |
Utambulisho na Nafasi za Boti
Boti za Nebo zina mtindo wa utambulisho wa mihimili mitatu:
- creature — Boti ni nini (aina ya msingi): "Mwanamkakati mwenye akili ya haraka", "Mtafiti makini"
- role — Inavyohusiana na mtumiaji (uhusiano): "Rafiki", "COO", "Mshauri"
- vibe — Nguvu yake (mtindo wa mawasiliano): "Mtulivu lakini mwenye msimamo", "Mchangamfu na mwenye kutia moyo"
Programu-jalizi yako ya chaneli inapopokea ujumbe unaotoka, sehemu ya sender ina name na role ya boti. Tumia hii kuunda jina la kuonyesha kwa jukwaa lako. Role si cheo cha kazi — ni kielelezo cha uhusiano. "Rafiki", "Mwana", na "Mshauri" ni roles halali pamoja na "COO" na "DevLead".