Oversikt
Hva Nebo er
Nebo er en personlig KI-assistent for datamaskinen — en KI-ansatt som alltid kjører og styrer det digitale livet ditt. Tenk på Nebo slik du tenker på en smarttelefon: en kraftig plattform som blir banebrytende gjennom appene sine.
På egen hånd er Nebo en dyktig KI-ansatt med minne, planlegging, nettlesing, filbehandling og skalltilgang. Men det som virkelig åpner mulighetene, er apper. Akkurat som en smarttelefons kraft kommer fra app-økosystemet, kommer Nebos kraft fra appene som utvider hva den kan gjøre.
Hva apper er
Nebo-apper er selvstendige, forhåndskompilerte enheter med utrolig funksjonalitet. Hver app gir Nebo en ny superkraft — kalenderstyring, sortering av e-post, prosjektoppfølging, hjemmeautomasjon, økonomisk analyse — alt en utvikler kan forestille seg.
Apper gir utrolig kraft på en svært trygg måte. Hver app kjører i en sandkasse med tillatelser som er avslått som standard. Den har bare tilgang til det manifestet erklærer og brukeren godkjenner.
Grensesnittet er 100 % samtalebasert. Brukere samhandler ikke med apper gjennom egne skjermer eller dashbord. De snakker med Nebo, og Nebo bruker appens verktøy for å få ting gjort. «Hva står i kalenderen min i morgen?» — Nebo kaller kalenderappen. «Opprett et møte med Sarah klokka 3 i ettermiddag» — Nebo kaller kalenderappen. Brukeren forlater aldri samtalen.
Apper kan eventuelt tilby et innstillingsgrensesnitt — et konfigurasjonspanel som åpnes i Nebos innebygde nettleservindu. Det er her brukerne legger inn API-nøkler, slår funksjoner av og på og konfigurerer appen. Innstillingsgrensesnittet styres av settings-matrisen i manifestet (Nebo gjengir skjemaet automatisk), eller appen kan levere sitt eget fullstendig tilpassede grensesnitt via ui-funksjonen.
Apper erstatter og utvider Nebos innebygde funksjoner. Nebo leveres med grunnleggende plattformverktøy (lokal kalendertilgang, skjermbilder osv.). Når du installerer en kalenderapp, erstatter den det innebygde kalenderverktøyet og blir et supersett — lokal + sky + aggregering + sjekk av tilgjengelighet.
Retningslinje om kun kompilert kode
Nebo håndhever en streng retningslinje om at kun kompilerte binærfiler er tillatt. Alle apper må være native, kompilerte kjørbare filer.
| Status | Språk |
|---|---|
| Støttet | Go (anbefalt), Rust, C/C++, Zig |
| Avvist | Python, Node.js, Ruby, Java, .NET, skallskript |
Begrunnelse:
- Hindre at KI-en endrer seg selv — En KI-ansatt med skalltilgang kan endre oppførselen til et tolket skript mens det kjører. Kompilerte binærfiler kan ikke endres etter signering.
- Signaturintegritet — Ed25519-signaturer dekker de rå binærbytene. En signert binærfil kan ikke endres uten at signaturen blir ugyldig.
- Håndheving av sandkassen — Validering av binærformatet (magiske byter for ELF/Mach-O/PE) er en rask og pålitelig kontroll.
Hurtigstart
Installer SDK-en
De offisielle SDK-ene tar seg av alt oppsett av gRPC-serveren, signalhåndtering og protokollbroer. Du implementerer bare handler-grensesnitt.
Go (anbefalt):
go get github.com/neboloop/nebo-sdk-go Rust (kommer snart):
# Coming soon
[dependencies]
nebo-sdk = "0.1" C/C++ (kommer snart):
# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/ Mappestruktur for apper
Apper ligger i undermappen apps/ i Nebo-datamappen din:
~/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) Sjekkliste for en minimal app
- Opprett
manifest.jsonmedid,name,version,provides - Skriv
TOOL.mdsom beskriver hvordan KI-ansatte skal bruke verktøyet ditt - Installer SDK-en (
go get github.com/neboloop/nebo-sdk-go) - Implementer handler-grensesnittet for funksjonen din (
ToolHandler,ChannelHandlerosv.) - Registrer handleren og kall
app.Run() - Bygg en native binærfil (
go build -o binary .) - Legg binærfilen + manifest.json + TOOL.md i mappen
apps/<your-app-id>/ - Nebo oppdager og starter den automatisk
Konfigurasjon
manifest.json
Hver app krever en 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
}
]
} Påkrevde felt:
| Felt | Beskrivelse |
|---|---|
id | Identifikator i omvendt domeneformat (f.eks. com.mycompany.myapp) |
name | Lesbart navn |
version | Semver-streng |
provides | Minst én funksjon (se nedenfor) |
Valgfrie felt:
| Felt | Standard | Beskrivelse |
|---|---|---|
runtime | "local" | "local" eller "remote" |
protocol | "grpc" | Bare "grpc" støttes |
permissions | [] | Hva appen trenger tilgang til |
description | "" | Vises i grensesnittet |
settings | [] | Konfigurerbare innstillinger (vises i innstillingsgrensesnittet) |
oauth | [] | Krav til OAuth-leverandør (se OAuth-delen nedenfor) |
Funksjoner
Erklær hva appen din tilbyr:
| Funksjon | gRPC-tjeneste | Beskrivelse |
|---|---|---|
gateway | GatewayService | Ruting av LLM-modeller |
tool:<name> | ToolService | Et navngitt verktøy for KI-ansatte |
channel:<name> | ChannelService | En meldingskanal |
comm | CommService | Kommunikasjon mellom KI-ansatte |
ui | UIService | Tilpasset grensesnitt med HTTP-proxy |
schedule | ScheduleService | Tilpasset planlegging |
vision | ToolService | Bildebehandling |
browser | ToolService | Nettleserautomatisering |
En app kan tilby flere funksjoner. En app kan for eksempel tilby både et verktøy og et UI-panel.
Tillatelser
Tillatelser styrer hva appen har tilgang til. Avslått som standard — er noe ikke erklært, kan ikke appen bruke det.
| Prefiks | Eksempler | Beskrivelse |
|---|---|---|
network: | network:outbound, network:* | Nettverkstilgang |
filesystem: | filesystem:read, filesystem:write | Tilgang til filsystemet |
memory: | memory:read, memory:write | Tilgang til KI-ansattes minne |
session: | session:read | Samtaleøkter |
tool: | tool:shell, tool:file | Bruke andre verktøy |
shell: | shell:exec | Kjøring av skallkommandoer |
channel: | channel:send, channel:* | Kanaloperasjoner |
comm: | comm:send, comm:* | Kommunikasjon mellom KI-ansatte |
model: | model:chat | Tilgang til KI-modeller |
user: | user:token | Motta brukerens JWT i forespørsler |
schedule: | schedule:create | Administrasjon av cron-jobber |
database: | database:query | Databasetilgang |
storage: | storage:read, storage:write | Vedvarende lagring |
context: | context:read | Tilgang til KI-ansattes kontekst |
subagent: | subagent:spawn | Operasjoner for underagenter |
lane: | lane:enqueue | Operasjoner for baner |
notification: | notification:send | Pushvarsler |
embedding: | embedding:search | Tilgang til vektor-embeddinger |
skill: | skill:invoke | Kalle opp ferdigheter |
advisor: | advisor:consult | Tilgang til rådgiversystemet |
mcp: | mcp:connect | Tilgang til MCP-servere |
voice: | voice:record | Tilgang til tale/lyd |
browser: | browser:navigate | Nettleserautomatisering |
oauth: | oauth:google, oauth:* | Tilgang til OAuth-tokener |
settings: | settings:read | Tilgang til innstillinger |
capability: | capability:register | Registrering av funksjoner |
Jokertegn-tillatelser støttes: network:* samsvarer med enhver network:-tillatelsessjekk.
Innstillinger
Innstillinger vises i Nebo-grensesnittet i appens innstillingspanel. Nebo lagrer dem i databasen og sender dem til appen din via Configure-RPC-en når de endres.
Innstillingsskjemaet ditt inkluderes i oppføringen i NeboAI-appbutikken. Apper med påkrevde innstillinger som ikke er konfigurert, viser et «Må settes opp»-merke i grensesnittet.
| Type | Beskrivelse |
|---|---|
text | Tekstfelt på én linje |
password | Maskert tekstfelt |
toggle | Boolsk av/på-bryter |
select | Nedtrekksmeny med forhåndsdefinerte valg |
number | Tallfelt |
url | URL-felt med validering |
{
"key": "region",
"title": "Region",
"type": "select",
"required": true,
"default": "us-east-1",
"options": [
{"label": "US East", "value": "us-east-1"},
{"label": "EU West", "value": "eu-west-1"}
]
} OAuth-krav
Apper kan erklære krav til OAuth-leverandører. Nebos OAuth-megler håndterer hele flyten — apper mottar tokener automatisk via Configure-RPC-en.
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | Felt | Beskrivelse |
|---|---|
provider | OAuth-leverandør: "google", "microsoft", "github" |
scopes | Matrise med OAuth-omfang appen trenger |
Når brukeren installerer appen, ber Nebo dem om å godkjenne de påkrevde OAuth-omfangene. Appen mottar fornyede tokener via Configure-RPC-en uten å håndtere OAuth-flyten selv.
Miljøvariabler
Appprosessen din får et renset miljø. Alle hemmeligheter fjernes. Du får:
| Variabel | Verdi |
|---|---|
NEBO_APP_DIR | Appens installasjonsmappe |
NEBO_APP_SOCK | Sti til Unix-socketen som skal opprettes |
NEBO_APP_ID | App-ID fra manifestet |
NEBO_APP_NAME | Appnavn fra manifestet |
NEBO_APP_VERSION | Appversjon fra manifestet |
NEBO_APP_DATA | Sti til appens data/-mappe |
PATH | System-PATH (sendes videre) |
HOME | Brukerens hjemmemappe (sendes videre) |
TMPDIR | Midlertidig mappe (sendes videre) |
Viktig: Binærfilen din må opprette en gRPC-server som lytter på Unix-socketen i NEBO_APP_SOCK. Nebo venter i opptil 10 sekunder på at denne socketen skal dukke opp.
Oppstartssekvens for apper
- Nebo leser
manifest.jsonog validerer den - Finner den kjørbare filen
binaryellerappi appmappen - Ser etter
.quarantined-markøren (nekter å starte apper i karantene) - Sjekk av tilbakekalling (kun apper distribuert av NeboAI)
- Verifisering av signatur (kun apper distribuert av NeboAI, hoppes over i utvikling)
- Validering av binærfilen (avviser symbolske lenker, skript, ikke-kjørbare filer og for store filer)
- Rydder opp gammel socket fra forrige kjøring
- Oppretter
data/-mappen for lagring i sandkasse - Setter opp loggfiler per app (
logs/stdout.log,logs/stderr.log) - Starter binærfilen med renset miljø og isolert prosessgruppe
- Venter på at Unix-socketen dukker opp (eksponentiell backoff, maks 10 sekunder)
- Kobler til via gRPC over Unix-socketen
- Oppretter funksjonsspesifikke gRPC-klienter basert på
provides - Kjører helsesjekk
- Registrerer funksjoner hos KI-ansatte (verktøy, gateway, comm osv.)
Verktøyapper
Erklær "provides": ["tool:my_tool_name"] i manifestet ditt.
STRAP-mønsteret
Alle Nebo-verktøyapper må bruke STRAP (Single Tool Resource Action Pattern) for skjemaet og rutingen av kjøringen. Dette er det samme mønsteret Nebo bruker internt for å samle over 35 enkeltverktøy i 4 domeneverktøy — noe som reduserer LLM-kontekstbruken med ~80 %.
Grunnidé: I stedet for å registrere flere verktøy (get_events, check_availability, suggest_slots), registrerer du ETT verktøy med feltene action (og eventuelt resource) som ruter til riktig handler.
Eksempel med én ressurs (kalender):
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") Eksempel med flere ressurser (prosjektstyring):
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") Regler for skjemaet:
- Ta alltid med et
action-felt som en påkrevd streng-enum - Legg til et
resource-felt (påkrevd streng-enum) bare hvis verktøyet ditt håndterer flere ulike ressurstyper - Alle andre felt er handlingsspesifikke parametere
- Beskrivelsen av
action-enumen skal liste opp alle tilgjengelige handlinger
Hvorfor STRAP er viktig:
- LLM-er lærer rutingmønsteret for
actionén gang og generaliserer på tvers av alle operasjoner - Verktøydefinisjoner bruker ~6 % av konteksten — STRAP kutter det med 80 %
- Nye operasjoner er bare nye enum-verdier, ikke nye verktøyregistreringer
- Fungerer likt på tvers av hostede og lokale modeller
Go-eksempel — kalkulatorverktøy
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": []
} Bygg og installer:
go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/ Rust-eksempel
use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;
struct Calculator;
#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }
#[async_trait]
impl ToolHandler for Calculator {
fn name(&self) -> &str { "calculator" }
fn description(&self) -> &str { "Performs arithmetic calculations." }
fn schema(&self) -> Value {
SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
.number("a", "First operand", true)
.number("b", "Second operand", true)
.build()
}
async fn execute(&self, input: Value) -> Result<String, NeboError> {
let i: Input = serde_json::from_value(input)
.map_err(|e| NeboError::Execution(e.to_string()))?;
let r = match i.action.as_str() {
"add" => i.a + i.b,
"subtract" => i.a - i.b,
"multiply" => i.a * i.b,
"divide" => {
if i.b == 0.0 {
return Err(NeboError::Execution("division by zero".into()));
}
i.a / i.b
}
other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
};
Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
NeboApp::new()?.register_tool(Calculator).run().await?;
Ok(())
} C-eksempel
#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;
} Kanalapper
Erklær "provides": ["channel:my_channel"] og "permissions": ["channel:send"].
Kanalapper bygger bro mellom eksterne meldingsplattformer (Telegram, Discord, Slack osv.) og Nebos KI-ansatte. Når en bruker sender en melding på den eksterne plattformen, strømmer appen din den til Nebo via Receive. Når KI-ansatte vil svare, kaller Nebo appens Send.
Slik fungerer det
- Nebo kaller
ID()for å hente kanalens unike identifikator - Nebo kaller
Connect()med konfigurasjon fra appens innstillinger - Nebo åpner en
Receive()-strøm — appen din sender innkommende meldinger hver gang en bruker sender melding til boten - Innkommende meldinger rutes til KI-ansattes hovedbane for samtaler
- Når KI-ansatte vil sende en melding, kaller Nebo
Send()med v1-meldingskonvolutten - Ved avslutning kaller Nebo
Disconnect()
v1-meldingskonvolutt
Alle kanalmeldinger — innkommende og utgående — bruker den felles meldingskonvolutten:
{
"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"
} | Felt | Type | Beskrivelse |
|---|---|---|
message_id | UUID v7 | Tidsordnet unik ID |
channel_id | {type}:{platform_id} | Rutbar kanalidentifikator |
sender | object | Botidentitet — navn, rolle, botId |
text | string | Meldingsinnhold |
attachments | array | Filer, bilder, lyd |
reply_to | UUID v7 | ID for overordnet melding, for tråder |
actions | array | Interaktive knapper/tastaturer |
platform_data | bytes | Ugjennomsiktig gjennomsending for plattformspesifikke funksjoner |
timestamp | ISO 8601 | Satt av utgiveren |
Design i to lag: De felles feltene (text, attachments, reply_to, actions) dekker 90 % av meldinger som ansatte starter. Plattformspesifikke funksjoner legges i platform_data — tillegget ditt oversetter dem til og fra plattformens eget format.
Samtalestrømmer
Kanalmeldinger rutes over egne samtalestrømmer per kanal for isolasjon:
neboai/bot/{botID}/channels/{channelType}/inbound # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound # messages from agent → channel Go-eksempel — Telegram-kanal
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
}
]
} Flere funksjoner
Comm-app
Erklær "provides": ["comm"] og "permissions": ["comm:*"]. Comm-apper gjør kommunikasjon mellom KI-ansatte mulig.
| Felt | Beskrivelse |
|---|---|
from | ID for avsenderen |
to | ID for mottakeren |
topic | Meldingens emne/kanal |
type | "message", "mention", "proposal", "command", "info", "task" |
content | Meldingsinnhold |
Viktig oppførsel:
Registerkunngjør denne KI-ansatte på nettverket med funksjonene sineSubscribe/Unsubscribestyrer abonnementer på emnerReceivestrømmer innkommende meldinger (serverstrømming, samme som kanaler)- Bare én comm-app kan være aktiv om gangen
Gateway-app
En gateway-app ruter LLM-forespørsler til modeller. Erklær "provides": ["gateway"] og "permissions": ["network:outbound", "user:token"].
GatewayRequest inneholder meldinger, verktøy, systemprompt, maks antall tokens, temperatur og en UserContext (JWT-token hvis tillatelsen user:token er gitt).
GatewayEvent-typer:
| Type | Innhold | Beskrivelse |
|---|---|---|
"text" | Tekstbit | Strømmet teksttoken |
"tool_call" | JSON | Modellen vil kalle et verktøy |
"thinking" | Tekstbit | Utvidet tenking/resonnering |
"error" | Feilmelding | Noe gikk galt |
"done" | Tom | Strømmen er fullført |
UI-app
En UI-app tilbyr et tilpasset konfigurasjonsgrensesnitt som åpnes i Nebos innebygde nettleservindu. Erklær "provides": ["ui"]. I motsetning til det automatiske innstillingsskjemaet (som Nebo gjengir fra settings i manifestet), leverer en UI-app sin egen komplette HTML/CSS/JS-frontend.
Appen din leveres med en ui/-mappe som inneholder statiske nettressurser (HTML, CSS, JS — vanligvis en SPA med index.html). Nebo serverer disse filene direkte og videresender API-kall til appen din via gRPC.
| Sti | Mekanisme | Formål |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Statisk filserver | Serverer filer fra ui/-mappen din (SPA-reserve til index.html) |
ANY /api/v1/apps/{id}/api/* | gRPC-proxy | Videresender HTTP-forespørsler til appens UIService.HandleRequest() |
SDK-en pakker inn en standard net/http.ServeMux, så du skriver vanlige HTTP-handlere i Go — SDK-en tar seg av gRPC-broen automatisk.
Go-eksempel — dashbord-UI:
package main
import (
"encoding/json"
"log"
"net/http"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Dashboard struct {
mux *http.ServeMux
}
func NewDashboard() *Dashboard {
d := &Dashboard{mux: http.NewServeMux()}
d.mux.HandleFunc("GET /status", func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
})
d.mux.HandleFunc("POST /action", func(w http.ResponseWriter, r *http.Request) {
var req map[string]string
json.NewDecoder(r.Body).Decode(&req)
json.NewEncoder(w).Encode(map[string]string{"result": "done"})
})
return d
}
func (d *Dashboard) Handler() *http.ServeMux { return d.mux }
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterUI(NewDashboard())
log.Fatal(app.Run())
} ui/index.html gjør fetch-kall til /api/v1/apps/com.example.dashboard/api/status, som videresendes til mux-handleren din.
Planleggingsapp
En planleggingsapp erstatter Nebos innebygde cron-planlegger. Erklær "provides": ["schedule"] og "permissions": ["schedule:create"].
Når planleggingsappen din starter, ruter Nebo all planlegging gjennom appen din i stedet for standard cron-motoren. Hvis appen krasjer, faller Nebo automatisk tilbake til den innebygde motoren.
- Appen din eier planleggingstilstanden — Nebo lagrer ikke tidsplaner i sin egen database når en planleggingsapp er aktiv
- Standard CRUD:
Create,Get,List,Update,Delete,Enable,Disable Triggerser en serverstrømmende RPC — appen din sender en utløsermelding hver gang en tidsplan slår til- Bare én planleggingsapp kan være aktiv om gangen
Apper med flere funksjoner
En app kan tilby flere funksjoner. For eksempel en dashbordapp med både et verktøy og et grensesnitt:
{
"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()) Pakking
.napp-format
For distribusjon gjennom NeboAI pakker du appen din som en .napp-fil (et tar.gz-arkiv):
cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md Påkrevde filer:
| Fil | Maks størrelse | Beskrivelse |
|---|---|---|
manifest.json | 1 MB | Appens metadata |
binary eller app | 500 MB | Kjørbar fil |
signatures.json | 1 MB | Ed25519-signaturer |
TOOL.md | 1 MB | Verktøyinstruksjoner for KI-ansatte |
Sikkerhetsregler under utpakking:
- Ingen stitraversering (
../avvises) - Ingen symbolske lenker (avvises)
- Ingen absolutte stier (avvises)
- Bare tillatte filnavn godtas
Signaturer
NeboAI signerer apper med Ed25519. Formatet for 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>"
} I utviklingsmodus (ingen NeboAI-URL konfigurert) hoppes signaturverifiseringen helt over. Du trenger ikke signatures.json for lokal utvikling.
Publisering
Når appen din fungerer lokalt, publiserer du den gjennom NeboAI for distribusjon til alle Nebo-brukere.
Oppsett av utviklerkonto
- Registrer en NeboAI-konto på
POST /api/v1/owners/register - Logg inn for å få et JWT-token:
POST /api/v1/owners/login - Opprett en utviklerkonto:
POST /api/v1/developer/accounts
Innsendingsflyt
draft → pending_review → [approved] → published
→ [rejected] → draft (fix and resubmit) Trinn 1: Opprett appen
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"
}' Trinn 2: Last opp binærfiler for plattformene
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" Last opp én binærfil per plattform: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.
Trinn 3: Send inn til gjennomgang
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
-H "Authorization: Bearer $TOKEN" Gjennomgangsprosessen
- Automatisk skanning — binærfiler skannes via VirusTotal
- Gjennomgang av administrator — NeboAI-teamet går gjennom metadata, manifest og skanneresultater
- Ved godkjenning — NeboAI signerer appen med Ed25519 og publiserer den
- Ved avvisning — du får en begrunnelse og kan rette opp og sende inn på nytt
Mål for gjennomgangstid: <24 timer.
Sende ut oppdateringer
- Oppdater appens versjon:
PUT /api/v1/developer/apps/{id}med den nye versjonen - Last opp nye binærfiler for hver plattform
- Send inn til gjennomgang på nytt
Hver oppdatering går gjennom den samme gjennomgangsprosessen. Tidligere versjoner er tilgjengelige til den nye versjonen er godkjent.
Metadata for butikken
| Felt | Beskrivelse |
|---|---|
category | f.eks. productivity, communication, developer-tools |
icon | URL til appikonet |
visibility | public eller private |
description | Kan være lengre og rikere enn beskrivelsen i manifestet |
Arbeidsflyt for utvikling
Lokal utvikling
Ingen pakking kreves for lokal utvikling:
- Opprett appkatalogen din:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - Skriv
manifest.jsonog koden din - Bygg binærfilen din:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo oppdager den nye mappen automatisk (eller start Nebo på nytt)
- Etter kodeendringer bygger du binærfilen på nytt — filovervåkeren starter appen på nytt
Vise logger
Appens stdout/stderr fanges opp i loggfiler per app:
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 Vedvarende data
Bruk data/-mappen (også tilgjengelig som miljøvariabelen NEBO_APP_DATA) for alle filer appen din må ta vare på. Denne mappen overlever appoppdateringer og karantene.
Feilsøkingstips
- Hvis appen ikke starter, sjekk
logs/stderr.logfor feil - Sørg for at binærfilen er kjørbar (
chmod +x binary) - Sørg for at du lytter på Unix-socketstien fra
NEBO_APP_SOCK - Socketen må være klar innen 10 sekunder etter oppstart
- Bruk
NEBO_APP_DATAtil lagring, ikke hardkodede stier - Skriv til stderr for feilsøkingslogging (fanges opp i
logs/stderr.log)
Verifisering
# 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 Avinstallering
nebo apps uninstall com.example.myapp Ferdigheter
Hva ferdigheter er
Ferdigheter er instruksjonssett som former hvordan Nebo oppfører seg i en samtale. Når en ferdighet er aktiv, settes innholdet rett inn i systemprompten — og styrer KI-ansattes tone, metode, fagkunnskap og verktøybruk i den økten.
Ferdigheter er ikke kode. De er markdown-dokumenter med YAML-metadata. Ingen kompilering, ingen binærfil, ingen gRPC. En ferdighet er en SKILL.md-fil i en mappe. Det er alt.
Ferdigheter er kontekstuelle og midlertidige. De aktiveres når de er relevante (via utløsertreff eller manuell lasting), varer i noen få turer og utløper når de ikke lenger trengs. Det holder KI-ansattes kontekst slank — bare veiledningen som betyr noe akkurat nå, er i prompten.
Ferdigheter utfyller apper. Apper gir kjørbare funksjoner (verktøy, kanaler, gatewayer). Ferdigheter gir veiledning for orkestrering — hvordan verktøyene brukes effektivt. En kalenderapp gir Nebo evnen til å lese og skrive hendelser. En ferdighet for «møteforberedelse» forteller Nebo hvordan den skal forberede møter med kalenderappen, e-post og nettsøk sammen.
Ferdigheter og apper
| Ferdigheter | Apper | |
|---|---|---|
| Format | Markdown (SKILL.md) | Kompilert binærfil (.napp) |
| Kjøretid | Settes inn i systemprompten | Prosess i sandkasse over gRPC |
| Tilbyr | Atferdsveiledning, metode | Verktøy, kanaler, UI-paneler |
| Levetid | Avgrenset til økten, utløper etter TTL | Kjører alltid |
| Opprettelse | Skriv en markdown-fil | Skriv, kompiler, signer, pakk |
| Sikkerhet | Ingen tillatelser nødvendig | Sandkasse med avslag som standard |
Hurtigstart
Opprett en mappe i Nebo-ferdighetsmappen din med en SKILL.md-fil:
~/Library/Application Support/Nebo/skills/ # macOS
~/.config/nebo/skills/ # Linux
%AppData%\Nebo\skills\ # Windows mkdir -p ~/.config/nebo/skills/my-skill Skriv en 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 overvåker ferdighetsmappen med fsnotify. Ferdigheten din er tilgjengelig med en gang — ingen omstart nødvendig. Si noe som samsvarer med en utløser, så aktiveres den automatisk.
Eller be Nebo direkte: «Lag en ferdighet for å skrive blogginnlegg» — Nebo skriver SKILL.md-filen for deg.
SKILL.md-format
Hver ferdighet er én enkelt SKILL.md-fil med to deler: YAML-frontmatter mellom ----markører, og en markdown-brødtekst (selve instruksjonene som settes inn i systemprompten).
| Felt | Påkrevd | Standard | Beskrivelse |
|---|---|---|---|
name | Ja | — | Unik identifikator (blir sluggen) |
description | Ja | — | Beskrivelse på én linje som vises i ferdighetskatalogen |
version | Nei | "1.0.0" | Semver for å spore oppdateringer |
author | Nei | — | Ferdighetens forfatter |
priority | Nei | 0 | Høyere = treffes først (100+ for kritiske overstyringer) |
max_turns | Nei | 4 | Turer uten aktivitet før automatisk utløp |
triggers | Nei | [] | Fraser som aktiverer denne ferdigheten automatisk (delstrengtreff uten skille mellom store og små bokstaver) |
tools | Nei | [] | Verktøy denne ferdigheten forventer å bruke (til informasjon) |
dependencies | Nei | [] | Andre ferdigheter som må være installert |
tags | Nei | [] | For kategorisering og oppdagelse |
platform | Nei | [] | Støttede plattformer: macos, linux, windows (tom = alle) |
Slik aktiveres ferdigheter
Ferdigheter følger en aktiveringsmodell i to faser: hint, deretter kall.
Fase 1: Utløsertreff — Hver gang en bruker sender en melding, skanner Nebo alle registrerte ferdigheter etter utløsertreff. Ferdigheter som treffer, vises som hint i systemprompten. KI-ansatte ser hintet og avgjør om ferdigheten skal kalles.
Fase 2: Kall — KI-ansatte kaller en ferdighet slik:
skill(name: "code-review") Dette returnerer hele SKILL.md-malen som verktøyresultat, registrerer kallet og setter malen inn i systemprompten igjen i de påfølgende turene.
TTL og utløp:
- Automatisk treffte ferdigheter: 4 turer uten aktivitet (kan konfigureres via
max_turns) - Manuelt lastede ferdigheter: 6 turer uten aktivitet
- Et nytt kall nullstiller tidtakeren
- Fast grense: maks 4 aktive ferdigheter per økt
- Tokenbudsjett: samlet innhold i aktive ferdigheter begrenset til 16 000 tegn
Administrere ferdigheter
KI-ansatte kan administrere ferdigheter gjennom verktøyet skill:
| Handling | Beskrivelse | Eksempel |
|---|---|---|
catalog | List opp alle tilgjengelige ferdigheter | skill(action: "catalog") |
load | Aktiver for denne økten | skill(name: "code-review", action: "load") |
unload | Deaktiver en ferdighet | skill(name: "code-review", action: "unload") |
create | Opprett en ny ferdighet på disken | skill(action: "create", content: "...") |
update | Oppdater en eksisterende ferdighet | skill(name: "my-skill", action: "update", content: "...") |
delete | Slett en ferdighet fra disken | skill(name: "my-skill", action: "delete") |
Skrive gode ferdigheter
En god ferdighetsmal har:
- En tydelig overskrift — forteller KI-ansatte hvilken modus de er i
- Kjerneprinsipper — atferdsreglene det ikke forhandles om
- Metode — trinnvis fremgangsmåte for vanlige scenarier
- Eksempler — konkrete mønstre fra brukermelding til svar
- Antimønstre — hva man IKKE skal gjøre (modeller lærer godt av negative eksempler)
Tips: Hver ferdighet bør gjøre én ting godt. Ikke lag en ferdighet for «generell programmering» — lag code-review, debugging, api-design som separate ferdigheter. KI-ansatte kan ha flere aktive samtidig.
Medfølgende ferdigheter
Nebo leveres med ferdigheter som dekker vanlige bruksområder:
| Ferdighet | Prioritet | Beskrivelse |
|---|---|---|
onboarding | 100 | Velkomst for nye brukere og innsamling av profil |
best-friend | 50 | Personlighetsferdighet — uformell, lojal, ærlig prat |
debugging | 25 | Systematisk metode for feilsøking |
api-design | 15 | Beste praksis for RESTful API-design |
code-review | 10 | Strukturert kodegjennomgang med alvorlighetsnivåer |
database-expert | 10 | Databasedesign, spørringer, optimalisering |
git-workflow | 10 | Git-forgreninger, commits, PR-arbeidsflyter |
security-audit | 10 | Sikkerhetsanalyse og oppdagelse av sårbarheter |
Disse fungerer både som nyttige standarder og som referanseimplementasjoner når du lager dine egne ferdigheter.
Referanse
Proto-filer
Proto-filer ligger i proto/apps/v0/. SDK-ene leveres med forhåndsgenerert kode, så du trenger ikke protoc for vanlig utvikling.
| Fil | Tjeneste | Viktige RPC-er |
|---|---|---|
v0/common.proto | (kun meldinger) | HealthCheckRequest/Response, SettingsMap, UserContext, Empty |
v0/tool.proto | ToolService | Name, Description, Schema, Execute, RequiresApproval, Configure |
v0/channel.proto | ChannelService | ID, Connect, Disconnect, Send, Receive (strøm), Configure |
v0/comm.proto | CommService | Name, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (strøm), Configure |
v0/gateway.proto | GatewayService | HealthCheck, Stream (strøm), 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 (strøm), Configure |
Hver tjeneste inkluderer RPC-ene HealthCheck og Configure. SDK-en håndterer begge automatisk.
Proto-typer for kanaler
| Meldingstype | Beskrivelse |
|---|---|
ChannelSendRequest | Konvolutt for utgående meldinger med message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | Plattformens meldings-ID for tråder |
InboundMessage | Konvolutt for innkommende meldinger med alle felles felt + tidsstempel |
MessageSender | Botidentitet (name, role, botId) — beriket av megleren |
Attachment | Vedlegg med fil/bilde/lyd (type, url, filename, size) |
MessageAction | Interaktiv knapp-/tastaturhandling (label, callback_id) |
Botidentitet og roller
Nebo-boter har en identitetsmodell med tre akser:
- creature — Hva boten er (arketype): «Kvikk strateg», «Grundig forsker»
- role — Hvordan den forholder seg til brukeren (relasjon): «Venn», «COO», «Mentor»
- vibe — Energien dens (kommunikasjonsstil): «Avslappet, men meningssterk», «Varm og oppmuntrende»
Når kanaltillegget ditt mottar en utgående melding, inneholder feltet sender botens name og role. Bruk dette til å formatere visningsnavnet for plattformen din. Rollen er ikke en stillingstittel — den beskriver en relasjon. «Venn», «Sønn» og «Mentor» er gyldige roller ved siden av «COO» og «DevLead».