అవలోకనం
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) కనీస యాప్ చెక్లిస్ట్
id,name,version,providesతోmanifest.jsonను సృష్టించండి- AI ఉద్యోగి మీ టూల్ను ఎలా ఉపయోగించాలో వివరించే
TOOL.mdరాయండి - SDKని ఇన్స్టాల్ చేయండి (
go get github.com/neboloop/nebo-sdk-go) - మీ సామర్థ్యం కోసం హ్యాండ్లర్ ఇంటర్ఫేస్ను అమలు చేయండి (
ToolHandler,ChannelHandlerమొదలైనవి) - హ్యాండ్లర్ను రిజిస్టర్ చేసి
app.Run()ని పిలవండి - నేటివ్ బైనరీని బిల్డ్ చేయండి (
go build -o binary .) - బైనరీ + manifest.json + TOOL.mdని
apps/<your-app-id>/డైరెక్టరీలో పెట్టండి - 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 సేవ | వివరణ |
|---|---|---|
gateway | GatewayService | LLM మోడల్ రూటింగ్ |
tool:<name> | ToolService | AI ఉద్యోగి కోసం పేరున్న టూల్ |
channel:<name> | ChannelService | మెసేజింగ్ ఛానెల్ |
comm | CommService | AI ఉద్యోగుల మధ్య కమ్యూనికేషన్ |
ui | UIService | HTTP ప్రాక్సీతో కస్టమ్ UI |
schedule | ScheduleService | కస్టమ్ షెడ్యూలింగ్ |
vision | ToolService | విజన్ ప్రాసెసింగ్ |
browser | ToolService | బ్రౌజర్ ఆటోమేషన్ |
ఒక యాప్ అనేక సామర్థ్యాలను అందించవచ్చు. ఉదాహరణకు, ఒక యాప్ టూల్, UI ప్యానెల్ రెండింటినీ అందించవచ్చు.
అనుమతులు
యాప్ ఏమి యాక్సెస్ చేయగలదో అనుమతులు నియంత్రిస్తాయి. డిఫాల్ట్గా నిరాకరణ — ప్రకటించకపోతే, యాప్ దాన్ని ఉపయోగించలేదు.
| ప్రిఫిక్స్ | ఉదాహరణలు | వివరణ |
|---|---|---|
network: | network:outbound, network:* | నెట్వర్క్ యాక్సెస్ |
filesystem: | filesystem:read, filesystem:write | ఫైల్ సిస్టమ్ యాక్సెస్ |
memory: | memory:read, memory:write | AI ఉద్యోగి జ్ఞాపకం యాక్సెస్ |
session: | session:read | సంభాషణ సెషన్లు |
tool: | tool:shell, tool:file | ఇతర టూల్స్ను ఉపయోగించడం |
shell: | shell:exec | షెల్ కమాండ్ ఎగ్జిక్యూషన్ |
channel: | channel:send, channel:* | ఛానెల్ ఆపరేషన్లు |
comm: | comm:send, comm:* | AI ఉద్యోగుల మధ్య కమ్యూనికేషన్ |
model: | model:chat | AI మోడల్ యాక్సెస్ |
user: | user:token | అభ్యర్థనల్లో వినియోగదారు JWTని అందుకోవడం |
schedule: | schedule:create | క్రాన్ జాబ్ నిర్వహణ |
database: | database:query | డేటాబేస్ యాక్సెస్ |
storage: | storage:read, storage:write | శాశ్వత స్టోరేజ్ |
context: | context:read | AI ఉద్యోగి సందర్భం యాక్సెస్ |
subagent: | subagent:spawn | సబ్-ఏజెంట్ ఆపరేషన్లు |
lane: | lane:enqueue | లేన్ ఆపరేషన్లు |
notification: | notification:send | పుష్ నోటిఫికేషన్లు |
embedding: | embedding:search | వెక్టర్ ఎంబెడింగ్ యాక్సెస్ |
skill: | skill:invoke | నైపుణ్యాన్ని పిలవడం |
advisor: | advisor:consult | అడ్వైజర్ సిస్టమ్ యాక్సెస్ |
mcp: | mcp:connect | MCP సర్వర్ యాక్సెస్ |
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"]
}
]
} | ఫీల్డ్ | వివరణ |
|---|---|
provider | OAuth ప్రొవైడర్: "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 సెకన్లు వేచి ఉంటుంది.
యాప్ లాంచ్ క్రమం
- Nebo
manifest.jsonను చదివి దాన్ని ధృవీకరిస్తుంది - యాప్ డైరెక్టరీలో
binaryలేదాappఎగ్జిక్యూటబుల్ను కనుగొంటుంది .quarantinedమార్కర్ కోసం తనిఖీ చేస్తుంది (క్వారంటైన్ చేసిన యాప్లను లాంచ్ చేయడానికి నిరాకరిస్తుంది)- రద్దు తనిఖీ (NeboAI పంపిణీ చేసిన యాప్లకు మాత్రమే)
- సంతకం ధృవీకరణ (NeboAI పంపిణీ చేసిన యాప్లకు మాత్రమే, devలో దాటవేయబడుతుంది)
- బైనరీ ధృవీకరణ (సింలింక్లు, స్క్రిప్ట్లు, ఎగ్జిక్యూటబుల్ కానివి, పరిమితి మించిన ఫైల్లను తిరస్కరిస్తుంది)
- మునుపటి రన్ నుండి మిగిలిన పాత సాకెట్ను శుభ్రం చేస్తుంది
- శాండ్బాక్స్ స్టోరేజ్ కోసం
data/డైరెక్టరీని సృష్టిస్తుంది - ప్రతి యాప్కు లాగ్ ఫైల్లను సెటప్ చేస్తుంది (
logs/stdout.log,logs/stderr.log) - శుద్ధి చేసిన ఎన్విరాన్మెంట్, ప్రాసెస్ గ్రూప్ ఐసోలేషన్తో బైనరీని ప్రారంభిస్తుంది
- Unix సాకెట్ కనిపించే వరకు వేచి ఉంటుంది (ఎక్స్పోనెన్షియల్ బ్యాక్ఆఫ్, గరిష్ఠంగా 10 సెకన్లు)
- Unix సాకెట్పై gRPC ద్వారా కనెక్ట్ అవుతుంది
providesఆధారంగా సామర్థ్య-నిర్దిష్ట gRPC క్లయింట్లను సృష్టిస్తుంది- హెల్త్ చెక్ నడుపుతుంది
- 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") స్కీమా నియమాలు:
- తప్పనిసరి స్ట్రింగ్ enumగా ఎల్లప్పుడూ ఒక
actionఫీల్డ్ను చేర్చండి - మీ టూల్ అనేక విభిన్న రిసోర్స్ రకాలను నిర్వహిస్తే మాత్రమే
resourceఫీల్డ్ను (తప్పనిసరి స్ట్రింగ్ enum) జోడించండి - మిగతా అన్ని ఫీల్డ్లు చర్య-నిర్దిష్ట పారామీటర్లు
actionenum వివరణ అందుబాటులో ఉన్న అన్ని చర్యలను జాబితా చేయాలి
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ను పిలుస్తుంది.
ఇది ఎలా పని చేస్తుంది
- మీ ఛానెల్ ప్రత్యేక ఐడెంటిఫైయర్ను పొందడానికి Nebo
ID()ని పిలుస్తుంది - మీ యాప్ సెట్టింగ్ల నుండి కాన్ఫిగ్తో Nebo
Connect()ని పిలుస్తుంది - Nebo ఒక
Receive()స్ట్రీమ్ను తెరుస్తుంది — వినియోగదారు బాట్కు మెసేజ్ చేసినప్పుడల్లా మీ యాప్ ఇన్బౌండ్ మెసేజ్లను పంపుతుంది - ఇన్బౌండ్ మెసేజ్లు AI ఉద్యోగి ప్రధాన సంభాషణ లేన్కు మళ్ళించబడతాయి
- AI ఉద్యోగి మెసేజ్ పంపాలనుకున్నప్పుడు, Nebo v1 మెసేజ్ ఎన్వలప్తో
Send()ని పిలుస్తుంది - షట్డౌన్ సమయంలో, 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_id | UUID v7 | సమయ క్రమంలో ప్రత్యేక ID |
channel_id | {type}:{platform_id} | రూట్ చేయగల ఛానెల్ ఐడెంటిఫైయర్ |
sender | object | బాట్ గుర్తింపు — name, role, botId |
text | string | మెసేజ్ బాడీ |
attachments | array | ఫైల్లు, చిత్రాలు, ఆడియో |
reply_to | UUID v7 | థ్రెడింగ్ కోసం పేరెంట్ మెసేజ్ ID |
actions | array | ఇంటరాక్టివ్ బటన్లు/కీబోర్డ్లు |
platform_data | bytes | ప్లాట్ఫామ్-నిర్దిష్ట ఫీచర్ల కోసం అపారదర్శకంగా పంపే డేటా |
timestamp | ISO 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.json | 1 MB | యాప్ మెటాడేటా |
binary లేదా app | 500 MB | ఎగ్జిక్యూటబుల్ |
signatures.json | 1 MB | Ed25519 సంతకాలు |
TOOL.md | 1 MB | AI ఉద్యోగి కోసం టూల్ సూచనలు |
ఎక్స్ట్రాక్షన్ సమయంలో భద్రతా నియమాలు:
- పాత్ ట్రావర్సల్ లేదు (
../తిరస్కరించబడుతుంది) - సింలింక్లు లేవు (తిరస్కరించబడతాయి)
- అబ్సొల్యూట్ పాత్లు లేవు (తిరస్కరించబడతాయి)
- అనుమతి జాబితాలోని ఫైల్ పేర్లు మాత్రమే అంగీకరించబడతాయి
సంతకాలు
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 ద్వారా ప్రచురించండి.
డెవలపర్ ఖాతా సెటప్
POST /api/v1/owners/registerవద్ద NeboAI ఖాతాను రిజిస్టర్ చేయండి- JWT టోకెన్ పొందడానికి లాగిన్ చేయండి:
POST /api/v1/owners/login - డెవలపర్ ఖాతాను సృష్టించండి:
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" సమీక్ష ప్రక్రియ
- ఆటోమేటెడ్ స్కాన్ — బైనరీలు VirusTotal ద్వారా స్కాన్ చేయబడతాయి
- అడ్మిన్ సమీక్ష — NeboAI టీమ్ మెటాడేటా, మ్యానిఫెస్ట్, స్కాన్ ఫలితాలను సమీక్షిస్తుంది
- ఆమోదం పొందితే — NeboAI యాప్కు Ed25519తో సంతకం చేసి దాన్ని ప్రచురిస్తుంది
- తిరస్కరించబడితే — మీకు కారణం తెలియజేయబడుతుంది, సరిచేసి మళ్ళీ సబ్మిట్ చేయవచ్చు
లక్ష్య సమీక్ష సమయం: <24 గంటలు.
అప్డేట్లను పంపడం
- యాప్ వెర్షన్ను అప్డేట్ చేయండి: కొత్త వెర్షన్తో
PUT /api/v1/developer/apps/{id} - ప్రతి ప్లాట్ఫామ్కు కొత్త బైనరీలను అప్లోడ్ చేయండి
- మళ్ళీ సమీక్ష కోసం సబ్మిట్ చేయండి
ప్రతి అప్డేట్ అదే సమీక్ష ప్రక్రియ ద్వారా వెళ్తుంది. కొత్త వెర్షన్ ఆమోదం పొందే వరకు పాత వెర్షన్లు అందుబాటులో ఉంటాయి.
స్టోర్ మెటాడేటా
| ఫీల్డ్ | వివరణ |
|---|---|
category | ఉదా., productivity, communication, developer-tools |
icon | యాప్ ఐకాన్ URL |
visibility | public లేదా private |
description | మ్యానిఫెస్ట్ వివరణ కంటే పొడవుగా/వివరంగా ఉండవచ్చు |
డెవ్ వర్క్ఫ్లో
లోకల్ డెవలప్మెంట్
లోకల్ డెవలప్మెంట్ కోసం ప్యాకేజింగ్ అవసరం లేదు:
- మీ యాప్ డైరెక్టరీని సృష్టించండి:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - మీ
manifest.json, కోడ్ రాయండి - మీ బైనరీని బిల్డ్ చేయండి:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo కొత్త డైరెక్టరీని ఆటోమేటిక్గా గుర్తిస్తుంది (లేదా Neboని రీస్టార్ట్ చేయండి)
- కోడ్ మార్పుల తర్వాత, బైనరీని మళ్ళీ బిల్డ్ చేయండి — ఫైల్ వాచర్ యాప్ను రీస్టార్ట్ చేస్తుంది
లాగ్లను చూడటం
యాప్ 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") |
మంచి నైపుణ్యాలు రాయడం
మంచి నైపుణ్య టెంప్లేట్లో ఇవి ఉంటాయి:
- స్పష్టమైన శీర్షిక — AI ఉద్యోగికి అది ఏ మోడ్లో ఉందో చెబుతుంది
- ముఖ్య సూత్రాలు — చర్చకు తావులేని ప్రవర్తనా నియమాలు
- పద్ధతి — సాధారణ సందర్భాల కోసం దశల వారీ విధానం
- ఉదాహరణలు — వినియోగదారు మెసేజ్ నుండి ప్రతిస్పందన వరకు నిర్దిష్ట నమూనాలు
- వ్యతిరేక నమూనాలు — ఏమి చేయకూడదో (నెగటివ్ ఉదాహరణల నుండి మోడల్లు బాగా నేర్చుకుంటాయి)
చిట్కా: ప్రతి నైపుణ్యం ఒక పనిని బాగా చేయాలి. "సాధారణ ప్రోగ్రామింగ్" నైపుణ్యాన్ని సృష్టించకండి — code-review, debugging, api-designలను వేర్వేరు నైపుణ్యాలుగా సృష్టించండి. AI ఉద్యోగికి ఒకేసారి అనేక యాక్టివ్ నైపుణ్యాలు ఉండవచ్చు.
బండిల్ చేసిన నైపుణ్యాలు
సాధారణ వినియోగ సందర్భాలను కవర్ చేసే బండిల్ చేసిన నైపుణ్యాలతో Nebo వస్తుంది:
| నైపుణ్యం | ప్రాధాన్యత | వివరణ |
|---|---|---|
onboarding | 100 | కొత్త వినియోగదారుకు స్వాగతం, ప్రొఫైల్ సేకరణ |
best-friend | 50 | వ్యక్తిత్వ నైపుణ్యం — సాధారణంగా, విశ్వాసంగా, నిజాయితీగా మాట్లాడటం |
debugging | 25 | క్రమబద్ధమైన డీబగ్గింగ్ పద్ధతి |
api-design | 15 | RESTful API డిజైన్ ఉత్తమ పద్ధతులు |
code-review | 10 | తీవ్రత స్థాయిలతో నిర్మాణాత్మక కోడ్ సమీక్ష |
database-expert | 10 | డేటాబేస్ డిజైన్, క్వెరీలు, ఆప్టిమైజేషన్ |
git-workflow | 10 | Git బ్రాంచింగ్, కమిట్లు, PR వర్క్ఫ్లోలు |
security-audit | 10 | భద్రతా విశ్లేషణ, బలహీనతల గుర్తింపు |
ఇవి ఉపయోగకరమైన డిఫాల్ట్లుగానూ, మీ సొంత నైపుణ్యాలను సృష్టించడానికి రిఫరెన్స్ అమలులుగానూ పని చేస్తాయి.
రిఫరెన్స్
Proto ఫైల్లు
Proto ఫైల్లు proto/apps/v0/లో ఉంటాయి. SDKలు ముందే జనరేట్ చేసిన కోడ్తో వస్తాయి, కాబట్టి సాధారణ డెవలప్మెంట్ కోసం మీకు protoc అవసరం లేదు.
| ఫైల్ | సేవ | ముఖ్య RPCలు |
|---|---|---|
v0/common.proto | (మెసేజ్లు మాత్రమే) | HealthCheckRequest/Response, SettingsMap, UserContext, Empty |
v0/tool.proto | ToolService | Name, Description, Schema, Execute, RequiresApproval, Configure |
v0/channel.proto | ChannelService | ID, Connect, Disconnect, Send, Receive (stream), Configure |
v0/comm.proto | CommService | Name, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure |
v0/gateway.proto | GatewayService | HealthCheck, Stream (stream), Poll, Cancel, Configure |
v0/ui.proto | UIService | HealthCheck, HandleRequest, Configure |
v0/schedule.proto | ScheduleService | HealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure |
ప్రతి సేవలో HealthCheck మరియు Configure RPCలు ఉంటాయి. SDK రెండింటినీ ఆటోమేటిక్గా చూసుకుంటుంది.
ఛానెల్ Proto రకాలు
| మెసేజ్ రకం | వివరణ |
|---|---|
ChannelSendRequest | message_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"లతో పాటు "స్నేహితుడు", "కొడుకు", "మార్గదర్శి" కూడా సరైన రోల్లే.