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
ಆ್ಯಪ್ಗಾಗಿ ಕೀ-ಮೌಲ್ಯ ಸಂಗ್ರಹ. ಇದಕ್ಕೆ 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
ಪ್ರಕಾರಬದ್ಧ ನಿರ್ಧಾರಗಳು: ಯಾವುದೋ ಡೇಟಾ ಬಗ್ಗೆ ಹೆಸರಿಸಲಾದ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿ, ಪ್ರತಿ ಉತ್ತರವನ್ನೂ ಸಂಭವನೀಯತೆಗಳು ಮತ್ತು ವಿಶ್ವಾಸದೊಂದಿಗೆ ಒಂದೇ ವೇಗದ ಕರೆಯಲ್ಲಿ ಪಡೆಯಿರಿ. ಯಾವುದನ್ನೂ ಪಠ್ಯವಾಗಿ ಬರೆಯಲಾಗುವುದಿಲ್ಲ, ಹಾಗಾಗಿ ಇದನ್ನು ತೀರ್ಮಾನಗಳಿಗೆ ಬಳಸಿ (ಈ ಲೀಡ್ ಬಿಸಿಯಾಗಿದೆಯೇ, ಈ ಟಿಕೆಟ್ ಯಾವ ವರ್ಗಕ್ಕೆ ಸೇರುತ್ತದೆ, ಎಷ್ಟು ತುರ್ತು) ಮತ್ತು ಎಣಿಕೆ, ದಿನಾಂಕಗಳು ಮತ್ತು ಮಿತಿಗಳನ್ನು ನಿಮ್ಮ ಸ್ವಂತ ಕೋಡ್ನಲ್ಲಿ ಇಡಿ. ಆ್ಯಪ್ನ ಉದ್ಯೋಗಿ ತನ್ನ 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 | ಉತ್ತರ |
|---|---|---|
choice | 2 ರಿಂದ 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ಒಳಗೆ 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'); ಸಾಪೇಕ್ಷ ಮಾರ್ಗ /apps/<id>/api/<path> ನಲ್ಲಿ ಆ್ಯಪ್ನ sidecar ಗೆ ಹೋಗುತ್ತದೆ. ಸಂಪೂರ್ಣ 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 ನಲ್ಲಿ ಇಡಿ.
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() ಅವುಗಳನ್ನು ಮರಳಿ ಓದುತ್ತವೆ.