NeboAI
NeboAI
ആരംഭിക്കൂ

ആപ്പ് SDK

App SDK ഒരു ആപ്പിന്റെ പേജിനെ Nebo-യുമായി ബന്ധിപ്പിക്കുന്നു. Nebo എല്ലാ ആപ്പുകൾക്കും നൽകുന്ന ഒരൊറ്റ സ്ക്രിപ്റ്റാണിത്, അത് പേജിൽ NeboAppSDK എന്ന ഒരൊറ്റ ഗ്ലോബൽ ചേർക്കുന്നു. ഇൻസ്റ്റാൾ ചെയ്യാനോ ബിൽഡ് ചെയ്യാനോ ഒന്നുമില്ല.

SDK ലോഡ് ചെയ്യുക

<script src="/sdk/nebo.global.js"></script>
<script>
  const { nebo, identity, storage, agents, janus, decide, chat, surfaces } = NeboAppSDK;
</script>

ഗ്ലോബൽ NeboAppSDK ആണ്; nebo ഗ്ലോബൽ ഇല്ല. NeboAppSDK.nebo ആണ് SDK ഇൻസ്റ്റൻസ്, ഓരോ മൊഡ്യൂളും മുകൾതലത്തിലും എക്സ്പോർട്ട് ചെയ്തിട്ടുണ്ട്, അതിനാൽ NeboAppSDK.storage-ഉം NeboAppSDK.nebo.storage-ഉം ഒരേ ഒബ്ജക്റ്റാണ്. ബ്രൗസറിനെ മറയ്ക്കാതിരിക്കാൻ, nebo.fetch neboFetch ആയും nebo.WebSocket NeboWebSocket ആയും എക്സ്പോർട്ട് ചെയ്യുന്നു.

identity

കോൾതിരികെ നൽകുന്നത്
identity.get()ആപ്പിന്റെ ജീവനക്കാരനുള്ള {id, name, displayName, description, persona, model, skills, inputValues}. കാഷെ ചെയ്തത്.
identity.invalidate()കാഷെ മായ്ക്കുന്നു.

storage

ആപ്പിനുള്ള ഒരു key-value സ്റ്റോർ. ഇതിന് storage:readwrite വേണം. ആപ്പിന്റെ ജീവനക്കാരൻ വായിക്കുകയും മാറ്റുകയും ചെയ്യുന്ന അതേ സ്റ്റോറാണിത്: ജീവനക്കാരനോട് സംസാരിച്ച് ഉടമ ചേർക്കുന്ന ഒരു രേഖ പേജിൽ കാണിക്കും, പേജിൽ ടൈപ്പ് ചെയ്യുന്നത് ജീവനക്കാരന് കണ്ടെത്താനാകും.

const deals = (await NeboAppSDK.storage.getItem('deals')) ?? [];
deals.push({ name: 'Example renewal', closes: '2026-10-31' });
await NeboAppSDK.storage.setItem('deals', deals);
കോൾപെരുമാറ്റം
storage.getItem(key)setItem സൂക്ഷിച്ചത് കൃത്യമായി (ഒബ്ജക്റ്റ്, ലിസ്റ്റ്, സംഖ്യ അല്ലെങ്കിൽ സ്ട്രിങ്), അല്ലെങ്കിൽ null.
storage.setItem(key, value)ഏത് JSON മൂല്യവും സൂക്ഷിക്കുന്നു.
storage.removeItem(key)ഒരു കീ നീക്കം ചെയ്യുന്നു; അത് പിന്നീട് keys()-ൽ കാണില്ല.
storage.keys()എല്ലാ കീകളും.
storage.clear()എല്ലാ കീകളും നീക്കം ചെയ്യുന്നു.
storage.onChange(handler)ജീവനക്കാരന്റെ (source: "employee") അല്ലെങ്കിൽ ആപ്പിന്റെ തുറന്ന ഏത് വിൻഡോയുടെയും, ഇതുൾപ്പെടെ (source: "page"), ഓരോ എഴുത്തിനും ശേഷം handler({appId, keys, action, source}) വിളിക്കുന്നു. ശ്രദ്ധിക്കുന്നത് നിർത്തുന്ന ഒരു ഫംഗ്ഷൻ തിരികെ നൽകുന്നു.

ആര് മാറ്റിയാലും, ഡാറ്റ മാറുമ്പോൾ വീണ്ടും വരയ്ക്കൂ:

async function load() {
  render((await NeboAppSDK.storage.getItem('deals')) ?? []);
}
load();
const stop = NeboAppSDK.storage.onChange((change) => {
  // { appId, keys: ['deals'], action: 'set' | 'delete', source: 'employee' | 'page' }
  if (change.keys.includes('deals')) load();
});

ആപ്പിന്റെ സ്വന്തം ജീവനക്കാരന് മാത്രമേ ഈ സ്റ്റോറിലേക്ക് എത്താനാകൂ, അതും സ്വന്തം ആപ്പിനായി മാത്രം; മറ്റൊരു ജീവനക്കാരൻ ആപ്പിന്റെ ജീവനക്കാരനോട് ചോദിക്കുന്നു. ഇരുവശത്തിനും കണ്ടെത്താവുന്ന കീകൾ തിരഞ്ഞെടുക്കൂ (ഒരു ലിസ്റ്റ് സൂക്ഷിക്കുന്ന ഒരു കീ, അല്ലെങ്കിൽ deal:42 പോലുള്ള ഒരു പ്രിഫിക്സിന് കീഴിൽ ഓരോ രേഖയ്ക്കും ഒരു കീ), ജീവനക്കാരന്റെ നിർദേശങ്ങളിൽ അവ വിവരിക്കൂ. "42" പോലെ സ്വയം സാധുവായ JSON ആയ ഒരു സ്ട്രിങ് പാഴ്സ് ചെയ്ത് തിരികെ വരും, അതിനാൽ തരം പ്രധാനമാണെങ്കിൽ അത് ഒരു ഒബ്ജക്റ്റിൽ പൊതിയൂ. ഓരോ മൂല്യവും 2 MB-യിൽ നന്നായി താഴെ സൂക്ഷിക്കൂ; ഒരു എഴുത്ത് നിരസിക്കപ്പെടുമ്പോൾ setItem പിശക് കാണിക്കില്ല.

agents

ആപ്പിന്റെ ജീവനക്കാരനോടോ മറ്റൊരു ജീവനക്കാരനോടോ ചോദിച്ച് അതിന്റെ ഉത്തരം നേടൂ. മറ്റൊരു ജീവനക്കാരനോട് ചോദിക്കാൻ subagent:<employee-id> വേണം.

const { text } = await NeboAppSDK.agents.invoke('Which open deals close this month?');

for await (const part of NeboAppSDK.agents.stream('Summarize the pipeline.')) {
  output.textContent += part.text;
}
കോൾതിരികെ നൽകുന്നത്
agents.invoke(message, {agent, data})ജീവനക്കാരൻ പൂർത്തിയാക്കുമ്പോൾ {text, tools}.
agents.stream(message, {agent, data}){text, done}-ന്റെ ഒരു async iterator.

janus

വ്യക്തിത്വമോ മെമ്മറിയോ ടൂളുകളോ ഇല്ലാത്ത നേരിട്ടുള്ള ഒരു മോഡൽ കോൾ.

കോൾതിരികെ നൽകുന്നത്
janus.complete({messages, model, temperature, max_tokens, system})മറുപടി ടെക്സ്റ്റ് ഒരു സ്ട്രിങ്ങായി.
janus.stream(same)ടെക്സ്റ്റ് ഭാഗങ്ങളുടെ ഒരു async iterator.

decide

Typed തീരുമാനങ്ങൾ: ചില ഡാറ്റയെക്കുറിച്ച് പേരുള്ള ചോദ്യങ്ങൾ ചോദിച്ച്, ഓരോ ഉത്തരവും സാധ്യതകളും ഒരു ആത്മവിശ്വാസ നിലയും സഹിതം, വേഗതയേറിയ ഒരൊറ്റ കോളിൽ തിരികെ നേടൂ. ഒന്നും ടെക്സ്റ്റായി എഴുതുന്നില്ല, അതിനാൽ വിലയിരുത്തലുകൾക്ക് (ഈ ലീഡ് ചൂടുള്ളതാണോ, ഈ ടിക്കറ്റ് ഏത് വിഭാഗത്തിൽ പെടുന്നു, എത്ര അടിയന്തരമാണ്) ഇത് ഉപയോഗിക്കൂ, എണ്ണലും തീയതികളും പരിധികളും നിങ്ങളുടെ സ്വന്തം കോഡിൽ സൂക്ഷിക്കൂ. ആപ്പിന്റെ ജീവനക്കാരന് അതിന്റെ decide ടൂൾ ഉപയോഗിച്ച് ഇതേ ചോദ്യങ്ങൾ ചോദിക്കാം, ഉദാഹരണത്തിന് ആപ്പിൽ സൂക്ഷിച്ച രേഖകളെക്കുറിച്ച്.

const { answers } = await NeboAppSDK.decide({
  state: { company: 'Example Co', status: 'asked for a quote today' },
  questions: {
    tier: {
      type: 'choice',
      instructions: 'How warm is this lead, judging by `status`?',
      criteria: { hot: 'ready to buy', warm: 'interested', cold: 'not now', other: "can't tell" }
    },
    fit: {
      type: 'score',
      instructions: 'How well does `company` fit our customers?',
      criteria: ['poor', 'fair', 'good', 'great']
    },
    reply: { type: 'noul', instructions: '`status` asks us for a reply.' }
  }
});

if (answers.tier.choice === 'hot' && answers.tier.confidence > 0.8) flag(lead);
// answers.fit.score is fractional: 0 is "poor", 1.5 is between "fair" and "good".
// answers.reply.noul is the probability the statement holds, from 0 to 1.
ചോദ്യ തരംcriteriaഉത്തരം
choice2 മുതൽ 255 വരെ പേരുള്ള ഓപ്ഷനുകളുടെ ഒരു ഒബ്ജക്റ്റ്, {option: description}. ലിസ്റ്റ് പൂർണ്ണമല്ലെങ്കിൽ other പോലുള്ള ഒരു ഒഴിവ് ഓപ്ഷൻ ചേർക്കൂ.choice (തിരഞ്ഞെടുത്ത ഓപ്ഷൻ), confidence (0 മുതൽ 1 വരെ), ഓരോ ഓപ്ഷനും probabilities.
scoreക്രമീകരിച്ച 2 മുതൽ 10 വരെ നിലകളുടെ ലിസ്റ്റ്, ഏറ്റവും താഴ്ന്നത് ആദ്യം.score (ഭിന്നസംഖ്യ, 0 ആദ്യ നിലയാണ്), confidence, ഓരോ നിലയ്ക്കും probabilities.
noulഒന്നുമില്ല: ചോദ്യം വിലയിരുത്തേണ്ട ഒരു പ്രസ്താവനയാണ്.noul, പ്രസ്താവന ശരിയാകാനുള്ള സാധ്യത. പ്രത്യേക ആത്മവിശ്വാസ നിലയില്ല.
  • decide({state, questions}) ഫലമായി {model, answers, usage} നൽകുന്നു, ഓരോ ഉത്തരവും അതിന്റെ ചോദ്യത്തിന് നിങ്ങൾ നൽകിയ പേരിന് കീഴിൽ.
  • state ടെക്സ്റ്റോ ഏതെങ്കിലും JSON-ഓ ആണ്. ചോദ്യങ്ങൾക്ക് വേണ്ട ഫീൽഡുകളിൽ മാത്രം പരിമിതപ്പെടുത്തി, instructions-നുള്ളിൽ ആ ഫീൽഡുകളുടെ പേരുകൾ ബാക്ക്ടിക്കുകളിൽ നൽകൂ. ചോദ്യം മുഴുവൻ instructions-ലാണ്; ചോദ്യത്തിന്റെ പേര് ഉത്തരത്തിന് ലേബൽ നൽകുക മാത്രം ചെയ്യുന്നു. വളരെ നീളമുള്ള state അയയ്ക്കുന്നതിനു മുമ്പ് മധ്യഭാഗത്ത് ചുരുക്കും.
  • കാരണം സന്ദേശമായുള്ള ഒരു പിശക് ഇത് നൽകുന്നു. പിശകിന് സ്റ്റാറ്റസ് കോഡ് ഇല്ല, അതിനാൽ കേസുകൾ വേർതിരിച്ചറിയണമെങ്കിൽ സന്ദേശം താരതമ്യം ചെയ്യുക:
    • തെറ്റായ രൂപത്തിലുള്ള ചോദ്യം, ഉദാഹരണത്തിന് ഒരു ഓപ്ഷൻ മാത്രമുള്ള ഒരു choice (ബോട്ട് 400 എന്ന് മറുപടി നൽകും, എന്താണ് തെറ്റെന്ന് സഹിതം).
    • ഉടമയുടെ അക്കൗണ്ടിൽ ജോലി ബാക്കിയില്ല: "നിങ്ങളുടെ അക്കൗണ്ടിൽ ഉൾപ്പെട്ട ജോലി മുഴുവൻ നിങ്ങൾ ഉപയോഗിച്ചു. തുടരാൻ ഒരു പ്ലാൻ തിരഞ്ഞെടുക്കുകയോ ക്രെഡിറ്റുകൾ ചേർക്കുകയോ ചെയ്യൂ." (429). ഉടമ ഒരു പ്ലാനോ ക്രെഡിറ്റുകളോ ചേർക്കുന്നതുവരെ വീണ്ടും ശ്രമിച്ചിട്ട് ഫലമില്ല.
    • ഒരേസമയം വളരെയധികം തീരുമാനങ്ങൾ: "ഒരേസമയം വളരെയധികം തീരുമാനങ്ങൾ. അൽപ്പസമയത്തിനു ശേഷം വീണ്ടും ശ്രമിക്കൂ." (429).
    • ബോട്ട് സൈൻ ഇൻ ചെയ്തിട്ടില്ല: "തീരുമാനങ്ങൾക്ക് NeboAI ബന്ധിപ്പിച്ചിരിക്കണം. NeboAI-യിൽ സൈൻ ഇൻ ചെയ്ത് വീണ്ടും ശ്രമിക്കൂ." (503).
    • തീരുമാന സേവനം പരാജയപ്പെട്ടു (502).
  • ഏതൊരു മോഡൽ കോളിനെയും പോലെ തീരുമാനങ്ങൾ ബോട്ട് ഉടമയുടെ NeboAI അക്കൗണ്ടിലേക്ക് ബിൽ ചെയ്യും. വിലനിർണയം കാണുക.

neboFetch

// Relative path: the app's own sidecar.
const res = await NeboAppSDK.neboFetch('/deals?stage=open');

// Absolute URL: through Nebo's proxy. Needs network:api.example.com.
const rates = await NeboAppSDK.neboFetch('https://api.example.com/rates');

ഒരു ആപേക്ഷിക പാത്ത് /apps/<id>/api/<path>-ൽ ആപ്പിന്റെ സൈഡ്കാറിലേക്ക് പോകുന്നു. ഒരു അബ്സൊല്യൂട്ട് http അല്ലെങ്കിൽ https URL Nebo-യുടെ പ്രോക്സിയിലൂടെ പോകുന്നു, അതിന് network:<host> അല്ലെങ്കിൽ network:* വേണം.

NeboWebSocket

new NeboAppSDK.NeboWebSocket() ആപ്പിന്റെ ജീവനക്കാരനിലേക്ക് ഒരു ലൈവ് സോക്കറ്റ് തുറക്കുകയും ബാക്ക്ഓഫോടെ വീണ്ടും ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു. ഇത് ആർഗ്യുമെന്റുകളൊന്നും സ്വീകരിക്കുന്നില്ല, send(data), close(), onopen, onmessage, onerror, onclose എന്നിവയുണ്ട്.

surfaces-ഉം a2ui-ഉം

surfaces.connect() ആപ്പിന്റെ ലൈവ് ചാനൽ തുറക്കുന്നു. ഇന്ന് അത് ആപ്പിന്റെ ജീവനക്കാരനിൽ നിന്നുള്ള ഇന്ററാക്ടീവ് കാർഡുകൾ കൊണ്ടുവരുന്നു: നിങ്ങളുടെ പേജ് ബണ്ടിൽ ചെയ്യുന്ന @a2ui/web_core-ൽ നിന്നുള്ള ഒരു MessageProcessor ഉപയോഗിച്ച് a2ui.init(processor) വിളിക്കൂ (SDK-ക്ക് സ്വന്തമായി റെൻഡറർ ഇല്ല). ഒരു കാർഡ് അത് ഉണ്ടാക്കിയ ആപ്പിൽ മാത്രമേ എത്തൂ, അതിലെ ഒരു ക്ലിക്ക് ആ ആപ്പിന്റെ ജീവനക്കാരനിലേക്ക് പോകുന്നു, കാർഡ് അയച്ചശേഷം തുറന്ന പേജിന് അത് ലഭിക്കില്ല, അതിനാൽ പേജ് എപ്പോഴും കാണിക്കേണ്ടത് storage-ൽ സൂക്ഷിക്കൂ.

surfaces.on(type, handler), surfaces.send(name, payload), surfaces.state എന്നിവയോടൊപ്പം text_content, state_delta, surface_update പോലുള്ള typed ഇവന്റുകളും SDK നിർവചിക്കുന്നു. Nebo ഇതുവരെ ആ ഇവന്റുകൾ ആപ്പ് പേജുകളിലേക്ക് അയയ്ക്കുന്നില്ല, send-ന് ഒന്നും മറുപടി നൽകുന്നില്ല. ലൈവ് ഡാറ്റയ്ക്ക് storage.onChange ഉപയോഗിക്കൂ.

chat

ആപ്പിന്റെ ജീവനക്കാരനുമായുള്ള Nebo-യുടെ ചാറ്റ് പേജിൽ എംബെഡ് ചെയ്യൂ.

NeboAppSDK.chat.mount(document.getElementById('chat'), {
  placeholder: 'Ask about a deal',
  contextId: 'deal-42'
});
NeboAppSDK.chat.setContext({ deal: 'Example renewal' });
കോൾപെരുമാറ്റം
chat.mount(element, options)ഓപ്ഷനുകൾ: placeholder, theme, height, borderless, contextId, scope.
chat.send(text)ഒരു സന്ദേശം അയയ്ക്കുന്നു.
chat.setContext(context)ജീവനക്കാരൻ കാണുന്ന കോൺടെക്സ്റ്റ് സജ്ജമാക്കുന്നു; null അത് മായ്ക്കുന്നു.
chat.onMessage(handler)സന്ദേശങ്ങൾ സ്വീകരിക്കുന്നു.
chat.newThread()പുതിയ ഒരു ത്രെഡ് തുടങ്ങുന്നു.
chat.unmount()ചാറ്റ് നീക്കം ചെയ്യുന്നു.

കോൺഫിഗറേഷൻ

Nebo-യ്ക്കുള്ളിൽ SDK ആപ്പ് id-യും base URL-ഉം സ്വയം കണ്ടെത്തുന്നു. മറ്റെവിടെയെങ്കിലും നിന്ന് നൽകുന്ന ഒരു പേജിന്, nebo.configure({appId, baseUrl}) വിളിക്കുക, അല്ലെങ്കിൽ NeboAppSDK.setAppId(id), NeboAppSDK.setBaseUrl(url) എന്നിവ വിളിക്കുക. getAppId(), getBaseUrl() എന്നിവ അവ തിരികെ വായിക്കുന്നു.