NeboAI
NeboAI
ప్రారంభించండి

App సైడ్‌కార్

సైడ్‌కార్ అంటే ఒక యాప్ పక్కన నడిచే బైనరీ. ఇది పేజీ APIని అందిస్తుంది, యాప్ డేటాను ఉంచుతుంది, యాప్ ఉద్యోగికి టూల్స్ ఇస్తుంది. Nebo దాన్ని ప్రారంభిస్తుంది, లోకల్ సాకెట్ ద్వారా దానికి అభ్యర్థనలను మళ్ళిస్తుంది, అది విఫలమైనప్పుడు రీస్టార్ట్ చేస్తుంది.

ఒప్పందం

సైడ్‌కార్ అంటే 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;
}

సైడ్‌కార్‌లు macOS, Linuxలో నడుస్తాయి.

Nebo బైనరీని ఎక్కడ కనుగొంటుంది

యాప్ ఫోల్డర్‌లో, వీటిలో ముందుగా ఉన్నదాన్ని Nebo ఉపయోగిస్తుంది:

  1. binary అనే పేరు ఉన్న ఫైల్
  2. app అనే పేరు ఉన్న ఫైల్
  3. tmp/లోని మొదటి ఫైల్
  4. bin/లోని మొదటి ఫైల్
  5. లోకల్ డెవలప్‌మెంట్ కోసం, sidecar/target/release/లోని మొదటి ఎగ్జిక్యూటబుల్

బైనరీ సింబాలిక్ లింక్ కాకుండా, సాధారణ, ఎగ్జిక్యూటబుల్ ఫైల్ అయి ఉండాలి, గరిష్ఠంగా 500 MB. ప్రచురించిన యాప్‌లు దాన్ని bin/<name> వద్ద ఉంచుతాయి. డిస్క్‌పై ఫైల్ మారినప్పుడు, Nebo సైడ్‌కార్‌ను రీస్టార్ట్ చేస్తుంది.

ఎన్విరాన్‌మెంట్

సైడ్‌కార్ ఖాళీ ఎన్విరాన్‌మెంట్, ఈ వేరియబుల్స్‌తో ప్రారంభమవుతుంది:

వేరియబుల్విలువ
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 వెళ్ళిపోయింది, సైడ్‌కార్ నిష్క్రమించాలి. సైడ్‌కార్ తన సొంత ప్రాసెస్ గ్రూప్‌లో నడుస్తుంది.

పేజీ నుండి అభ్యర్థనలు

పేజీ neboFetch, సాపేక్ష పాత్‌తో చేసే /apps/<id>/api/<path>కి అభ్యర్థన, pathను <path>కి సెట్ చేసి HandleRequestను చేరుతుంది. _తో ప్రారంభమయ్యే పాత్‌లు తిరస్కరించబడతాయి. అభ్యర్థన బాడీలు 10 MBకి, ప్రతిస్పందనలు 32 MBకి పరిమితం.

ఉద్యోగి కోసం టూల్స్

యాప్ agent.jsonలో టూల్స్‌ను ప్రకటించండి. ప్రతిదీ app__<app>__<name> అనే పేరున్న టూల్‌గా మారుతుంది, ఉద్యోగికి అవసరమైనప్పుడు లోడ్ అవుతుంది. ఒక కాల్ method, path వద్ద సైడ్‌కార్‌కు అభ్యర్థనగా మారుతుంది.

"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/...ని పిలిచి సైడ్‌కార్ పేజీ ఉపయోగించే అవే సేవలను ఉపయోగించవచ్చు.

రూట్చేసేది
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 ప్రతి మూడు సెకన్లకు సాకెట్‌ను పరీక్షిస్తుంది.
  • విఫలమైన సైడ్‌కార్ ఒక సెకను తర్వాత రీస్టార్ట్ అవుతుంది, ఆ సమయం రెట్టింపు అవుతూ గరిష్ఠంగా 60 సెకన్ల వరకు. వరుసగా ఐదు వైఫల్యాల తర్వాత అది విఫలమైనదిగా గుర్తించబడుతుంది. 60 సెకన్లు నడుస్తూ ఉన్న సైడ్‌కార్ మళ్ళీ ఆరోగ్యంగా ఉన్నట్లు.
  • ఆగిపోయిన సైడ్‌కార్‌కు వచ్చే అభ్యర్థన దాన్ని ప్రారంభించి గరిష్ఠంగా 15 సెకన్లు వేచి ఉంటుంది. GET, HEAD అభ్యర్థనలు మళ్ళీ ప్రయత్నించబడతాయి.
  • సైడ్‌కార్‌ను ఆపడానికి, Nebo దాని ప్రాసెస్ గ్రూప్‌కు SIGTERM పంపుతుంది, తర్వాత రెండు సెకన్లలో దాన్ని బలవంతంగా ముగిస్తుంది.