NeboAI
NeboAI
ప్రారంభించండి

Nebo కోసం యాప్‌లు నిర్మించండి

మీ AIకి కొత్త సూపర్ పవర్‌లు ఇవ్వండి. టూల్స్, ఛానెల్‌లు, గేట్‌వేలు, UI ప్యానెల్‌లు — మీరు ఊహించగలిగే ఏదైనా, నేటివ్ బైనరీగా కంపైల్ చేసి.

అవలోకనం

Nebo అంటే ఏమిటి

Nebo ఒక వ్యక్తిగత డెస్క్‌టాప్ AI అసిస్టెంట్ — మీ డిజిటల్ జీవితాన్ని నిర్వహించే, ఎల్లప్పుడూ నడుస్తూ ఉండే AI ఉద్యోగి. స్మార్ట్‌ఫోన్ గురించి ఆలోచించినట్లే Nebo గురించి ఆలోచించండి: దాని యాప్‌ల ద్వారా పూర్తిగా మార్పు తెచ్చే శక్తివంతమైన ప్లాట్‌ఫామ్.

సొంతంగా, Nebo జ్ఞాపకం, షెడ్యూలింగ్, వెబ్ బ్రౌజింగ్, ఫైల్ నిర్వహణ, షెల్ యాక్సెస్ ఉన్న సమర్థుడైన AI ఉద్యోగి. కానీ అసలు శక్తి యాప్‌లలో ఉంది. స్మార్ట్‌ఫోన్ శక్తి దాని యాప్ వ్యవస్థ నుండి వచ్చినట్లే, Nebo శక్తి అది చేయగలిగేదాన్ని విస్తరించే యాప్‌ల నుండి వస్తుంది.

యాప్‌లు అంటే ఏమిటి

Nebo యాప్‌లు స్వయంసంపూర్ణమైన, ముందే కంపైల్ చేసిన అద్భుతమైన కార్యాచరణ యూనిట్‌లు. ప్రతి యాప్ Neboకి ఒక కొత్త సూపర్ పవర్ ఇస్తుంది — క్యాలెండర్ నిర్వహణ, ఇమెయిల్ వర్గీకరణ, ప్రాజెక్ట్ ట్రాకింగ్, హోమ్ ఆటోమేషన్, ఆర్థిక విశ్లేషణ — డెవలపర్ ఊహించగలిగే ఏదైనా.

యాప్‌లు చాలా సురక్షితమైన పద్ధతిలో అద్భుతమైన శక్తిని అందిస్తాయి. ప్రతి యాప్ డిఫాల్ట్‌గా అన్నీ నిరాకరించే అనుమతులతో ఒక శాండ్‌బాక్స్‌లో నడుస్తుంది. దాని మ్యానిఫెస్ట్ ప్రకటించినవి, వినియోగదారు ఆమోదించినవి మాత్రమే అది యాక్సెస్ చేయగలదు.

ఇంటర్‌ఫేస్ 100% సంభాషణాత్మకం. వినియోగదారులు వేర్వేరు స్క్రీన్‌లు లేదా డ్యాష్‌బోర్డ్‌ల ద్వారా యాప్‌లతో పని చేయరు. వారు Neboతో మాట్లాడతారు, Nebo పనులు పూర్తి చేయడానికి యాప్ టూల్స్‌ను ఉపయోగిస్తుంది. "రేపు నా క్యాలెండర్‌లో ఏముంది?" — Nebo క్యాలెండర్ యాప్‌ను పిలుస్తుంది. "Sarahతో మధ్యాహ్నం 3 గంటలకు మీటింగ్ సృష్టించు" — Nebo క్యాలెండర్ యాప్‌ను పిలుస్తుంది. వినియోగదారు సంభాషణను ఎప్పుడూ వదలరు.

యాప్‌లు ఐచ్ఛికంగా సెట్టింగ్‌ల UIని అందించవచ్చు — Nebo అంతర్నిర్మిత బ్రౌజర్ విండోలో తెరుచుకునే కాన్ఫిగరేషన్ ప్యానెల్. వినియోగదారులు API కీలను నమోదు చేసేది, ఫీచర్‌లను ఆన్/ఆఫ్ చేసేది, యాప్‌ను కాన్ఫిగర్ చేసేది ఇక్కడే. సెట్టింగ్‌ల UI మ్యానిఫెస్ట్‌లోని settings అర్రే ఆధారంగా నడుస్తుంది (Nebo ఫారమ్‌ను ఆటోమేటిక్‌గా చూపిస్తుంది), లేదా యాప్ ui సామర్థ్యం ద్వారా తన సొంత పూర్తి కస్టమ్ UIని అందించవచ్చు.

యాప్‌లు Nebo అంతర్నిర్మిత సామర్థ్యాలను భర్తీ చేసి విస్తరిస్తాయి. Nebo ప్రాథమిక ప్లాట్‌ఫామ్ టూల్స్‌తో వస్తుంది (లోకల్ క్యాలెండర్ యాక్సెస్, స్క్రీన్‌షాట్‌లు మొదలైనవి). మీరు క్యాలెండర్ యాప్‌ను ఇన్‌స్టాల్ చేసినప్పుడు, అది అంతర్నిర్మిత క్యాలెండర్ టూల్‌ను భర్తీ చేసి దానికంటే విస్తృతమైనదిగా మారుతుంది — లోకల్ + క్లౌడ్ + సమీకరణ + లభ్యత తనిఖీ.

కంపైల్ చేసినవి మాత్రమే విధానం

Nebo కఠినమైన కంపైల్-మాత్రమే బైనరీ విధానాన్ని అమలు చేస్తుంది. అన్ని యాప్‌లు నేటివ్ కంపైల్ చేసిన ఎగ్జిక్యూటబుల్స్ అయి ఉండాలి.

స్థితిభాషలు
మద్దతు ఉందిGo (సిఫార్సు చేయబడింది), Rust, C/C++, Zig
తిరస్కరించబడిందిPython, Node.js, Ruby, Java, .NET, షెల్ స్క్రిప్ట్‌లు

కారణం:

  • AI స్వీయ-మార్పు నివారణ — షెల్ యాక్సెస్ ఉన్న AI ఉద్యోగి రన్‌టైమ్‌లో ఇంటర్‌ప్రెటెడ్ స్క్రిప్ట్ ప్రవర్తనను మార్చగలరు. కంపైల్ చేసిన బైనరీలు సంతకం చేసిన తర్వాత మార్చలేనివి.
  • సంతకం సమగ్రత — Ed25519 సంతకాలు ముడి బైనరీ బైట్‌లను కవర్ చేస్తాయి. సంతకం చేసిన బైనరీని సంతకాన్ని చెల్లకుండా చేయకుండా మార్చలేరు.
  • శాండ్‌బాక్స్ అమలు — బైనరీ ఫార్మాట్ ధృవీకరణ (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/

యాప్ డైరెక్టరీ నిర్మాణం

యాప్‌లు మీ Nebo డేటా డైరెక్టరీలోని apps/ సబ్‌డైరెక్టరీలో ఉంటాయి:

~/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. id, name, version, providesతో manifest.jsonను సృష్టించండి
  2. AI ఉద్యోగి మీ టూల్‌ను ఎలా ఉపయోగించాలో వివరించే 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మనుషులు చదవగలిగే పేరు
versionSemver స్ట్రింగ్
providesకనీసం ఒక సామర్థ్యం (కింద చూడండి)

ఐచ్ఛిక ఫీల్డ్‌లు:

ఫీల్డ్డిఫాల్ట్వివరణ
runtime"local""local" లేదా "remote"
protocol"grpc""grpc"కి మాత్రమే మద్దతు ఉంది
permissions[]యాప్‌కు ఏ యాక్సెస్ అవసరం
description""UIలో చూపబడుతుంది
settings[]కాన్ఫిగర్ చేయగల సెట్టింగ్‌లు (సెట్టింగ్‌ల UIలో చూపబడతాయి)
oauth[]OAuth ప్రొవైడర్ అవసరాలు (కింద OAuth విభాగం చూడండి)

సామర్థ్యాలు

మీ యాప్ ఏమి అందిస్తుందో ప్రకటించండి:

సామర్థ్యంgRPC సేవవివరణ
gatewayGatewayServiceLLM మోడల్ రూటింగ్
tool:<name>ToolServiceAI ఉద్యోగి కోసం పేరున్న టూల్
channel:<name>ChannelServiceమెసేజింగ్ ఛానెల్
commCommServiceAI ఉద్యోగుల మధ్య కమ్యూనికేషన్
uiUIServiceHTTP ప్రాక్సీతో కస్టమ్ UI
scheduleScheduleServiceకస్టమ్ షెడ్యూలింగ్
visionToolServiceవిజన్ ప్రాసెసింగ్
browserToolServiceబ్రౌజర్ ఆటోమేషన్

ఒక యాప్ అనేక సామర్థ్యాలను అందించవచ్చు. ఉదాహరణకు, ఒక యాప్ టూల్, UI ప్యానెల్ రెండింటినీ అందించవచ్చు.

అనుమతులు

యాప్ ఏమి యాక్సెస్ చేయగలదో అనుమతులు నియంత్రిస్తాయి. డిఫాల్ట్‌గా నిరాకరణ — ప్రకటించకపోతే, యాప్ దాన్ని ఉపయోగించలేదు.

ప్రిఫిక్స్ఉదాహరణలువివరణ
network:network:outbound, network:*నెట్‌వర్క్ యాక్సెస్
filesystem:filesystem:read, filesystem:writeఫైల్ సిస్టమ్ యాక్సెస్
memory:memory:read, memory:writeAI ఉద్యోగి జ్ఞాపకం యాక్సెస్
session:session:readసంభాషణ సెషన్‌లు
tool:tool:shell, tool:fileఇతర టూల్స్‌ను ఉపయోగించడం
shell:shell:execషెల్ కమాండ్ ఎగ్జిక్యూషన్
channel:channel:send, channel:*ఛానెల్ ఆపరేషన్‌లు
comm:comm:send, comm:*AI ఉద్యోగుల మధ్య కమ్యూనికేషన్
model:model:chatAI మోడల్ యాక్సెస్
user:user:tokenఅభ్యర్థనల్లో వినియోగదారు JWTని అందుకోవడం
schedule:schedule:createక్రాన్ జాబ్ నిర్వహణ
database:database:queryడేటాబేస్ యాక్సెస్
storage:storage:read, storage:writeశాశ్వత స్టోరేజ్
context:context:readAI ఉద్యోగి సందర్భం యాక్సెస్
subagent:subagent:spawnసబ్-ఏజెంట్ ఆపరేషన్‌లు
lane:lane:enqueueలేన్ ఆపరేషన్‌లు
notification:notification:sendపుష్ నోటిఫికేషన్‌లు
embedding:embedding:searchవెక్టర్ ఎంబెడింగ్ యాక్సెస్
skill:skill:invokeనైపుణ్యాన్ని పిలవడం
advisor:advisor:consultఅడ్వైజర్ సిస్టమ్ యాక్సెస్
mcp:mcp:connectMCP సర్వర్ యాక్సెస్
voice:voice:recordవాయిస్/ఆడియో యాక్సెస్
browser:browser:navigateబ్రౌజర్ ఆటోమేషన్
oauth:oauth:google, oauth:*OAuth టోకెన్ యాక్సెస్
settings:settings:readసెట్టింగ్‌ల యాక్సెస్
capability:capability:registerసామర్థ్య రిజిస్ట్రేషన్

వైల్డ్‌కార్డ్ అనుమతులకు మద్దతు ఉంది: network:* ఏ network: అనుమతి తనిఖీకైనా సరిపోలుతుంది.

సెట్టింగ్‌లు

సెట్టింగ్‌లు Nebo UIలో యాప్ సెట్టింగ్‌ల ప్యానెల్ కింద కనిపిస్తాయి. Nebo వాటిని డేటాబేస్‌లో నిల్వ చేసి, అవి మారినప్పుడు Configure RPC ద్వారా మీ యాప్‌కు పంపుతుంది.

మీ సెట్టింగ్‌ల స్కీమా 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 ప్రొవైడర్ అవసరాలను ప్రకటించవచ్చు. Nebo OAuth బ్రోకర్ మొత్తం ఫ్లోను చూసుకుంటుంది — యాప్‌లు Configure RPC ద్వారా టోకెన్‌లను ఆటోమేటిక్‌గా అందుకుంటాయి.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
ఫీల్డ్వివరణ
providerOAuth ప్రొవైడర్: "google", "microsoft", "github"
scopesయాప్‌కు అవసరమైన OAuth స్కోప్‌ల అర్రే

వినియోగదారు యాప్‌ను ఇన్‌స్టాల్ చేసినప్పుడు, అవసరమైన OAuth స్కోప్‌లను అధీకృతం చేయమని Nebo వారిని అడుగుతుంది. యాప్ OAuth ఫ్లోను తానే నిర్వహించకుండా Configure RPC ద్వారా రిఫ్రెష్ చేసిన టోకెన్‌లను అందుకుంటుంది.

ఎన్విరాన్‌మెంట్ వేరియబుల్స్

మీ యాప్ ప్రాసెస్ శుద్ధి చేసిన ఎన్విరాన్‌మెంట్‌ను అందుకుంటుంది. అన్ని రహస్యాలు తొలగించబడతాయి. మీకు లభించేవి:

వేరియబుల్విలువ
NEBO_APP_DIRయాప్ ఇన్‌స్టాలేషన్ డైరెక్టరీ
NEBO_APP_SOCKసృష్టించాల్సిన Unix సాకెట్ పాత్
NEBO_APP_IDమ్యానిఫెస్ట్ నుండి యాప్ ID
NEBO_APP_NAMEమ్యానిఫెస్ట్ నుండి యాప్ పేరు
NEBO_APP_VERSIONమ్యానిఫెస్ట్ నుండి యాప్ వెర్షన్
NEBO_APP_DATAయాప్ data/ డైరెక్టరీ పాత్
PATHసిస్టమ్ PATH (అలాగే పంపబడుతుంది)
HOMEవినియోగదారు హోమ్ డైరెక్టరీ (అలాగే పంపబడుతుంది)
TMPDIRటెంప్ డైరెక్టరీ (అలాగే పంపబడుతుంది)

చాలా ముఖ్యం: మీ బైనరీ NEBO_APP_SOCK వద్ద ఉన్న Unix సాకెట్‌పై వినే gRPC సర్వర్‌ను సృష్టించాలి. ఈ సాకెట్ కనిపించడం కోసం Nebo గరిష్ఠంగా 10 సెకన్లు వేచి ఉంటుంది.

యాప్ లాంచ్ క్రమం

  1. Nebo manifest.jsonను చదివి దాన్ని ధృవీకరిస్తుంది
  2. యాప్ డైరెక్టరీలో binary లేదా app ఎగ్జిక్యూటబుల్‌ను కనుగొంటుంది
  3. .quarantined మార్కర్ కోసం తనిఖీ చేస్తుంది (క్వారంటైన్ చేసిన యాప్‌లను లాంచ్ చేయడానికి నిరాకరిస్తుంది)
  4. రద్దు తనిఖీ (NeboAI పంపిణీ చేసిన యాప్‌లకు మాత్రమే)
  5. సంతకం ధృవీకరణ (NeboAI పంపిణీ చేసిన యాప్‌లకు మాత్రమే, dev‌లో దాటవేయబడుతుంది)
  6. బైనరీ ధృవీకరణ (సింలింక్‌లు, స్క్రిప్ట్‌లు, ఎగ్జిక్యూటబుల్ కానివి, పరిమితి మించిన ఫైల్‌లను తిరస్కరిస్తుంది)
  7. మునుపటి రన్ నుండి మిగిలిన పాత సాకెట్‌ను శుభ్రం చేస్తుంది
  8. శాండ్‌బాక్స్ స్టోరేజ్ కోసం data/ డైరెక్టరీని సృష్టిస్తుంది
  9. ప్రతి యాప్‌కు లాగ్ ఫైల్‌లను సెటప్ చేస్తుంది (logs/stdout.log, logs/stderr.log)
  10. శుద్ధి చేసిన ఎన్విరాన్‌మెంట్, ప్రాసెస్ గ్రూప్ ఐసోలేషన్‌తో బైనరీని ప్రారంభిస్తుంది
  11. Unix సాకెట్ కనిపించే వరకు వేచి ఉంటుంది (ఎక్స్‌పోనెన్షియల్ బ్యాక్‌ఆఫ్, గరిష్ఠంగా 10 సెకన్లు)
  12. Unix సాకెట్‌పై gRPC ద్వారా కనెక్ట్ అవుతుంది
  13. provides ఆధారంగా సామర్థ్య-నిర్దిష్ట gRPC క్లయింట్‌లను సృష్టిస్తుంది
  14. హెల్త్ చెక్ నడుపుతుంది
  15. AI ఉద్యోగితో సామర్థ్యాలను రిజిస్టర్ చేస్తుంది (టూల్స్, గేట్‌వే, comm మొదలైనవి)

టూల్ యాప్‌లు

మీ మ్యానిఫెస్ట్‌లో "provides": ["tool:my_tool_name"] అని ప్రకటించండి.

STRAP నమూనా

అన్ని Nebo టూల్ యాప్‌లు తమ స్కీమా, ఎగ్జిక్యూషన్ రూటింగ్ కోసం STRAP (Single Tool Resource Action Pattern)ను తప్పనిసరిగా ఉపయోగించాలి. 35+ వ్యక్తిగత టూల్స్‌ను 4 డొమైన్ టూల్స్‌గా ఏకీకృతం చేయడానికి Nebo అంతర్గతంగా ఉపయోగించే నమూనా ఇదే — 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. తప్పనిసరి స్ట్రింగ్ enumగా ఎల్లప్పుడూ ఒక action ఫీల్డ్‌ను చేర్చండి
  2. మీ టూల్ అనేక విభిన్న రిసోర్స్ రకాలను నిర్వహిస్తే మాత్రమే resource ఫీల్డ్‌ను (తప్పనిసరి స్ట్రింగ్ enum) జోడించండి
  3. మిగతా అన్ని ఫీల్డ్‌లు చర్య-నిర్దిష్ట పారామీటర్‌లు
  4. action enum వివరణ అందుబాటులో ఉన్న అన్ని చర్యలను జాబితా చేయాలి

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 AI ఉద్యోగితో కలుపుతాయి. వినియోగదారు బాహ్య ప్లాట్‌ఫామ్‌లో మెసేజ్ పంపినప్పుడు, మీ యాప్ దాన్ని Receive ద్వారా Neboకి స్ట్రీమ్ చేస్తుంది. AI ఉద్యోగి జవాబు ఇవ్వాలనుకున్నప్పుడు, Nebo మీ యాప్ Sendను పిలుస్తుంది.

ఇది ఎలా పని చేస్తుంది

  1. మీ ఛానెల్ ప్రత్యేక ఐడెంటిఫైయర్‌ను పొందడానికి Nebo ID()ని పిలుస్తుంది
  2. మీ యాప్ సెట్టింగ్‌ల నుండి కాన్ఫిగ్‌తో Nebo Connect()ని పిలుస్తుంది
  3. Nebo ఒక Receive() స్ట్రీమ్‌ను తెరుస్తుంది — వినియోగదారు బాట్‌కు మెసేజ్ చేసినప్పుడల్లా మీ యాప్ ఇన్‌బౌండ్ మెసేజ్‌లను పంపుతుంది
  4. ఇన్‌బౌండ్ మెసేజ్‌లు AI ఉద్యోగి ప్రధాన సంభాషణ లేన్‌కు మళ్ళించబడతాయి
  5. AI ఉద్యోగి మెసేజ్ పంపాలనుకున్నప్పుడు, Nebo v1 మెసేజ్ ఎన్వలప్‌తో Send()ని పిలుస్తుంది
  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బాట్ గుర్తింపు — name, role, botId
textstringమెసేజ్ బాడీ
attachmentsarrayఫైల్‌లు, చిత్రాలు, ఆడియో
reply_toUUID v7థ్రెడింగ్ కోసం పేరెంట్ మెసేజ్ ID
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 యాప్‌లు AI ఉద్యోగుల మధ్య కమ్యూనికేషన్‌ను సాధ్యం చేస్తాయి.

ఫీల్డ్వివరణ
fromపంపే ఉద్యోగి ID
toఅందుకునే ఉద్యోగి ID
topicమెసేజ్ అంశం/ఛానెల్
type"message", "mention", "proposal", "command", "info", "task"
contentమెసేజ్ బాడీ

ముఖ్య ప్రవర్తనలు:

  • Register ఈ AI ఉద్యోగిని దాని సామర్థ్యాలతో నెట్‌వర్క్‌లో ప్రకటిస్తుంది
  • Subscribe/Unsubscribe అంశాల సబ్‌స్క్రిప్షన్‌లను నిర్వహిస్తాయి
  • Receive ఇన్‌బౌండ్ మెసేజ్‌లను స్ట్రీమ్ చేస్తుంది (సర్వర్-స్ట్రీమింగ్, ఛానెల్‌ల లాగే)
  • ఒకేసారి ఒక comm యాప్ మాత్రమే యాక్టివ్‌గా ఉండగలదు

గేట్‌వే యాప్

గేట్‌వే యాప్ LLM అభ్యర్థనలను మోడల్‌లకు మళ్ళిస్తుంది. "provides": ["gateway"] మరియు "permissions": ["network:outbound", "user:token"] అని ప్రకటించండి.

GatewayRequestలో మెసేజ్‌లు, టూల్స్, సిస్టమ్ ప్రాంప్ట్, గరిష్ఠ టోకెన్‌లు, టెంపరేచర్, మరియు ఒక UserContext (user:token అనుమతి ఇస్తే JWT టోకెన్) ఉంటాయి.

GatewayEvent రకాలు:

రకంకంటెంట్వివరణ
"text"టెక్స్ట్ భాగంస్ట్రీమింగ్ టెక్స్ట్ టోకెన్
"tool_call"JSONమోడల్ ఒక టూల్‌ను పిలవాలనుకుంటోంది
"thinking"టెక్స్ట్ భాగంవిస్తృత ఆలోచన/తర్కం
"error"ఎర్రర్ మెసేజ్ఏదో తప్పు జరిగింది
"done"ఖాళీస్ట్రీమ్ పూర్తయింది

UI యాప్

UI యాప్ Nebo అంతర్నిర్మిత బ్రౌజర్ విండోలో తెరుచుకునే కస్టమ్ కాన్ఫిగరేషన్ ఇంటర్‌ఫేస్‌ను అందిస్తుంది. "provides": ["ui"] అని ప్రకటించండి. ఆటోమేటిక్ సెట్టింగ్‌ల ఫారమ్‌లా కాకుండా (దాన్ని Nebo మీ settings మ్యానిఫెస్ట్ నుండి చూపిస్తుంది), UI యాప్ తన సొంత పూర్తి HTML/CSS/JS ఫ్రంట్‌ఎండ్‌ను అందిస్తుంది.

మీ యాప్ స్టాటిక్ వెబ్ అసెట్‌లు (HTML, CSS, JS — సాధారణంగా index.htmlతో ఒక SPA) ఉన్న ui/ డైరెక్టరీతో వస్తుంది. 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ను చుడుతుంది కాబట్టి మీరు సాధారణ Go HTTP హ్యాండ్లర్‌లు రాస్తారు — 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 /api/v1/apps/com.example.dashboard/api/statusకి fetch కాల్స్ చేస్తుంది, అవి మీ mux హ్యాండ్లర్‌కు ప్రాక్సీ చేయబడతాయి.

షెడ్యూల్ యాప్

షెడ్యూల్ యాప్ Nebo అంతర్నిర్మిత క్రాన్ షెడ్యూలర్‌ను భర్తీ చేస్తుంది. "provides": ["schedule"] మరియు "permissions": ["schedule:create"] అని ప్రకటించండి.

మీ షెడ్యూల్ యాప్ లాంచ్ అయినప్పుడు, Nebo డిఫాల్ట్ క్రాన్ ఇంజిన్‌కు బదులు అన్ని షెడ్యూలింగ్‌ను మీ యాప్ ద్వారా మళ్ళిస్తుంది. మీ యాప్ క్రాష్ అయితే, Nebo ఆటోమేటిక్‌గా అంతర్నిర్మిత ఇంజిన్‌కు తిరిగి వెళ్తుంది.

  • మీ యాప్ షెడ్యూల్ స్థితికి యజమాని — షెడ్యూల్ యాప్ యాక్టివ్‌గా ఉన్నప్పుడు Nebo షెడ్యూల్‌లను తన సొంత DBలో నిల్వ చేయదు
  • స్టాండర్డ్ 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 MBEd25519 సంతకాలు
TOOL.md1 MBAI ఉద్యోగి కోసం టూల్ సూచనలు

ఎక్స్‌ట్రాక్షన్ సమయంలో భద్రతా నియమాలు:

  • పాత్ ట్రావర్సల్ లేదు (../ తిరస్కరించబడుతుంది)
  • సింలింక్‌లు లేవు (తిరస్కరించబడతాయి)
  • అబ్సొల్యూట్ పాత్‌లు లేవు (తిరస్కరించబడతాయి)
  • అనుమతి జాబితాలోని ఫైల్ పేర్లు మాత్రమే అంగీకరించబడతాయి

సంతకాలు

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

dev మోడ్‌లో (NeboAI URL కాన్ఫిగర్ చేయనప్పుడు), సంతకం ధృవీకరణ పూర్తిగా దాటవేయబడుతుంది. లోకల్ డెవలప్‌మెంట్ కోసం మీకు signatures.json అవసరం లేదు.

ప్రచురణ

మీ యాప్ లోకల్‌గా పని చేసిన తర్వాత, Nebo వినియోగదారులందరికీ పంపిణీ కోసం దాన్ని NeboAI ద్వారా ప్రచురించండి.

డెవలపర్ ఖాతా సెటప్

  1. POST /api/v1/owners/register వద్ద NeboAI ఖాతాను రిజిస్టర్ చేయండి
  2. 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 టీమ్ మెటాడేటా, మ్యానిఫెస్ట్, స్కాన్ ఫలితాలను సమీక్షిస్తుంది
  3. ఆమోదం పొందితే — NeboAI యాప్‌కు Ed25519తో సంతకం చేసి దాన్ని ప్రచురిస్తుంది
  4. తిరస్కరించబడితే — మీకు కారణం తెలియజేయబడుతుంది, సరిచేసి మళ్ళీ సబ్మిట్ చేయవచ్చు

లక్ష్య సమీక్ష సమయం: <24 గంటలు.

అప్‌డేట్‌లను పంపడం

  1. యాప్ వెర్షన్‌ను అప్‌డేట్ చేయండి: కొత్త వెర్షన్‌తో PUT /api/v1/developer/apps/{id}
  2. ప్రతి ప్లాట్‌ఫామ్‌కు కొత్త బైనరీలను అప్‌లోడ్ చేయండి
  3. మళ్ళీ సమీక్ష కోసం సబ్మిట్ చేయండి

ప్రతి అప్‌డేట్ అదే సమీక్ష ప్రక్రియ ద్వారా వెళ్తుంది. కొత్త వెర్షన్ ఆమోదం పొందే వరకు పాత వెర్షన్‌లు అందుబాటులో ఉంటాయి.

స్టోర్ మెటాడేటా

ఫీల్డ్వివరణ
categoryఉదా., productivity, communication, developer-tools
iconయాప్ ఐకాన్ URL
visibilitypublic లేదా private
descriptionమ్యానిఫెస్ట్ వివరణ కంటే పొడవుగా/వివరంగా ఉండవచ్చు

డెవ్ వర్క్‌ఫ్లో

లోకల్ డెవలప్‌మెంట్

లోకల్ డెవలప్‌మెంట్ కోసం ప్యాకేజింగ్ అవసరం లేదు:

  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 env varగా కూడా అందుబాటులో ఉంది) ఉపయోగించండి. ఈ డైరెక్టరీ యాప్ అప్‌డేట్‌లు, క్వారంటైన్ తర్వాత కూడా నిలిచి ఉంటుంది.

డీబగ్గింగ్ చిట్కాలు

  • మీ యాప్ ప్రారంభం కాకపోతే, ఎర్రర్‌ల కోసం logs/stderr.log చూడండి
  • బైనరీ ఎగ్జిక్యూటబుల్‌గా ఉందో లేదో నిర్ధారించుకోండి (chmod +x binary)
  • మీరు NEBO_APP_SOCK నుండి వచ్చే Unix సాకెట్ పాత్‌పై వింటున్నారని నిర్ధారించుకోండి
  • లాంచ్ అయిన 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 ఎలా ప్రవర్తించాలో రూపొందించే సూచనల సమితులు. ఒక నైపుణ్యం యాక్టివ్‌గా ఉన్నప్పుడు, దాని కంటెంట్ నేరుగా సిస్టమ్ ప్రాంప్ట్‌లోకి చొప్పించబడుతుంది — ఆ సెషన్ కోసం AI ఉద్యోగి స్వరం, పద్ధతి, రంగ నైపుణ్యం, టూల్ వినియోగాన్ని మార్గనిర్దేశం చేస్తుంది.

నైపుణ్యాలు కోడ్ కాదు. అవి YAML మెటాడేటాతో ఉన్న markdown పత్రాలు. కంపైలేషన్ లేదు, బైనరీ లేదు, gRPC లేదు. ఒక నైపుణ్యం అంటే ఒక డైరెక్టరీలోని SKILL.md ఫైల్. అంతే.

నైపుణ్యాలు సందర్భోచితమైనవి, తాత్కాలికమైనవి. సంబంధితమైనప్పుడు (ట్రిగ్గర్ సరిపోలిక లేదా మాన్యువల్ లోడ్ ద్వారా) అవి యాక్టివేట్ అవుతాయి, కొన్ని టర్న్‌ల పాటు ఉంటాయి, ఇక అవసరం లేనప్పుడు గడువు ముగుస్తాయి. ఇది AI ఉద్యోగి కాంటెక్స్ట్‌ను తేలికగా ఉంచుతుంది — ప్రస్తుతం ముఖ్యమైన మార్గదర్శకత్వం మాత్రమే ప్రాంప్ట్‌లో ఉంటుంది.

నైపుణ్యాలు యాప్‌లకు పూరకంగా ఉంటాయి. యాప్‌లు ఎగ్జిక్యూట్ చేయగల సామర్థ్యాలను (టూల్స్, ఛానెల్‌లు, గేట్‌వేలు) అందిస్తాయి. నైపుణ్యాలు సమన్వయ మార్గదర్శకత్వాన్ని అందిస్తాయి — ఆ టూల్స్‌ను సమర్థంగా ఎలా ఉపయోగించాలో. క్యాలెండర్ యాప్ Neboకి ఈవెంట్‌లు చదివే, రాసే సామర్థ్యం ఇస్తుంది. "మీటింగ్ సన్నద్ధత" నైపుణ్యం ఆ క్యాలెండర్ యాప్, ఇమెయిల్, వెబ్ శోధనను కలిపి ఉపయోగించి మీటింగ్‌లకు ఎలా సిద్ధం కావాలో Neboకి చెబుతుంది.

నైపుణ్యాలు vs యాప్‌లు

నైపుణ్యాలుయాప్‌లు
ఫార్మాట్Markdown (SKILL.md)కంపైల్ చేసిన బైనరీ (.napp)
రన్‌టైమ్సిస్టమ్ ప్రాంప్ట్‌లోకి చొప్పించబడుతుందిgRPC ద్వారా శాండ్‌బాక్స్‌లో నడిచే ప్రాసెస్
అందిస్తుందిప్రవర్తనా మార్గదర్శకత్వం, పద్ధతిటూల్స్, ఛానెల్‌లు, UI ప్యానెల్‌లు
జీవితకాలంసెషన్ పరిధిలో, TTL ఆధారిత గడువుఎల్లప్పుడూ నడుస్తూ ఉంటుంది
సృష్టిఒక markdown ఫైల్ రాయండిరాయండి, కంపైల్ చేయండి, సంతకం చేయండి, ప్యాకేజ్ చేయండి
భద్రతఅనుమతులు అవసరం లేదుడిఫాల్ట్‌గా నిరాకరించే శాండ్‌బాక్స్

త్వరిత ప్రారంభం

మీ 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 ఫైల్: --- మార్కర్‌ల మధ్య YAML ఫ్రంట్‌మ్యాటర్, మరియు ఒక markdown బాడీ (సిస్టమ్ ప్రాంప్ట్‌లోకి చొప్పించే అసలు సూచనలు).

ఫీల్డ్తప్పనిసరిడిఫాల్ట్వివరణ
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 రిజిస్టర్ చేసిన అన్ని నైపుణ్యాలను ట్రిగ్గర్ సరిపోలికల కోసం స్కాన్ చేస్తుంది. సరిపోయే నైపుణ్యాలు సిస్టమ్ ప్రాంప్ట్‌లో సూచనలుగా కనిపిస్తాయి. AI ఉద్యోగి సూచనను చూసి నైపుణ్యాన్ని పిలవాలో వద్దో నిర్ణయిస్తారు.

దశ 2: పిలుపు — AI ఉద్యోగి ఇలా కాల్ చేయడం ద్వారా నైపుణ్యాన్ని పిలుస్తారు:

skill(name: "code-review")

ఇది పూర్తి SKILL.md టెంప్లేట్‌ను టూల్ ఫలితంగా తిరిగి ఇస్తుంది, పిలుపును నమోదు చేస్తుంది, తర్వాతి టర్న్‌లలో టెంప్లేట్‌ను సిస్టమ్ ప్రాంప్ట్‌లోకి మళ్ళీ చొప్పిస్తుంది.

TTL మరియు గడువు:

  • ఆటోమేటిక్‌గా సరిపోలిన నైపుణ్యాలు: 4 టర్న్‌ల నిష్క్రియత (max_turns ద్వారా మార్చవచ్చు)
  • మాన్యువల్‌గా లోడ్ చేసిన నైపుణ్యాలు: 6 టర్న్‌ల నిష్క్రియత
  • మళ్ళీ పిలిస్తే టైమర్ రీసెట్ అవుతుంది
  • కఠిన పరిమితి: ప్రతి సెషన్‌కు గరిష్ఠంగా 4 యాక్టివ్ నైపుణ్యాలు
  • టోకెన్ బడ్జెట్: యాక్టివ్ నైపుణ్యాల మొత్తం కంటెంట్ 16,000 అక్షరాలకు పరిమితం

నైపుణ్యాలను నిర్వహించడం

AI ఉద్యోగి 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. స్పష్టమైన శీర్షిక — AI ఉద్యోగికి అది ఏ మోడ్‌లో ఉందో చెబుతుంది
  2. ముఖ్య సూత్రాలు — చర్చకు తావులేని ప్రవర్తనా నియమాలు
  3. పద్ధతి — సాధారణ సందర్భాల కోసం దశల వారీ విధానం
  4. ఉదాహరణలు — వినియోగదారు మెసేజ్ నుండి ప్రతిస్పందన వరకు నిర్దిష్ట నమూనాలు
  5. వ్యతిరేక నమూనాలు — ఏమి చేయకూడదో (నెగటివ్ ఉదాహరణల నుండి మోడల్‌లు బాగా నేర్చుకుంటాయి)

చిట్కా: ప్రతి నైపుణ్యం ఒక పనిని బాగా చేయాలి. "సాధారణ ప్రోగ్రామింగ్" నైపుణ్యాన్ని సృష్టించకండి — code-review, debugging, api-designలను వేర్వేరు నైపుణ్యాలుగా సృష్టించండి. AI ఉద్యోగికి ఒకేసారి అనేక యాక్టివ్ నైపుణ్యాలు ఉండవచ్చు.

బండిల్ చేసిన నైపుణ్యాలు

సాధారణ వినియోగ సందర్భాలను కవర్ చేసే బండిల్ చేసిన నైపుణ్యాలతో Nebo వస్తుంది:

నైపుణ్యంప్రాధాన్యతవివరణ
onboarding100కొత్త వినియోగదారుకు స్వాగతం, ప్రొఫైల్ సేకరణ
best-friend50వ్యక్తిత్వ నైపుణ్యం — సాధారణంగా, విశ్వాసంగా, నిజాయితీగా మాట్లాడటం
debugging25క్రమబద్ధమైన డీబగ్గింగ్ పద్ధతి
api-design15RESTful API డిజైన్ ఉత్తమ పద్ధతులు
code-review10తీవ్రత స్థాయిలతో నిర్మాణాత్మక కోడ్ సమీక్ష
database-expert10డేటాబేస్ డిజైన్, క్వెరీలు, ఆప్టిమైజేషన్
git-workflow10Git బ్రాంచింగ్, కమిట్‌లు, 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

ప్రతి సేవలో HealthCheck మరియు Configure RPCలు ఉంటాయి. SDK రెండింటినీ ఆటోమేటిక్‌గా చూసుకుంటుంది.

ఛానెల్ Proto రకాలు

మెసేజ్ రకంవివరణ
ChannelSendRequestmessage_id, channelId, sender, text, attachments, reply_to, actions, platform_dataతో అవుట్‌బౌండ్ మెసేజ్ ఎన్వలప్
ChannelSendResponseథ్రెడింగ్ కోసం ప్లాట్‌ఫామ్ మెసేజ్ ID
InboundMessageఅన్ని ఉమ్మడి ఫీల్డ్‌లు + timestampతో ఇన్‌బౌండ్ మెసేజ్ ఎన్వలప్
MessageSenderబాట్ గుర్తింపు (name, role, botId) — బ్రోకర్ ద్వారా సమృద్ధి చేయబడుతుంది
Attachmentఫైల్/చిత్రం/ఆడియో అటాచ్‌మెంట్ (type, url, filename, size)
MessageActionఇంటరాక్టివ్ బటన్/కీబోర్డ్ చర్య (label, callback_id)

బాట్ గుర్తింపు మరియు పాత్రలు

Nebo బాట్‌లకు మూడు-అక్షాల గుర్తింపు నమూనా ఉంటుంది:

  • creature — బాట్ ఏమిటి (ఆర్కిటైప్): "చురుకైన వ్యూహకర్త", "శ్రద్ధగల పరిశోధకుడు"
  • role — వినియోగదారుతో దానికి ఉన్న సంబంధం: "స్నేహితుడు", "COO", "మార్గదర్శి"
  • vibe — దాని శక్తి (కమ్యూనికేషన్ శైలి): "నిదానంగా కానీ స్పష్టమైన అభిప్రాయాలతో", "ఆత్మీయంగా, ప్రోత్సాహకరంగా"

మీ ఛానెల్ ప్లగిన్ అవుట్‌బౌండ్ మెసేజ్ అందుకున్నప్పుడు, sender ఫీల్డ్‌లో బాట్ name మరియు role ఉంటాయి. మీ ప్లాట్‌ఫామ్ కోసం డిస్‌ప్లే పేరును ఫార్మాట్ చేయడానికి దీన్ని ఉపయోగించండి. రోల్ అనేది ఉద్యోగ హోదా కాదు — అది సంబంధాన్ని వివరిస్తుంది. "COO", "DevLead"లతో పాటు "స్నేహితుడు", "కొడుకు", "మార్గదర్శి" కూడా సరైన రోల్‌లే.