NeboAI
NeboAI
ਸ਼ੁਰੂ ਕਰੋ

Nebo ਲਈ ਐਪਸ ਬਣਾਓ

ਆਪਣੇ AI ਨੂੰ ਨਵੀਆਂ ਸੁਪਰਪਾਵਰਾਂ ਦਿਓ। ਟੂਲ, ਚੈਨਲ, ਗੇਟਵੇ, UI ਪੈਨਲ — ਜੋ ਵੀ ਤੁਸੀਂ ਸੋਚ ਸਕਦੇ ਹੋ, ਨੇਟਿਵ ਬਾਈਨਰੀ ਵਿੱਚ ਕੰਪਾਈਲ ਕੀਤਾ ਹੋਇਆ।

ਸੰਖੇਪ ਜਾਣਕਾਰੀ

Nebo ਕੀ ਹੈ

Nebo ਇੱਕ ਨਿੱਜੀ ਡੈਸਕਟਾਪ AI ਸਹਾਇਕ ਹੈ — ਹਮੇਸ਼ਾ ਚੱਲਣ ਵਾਲਾ ਇੱਕ AI ਕਰਮਚਾਰੀ ਜੋ ਤੁਹਾਡੀ ਡਿਜੀਟਲ ਜ਼ਿੰਦਗੀ ਸੰਭਾਲਦਾ ਹੈ। Nebo ਬਾਰੇ ਉਸੇ ਤਰ੍ਹਾਂ ਸੋਚੋ ਜਿਵੇਂ ਤੁਸੀਂ ਸਮਾਰਟਫ਼ੋਨ ਬਾਰੇ ਸੋਚਦੇ ਹੋ: ਇੱਕ ਤਾਕਤਵਰ ਪਲੇਟਫ਼ਾਰਮ ਜੋ ਆਪਣੀਆਂ ਐਪਸ ਰਾਹੀਂ ਸਭ ਕੁਝ ਬਦਲ ਦਿੰਦਾ ਹੈ।

ਆਪਣੇ ਆਪ ਵਿੱਚ Nebo ਇੱਕ ਕਾਬਲ AI ਕਰਮਚਾਰੀ ਹੈ ਜਿਸ ਕੋਲ ਮੈਮੋਰੀ, ਸ਼ਡਿਊਲਿੰਗ, ਵੈੱਬ ਬ੍ਰਾਊਜ਼ਿੰਗ, ਫ਼ਾਈਲ ਪ੍ਰਬੰਧਨ ਅਤੇ ਸ਼ੈੱਲ ਪਹੁੰਚ ਹੈ। ਪਰ ਅਸਲ ਤਾਕਤ ਐਪਸ ਵਿੱਚ ਹੈ। ਜਿਵੇਂ ਸਮਾਰਟਫ਼ੋਨ ਦੀ ਤਾਕਤ ਉਸਦੇ ਐਪ ਈਕੋਸਿਸਟਮ ਤੋਂ ਆਉਂਦੀ ਹੈ, ਉਸੇ ਤਰ੍ਹਾਂ Nebo ਦੀ ਤਾਕਤ ਉਨ੍ਹਾਂ ਐਪਸ ਤੋਂ ਆਉਂਦੀ ਹੈ ਜੋ ਉਸਦੀ ਕਾਬਲੀਅਤ ਵਧਾਉਂਦੀਆਂ ਹਨ।

ਐਪਸ ਕੀ ਹਨ

Nebo ਐਪਸ ਆਪਣੇ ਆਪ ਵਿੱਚ ਪੂਰੀਆਂ, ਪਹਿਲਾਂ ਤੋਂ ਕੰਪਾਈਲ ਕੀਤੀਆਂ ਇਕਾਈਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਕਮਾਲ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਹੈ। ਹਰ ਐਪ Nebo ਨੂੰ ਇੱਕ ਨਵੀਂ ਸੁਪਰਪਾਵਰ ਦਿੰਦੀ ਹੈ — ਕੈਲੰਡਰ ਪ੍ਰਬੰਧਨ, ਈਮੇਲ ਛਾਂਟੀ, ਪ੍ਰੋਜੈਕਟ ਟ੍ਰੈਕਿੰਗ, ਘਰੇਲੂ ਆਟੋਮੇਸ਼ਨ, ਵਿੱਤੀ ਵਿਸ਼ਲੇਸ਼ਣ — ਜੋ ਵੀ ਕੋਈ ਡਿਵੈਲਪਰ ਸੋਚ ਸਕੇ।

ਐਪਸ ਬਹੁਤ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਕਮਾਲ ਦੀ ਤਾਕਤ ਦਿੰਦੀਆਂ ਹਨ। ਹਰ ਐਪ ਇੱਕ ਸੈਂਡਬਾਕਸ ਵਿੱਚ ਚੱਲਦੀ ਹੈ, ਜਿੱਥੇ ਇਜਾਜ਼ਤਾਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਬੰਦ ਹੁੰਦੀਆਂ ਹਨ। ਇਹ ਸਿਰਫ਼ ਉਸ ਤੱਕ ਪਹੁੰਚ ਸਕਦੀ ਹੈ ਜੋ ਇਸਦਾ ਮੈਨੀਫ਼ੈਸਟ ਐਲਾਨਦਾ ਹੈ ਅਤੇ ਵਰਤੋਂਕਾਰ ਮਨਜ਼ੂਰ ਕਰਦਾ ਹੈ।

ਇੰਟਰਫ਼ੇਸ 100% ਗੱਲਬਾਤ ਵਾਲਾ ਹੈ। ਵਰਤੋਂਕਾਰ ਵੱਖਰੀਆਂ ਸਕ੍ਰੀਨਾਂ ਜਾਂ ਡੈਸ਼ਬੋਰਡਾਂ ਰਾਹੀਂ ਐਪਸ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦੇ। ਉਹ Nebo ਨਾਲ ਗੱਲ ਕਰਦੇ ਹਨ, ਅਤੇ Nebo ਕੰਮ ਪੂਰੇ ਕਰਨ ਲਈ ਐਪ ਦੇ ਟੂਲ ਵਰਤਦਾ ਹੈ। "ਕੱਲ੍ਹ ਮੇਰੇ ਕੈਲੰਡਰ ’ਤੇ ਕੀ ਹੈ?" — Nebo ਕੈਲੰਡਰ ਐਪ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। "ਦੁਪਹਿਰ 3 ਵਜੇ Sarah ਨਾਲ ਮੀਟਿੰਗ ਬਣਾਓ" — Nebo ਕੈਲੰਡਰ ਐਪ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਵਰਤੋਂਕਾਰ ਕਦੇ ਗੱਲਬਾਤ ਤੋਂ ਬਾਹਰ ਨਹੀਂ ਜਾਂਦਾ।

ਐਪਸ ਚਾਹੁਣ ਤਾਂ ਇੱਕ ਸੈਟਿੰਗਾਂ UI ਵੀ ਦੇ ਸਕਦੀਆਂ ਹਨ — ਇੱਕ ਕੌਂਫ਼ਿਗਰੇਸ਼ਨ ਪੈਨਲ ਜੋ Nebo ਦੀ ਬਿਲਟ-ਇਨ ਬ੍ਰਾਊਜ਼ਰ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ। ਇੱਥੇ ਵਰਤੋਂਕਾਰ API ਕੁੰਜੀਆਂ ਦਰਜ ਕਰਦੇ ਹਨ, ਫ਼ੀਚਰ ਚਾਲੂ-ਬੰਦ ਕਰਦੇ ਹਨ ਅਤੇ ਐਪ ਨੂੰ ਕੌਂਫ਼ਿਗਰ ਕਰਦੇ ਹਨ। ਸੈਟਿੰਗਾਂ UI ਮੈਨੀਫ਼ੈਸਟ ਵਿਚਲੀ settings ਐਰੇ ਨਾਲ ਚੱਲਦਾ ਹੈ (Nebo ਫ਼ਾਰਮ ਆਪਣੇ ਆਪ ਬਣਾਉਂਦਾ ਹੈ), ਜਾਂ ਐਪ ui ਸਮਰੱਥਾ ਰਾਹੀਂ ਆਪਣਾ ਪੂਰਾ ਕਸਟਮ UI ਦੇ ਸਕਦੀ ਹੈ।

ਐਪਸ Nebo ਦੀਆਂ ਬਿਲਟ-ਇਨ ਸਮਰੱਥਾਵਾਂ ਦੀ ਥਾਂ ਲੈਂਦੀਆਂ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਵਧਾਉਂਦੀਆਂ ਹਨ। Nebo ਬੁਨਿਆਦੀ ਪਲੇਟਫ਼ਾਰਮ ਟੂਲਾਂ ਨਾਲ ਆਉਂਦਾ ਹੈ (ਲੋਕਲ ਕੈਲੰਡਰ ਪਹੁੰਚ, ਸਕ੍ਰੀਨਸ਼ਾਟ ਆਦਿ)। ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਕੈਲੰਡਰ ਐਪ ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ, ਉਹ ਬਿਲਟ-ਇਨ ਕੈਲੰਡਰ ਟੂਲ ਦੀ ਥਾਂ ਲੈ ਲੈਂਦੀ ਹੈ ਅਤੇ ਉਸ ਤੋਂ ਵੱਡਾ ਰੂਪ ਬਣ ਜਾਂਦੀ ਹੈ — ਲੋਕਲ + ਕਲਾਊਡ + ਇਕੱਠਾ ਕਰਨਾ + ਉਪਲਬਧਤਾ ਦੀ ਜਾਂਚ।

ਸਿਰਫ਼-ਕੰਪਾਈਲ ਨੀਤੀ

Nebo ਸਖ਼ਤੀ ਨਾਲ ਸਿਰਫ਼-ਕੰਪਾਈਲ ਬਾਈਨਰੀ ਨੀਤੀ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਸਾਰੀਆਂ ਐਪਸ ਨੇਟਿਵ ਕੰਪਾਈਲ ਕੀਤੀਆਂ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।

ਸਥਿਤੀਭਾਸ਼ਾਵਾਂ
ਸਮਰਥਿਤGo (ਸਿਫ਼ਾਰਸ਼ੀ), Rust, C/C++, Zig
ਨਾਮਨਜ਼ੂਰPython, Node.js, Ruby, Java, .NET, ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ

ਕਾਰਨ:

  • AI ਵੱਲੋਂ ਆਪਣੇ ਆਪ ਨੂੰ ਬਦਲਣ ਤੋਂ ਰੋਕ — ਸ਼ੈੱਲ ਪਹੁੰਚ ਵਾਲਾ AI ਕਰਮਚਾਰੀ ਚੱਲਦੇ ਸਮੇਂ ਕਿਸੇ ਇੰਟਰਪ੍ਰੈਟਿਡ ਸਕ੍ਰਿਪਟ ਦਾ ਵਿਹਾਰ ਬਦਲ ਸਕਦਾ ਹੈ। ਕੰਪਾਈਲ ਕੀਤੀਆਂ ਬਾਈਨਰੀਆਂ ਦਸਤਖ਼ਤ ਤੋਂ ਬਾਅਦ ਬਦਲੀਆਂ ਨਹੀਂ ਜਾ ਸਕਦੀਆਂ।
  • ਦਸਤਖ਼ਤ ਦੀ ਅਖੰਡਤਾ — Ed25519 ਦਸਤਖ਼ਤ ਕੱਚੇ ਬਾਈਨਰੀ ਬਾਈਟਾਂ ਨੂੰ ਕਵਰ ਕਰਦੇ ਹਨ। ਦਸਤਖ਼ਤ ਕੀਤੀ ਬਾਈਨਰੀ ਨੂੰ ਦਸਤਖ਼ਤ ਰੱਦ ਕੀਤੇ ਬਿਨਾਂ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ।
  • ਸੈਂਡਬਾਕਸ ਲਾਗੂ ਕਰਨਾ — ਬਾਈਨਰੀ ਫ਼ਾਰਮੈਟ ਦੀ ਪੁਸ਼ਟੀ (ELF/Mach-O/PE ਮੈਜਿਕ ਬਾਈਟ) ਇੱਕ ਤੇਜ਼ ਅਤੇ ਭਰੋਸੇਯੋਗ ਰੋਕ ਹੈ।

ਜਲਦੀ ਸ਼ੁਰੂਆਤ

SDK ਇੰਸਟਾਲ ਕਰੋ

ਅਧਿਕਾਰਤ SDK ਸਾਰਾ gRPC ਸਰਵਰ ਸੈੱਟਅੱਪ, ਸਿਗਨਲ ਹੈਂਡਲਿੰਗ ਅਤੇ ਪ੍ਰੋਟੋਕੋਲ ਬ੍ਰਿਜਿੰਗ ਸੰਭਾਲਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਹੈਂਡਲਰ ਇੰਟਰਫ਼ੇਸ ਲਾਗੂ ਕਰਨੇ ਪੈਂਦੇ ਹਨ।

Go (ਸਿਫ਼ਾਰਸ਼ੀ):

go get github.com/neboloop/nebo-sdk-go

Rust (ਜਲਦੀ ਆ ਰਿਹਾ ਹੈ):

# Coming soon
[dependencies]
nebo-sdk = "0.1"

C/C++ (ਜਲਦੀ ਆ ਰਿਹਾ ਹੈ):

# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/

ਐਪ ਡਾਇਰੈਕਟਰੀ ਢਾਂਚਾ

ਐਪਸ ਤੁਹਾਡੀ Nebo ਡਾਟਾ ਡਾਇਰੈਕਟਰੀ ਦੀ apps/ ਸਬ-ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਰਹਿੰਦੀਆਂ ਹਨ:

~/Library/Application Support/Nebo/apps/   # macOS
~/.config/nebo/apps/                        # Linux
%AppData%\Nebo\apps\                        # Windows

apps/
  com.example.myapp/
    manifest.json       # Required: app metadata
    binary              # Required: executable (or named "app")
    signatures.json     # Required for NeboAI distribution, optional in dev
    TOOL.md             # Required: tool instructions for the agent
    data/               # Auto-created: app's sandboxed storage
    logs/               # Auto-created: stdout.log, stderr.log
    ui/                 # Optional: static UI assets (HTML/CSS/JS)

ਘੱਟੋ-ਘੱਟ ਐਪ ਲਈ ਜਾਂਚ-ਸੂਚੀ

  1. id, name, version, provides ਨਾਲ manifest.json ਬਣਾਓ
  2. TOOL.md ਲਿਖੋ, ਜੋ ਦੱਸੇ ਕਿ AI ਕਰਮਚਾਰੀ ਤੁਹਾਡਾ ਟੂਲ ਕਿਵੇਂ ਵਰਤੇ
  3. SDK ਇੰਸਟਾਲ ਕਰੋ (go get github.com/neboloop/nebo-sdk-go)
  4. ਆਪਣੀ ਸਮਰੱਥਾ ਲਈ ਹੈਂਡਲਰ ਇੰਟਰਫ਼ੇਸ ਲਾਗੂ ਕਰੋ (ToolHandler, ChannelHandler ਆਦਿ)
  5. ਹੈਂਡਲਰ ਰਜਿਸਟਰ ਕਰੋ ਅਤੇ app.Run() ਕਾਲ ਕਰੋ
  6. ਨੇਟਿਵ ਬਾਈਨਰੀ ਬਣਾਓ (go build -o binary .)
  7. ਬਾਈਨਰੀ + manifest.json + TOOL.md ਨੂੰ apps/<your-app-id>/ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਰੱਖੋ
  8. Nebo ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਲੱਭ ਕੇ ਚਾਲੂ ਕਰ ਦਿੰਦਾ ਹੈ

ਕੌਂਫ਼ਿਗਰੇਸ਼ਨ

manifest.json

ਹਰ ਐਪ ਲਈ ਇੱਕ manifest.json ਲਾਜ਼ਮੀ ਹੈ:

{
    "id": "com.example.myapp",
    "name": "My App",
    "version": "1.0.0",
    "description": "What this app does",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["tool:my_tool"],
    "permissions": ["network:outbound"],
    "settings": [
        {
            "key": "api_key",
            "title": "API Key",
            "type": "password",
            "required": true,
            "description": "Your API key for the service",
            "secret": true
        }
    ]
}

ਲਾਜ਼ਮੀ ਖੇਤਰ:

ਖੇਤਰਵੇਰਵਾ
idਉਲਟ-ਡੋਮੇਨ ਪਛਾਣਕਰਤਾ (ਜਿਵੇਂ com.mycompany.myapp)
nameਪੜ੍ਹਨਯੋਗ ਨਾਮ
versionSemver ਸਤਰ
providesਘੱਟੋ-ਘੱਟ ਇੱਕ ਸਮਰੱਥਾ (ਹੇਠਾਂ ਵੇਖੋ)

ਵਿਕਲਪਿਕ ਖੇਤਰ:

ਖੇਤਰਡਿਫ਼ੌਲਟਵੇਰਵਾ
runtime"local""local" ਜਾਂ "remote"
protocol"grpc"ਸਿਰਫ਼ "grpc" ਸਮਰਥਿਤ ਹੈ
permissions[]ਐਪ ਨੂੰ ਕਿਸ ਚੀਜ਼ ਤੱਕ ਪਹੁੰਚ ਚਾਹੀਦੀ ਹੈ
description""UI ਵਿੱਚ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ
settings[]ਕੌਂਫ਼ਿਗਰ ਕਰਨਯੋਗ ਸੈਟਿੰਗਾਂ (ਸੈਟਿੰਗਾਂ UI ਵਿੱਚ ਦਿਖਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ)
oauth[]OAuth ਪ੍ਰਦਾਤਾ ਦੀਆਂ ਲੋੜਾਂ (ਹੇਠਾਂ OAuth ਭਾਗ ਵੇਖੋ)

ਸਮਰੱਥਾਵਾਂ

ਐਲਾਨ ਕਰੋ ਕਿ ਤੁਹਾਡੀ ਐਪ ਕੀ ਦਿੰਦੀ ਹੈ:

ਸਮਰੱਥਾgRPC ਸੇਵਾਵੇਰਵਾ
gatewayGatewayServiceLLM ਮਾਡਲ ਰੂਟਿੰਗ
tool:<name>ToolServiceAI ਕਰਮਚਾਰੀ ਲਈ ਇੱਕ ਨਾਮਿਤ ਟੂਲ
channel:<name>ChannelServiceਇੱਕ ਮੈਸੇਜਿੰਗ ਚੈਨਲ
commCommServiceAI ਕਰਮਚਾਰੀਆਂ ਵਿਚਕਾਰ ਸੰਚਾਰ
uiUIServiceHTTP ਪ੍ਰੌਕਸੀ ਨਾਲ ਕਸਟਮ UI
scheduleScheduleServiceਕਸਟਮ ਸ਼ਡਿਊਲਿੰਗ
visionToolServiceਵਿਜ਼ਨ ਪ੍ਰੋਸੈਸਿੰਗ
browserToolServiceਬ੍ਰਾਊਜ਼ਰ ਆਟੋਮੇਸ਼ਨ

ਇੱਕ ਐਪ ਕਈ ਸਮਰੱਥਾਵਾਂ ਦੇ ਸਕਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕੋਈ ਐਪ ਇੱਕ ਟੂਲ ਅਤੇ ਇੱਕ UI ਪੈਨਲ ਦੋਵੇਂ ਦੇ ਸਕਦੀ ਹੈ।

ਇਜਾਜ਼ਤਾਂ

ਇਜਾਜ਼ਤਾਂ ਤੈਅ ਕਰਦੀਆਂ ਹਨ ਕਿ ਐਪ ਕਿਸ ਚੀਜ਼ ਤੱਕ ਪਹੁੰਚ ਸਕਦੀ ਹੈ। ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਭ ਬੰਦ — ਜੇ ਐਲਾਨ ਨਹੀਂ ਕੀਤਾ, ਤਾਂ ਐਪ ਇਸਨੂੰ ਵਰਤ ਨਹੀਂ ਸਕਦੀ।

ਅਗੇਤਰਉਦਾਹਰਨਾਂਵੇਰਵਾ
network:network:outbound, network:*ਨੈੱਟਵਰਕ ਪਹੁੰਚ
filesystem:filesystem:read, filesystem:writeਫ਼ਾਈਲ ਸਿਸਟਮ ਪਹੁੰਚ
memory:memory:read, memory:writeAI ਕਰਮਚਾਰੀ ਦੀ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚ
session:session:readਗੱਲਬਾਤ ਸੈਸ਼ਨ
tool:tool:shell, tool:fileਹੋਰ ਟੂਲ ਵਰਤੋ
shell:shell:execਸ਼ੈੱਲ ਕਮਾਂਡ ਚਲਾਉਣਾ
channel:channel:send, channel:*ਚੈਨਲ ਕਾਰਵਾਈਆਂ
comm:comm:send, comm:*AI ਕਰਮਚਾਰੀਆਂ ਵਿਚਕਾਰ ਸੰਚਾਰ
model:model:chatAI ਮਾਡਲ ਪਹੁੰਚ
user:user:tokenਬੇਨਤੀਆਂ ਵਿੱਚ ਵਰਤੋਂਕਾਰ ਦਾ JWT ਪ੍ਰਾਪਤ ਕਰੋ
schedule:schedule:createਕ੍ਰੌਨ ਜੌਬ ਪ੍ਰਬੰਧਨ
database:database:queryਡਾਟਾਬੇਸ ਪਹੁੰਚ
storage:storage:read, storage:writeਸਥਾਈ ਸਟੋਰੇਜ
context:context:readAI ਕਰਮਚਾਰੀ ਦੇ ਸੰਦਰਭ ਤੱਕ ਪਹੁੰਚ
subagent:subagent:spawnਸਬ-ਏਜੰਟ ਕਾਰਵਾਈਆਂ
lane:lane:enqueueਲੇਨ ਕਾਰਵਾਈਆਂ
notification:notification:sendਪੁਸ਼ ਸੂਚਨਾਵਾਂ
embedding:embedding:searchਵੈਕਟਰ ਐਂਬੈਡਿੰਗ ਪਹੁੰਚ
skill:skill:invokeਸਕਿੱਲ ਚਲਾਉਣਾ
advisor:advisor:consultਸਲਾਹਕਾਰ ਸਿਸਟਮ ਪਹੁੰਚ
mcp:mcp:connectMCP ਸਰਵਰ ਪਹੁੰਚ
voice:voice:recordਆਵਾਜ਼/ਆਡੀਓ ਪਹੁੰਚ
browser:browser:navigateਬ੍ਰਾਊਜ਼ਰ ਆਟੋਮੇਸ਼ਨ
oauth:oauth:google, oauth:*OAuth ਟੋਕਨ ਪਹੁੰਚ
settings:settings:readਸੈਟਿੰਗਾਂ ਤੱਕ ਪਹੁੰਚ
capability:capability:registerਸਮਰੱਥਾ ਰਜਿਸਟ੍ਰੇਸ਼ਨ

ਵਾਈਲਡਕਾਰਡ ਇਜਾਜ਼ਤਾਂ ਸਮਰਥਿਤ ਹਨ: network:* ਕਿਸੇ ਵੀ network: ਇਜਾਜ਼ਤ ਜਾਂਚ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।

ਸੈਟਿੰਗਾਂ

ਸੈਟਿੰਗਾਂ Nebo UI ਵਿੱਚ ਐਪ ਦੇ ਸੈਟਿੰਗਾਂ ਪੈਨਲ ਹੇਠ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ। Nebo ਇਨ੍ਹਾਂ ਨੂੰ ਡਾਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ ਅਤੇ ਬਦਲਣ ’ਤੇ Configure RPC ਰਾਹੀਂ ਤੁਹਾਡੀ ਐਪ ਨੂੰ ਭੇਜਦਾ ਹੈ।

ਤੁਹਾਡਾ ਸੈਟਿੰਗਾਂ ਸਕੀਮਾ NeboAI ਐਪ ਸਟੋਰ ਦੀ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਜਿਨ੍ਹਾਂ ਐਪਸ ਦੀਆਂ ਲਾਜ਼ਮੀ ਸੈਟਿੰਗਾਂ ਕੌਂਫ਼ਿਗਰ ਨਹੀਂ ਹੋਈਆਂ, ਉਹ UI ਵਿੱਚ "ਸੈੱਟਅੱਪ ਦੀ ਲੋੜ" ਬੈਜ ਦਿਖਾਉਂਦੀਆਂ ਹਨ।

ਕਿਸਮਵੇਰਵਾ
textਇੱਕ-ਲਾਈਨ ਟੈਕਸਟ ਇਨਪੁੱਟ
passwordਲੁਕਿਆ ਹੋਇਆ ਟੈਕਸਟ ਇਨਪੁੱਟ
toggleਬੂਲੀਅਨ ਚਾਲੂ/ਬੰਦ ਸਵਿੱਚ
selectਪਹਿਲਾਂ ਤੋਂ ਤੈਅ ਵਿਕਲਪਾਂ ਵਾਲਾ ਡ੍ਰੌਪਡਾਊਨ
numberਸੰਖਿਆਤਮਕ ਇਨਪੁੱਟ
urlਪੁਸ਼ਟੀ ਵਾਲਾ URL ਇਨਪੁੱਟ
{
    "key": "region",
    "title": "Region",
    "type": "select",
    "required": true,
    "default": "us-east-1",
    "options": [
        {"label": "US East", "value": "us-east-1"},
        {"label": "EU West", "value": "eu-west-1"}
    ]
}

OAuth ਲੋੜਾਂ

ਐਪਸ OAuth ਪ੍ਰਦਾਤਾ ਦੀਆਂ ਲੋੜਾਂ ਐਲਾਨ ਸਕਦੀਆਂ ਹਨ। Nebo ਦਾ OAuth ਬ੍ਰੋਕਰ ਸਾਰਾ ਫ਼ਲੋ ਸੰਭਾਲਦਾ ਹੈ — ਐਪਸ ਨੂੰ Configure RPC ਰਾਹੀਂ ਟੋਕਨ ਆਪਣੇ ਆਪ ਮਿਲ ਜਾਂਦੇ ਹਨ।

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
ਖੇਤਰਵੇਰਵਾ
providerOAuth ਪ੍ਰਦਾਤਾ: "google", "microsoft", "github"
scopesਐਪ ਨੂੰ ਲੋੜੀਂਦੇ OAuth ਸਕੋਪਾਂ ਦੀ ਐਰੇ

ਜਦੋਂ ਵਰਤੋਂਕਾਰ ਐਪ ਇੰਸਟਾਲ ਕਰਦਾ ਹੈ, 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 ਸਕਿੰਟ ਤੱਕ ਉਡੀਕ ਕਰਦਾ ਹੈ।

ਐਪ ਚਾਲੂ ਹੋਣ ਦਾ ਕ੍ਰਮ

  1. Nebo manifest.json ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਉਸਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ
  2. ਐਪ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ binary ਜਾਂ app ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਲੱਭਦਾ ਹੈ
  3. .quarantined ਮਾਰਕਰ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ (ਕੁਆਰੰਟੀਨ ਕੀਤੀਆਂ ਐਪਸ ਚਾਲੂ ਕਰਨ ਤੋਂ ਇਨਕਾਰ ਕਰਦਾ ਹੈ)
  4. ਰੱਦ ਹੋਣ ਦੀ ਜਾਂਚ (ਸਿਰਫ਼ NeboAI ਵੱਲੋਂ ਵੰਡੀਆਂ ਐਪਸ ਲਈ)
  5. ਦਸਤਖ਼ਤ ਦੀ ਪੁਸ਼ਟੀ (ਸਿਰਫ਼ NeboAI ਵੱਲੋਂ ਵੰਡੀਆਂ ਐਪਸ ਲਈ, dev ਵਿੱਚ ਛੱਡ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ)
  6. ਬਾਈਨਰੀ ਦੀ ਪੁਸ਼ਟੀ (ਸਿਮਲਿੰਕ, ਸਕ੍ਰਿਪਟਾਂ, ਨਾ-ਚੱਲਣਯੋਗ ਅਤੇ ਹੱਦੋਂ ਵੱਡੀਆਂ ਫ਼ਾਈਲਾਂ ਨਾਮਨਜ਼ੂਰ ਕਰਦਾ ਹੈ)
  7. ਪਿਛਲੀ ਵਾਰ ਦਾ ਪੁਰਾਣਾ ਸਾਕਟ ਸਾਫ਼ ਕਰਦਾ ਹੈ
  8. ਸੈਂਡਬਾਕਸ ਸਟੋਰੇਜ ਲਈ data/ ਡਾਇਰੈਕਟਰੀ ਬਣਾਉਂਦਾ ਹੈ
  9. ਹਰ ਐਪ ਲਈ ਲੌਗ ਫ਼ਾਈਲਾਂ ਸੈੱਟ ਕਰਦਾ ਹੈ (logs/stdout.log, logs/stderr.log)
  10. ਸਾਫ਼ ਕੀਤੇ ਵਾਤਾਵਰਨ ਅਤੇ ਪ੍ਰੋਸੈਸ ਗਰੁੱਪ ਅਲੱਗਤਾ ਨਾਲ ਬਾਈਨਰੀ ਚਾਲੂ ਕਰਦਾ ਹੈ
  11. Unix ਸਾਕਟ ਦੇ ਦਿਖਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ (ਘਾਤਅੰਕੀ ਬੈਕਆਫ਼, ਵੱਧ ਤੋਂ ਵੱਧ 10 ਸਕਿੰਟ)
  12. Unix ਸਾਕਟ ਉੱਤੇ gRPC ਰਾਹੀਂ ਜੁੜਦਾ ਹੈ
  13. provides ਦੇ ਆਧਾਰ ’ਤੇ ਸਮਰੱਥਾ-ਵਿਸ਼ੇਸ਼ gRPC ਕਲਾਇੰਟ ਬਣਾਉਂਦਾ ਹੈ
  14. ਸਿਹਤ ਜਾਂਚ ਚਲਾਉਂਦਾ ਹੈ
  15. AI ਕਰਮਚਾਰੀ ਨਾਲ ਸਮਰੱਥਾਵਾਂ ਰਜਿਸਟਰ ਕਰਦਾ ਹੈ (ਟੂਲ, ਗੇਟਵੇ, comm ਆਦਿ)

ਟੂਲ ਐਪਸ

ਆਪਣੇ ਮੈਨੀਫ਼ੈਸਟ ਵਿੱਚ "provides": ["tool:my_tool_name"] ਐਲਾਨ ਕਰੋ।

STRAP ਪੈਟਰਨ

ਸਾਰੀਆਂ Nebo ਟੂਲ ਐਪਸ ਨੂੰ ਆਪਣੇ ਸਕੀਮਾ ਅਤੇ ਕਾਰਵਾਈ ਰੂਟਿੰਗ ਲਈ STRAP (Single Tool Resource Action Pattern) ਜ਼ਰੂਰ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਉਹੀ ਪੈਟਰਨ ਹੈ ਜੋ 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")

ਸਕੀਮਾ ਨਿਯਮ:

  1. ਹਮੇਸ਼ਾ ਇੱਕ action ਖੇਤਰ ਲਾਜ਼ਮੀ string enum ਵਜੋਂ ਸ਼ਾਮਲ ਕਰੋ
  2. resource ਖੇਤਰ (ਲਾਜ਼ਮੀ string enum) ਸਿਰਫ਼ ਤਾਂ ਜੋੜੋ ਜੇ ਤੁਹਾਡਾ ਟੂਲ ਕਈ ਵੱਖਰੀਆਂ ਸਰੋਤ ਕਿਸਮਾਂ ਸੰਭਾਲਦਾ ਹੈ
  3. ਬਾਕੀ ਸਾਰੇ ਖੇਤਰ ਕਾਰਵਾਈ-ਵਿਸ਼ੇਸ਼ ਪੈਰਾਮੀਟਰ ਹਨ
  4. action enum ਦੇ ਵੇਰਵੇ ਵਿੱਚ ਸਾਰੀਆਂ ਉਪਲਬਧ ਕਾਰਵਾਈਆਂ ਦੀ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ

STRAP ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ:

  • LLM action ਰੂਟਿੰਗ ਪੈਟਰਨ ਇੱਕ ਵਾਰ ਸਿੱਖ ਲੈਂਦੇ ਹਨ ਅਤੇ ਸਾਰੀਆਂ ਕਾਰਵਾਈਆਂ ’ਤੇ ਲਾਗੂ ਕਰਦੇ ਹਨ
  • ਟੂਲ ਪਰਿਭਾਸ਼ਾਵਾਂ ਲਗਭਗ 6% ਸੰਦਰਭ ਖਾ ਜਾਂਦੀਆਂ ਹਨ — STRAP ਇਸਨੂੰ 80% ਘਟਾ ਦਿੰਦਾ ਹੈ
  • ਨਵੀਆਂ ਕਾਰਵਾਈਆਂ ਸਿਰਫ਼ enum ਵਿੱਚ ਵਾਧਾ ਹਨ, ਨਵੀਆਂ ਟੂਲ ਰਜਿਸਟ੍ਰੇਸ਼ਨਾਂ ਨਹੀਂ
  • ਹੋਸਟ ਕੀਤੇ ਅਤੇ ਲੋਕਲ ਮਾਡਲਾਂ ’ਤੇ ਇੱਕੋ ਜਿਹਾ ਕੰਮ ਕਰਦਾ ਹੈ

Go ਉਦਾਹਰਨ — ਕੈਲਕੁਲੇਟਰ ਟੂਲ

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    nebo "github.com/neboloop/nebo-sdk-go"
)

type Calculator struct{}

func (c *Calculator) Name() string        { return "calculator" }
func (c *Calculator) Description() string { return "Performs arithmetic calculations." }

func (c *Calculator) Schema() json.RawMessage {
    return nebo.NewSchema("add", "subtract", "multiply", "divide").
        Number("a", "First operand", true).
        Number("b", "Second operand", true).
        Build()
}

func (c *Calculator) Execute(_ context.Context, input json.RawMessage) (string, error) {
    var in struct {
        Action string  `json:"action"`
        A      float64 `json:"a"`
        B      float64 `json:"b"`
    }
    if err := json.Unmarshal(input, &in); err != nil {
        return "", fmt.Errorf("invalid input: %w", err)
    }

    var result float64
    switch in.Action {
    case "add":
        result = in.A + in.B
    case "subtract":
        result = in.A - in.B
    case "multiply":
        result = in.A * in.B
    case "divide":
        if in.B == 0 {
            return "", fmt.Errorf("division by zero")
        }
        result = in.A / in.B
    default:
        return "", fmt.Errorf("unknown action: %s", in.Action)
    }

    return fmt.Sprintf("%g %s %g = %g", in.A, in.Action, in.B, result), nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterTool(&Calculator{})
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.calculator",
    "name": "Calculator",
    "version": "1.0.0",
    "description": "Arithmetic calculator tool for the agent",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["tool:calculator"],
    "permissions": []
}

ਬਣਾਓ ਅਤੇ ਇੰਸਟਾਲ ਕਰੋ:

go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/

Rust ਉਦਾਹਰਨ

use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;

struct Calculator;

#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }

#[async_trait]
impl ToolHandler for Calculator {
    fn name(&self) -> &str { "calculator" }
    fn description(&self) -> &str { "Performs arithmetic calculations." }
    fn schema(&self) -> Value {
        SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
            .number("a", "First operand", true)
            .number("b", "Second operand", true)
            .build()
    }
    async fn execute(&self, input: Value) -> Result<String, NeboError> {
        let i: Input = serde_json::from_value(input)
            .map_err(|e| NeboError::Execution(e.to_string()))?;
        let r = match i.action.as_str() {
            "add" => i.a + i.b,
            "subtract" => i.a - i.b,
            "multiply" => i.a * i.b,
            "divide" => {
                if i.b == 0.0 {
                    return Err(NeboError::Execution("division by zero".into()));
                }
                i.a / i.b
            }
            other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
        };
        Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    NeboApp::new()?.register_tool(Calculator).run().await?;
    Ok(())
}

C ਉਦਾਹਰਨ

#include <nebo/nebo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int calculator_execute(const char *input_json, char **output, int *is_error) {
    /* Parse JSON, compute result, set *output */
    *output = strdup("2 add 3 = 5");
    *is_error = 0;
    return 0;
}

int main(void) {
    const char *actions[] = {"add", "subtract", "multiply", "divide", NULL};
    nebo_schema_builder_t *sb = nebo_schema_new(actions);
    nebo_schema_number(sb, "a", "First operand", 1);
    nebo_schema_number(sb, "b", "Second operand", 1);
    char *schema = nebo_schema_build(sb);
    nebo_schema_free(sb);

    nebo_tool_handler_t calculator = {
        .name = "calculator",
        .description = "Performs arithmetic calculations.",
        .schema = schema,
        .execute = calculator_execute,
    };

    nebo_app_t *app = nebo_app_new();
    nebo_app_register_tool(app, &calculator);
    int ret = nebo_app_run(app);
    free(schema);
    return ret;
}

ਚੈਨਲ ਐਪਸ

"provides": ["channel:my_channel"] ਅਤੇ "permissions": ["channel:send"] ਐਲਾਨ ਕਰੋ।

ਚੈਨਲ ਐਪਸ ਬਾਹਰੀ ਮੈਸੇਜਿੰਗ ਪਲੇਟਫ਼ਾਰਮਾਂ (Telegram, Discord, Slack ਆਦਿ) ਨੂੰ Nebo ਦੇ AI ਕਰਮਚਾਰੀ ਨਾਲ ਜੋੜਦੀਆਂ ਹਨ। ਜਦੋਂ ਕੋਈ ਵਰਤੋਂਕਾਰ ਬਾਹਰੀ ਪਲੇਟਫ਼ਾਰਮ ’ਤੇ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ, ਤੁਹਾਡੀ ਐਪ ਉਸਨੂੰ Receive ਰਾਹੀਂ Nebo ਤੱਕ ਸਟ੍ਰੀਮ ਕਰਦੀ ਹੈ। ਜਦੋਂ AI ਕਰਮਚਾਰੀ ਜਵਾਬ ਦੇਣਾ ਚਾਹੁੰਦਾ ਹੈ, Nebo ਤੁਹਾਡੀ ਐਪ ਦਾ Send ਕਾਲ ਕਰਦਾ ਹੈ।

ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

  1. Nebo ਤੁਹਾਡੇ ਚੈਨਲ ਦਾ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਲੈਣ ਲਈ ID() ਕਾਲ ਕਰਦਾ ਹੈ
  2. Nebo ਤੁਹਾਡੀ ਐਪ ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਵਾਲੀ ਕੌਂਫ਼ਿਗ ਨਾਲ Connect() ਕਾਲ ਕਰਦਾ ਹੈ
  3. Nebo ਇੱਕ Receive() ਸਟ੍ਰੀਮ ਖੋਲ੍ਹਦਾ ਹੈ — ਜਦੋਂ ਵੀ ਕੋਈ ਵਰਤੋਂਕਾਰ ਬੋਟ ਨੂੰ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ, ਤੁਹਾਡੀ ਐਪ ਆਉਣ ਵਾਲੇ ਸੁਨੇਹੇ ਭੇਜਦੀ ਹੈ
  4. ਆਉਣ ਵਾਲੇ ਸੁਨੇਹੇ AI ਕਰਮਚਾਰੀ ਦੀ ਮੁੱਖ ਗੱਲਬਾਤ ਲੇਨ ਵੱਲ ਭੇਜੇ ਜਾਂਦੇ ਹਨ
  5. ਜਦੋਂ AI ਕਰਮਚਾਰੀ ਸੁਨੇਹਾ ਭੇਜਣਾ ਚਾਹੁੰਦਾ ਹੈ, Nebo v1 ਸੁਨੇਹਾ ਲਿਫ਼ਾਫ਼ੇ ਨਾਲ Send() ਕਾਲ ਕਰਦਾ ਹੈ
  6. ਬੰਦ ਹੋਣ ’ਤੇ, Nebo Disconnect() ਕਾਲ ਕਰਦਾ ਹੈ

v1 ਸੁਨੇਹਾ ਲਿਫ਼ਾਫ਼ਾ

ਸਾਰੇ ਚੈਨਲ ਸੁਨੇਹੇ — ਆਉਣ ਵਾਲੇ ਅਤੇ ਜਾਣ ਵਾਲੇ — ਸਾਂਝਾ ਸੁਨੇਹਾ ਲਿਫ਼ਾਫ਼ਾ ਵਰਤਦੇ ਹਨ:

{
  "message_id": "01953f8a-...",
  "channel_id": "telegram:12345",
  "sender": { "name": "Alex", "role": "COO", "bot_id": "uuid" },
  "text": "Q3 numbers look good...",
  "attachments": [{ "type": "image", "url": "https://...", "filename": "chart.png", "size": 45000 }],
  "reply_to": "01953f89-...",
  "actions": [{ "label": "Approve", "callback_id": "approve_q3" }],
  "platform_data": null,
  "timestamp": "2026-02-12T15:10:00Z"
}
ਖੇਤਰਕਿਸਮਵੇਰਵਾ
message_idUUID v7ਸਮੇਂ ਦੇ ਕ੍ਰਮ ਵਾਲੀ ਵਿਲੱਖਣ ID
channel_id{type}:{platform_id}ਰੂਟ ਕਰਨਯੋਗ ਚੈਨਲ ਪਛਾਣਕਰਤਾ
senderobjectਬੋਟ ਦੀ ਪਛਾਣ — ਨਾਮ, ਭੂਮਿਕਾ, botId
textstringਸੁਨੇਹੇ ਦੀ ਸਮੱਗਰੀ
attachmentsarrayਫ਼ਾਈਲਾਂ, ਤਸਵੀਰਾਂ, ਆਡੀਓ
reply_toUUID v7ਥ੍ਰੈਡਿੰਗ ਲਈ ਮੂਲ ਸੁਨੇਹੇ ਦੀ ID
actionsarrayਇੰਟਰੈਕਟਿਵ ਬਟਨ/ਕੀਬੋਰਡ
platform_databytesਪਲੇਟਫ਼ਾਰਮ-ਵਿਸ਼ੇਸ਼ ਫ਼ੀਚਰਾਂ ਲਈ ਬਿਨਾਂ ਬਦਲੇ ਅੱਗੇ ਭੇਜਿਆ ਜਾਣ ਵਾਲਾ ਡਾਟਾ
timestampISO 8601ਇਸਨੂੰ ਪ੍ਰਕਾਸ਼ਕ ਸੈੱਟ ਕਰਦਾ ਹੈ

ਦੋ-ਪਰਤੀ ਡਿਜ਼ਾਈਨ: ਸਾਂਝੇ ਖੇਤਰ (text, attachments, reply_to, actions) ਕਰਮਚਾਰੀ ਵੱਲੋਂ ਸ਼ੁਰੂ ਕੀਤੇ 90% ਸੁਨੇਹਿਆਂ ਨੂੰ ਕਵਰ ਕਰਦੇ ਹਨ। ਪਲੇਟਫ਼ਾਰਮ-ਵਿਸ਼ੇਸ਼ ਫ਼ੀਚਰ platform_data ਵਿੱਚ ਜਾਂਦੇ ਹਨ — ਤੁਹਾਡਾ ਪਲੱਗਇਨ ਉਨ੍ਹਾਂ ਨੂੰ ਪਲੇਟਫ਼ਾਰਮ ਦੇ ਨੇਟਿਵ ਫ਼ਾਰਮੈਟ ਵਿੱਚ ਅਤੇ ਉਸ ਤੋਂ ਬਦਲਦਾ ਹੈ।

ਗੱਲਬਾਤ ਸਟ੍ਰੀਮਾਂ

ਅਲੱਗਤਾ ਲਈ ਚੈਨਲ ਸੁਨੇਹੇ ਹਰ ਚੈਨਲ ਦੀ ਆਪਣੀ ਗੱਲਬਾਤ ਸਟ੍ਰੀਮ ਰਾਹੀਂ ਭੇਜੇ ਜਾਂਦੇ ਹਨ:

neboai/bot/{botID}/channels/{channelType}/inbound    # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound   # messages from agent → channel

Go ਉਦਾਹਰਨ — Telegram ਚੈਨਲ

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "time"

    "github.com/google/uuid"
    tgbot "github.com/go-telegram/bot"
    nebo "github.com/neboloop/nebo-sdk-go"
)

type Telegram struct {
    bot      *tgbot.Bot
    messages chan nebo.ChannelEnvelope
    cancel   context.CancelFunc
}

func (t *Telegram) ID() string { return "telegram" }

func (t *Telegram) Connect(_ context.Context, config map[string]string) error {
    token := config["bot_token"]
    if token == "" {
        return fmt.Errorf("bot_token is required")
    }

    botCtx, cancel := context.WithCancel(context.Background())
    t.cancel = cancel

    bot, err := tgbot.New(token, tgbot.WithDefaultHandler(
        func(bCtx context.Context, b *tgbot.Bot, update *tgbot.Update) {
            if update.Message == nil {
                return
            }
            env := nebo.ChannelEnvelope{
                MessageID: uuid.Must(uuid.NewV7()).String(),
                ChannelID: fmt.Sprintf("telegram:%d", update.Message.Chat.ID),
                Text:      update.Message.Text,
                Timestamp: time.Unix(int64(update.Message.Date), 0).UTC(),
            }
            t.messages <- env
        },
    ))
    if err != nil {
        return err
    }

    t.bot = bot
    go bot.Start(botCtx)
    return nil
}

func (t *Telegram) Send(ctx context.Context, env nebo.ChannelEnvelope) (string, error) {
    if t.bot == nil {
        return "", fmt.Errorf("not connected")
    }
    chatID := env.ChannelID[len("telegram:"):]
    params := &tgbot.SendMessageParams{
        ChatID: chatID,
        Text:   env.Text,
    }
    msg, err := t.bot.SendMessage(ctx, params)
    if err != nil {
        return "", err
    }
    return fmt.Sprintf("%d", msg.MessageID), nil
}

func (t *Telegram) Receive(_ context.Context) (<-chan nebo.ChannelEnvelope, error) {
    return t.messages, nil
}

func (t *Telegram) Disconnect(_ context.Context) error {
    if t.cancel != nil {
        t.cancel()
    }
    return nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterChannel(&Telegram{
        messages: make(chan nebo.ChannelEnvelope, 100),
    })
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.telegram",
    "name": "Telegram",
    "version": "1.0.0",
    "description": "Telegram messaging channel for Nebo",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["channel:telegram"],
    "permissions": ["channel:send", "network:outbound"],
    "settings": [
        {
            "key": "bot_token",
            "title": "Bot Token",
            "type": "password",
            "required": true,
            "description": "Telegram bot token from @BotFather",
            "secret": true
        }
    ]
}

ਹੋਰ ਸਮਰੱਥਾਵਾਂ

Comm ਐਪ

"provides": ["comm"] ਅਤੇ "permissions": ["comm:*"] ਐਲਾਨ ਕਰੋ। Comm ਐਪਸ AI ਕਰਮਚਾਰੀਆਂ ਵਿਚਕਾਰ ਸੰਚਾਰ ਸੰਭਵ ਬਣਾਉਂਦੀਆਂ ਹਨ।

ਖੇਤਰਵੇਰਵਾ
fromਭੇਜਣ ਵਾਲੇ ਕਰਮਚਾਰੀ ਦੀ ID
toਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਕਰਮਚਾਰੀ ਦੀ ID
topicਸੁਨੇਹੇ ਦਾ ਵਿਸ਼ਾ/ਚੈਨਲ
type"message", "mention", "proposal", "command", "info", "task"
contentਸੁਨੇਹੇ ਦੀ ਸਮੱਗਰੀ

ਮੁੱਖ ਵਿਹਾਰ:

  • Register ਇਸ AI ਕਰਮਚਾਰੀ ਨੂੰ ਉਸਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਸਮੇਤ ਨੈੱਟਵਰਕ ’ਤੇ ਐਲਾਨਦਾ ਹੈ
  • Subscribe/Unsubscribe ਵਿਸ਼ਿਆਂ ਦੀਆਂ ਸਬਸਕ੍ਰਿਪਸ਼ਨਾਂ ਸੰਭਾਲਦੇ ਹਨ
  • Receive ਆਉਣ ਵਾਲੇ ਸੁਨੇਹੇ ਸਟ੍ਰੀਮ ਕਰਦਾ ਹੈ (ਸਰਵਰ-ਸਟ੍ਰੀਮਿੰਗ, ਚੈਨਲਾਂ ਵਾਂਗ ਹੀ)
  • ਇੱਕ ਸਮੇਂ ਸਿਰਫ਼ ਇੱਕ comm ਐਪ ਸਰਗਰਮ ਹੋ ਸਕਦੀ ਹੈ

ਗੇਟਵੇ ਐਪ

ਗੇਟਵੇ ਐਪ LLM ਬੇਨਤੀਆਂ ਨੂੰ ਮਾਡਲਾਂ ਵੱਲ ਭੇਜਦੀ ਹੈ। "provides": ["gateway"] ਅਤੇ "permissions": ["network:outbound", "user:token"] ਐਲਾਨ ਕਰੋ।

GatewayRequest ਵਿੱਚ ਸੁਨੇਹੇ, ਟੂਲ, ਸਿਸਟਮ ਪ੍ਰੌਂਪਟ, ਵੱਧ ਤੋਂ ਵੱਧ ਟੋਕਨ, temperature ਅਤੇ ਇੱਕ UserContext ਹੁੰਦੇ ਹਨ (ਜੇ user:token ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਗਈ ਹੋਵੇ ਤਾਂ JWT ਟੋਕਨ)।

GatewayEvent ਕਿਸਮਾਂ:

ਕਿਸਮਸਮੱਗਰੀਵੇਰਵਾ
"text"ਟੈਕਸਟ ਦਾ ਟੁਕੜਾਸਟ੍ਰੀਮਿੰਗ ਟੈਕਸਟ ਟੋਕਨ
"tool_call"JSONਮਾਡਲ ਕੋਈ ਟੂਲ ਕਾਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ
"thinking"ਟੈਕਸਟ ਦਾ ਟੁਕੜਾਵਿਸਤ੍ਰਿਤ ਸੋਚ/ਤਰਕ
"error"ਗ਼ਲਤੀ ਦਾ ਸੁਨੇਹਾਕੁਝ ਗ਼ਲਤ ਹੋ ਗਿਆ
"done"ਖ਼ਾਲੀਸਟ੍ਰੀਮ ਪੂਰੀ ਹੋ ਗਈ ਹੈ

UI ਐਪ

UI ਐਪ ਇੱਕ ਕਸਟਮ ਕੌਂਫ਼ਿਗਰੇਸ਼ਨ ਇੰਟਰਫ਼ੇਸ ਦਿੰਦੀ ਹੈ ਜੋ Nebo ਦੀ ਬਿਲਟ-ਇਨ ਬ੍ਰਾਊਜ਼ਰ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ। "provides": ["ui"] ਐਲਾਨ ਕਰੋ। ਆਟੋਮੈਟਿਕ ਸੈਟਿੰਗਾਂ ਫ਼ਾਰਮ (ਜੋ Nebo ਤੁਹਾਡੇ settings ਮੈਨੀਫ਼ੈਸਟ ਤੋਂ ਬਣਾਉਂਦਾ ਹੈ) ਦੇ ਉਲਟ, UI ਐਪ ਆਪਣਾ ਪੂਰਾ HTML/CSS/JS ਫ਼੍ਰੰਟਐਂਡ ਦਿੰਦੀ ਹੈ।

ਤੁਹਾਡੀ ਐਪ ਇੱਕ 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.json1 MBਐਪ ਮੈਟਾਡਾਟਾ
binary ਜਾਂ app500 MBਐਗਜ਼ੀਕਿਊਟੇਬਲ
signatures.json1 MBEd25519 ਦਸਤਖ਼ਤ
TOOL.md1 MBAI ਕਰਮਚਾਰੀ ਲਈ ਟੂਲ ਹਦਾਇਤਾਂ

ਖੋਲ੍ਹਣ ਸਮੇਂ ਸੁਰੱਖਿਆ ਨਿਯਮ:

  • ਪਾਥ ਟ੍ਰੈਵਰਸਲ ਨਹੀਂ (../ ਨਾਮਨਜ਼ੂਰ)
  • ਸਿਮਲਿੰਕ ਨਹੀਂ (ਨਾਮਨਜ਼ੂਰ)
  • ਪੂਰੇ (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 ਰਾਹੀਂ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ।

ਡਿਵੈਲਪਰ ਖਾਤੇ ਦਾ ਸੈੱਟਅੱਪ

  1. POST /api/v1/owners/register ’ਤੇ NeboAI ਖਾਤਾ ਰਜਿਸਟਰ ਕਰੋ
  2. JWT ਟੋਕਨ ਲੈਣ ਲਈ ਲੌਗ ਇਨ ਕਰੋ: POST /api/v1/owners/login
  3. ਡਿਵੈਲਪਰ ਖਾਤਾ ਬਣਾਓ: POST /api/v1/developer/accounts

ਜਮ੍ਹਾਂ ਕਰਨ ਦਾ ਤਰੀਕਾ

draft → pending_review → [approved] → published
                       → [rejected] → draft (fix and resubmit)

ਕਦਮ 1: ਐਪ ਬਣਾਓ

curl -X POST https://neboai.com/api/v1/developer/apps \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My App",
    "version": "1.0.0",
    "description": "What it does",
    "category": "productivity",
    "visibility": "public"
  }'

ਕਦਮ 2: ਪਲੇਟਫ਼ਾਰਮ ਬਾਈਨਰੀਆਂ ਅੱਪਲੋਡ ਕਰੋ

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/binaries \
  -H "Authorization: Bearer $TOKEN" \
  -F "binary=@myapp-darwin-arm64" \
  -F "platform=darwin-arm64"

ਹਰ ਪਲੇਟਫ਼ਾਰਮ ਲਈ ਇੱਕ ਬਾਈਨਰੀ ਅੱਪਲੋਡ ਕਰੋ: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64।

ਕਦਮ 3: ਸਮੀਖਿਆ ਲਈ ਜਮ੍ਹਾਂ ਕਰੋ

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
  -H "Authorization: Bearer $TOKEN"

ਸਮੀਖਿਆ ਪ੍ਰਕਿਰਿਆ

  1. ਆਟੋਮੈਟਿਕ ਸਕੈਨ — ਬਾਈਨਰੀਆਂ VirusTotal ਰਾਹੀਂ ਸਕੈਨ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ
  2. ਐਡਮਿਨ ਸਮੀਖਿਆ — NeboAI ਟੀਮ ਮੈਟਾਡਾਟਾ, ਮੈਨੀਫ਼ੈਸਟ ਅਤੇ ਸਕੈਨ ਨਤੀਜਿਆਂ ਦੀ ਸਮੀਖਿਆ ਕਰਦੀ ਹੈ
  3. ਮਨਜ਼ੂਰੀ ’ਤੇ — NeboAI ਐਪ ’ਤੇ Ed25519 ਨਾਲ ਦਸਤਖ਼ਤ ਕਰਕੇ ਇਸਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦਾ ਹੈ
  4. ਨਾਮਨਜ਼ੂਰੀ ’ਤੇ — ਤੁਹਾਨੂੰ ਕਾਰਨ ਦੱਸਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਠੀਕ ਕਰਕੇ ਦੁਬਾਰਾ ਜਮ੍ਹਾਂ ਕਰ ਸਕਦੇ ਹੋ

ਸਮੀਖਿਆ ਦਾ ਟੀਚਾ ਸਮਾਂ: <24 ਘੰਟੇ।

ਅੱਪਡੇਟ ਭੇਜਣਾ

  1. ਐਪ ਦਾ ਵਰਜ਼ਨ ਅੱਪਡੇਟ ਕਰੋ: ਨਵੇਂ ਵਰਜ਼ਨ ਨਾਲ PUT /api/v1/developer/apps/{id}
  2. ਹਰ ਪਲੇਟਫ਼ਾਰਮ ਲਈ ਨਵੀਆਂ ਬਾਈਨਰੀਆਂ ਅੱਪਲੋਡ ਕਰੋ
  3. ਦੁਬਾਰਾ ਸਮੀਖਿਆ ਲਈ ਜਮ੍ਹਾਂ ਕਰੋ

ਹਰ ਅੱਪਡੇਟ ਉਸੇ ਸਮੀਖਿਆ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ। ਨਵਾਂ ਵਰਜਨ ਮਨਜ਼ੂਰ ਹੋਣ ਤੱਕ ਪਿਛਲੇ ਵਰਜਨ ਉਪਲਬਧ ਰਹਿੰਦੇ ਹਨ।

ਸਟੋਰ ਮੈਟਾਡਾਟਾ

ਖੇਤਰਵੇਰਵਾ
categoryਜਿਵੇਂ productivity, communication, developer-tools
iconਐਪ ਆਈਕਨ URL
visibilitypublic ਜਾਂ private
descriptionਮੈਨੀਫ਼ੈਸਟ ਦੇ ਵੇਰਵੇ ਨਾਲੋਂ ਲੰਮਾ/ਵਧੇਰੇ ਵਿਸਥਾਰ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ

ਡਿਵੈਲਪਮੈਂਟ ਵਰਕਫਲੋ

ਲੋਕਲ ਡਿਵੈਲਪਮੈਂਟ

ਲੋਕਲ ਡਿਵੈਲਪਮੈਂਟ ਲਈ ਪੈਕੇਜਿੰਗ ਦੀ ਲੋੜ ਨਹੀਂ:

  1. ਆਪਣੀ ਐਪ ਡਾਇਰੈਕਟਰੀ ਬਣਾਓ:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. ਆਪਣਾ manifest.json ਅਤੇ ਕੋਡ ਲਿਖੋ
  3. ਆਪਣੀ ਬਾਈਨਰੀ ਬਿਲਡ ਕਰੋ:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo ਨਵੀਂ ਡਾਇਰੈਕਟਰੀ ਆਪਣੇ ਆਪ ਪਛਾਣ ਲੈਂਦਾ ਹੈ (ਜਾਂ Nebo ਮੁੜ ਚਾਲੂ ਕਰੋ)
  5. ਕੋਡ ਬਦਲਣ ਤੋਂ ਬਾਅਦ ਬਾਈਨਰੀ ਦੁਬਾਰਾ ਬਣਾਓ — ਫ਼ਾਈਲ ਵਾਚਰ ਐਪ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰ ਦੇਵੇਗਾ

ਲੌਗ ਵੇਖਣਾ

ਐਪ ਦਾ stdout/stderr ਹਰ ਐਪ ਦੀਆਂ ਆਪਣੀਆਂ ਲੌਗ ਫ਼ਾਈਲਾਂ ਵਿੱਚ ਦਰਜ ਹੁੰਦਾ ਹੈ:

tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stdout.log
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stderr.log

ਸਥਾਈ ਡਾਟਾ

ਤੁਹਾਡੀ ਐਪ ਨੂੰ ਜੋ ਵੀ ਫ਼ਾਈਲਾਂ ਸੰਭਾਲ ਕੇ ਰੱਖਣੀਆਂ ਹਨ, ਉਨ੍ਹਾਂ ਲਈ data/ ਡਾਇਰੈਕਟਰੀ ਵਰਤੋ (ਜੋ NEBO_APP_DATA 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")

ਵਧੀਆ ਸਕਿੱਲਾਂ ਲਿਖਣਾ

ਇੱਕ ਵਧੀਆ ਸਕਿੱਲ ਟੈਂਪਲੇਟ ਵਿੱਚ ਇਹ ਹੁੰਦਾ ਹੈ:

  1. ਸਾਫ਼ ਸਿਰਲੇਖ — AI ਕਰਮਚਾਰੀ ਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਉਹ ਕਿਸ ਮੋਡ ਵਿੱਚ ਹੈ
  2. ਮੁੱਖ ਸਿਧਾਂਤ — ਵਿਹਾਰ ਦੇ ਅਟੱਲ ਨਿਯਮ
  3. ਕਾਰਜ-ਵਿਧੀ — ਆਮ ਹਾਲਾਤਾਂ ਲਈ ਕਦਮ-ਦਰ-ਕਦਮ ਤਰੀਕਾ
  4. ਉਦਾਹਰਨਾਂ — ਵਰਤੋਂਕਾਰ ਦੇ ਸੁਨੇਹੇ ਤੋਂ ਜਵਾਬ ਤੱਕ ਦੇ ਠੋਸ ਨਮੂਨੇ
  5. ਗ਼ਲਤ ਨਮੂਨੇ — ਕੀ ਨਹੀਂ ਕਰਨਾ (ਮਾਡਲ ਨਕਾਰਾਤਮਕ ਉਦਾਹਰਨਾਂ ਤੋਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਿੱਖਦੇ ਹਨ)

ਸੁਝਾਅ: ਹਰ ਸਕਿੱਲ ਇੱਕ ਕੰਮ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕਰੇ। "ਆਮ ਪ੍ਰੋਗਰਾਮਿੰਗ" ਸਕਿੱਲ ਨਾ ਬਣਾਓ — code-review, debugging, api-design ਵੱਖ-ਵੱਖ ਸਕਿੱਲਾਂ ਵਜੋਂ ਬਣਾਓ। AI ਕਰਮਚਾਰੀ ਕੋਲ ਇੱਕੋ ਸਮੇਂ ਕਈ ਸਕਿੱਲਾਂ ਸਰਗਰਮ ਹੋ ਸਕਦੀਆਂ ਹਨ।

ਨਾਲ ਆਉਣ ਵਾਲੀਆਂ ਸਕਿੱਲਾਂ

Nebo ਆਮ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਨਾਲ ਆਉਣ ਵਾਲੀਆਂ ਸਕਿੱਲਾਂ ਨਾਲ ਆਉਂਦਾ ਹੈ:

ਸਕਿੱਲਤਰਜੀਹਵੇਰਵਾ
onboarding100ਨਵੇਂ ਵਰਤੋਂਕਾਰ ਦਾ ਸਵਾਗਤ ਅਤੇ ਪ੍ਰੋਫ਼ਾਈਲ ਜਾਣਕਾਰੀ ਇਕੱਠੀ ਕਰਨਾ
best-friend50ਸ਼ਖ਼ਸੀਅਤ ਸਕਿੱਲ — ਸਹਿਜ, ਵਫ਼ਾਦਾਰ, ਸਿੱਧੀ ਗੱਲ
debugging25ਯੋਜਨਾਬੱਧ ਡੀਬੱਗਿੰਗ ਕਾਰਜ-ਵਿਧੀ
api-design15RESTful API ਡਿਜ਼ਾਈਨ ਦੇ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ
code-review10ਗੰਭੀਰਤਾ ਪੱਧਰਾਂ ਵਾਲੀ ਢਾਂਚਾਗਤ ਕੋਡ ਸਮੀਖਿਆ
database-expert10ਡਾਟਾਬੇਸ ਡਿਜ਼ਾਈਨ, ਕੁਐਰੀਆਂ, ਅਨੁਕੂਲਨ
git-workflow10Git ਬ੍ਰਾਂਚਿੰਗ, ਕਮਿਟ, PR ਵਰਕਫਲੋ
security-audit10ਸੁਰੱਖਿਆ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਪਛਾਣ

ਇਹ ਲਾਭਦਾਇਕ ਡਿਫ਼ੌਲਟ ਵੀ ਹਨ ਅਤੇ ਆਪਣੀਆਂ ਸਕਿੱਲਾਂ ਬਣਾਉਣ ਲਈ ਹਵਾਲਾ ਨਮੂਨੇ ਵੀ।

ਹਵਾਲਾ

Proto ਫ਼ਾਈਲਾਂ

Proto ਫ਼ਾਈਲਾਂ proto/apps/v0/ ਵਿੱਚ ਹਨ। SDK ਪਹਿਲਾਂ ਤੋਂ ਬਣੇ ਕੋਡ ਨਾਲ ਆਉਂਦੇ ਹਨ, ਇਸ ਲਈ ਆਮ ਡਿਵੈਲਪਮੈਂਟ ਲਈ ਤੁਹਾਨੂੰ protoc ਦੀ ਲੋੜ ਨਹੀਂ।

ਫ਼ਾਈਲਸੇਵਾਮੁੱਖ RPC
v0/common.proto(ਸਿਰਫ਼ ਸੁਨੇਹੇ)HealthCheckRequest/Response, SettingsMap, UserContext, Empty
v0/tool.protoToolServiceName, Description, Schema, Execute, RequiresApproval, Configure
v0/channel.protoChannelServiceID, Connect, Disconnect, Send, Receive (stream), Configure
v0/comm.protoCommServiceName, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure
v0/gateway.protoGatewayServiceHealthCheck, Stream (stream), Poll, Cancel, Configure
v0/ui.protoUIServiceHealthCheck, HandleRequest, Configure
v0/schedule.protoScheduleServiceHealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure

ਹਰ ਸੇਵਾ ਵਿੱਚ HealthCheck ਅਤੇ Configure RPC ਸ਼ਾਮਲ ਹਨ। SDK ਦੋਵੇਂ ਆਪਣੇ ਆਪ ਸੰਭਾਲਦਾ ਹੈ।

ਚੈਨਲ Proto ਕਿਸਮਾਂ

ਸੁਨੇਹੇ ਦੀ ਕਿਸਮਵੇਰਵਾ
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" ਵਾਂਗ ਜਾਇਜ਼ ਭੂਮਿਕਾਵਾਂ ਹਨ।