അവലോകനം
Nebo എന്താണ്
Nebo ഒരു വ്യക്തിഗത ഡെസ്ക്ടോപ്പ് AI അസിസ്റ്റന്റാണ് — നിങ്ങളുടെ ഡിജിറ്റൽ ജീവിതം കൈകാര്യം ചെയ്യുന്ന, എപ്പോഴും പ്രവർത്തിക്കുന്ന ഒരു AI ജീവനക്കാരൻ. ഒരു സ്മാർട്ട്ഫോണിനെ കാണുന്നതുപോലെ Nebo-യെ കാണൂ: ആപ്പുകളിലൂടെ അടിമുടി മാറ്റം കൊണ്ടുവരുന്ന ശക്തമായ ഒരു പ്ലാറ്റ്ഫോം.
സ്വന്തം നിലയിൽ തന്നെ, മെമ്മറി, ഷെഡ്യൂളിങ്, വെബ് ബ്രൗസിങ്, ഫയൽ മാനേജ്മെന്റ്, ഷെൽ ആക്സസ് എന്നിവയുള്ള കഴിവുള്ള ഒരു AI ജീവനക്കാരനാണ് Nebo. എന്നാൽ യഥാർഥ താക്കോൽ ആപ്പുകളാണ്. ഒരു സ്മാർട്ട്ഫോണിന്റെ ശക്തി അതിന്റെ ആപ്പ് ഇക്കോസിസ്റ്റത്തിൽ നിന്ന് വരുന്നതുപോലെ, Nebo-യുടെ ശക്തി അതിന് ചെയ്യാനാകുന്നത് വിപുലീകരിക്കുന്ന ആപ്പുകളിൽ നിന്നാണ്.
ആപ്പുകൾ എന്താണ്
Nebo ആപ്പുകൾ അതിശയകരമായ പ്രവർത്തനക്ഷമതയുള്ള, സ്വയംപൂർണ്ണമായ, മുൻകൂട്ടി കംപൈൽ ചെയ്ത യൂണിറ്റുകളാണ്. ഓരോ ആപ്പും Nebo-യ്ക്ക് ഒരു പുതിയ അതിശക്തി നൽകുന്നു — കലണ്ടർ മാനേജ്മെന്റ്, ഇമെയിൽ തരംതിരിക്കൽ, പ്രോജക്റ്റ് ട്രാക്കിങ്, ഹോം ഓട്ടോമേഷൻ, സാമ്പത്തിക വിശകലനം — ഒരു ഡെവലപ്പർക്ക് സങ്കൽപ്പിക്കാവുന്ന എന്തും.
ആപ്പുകൾ വളരെ സുരക്ഷിതമായ രീതിയിൽ അതിശയകരമായ ശക്തി നൽകുന്നു. ഓരോ ആപ്പും ഡിഫോൾട്ടായി എല്ലാം നിഷേധിക്കുന്ന അനുമതികളുള്ള ഒരു സാൻഡ്ബോക്സിലാണ് പ്രവർത്തിക്കുന്നത്. അതിന്റെ മാനിഫെസ്റ്റ് പ്രഖ്യാപിക്കുന്നതും ഉപയോക്താവ് അംഗീകരിക്കുന്നതും മാത്രമേ അതിന് ആക്സസ് ചെയ്യാനാകൂ.
ഇന്റർഫേസ് 100% സംഭാഷണരൂപത്തിലാണ്. ഉപയോക്താക്കൾ പ്രത്യേക സ്ക്രീനുകളിലൂടെയോ ഡാഷ്ബോർഡുകളിലൂടെയോ ആപ്പുകളുമായി ഇടപെടുന്നില്ല. അവർ Nebo-യോട് സംസാരിക്കുന്നു, കാര്യങ്ങൾ ചെയ്തുതീർക്കാൻ Nebo ആപ്പിന്റെ ടൂളുകൾ ഉപയോഗിക്കുന്നു. "നാളെ എന്റെ കലണ്ടറിൽ എന്താണുള്ളത്?" — Nebo കലണ്ടർ ആപ്പിനെ വിളിക്കുന്നു. "Sarah-യുമായി 3pm-ന് ഒരു മീറ്റിങ് ഉണ്ടാക്കൂ" — Nebo കലണ്ടർ ആപ്പിനെ വിളിക്കുന്നു. ഉപയോക്താവ് ഒരിക്കലും സംഭാഷണം വിട്ടുപോകുന്നില്ല.
ആപ്പുകൾക്ക് ഐച്ഛികമായി ഒരു സെറ്റിങ്സ് UI നൽകാം — Nebo-യുടെ ബിൽറ്റ്-ഇൻ ബ്രൗസർ വിൻഡോയിൽ തുറക്കുന്ന ഒരു കോൺഫിഗറേഷൻ പാനൽ. ഇവിടെയാണ് ഉപയോക്താക്കൾ API കീകൾ നൽകുന്നതും ഫീച്ചറുകൾ ഓണാക്കുന്നതും ഓഫാക്കുന്നതും ആപ്പ് കോൺഫിഗർ ചെയ്യുന്നതും. മാനിഫെസ്റ്റിലെ settings അറേയാണ് സെറ്റിങ്സ് UI നിയന്ത്രിക്കുന്നത് (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 | [] | കോൺഫിഗർ ചെയ്യാവുന്ന ക്രമീകരണങ്ങൾ (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-ൽ "Needs Setup" ബാഡ്ജ് കാണിക്കും.
| തരം | വിവരണം |
|---|---|
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) ചേർക്കൂ - മറ്റെല്ലാ ഫീൽഡുകളും ഓരോ action-നുമുള്ള പാരാമീറ്ററുകളാണ്
actionenum-ന്റെ വിവരണം ലഭ്യമായ എല്ലാ actions-ഉം ലിസ്റ്റ് ചെയ്യണം
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-ൽ സന്ദേശങ്ങൾ, ടൂളുകൾ, സിസ്റ്റം പ്രോംപ്റ്റ്, max tokens, temperature, ഒരു UserContext (user:token അനുമതി നൽകിയിട്ടുണ്ടെങ്കിൽ JWT ടോക്കൺ) എന്നിവ അടങ്ങുന്നു.
GatewayEvent തരങ്ങൾ:
| തരം | ഉള്ളടക്കം | വിവരണം |
|---|---|---|
"text" | ടെക്സ്റ്റ് ഭാഗം | സ്ട്രീം ചെയ്യുന്ന ടെക്സ്റ്റ് ടോക്കൺ |
"tool_call" | JSON | മോഡലിന് ഒരു ടൂൾ വിളിക്കണം |
"thinking" | ടെക്സ്റ്റ് ഭാഗം | വിപുലമായ ചിന്ത/യുക്തി |
"error" | പിശക് സന്ദേശം | എന്തോ തകരാറ് സംഭവിച്ചു |
"done" | ശൂന്യം | സ്ട്രീം പൂർത്തിയായി |
UI ആപ്പ്
ഒരു UI ആപ്പ് Nebo-യുടെ ബിൽറ്റ്-ഇൻ ബ്രൗസർ വിൻഡോയിൽ തുറക്കുന്ന ഇഷ്ടാനുസൃത കോൺഫിഗറേഷൻ ഇന്റർഫേസ് നൽകുന്നു. "provides": ["ui"] പ്രഖ്യാപിക്കൂ. സ്വയമേവയുള്ള സെറ്റിങ്സ് ഫോമിൽ നിന്ന് വ്യത്യസ്തമായി (നിങ്ങളുടെ settings മാനിഫെസ്റ്റിൽ നിന്ന് Nebo റെൻഡർ ചെയ്യുന്നത്), ഒരു 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-യുടെ ബിൽറ്റ്-ഇൻ ക്രോൺ ഷെഡ്യൂളറിനെ മാറ്റിസ്ഥാപിക്കുന്നു. "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-യ്ക്ക് ഇവന്റുകൾ വായിക്കാനും എഴുതാനുമുള്ള കഴിവ് നൽകുന്നു. ഒരു "meeting prep" സ്കിൽ ആ കലണ്ടർ ആപ്പും ഇമെയിലും വെബ് തിരയലും ഒരുമിച്ച് ഉപയോഗിച്ച് മീറ്റിങ്ങുകൾക്ക് എങ്ങനെ തയ്യാറെടുക്കണമെന്ന് 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 ഫ്രണ്ട്മാറ്ററും, ഒരു markdown ബോഡിയും (സിസ്റ്റം പ്രോംപ്റ്റിലേക്ക് ചേർക്കുന്ന യഥാർഥ നിർദേശങ്ങൾ).
| ഫീൽഡ് | നിർബന്ധം | ഡിഫോൾട്ട് | വിവരണം |
|---|---|---|---|
name | അതെ | — | അദ്വിതീയ ഐഡന്റിഫയർ (സ്ലഗ് ആയി മാറുന്നു) |
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 ടൂളിലൂടെ സ്കില്ലുകൾ കൈകാര്യം ചെയ്യാം:
| Action | വിവരണം | ഉദാഹരണം |
|---|---|---|
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 ജീവനക്കാരനോട് പറയുന്നു
- അടിസ്ഥാന തത്വങ്ങൾ — വിട്ടുവീഴ്ചയില്ലാത്ത പെരുമാറ്റ നിയമങ്ങൾ
- രീതിശാസ്ത്രം — സാധാരണ സാഹചര്യങ്ങൾക്കുള്ള ഘട്ടംഘട്ടമായ സമീപനം
- ഉദാഹരണങ്ങൾ — ഉപയോക്തൃ സന്ദേശത്തിൽ നിന്ന് മറുപടിയിലേക്കുള്ള വ്യക്തമായ മാതൃകകൾ
- ഒഴിവാക്കേണ്ട രീതികൾ — എന്ത് ചെയ്യരുത് (നെഗറ്റീവ് ഉദാഹരണങ്ങളിൽ നിന്ന് മോഡലുകൾ നന്നായി പഠിക്കും)
നുറുങ്ങ്: ഓരോ സ്കില്ലും ഒരു കാര്യം നന്നായി ചെയ്യണം. ഒരു "general programming" സ്കിൽ ഉണ്ടാക്കരുത് — 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 | ഇന്ററാക്ടീവ് ബട്ടൺ/കീബോർഡ് action (label, callback_id) |
ബോട്ട് ഐഡന്റിറ്റിയും റോളുകളും
Nebo ബോട്ടുകൾക്ക് മൂന്ന് അച്ചുതണ്ടുകളുള്ള ഒരു ഐഡന്റിറ്റി മാതൃകയുണ്ട്:
- creature — ബോട്ട് എന്താണ് (ആദിരൂപം): "ചുറുചുറുക്കുള്ള തന്ത്രജ്ഞൻ", "സൂക്ഷ്മതയുള്ള ഗവേഷകൻ"
- role — ഉപയോക്താവുമായുള്ള ബന്ധം: "സുഹൃത്ത്", "COO", "മാർഗദർശി"
- vibe — അതിന്റെ ഊർജ്ജം (ആശയവിനിമയ ശൈലി): "ശാന്തം, എന്നാൽ സ്വന്തം അഭിപ്രായമുള്ളത്", "ഊഷ്മളവും പ്രോത്സാഹിപ്പിക്കുന്നതും"
നിങ്ങളുടെ ചാനൽ പ്ലഗിന് ഒരു ഔട്ട്ബൗണ്ട് സന്ദേശം ലഭിക്കുമ്പോൾ, sender ഫീൽഡിൽ ബോട്ടിന്റെ name-ഉം role-ഉം ഉണ്ടാകും. നിങ്ങളുടെ പ്ലാറ്റ്ഫോമിനായി ഡിസ്പ്ലേ നാമം ഫോർമാറ്റ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കൂ. role ഒരു ജോലിപ്പേരല്ല — അത് ബന്ധത്തെ വിവരിക്കുന്നതാണ്. "COO", "DevLead" എന്നിവയ്ക്കൊപ്പം "സുഹൃത്ത്", "മകൻ", "മാർഗദർശി" എന്നിവയും സാധുവായ റോളുകളാണ്.