NeboAI
NeboAI
ആരംഭിക്കൂ

ആപ്പ് സൈഡ്കാർ

ഒരു ആപ്പിനരികിൽ പ്രവർത്തിക്കുന്ന ഒരു ബൈനറിയാണ് സൈഡ്കാർ. അത് പേജിന്റെ 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>ആപ്പിന്റെ key-value സ്റ്റോർ.
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 അയയ്ക്കുന്നു, എന്നിട്ട് രണ്ട് സെക്കൻഡിനു ശേഷം അതിനെ ബലമായി അവസാനിപ്പിക്കുന്നു.