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. AI ಉದ್ಯೋಗಿ ನಿಮ್ಮ ಪರಿಕರವನ್ನು ಹೇಗೆ ಬಳಸಬೇಕು ಎಂದು ವಿವರಿಸುವ TOOL.md ಬರೆಯಿರಿ
  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:createCron ಜಾಬ್ ನಿರ್ವಹಣೆ
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 ಸ್ಕೋಪ್‌ಗಳ ಅರೇ

ಬಳಕೆದಾರರು ಆ್ಯಪ್ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದಾಗ, ಅಗತ್ಯ 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 ಸೆಕೆಂಡುಗಳವರೆಗೆ ಕಾಯುತ್ತದೆ.

ಆ್ಯಪ್ ಆರಂಭದ ಅನುಕ್ರಮ

  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) ಅನ್ನು ಕಡ್ಡಾಯವಾಗಿ ಬಳಸಬೇಕು. 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")

ಸ್ಕೀಮಾ ನಿಯಮಗಳು:

  1. ಯಾವಾಗಲೂ ಅಗತ್ಯ ಸ್ಟ್ರಿಂಗ್ enum ಆಗಿ action ಕ್ಷೇತ್ರವನ್ನು ಸೇರಿಸಿ
  2. ನಿಮ್ಮ ಪರಿಕರ ಹಲವು ವಿಭಿನ್ನ ಸಂಪನ್ಮೂಲ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ವಹಿಸಿದರೆ ಮಾತ್ರ resource ಕ್ಷೇತ್ರ (ಅಗತ್ಯ ಸ್ಟ್ರಿಂಗ್ 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 ನಲ್ಲಿ ಸಂದೇಶಗಳು, ಪರಿಕರಗಳು, ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್, ಗರಿಷ್ಠ ಟೋಕನ್‌ಗಳು, ಟೆಂಪರೇಚರ್ ಮತ್ತು 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.json1 MBಆ್ಯಪ್ ಮೆಟಾಡೇಟಾ
binary ಅಥವಾ app500 MBಎಕ್ಸಿಕ್ಯೂಟಬಲ್
signatures.json1 MBEd25519 ಸಹಿಗಳು
TOOL.md1 MBAI ಉದ್ಯೋಗಿಗಾಗಿ ಪರಿಕರ ಸೂಚನೆಗಳು

ಹೊರತೆಗೆಯುವಾಗ ಸುರಕ್ಷತಾ ನಿಯಮಗಳು:

  • ಮಾರ್ಗ ಅತಿಕ್ರಮಣ ಇಲ್ಲ (../ ತಿರಸ್ಕೃತ)
  • ಸಿಮ್‌ಲಿಂಕ್‌ಗಳು ಇಲ್ಲ (ತಿರಸ್ಕೃತ)
  • ಸಂಪೂರ್ಣ ಮಾರ್ಗಗಳು ಇಲ್ಲ (ತಿರಸ್ಕೃತ)
  • ಅನುಮತಿ ಪಟ್ಟಿಯಲ್ಲಿರುವ ಫೈಲ್ ಹೆಸರುಗಳು ಮಾತ್ರ ಸ್ವೀಕಾರ

ಸಹಿಗಳು

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 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")

ಉತ್ತಮ ಸ್ಕಿಲ್‌ಗಳನ್ನು ಬರೆಯುವುದು

ಉತ್ತಮ ಸ್ಕಿಲ್ ಟೆಂಪ್ಲೇಟ್‌ನಲ್ಲಿ ಇವು ಇರುತ್ತವೆ:

  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 ಪ್ರಕಾರಗಳು

ಸಂದೇಶ ಪ್ರಕಾರವಿವರಣೆ
ChannelSendRequestmessage_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" ಜೊತೆಗೆ "ಸ್ನೇಹಿತ", "ಮಗ" ಮತ್ತು "ಮಾರ್ಗದರ್ಶಕ" ಕೂಡ ಮಾನ್ಯ ಪಾತ್ರಗಳು.