ਸੰਖੇਪ ਜਾਣਕਾਰੀ
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ਬਣਾਓTOOL.mdਲਿਖੋ, ਜੋ ਦੱਸੇ ਕਿ AI ਕਰਮਚਾਰੀ ਤੁਹਾਡਾ ਟੂਲ ਕਿਵੇਂ ਵਰਤੇ- SDK ਇੰਸਟਾਲ ਕਰੋ (
go get github.com/neboloop/nebo-sdk-go) - ਆਪਣੀ ਸਮਰੱਥਾ ਲਈ ਹੈਂਡਲਰ ਇੰਟਰਫ਼ੇਸ ਲਾਗੂ ਕਰੋ (
ToolHandler,ChannelHandlerਆਦਿ) - ਹੈਂਡਲਰ ਰਜਿਸਟਰ ਕਰੋ ਅਤੇ
app.Run()ਕਾਲ ਕਰੋ - ਨੇਟਿਵ ਬਾਈਨਰੀ ਬਣਾਓ (
go build -o binary .) - ਬਾਈਨਰੀ + manifest.json + TOOL.md ਨੂੰ
apps/<your-app-id>/ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਰੱਖੋ - Nebo ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਲੱਭ ਕੇ ਚਾਲੂ ਕਰ ਦਿੰਦਾ ਹੈ
ਕੌਂਫ਼ਿਗਰੇਸ਼ਨ
manifest.json
ਹਰ ਐਪ ਲਈ ਇੱਕ manifest.json ਲਾਜ਼ਮੀ ਹੈ:
{
"id": "com.example.myapp",
"name": "My App",
"version": "1.0.0",
"description": "What this app does",
"runtime": "local",
"protocol": "grpc",
"provides": ["tool:my_tool"],
"permissions": ["network:outbound"],
"settings": [
{
"key": "api_key",
"title": "API Key",
"type": "password",
"required": true,
"description": "Your API key for the service",
"secret": true
}
]
} ਲਾਜ਼ਮੀ ਖੇਤਰ:
| ਖੇਤਰ | ਵੇਰਵਾ |
|---|---|
id | ਉਲਟ-ਡੋਮੇਨ ਪਛਾਣਕਰਤਾ (ਜਿਵੇਂ com.mycompany.myapp) |
name | ਪੜ੍ਹਨਯੋਗ ਨਾਮ |
version | Semver ਸਤਰ |
provides | ਘੱਟੋ-ਘੱਟ ਇੱਕ ਸਮਰੱਥਾ (ਹੇਠਾਂ ਵੇਖੋ) |
ਵਿਕਲਪਿਕ ਖੇਤਰ:
| ਖੇਤਰ | ਡਿਫ਼ੌਲਟ | ਵੇਰਵਾ |
|---|---|---|
runtime | "local" | "local" ਜਾਂ "remote" |
protocol | "grpc" | ਸਿਰਫ਼ "grpc" ਸਮਰਥਿਤ ਹੈ |
permissions | [] | ਐਪ ਨੂੰ ਕਿਸ ਚੀਜ਼ ਤੱਕ ਪਹੁੰਚ ਚਾਹੀਦੀ ਹੈ |
description | "" | UI ਵਿੱਚ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ |
settings | [] | ਕੌਂਫ਼ਿਗਰ ਕਰਨਯੋਗ ਸੈਟਿੰਗਾਂ (ਸੈਟਿੰਗਾਂ UI ਵਿੱਚ ਦਿਖਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ) |
oauth | [] | OAuth ਪ੍ਰਦਾਤਾ ਦੀਆਂ ਲੋੜਾਂ (ਹੇਠਾਂ OAuth ਭਾਗ ਵੇਖੋ) |
ਸਮਰੱਥਾਵਾਂ
ਐਲਾਨ ਕਰੋ ਕਿ ਤੁਹਾਡੀ ਐਪ ਕੀ ਦਿੰਦੀ ਹੈ:
| ਸਮਰੱਥਾ | gRPC ਸੇਵਾ | ਵੇਰਵਾ |
|---|---|---|
gateway | GatewayService | LLM ਮਾਡਲ ਰੂਟਿੰਗ |
tool:<name> | ToolService | AI ਕਰਮਚਾਰੀ ਲਈ ਇੱਕ ਨਾਮਿਤ ਟੂਲ |
channel:<name> | ChannelService | ਇੱਕ ਮੈਸੇਜਿੰਗ ਚੈਨਲ |
comm | CommService | AI ਕਰਮਚਾਰੀਆਂ ਵਿਚਕਾਰ ਸੰਚਾਰ |
ui | UIService | HTTP ਪ੍ਰੌਕਸੀ ਨਾਲ ਕਸਟਮ UI |
schedule | ScheduleService | ਕਸਟਮ ਸ਼ਡਿਊਲਿੰਗ |
vision | ToolService | ਵਿਜ਼ਨ ਪ੍ਰੋਸੈਸਿੰਗ |
browser | ToolService | ਬ੍ਰਾਊਜ਼ਰ ਆਟੋਮੇਸ਼ਨ |
ਇੱਕ ਐਪ ਕਈ ਸਮਰੱਥਾਵਾਂ ਦੇ ਸਕਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕੋਈ ਐਪ ਇੱਕ ਟੂਲ ਅਤੇ ਇੱਕ UI ਪੈਨਲ ਦੋਵੇਂ ਦੇ ਸਕਦੀ ਹੈ।
ਇਜਾਜ਼ਤਾਂ
ਇਜਾਜ਼ਤਾਂ ਤੈਅ ਕਰਦੀਆਂ ਹਨ ਕਿ ਐਪ ਕਿਸ ਚੀਜ਼ ਤੱਕ ਪਹੁੰਚ ਸਕਦੀ ਹੈ। ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਭ ਬੰਦ — ਜੇ ਐਲਾਨ ਨਹੀਂ ਕੀਤਾ, ਤਾਂ ਐਪ ਇਸਨੂੰ ਵਰਤ ਨਹੀਂ ਸਕਦੀ।
| ਅਗੇਤਰ | ਉਦਾਹਰਨਾਂ | ਵੇਰਵਾ |
|---|---|---|
network: | network:outbound, network:* | ਨੈੱਟਵਰਕ ਪਹੁੰਚ |
filesystem: | filesystem:read, filesystem:write | ਫ਼ਾਈਲ ਸਿਸਟਮ ਪਹੁੰਚ |
memory: | memory:read, memory:write | AI ਕਰਮਚਾਰੀ ਦੀ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚ |
session: | session:read | ਗੱਲਬਾਤ ਸੈਸ਼ਨ |
tool: | tool:shell, tool:file | ਹੋਰ ਟੂਲ ਵਰਤੋ |
shell: | shell:exec | ਸ਼ੈੱਲ ਕਮਾਂਡ ਚਲਾਉਣਾ |
channel: | channel:send, channel:* | ਚੈਨਲ ਕਾਰਵਾਈਆਂ |
comm: | comm:send, comm:* | AI ਕਰਮਚਾਰੀਆਂ ਵਿਚਕਾਰ ਸੰਚਾਰ |
model: | model:chat | AI ਮਾਡਲ ਪਹੁੰਚ |
user: | user:token | ਬੇਨਤੀਆਂ ਵਿੱਚ ਵਰਤੋਂਕਾਰ ਦਾ JWT ਪ੍ਰਾਪਤ ਕਰੋ |
schedule: | schedule:create | ਕ੍ਰੌਨ ਜੌਬ ਪ੍ਰਬੰਧਨ |
database: | database:query | ਡਾਟਾਬੇਸ ਪਹੁੰਚ |
storage: | storage:read, storage:write | ਸਥਾਈ ਸਟੋਰੇਜ |
context: | context:read | AI ਕਰਮਚਾਰੀ ਦੇ ਸੰਦਰਭ ਤੱਕ ਪਹੁੰਚ |
subagent: | subagent:spawn | ਸਬ-ਏਜੰਟ ਕਾਰਵਾਈਆਂ |
lane: | lane:enqueue | ਲੇਨ ਕਾਰਵਾਈਆਂ |
notification: | notification:send | ਪੁਸ਼ ਸੂਚਨਾਵਾਂ |
embedding: | embedding:search | ਵੈਕਟਰ ਐਂਬੈਡਿੰਗ ਪਹੁੰਚ |
skill: | skill:invoke | ਸਕਿੱਲ ਚਲਾਉਣਾ |
advisor: | advisor:consult | ਸਲਾਹਕਾਰ ਸਿਸਟਮ ਪਹੁੰਚ |
mcp: | mcp:connect | MCP ਸਰਵਰ ਪਹੁੰਚ |
voice: | voice:record | ਆਵਾਜ਼/ਆਡੀਓ ਪਹੁੰਚ |
browser: | browser:navigate | ਬ੍ਰਾਊਜ਼ਰ ਆਟੋਮੇਸ਼ਨ |
oauth: | oauth:google, oauth:* | OAuth ਟੋਕਨ ਪਹੁੰਚ |
settings: | settings:read | ਸੈਟਿੰਗਾਂ ਤੱਕ ਪਹੁੰਚ |
capability: | capability:register | ਸਮਰੱਥਾ ਰਜਿਸਟ੍ਰੇਸ਼ਨ |
ਵਾਈਲਡਕਾਰਡ ਇਜਾਜ਼ਤਾਂ ਸਮਰਥਿਤ ਹਨ: network:* ਕਿਸੇ ਵੀ network: ਇਜਾਜ਼ਤ ਜਾਂਚ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
ਸੈਟਿੰਗਾਂ
ਸੈਟਿੰਗਾਂ Nebo UI ਵਿੱਚ ਐਪ ਦੇ ਸੈਟਿੰਗਾਂ ਪੈਨਲ ਹੇਠ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ। Nebo ਇਨ੍ਹਾਂ ਨੂੰ ਡਾਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ ਅਤੇ ਬਦਲਣ ’ਤੇ Configure RPC ਰਾਹੀਂ ਤੁਹਾਡੀ ਐਪ ਨੂੰ ਭੇਜਦਾ ਹੈ।
ਤੁਹਾਡਾ ਸੈਟਿੰਗਾਂ ਸਕੀਮਾ NeboAI ਐਪ ਸਟੋਰ ਦੀ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਜਿਨ੍ਹਾਂ ਐਪਸ ਦੀਆਂ ਲਾਜ਼ਮੀ ਸੈਟਿੰਗਾਂ ਕੌਂਫ਼ਿਗਰ ਨਹੀਂ ਹੋਈਆਂ, ਉਹ UI ਵਿੱਚ "ਸੈੱਟਅੱਪ ਦੀ ਲੋੜ" ਬੈਜ ਦਿਖਾਉਂਦੀਆਂ ਹਨ।
| ਕਿਸਮ | ਵੇਰਵਾ |
|---|---|
text | ਇੱਕ-ਲਾਈਨ ਟੈਕਸਟ ਇਨਪੁੱਟ |
password | ਲੁਕਿਆ ਹੋਇਆ ਟੈਕਸਟ ਇਨਪੁੱਟ |
toggle | ਬੂਲੀਅਨ ਚਾਲੂ/ਬੰਦ ਸਵਿੱਚ |
select | ਪਹਿਲਾਂ ਤੋਂ ਤੈਅ ਵਿਕਲਪਾਂ ਵਾਲਾ ਡ੍ਰੌਪਡਾਊਨ |
number | ਸੰਖਿਆਤਮਕ ਇਨਪੁੱਟ |
url | ਪੁਸ਼ਟੀ ਵਾਲਾ URL ਇਨਪੁੱਟ |
{
"key": "region",
"title": "Region",
"type": "select",
"required": true,
"default": "us-east-1",
"options": [
{"label": "US East", "value": "us-east-1"},
{"label": "EU West", "value": "eu-west-1"}
]
} OAuth ਲੋੜਾਂ
ਐਪਸ OAuth ਪ੍ਰਦਾਤਾ ਦੀਆਂ ਲੋੜਾਂ ਐਲਾਨ ਸਕਦੀਆਂ ਹਨ। Nebo ਦਾ OAuth ਬ੍ਰੋਕਰ ਸਾਰਾ ਫ਼ਲੋ ਸੰਭਾਲਦਾ ਹੈ — ਐਪਸ ਨੂੰ Configure RPC ਰਾਹੀਂ ਟੋਕਨ ਆਪਣੇ ਆਪ ਮਿਲ ਜਾਂਦੇ ਹਨ।
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | ਖੇਤਰ | ਵੇਰਵਾ |
|---|---|
provider | OAuth ਪ੍ਰਦਾਤਾ: "google", "microsoft", "github" |
scopes | ਐਪ ਨੂੰ ਲੋੜੀਂਦੇ OAuth ਸਕੋਪਾਂ ਦੀ ਐਰੇ |
ਜਦੋਂ ਵਰਤੋਂਕਾਰ ਐਪ ਇੰਸਟਾਲ ਕਰਦਾ ਹੈ, Nebo ਉਸਨੂੰ ਲੋੜੀਂਦੇ OAuth ਸਕੋਪ ਅਧਿਕਾਰਤ ਕਰਨ ਲਈ ਕਹਿੰਦਾ ਹੈ। ਐਪ ਨੂੰ 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) ਜ਼ਰੂਰ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਉਹੀ ਪੈਟਰਨ ਹੈ ਜੋ Nebo ਅੰਦਰੂਨੀ ਤੌਰ ’ਤੇ 35+ ਵੱਖ-ਵੱਖ ਟੂਲਾਂ ਨੂੰ 4 ਡੋਮੇਨ ਟੂਲਾਂ ਵਿੱਚ ਇਕੱਠਾ ਕਰਨ ਲਈ ਵਰਤਦਾ ਹੈ — ਜਿਸ ਨਾਲ 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") ਸਕੀਮਾ ਨਿਯਮ:
- ਹਮੇਸ਼ਾ ਇੱਕ
actionਖੇਤਰ ਲਾਜ਼ਮੀ string enum ਵਜੋਂ ਸ਼ਾਮਲ ਕਰੋ 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 | ਬੋਟ ਦੀ ਪਛਾਣ — ਨਾਮ, ਭੂਮਿਕਾ, 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 ਫ਼੍ਰੰਟਐਂਡ ਦਿੰਦੀ ਹੈ।
ਤੁਹਾਡੀ ਐਪ ਇੱਕ ui/ ਡਾਇਰੈਕਟਰੀ ਨਾਲ ਆਉਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਸਥਿਰ ਵੈੱਬ ਫ਼ਾਈਲਾਂ ਹੁੰਦੀਆਂ ਹਨ (HTML, CSS, JS — ਆਮ ਤੌਰ ’ਤੇ index.html ਵਾਲਾ ਇੱਕ SPA)। 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"] ਐਲਾਨ ਕਰੋ।
ਜਦੋਂ ਤੁਹਾਡੀ ਸ਼ਡਿਊਲ ਐਪ ਚਾਲੂ ਹੁੰਦੀ ਹੈ, 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 ਕਰਮਚਾਰੀ ਲਈ ਟੂਲ ਹਦਾਇਤਾਂ |
ਖੋਲ੍ਹਣ ਸਮੇਂ ਸੁਰੱਖਿਆ ਨਿਯਮ:
- ਪਾਥ ਟ੍ਰੈਵਰਸਲ ਨਹੀਂ (
../ਨਾਮਨਜ਼ੂਰ) - ਸਿਮਲਿੰਕ ਨਹੀਂ (ਨਾਮਨਜ਼ੂਰ)
- ਪੂਰੇ (absolute) ਪਾਥ ਨਹੀਂ (ਨਾਮਨਜ਼ੂਰ)
- ਸਿਰਫ਼ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਸੂਚੀ ਵਾਲੇ ਫ਼ਾਈਲ ਨਾਮ ਹੀ ਸਵੀਕਾਰ ਹੁੰਦੇ ਹਨ
ਦਸਤਖ਼ਤ
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 ਵੇਰੀਏਬਲ ਵਜੋਂ ਵੀ ਉਪਲਬਧ ਹੈ)। ਇਹ ਡਾਇਰੈਕਟਰੀ ਐਪ ਅੱਪਡੇਟਾਂ ਅਤੇ ਕੁਆਰੰਟੀਨ ਤੋਂ ਬਾਅਦ ਵੀ ਬਚੀ ਰਹਿੰਦੀ ਹੈ।
ਡੀਬੱਗਿੰਗ ਸੁਝਾਅ
- ਜੇ ਤੁਹਾਡੀ ਐਪ ਚਾਲੂ ਨਹੀਂ ਹੁੰਦੀ, ਤਾਂ ਗ਼ਲਤੀਆਂ ਲਈ
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" ਵਾਂਗ ਜਾਇਜ਼ ਭੂਮਿਕਾਵਾਂ ਹਨ।