మీ AI ఏజెంట్కు మెమరీ ఇవ్వండి: ఆరు నెలల WhatsApp చాట్లు, కాంటాక్ట్లు
Coexistence ద్వారా కనెక్ట్ అయిన నంబర్పై, యాప్లోని కాంటాక్ట్లను, 180 రోజుల వరకు ఒకరితో ఒకరు జరిగిన చాట్లను, ఒకసారి మాత్రమే, Meta మీ సర్వర్కు పంపగలదు. ఇది జరగాలంటే కనెక్ట్ అయిన 24 గంటల్లోపే డైరెక్ట్ వెబ్హుక్ గమ్యం సేవ్ చేయబడాలి, అలాగే వ్యాపారం యాప్లో అంగీకరించాలి. చంక్స్ క్రమం తప్పి రావచ్చు, ప్రోగ్రెస్ 100 అంటే ముగింపు. సందేశాలను id ద్వారా నిల్వ చేయండి, వ్యక్తులను BSUID ద్వారా గుర్తించండి, ఇటీవలి మలుపులను ఏజెంట్కు అందించండి.
easyCoexistence నంబర్ను Meta యొక్క Coexistence ఫ్లో ద్వారా కనెక్ట్ చేస్తుంది, మరియు మీరు ఎండ్పాయింట్ను కనెక్ట్ అయిన 24 గంటల్లోపే డైరెక్ట్ వెబ్హుక్ గమ్యంగా సేవ్ చేస్తే, కాంటాక్ట్లు మరియు 180 రోజుల వరకు చాట్ల కోసం Meta ను ఒకసారి అడుగుతుంది, అవి నేరుగా మీ సర్వర్కు వెళ్తాయి.
ఆన్బోర్డింగ్ నుండి హిస్టరీ సింక్ ఎంత వెనక్కి వెళ్తుంది; Meta ఫీచర్ టేబుల్ దీన్ని అత్యంత ఇటీవలి 6 నెలలుగా పేర్కొంటుంది.
ఆన్బోర్డింగ్ తర్వాత కాంటాక్ట్లు మరియు హిస్టరీ కోసం అభ్యర్థించే సమయం; ప్రతి అభ్యర్థనను ఒకసారి మాత్రమే చేయవచ్చు.
హిస్టరీ సింక్ పూర్తయిందని సూచించే metadata.progress విలువ; కేవలం phase సరిపోదని Meta చెబుతుంది.
WhatsApp Business యాప్లో వ్యాపారం హిస్టరీ షేరింగ్ను ఆపివేసినప్పుడు హిస్టరీ వెబ్హుక్లో వచ్చే ఎర్రర్ కోడ్.
ఫేజ్ 0 ఆన్బోర్డింగ్కు ముందు రోజు 0 నుండి 1 వరకు, ఫేజ్ 1 రోజులు 1 నుండి 90 వరకు, ఫేజ్ 2 రోజులు 90 నుండి 180 వరకు.
Meta పంపే అతిపెద్ద వెబ్హుక్ పేలోడ్, మీ ఎండ్పాయింట్కు అవసరమైన బాడీ సైజ్ పరిమితిని నిర్ణయిస్తుంది.
ఇంపోర్ట్లో ఏమి వస్తుంది, ఏమి వెనుక ఉండిపోతుంది?
ఫోన్లోని WhatsApp Business యాప్ నుండి రెండు ప్రవాహాలు వస్తాయి. కాంటాక్ట్లు smb_app_state_sync వెబ్హుక్ల రూపంలో వస్తాయి, ప్రతి కాంటాక్ట్కు ఒక ఎంట్రీ, action విలువ add లేదా remove. అదే ఫీల్డ్ వ్యాపారం యాప్లో తర్వాత జోడించే, సవరించే లేదా తొలగించే కాంటాక్ట్ల గురించి కూడా తెలియజేస్తూనే ఉంటుంది. చాట్లు history వెబ్హుక్ల రూపంలో వస్తాయి: ఆన్బోర్డింగ్కు ముందు 180 రోజుల వరకు జరిగిన ఒకరితో ఒకరు సంభాషణలు, రెండు దిశల్లోనూ, వాటి డెలివరీ స్టేటస్తో. ఏవి రావు అనేది క్రింద జాబితా చేయబడింది, కాబట్టి ఇంపోర్ట్పై ఆధారపడిన మెమరీ వాటిని ఆశించకూడదు.
ఇంపోర్ట్ మీ సర్వర్కు చేరుతుందని ఎలా నిర్ధారించుకోవాలి?
కనెక్ట్ చేయడానికి ముందే ఎండ్పాయింట్ లైవ్లో ఉంచండి, తర్వాత కనెక్ట్ అయిన 24 గంటల్లోపే దాన్ని నంబర్ యొక్క డైరెక్ట్ వెబ్హుక్ గమ్యంగా సేవ్ చేయండి: నంబర్ పేజీలో "Route incoming messages to your own webhook" కింద, మీ AI నుండి set_webhook_destination తో, లేదా Partner API connect session లో webhook_url గా. దీన్ని సేవ్ చేయడమే easyCoexistence ను ఆన్బోర్డింగ్కు ఒకసారి మాత్రమే, మొదట కాంటాక్ట్లు, తర్వాత హిస్టరీ కోసం Meta నుండి సింక్ అభ్యర్థించేలా చేస్తుంది. అభ్యర్థన మరియు Meta అభ్యర్థన ids నంబర్ యొక్క ఈవెంట్ లాగ్లో history_sync_requested గా కనిపిస్తాయి.
కనెక్షన్ సమయంలో యాప్ అడిగినప్పుడు వ్యాపారం హిస్టరీ షేర్ చేయడానికి అంగీకరించాలి. మెసేజ్లు easyCoexistence ద్వారా వచ్చే నంబర్ (Where incoming messages go కార్డ్లో Through easyCoexistence), Forward URL ఉన్నప్పటికీ, ఇంపోర్ట్ పొందదు, ఎందుకంటే అభ్యర్థన డైరెక్ట్ గమ్యానికి మాత్రమే చేయబడుతుంది. తర్వాత మీకు automations అవసరమైతే, ఇంపోర్ట్ ముగిసిన తర్వాత మారండి.
హిస్టరీ చంక్స్ ఎలా వస్తాయి?
క్రమం తప్పి వస్తాయి, అత్యంత ఇటీవలి సందేశాల నుండి వెనక్కి వెళ్లే ఫేజ్లలో: ఫేజ్ 0 ఆన్బోర్డింగ్కు ముందు చివరి రోజును కవర్ చేస్తుంది, ఫేజ్ 1 రోజు 90 వరకు, ఫేజ్ 2 రోజు 180 వరకు. క్రమం ముఖ్యమైతే metadata.chunk_order ద్వారా క్రమబద్ధీకరించండి, మరియు metadata.progress = 100 ను ముగింపుగా పరిగణించండి, ఎందుకంటే phase ఒక ఫేజ్ పూర్తయిందని చెప్పదని Meta గమనిస్తుంది. సంభాషణ id కస్టమర్ ఫోన్ నంబర్, దాన్ని పంచుకోలేనప్పుడు వదిలివేయబడుతుంది, మరియు దాని context లో wa_id, user_id మరియు username ఉంటాయి. వ్యాపారం పంపిన సందేశంలో from వ్యాపార నంబర్కు సెట్ చేయబడి, to ఫీల్డ్ ఉంటుంది.
{
"messaging_product": "whatsapp",
"metadata": { "display_phone_number": "16315550142", "phone_number_id": "106540352242922" },
"history": [{
"metadata": { "phase": 1, "chunk_order": 2, "progress": 55 },
"threads": [{
"id": "5511987654321",
"context": { "wa_id": "5511987654321", "user_id": "BR.13491208655302741918" },
"messages": [
{
"from": "5511987654321",
"from_user_id": "BR.13491208655302741918",
"id": "wamid.HBgNNTUxMTk4NzY1NDMyMRUCABIYFDNBMDhFN0QxRjM2QTk4RTU2RTY0AA==",
"timestamp": "1789912800",
"type": "text",
"text": { "body": "Can I pick up the cake on Saturday?" },
"history_context": { "status": "read" }
},
{
"from": "16315550142",
"to": "5511987654321",
"id": "wamid.HBgNNTUxMTk4NzY1NDMyMRUCABEYEjQ2RDhGMkE3QjEwQzNFOTFBMgA=",
"timestamp": "1789913100",
"type": "text",
"text": { "body": "Yes, from 9 am. See you then!" },
"history_context": { "status": "read" }
}
]
}]
}]
}ఏజెంట్ మెమరీని ఎలా నిల్వ చేయాలి?
రెండు టేబుల్స్ సరిపోతాయి. వ్యక్తులు BSUID ద్వారా కీ చేయబడతారు, అంటే Meta కాంటాక్ట్లు, సంభాషణలు మరియు సందేశాలకు జోడించే user_id, దానితో పాటు ఫోన్ నంబర్ కూడా ఉంచబడుతుంది, ఎందుకంటే username ఉన్న వినియోగదారు నంబర్ లేకుండా రావచ్చు; Meta యొక్క స్వంత రిఫరెన్స్ కాంటాక్ట్ను గుర్తించడానికి user_id ఉపయోగించమని చెబుతుంది. సందేశాలు వాటి wamid ద్వారా కీ చేయబడతాయి, కాబట్టి ఇంపోర్ట్, లైవ్ వెబ్హుక్లు మరియు మళ్లీ ప్రయత్నించిన డెలివరీలు అదే సందేశాన్ని ఒకే వరుసగా మారుస్తాయి, మరియు from_business ఫ్లాగ్ ఎవరు మాట్లాడారో నమోదు చేస్తుంది. వ్యక్తి మరియు సమయం ప్రకారం ఇండెక్స్ చేయండి, ఎందుకంటే ఏజెంట్ ఒక వ్యక్తి యొక్క ఇటీవలి మలుపులను అడుగుతుంది.
-- One row per person. Key on the BSUID (user_id); keep the phone number beside it.
create table wa_contacts (
user_key text primary key, -- user_id (BSUID) when present, else the phone number
wa_id text, -- phone number in digits, when Meta shares it
username text,
name text, -- full_name from the app's address book
removed boolean not null default false,
updated_at timestamptz not null default now()
);
-- One row per message. The wamid makes history, live events and retries collapse.
create table wa_messages (
id text primary key, -- messages[].id
user_key text not null,
from_business boolean not null,
type text not null, -- text, image, media_placeholder...
body text not null, -- the text, a caption, or a [type] placeholder
sent_at timestamptz not null,
source text not null -- history | live | echo
);
create index wa_messages_by_user on wa_messages (user_key, sent_at desc);చంక్స్ మరియు కాంటాక్ట్లను దానిలోకి ఎలా లోడ్ చేయాలి?
ఐడెంపోటెంట్ ఇన్సర్ట్లతో, కాబట్టి క్రమం మరియు మళ్లీ డెలివరీ ముఖ్యం కాకుండా పోతాయి. ingestHistory ఒక history మార్పును చదువుతుంది: 2593109 తిరస్కరణను లాగ్ చేసి ముందుకు సాగుతుంది, context.user_id లేదా దాని id ద్వారా సంభాషణను కీ చేస్తుంది, from విలువ metadata.display_phone_number కు సమానమైనప్పుడు సందేశాన్ని వ్యాపారానిదిగా గుర్తిస్తుంది, మరియు టెక్స్ట్ లేనప్పుడు [type] ప్లేస్హోల్డర్ నిల్వ చేస్తుంది. ingestContacts user_id లేదా ఫోన్ నంబర్పై upsert చేస్తుంది, మరియు తొలగించబడిన కాంటాక్ట్ల సందేశాలను తొలగించకుండా వాటిని ఫ్లాగ్ చేస్తుంది. డైరెక్ట్ గమ్యంలో change.value తో, లేదా forward యొక్క event history లేదా smb_app_state_sync అయినప్పుడు బాడీ యొక్క value తో వాటిని కాల్ చేయండి.
// memory.mjs: npm i pg. Feed it the value of a "history" or "smb_app_state_sync"
// change: change.value on a direct destination, delivery.value on a forward.
import pg from "pg";
const db = new pg.Pool(); // reads the PG* environment variables
export async function ingestHistory(value) {
const business = value.metadata?.display_phone_number; // digits, like messages[].from
for (const chunk of value.history ?? []) {
if (chunk.errors?.some((e) => e.code === 2593109)) {
console.log("The business turned off history sharing in the app"); // contacts still come
continue;
}
for (const thread of chunk.threads ?? []) {
const userKey = thread.context?.user_id ?? thread.id; // thread.id is the phone, when shared
for (const m of thread.messages ?? []) {
await db.query(
`insert into wa_messages (id, user_key, from_business, type, body, sent_at, source)
values ($1, $2, $3, $4, $5, to_timestamp($6), 'history')
on conflict (id) do nothing`,
[m.id, userKey, m.from === business, m.type,
m.text?.body ?? m[m.type]?.caption ?? `[${m.type}]`, Number(m.timestamp)]
);
}
}
const { phase, chunk_order, progress } = chunk.metadata ?? {};
console.log(`history: phase ${phase}, chunk ${chunk_order}, ${progress}%`);
if (Number(progress) === 100) console.log("Import complete; late chunks still insert safely");
}
}
export async function ingestContacts(value) {
for (const s of value.state_sync ?? []) {
const c = s.type === "contact" ? s.contact ?? {} : null;
const userKey = c && (c.user_id ?? c.phone_number);
if (!userKey) continue;
await db.query(
`insert into wa_contacts (user_key, wa_id, username, name, removed)
values ($1, $2, $3, $4, $5)
on conflict (user_key) do update set
wa_id = coalesce(excluded.wa_id, wa_contacts.wa_id),
username = coalesce(excluded.username, wa_contacts.username),
name = coalesce(excluded.name, wa_contacts.name),
removed = excluded.removed, updated_at = now()`,
[userKey, c.phone_number ?? null, c.username ?? null, c.full_name ?? c.first_name ?? null,
s.action === "remove"]
);
}
}
// A bounded memory for one person: who they are and their last turns, oldest first.
export async function memoryFor(userKey, turns = 20) {
const [{ rows: [contact] }, { rows }] = await Promise.all([
db.query("select name from wa_contacts where user_key = $1 and not removed", [userKey]),
db.query(
`select from_business, body from wa_messages
where user_key = $1 order by sent_at desc limit $2`, [userKey, turns]),
]);
const history = rows.reverse().map((r) => ({ role: r.from_business ? "assistant" : "user", content: r.body }));
while (history[0]?.role === "assistant") history.shift(); // open on the customer's turn
const who = contact?.name ? `The customer is ${contact.name}.` : "The customer is not in the address book.";
return { system: `${process.env.AI_INSTRUCTIONS ?? ""}\n${who}`.trim(), history };
}ఆ మెమరీని ఏజెంట్కు ఎలా అందించాలి?
ఎప్పుడూ ఒకేసారి కాకుండా, పరిమితితో. memoryFor వ్యక్తి పేరును అడ్రస్ బుక్ నుండి మరియు వారి చివరి 20 మలుపులను, పాత నుండి కొత్త వరకు, చాలా చాట్ APIలు ఆశించినట్టుగా కస్టమర్ మలుపుతో ప్రారంభించి తిరిగి ఇస్తుంది; ఏజెంట్కు ఎక్కువ అవసరమైతే పాత సంభాషణల నిల్వ చేసిన సారాంశాన్ని జోడించండి. ఆరు నెలల చాట్లను ప్రతి ప్రాంప్ట్లో ఉంచితే ప్రతి సమాధానానికి టోకెన్లు ఖర్చవుతాయి మరియు అడుగుతున్న ప్రశ్నను అణచివేస్తుంది.
పోలిక కోసం, అంతర్నిర్మిత Reply with AI స్టెప్ గరిష్టంగా 20 మునుపటి సందేశాలను (డిఫాల్ట్గా 10) చదువుతుంది, మరియు Call my webhook స్టెప్ చివరి 10 పంపుతుంది. రెండూ యజమాని ఎంచుకునే నిలుపుదల కాలం, అంటే 30, 90 లేదా 365 రోజులు (డిఫాల్ట్గా 90), automations ఆన్ చేసిన క్షణం నుండి ఉంచబడిన టెక్స్ట్పై ఆధారపడతాయి, అందుకే ఇంపోర్ట్ చేసిన ఆరు నెలల చాట్లు మీ స్వంత డేటాబేస్లోనే ఉండాలి.
ఇంపోర్ట్ తర్వాత మెమరీ ఎలా తాజాగా ఉంటుంది?
ఇంపోర్ట్ తర్వాత అదే గమ్యం లైవ్ ట్రాఫిక్ను స్వీకరిస్తూనే ఉంటుంది: కస్టమర్ల నుండి సందేశాలు, యాప్లో టైప్ చేసిన జవాబుల కోసం smb_message_echoes, మరియు వ్యాపారం తన కాంటాక్ట్లను సవరించినప్పుడు smb_app_state_sync. వీటిని source live లేదా echo తో అదే టేబుల్స్ ద్వారా ఇన్సర్ట్ చేయండి. కస్టమర్ ఫోన్ నంబర్ మార్చినప్పుడు, Meta previous_user_id తో user_changed_number లేదా user_changed_user_id రకం system సందేశం పంపుతుంది, అది వారి వరుసలను కొత్త BSUIDకు తరలించమని మీకు సూచన.
తర్వాత automations ఆన్ చేస్తే డైరెక్ట్ గమ్యం తొలగిపోతుంది. అదే URLను Forward URL గా జోడించండి, ప్రతి సంతకం చేసిన POST నుండి event మరియు value చదవండి, మరియు మారే ముందు progress 100 కోసం వేచి ఉండండి, లేకపోతే మిగిలిన చంక్స్ ఆ ఫార్వర్డ్ ద్వారా మాత్రమే మీకు చేరతాయి.
దీన్ని ఎలా సెటప్ చేయాలి
- Put the endpoint onlineIt must return hub.challenge as plain text on Meta's GET handshake when hub.verify_token matches, accept POST bodies of a few megabytes and answer 200 fast.
- Connect the numberRun the connection from the dashboard, and accept sharing chat history when the WhatsApp Business app asks.
- Save the destination within 24 hoursOn the number's page, under Route incoming messages to your own webhook, fill Webhook URL (with a long random path) and Verify token, then Save; or ask your AI to call set_webhook_destination.
- Store chunks until progress 100Insert contacts and messages as they come; the event log shows history_sync_requested once the request went to Meta.
- Switch modes only afterwardsIf you want automations, choose Through easyCoexistence in the card Where incoming messages go and add the same URL as the Forward URL.
సాధారణ పొరపాట్లు
- రెండో రోజున గమ్యం సేవ్ చేయడం. సింక్ కనెక్ట్ అయిన 24 గంటల్లోపే మాత్రమే అభ్యర్థించబడుతుంది, కాబట్టి తర్వాత సేవ్ చేసిన ఎండ్పాయింట్ లైవ్ సందేశాల నుండి మాత్రమే మొదలవుతుంది.
- progress 100 చేరకముందే automations ఆన్ చేయడం. డైరెక్ట్ గమ్యం వెంటనే తొలగించబడుతుంది, మరియు Forward URL ముందే సెట్ చేయబడితే మాత్రమే తర్వాతి చంక్స్ మీకు చేరతాయి.
- ఫేజ్ 2ను ఇంపోర్ట్ ముగింపుగా భావించడం. కేవలం metadata.progress = 100 మాత్రమే సింక్ పూర్తయిందని చెబుతుంది, మరియు చంక్స్ క్రమంలో డెలివరీ కావు.
- మెమరీని కేవలం ఫోన్ నంబర్పై కీ చేయడం. username ఉన్న వినియోగదారు పంచుకోలేనప్పుడు సంభాషణ ids మరియు కాంటాక్ట్లు ఫోన్ నంబర్ను వదిలేస్తాయి, అయితే user_id ఇప్పటికీ ఉంటుంది.
అభ్యర్థన నంబర్ యొక్క ఈవెంట్ లాగ్లో నమోదు అవుతుంది, ఆ తర్వాత నంబర్ 24/7 పర్యవేక్షించబడుతుంది. నంబర్కు నెలకు US$ 9 నుండి US$ 0.75 వరకు, మీరు నంబర్లు జోడించే కొద్దీ తగ్గుతూ, మొదటి 3 రోజులు ఉచితం.
తరచుగా అడిగే ప్రశ్నలు
ఇంపోర్ట్ రెండోసారి జరగగలదా?
కొత్త ఆన్బోర్డింగ్ ద్వారా మాత్రమే. Meta ప్రతి ఆన్బోర్డింగ్కు ఒక అభ్యర్థనను అనుమతిస్తుంది, కాబట్టి నంబర్ను డిస్కనెక్ట్ చేసి మళ్లీ కనెక్ట్ చేయాలి, అప్పుడు చాట్లు మళ్లీ వస్తాయి; సందేశ id ద్వారా ఇన్సర్ట్ చేయడం వల్ల రెండో పాస్ ఏదీ రెండుసార్లు జోడించదు.
easyCoexistence ఇంపోర్ట్ చేసిన చాట్ల కాపీ ఉంచుతుందా?
లేదు. హిస్టరీ మరియు కాంటాక్ట్లు Meta నుండి నేరుగా మీ ఎండ్పాయింట్కు వెళ్తాయి మరియు డిఫాల్ట్గా నిల్వ చేయబడవు. automations ఆన్ ఉన్న నంబర్ కోసం easyCoexistence సందేశ టెక్స్ట్ను మీరు ఎంచుకునే కాలం, అంటే 30, 90 లేదా 365 రోజులు (డిఫాల్ట్గా 90) ఉంచుతుంది, మరియు Conversations స్క్రీన్ దాన్ని చూపుతుంది; ఫార్వర్డ్ చేసిన డెలివరీలు 7 రోజుల వరకు, రన్ లాగ్లు 30 రోజులు ఉంచబడతాయి.
పేలోడ్లు ఎంత పెద్దవి కావచ్చు?
ఒకే Meta వెబ్హుక్ 3 MB వరకు తీసుకెళ్లగలదు, మరియు బిజీ నంబర్ చాలా హిస్టరీ చంక్స్ పంపుతుంది. మీ ఫ్రేమ్వర్క్ బాడీ పరిమితిని పెంచండి (Express డిఫాల్ట్ 100 kb), మరియు డేటాబేస్కు రాయడానికి ముందే acknowledge చేయండి.
ఏజెంట్కు ఇంపోర్ట్ అవసరమా?
లేదు. అది లేకుండా, కనెక్ట్ చేసిన తర్వాత వచ్చే మొదటి సందేశం నుండి మెమరీ మొదలై లైవ్ ట్రాఫిక్ నుండి పెరుగుతుంది. గత సంభాషణలు మొదటి రోజు నుండే సమాధానాలను రూపొందించాలంటే ఇంపోర్ట్ ముఖ్యం, ఉదాహరణకు తిరిగి వచ్చిన కస్టమర్ యొక్క చివరి ఆర్డర్.
చదవడం కొనసాగించండి
ప్రారంభించడానికి సిద్ధంగా ఉన్నారా?
నెలల్లో కాదు, నిమిషాల్లో WhatsApp Coexistence సెటప్ చేయండి. యాప్ ఫోన్లో పనిచేస్తూనే ఉంటుంది.
ఉచిత ట్రయల్ ప్రారంభించండిధృవీకరించిన తేదీ