மேலோட்டம்
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) குறைந்தபட்ச ஆப் சரிபார்ப்புப் பட்டியல்
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 | Cron வேலை மேலாண்மை |
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-இல் தவிர்க்கப்படும்)
- பைனரி சரிபார்ப்பு (symlink-கள், ஸ்கிரிப்டுகள், இயக்க முடியாதவை, அளவுக்கு மீறிய கோப்புகளை நிராகரிக்கிறது)
- முந்தைய ஓட்டத்தின் பழைய சாக்கெட்டைச் சுத்தம் செய்கிறது
- சாண்ட்பாக்ஸ் சேமிப்பகத்துக்காக
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") ஸ்கீமா விதிகள்:
- தேவையான string enum-ஆக எப்போதும் ஒரு
actionபுலத்தைச் சேருங்கள் - உங்கள் கருவி பல தனித்துவமான வள வகைகளை நிர்வகித்தால் மட்டுமே
resourceபுலத்தை (தேவையான string 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-இல் செய்திகள், கருவிகள், சிஸ்டம் ப்ராம்ப்ட், அதிகபட்ச டோக்கன்கள், 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.json | 1 MB | ஆப் மெட்டாடேட்டா |
binary அல்லது app | 500 MB | இயக்கக் கோப்பு |
signatures.json | 1 MB | Ed25519 கையொப்பங்கள் |
TOOL.md | 1 MB | AI பணியாளருக்கான கருவி வழிமுறைகள் |
பிரித்தெடுக்கும்போது பாதுகாப்பு விதிகள்:
- பாதைக் கடத்தல் இல்லை (
../நிராகரிக்கப்படும்) - 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 மூலம் வெளியிடுங்கள்.
டெவலப்பர் கணக்கு அமைப்பு
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-ஐயும் குறியீட்டையும் எழுதுங்கள் - உங்கள் binary-ஐ உருவாக்கவும்:
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 சூழல் மாறியாகவும் கிடைக்கும்) பயன்படுத்துங்கள். இந்தக் கோப்பகம் ஆப் புதுப்பிப்புகளையும் தனிமைப்படுத்தலையும் தாண்டி நிலைத்திருக்கும்.
பிழைதிருத்தக் குறிப்புகள்
- உங்கள் ஆப் தொடங்கவில்லை என்றால், பிழைகளுக்கு
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") |
நல்ல திறன்களை எழுதுதல்
ஒரு நல்ல திறன் வார்ப்புருவில் இருக்க வேண்டியவை:
- தெளிவான தலைப்பு — 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 இருக்கும். உங்கள் தளத்துக்கான காட்சிப் பெயரை வடிவமைக்க இதைப் பயன்படுத்துங்கள். role ஒரு பணிப் பெயர் அல்ல — அது ஒரு உறவு விவரிப்பான். "COO", "DevLead" ஆகியவற்றுடன் "நண்பர்", "மகன்", "வழிகாட்டி" ஆகியவையும் செல்லுபடியான roles.