NeboAI
NeboAI
Kom i gang

Bygg apper for Nebo

Gi KI-en din nye superkrefter. Verktøy, kanaler, gatewayer, UI-paneler — alt du kan forestille deg, kompilert til en native binærfil.

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.

StatusSpråk
StøttetGo (anbefalt), Rust, C/C++, Zig
AvvistPython, 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

  1. Opprett manifest.json med id, name, version, provides
  2. Skriv TOOL.md som beskriver hvordan KI-ansatte skal bruke verktøyet ditt
  3. Installer SDK-en (go get github.com/neboloop/nebo-sdk-go)
  4. Implementer handler-grensesnittet for funksjonen din (ToolHandler, ChannelHandler osv.)
  5. Registrer handleren og kall app.Run()
  6. Bygg en native binærfil (go build -o binary .)
  7. Legg binærfilen + manifest.json + TOOL.md i mappen apps/<your-app-id>/
  8. 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:

FeltBeskrivelse
idIdentifikator i omvendt domeneformat (f.eks. com.mycompany.myapp)
nameLesbart navn
versionSemver-streng
providesMinst én funksjon (se nedenfor)

Valgfrie felt:

FeltStandardBeskrivelse
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:

FunksjongRPC-tjenesteBeskrivelse
gatewayGatewayServiceRuting av LLM-modeller
tool:<name>ToolServiceEt navngitt verktøy for KI-ansatte
channel:<name>ChannelServiceEn meldingskanal
commCommServiceKommunikasjon mellom KI-ansatte
uiUIServiceTilpasset grensesnitt med HTTP-proxy
scheduleScheduleServiceTilpasset planlegging
visionToolServiceBildebehandling
browserToolServiceNettleserautomatisering

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.

PrefiksEksemplerBeskrivelse
network:network:outbound, network:*Nettverkstilgang
filesystem:filesystem:read, filesystem:writeTilgang til filsystemet
memory:memory:read, memory:writeTilgang til KI-ansattes minne
session:session:readSamtaleøkter
tool:tool:shell, tool:fileBruke andre verktøy
shell:shell:execKjøring av skallkommandoer
channel:channel:send, channel:*Kanaloperasjoner
comm:comm:send, comm:*Kommunikasjon mellom KI-ansatte
model:model:chatTilgang til KI-modeller
user:user:tokenMotta brukerens JWT i forespørsler
schedule:schedule:createAdministrasjon av cron-jobber
database:database:queryDatabasetilgang
storage:storage:read, storage:writeVedvarende lagring
context:context:readTilgang til KI-ansattes kontekst
subagent:subagent:spawnOperasjoner for underagenter
lane:lane:enqueueOperasjoner for baner
notification:notification:sendPushvarsler
embedding:embedding:searchTilgang til vektor-embeddinger
skill:skill:invokeKalle opp ferdigheter
advisor:advisor:consultTilgang til rådgiversystemet
mcp:mcp:connectTilgang til MCP-servere
voice:voice:recordTilgang til tale/lyd
browser:browser:navigateNettleserautomatisering
oauth:oauth:google, oauth:*Tilgang til OAuth-tokener
settings:settings:readTilgang til innstillinger
capability:capability:registerRegistrering 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.

TypeBeskrivelse
textTekstfelt på én linje
passwordMaskert tekstfelt
toggleBoolsk av/på-bryter
selectNedtrekksmeny med forhåndsdefinerte valg
numberTallfelt
urlURL-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"]
        }
    ]
}
FeltBeskrivelse
providerOAuth-leverandør: "google", "microsoft", "github"
scopesMatrise 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:

VariabelVerdi
NEBO_APP_DIRAppens installasjonsmappe
NEBO_APP_SOCKSti til Unix-socketen som skal opprettes
NEBO_APP_IDApp-ID fra manifestet
NEBO_APP_NAMEAppnavn fra manifestet
NEBO_APP_VERSIONAppversjon fra manifestet
NEBO_APP_DATASti til appens data/-mappe
PATHSystem-PATH (sendes videre)
HOMEBrukerens hjemmemappe (sendes videre)
TMPDIRMidlertidig 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

  1. Nebo leser manifest.json og validerer den
  2. Finner den kjørbare filen binary eller app i appmappen
  3. Ser etter .quarantined-markøren (nekter å starte apper i karantene)
  4. Sjekk av tilbakekalling (kun apper distribuert av NeboAI)
  5. Verifisering av signatur (kun apper distribuert av NeboAI, hoppes over i utvikling)
  6. Validering av binærfilen (avviser symbolske lenker, skript, ikke-kjørbare filer og for store filer)
  7. Rydder opp gammel socket fra forrige kjøring
  8. Oppretter data/-mappen for lagring i sandkasse
  9. Setter opp loggfiler per app (logs/stdout.log, logs/stderr.log)
  10. Starter binærfilen med renset miljø og isolert prosessgruppe
  11. Venter på at Unix-socketen dukker opp (eksponentiell backoff, maks 10 sekunder)
  12. Kobler til via gRPC over Unix-socketen
  13. Oppretter funksjonsspesifikke gRPC-klienter basert på provides
  14. Kjører helsesjekk
  15. 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:

  1. Ta alltid med et action-felt som en påkrevd streng-enum
  2. Legg til et resource-felt (påkrevd streng-enum) bare hvis verktøyet ditt håndterer flere ulike ressurstyper
  3. Alle andre felt er handlingsspesifikke parametere
  4. 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

  1. Nebo kaller ID() for å hente kanalens unike identifikator
  2. Nebo kaller Connect() med konfigurasjon fra appens innstillinger
  3. Nebo åpner en Receive()-strøm — appen din sender innkommende meldinger hver gang en bruker sender melding til boten
  4. Innkommende meldinger rutes til KI-ansattes hovedbane for samtaler
  5. Når KI-ansatte vil sende en melding, kaller Nebo Send() med v1-meldingskonvolutten
  6. 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"
}
FeltTypeBeskrivelse
message_idUUID v7Tidsordnet unik ID
channel_id{type}:{platform_id}Rutbar kanalidentifikator
senderobjectBotidentitet — navn, rolle, botId
textstringMeldingsinnhold
attachmentsarrayFiler, bilder, lyd
reply_toUUID v7ID for overordnet melding, for tråder
actionsarrayInteraktive knapper/tastaturer
platform_databytesUgjennomsiktig gjennomsending for plattformspesifikke funksjoner
timestampISO 8601Satt 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.

FeltBeskrivelse
fromID for avsenderen
toID for mottakeren
topicMeldingens emne/kanal
type"message", "mention", "proposal", "command", "info", "task"
contentMeldingsinnhold

Viktig oppførsel:

  • Register kunngjør denne KI-ansatte på nettverket med funksjonene sine
  • Subscribe/Unsubscribe styrer abonnementer på emner
  • Receive strø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:

TypeInnholdBeskrivelse
"text"TekstbitStrømmet teksttoken
"tool_call"JSONModellen vil kalle et verktøy
"thinking"TekstbitUtvidet tenking/resonnering
"error"FeilmeldingNoe gikk galt
"done"TomStrø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.

StiMekanismeFormål
GET /api/v1/apps/{id}/ui/*Statisk filserverServerer filer fra ui/-mappen din (SPA-reserve til index.html)
ANY /api/v1/apps/{id}/api/*gRPC-proxyVideresender 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
  • Triggers er 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:

FilMaks størrelseBeskrivelse
manifest.json1 MBAppens metadata
binary eller app500 MBKjørbar fil
signatures.json1 MBEd25519-signaturer
TOOL.md1 MBVerktø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

  1. Registrer en NeboAI-konto på POST /api/v1/owners/register
  2. Logg inn for å få et JWT-token: POST /api/v1/owners/login
  3. 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

  1. Automatisk skanning — binærfiler skannes via VirusTotal
  2. Gjennomgang av administrator — NeboAI-teamet går gjennom metadata, manifest og skanneresultater
  3. Ved godkjenning — NeboAI signerer appen med Ed25519 og publiserer den
  4. 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

  1. Oppdater appens versjon: PUT /api/v1/developer/apps/{id} med den nye versjonen
  2. Last opp nye binærfiler for hver plattform
  3. 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

FeltBeskrivelse
categoryf.eks. productivity, communication, developer-tools
iconURL til appikonet
visibilitypublic eller private
descriptionKan være lengre og rikere enn beskrivelsen i manifestet

Arbeidsflyt for utvikling

Lokal utvikling

Ingen pakking kreves for lokal utvikling:

  1. Opprett appkatalogen din:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Skriv manifest.json og koden din
  3. Bygg binærfilen din:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo oppdager den nye mappen automatisk (eller start Nebo på nytt)
  5. 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.log for 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_DATA til 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

FerdigheterApper
FormatMarkdown (SKILL.md)Kompilert binærfil (.napp)
KjøretidSettes inn i systempromptenProsess i sandkasse over gRPC
TilbyrAtferdsveiledning, metodeVerktøy, kanaler, UI-paneler
LevetidAvgrenset til økten, utløper etter TTLKjører alltid
OpprettelseSkriv en markdown-filSkriv, kompiler, signer, pakk
SikkerhetIngen tillatelser nødvendigSandkasse 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).

FeltPåkrevdStandardBeskrivelse
nameJa—Unik identifikator (blir sluggen)
descriptionJa—Beskrivelse på én linje som vises i ferdighetskatalogen
versionNei"1.0.0"Semver for å spore oppdateringer
authorNei—Ferdighetens forfatter
priorityNei0Høyere = treffes først (100+ for kritiske overstyringer)
max_turnsNei4Turer uten aktivitet før automatisk utløp
triggersNei[]Fraser som aktiverer denne ferdigheten automatisk (delstrengtreff uten skille mellom store og små bokstaver)
toolsNei[]Verktøy denne ferdigheten forventer å bruke (til informasjon)
dependenciesNei[]Andre ferdigheter som må være installert
tagsNei[]For kategorisering og oppdagelse
platformNei[]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:

HandlingBeskrivelseEksempel
catalogList opp alle tilgjengelige ferdigheterskill(action: "catalog")
loadAktiver for denne øktenskill(name: "code-review", action: "load")
unloadDeaktiver en ferdighetskill(name: "code-review", action: "unload")
createOpprett en ny ferdighet på diskenskill(action: "create", content: "...")
updateOppdater en eksisterende ferdighetskill(name: "my-skill", action: "update", content: "...")
deleteSlett en ferdighet fra diskenskill(name: "my-skill", action: "delete")

Skrive gode ferdigheter

En god ferdighetsmal har:

  1. En tydelig overskrift — forteller KI-ansatte hvilken modus de er i
  2. Kjerneprinsipper — atferdsreglene det ikke forhandles om
  3. Metode — trinnvis fremgangsmåte for vanlige scenarier
  4. Eksempler — konkrete mønstre fra brukermelding til svar
  5. 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:

FerdighetPrioritetBeskrivelse
onboarding100Velkomst for nye brukere og innsamling av profil
best-friend50Personlighetsferdighet — uformell, lojal, ærlig prat
debugging25Systematisk metode for feilsøking
api-design15Beste praksis for RESTful API-design
code-review10Strukturert kodegjennomgang med alvorlighetsnivåer
database-expert10Databasedesign, spørringer, optimalisering
git-workflow10Git-forgreninger, commits, PR-arbeidsflyter
security-audit10Sikkerhetsanalyse 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.

FilTjenesteViktige RPC-er
v0/common.proto(kun meldinger)HealthCheckRequest/Response, SettingsMap, UserContext, Empty
v0/tool.protoToolServiceName, Description, Schema, Execute, RequiresApproval, Configure
v0/channel.protoChannelServiceID, Connect, Disconnect, Send, Receive (strøm), Configure
v0/comm.protoCommServiceName, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (strøm), Configure
v0/gateway.protoGatewayServiceHealthCheck, Stream (strøm), Poll, Cancel, Configure
v0/ui.protoUIServiceHealthCheck, HandleRequest, Configure
v0/schedule.protoScheduleServiceHealthCheck, 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

MeldingstypeBeskrivelse
ChannelSendRequestKonvolutt for utgående meldinger med message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponsePlattformens meldings-ID for tråder
InboundMessageKonvolutt for innkommende meldinger med alle felles felt + tidsstempel
MessageSenderBotidentitet (name, role, botId) — beriket av megleren
AttachmentVedlegg med fil/bilde/lyd (type, url, filename, size)
MessageActionInteraktiv 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».