ಅವಲೋಕನ
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 ನಲ್ಲಿ ಬಿಟ್ಟುಬಿಡಲಾಗುತ್ತದೆ)
- ಬೈನರಿ ಮೌಲ್ಯೀಕರಣ (ಸಿಮ್ಲಿಂಕ್ಗಳು, ಸ್ಕ್ರಿಪ್ಟ್ಗಳು, ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಅಲ್ಲದವು, ಅತಿ ದೊಡ್ಡ ಫೈಲ್ಗಳನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ)
- ಹಿಂದಿನ ರನ್ನ ಹಳೆಯ ಸಾಕೆಟ್ ಅನ್ನು ತೆರವುಗೊಳಿಸುತ್ತದೆ
- ಸ್ಯಾಂಡ್ಬಾಕ್ಸ್ ಸಂಗ್ರಹಣೆಗಾಗಿ
data/ಡೈರೆಕ್ಟರಿ ರಚಿಸುತ್ತದೆ - ಪ್ರತಿ ಆ್ಯಪ್ಗೆ ಲಾಗ್ ಫೈಲ್ಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ (
logs/stdout.log,logs/stderr.log) - ಶುದ್ಧೀಕರಿಸಿದ ಪರಿಸರ ಮತ್ತು ಪ್ರೊಸೆಸ್ ಗ್ರೂಪ್ ಪ್ರತ್ಯೇಕತೆಯೊಂದಿಗೆ ಬೈನರಿ ಆರಂಭಿಸುತ್ತದೆ
- Unix ಸಾಕೆಟ್ ಕಾಣಿಸಿಕೊಳ್ಳಲು ಕಾಯುತ್ತದೆ (ಘಾತೀಯ ಬ್ಯಾಕ್ಆಫ್, ಗರಿಷ್ಠ 10 ಸೆಕೆಂಡುಗಳು)
- Unix ಸಾಕೆಟ್ ಮೂಲಕ gRPC ಯಿಂದ ಸಂಪರ್ಕಿಸುತ್ತದೆ
providesಆಧಾರದ ಮೇಲೆ ಸಾಮರ್ಥ್ಯ-ನಿರ್ದಿಷ್ಟ gRPC ಕ್ಲೈಂಟ್ಗಳನ್ನು ರಚಿಸುತ್ತದೆ- ಆರೋಗ್ಯ ಪರಿಶೀಲನೆ ನಡೆಸುತ್ತದೆ
- AI ಉದ್ಯೋಗಿಯೊಂದಿಗೆ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೋಂದಾಯಿಸುತ್ತದೆ (ಪರಿಕರಗಳು, ಗೇಟ್ವೇ, comm, ಇತ್ಯಾದಿ)
ಪರಿಕರ ಆ್ಯಪ್ಗಳು
ನಿಮ್ಮ ಮ್ಯಾನಿಫೆಸ್ಟ್ನಲ್ಲಿ "provides": ["tool:my_tool_name"] ಘೋಷಿಸಿ.
STRAP ಮಾದರಿ
ಎಲ್ಲಾ Nebo ಪರಿಕರ ಆ್ಯಪ್ಗಳು ತಮ್ಮ ಸ್ಕೀಮಾ ಮತ್ತು ಚಾಲನಾ ರೂಟಿಂಗ್ಗಾಗಿ STRAP (Single Tool Resource Action Pattern) ಅನ್ನು ಕಡ್ಡಾಯವಾಗಿ ಬಳಸಬೇಕು. 35+ ಪ್ರತ್ಯೇಕ ಪರಿಕರಗಳನ್ನು 4 ಡೊಮೇನ್ ಪರಿಕರಗಳಾಗಿ ಒಗ್ಗೂಡಿಸಲು Nebo ಆಂತರಿಕವಾಗಿ ಬಳಸುವ ಅದೇ ಮಾದರಿ ಇದು — LLM ಸಂದರ್ಭದ ಹೊರೆಯನ್ನು ~80% ರಷ್ಟು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಮೂಲ ಕಲ್ಪನೆ: ಹಲವು ಪರಿಕರಗಳನ್ನು (get_events, check_availability, suggest_slots) ನೋಂದಾಯಿಸುವ ಬದಲು, ಸರಿಯಾದ ಹ್ಯಾಂಡ್ಲರ್ಗೆ ಕಳುಹಿಸುವ action (ಮತ್ತು ಐಚ್ಛಿಕವಾಗಿ resource) ಕ್ಷೇತ್ರಗಳಿರುವ ಒಂದೇ ಪರಿಕರವನ್ನು ನೋಂದಾಯಿಸಿ.
ಏಕ-ಸಂಪನ್ಮೂಲ ಉದಾಹರಣೆ (ಕ್ಯಾಲೆಂಡರ್):
calendar(action: "get_events", start: "2025-01-15T09:00:00Z", end: "2025-01-16T00:00:00Z")
calendar(action: "next_event")
calendar(action: "check_availability", start: "...", end: "...")
calendar(action: "suggest_slots", duration_minutes: 30, preferred_time: "morning") ಬಹು-ಸಂಪನ್ಮೂಲ ಉದಾಹರಣೆ (ಪ್ರಾಜೆಕ್ಟ್ ಮ್ಯಾನೇಜರ್):
project(resource: "task", action: "create", title: "Ship v2", assignee: "alice")
project(resource: "task", action: "list", status: "open")
project(resource: "milestone", action: "create", name: "Beta", deadline: "2025-03-01")
project(resource: "milestone", action: "list") ಸ್ಕೀಮಾ ನಿಯಮಗಳು:
- ಯಾವಾಗಲೂ ಅಗತ್ಯ ಸ್ಟ್ರಿಂಗ್ enum ಆಗಿ
actionಕ್ಷೇತ್ರವನ್ನು ಸೇರಿಸಿ - ನಿಮ್ಮ ಪರಿಕರ ಹಲವು ವಿಭಿನ್ನ ಸಂಪನ್ಮೂಲ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ವಹಿಸಿದರೆ ಮಾತ್ರ
resourceಕ್ಷೇತ್ರ (ಅಗತ್ಯ ಸ್ಟ್ರಿಂಗ್ enum) ಸೇರಿಸಿ - ಉಳಿದ ಎಲ್ಲಾ ಕ್ಷೇತ್ರಗಳು ಕ್ರಿಯೆ-ನಿರ್ದಿಷ್ಟ ಪ್ಯಾರಾಮೀಟರ್ಗಳು
actionenum ವಿವರಣೆ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಕ್ರಿಯೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಬೇಕು
STRAP ಏಕೆ ಮುಖ್ಯ:
- LLM ಗಳು
actionರೂಟಿಂಗ್ ಮಾದರಿಯನ್ನು ಒಮ್ಮೆ ಕಲಿತು ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೂ ಅನ್ವಯಿಸುತ್ತವೆ - ಪರಿಕರ ವ್ಯಾಖ್ಯಾನಗಳು ಸಂದರ್ಭದ ~6% ಬಳಸುತ್ತವೆ — STRAP ಅದನ್ನು 80% ರಷ್ಟು ಕಡಿತಗೊಳಿಸುತ್ತದೆ
- ಹೊಸ ಕಾರ್ಯಾಚರಣೆಗಳು ಕೇವಲ enum ಸೇರ್ಪಡೆಗಳು, ಹೊಸ ಪರಿಕರ ನೋಂದಣಿಗಳಲ್ಲ
- ಹೋಸ್ಟ್ ಮಾಡಿದ ಮತ್ತು ಸ್ಥಳೀಯ ಮಾಡೆಲ್ಗಳಲ್ಲಿ ಒಂದೇ ರೀತಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ
Go ಉದಾಹರಣೆ — ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಪರಿಕರ
package main
import (
"context"
"encoding/json"
"fmt"
"log"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Calculator struct{}
func (c *Calculator) Name() string { return "calculator" }
func (c *Calculator) Description() string { return "Performs arithmetic calculations." }
func (c *Calculator) Schema() json.RawMessage {
return nebo.NewSchema("add", "subtract", "multiply", "divide").
Number("a", "First operand", true).
Number("b", "Second operand", true).
Build()
}
func (c *Calculator) Execute(_ context.Context, input json.RawMessage) (string, error) {
var in struct {
Action string `json:"action"`
A float64 `json:"a"`
B float64 `json:"b"`
}
if err := json.Unmarshal(input, &in); err != nil {
return "", fmt.Errorf("invalid input: %w", err)
}
var result float64
switch in.Action {
case "add":
result = in.A + in.B
case "subtract":
result = in.A - in.B
case "multiply":
result = in.A * in.B
case "divide":
if in.B == 0 {
return "", fmt.Errorf("division by zero")
}
result = in.A / in.B
default:
return "", fmt.Errorf("unknown action: %s", in.Action)
}
return fmt.Sprintf("%g %s %g = %g", in.A, in.Action, in.B, result), nil
}
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterTool(&Calculator{})
log.Fatal(app.Run())
} manifest.json:
{
"id": "com.example.calculator",
"name": "Calculator",
"version": "1.0.0",
"description": "Arithmetic calculator tool for the agent",
"runtime": "local",
"protocol": "grpc",
"provides": ["tool:calculator"],
"permissions": []
} ಬಿಲ್ಡ್ ಮಾಡಿ ಇನ್ಸ್ಟಾಲ್ ಮಾಡಿ:
go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/ Rust ಉದಾಹರಣೆ
use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;
struct Calculator;
#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }
#[async_trait]
impl ToolHandler for Calculator {
fn name(&self) -> &str { "calculator" }
fn description(&self) -> &str { "Performs arithmetic calculations." }
fn schema(&self) -> Value {
SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
.number("a", "First operand", true)
.number("b", "Second operand", true)
.build()
}
async fn execute(&self, input: Value) -> Result<String, NeboError> {
let i: Input = serde_json::from_value(input)
.map_err(|e| NeboError::Execution(e.to_string()))?;
let r = match i.action.as_str() {
"add" => i.a + i.b,
"subtract" => i.a - i.b,
"multiply" => i.a * i.b,
"divide" => {
if i.b == 0.0 {
return Err(NeboError::Execution("division by zero".into()));
}
i.a / i.b
}
other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
};
Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
NeboApp::new()?.register_tool(Calculator).run().await?;
Ok(())
} C ಉದಾಹರಣೆ
#include <nebo/nebo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static int calculator_execute(const char *input_json, char **output, int *is_error) {
/* Parse JSON, compute result, set *output */
*output = strdup("2 add 3 = 5");
*is_error = 0;
return 0;
}
int main(void) {
const char *actions[] = {"add", "subtract", "multiply", "divide", NULL};
nebo_schema_builder_t *sb = nebo_schema_new(actions);
nebo_schema_number(sb, "a", "First operand", 1);
nebo_schema_number(sb, "b", "Second operand", 1);
char *schema = nebo_schema_build(sb);
nebo_schema_free(sb);
nebo_tool_handler_t calculator = {
.name = "calculator",
.description = "Performs arithmetic calculations.",
.schema = schema,
.execute = calculator_execute,
};
nebo_app_t *app = nebo_app_new();
nebo_app_register_tool(app, &calculator);
int ret = nebo_app_run(app);
free(schema);
return ret;
} ಚಾನೆಲ್ ಆ್ಯಪ್ಗಳು
"provides": ["channel:my_channel"] ಮತ್ತು "permissions": ["channel:send"] ಘೋಷಿಸಿ.
ಚಾನೆಲ್ ಆ್ಯಪ್ಗಳು ಬಾಹ್ಯ ಸಂದೇಶ ಪ್ಲಾಟ್ಫಾರ್ಮ್ಗಳನ್ನು (Telegram, Discord, Slack, ಇತ್ಯಾದಿ) Nebo ದ AI ಉದ್ಯೋಗಿಗೆ ಜೋಡಿಸುತ್ತವೆ. ಬಳಕೆದಾರರು ಬಾಹ್ಯ ಪ್ಲಾಟ್ಫಾರ್ಮ್ನಲ್ಲಿ ಸಂದೇಶ ಕಳುಹಿಸಿದಾಗ, ನಿಮ್ಮ ಆ್ಯಪ್ ಅದನ್ನು Receive ಮೂಲಕ Nebo ಗೆ ಸ್ಟ್ರೀಮ್ ಮಾಡುತ್ತದೆ. AI ಉದ್ಯೋಗಿ ಉತ್ತರಿಸಲು ಬಯಸಿದಾಗ, Nebo ನಿಮ್ಮ ಆ್ಯಪ್ನ Send ಅನ್ನು ಕರೆಯುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ
- ನಿಮ್ಮ ಚಾನೆಲ್ನ ಅನನ್ಯ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಪಡೆಯಲು Nebo
ID()ಕರೆಯುತ್ತದೆ - ನಿಮ್ಮ ಆ್ಯಪ್ನ ಸೆಟ್ಟಿಂಗ್ಗಳಿಂದ ಬಂದ ಕಾನ್ಫಿಗ್ನೊಂದಿಗೆ Nebo
Connect()ಕರೆಯುತ್ತದೆ - Nebo
Receive()ಸ್ಟ್ರೀಮ್ ತೆರೆಯುತ್ತದೆ — ಬಳಕೆದಾರರು ಬಾಟ್ಗೆ ಸಂದೇಶ ಕಳುಹಿಸಿದಾಗಲೆಲ್ಲಾ ನಿಮ್ಮ ಆ್ಯಪ್ ಒಳಬರುವ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ - ಒಳಬರುವ ಸಂದೇಶಗಳನ್ನು AI ಉದ್ಯೋಗಿಯ ಮುಖ್ಯ ಸಂಭಾಷಣಾ ಲೇನ್ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ
- AI ಉದ್ಯೋಗಿ ಸಂದೇಶ ಕಳುಹಿಸಲು ಬಯಸಿದಾಗ, Nebo v1 ಸಂದೇಶ ಲಕೋಟೆಯೊಂದಿಗೆ
Send()ಕರೆಯುತ್ತದೆ - ಸ್ಥಗಿತಗೊಳಿಸುವಾಗ, Nebo
Disconnect()ಕರೆಯುತ್ತದೆ
v1 ಸಂದೇಶ ಲಕೋಟೆ
ಎಲ್ಲಾ ಚಾನೆಲ್ ಸಂದೇಶಗಳು — ಒಳಬರುವ ಮತ್ತು ಹೊರಹೋಗುವ — ಸಾಮಾನ್ಯ ಸಂದೇಶ ಲಕೋಟೆಯನ್ನು ಬಳಸುತ್ತವೆ:
{
"message_id": "01953f8a-...",
"channel_id": "telegram:12345",
"sender": { "name": "Alex", "role": "COO", "bot_id": "uuid" },
"text": "Q3 numbers look good...",
"attachments": [{ "type": "image", "url": "https://...", "filename": "chart.png", "size": 45000 }],
"reply_to": "01953f89-...",
"actions": [{ "label": "Approve", "callback_id": "approve_q3" }],
"platform_data": null,
"timestamp": "2026-02-12T15:10:00Z"
} | ಕ್ಷೇತ್ರ | ಪ್ರಕಾರ | ವಿವರಣೆ |
|---|---|---|
message_id | UUID v7 | ಸಮಯ ಕ್ರಮದ ಅನನ್ಯ ID |
channel_id | {type}:{platform_id} | ರೂಟ್ ಮಾಡಬಹುದಾದ ಚಾನೆಲ್ ಗುರುತಿಸುವಿಕೆ |
sender | object | ಬಾಟ್ ಗುರುತು — ಹೆಸರು, ಪಾತ್ರ, botId |
text | string | ಸಂದೇಶದ ಮುಖ್ಯ ಭಾಗ |
attachments | array | ಫೈಲ್ಗಳು, ಚಿತ್ರಗಳು, ಆಡಿಯೊ |
reply_to | UUID v7 | ಥ್ರೆಡ್ಗಾಗಿ ಮೂಲ ಸಂದೇಶದ ID |
actions | array | ಸಂವಾದಾತ್ಮಕ ಬಟನ್ಗಳು/ಕೀಬೋರ್ಡ್ಗಳು |
platform_data | bytes | ಪ್ಲಾಟ್ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ವೈಶಿಷ್ಟ್ಯಗಳಿಗಾಗಿ ಅಪಾರದರ್ಶಕ ನೇರ ರವಾನೆ |
timestamp | ISO 8601 | ಪ್ರಕಾಶಕರು ಇದನ್ನು ಹೊಂದಿಸುತ್ತಾರೆ |
ಎರಡು-ಪದರದ ವಿನ್ಯಾಸ: ಸಾಮಾನ್ಯ ಕ್ಷೇತ್ರಗಳು (text, attachments, reply_to, actions) ಉದ್ಯೋಗಿ ಪ್ರಾರಂಭಿಸುವ 90% ಸಂದೇಶಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತವೆ. ಪ್ಲಾಟ್ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ವೈಶಿಷ್ಟ್ಯಗಳು platform_data ನಲ್ಲಿ ಹೋಗುತ್ತವೆ — ನಿಮ್ಮ ಪ್ಲಗಿನ್ ಅವುಗಳನ್ನು ನೇಟಿವ್ ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಸ್ವರೂಪಕ್ಕೆ/ಸ್ವರೂಪದಿಂದ ಹೊಂದಿಸುತ್ತದೆ.
ಸಂಭಾಷಣಾ ಸ್ಟ್ರೀಮ್ಗಳು
ಪ್ರತ್ಯೇಕತೆಗಾಗಿ ಚಾನೆಲ್ ಸಂದೇಶಗಳನ್ನು ಪ್ರತಿ-ಚಾನೆಲ್ ಸಂಭಾಷಣಾ ಸ್ಟ್ರೀಮ್ಗಳ ಮೂಲಕ ಕಳುಹಿಸಲಾಗುತ್ತದೆ:
neboai/bot/{botID}/channels/{channelType}/inbound # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound # messages from agent → channel Go ಉದಾಹರಣೆ — Telegram ಚಾನೆಲ್
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"time"
"github.com/google/uuid"
tgbot "github.com/go-telegram/bot"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Telegram struct {
bot *tgbot.Bot
messages chan nebo.ChannelEnvelope
cancel context.CancelFunc
}
func (t *Telegram) ID() string { return "telegram" }
func (t *Telegram) Connect(_ context.Context, config map[string]string) error {
token := config["bot_token"]
if token == "" {
return fmt.Errorf("bot_token is required")
}
botCtx, cancel := context.WithCancel(context.Background())
t.cancel = cancel
bot, err := tgbot.New(token, tgbot.WithDefaultHandler(
func(bCtx context.Context, b *tgbot.Bot, update *tgbot.Update) {
if update.Message == nil {
return
}
env := nebo.ChannelEnvelope{
MessageID: uuid.Must(uuid.NewV7()).String(),
ChannelID: fmt.Sprintf("telegram:%d", update.Message.Chat.ID),
Text: update.Message.Text,
Timestamp: time.Unix(int64(update.Message.Date), 0).UTC(),
}
t.messages <- env
},
))
if err != nil {
return err
}
t.bot = bot
go bot.Start(botCtx)
return nil
}
func (t *Telegram) Send(ctx context.Context, env nebo.ChannelEnvelope) (string, error) {
if t.bot == nil {
return "", fmt.Errorf("not connected")
}
chatID := env.ChannelID[len("telegram:"):]
params := &tgbot.SendMessageParams{
ChatID: chatID,
Text: env.Text,
}
msg, err := t.bot.SendMessage(ctx, params)
if err != nil {
return "", err
}
return fmt.Sprintf("%d", msg.MessageID), nil
}
func (t *Telegram) Receive(_ context.Context) (<-chan nebo.ChannelEnvelope, error) {
return t.messages, nil
}
func (t *Telegram) Disconnect(_ context.Context) error {
if t.cancel != nil {
t.cancel()
}
return nil
}
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterChannel(&Telegram{
messages: make(chan nebo.ChannelEnvelope, 100),
})
log.Fatal(app.Run())
} manifest.json:
{
"id": "com.example.telegram",
"name": "Telegram",
"version": "1.0.0",
"description": "Telegram messaging channel for Nebo",
"runtime": "local",
"protocol": "grpc",
"provides": ["channel:telegram"],
"permissions": ["channel:send", "network:outbound"],
"settings": [
{
"key": "bot_token",
"title": "Bot Token",
"type": "password",
"required": true,
"description": "Telegram bot token from @BotFather",
"secret": true
}
]
} ಇನ್ನಷ್ಟು ಸಾಮರ್ಥ್ಯಗಳು
Comm ಆ್ಯಪ್
"provides": ["comm"] ಮತ್ತು "permissions": ["comm:*"] ಘೋಷಿಸಿ. Comm ಆ್ಯಪ್ಗಳು AI ಉದ್ಯೋಗಿಗಳ ನಡುವೆ ಸಂವಹನವನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತವೆ.
| ಕ್ಷೇತ್ರ | ವಿವರಣೆ |
|---|---|
from | ಕಳುಹಿಸುವ ಉದ್ಯೋಗಿಯ ID |
to | ಸ್ವೀಕರಿಸುವ ಉದ್ಯೋಗಿಯ ID |
topic | ಸಂದೇಶದ ವಿಷಯ/ಚಾನೆಲ್ |
type | "message", "mention", "proposal", "command", "info", "task" |
content | ಸಂದೇಶದ ಮುಖ್ಯ ಭಾಗ |
ಮುಖ್ಯ ನಡವಳಿಕೆಗಳು:
Registerಈ AI ಉದ್ಯೋಗಿಯನ್ನು ಅದರ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ ನೆಟ್ವರ್ಕ್ನಲ್ಲಿ ಘೋಷಿಸುತ್ತದೆSubscribe/Unsubscribeವಿಷಯ ಚಂದಾದಾರಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆReceiveಒಳಬರುವ ಸಂದೇಶಗಳನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡುತ್ತದೆ (ಸರ್ವರ್-ಸ್ಟ್ರೀಮಿಂಗ್, ಚಾನೆಲ್ಗಳಂತೆಯೇ)- ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದೇ comm ಆ್ಯಪ್ ಸಕ್ರಿಯವಾಗಿರಬಹುದು
ಗೇಟ್ವೇ ಆ್ಯಪ್
ಗೇಟ್ವೇ ಆ್ಯಪ್ LLM ವಿನಂತಿಗಳನ್ನು ಮಾಡೆಲ್ಗಳಿಗೆ ಕಳುಹಿಸುತ್ತದೆ. "provides": ["gateway"] ಮತ್ತು "permissions": ["network:outbound", "user:token"] ಘೋಷಿಸಿ.
GatewayRequest ನಲ್ಲಿ ಸಂದೇಶಗಳು, ಪರಿಕರಗಳು, ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್, ಗರಿಷ್ಠ ಟೋಕನ್ಗಳು, ಟೆಂಪರೇಚರ್ ಮತ್ತು UserContext (user:token ಅನುಮತಿ ನೀಡಿದ್ದರೆ JWT ಟೋಕನ್) ಇರುತ್ತವೆ.
GatewayEvent ಪ್ರಕಾರಗಳು:
| ಪ್ರಕಾರ | ವಿಷಯ | ವಿವರಣೆ |
|---|---|---|
"text" | ಪಠ್ಯದ ತುಣುಕು | ಸ್ಟ್ರೀಮಿಂಗ್ ಪಠ್ಯ ಟೋಕನ್ |
"tool_call" | JSON | ಮಾಡೆಲ್ ಪರಿಕರವನ್ನು ಕರೆಯಲು ಬಯಸುತ್ತದೆ |
"thinking" | ಪಠ್ಯದ ತುಣುಕು | ವಿಸ್ತೃತ ಆಲೋಚನೆ/ತರ್ಕ |
"error" | ದೋಷ ಸಂದೇಶ | ಏನೋ ತಪ್ಪಾಗಿದೆ |
"done" | ಖಾಲಿ | ಸ್ಟ್ರೀಮ್ ಪೂರ್ಣಗೊಂಡಿದೆ |
UI ಆ್ಯಪ್
UI ಆ್ಯಪ್ Nebo ದ ಅಂತರ್ನಿರ್ಮಿತ ಬ್ರೌಸರ್ ವಿಂಡೋದಲ್ಲಿ ತೆರೆಯುವ ಕಸ್ಟಮ್ ಕಾನ್ಫಿಗರೇಶನ್ ಇಂಟರ್ಫೇಸ್ ಒದಗಿಸುತ್ತದೆ. "provides": ["ui"] ಘೋಷಿಸಿ. ಸ್ವಯಂಚಾಲಿತ ಸೆಟ್ಟಿಂಗ್ಗಳ ಫಾರ್ಮ್ಗಿಂತ ಭಿನ್ನವಾಗಿ (ಅದನ್ನು Nebo ನಿಮ್ಮ settings ಮ್ಯಾನಿಫೆಸ್ಟ್ನಿಂದ ರೆಂಡರ್ ಮಾಡುತ್ತದೆ), UI ಆ್ಯಪ್ ತನ್ನದೇ ಪೂರ್ಣ HTML/CSS/JS ಫ್ರಂಟ್ಎಂಡ್ ಒದಗಿಸುತ್ತದೆ.
ನಿಮ್ಮ ಆ್ಯಪ್ ಸ್ಥಿರ ವೆಬ್ ಆಸ್ತಿಗಳಿರುವ (HTML, CSS, JS — ಸಾಮಾನ್ಯವಾಗಿ index.html ಇರುವ SPA) ui/ ಡೈರೆಕ್ಟರಿಯೊಂದಿಗೆ ಬರುತ್ತದೆ. Nebo ಈ ಫೈಲ್ಗಳನ್ನು ನೇರವಾಗಿ ಒದಗಿಸುತ್ತದೆ ಮತ್ತು API ಕರೆಗಳನ್ನು gRPC ಮೂಲಕ ನಿಮ್ಮ ಆ್ಯಪ್ಗೆ ಪ್ರಾಕ್ಸಿ ಮಾಡುತ್ತದೆ.
| ಮಾರ್ಗ | ಕಾರ್ಯವಿಧಾನ | ಉದ್ದೇಶ |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | ಸ್ಥಿರ ಫೈಲ್ ಸರ್ವರ್ | ನಿಮ್ಮ ui/ ಡೈರೆಕ್ಟರಿಯಿಂದ ಫೈಲ್ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ (SPA ಗಾಗಿ index.html ಗೆ ಹಿಂದಿರುಗುತ್ತದೆ) |
ANY /api/v1/apps/{id}/api/* | gRPC ಪ್ರಾಕ್ಸಿ | HTTP ವಿನಂತಿಗಳನ್ನು ನಿಮ್ಮ ಆ್ಯಪ್ನ UIService.HandleRequest() ಗೆ ಪ್ರಾಕ್ಸಿ ಮಾಡುತ್ತದೆ |
SDK ಪ್ರಮಾಣಿತ net/http.ServeMux ಅನ್ನು ಸುತ್ತುವರಿಯುತ್ತದೆ, ಹಾಗಾಗಿ ನೀವು ಸಾಮಾನ್ಯ Go HTTP ಹ್ಯಾಂಡ್ಲರ್ಗಳನ್ನು ಬರೆಯುತ್ತೀರಿ — SDK gRPC ಸೇತುವೆಯನ್ನು ತಾನಾಗಿಯೇ ನಿಭಾಯಿಸುತ್ತದೆ.
Go ಉದಾಹರಣೆ — ಡ್ಯಾಶ್ಬೋರ್ಡ್ UI:
package main
import (
"encoding/json"
"log"
"net/http"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Dashboard struct {
mux *http.ServeMux
}
func NewDashboard() *Dashboard {
d := &Dashboard{mux: http.NewServeMux()}
d.mux.HandleFunc("GET /status", func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
})
d.mux.HandleFunc("POST /action", func(w http.ResponseWriter, r *http.Request) {
var req map[string]string
json.NewDecoder(r.Body).Decode(&req)
json.NewEncoder(w).Encode(map[string]string{"result": "done"})
})
return d
}
func (d *Dashboard) Handler() *http.ServeMux { return d.mux }
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterUI(NewDashboard())
log.Fatal(app.Run())
} ನಿಮ್ಮ ui/index.html /api/v1/apps/com.example.dashboard/api/status ಗೆ fetch ಕರೆಗಳನ್ನು ಮಾಡುತ್ತದೆ, ಅವು ನಿಮ್ಮ mux ಹ್ಯಾಂಡ್ಲರ್ಗೆ ಪ್ರಾಕ್ಸಿ ಆಗುತ್ತವೆ.
ವೇಳಾಪಟ್ಟಿ ಆ್ಯಪ್
ವೇಳಾಪಟ್ಟಿ ಆ್ಯಪ್ Nebo ದ ಅಂತರ್ನಿರ್ಮಿತ cron ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಬದಲಿಸುತ್ತದೆ. "provides": ["schedule"] ಮತ್ತು "permissions": ["schedule:create"] ಘೋಷಿಸಿ.
ನಿಮ್ಮ ವೇಳಾಪಟ್ಟಿ ಆ್ಯಪ್ ಆರಂಭವಾದಾಗ, Nebo ಪೂರ್ವನಿಯೋಜಿತ cron ಎಂಜಿನ್ ಬದಲು ಎಲ್ಲಾ ವೇಳಾಪಟ್ಟಿಯನ್ನು ನಿಮ್ಮ ಆ್ಯಪ್ ಮೂಲಕ ನಡೆಸುತ್ತದೆ. ನಿಮ್ಮ ಆ್ಯಪ್ ಕ್ರ್ಯಾಶ್ ಆದರೆ, Nebo ತಾನಾಗಿಯೇ ಅಂತರ್ನಿರ್ಮಿತ ಎಂಜಿನ್ಗೆ ಹಿಂದಿರುಗುತ್ತದೆ.
- ನಿಮ್ಮ ಆ್ಯಪ್ ವೇಳಾಪಟ್ಟಿಯ ಸ್ಥಿತಿಯ ಮಾಲೀಕ — ವೇಳಾಪಟ್ಟಿ ಆ್ಯಪ್ ಸಕ್ರಿಯವಾಗಿದ್ದಾಗ Nebo ತನ್ನದೇ DB ಯಲ್ಲಿ ವೇಳಾಪಟ್ಟಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ
- ಪ್ರಮಾಣಿತ CRUD:
Create,Get,List,Update,Delete,Enable,Disable Triggersಸರ್ವರ್-ಸ್ಟ್ರೀಮಿಂಗ್ RPC — ವೇಳಾಪಟ್ಟಿ ಚಾಲನೆಗೊಂಡಾಗಲೆಲ್ಲಾ ನಿಮ್ಮ ಆ್ಯಪ್ ಟ್ರಿಗರ್ ಸಂದೇಶ ಕಳುಹಿಸುತ್ತದೆ- ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದೇ ವೇಳಾಪಟ್ಟಿ ಆ್ಯಪ್ ಸಕ್ರಿಯವಾಗಿರಬಹುದು
ಬಹು-ಸಾಮರ್ಥ್ಯದ ಆ್ಯಪ್ಗಳು
ಒಂದು ಆ್ಯಪ್ ಹಲವು ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಒದಗಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪರಿಕರ ಮತ್ತು UI ಎರಡೂ ಇರುವ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಆ್ಯಪ್:
{
"id": "com.example.dashboard",
"name": "Dashboard",
"version": "1.0.0",
"provides": ["tool:dashboard_query", "ui"],
"permissions": ["network:outbound"]
} app, _ := nebo.New()
app.RegisterTool(&dashboardTool{})
app.RegisterUI(&dashboardUI{})
log.Fatal(app.Run()) ಪ್ಯಾಕೇಜಿಂಗ್
.napp ಸ್ವರೂಪ
NeboAI ಮೂಲಕ ವಿತರಣೆಗಾಗಿ, ನಿಮ್ಮ ಆ್ಯಪ್ ಅನ್ನು .napp ಫೈಲ್ ಆಗಿ (tar.gz ಆರ್ಕೈವ್) ಪ್ಯಾಕೇಜ್ ಮಾಡಿ:
cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md ಅಗತ್ಯ ಫೈಲ್ಗಳು:
| ಫೈಲ್ | ಗರಿಷ್ಠ ಗಾತ್ರ | ವಿವರಣೆ |
|---|---|---|
manifest.json | 1 MB | ಆ್ಯಪ್ ಮೆಟಾಡೇಟಾ |
binary ಅಥವಾ app | 500 MB | ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ |
signatures.json | 1 MB | Ed25519 ಸಹಿಗಳು |
TOOL.md | 1 MB | AI ಉದ್ಯೋಗಿಗಾಗಿ ಪರಿಕರ ಸೂಚನೆಗಳು |
ಹೊರತೆಗೆಯುವಾಗ ಸುರಕ್ಷತಾ ನಿಯಮಗಳು:
- ಮಾರ್ಗ ಅತಿಕ್ರಮಣ ಇಲ್ಲ (
../ತಿರಸ್ಕೃತ) - ಸಿಮ್ಲಿಂಕ್ಗಳು ಇಲ್ಲ (ತಿರಸ್ಕೃತ)
- ಸಂಪೂರ್ಣ ಮಾರ್ಗಗಳು ಇಲ್ಲ (ತಿರಸ್ಕೃತ)
- ಅನುಮತಿ ಪಟ್ಟಿಯಲ್ಲಿರುವ ಫೈಲ್ ಹೆಸರುಗಳು ಮಾತ್ರ ಸ್ವೀಕಾರ
ಸಹಿಗಳು
NeboAI ಆ್ಯಪ್ಗಳಿಗೆ Ed25519 ನಿಂದ ಸಹಿ ಮಾಡುತ್ತದೆ. signatures.json ಸ್ವರೂಪ:
{
"key_id": "a1b2c3d4",
"algorithm": "ed25519",
"manifest_signature": "<base64 signature of raw manifest.json bytes>",
"binary_sha256": "<hex SHA256 of binary>",
"binary_signature": "<base64 signature of raw binary bytes>"
} dev ಮೋಡ್ನಲ್ಲಿ (NeboAI URL ಕಾನ್ಫಿಗರ್ ಮಾಡದಿದ್ದಾಗ), ಸಹಿ ಪರಿಶೀಲನೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಿಟ್ಟುಬಿಡಲಾಗುತ್ತದೆ. ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿಗೆ ನಿಮಗೆ signatures.json ಬೇಕಿಲ್ಲ.
ಪ್ರಕಟಣೆ
ನಿಮ್ಮ ಆ್ಯಪ್ ಸ್ಥಳೀಯವಾಗಿ ಕೆಲಸ ಮಾಡಿದ ನಂತರ, ಎಲ್ಲಾ Nebo ಬಳಕೆದಾರರಿಗೆ ವಿತರಿಸಲು ಅದನ್ನು NeboAI ಮೂಲಕ ಪ್ರಕಟಿಸಿ.
ಡೆವಲಪರ್ ಖಾತೆ ಸೆಟಪ್
POST /api/v1/owners/registerನಲ್ಲಿ NeboAI ಖಾತೆ ನೋಂದಾಯಿಸಿ- JWT ಟೋಕನ್ ಪಡೆಯಲು ಲಾಗ್ ಇನ್ ಮಾಡಿ:
POST /api/v1/owners/login - ಡೆವಲಪರ್ ಖಾತೆ ರಚಿಸಿ:
POST /api/v1/developer/accounts
ಸಲ್ಲಿಕೆಯ ಪ್ರಕ್ರಿಯೆ
draft → pending_review → [approved] → published
→ [rejected] → draft (fix and resubmit) ಹಂತ 1: ಆ್ಯಪ್ ರಚಿಸಿ
curl -X POST https://neboai.com/api/v1/developer/apps \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"name": "My App",
"version": "1.0.0",
"description": "What it does",
"category": "productivity",
"visibility": "public"
}' ಹಂತ 2: ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಬೈನರಿಗಳನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಿ
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/binaries \
-H "Authorization: Bearer $TOKEN" \
-F "binary=@myapp-darwin-arm64" \
-F "platform=darwin-arm64" ಪ್ರತಿ ಪ್ಲಾಟ್ಫಾರ್ಮ್ಗೆ ಒಂದು ಬೈನರಿ ಅಪ್ಲೋಡ್ ಮಾಡಿ: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.
ಹಂತ 3: ಪರಿಶೀಲನೆಗೆ ಸಲ್ಲಿಸಿ
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
-H "Authorization: Bearer $TOKEN" ಪರಿಶೀಲನಾ ಪ್ರಕ್ರಿಯೆ
- ಸ್ವಯಂಚಾಲಿತ ಸ್ಕ್ಯಾನ್ — ಬೈನರಿಗಳನ್ನು VirusTotal ಮೂಲಕ ಸ್ಕ್ಯಾನ್ ಮಾಡಲಾಗುತ್ತದೆ
- ನಿರ್ವಾಹಕರ ಪರಿಶೀಲನೆ — NeboAI ತಂಡ ಮೆಟಾಡೇಟಾ, ಮ್ಯಾನಿಫೆಸ್ಟ್ ಮತ್ತು ಸ್ಕ್ಯಾನ್ ಫಲಿತಾಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ
- ಅನುಮೋದನೆಯಾದರೆ — NeboAI ಆ್ಯಪ್ಗೆ Ed25519 ನಿಂದ ಸಹಿ ಮಾಡಿ ಪ್ರಕಟಿಸುತ್ತದೆ
- ತಿರಸ್ಕೃತವಾದರೆ — ನಿಮಗೆ ಕಾರಣ ಸಿಗುತ್ತದೆ ಮತ್ತು ಸರಿಪಡಿಸಿ ಮತ್ತೆ ಸಲ್ಲಿಸಬಹುದು
ಗುರಿ ಪರಿಶೀಲನಾ ಸಮಯ: <24 ಗಂಟೆಗಳು.
ಅಪ್ಡೇಟ್ಗಳನ್ನು ಕಳುಹಿಸುವುದು
- ಆ್ಯಪ್ನ ಆವೃತ್ತಿಯನ್ನು ನವೀಕರಿಸಿ: ಹೊಸ ಆವೃತ್ತಿಯೊಂದಿಗೆ
PUT /api/v1/developer/apps/{id} - ಪ್ರತಿ ಪ್ಲಾಟ್ಫಾರ್ಮ್ಗೆ ಹೊಸ ಬೈನರಿಗಳನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಿ
- ಮತ್ತೆ ಪರಿಶೀಲನೆಗೆ ಸಲ್ಲಿಸಿ
ಪ್ರತಿ ಅಪ್ಡೇಟ್ ಅದೇ ಪರಿಶೀಲನಾ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ಹೋಗುತ್ತದೆ. ಹೊಸ ಆವೃತ್ತಿ ಅನುಮೋದನೆಯಾಗುವವರೆಗೆ ಹಿಂದಿನ ಆವೃತ್ತಿಗಳು ಲಭ್ಯವಿರುತ್ತವೆ.
ಸ್ಟೋರ್ ಮೆಟಾಡೇಟಾ
| ಕ್ಷೇತ್ರ | ವಿವರಣೆ |
|---|---|
category | ಉದಾ., productivity, communication, developer-tools |
icon | ಆ್ಯಪ್ ಐಕಾನ್ URL |
visibility | public ಅಥವಾ private |
description | ಮ್ಯಾನಿಫೆಸ್ಟ್ ವಿವರಣೆಗಿಂತ ಉದ್ದ/ಸಮೃದ್ಧವಾಗಿರಬಹುದು |
ಅಭಿವೃದ್ಧಿ ವರ್ಕ್ಫ್ಲೋ
ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿ
ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿಗೆ ಪ್ಯಾಕೇಜಿಂಗ್ ಅಗತ್ಯವಿಲ್ಲ:
- ನಿಮ್ಮ ಆ್ಯಪ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಿ:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - ನಿಮ್ಮ
manifest.jsonಮತ್ತು ಕೋಡ್ ಬರೆಯಿರಿ - ನಿಮ್ಮ ಬೈನರಿಯನ್ನು ಬಿಲ್ಡ್ ಮಾಡಿ:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo ಹೊಸ ಡೈರೆಕ್ಟರಿಯನ್ನು ತಾನಾಗಿಯೇ ಪತ್ತೆಹಚ್ಚುತ್ತದೆ (ಅಥವಾ Nebo ಮರುಪ್ರಾರಂಭಿಸಿ)
- ಕೋಡ್ ಬದಲಾವಣೆಗಳ ನಂತರ, ಬೈನರಿಯನ್ನು ಮರು-ಬಿಲ್ಡ್ ಮಾಡಿ — ಫೈಲ್ ವಾಚರ್ ಆ್ಯಪ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸುತ್ತದೆ
ಲಾಗ್ಗಳನ್ನು ನೋಡುವುದು
ಆ್ಯಪ್ನ stdout/stderr ಪ್ರತಿ ಆ್ಯಪ್ನ ಲಾಗ್ ಫೈಲ್ಗಳಲ್ಲಿ ದಾಖಲಾಗುತ್ತವೆ:
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stdout.log
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stderr.log ಶಾಶ್ವತ ಡೇಟಾ
ನಿಮ್ಮ ಆ್ಯಪ್ ಉಳಿಸಿಕೊಳ್ಳಬೇಕಾದ ಯಾವುದೇ ಫೈಲ್ಗಳಿಗೆ data/ ಡೈರೆಕ್ಟರಿಯನ್ನು ಬಳಸಿ (NEBO_APP_DATA env var ಆಗಿಯೂ ಲಭ್ಯ). ಈ ಡೈರೆಕ್ಟರಿ ಆ್ಯಪ್ ಅಪ್ಡೇಟ್ಗಳು ಮತ್ತು ಕ್ವಾರಂಟೈನ್ ನಂತರವೂ ಉಳಿಯುತ್ತದೆ.
ಡೀಬಗ್ಗಿಂಗ್ ಸಲಹೆಗಳು
- ನಿಮ್ಮ ಆ್ಯಪ್ ಆರಂಭವಾಗದಿದ್ದರೆ, ದೋಷಗಳಿಗಾಗಿ
logs/stderr.logಪರಿಶೀಲಿಸಿ - ಬೈನರಿ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಆಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ (
chmod +x binary) NEBO_APP_SOCKನಿಂದ ಬಂದ Unix ಸಾಕೆಟ್ ಮಾರ್ಗದಲ್ಲಿ ನೀವು ಆಲಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ- ಆರಂಭವಾದ 10 ಸೆಕೆಂಡುಗಳೊಳಗೆ ಸಾಕೆಟ್ ಸಿದ್ಧವಾಗಿರಬೇಕು
- ಸಂಗ್ರಹಣೆಗೆ ಹಾರ್ಡ್ಕೋಡ್ ಮಾಡಿದ ಮಾರ್ಗಗಳ ಬದಲು
NEBO_APP_DATAಬಳಸಿ - ಡೀಬಗ್ ಲಾಗಿಂಗ್ಗಾಗಿ stderr ಗೆ ಮುದ್ರಿಸಿ (
logs/stderr.logನಲ್ಲಿ ದಾಖಲಾಗುತ್ತದೆ)
ಪರಿಶೀಲನೆ
# List installed apps
nebo apps list
# Check running apps via the web UI Settings > Apps
# Or check the apps directory for running sockets
ls ~/Library/Application\ Support/Nebo/apps/*/app.sock ಅನ್ಇನ್ಸ್ಟಾಲ್ ಮಾಡುವುದು
nebo apps uninstall com.example.myapp ಸ್ಕಿಲ್ಗಳು
ಸ್ಕಿಲ್ಗಳು ಎಂದರೇನು
ಸ್ಕಿಲ್ಗಳು ಸಂಭಾಷಣೆಯ ಸಮಯದಲ್ಲಿ Nebo ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ರೂಪಿಸುವ ಸೂಚನಾ ಸೆಟ್ಗಳು. ಸ್ಕಿಲ್ ಸಕ್ರಿಯವಾಗಿದ್ದಾಗ, ಅದರ ವಿಷಯವನ್ನು ನೇರವಾಗಿ ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ — ಆ ಸೆಷನ್ನಲ್ಲಿ AI ಉದ್ಯೋಗಿಯ ಧಾಟಿ, ಕಾರ್ಯವಿಧಾನ, ಕ್ಷೇತ್ರ ಪರಿಣತಿ ಮತ್ತು ಪರಿಕರ ಬಳಕೆಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ.
ಸ್ಕಿಲ್ಗಳು ಕೋಡ್ ಅಲ್ಲ. ಅವು YAML ಮೆಟಾಡೇಟಾ ಇರುವ markdown ದಸ್ತಾವೇಜುಗಳು. ಕಂಪೈಲೇಶನ್ ಇಲ್ಲ, ಬೈನರಿ ಇಲ್ಲ, gRPC ಇಲ್ಲ. ಸ್ಕಿಲ್ ಎಂದರೆ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಒಂದು SKILL.md ಫೈಲ್. ಅಷ್ಟೇ.
ಸ್ಕಿಲ್ಗಳು ಸಂದರ್ಭೋಚಿತ ಮತ್ತು ತಾತ್ಕಾಲಿಕ. ಅವು ಪ್ರಸ್ತುತವಾದಾಗ ಸಕ್ರಿಯವಾಗುತ್ತವೆ (ಟ್ರಿಗರ್ ಹೊಂದಿಕೆ ಅಥವಾ ಕೈಯಾರೆ ಲೋಡ್ ಮೂಲಕ), ಕೆಲವು ಸರದಿಗಳವರೆಗೆ ಉಳಿಯುತ್ತವೆ, ಮತ್ತು ಅಗತ್ಯವಿಲ್ಲದಾಗ ಅವಧಿ ಮುಗಿಯುತ್ತವೆ. ಇದು AI ಉದ್ಯೋಗಿಯ ಸಂದರ್ಭವನ್ನು ಹಗುರವಾಗಿಡುತ್ತದೆ — ಈಗ ಮುಖ್ಯವಾದ ಮಾರ್ಗದರ್ಶನ ಮಾತ್ರ ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿರುತ್ತದೆ.
ಸ್ಕಿಲ್ಗಳು ಆ್ಯಪ್ಗಳಿಗೆ ಪೂರಕ. ಆ್ಯಪ್ಗಳು ಚಾಲನೀಯ ಸಾಮರ್ಥ್ಯಗಳನ್ನು (ಪರಿಕರಗಳು, ಚಾನೆಲ್ಗಳು, ಗೇಟ್ವೇಗಳು) ಒದಗಿಸುತ್ತವೆ. ಸ್ಕಿಲ್ಗಳು ಸಂಯೋಜನಾ ಮಾರ್ಗದರ್ಶನ ಒದಗಿಸುತ್ತವೆ — ಆ ಪರಿಕರಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ಬಳಸುವುದು. ಕ್ಯಾಲೆಂಡರ್ ಆ್ಯಪ್ Nebo ಗೆ ಈವೆಂಟ್ಗಳನ್ನು ಓದುವ ಮತ್ತು ಬರೆಯುವ ಸಾಮರ್ಥ್ಯ ನೀಡುತ್ತದೆ. "ಸಭೆ ತಯಾರಿ" ಸ್ಕಿಲ್ ಆ ಕ್ಯಾಲೆಂಡರ್ ಆ್ಯಪ್, ಇಮೇಲ್ ಮತ್ತು ವೆಬ್ ಹುಡುಕಾಟವನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸಿ ಸಭೆಗಳಿಗೆ ಹೇಗೆ ತಯಾರಾಗಬೇಕು ಎಂದು Nebo ಗೆ ಹೇಳುತ್ತದೆ.
ಸ್ಕಿಲ್ಗಳು ಮತ್ತು ಆ್ಯಪ್ಗಳು
| ಸ್ಕಿಲ್ಗಳು | ಆ್ಯಪ್ಗಳು | |
|---|---|---|
| ಸ್ವರೂಪ | 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 ಇರುತ್ತವೆ. ನಿಮ್ಮ ಪ್ಲಾಟ್ಫಾರ್ಮ್ಗೆ ತೋರಿಸುವ ಹೆಸರನ್ನು ರೂಪಿಸಲು ಇದನ್ನು ಬಳಸಿ. ಪಾತ್ರವು ಹುದ್ದೆಯ ಹೆಸರಲ್ಲ — ಅದು ಸಂಬಂಧದ ವಿವರಣೆ. "COO" ಮತ್ತು "DevLead" ಜೊತೆಗೆ "ಸ್ನೇಹಿತ", "ಮಗ" ಮತ್ತು "ಮಾರ್ಗದರ್ಶಕ" ಕೂಡ ಮಾನ್ಯ ಪಾತ್ರಗಳು.