NeboAI
NeboAI
Ξεκινήστε

Φτιάξτε εφαρμογές για το Nebo

Δώστε στην ΤΝ σας νέες υπερδυνάμεις. Εργαλεία, κανάλια, πύλες, πάνελ UI — ό,τι μπορείτε να φανταστείτε, μεταγλωττισμένο σε εγγενές εκτελέσιμο.

Επισκόπηση

Τι είναι το Nebo

Το Nebo είναι ένας προσωπικός βοηθός ΤΝ για τον υπολογιστή — ένας υπάλληλος ΤΝ που λειτουργεί διαρκώς και διαχειρίζεται την ψηφιακή σας ζωή. Σκεφτείτε το Nebo όπως σκέφτεστε ένα smartphone: μια ισχυρή πλατφόρμα που γίνεται καθοριστική μέσα από τις εφαρμογές της.

Από μόνο του, το Nebo είναι ένας ικανός υπάλληλος ΤΝ με μνήμη, προγραμματισμό, περιήγηση στο web, διαχείριση αρχείων και πρόσβαση στο shell. Όμως το πραγματικό άνοιγμα είναι οι Εφαρμογές. Όπως η δύναμη ενός smartphone προέρχεται από το οικοσύστημα εφαρμογών του, έτσι και η δύναμη του Nebo προέρχεται από τις εφαρμογές που επεκτείνουν όσα μπορεί να κάνει.

Τι είναι οι εφαρμογές

Οι εφαρμογές Nebo είναι αυτόνομες, προμεταγλωττισμένες μονάδες εξαιρετικής λειτουργικότητας. Κάθε εφαρμογή δίνει στο Nebo μια νέα υπερδύναμη — διαχείριση ημερολογίου, ταξινόμηση email, παρακολούθηση έργων, οικιακό αυτοματισμό, οικονομική ανάλυση — ό,τι μπορεί να φανταστεί ένας προγραμματιστής.

Οι εφαρμογές παρέχουν τεράστια ισχύ με πολύ ασφαλή τρόπο. Κάθε εφαρμογή εκτελείται σε sandbox με δικαιώματα που απαγορεύονται από προεπιλογή. Μπορεί να έχει πρόσβαση μόνο σε όσα δηλώνει το manifest της και εγκρίνει ο χρήστης.

Η διεπαφή είναι 100% συνομιλιακή. Οι χρήστες δεν αλληλεπιδρούν με τις εφαρμογές μέσα από ξεχωριστές οθόνες ή πίνακες ελέγχου. Μιλούν στο Nebo και το Nebo χρησιμοποιεί τα εργαλεία της εφαρμογής για να γίνει η δουλειά. «Τι έχω στο ημερολόγιο αύριο;» — το Nebo καλεί την εφαρμογή ημερολογίου. «Κλείσε μια συνάντηση με τη Sarah στις 3 μ.μ.» — το Nebo καλεί την εφαρμογή ημερολογίου. Ο χρήστης δεν βγαίνει ποτέ από τη συνομιλία.

Οι εφαρμογές μπορούν προαιρετικά να παρέχουν ένα UI ρυθμίσεων — ένα πάνελ διαμόρφωσης που ανοίγει στο ενσωματωμένο παράθυρο προγράμματος περιήγησης του Nebo. Εδώ οι χρήστες εισάγουν κλειδιά API, ενεργοποιούν λειτουργίες και διαμορφώνουν την εφαρμογή. Το UI ρυθμίσεων βασίζεται στον πίνακα settings του manifest (το Nebo αποδίδει τη φόρμα αυτόματα), ή η εφαρμογή μπορεί να παρέχει το δικό της πλήρως προσαρμοσμένο UI μέσω της δυνατότητας ui.

Οι εφαρμογές αντικαθιστούν και επεκτείνουν τις ενσωματωμένες δυνατότητες του Nebo. Το Nebo διατίθεται με βασικά εργαλεία πλατφόρμας (τοπική πρόσβαση σε ημερολόγιο, στιγμιότυπα οθόνης κ.λπ.). Όταν εγκαθιστάτε μια εφαρμογή ημερολογίου, αντικαθιστά το ενσωματωμένο εργαλείο ημερολογίου και γίνεται υπερσύνολό του — τοπικό + cloud + συγκέντρωση + έλεγχος διαθεσιμότητας.

Πολιτική μόνο μεταγλωττισμένων

Το Nebo επιβάλλει αυστηρή πολιτική μόνο μεταγλωττισμένων εκτελέσιμων. Όλες οι εφαρμογές πρέπει να είναι εγγενή μεταγλωττισμένα εκτελέσιμα.

ΚατάστασηΓλώσσες
ΥποστηρίζονταιGo (συνιστάται), Rust, C/C++, Zig
ΑπορρίπτονταιPython, Node.js, Ruby, Java, .NET, σενάρια shell

Αιτιολόγηση:

  • Αποτροπή αυτοτροποποίησης της ΤΝ — Ένας υπάλληλος ΤΝ με πρόσβαση στο shell θα μπορούσε να τροποποιήσει τη συμπεριφορά ενός διερμηνευόμενου σεναρίου κατά την εκτέλεση. Τα μεταγλωττισμένα εκτελέσιμα είναι αμετάβλητα μετά την υπογραφή.
  • Ακεραιότητα υπογραφής — Οι υπογραφές Ed25519 καλύπτουν τα ακατέργαστα bytes του εκτελέσιμου. Ένα υπογεγραμμένο εκτελέσιμο δεν μπορεί να τροποποιηθεί χωρίς να ακυρωθεί η υπογραφή.
  • Επιβολή sandbox — Ο έλεγχος της μορφής του εκτελέσιμου (magic bytes ELF/Mach-O/PE) είναι μια γρήγορη, αξιόπιστη πύλη.

Γρήγορη εκκίνηση

Εγκατάσταση του SDK

Τα επίσημα SDK αναλαμβάνουν όλη τη ρύθμιση του διακομιστή gRPC, τον χειρισμό σημάτων και τη γεφύρωση πρωτοκόλλων. Εσείς απλώς υλοποιείτε διεπαφές χειριστών.

Go (συνιστάται):

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

Rust (σύντομα):

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

C/C++ (σύντομα):

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

Δομή καταλόγου εφαρμογής

Οι εφαρμογές βρίσκονται στον υποκατάλογο apps/ του καταλόγου δεδομένων του 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)

Λίστα ελέγχου ελάχιστης εφαρμογής

  1. Δημιουργήστε το manifest.json με id, name, version, provides
  2. Γράψτε το TOOL.md που περιγράφει πώς πρέπει ο υπάλληλος ΤΝ να χρησιμοποιεί το εργαλείο σας
  3. Εγκαταστήστε το SDK (go get github.com/neboloop/nebo-sdk-go)
  4. Υλοποιήστε τη διεπαφή χειριστή για τη δυνατότητά σας (ToolHandler, ChannelHandler κ.λπ.)
  5. Καταχωρίστε τον χειριστή και καλέστε το app.Run()
  6. Μεταγλωττίστε ένα εγγενές εκτελέσιμο (go build -o binary .)
  7. Τοποθετήστε το εκτελέσιμο + manifest.json + TOOL.md στον κατάλογο apps/<your-app-id>/
  8. Το Nebo το εντοπίζει και το εκκινεί αυτόματα

Διαμόρφωση

manifest.json

Κάθε εφαρμογή απαιτεί ένα 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
        }
    ]
}

Υποχρεωτικά πεδία:

ΠεδίοΠεριγραφή
idΑναγνωριστικό σε αντίστροφη μορφή τομέα (π.χ. com.mycompany.myapp)
nameΌνομα αναγνώσιμο από άνθρωπο
versionΣυμβολοσειρά semver
providesΤουλάχιστον μία δυνατότητα (βλ. παρακάτω)

Προαιρετικά πεδία:

ΠεδίοΠροεπιλογήΠεριγραφή
runtime"local""local" ή "remote"
protocol"grpc"Υποστηρίζεται μόνο το "grpc"
permissions[]Σε τι χρειάζεται πρόσβαση η εφαρμογή
description""Εμφανίζεται στο UI
settings[]Ρυθμίσεις που διαμορφώνονται (αποδίδονται στο UI ρυθμίσεων)
oauth[]Απαιτήσεις παρόχου OAuth (βλ. την ενότητα OAuth παρακάτω)

Δυνατότητες

Δηλώστε τι παρέχει η εφαρμογή σας:

ΔυνατότηταΥπηρεσία gRPCΠεριγραφή
gatewayGatewayServiceΔρομολόγηση μοντέλων LLM
tool:<name>ToolServiceΈνα επώνυμο εργαλείο για τον υπάλληλο ΤΝ
channel:<name>ChannelServiceΈνα κανάλι μηνυμάτων
commCommServiceΕπικοινωνία μεταξύ υπαλλήλων ΤΝ
uiUIServiceΠροσαρμοσμένο UI με διακομιστή μεσολάβησης HTTP
scheduleScheduleServiceΠροσαρμοσμένος προγραμματισμός
visionToolServiceΕπεξεργασία εικόνας
browserToolServiceΑυτοματοποίηση προγράμματος περιήγησης

Μια εφαρμογή μπορεί να παρέχει πολλές δυνατότητες. Για παράδειγμα, μια εφαρμογή θα μπορούσε να παρέχει και ένα εργαλείο και ένα πάνελ UI.

Δικαιώματα

Τα δικαιώματα ελέγχουν σε τι έχει πρόσβαση η εφαρμογή. Απαγόρευση από προεπιλογή — αν δεν δηλωθεί, η εφαρμογή δεν μπορεί να το χρησιμοποιήσει.

ΠρόθεμαΠαραδείγματαΠεριγραφή
network:network:outbound, network:*Πρόσβαση στο δίκτυο
filesystem:filesystem:read, filesystem:writeΠρόσβαση στο σύστημα αρχείων
memory:memory:read, memory:writeΠρόσβαση στη μνήμη του υπαλλήλου ΤΝ
session:session:readΣυνεδρίες συνομιλίας
tool:tool:shell, tool:fileΧρήση άλλων εργαλείων
shell:shell:execΕκτέλεση εντολών shell
channel:channel:send, channel:*Λειτουργίες καναλιών
comm:comm:send, comm:*Επικοινωνία μεταξύ υπαλλήλων ΤΝ
model:model:chatΠρόσβαση σε μοντέλα ΤΝ
user:user:tokenΛήψη του JWT του χρήστη στα αιτήματα
schedule:schedule:createΔιαχείριση εργασιών cron
database:database:queryΠρόσβαση σε βάση δεδομένων
storage:storage:read, storage:writeΜόνιμη αποθήκευση
context:context:readΠρόσβαση στο πλαίσιο του υπαλλήλου ΤΝ
subagent:subagent:spawnΛειτουργίες sub-agent
lane:lane:enqueueΛειτουργίες lane
notification:notification:sendΕιδοποιήσεις push
embedding:embedding:searchΠρόσβαση σε vector embeddings
skill:skill:invokeΚλήση δεξιοτήτων
advisor:advisor:consultΠρόσβαση στο σύστημα συμβούλων
mcp:mcp:connectΠρόσβαση σε διακομιστή MCP
voice:voice:recordΠρόσβαση σε φωνή/ήχο
browser:browser:navigateΑυτοματοποίηση προγράμματος περιήγησης
oauth:oauth:google, oauth:*Πρόσβαση σε tokens OAuth
settings:settings:readΠρόσβαση στις ρυθμίσεις
capability:capability:registerΚαταχώριση δυνατοτήτων

Υποστηρίζονται δικαιώματα με μπαλαντέρ: το network:* ταιριάζει με κάθε έλεγχο δικαιώματος network:.

Ρυθμίσεις

Οι ρυθμίσεις εμφανίζονται στο UI του Nebo, στο πάνελ ρυθμίσεων της εφαρμογής. Το Nebo τις αποθηκεύει στη βάση δεδομένων και τις στέλνει στην εφαρμογή σας μέσω του RPC Configure όταν αλλάζουν.

Το σχήμα ρυθμίσεών σας περιλαμβάνεται στην καταχώριση του καταστήματος εφαρμογών της NeboAI. Οι εφαρμογές με υποχρεωτικές ρυθμίσεις που δεν έχουν διαμορφωθεί εμφανίζουν μια ένδειξη «Χρειάζεται ρύθμιση» στο UI.

ΤύποςΠεριγραφή
textΠεδίο κειμένου μίας γραμμής
passwordΠεδίο κειμένου με απόκρυψη
toggleΔιακόπτης ενεργοποίησης/απενεργοποίησης
selectΑναπτυσσόμενη λίστα με προκαθορισμένες επιλογές
numberΑριθμητικό πεδίο
urlΠεδίο URL με επικύρωση
{
    "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

Οι εφαρμογές μπορούν να δηλώνουν απαιτήσεις παρόχου OAuth. Ο μεσολαβητής OAuth του Nebo χειρίζεται όλη τη ροή — οι εφαρμογές λαμβάνουν tokens αυτόματα μέσω του RPC Configure.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
ΠεδίοΠεριγραφή
providerΠάροχος OAuth: "google", "microsoft", "github"
scopesΠίνακας με τα scopes OAuth που χρειάζεται η εφαρμογή

Όταν ο χρήστης εγκαθιστά την εφαρμογή, το Nebo του ζητά να εγκρίνει τα απαιτούμενα scopes OAuth. Η εφαρμογή λαμβάνει ανανεωμένα tokens μέσω του RPC Configure χωρίς να χειρίζεται η ίδια τη ροή OAuth.

Μεταβλητές περιβάλλοντος

Η διεργασία της εφαρμογής σας λαμβάνει ένα καθαρισμένο περιβάλλον. Όλα τα μυστικά αφαιρούνται. Λαμβάνετε:

ΜεταβλητήΤιμή
NEBO_APP_DIRΚατάλογος εγκατάστασης της εφαρμογής
NEBO_APP_SOCKΔιαδρομή προς το Unix socket που πρέπει να δημιουργηθεί
NEBO_APP_IDID εφαρμογής από το manifest
NEBO_APP_NAMEΌνομα εφαρμογής από το manifest
NEBO_APP_VERSIONΈκδοση εφαρμογής από το manifest
NEBO_APP_DATAΔιαδρομή προς τον κατάλογο data/ της εφαρμογής
PATHPATH συστήματος (μεταβιβάζεται)
HOMEΑρχικός κατάλογος χρήστη (μεταβιβάζεται)
TMPDIRΚατάλογος προσωρινών αρχείων (μεταβιβάζεται)

Κρίσιμο: Το εκτελέσιμό σας πρέπει να δημιουργεί έναν διακομιστή gRPC που ακούει στο Unix socket στο NEBO_APP_SOCK. Το Nebo περιμένει έως 10 δευτερόλεπτα να εμφανιστεί αυτό το socket.

Ακολουθία εκκίνησης εφαρμογής

  1. Το Nebo διαβάζει το manifest.json και το επικυρώνει
  2. Βρίσκει το εκτελέσιμο binary ή app στον κατάλογο της εφαρμογής
  3. Ελέγχει για τον δείκτη .quarantined (αρνείται να εκκινήσει εφαρμογές σε καραντίνα)
  4. Έλεγχος ανάκλησης (μόνο για εφαρμογές που διανέμονται από τη NeboAI)
  5. Επαλήθευση υπογραφής (μόνο για εφαρμογές που διανέμονται από τη NeboAI, παραλείπεται στην ανάπτυξη)
  6. Επικύρωση εκτελέσιμου (απορρίπτει συμβολικούς συνδέσμους, σενάρια, μη εκτελέσιμα, υπερμεγέθη αρχεία)
  7. Καθαρίζει το παλιό socket από την προηγούμενη εκτέλεση
  8. Δημιουργεί τον κατάλογο data/ για αποθήκευση σε sandbox
  9. Ρυθμίζει αρχεία καταγραφής ανά εφαρμογή (logs/stdout.log, logs/stderr.log)
  10. Εκκινεί το εκτελέσιμο με καθαρισμένο περιβάλλον και απομόνωση ομάδας διεργασιών
  11. Περιμένει να εμφανιστεί το Unix socket (εκθετική αναμονή, έως 10 δευτερόλεπτα)
  12. Συνδέεται μέσω gRPC πάνω από το Unix socket
  13. Δημιουργεί πελάτες gRPC ανά δυνατότητα με βάση το provides
  14. Εκτελεί έλεγχο υγείας
  15. Καταχωρίζει τις δυνατότητες στον υπάλληλο ΤΝ (εργαλεία, πύλη, comm κ.λπ.)

Εφαρμογές εργαλείων

Δηλώστε "provides": ["tool:my_tool_name"] στο manifest σας.

Το μοτίβο STRAP

Όλες οι εφαρμογές εργαλείων του Nebo πρέπει να χρησιμοποιούν το STRAP (Single Tool Resource Action Pattern) για το σχήμα τους και τη δρομολόγηση της εκτέλεσης. Είναι το ίδιο μοτίβο που χρησιμοποιεί εσωτερικά το Nebo για να ενοποιήσει πάνω από 35 μεμονωμένα εργαλεία σε 4 εργαλεία τομέα — μειώνοντας την επιβάρυνση του πλαισίου του LLM κατά ~80%.

Βασική ιδέα: Αντί να καταχωρίζετε πολλά εργαλεία (get_events, check_availability, suggest_slots), καταχωρίστε ΕΝΑ εργαλείο με πεδία action (και προαιρετικά resource) που δρομολογούν στον σωστό χειριστή.

Παράδειγμα με έναν πόρο (ημερολόγιο):

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

Παράδειγμα με πολλούς πόρους (διαχείριση έργων):

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

Κανόνες σχήματος:

  1. Συμπεριλαμβάνετε πάντα ένα πεδίο action ως υποχρεωτικό enum συμβολοσειράς
  2. Προσθέστε ένα πεδίο resource (υποχρεωτικό enum συμβολοσειράς) μόνο αν το εργαλείο σας διαχειρίζεται πολλούς διαφορετικούς τύπους πόρων
  3. Όλα τα άλλα πεδία είναι παράμετροι ειδικές για κάθε ενέργεια
  4. Η περιγραφή του enum action πρέπει να απαριθμεί όλες τις διαθέσιμες ενέργειες

Γιατί έχει σημασία το STRAP:

  • Τα LLM μαθαίνουν το μοτίβο δρομολόγησης action μία φορά και το γενικεύουν σε όλες τις λειτουργίες
  • Οι ορισμοί εργαλείων καταναλώνουν ~6% του πλαισίου — το STRAP το μειώνει κατά 80%
  • Οι νέες λειτουργίες είναι απλώς προσθήκες στο enum, όχι νέες καταχωρίσεις εργαλείων
  • Λειτουργεί πανομοιότυπα σε φιλοξενούμενα και τοπικά μοντέλα

Παράδειγμα σε Go — Εργαλείο αριθμομηχανής

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

Μεταγλώττιση και εγκατάσταση:

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

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

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

Εφαρμογές καναλιών

Δηλώστε "provides": ["channel:my_channel"] και "permissions": ["channel:send"].

Οι εφαρμογές καναλιών γεφυρώνουν εξωτερικές πλατφόρμες μηνυμάτων (Telegram, Discord, Slack κ.λπ.) με τον υπάλληλο ΤΝ του Nebo. Όταν ένας χρήστης στέλνει μήνυμα στην εξωτερική πλατφόρμα, η εφαρμογή σας το μεταδίδει στο Nebo μέσω του Receive. Όταν ο υπάλληλος ΤΝ θέλει να απαντήσει, το Nebo καλεί το Send της εφαρμογής σας.

Πώς λειτουργεί

  1. Το Nebo καλεί το ID() για να πάρει το μοναδικό αναγνωριστικό του καναλιού σας
  2. Το Nebo καλεί το Connect() με τη διαμόρφωση από τις ρυθμίσεις της εφαρμογής σας
  3. Το Nebo ανοίγει μια ροή Receive() — η εφαρμογή σας στέλνει εισερχόμενα μηνύματα κάθε φορά που ένας χρήστης στέλνει μήνυμα στο bot
  4. Τα εισερχόμενα μηνύματα δρομολογούνται στην κύρια lane συνομιλίας του υπαλλήλου ΤΝ
  5. Όταν ο υπάλληλος ΤΝ θέλει να στείλει μήνυμα, το Nebo καλεί το Send() με τον φάκελο μηνύματος v1
  6. Κατά τον τερματισμό, το Nebo καλεί το Disconnect()

Φάκελος μηνύματος v1

Όλα τα μηνύματα καναλιών — εισερχόμενα και εξερχόμενα — χρησιμοποιούν τον κοινό φάκελο μηνύματος:

{
  "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"
}
ΠεδίοΤύποςΠεριγραφή
message_idUUID v7Μοναδικό ID ταξινομημένο χρονικά
channel_id{type}:{platform_id}Αναγνωριστικό καναλιού με δυνατότητα δρομολόγησης
senderobjectΤαυτότητα bot — name, role, botId
textstringΣώμα μηνύματος
attachmentsarrayΑρχεία, εικόνες, ήχος
reply_toUUID v7ID γονικού μηνύματος για νήματα
actionsarrayΔιαδραστικά κουμπιά/πληκτρολόγια
platform_databytesΑδιαφανής μεταβίβαση για λειτουργίες ειδικές για την πλατφόρμα
timestampISO 8601Το ορίζει ο εκδότης

Σχεδιασμός δύο επιπέδων: Τα κοινά πεδία (text, attachments, reply_to, actions) καλύπτουν το 90% των μηνυμάτων που ξεκινούν οι υπάλληλοι. Οι λειτουργίες ειδικές για την πλατφόρμα μπαίνουν στο platform_data — το πρόσθετό σας τις αντιστοιχίζει από/προς την εγγενή μορφή της πλατφόρμας.

Ροές συνομιλίας

Τα μηνύματα καναλιών δρομολογούνται μέσω ροών συνομιλίας ανά κανάλι για απομόνωση:

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

Παράδειγμα σε Go — Κανάλι 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
        }
    ]
}

Περισσότερες δυνατότητες

Εφαρμογή comm

Δηλώστε "provides": ["comm"] και "permissions": ["comm:*"]. Οι εφαρμογές comm επιτρέπουν την επικοινωνία μεταξύ υπαλλήλων ΤΝ.

ΠεδίοΠεριγραφή
fromID υπαλλήλου αποστολέα
toID υπαλλήλου παραλήπτη
topicΘέμα/κανάλι μηνύματος
type"message", "mention", "proposal", "command", "info", "task"
contentΣώμα μηνύματος

Βασικές συμπεριφορές:

  • Το Register ανακοινώνει αυτόν τον υπάλληλο ΤΝ στο δίκτυο μαζί με τις δυνατότητές του
  • Τα Subscribe/Unsubscribe διαχειρίζονται τις συνδρομές σε θέματα
  • Το Receive μεταδίδει εισερχόμενα μηνύματα (ροή από τον διακομιστή, όπως στα κανάλια)
  • Μόνο μία εφαρμογή comm μπορεί να είναι ενεργή κάθε φορά

Εφαρμογή πύλης

Μια εφαρμογή πύλης δρομολογεί αιτήματα LLM σε μοντέλα. Δηλώστε "provides": ["gateway"] και "permissions": ["network:outbound", "user:token"].

Το GatewayRequest περιέχει μηνύματα, εργαλεία, system prompt, μέγιστο αριθμό tokens, θερμοκρασία και ένα UserContext (token JWT αν έχει δοθεί το δικαίωμα user:token).

Τύποι GatewayEvent:

ΤύποςΠεριεχόμενοΠεριγραφή
"text"Τμήμα κειμένουToken κειμένου σε ροή
"tool_call"JSONΤο μοντέλο θέλει να καλέσει ένα εργαλείο
"thinking"Τμήμα κειμένουΕκτεταμένη σκέψη/συλλογισμός
"error"Μήνυμα σφάλματοςΚάτι πήγε στραβά
"done"ΚενόΗ ροή ολοκληρώθηκε

Εφαρμογή UI

Μια εφαρμογή UI παρέχει μια προσαρμοσμένη διεπαφή διαμόρφωσης που ανοίγει στο ενσωματωμένο παράθυρο προγράμματος περιήγησης του Nebo. Δηλώστε "provides": ["ui"]. Σε αντίθεση με την αυτόματη φόρμα ρυθμίσεων (την οποία αποδίδει το Nebo από το settings του manifest σας), μια εφαρμογή UI σερβίρει το δικό της πλήρες frontend σε HTML/CSS/JS.

Η εφαρμογή σας περιλαμβάνει έναν κατάλογο ui/ με στατικά web assets (HTML, CSS, JS — συνήθως ένα SPA με index.html). Το Nebo σερβίρει αυτά τα αρχεία απευθείας και προωθεί τις κλήσεις API στην εφαρμογή σας μέσω gRPC.

ΔιαδρομήΜηχανισμόςΣκοπός
GET /api/v1/apps/{id}/ui/*Διακομιστής στατικών αρχείωνΣερβίρει αρχεία από τον κατάλογο ui/ σας (εναλλακτική SPA στο index.html)
ANY /api/v1/apps/{id}/api/*Διακομιστής μεσολάβησης gRPCΠροωθεί αιτήματα HTTP στο UIService.HandleRequest() της εφαρμογής σας

Το SDK περιβάλλει ένα τυπικό net/http.ServeMux, ώστε να γράφετε κανονικούς χειριστές HTTP σε Go — το SDK χειρίζεται αυτόματα τη γεφύρωση gRPC.

Παράδειγμα σε Go — 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 σας θα έκανε κλήσεις fetch στο /api/v1/apps/com.example.dashboard/api/status, οι οποίες προωθούνται στον χειριστή mux σας.

Εφαρμογή χρονοδιαγράμματος

Μια εφαρμογή χρονοδιαγράμματος αντικαθιστά τον ενσωματωμένο χρονοπρογραμματιστή cron του Nebo. Δηλώστε "provides": ["schedule"] και "permissions": ["schedule:create"].

Όταν εκκινείται η εφαρμογή χρονοδιαγράμματός σας, το Nebo δρομολογεί όλο τον προγραμματισμό μέσω της εφαρμογής σας αντί για την προεπιλεγμένη μηχανή cron. Αν η εφαρμογή σας καταρρεύσει, το Nebo επιστρέφει αυτόματα στην ενσωματωμένη μηχανή.

  • Η εφαρμογή σας κατέχει την κατάσταση των χρονοδιαγραμμάτων — το Nebo δεν αποθηκεύει χρονοδιαγράμματα στη δική του βάση δεδομένων όταν είναι ενεργή μια εφαρμογή χρονοδιαγράμματος
  • Τυπικό CRUD: Create, Get, List, Update, Delete, Enable, Disable
  • Το Triggers είναι ένα RPC ροής από τον διακομιστή — η εφαρμογή σας στέλνει ένα μήνυμα ενεργοποίησης κάθε φορά που ενεργοποιείται ένα χρονοδιάγραμμα
  • Μόνο μία εφαρμογή χρονοδιαγράμματος μπορεί να είναι ενεργή κάθε φορά

Εφαρμογές πολλαπλών δυνατοτήτων

Μια εφαρμογή μπορεί να παρέχει πολλές δυνατότητες. Για παράδειγμα, μια εφαρμογή πίνακα ελέγχου με εργαλείο και UI μαζί:

{
    "id": "com.example.dashboard",
    "name": "Dashboard",
    "version": "1.0.0",
    "provides": ["tool:dashboard_query", "ui"],
    "permissions": ["network:outbound"]
}
app, _ := nebo.New()
app.RegisterTool(&dashboardTool{})
app.RegisterUI(&dashboardUI{})
log.Fatal(app.Run())

Πακετάρισμα

Μορφή .napp

Για διανομή μέσω της NeboAI, πακετάρετε την εφαρμογή σας ως αρχείο .napp (ένα αρχείο tar.gz):

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

Απαιτούμενα αρχεία:

ΑρχείοΜέγιστο μέγεθοςΠεριγραφή
manifest.json1 MBΜεταδεδομένα εφαρμογής
binary ή app500 MBΕκτελέσιμο
signatures.json1 MBΥπογραφές Ed25519
TOOL.md1 MBΟδηγίες εργαλείου για τον υπάλληλο ΤΝ

Κανόνες ασφαλείας κατά την αποσυμπίεση:

  • Όχι διάσχιση διαδρομής (το ../ απορρίπτεται)
  • Όχι συμβολικοί σύνδεσμοι (απορρίπτονται)
  • Όχι απόλυτες διαδρομές (απορρίπτονται)
  • Γίνονται δεκτά μόνο εγκεκριμένα ονόματα αρχείων

Υπογραφές

Η NeboAI υπογράφει τις εφαρμογές με Ed25519. Η μορφή του 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>"
}

Σε λειτουργία ανάπτυξης (χωρίς διαμορφωμένο URL της NeboAI), η επαλήθευση υπογραφής παραλείπεται εντελώς. Δεν χρειάζεστε signatures.json για τοπική ανάπτυξη.

Δημοσίευση

Μόλις η εφαρμογή σας λειτουργεί τοπικά, δημοσιεύστε τη μέσω της NeboAI για διανομή σε όλους τους χρήστες του Nebo.

Ρύθμιση λογαριασμού προγραμματιστή

  1. Εγγραφείτε για λογαριασμό NeboAI στο POST /api/v1/owners/register
  2. Συνδεθείτε για να πάρετε token JWT: POST /api/v1/owners/login
  3. Δημιουργήστε λογαριασμό προγραμματιστή: POST /api/v1/developer/accounts

Ροή υποβολής

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

Βήμα 1: Δημιουργήστε την εφαρμογή

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

Βήμα 2: Ανεβάστε τα εκτελέσιμα ανά πλατφόρμα

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"

Ανεβάστε ένα εκτελέσιμο ανά πλατφόρμα: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.

Βήμα 3: Υποβάλετε για έλεγχο

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

Διαδικασία ελέγχου

  1. Αυτόματη σάρωση — τα εκτελέσιμα σαρώνονται μέσω VirusTotal
  2. Έλεγχος από διαχειριστή — η ομάδα της NeboAI ελέγχει τα μεταδεδομένα, το manifest και τα αποτελέσματα της σάρωσης
  3. Με την έγκριση — η NeboAI υπογράφει την εφαρμογή με Ed25519 και τη δημοσιεύει
  4. Με την απόρριψη — λαμβάνετε αιτιολογία και μπορείτε να διορθώσετε και να υποβάλετε ξανά

Στόχος χρόνου ελέγχου: <24 ώρες.

Αποστολή ενημερώσεων

  1. Ενημερώστε την έκδοση της εφαρμογής: PUT /api/v1/developer/apps/{id} με τη νέα έκδοση
  2. Ανεβάστε νέα εκτελέσιμα για κάθε πλατφόρμα
  3. Υποβάλετε ξανά για έλεγχο

Κάθε ενημέρωση περνά από την ίδια διαδικασία ελέγχου. Οι προηγούμενες εκδόσεις παραμένουν διαθέσιμες μέχρι να εγκριθεί η νέα έκδοση.

Μεταδεδομένα καταστήματος

ΠεδίοΠεριγραφή
categoryπ.χ. productivity, communication, developer-tools
iconURL εικονιδίου εφαρμογής
visibilitypublic ή private
descriptionΜπορεί να είναι μεγαλύτερη/πλουσιότερη από την περιγραφή του manifest

Ροή ανάπτυξης

Τοπική ανάπτυξη

Δεν απαιτείται πακετάρισμα για τοπική ανάπτυξη:

  1. Δημιουργήστε τον κατάλογο της εφαρμογής σας:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Γράψτε το manifest.json και τον κώδικά σας
  3. Μεταγλωττίστε το εκτελέσιμό σας:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Το Nebo εντοπίζει αυτόματα τον νέο κατάλογο (ή επανεκκινήστε το Nebo)
  5. Μετά από αλλαγές στον κώδικα, μεταγλωττίστε ξανά το εκτελέσιμο — ο παρατηρητής αρχείων θα επανεκκινήσει την εφαρμογή

Προβολή αρχείων καταγραφής

Τα stdout/stderr της εφαρμογής καταγράφονται σε αρχεία καταγραφής ανά εφαρμογή:

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/ (διαθέσιμο και ως μεταβλητή περιβάλλοντος NEBO_APP_DATA) για όσα αρχεία χρειάζεται να διατηρεί η εφαρμογή σας. Αυτός ο κατάλογος επιβιώνει από ενημερώσεις της εφαρμογής και από την καραντίνα.

Συμβουλές αποσφαλμάτωσης

  • Αν η εφαρμογή σας δεν ξεκινά, ελέγξτε το logs/stderr.log για σφάλματα
  • Βεβαιωθείτε ότι το εκτελέσιμο έχει δικαίωμα εκτέλεσης (chmod +x binary)
  • Βεβαιωθείτε ότι ακούτε στη διαδρομή Unix socket από το NEBO_APP_SOCK
  • Το socket πρέπει να είναι έτοιμο μέσα σε 10 δευτερόλεπτα από την εκκίνηση
  • Χρησιμοποιήστε το NEBO_APP_DATA για αποθήκευση, όχι σταθερές διαδρομές στον κώδικα
  • Γράψτε στο stderr για καταγραφή αποσφαλμάτωσης (καταγράφεται στο logs/stderr.log)

Επαλήθευση

# 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

Απεγκατάσταση

nebo apps uninstall com.example.myapp

Δεξιότητες

Τι είναι οι δεξιότητες

Οι δεξιότητες είναι σύνολα οδηγιών που διαμορφώνουν τη συμπεριφορά του Nebo σε μια συνομιλία. Όταν μια δεξιότητα είναι ενεργή, το περιεχόμενό της εισάγεται απευθείας στο system prompt — καθοδηγώντας τον τόνο, τη μεθοδολογία, την εξειδίκευση και τη χρήση εργαλείων του υπαλλήλου ΤΝ για εκείνη τη συνεδρία.

Οι δεξιότητες δεν είναι κώδικας. Είναι έγγραφα markdown με μεταδεδομένα YAML. Χωρίς μεταγλώττιση, χωρίς εκτελέσιμο, χωρίς gRPC. Μια δεξιότητα είναι ένα αρχείο SKILL.md σε έναν κατάλογο. Αυτό είναι όλο.

Οι δεξιότητες είναι συγκυριακές και προσωρινές. Ενεργοποιούνται όταν είναι σχετικές (μέσω αντιστοίχισης εναυσμάτων ή χειροκίνητης φόρτωσης), παραμένουν για λίγους γύρους και λήγουν όταν δεν χρειάζονται πια. Έτσι το πλαίσιο του υπαλλήλου ΤΝ μένει λιτό — στο prompt βρίσκεται μόνο η καθοδήγηση που μετράει αυτή τη στιγμή.

Οι δεξιότητες συμπληρώνουν τις εφαρμογές. Οι εφαρμογές παρέχουν εκτελέσιμες δυνατότητες (εργαλεία, κανάλια, πύλες). Οι δεξιότητες παρέχουν καθοδήγηση ενορχήστρωσης — πώς να χρησιμοποιούνται αποτελεσματικά αυτά τα εργαλεία. Μια εφαρμογή ημερολογίου δίνει στο Nebo τη δυνατότητα να διαβάζει και να γράφει συμβάντα. Μια δεξιότητα «προετοιμασίας συνάντησης» λέει στο Nebo πώς να προετοιμάζεται για συναντήσεις χρησιμοποιώντας μαζί την εφαρμογή ημερολογίου, το email και την αναζήτηση στο web.

Δεξιότητες και εφαρμογές

ΔεξιότητεςΕφαρμογές
ΜορφήMarkdown (SKILL.md)Μεταγλωττισμένο εκτελέσιμο (.napp)
ΕκτέλεσηΕισάγεται στο system promptΔιεργασία σε sandbox μέσω gRPC
ΠαρέχειΚαθοδήγηση συμπεριφοράς, μεθοδολογίαΕργαλεία, κανάλια, πάνελ UI
Διάρκεια ζωήςΑνά συνεδρία, λήξη βάσει TTLΛειτουργεί πάντα
ΔημιουργίαΓράψτε ένα αρχείο markdownΓράψτε, μεταγλωττίστε, υπογράψτε, πακετάρετε
ΑσφάλειαΔεν χρειάζονται δικαιώματαSandbox με απαγόρευση από προεπιλογή

Γρήγορη εκκίνηση

Δημιουργήστε έναν κατάλογο στον φάκελο δεξιοτήτων του Nebo με ένα αρχείο SKILL.md:

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

Γράψτε ένα 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 παρακολουθεί τον κατάλογο δεξιοτήτων με το fsnotify. Η δεξιότητά σας είναι διαθέσιμη αμέσως — χωρίς επανεκκίνηση. Πείτε κάτι που ταιριάζει με ένα έναυσμα και ενεργοποιείται αυτόματα.

Ή ζητήστε το απευθείας από το Nebo: «Φτιάξε μια δεξιότητα για τη συγγραφή άρθρων ιστολογίου» — το Nebo θα γράψει το αρχείο SKILL.md για εσάς.

Μορφή SKILL.md

Κάθε δεξιότητα είναι ένα μόνο αρχείο SKILL.md με δύο μέρη: frontmatter YAML ανάμεσα σε δείκτες --- και ένα σώμα markdown (τις πραγματικές οδηγίες που εισάγονται στο system prompt).

ΠεδίοΥποχρεωτικόΠροεπιλογήΠεριγραφή
nameΝαι—Μοναδικό αναγνωριστικό (γίνεται το slug)
descriptionΝαι—Περιγραφή μίας γραμμής που εμφανίζεται στον κατάλογο δεξιοτήτων
versionΌχι"1.0.0"Semver για την παρακολούθηση ενημερώσεων
authorΌχι—Δημιουργός της δεξιότητας
priorityΌχι0Υψηλότερο = αντιστοιχίζεται πρώτο (100+ για κρίσιμες παρακάμψεις)
max_turnsΌχι4Γύροι αδράνειας πριν από την αυτόματη λήξη
triggersΌχι[]Φράσεις που ενεργοποιούν αυτόματα αυτή τη δεξιότητα (αντιστοίχιση υποσυμβολοσειράς χωρίς διάκριση πεζών-κεφαλαίων)
toolsΌχι[]Εργαλεία που αναμένει να χρησιμοποιήσει αυτή η δεξιότητα (ενημερωτικά)
dependenciesΌχι[]Άλλες δεξιότητες που πρέπει να είναι εγκατεστημένες
tagsΌχι[]Για κατηγοριοποίηση και εύρεση
platformΌχι[]Υποστηριζόμενες πλατφόρμες: macos, linux, windows (κενό = όλες)

Πώς ενεργοποιούνται οι δεξιότητες

Οι δεξιότητες ακολουθούν ένα μοντέλο ενεργοποίησης δύο φάσεων: υπόδειξη και μετά κλήση.

Φάση 1: Αντιστοίχιση εναυσμάτων — Κάθε φορά που ένας χρήστης στέλνει μήνυμα, το Nebo σαρώνει όλες τις καταχωρισμένες δεξιότητες για αντιστοιχίσεις εναυσμάτων. Οι δεξιότητες που ταιριάζουν εμφανίζονται ως υποδείξεις στο system prompt. Ο υπάλληλος ΤΝ βλέπει την υπόδειξη και αποφασίζει αν θα καλέσει τη δεξιότητα.

Φάση 2: Κλήση — Ο υπάλληλος ΤΝ καλεί μια δεξιότητα καλώντας:

skill(name: "code-review")

Αυτό επιστρέφει ολόκληρο το πρότυπο SKILL.md ως αποτέλεσμα του εργαλείου, καταγράφει την κλήση και επανεισάγει το πρότυπο στο system prompt στους επόμενους γύρους.

TTL και λήξη:

  • Δεξιότητες με αυτόματη αντιστοίχιση: 4 γύροι αδράνειας (ρυθμίζεται μέσω max_turns)
  • Δεξιότητες με χειροκίνητη φόρτωση: 6 γύροι αδράνειας
  • Η εκ νέου κλήση μηδενίζει τον χρονομετρητή
  • Αυστηρό όριο: έως 4 ενεργές δεξιότητες ανά συνεδρία
  • Προϋπολογισμός tokens: το συνολικό περιεχόμενο των ενεργών δεξιοτήτων περιορίζεται στους 16.000 χαρακτήρες

Διαχείριση δεξιοτήτων

Ο υπάλληλος ΤΝ μπορεί να διαχειρίζεται δεξιότητες μέσω του εργαλείου skill:

ΕνέργειαΠεριγραφήΠαράδειγμα
catalogΛίστα όλων των διαθέσιμων δεξιοτήτωνskill(action: "catalog")
loadΕνεργοποίηση για αυτή τη συνεδρίαskill(name: "code-review", action: "load")
unloadΑπενεργοποίηση δεξιότηταςskill(name: "code-review", action: "unload")
createΔημιουργία νέας δεξιότητας στον δίσκοskill(action: "create", content: "...")
updateΕνημέρωση υπάρχουσας δεξιότηταςskill(name: "my-skill", action: "update", content: "...")
deleteΔιαγραφή δεξιότητας από τον δίσκοskill(name: "my-skill", action: "delete")

Πώς να γράφετε καλές δεξιότητες

Ένα καλό πρότυπο δεξιότητας έχει:

  1. Σαφή επικεφαλίδα — λέει στον υπάλληλο ΤΝ σε ποια λειτουργία βρίσκεται
  2. Βασικές αρχές — οι αδιαπραγμάτευτοι κανόνες συμπεριφοράς
  3. Μεθοδολογία — προσέγγιση βήμα προς βήμα για συνηθισμένα σενάρια
  4. Παραδείγματα — συγκεκριμένα μοτίβα μηνύματος χρήστη προς απάντηση
  5. Αντι-μοτίβα — τι ΔΕΝ πρέπει να γίνεται (τα μοντέλα μαθαίνουν καλά από αρνητικά παραδείγματα)

Συμβουλή: Κάθε δεξιότητα πρέπει να κάνει ένα πράγμα καλά. Μην φτιάχνετε μια δεξιότητα «γενικού προγραμματισμού» — φτιάξτε τις code-review, debugging, api-design ως ξεχωριστές δεξιότητες. Ο υπάλληλος ΤΝ μπορεί να έχει πολλές ενεργές ταυτόχρονα.

Ενσωματωμένες δεξιότητες

Το Nebo διατίθεται με ενσωματωμένες δεξιότητες που καλύπτουν συνηθισμένες περιπτώσεις χρήσης:

ΔεξιότηταΠροτεραιότηταΠεριγραφή
onboarding100Υποδοχή νέου χρήστη και συλλογή προφίλ
best-friend50Δεξιότητα προσωπικότητας — χαλαρή, πιστή, ειλικρινής κουβέντα
debugging25Συστηματική μεθοδολογία αποσφαλμάτωσης
api-design15Βέλτιστες πρακτικές σχεδιασμού RESTful API
code-review10Δομημένος έλεγχος κώδικα με επίπεδα σοβαρότητας
database-expert10Σχεδιασμός βάσεων δεδομένων, ερωτήματα, βελτιστοποίηση
git-workflow10Κλάδοι Git, commits, ροές εργασίας PR
security-audit10Ανάλυση ασφάλειας και εντοπισμός ευπαθειών

Αυτές λειτουργούν ταυτόχρονα ως χρήσιμες προεπιλογές και ως υλοποιήσεις αναφοράς για να δημιουργήσετε τις δικές σας δεξιότητες.

Αναφορά

Αρχεία proto

Τα αρχεία proto βρίσκονται στο proto/apps/v0/. Τα SDK περιλαμβάνουν προπαραγμένο κώδικα, οπότε δεν χρειάζεστε το protoc για την κανονική ανάπτυξη.

ΑρχείοΥπηρεσίαΒασικά RPC
v0/common.proto(μόνο μηνύματα)HealthCheckRequest/Response, SettingsMap, UserContext, Empty
v0/tool.protoToolServiceName, Description, Schema, Execute, RequiresApproval, Configure
v0/channel.protoChannelServiceID, Connect, Disconnect, Send, Receive (stream), Configure
v0/comm.protoCommServiceName, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure
v0/gateway.protoGatewayServiceHealthCheck, Stream (stream), Poll, Cancel, Configure
v0/ui.protoUIServiceHealthCheck, HandleRequest, Configure
v0/schedule.protoScheduleServiceHealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure

Κάθε υπηρεσία περιλαμβάνει τα RPC HealthCheck και Configure. Το SDK τα χειρίζεται και τα δύο αυτόματα.

Τύποι proto καναλιών

Τύπος μηνύματοςΠεριγραφή
ChannelSendRequestΦάκελος εξερχόμενου μηνύματος με message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponseID μηνύματος πλατφόρμας για νήματα
InboundMessageΦάκελος εισερχόμενου μηνύματος με όλα τα κοινά πεδία + timestamp
MessageSenderΤαυτότητα bot (name, role, botId) — εμπλουτίζεται από τον μεσολαβητή
AttachmentΣυνημμένο αρχείο/εικόνα/ήχος (type, url, filename, size)
MessageActionΔιαδραστική ενέργεια κουμπιού/πληκτρολογίου (label, callback_id)

Ταυτότητα και ρόλοι bot

Τα bot του Nebo έχουν ένα μοντέλο ταυτότητας τριών αξόνων:

  • creature — Τι είναι το bot (αρχέτυπο): «Ετοιμόλογος στρατηγός», «Σχολαστικός ερευνητής»
  • role — Πώς σχετίζεται με τον χρήστη (σχέση): «Φίλος», «COO», «Μέντορας»
  • vibe — Η ενέργειά του (στυλ επικοινωνίας): «Χαλαρός αλλά με άποψη», «Ζεστός και ενθαρρυντικός»

Όταν το πρόσθετο καναλιού σας λαμβάνει ένα εξερχόμενο μήνυμα, το πεδίο sender περιέχει το name και το role του bot. Χρησιμοποιήστε τα για να μορφοποιήσετε το εμφανιζόμενο όνομα για την πλατφόρμα σας. Ο ρόλος δεν είναι τίτλος θέσης — είναι περιγραφή σχέσης. Τα «Φίλος», «Γιος» και «Μέντορας» είναι έγκυροι ρόλοι μαζί με τα «COO» και «DevLead».