NeboAI
NeboAI
தொடங்குங்கள்

Nebo-க்கான ஆப்களை உருவாக்குங்கள்

உங்கள் AI-க்குப் புதிய அதிசக்திகளைக் கொடுங்கள். கருவிகள், சேனல்கள், கேட்வேக்கள், UI பேனல்கள் — நீங்கள் கற்பனை செய்யும் எதுவும், நேட்டிவ் பைனரியாகத் தொகுக்கப்பட்டு.

மேலோட்டம்

Nebo என்றால் என்ன

Nebo ஒரு தனிப்பட்ட டெஸ்க்டாப் AI உதவியாளர் — உங்கள் டிஜிட்டல் வாழ்க்கையை நிர்வகிக்கும், எப்போதும் இயங்கும் AI பணியாளர். ஸ்மார்ட்ஃபோனைப் பற்றி நினைப்பதுபோல Nebo-வைப் பற்றி நினையுங்கள்: அதன் ஆப்கள் மூலம் பெரும் மாற்றத்தைக் கொண்டுவரும் ஒரு சக்திவாய்ந்த தளம்.

தனியாகவே, Nebo நினைவகம், அட்டவணையிடல், இணைய உலாவல், கோப்பு மேலாண்மை, ஷெல் அணுகல் கொண்ட திறமையான AI பணியாளர். ஆனால் உண்மையான திறவுகோல் ஆப்கள்தான். ஸ்மார்ட்ஃபோனின் சக்தி அதன் ஆப் சூழலமைப்பிலிருந்து வருவதுபோல, Nebo-வின் சக்தி அது செய்யக்கூடியதை விரிவுபடுத்தும் ஆப்களிலிருந்து வருகிறது.

ஆப்கள் என்றால் என்ன

Nebo ஆப்கள், அற்புதமான செயல்பாடுகளைக் கொண்ட, தன்னிறைவான, முன்பே தொகுக்கப்பட்ட அலகுகள். ஒவ்வொரு ஆப்பும் Nebo-க்கு ஒரு புதிய அதிசக்தியைத் தருகிறது — நாள்காட்டி மேலாண்மை, மின்னஞ்சல் வகைப்படுத்தல், திட்டக் கண்காணிப்பு, வீட்டுத் தானியக்கம், நிதிப் பகுப்பாய்வு — ஒரு டெவலப்பர் கற்பனை செய்யக்கூடிய எதுவும்.

ஆப்கள் மிகப் பாதுகாப்பான முறையில் அற்புதமான சக்தியை வழங்குகின்றன. ஒவ்வொரு ஆப்பும் இயல்பாக எல்லாவற்றையும் மறுக்கும் அனுமதிகளுடன் ஒரு சாண்ட்பாக்ஸில் இயங்குகிறது. அதன் மேனிஃபெஸ்ட் அறிவிப்பதையும் பயனர் அங்கீகரிப்பதையும் மட்டுமே அது அணுக முடியும்.

இடைமுகம் 100% உரையாடல் வழியானது. பயனர்கள் தனித் திரைகள் அல்லது டாஷ்போர்டுகள் மூலம் ஆப்களுடன் தொடர்புகொள்வதில்லை. அவர்கள் Nebo-விடம் பேசுகிறார்கள், Nebo ஆப்பின் கருவிகளைப் பயன்படுத்தி வேலையை முடிக்கிறது. "நாளை என் நாள்காட்டியில் என்ன இருக்கிறது?" — Nebo நாள்காட்டி ஆப்பை அழைக்கிறது. "மாலை 3 மணிக்கு Sarah-உடன் ஒரு சந்திப்பை உருவாக்கு" — 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:createCron வேலை மேலாண்மை
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. பைனரி சரிபார்ப்பு (symlink-கள், ஸ்கிரிப்டுகள், இயக்க முடியாதவை, அளவுக்கு மீறிய கோப்புகளை நிராகரிக்கிறது)
  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. தேவையான string enum-ஆக எப்போதும் ஒரு action புலத்தைச் சேருங்கள்
  2. உங்கள் கருவி பல தனித்துவமான வள வகைகளை நிர்வகித்தால் மட்டுமே resource புலத்தை (தேவையான string 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-இல் செய்திகள், கருவிகள், சிஸ்டம் ப்ராம்ப்ட், அதிகபட்ச டோக்கன்கள், temperature, மற்றும் ஒரு 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 ஹேண்ட்லர்களை எழுதுகிறீர்கள் — gRPC இணைப்பை SDK தானாகக் கையாளுகிறது.

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-வின் உள்ளமைந்த cron அட்டவணையாளரை மாற்றீடு செய்கிறது. "provides": ["schedule"] மற்றும் "permissions": ["schedule:create"]-ஐ அறிவியுங்கள்.

உங்கள் அட்டவணை ஆப் தொடங்கும்போது, இயல்புநிலை cron இயந்திரத்துக்குப் பதிலாக எல்லா அட்டவணையிடலையும் 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 பணியாளருக்கான கருவி வழிமுறைகள்

பிரித்தெடுக்கும்போது பாதுகாப்பு விதிகள்:

  • பாதைக் கடத்தல் இல்லை (../ நிராகரிக்கப்படும்)
  • symlink-கள் இல்லை (நிராகரிக்கப்படும்)
  • முழுமையான பாதைகள் இல்லை (நிராகரிக்கப்படும்)
  • அனுமதிப் பட்டியலில் உள்ள கோப்புப் பெயர்கள் மட்டுமே ஏற்கப்படும்

கையொப்பங்கள்

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. உங்கள் binary-ஐ உருவாக்கவும்:
    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)
  • 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-க்குச் சொல்கிறது.

திறன்களும் ஆப்களும்

திறன்கள்ஆப்கள்
வடிவம்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 frontmatter, மற்றும் ஒரு 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 இருக்கும். உங்கள் தளத்துக்கான காட்சிப் பெயரை வடிவமைக்க இதைப் பயன்படுத்துங்கள். role ஒரு பணிப் பெயர் அல்ல — அது ஒரு உறவு விவரிப்பான். "COO", "DevLead" ஆகியவற்றுடன் "நண்பர்", "மகன்", "வழிகாட்டி" ஆகியவையும் செல்லுபடியான roles.