NeboAI
NeboAI
શરૂ કરો

App 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 instance છે, અને દરેક મોડ્યુલ ટોચના સ્તરે પણ export થાય છે, તેથી NeboAppSDK.storage અને NeboAppSDK.nebo.storage એક જ ઑબ્જેક્ટ છે. બ્રાઉઝરને ઢાંકી ન દેવાય તે માટે, nebo.fetch ને neboFetch તરીકે અને nebo.WebSocket ને NeboWebSocket તરીકે export કરવામાં આવે છે.

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)દરેક write પછી handler({appId, keys, action, source}) કૉલ કરે છે, પછી ભલે તે કર્મચારીએ (source: "employee") કર્યું હોય કે ઍપની કોઈ પણ ખુલ્લી વિન્ડોએ, આ વિન્ડો સહિત (source: "page"). સાંભળવાનું બંધ કરતું ફંક્શન પરત આપે છે.

ડેટા બદલાય ત્યારે ફરી દોરો, ભલે ગમે તેણે બદલ્યો હોય:

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 જેવા પ્રિફિક્સ હેઠળ દરેક રેકોર્ડ માટે એક કી) અને કર્મચારીની સૂચનાઓમાં તેમનું વર્ણન કરો. જે સ્ટ્રિંગ પોતે માન્ય JSON હોય, જેમ કે "42", તે પાર્સ થઈને પાછી આવે છે, તેથી પ્રકાર મહત્ત્વનો હોય તો તેને ઑબ્જેક્ટમાં લપેટો. દરેક મૂલ્ય 2 MB થી ઘણું ઓછું રાખો; write નકારાય ત્યારે 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

પ્રકારબદ્ધ નિર્ણયો: કોઈ ડેટા વિશે નામવાળા પ્રશ્નો પૂછો અને એક ઝડપી કૉલમાં દરેક જવાબ સંભાવનાઓ અને વિશ્વાસ સાથે પાછો મેળવો. કંઈ ટેક્સ્ટ તરીકે લખાતું નથી, તેથી તેનો ઉપયોગ નિર્ણયો માટે કરો (આ લીડ ગરમ છે કે નહીં, આ ટિકિટ કઈ શ્રેણીની છે, તે કેટલી તાત્કાલિક છે) અને ગણતરી, તારીખો અને થ્રેશોલ્ડ તમારા પોતાના કોડમાં રાખો. ઍપનો કર્મચારી પોતાના 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.
score2 થી 10 ક્રમિત સ્તરોની યાદી, સૌથી નીચું પહેલાં.score (અપૂર્ણાંક, 0 એ પહેલું સ્તર છે), confidence અને દરેક સ્તર માટે probabilities.
noulકંઈ નહીં: પ્રશ્ન એક જ વિધાન છે જેના પર નિર્ણય લેવાનો છે.noul, વિધાન સાચું હોવાની સંભાવના. અલગ વિશ્વાસ નહીં.
  • decide({state, questions}) નું પરિણામ {model, answers, usage} આવે છે, જેમાં દરેક જવાબ તમે તેના પ્રશ્નને આપેલા નામ હેઠળ હોય છે.
  • state ટેક્સ્ટ અથવા કોઈ પણ JSON છે. તેને પ્રશ્નોને જરૂરી ફીલ્ડ પૂરતું મર્યાદિત રાખો અને instructions માં એ ફીલ્ડનાં નામ backticks માં લખો. આખો પ્રશ્ન 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');

સાપેક્ષ પાથ ઍપના sidecar પર /apps/<id>/api/<path> પર જાય છે. સંપૂર્ણ http અથવા https URL Nebo ના પ્રૉક્સી દ્વારા જાય છે અને તેને network:<host> અથવા network:* જોઈએ.

NeboWebSocket

new NeboAppSDK.NeboWebSocket() ઍપના કર્મચારી સાથે લાઇવ સૉકેટ ખોલે છે અને backoff સાથે ફરી જોડાય છે. તે કોઈ આર્ગ્યુમેન્ટ લેતું નથી અને તેમાં send(data), close(), onopen, onmessage, onerror અને onclose છે.

surfaces અને a2ui

surfaces.connect() ઍપની લાઇવ ચૅનલ ખોલે છે. આજે તે ઍપના કર્મચારી તરફથી ઇન્ટરૅક્ટિવ કાર્ડ લાવે છે: @a2ui/web_core ના MessageProcessor સાથે a2ui.init(processor) કૉલ કરો, જે તમારું પેજ બંડલ કરે છે (SDK પાસે પોતાનું કોઈ રેન્ડરર નથી). કાર્ડ ફક્ત એ ઍપ સુધી પહોંચે છે જેના માટે તે બન્યું હતું, તેના પરનું ક્લિક એ ઍપના કર્મચારીને જાય છે, અને કાર્ડ મોકલાયા પછી ખૂલેલા પેજને તે મળતું નથી, તેથી પેજે હંમેશાં બતાવવું જોઈએ તે storage માં રાખો.

SDK text_content, state_delta અને surface_update જેવી પ્રકારબદ્ધ ઇવેન્ટ પણ વ્યાખ્યાયિત કરે છે, surfaces.on(type, handler), surfaces.send(name, payload) અને surfaces.state સાથે. 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 અને બેઝ URL જાતે શોધી લે છે. બીજે સર્વ થતા પેજ માટે, nebo.configure({appId, baseUrl}) કૉલ કરો, અથવા NeboAppSDK.setAppId(id) અને NeboAppSDK.setBaseUrl(url). getAppId() અને getBaseUrl() તેમને પાછા વાંચે છે.