NeboAI
NeboAI
ಪ್ರಾರಂಭಿಸಿ

ಆ್ಯಪ್ ಸೈಡ್‌ಕಾರ್

sidecar ಎಂದರೆ ಆ್ಯಪ್‌ನ ಪಕ್ಕದಲ್ಲಿ ನಡೆಯುವ ಬೈನರಿ. ಇದು ಪುಟದ API ಒದಗಿಸುತ್ತದೆ, ಆ್ಯಪ್‌ನ ಡೇಟಾ ಇಟ್ಟುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಆ್ಯಪ್‌ನ ಉದ್ಯೋಗಿಗೆ ಪರಿಕರಗಳನ್ನು ನೀಡುತ್ತದೆ. Nebo ಅದನ್ನು ಆರಂಭಿಸುತ್ತದೆ, ಸ್ಥಳೀಯ ಸಾಕೆಟ್ ಮೂಲಕ ವಿನಂತಿಗಳನ್ನು ಅದಕ್ಕೆ ಕಳುಹಿಸುತ್ತದೆ, ಮತ್ತು ವಿಫಲವಾದಾಗ ಮರುಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಒಪ್ಪಂದ

sidecar ಎಂದರೆ Unix ಸಾಕೆಟ್‌ನಲ್ಲಿರುವ gRPC ಸರ್ವರ್. NEBO_APP_SOCK ನಲ್ಲಿರುವ ಮಾರ್ಗದಲ್ಲಿ ಆಲಿಸಿ ಮತ್ತು apps.v0.UIService ಅನುಷ್ಠಾನಗೊಳಿಸಿ. Nebo ಪ್ರತಿ ವಿನಂತಿಗೂ HandleRequest ಕರೆಯುತ್ತದೆ; HealthCheck ಮತ್ತು Configure ಸೇವೆಯ ಭಾಗವಾಗಿವೆ ಆದರೆ ಇಂದು ಕರೆಯಲಾಗುವುದಿಲ್ಲ. ಸಾಕೆಟ್ ಮ್ಯಾನಿಫೆಸ್ಟ್‌ನ startup_timeout ಒಳಗೆ ಕಾಣಿಸಿಕೊಳ್ಳಬೇಕು, ಅದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ 10 ಸೆಕೆಂಡುಗಳು ಮತ್ತು ಗರಿಷ್ಠ 120 ಆಗಿರಬಹುದು.

syntax = "proto3";
package apps.v0;

service UIService {
  rpc HealthCheck(HealthCheckRequest) returns (HealthCheckResponse);
  rpc Configure(SettingsMap) returns (Empty);
  rpc HandleRequest(HttpRequest) returns (HttpResponse);
}

message HttpRequest {
  string method = 1;               // GET, POST, PUT, DELETE, ...
  string path = 2;                 // relative to /apps/{id}/api/
  string query = 3;                // raw query string
  map<string, string> headers = 4;
  bytes body = 5;
}

message HttpResponse {
  int32 status_code = 1;
  map<string, string> headers = 2;
  bytes body = 3;
}

Sidecar ಗಳು macOS ಮತ್ತು Linux ನಲ್ಲಿ ನಡೆಯುತ್ತವೆ.

Nebo ಬೈನರಿಯನ್ನು ಎಲ್ಲಿ ಹುಡುಕುತ್ತದೆ

ಆ್ಯಪ್‌ನ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ, ಇವುಗಳಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೊದಲನೆಯದನ್ನು Nebo ಬಳಸುತ್ತದೆ:

  1. binary ಎಂಬ ಹೆಸರಿನ ಫೈಲ್
  2. app ಎಂಬ ಹೆಸರಿನ ಫೈಲ್
  3. tmp/ ನಲ್ಲಿರುವ ಮೊದಲ ಫೈಲ್
  4. bin/ ನಲ್ಲಿರುವ ಮೊದಲ ಫೈಲ್
  5. ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿಗಾಗಿ, sidecar/target/release/ ನಲ್ಲಿರುವ ಮೊದಲ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್

ಬೈನರಿ ಸಾಮಾನ್ಯ, ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಫೈಲ್ ಆಗಿರಬೇಕು, ಸಾಂಕೇತಿಕ ಲಿಂಕ್ ಆಗಿರಬಾರದು, ಮತ್ತು ಗರಿಷ್ಠ 500 MB. ಪ್ರಕಟಿತ ಆ್ಯಪ್‌ಗಳು ಅದನ್ನು bin/<name> ನಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ. ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಫೈಲ್ ಬದಲಾದಾಗ, Nebo sidecar ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಪರಿಸರ

sidecar ಖಾಲಿ ಪರಿಸರ ಮತ್ತು ಈ ವೇರಿಯಬಲ್‌ಗಳೊಂದಿಗೆ ಆರಂಭವಾಗುತ್ತದೆ:

ವೇರಿಯಬಲ್ಮೌಲ್ಯ
NEBO_APP_ID, NEBO_APP_NAME, NEBO_APP_VERSIONಆ್ಯಪ್‌ನ ಗುರುತು.
NEBO_APP_DIRಆ್ಯಪ್‌ನ ಫೋಲ್ಡರ್.
NEBO_APP_SOCKಆಲಿಸಬೇಕಾದ ಸಾಕೆಟ್, <app folder>/<id>.sock. Nebo ಅದರ ಮೋಡ್ ಅನ್ನು 0600 ಗೆ ಹೊಂದಿಸುತ್ತದೆ.
NEBO_DATA_DIRಆ್ಯಪ್‌ನ ಡೇಟಾ ಫೋಲ್ಡರ್, <data>/appdata/agents/<id>/. ಕಾರ್ಯನಿರತ ಡೈರೆಕ್ಟರಿಯೂ ಇದೇ.
NEBO_API_URLಬಾಟ್‌ನ ಸ್ಥಳೀಯ API, http://127.0.0.1:<port>.
NEBO_APP_TOKENಬಾಟ್‌ನ ಆ್ಯಪ್ API ಕರೆಯಲು ಟೋಕನ್.
PATH, HOME, TMPDIR, LANG, LC_ALL, TZನೇರವಾಗಿ ರವಾನಿಸಲಾಗುತ್ತದೆ.

ಪ್ರಮಾಣಿತ ಔಟ್‌ಪುಟ್ ಮತ್ತು ಪ್ರಮಾಣಿತ ದೋಷ ಡೇಟಾ ಫೋಲ್ಡರ್‌ನಲ್ಲಿರುವ sidecar.log ಗೆ ಹೋಗುತ್ತವೆ. ಪ್ರಮಾಣಿತ ಇನ್‌ಪುಟ್ ಒಂದು ಪೈಪ್; ಫೈಲ್‌ನ ಅಂತ್ಯ ಎಂದರೆ Nebo ಹೋಗಿದೆ ಮತ್ತು sidecar ನಿರ್ಗಮಿಸಬೇಕು. sidecar ತನ್ನದೇ ಪ್ರೊಸೆಸ್ ಗ್ರೂಪ್‌ನಲ್ಲಿ ನಡೆಯುತ್ತದೆ.

ಪುಟದಿಂದ ವಿನಂತಿಗಳು

ಪುಟ neboFetch ಮತ್ತು ಸಾಪೇಕ್ಷ ಮಾರ್ಗದಿಂದ ಮಾಡುವ /apps/<id>/api/<path> ಗೆ ವಿನಂತಿ, path ಅನ್ನು <path> ಗೆ ಹೊಂದಿಸಿ HandleRequest ತಲುಪುತ್ತದೆ. _ ನಿಂದ ಆರಂಭವಾಗುವ ಮಾರ್ಗಗಳನ್ನು ನಿರಾಕರಿಸಲಾಗುತ್ತದೆ. ವಿನಂತಿಯ ಮುಖ್ಯ ಭಾಗ 10 MB ಗೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಗಳು 32 MB ಗೆ ಸೀಮಿತ.

ಉದ್ಯೋಗಿಗಾಗಿ ಪರಿಕರಗಳು

ಆ್ಯಪ್‌ನ agent.json ನಲ್ಲಿ ಪರಿಕರಗಳನ್ನು ಘೋಷಿಸಿ. ಪ್ರತಿಯೊಂದೂ app__<app>__<name> ಎಂಬ ಹೆಸರಿನ ಪರಿಕರವಾಗುತ್ತದೆ, ಉದ್ಯೋಗಿಗೆ ಬೇಕಾದಾಗ ಲೋಡ್ ಆಗುತ್ತದೆ. ಒಂದು ಕರೆ method ಮತ್ತು path ನಲ್ಲಿ sidecar ಗೆ ವಿನಂತಿಯಾಗುತ್ತದೆ.

"tools": [
  {
    "name": "list_deals",
    "description": "List open deals, optionally filtered by stage.",
    "method": "GET",
    "path": "/deals",
    "input_schema": { "type": "object", "properties": { "stage": { "type": "string" } } }
  }
]

Nebo ಅನ್ನು ಕರೆಯುವುದು

Authorization: Bearer $NEBO_APP_TOKEN ಹೆಡರ್‌ನೊಂದಿಗೆ $NEBO_API_URL/api/v1/apps/$NEBO_APP_ID/... ಕರೆಯುವ ಮೂಲಕ sidecar ಪುಟದಂತೆಯೇ ಅದೇ ಸೇವೆಗಳನ್ನು ಬಳಸಬಹುದು.

ಮಾರ್ಗಮಾಡುವುದು
GET /storage, GET|PUT|DELETE /storage/<key>ಆ್ಯಪ್‌ನ ಕೀ-ಮೌಲ್ಯ ಸಂಗ್ರಹ.
POST /agents/invoke, POST /agents/streamಉದ್ಯೋಗಿಯನ್ನು ಕೇಳುತ್ತದೆ: {message, agent, data}. ಸ್ಟ್ರೀಮ್ ಪ್ರತಿಕ್ರಿಯೆಗಳು server-sent events.
POST /janus/complete, POST /janus/streamನೇರ ಮಾಡೆಲ್ ಕರೆ: {messages, model, temperature, max_tokens, system}.
POST /http/proxyಆ್ಯಪ್‌ನ network: ಅನುಮತಿಗಳು ಅನುಮತಿಸುವ ಹೊರಗಿನ ವಿನಂತಿ, {url, method, headers, body}.
GET /identityಆ್ಯಪ್‌ನ ಉದ್ಯೋಗಿ.

ಜೀವನಚಕ್ರ

  • Nebo ಪ್ರತಿ ಮೂರು ಸೆಕೆಂಡುಗಳಿಗೊಮ್ಮೆ ಸಾಕೆಟ್ ಪರೀಕ್ಷಿಸುತ್ತದೆ.
  • ವಿಫಲವಾದ sidecar ಒಂದು ಸೆಕೆಂಡಿನ ನಂತರ ಮರುಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಗರಿಷ್ಠ 60 ಸೆಕೆಂಡುಗಳವರೆಗೆ ದ್ವಿಗುಣಗೊಳ್ಳುತ್ತದೆ. ಸತತ ಐದು ವೈಫಲ್ಯಗಳ ನಂತರ ಅದನ್ನು ವಿಫಲ ಎಂದು ಗುರುತಿಸಲಾಗುತ್ತದೆ. 60 ಸೆಕೆಂಡುಗಳ ಕಾಲ ಚಾಲನೆಯಲ್ಲಿರುವ sidecar ಮತ್ತೆ ಆರೋಗ್ಯಕರ.
  • ನಿಲ್ಲಿಸಿದ sidecar ಗೆ ಬರುವ ವಿನಂತಿ ಅದನ್ನು ಆರಂಭಿಸಿ 15 ಸೆಕೆಂಡುಗಳವರೆಗೆ ಕಾಯುತ್ತದೆ. GET ಮತ್ತು HEAD ವಿನಂತಿಗಳನ್ನು ಮರುಪ್ರಯತ್ನಿಸಲಾಗುತ್ತದೆ.
  • sidecar ನಿಲ್ಲಿಸಲು, Nebo ಅದರ ಪ್ರೊಸೆಸ್ ಗ್ರೂಪ್‌ಗೆ SIGTERM ಕಳುಹಿಸುತ್ತದೆ, ನಂತರ ಎರಡು ಸೆಕೆಂಡುಗಳ ಬಳಿಕ ಅದನ್ನು ಬಲವಂತವಾಗಿ ನಿಲ್ಲಿಸುತ್ತದೆ.