Coexistence எண்ணில் Node.js மற்றும் Python மூலம் WhatsApp AI ஏஜென்ட்டை உருவாக்குங்கள்
எண்ணின் செய்திகளை இரண்டு வழிகளில் பெறலாம்: நீங்கள் சரிபார்க்கும் HMAC கையொப்பத்துடன் (X-EC-Signature) முன்னனுப்பப்பட்டவை, அல்லது URL-இல் ரகசியக் குறியீட்டுடன் Meta-வின் வெப்ஹூக்கிலிருந்து நேரடியாக. பிறகு ஏற்கனவே கையாளப்பட்ட மெசேஜ் ஐடியைத் தவிர்க்கவும்; ஃபோனிலிருந்து ஒருவர் பதிலளித்ததை எக்கோ காட்டும் அரட்டையில் அமைதியாக இருங்கள்; வாடிக்கையாளரின் கடைசி மெசேஜிலிருந்து 24 மணி நேரத்திற்குள் மட்டுமே Cloud API வழியாக உங்கள் மாடலின் பதிலை அனுப்புங்கள்.
easyCoexistence வணிகம் WhatsApp Business ஆப்பில் தொடர்ந்து பயன்படுத்தும் எண்ணை Meta-வின் Cloud API-உடன் இணைக்கிறது, get_api_credentials மூலம் உங்கள் குறியீட்டுக்கு நற்சான்றுகளை வழங்குகிறது, ஆட்டோமேஷன்கள் இயக்கத்தில் இருக்கும்போது மெசேஜ்களை Meta-விடமிருந்து நேரடியாக உங்கள் சர்வருக்கோ அல்லது கையொப்பமிடப்பட்ட முன்னனுப்பல் வழியாகவோ அனுப்புகிறது.
கையொப்பத்தின் t மதிப்புக்கும் உங்கள் கடிகாரத்துக்கும் இடையே ஏற்கக்கூடிய மிகப்பெரிய இடைவெளி; ஒவ்வொரு மறுமுயற்சியும் புதிய t உடன் மீண்டும் கையொப்பமிடப்படும்.
முன்னனுப்பப்பட்ட POST 2xx பதிலுக்காக easyCoexistence எவ்வளவு நேரம் காத்திருக்கிறது, அதன் பிறகு அந்த டெலிவரியை மறுமுயற்சி செய்ய அது திட்டமிடும்.
HTTP 200 கிடைக்காத நேரடி வெப்ஹூக்கை Meta எவ்வளவு நேரம் மீண்டும் முயற்சிக்கிறது; இதனால் ஒரே மெசேஜ் இரண்டு முறை வரக்கூடும்.
பயனரின் கடைசி மெசேஜுக்குப் பிறகு வாடிக்கையாளர் சேவை சாளரம்; அதற்கு வெளியே Meta டெம்ப்ளேட் மெசேஜ்களை மட்டுமே ஏற்கும்.
WhatsApp Business ஆப் மற்றும் Cloud API இரண்டுடனும் பயன்படுத்தப்படும் எண்ணின் நிலையான த்ரூபுட்.
எந்த வழியை கோடிங் ஏஜென்ட் பயன்படுத்த வேண்டும்?
முன்னனுப்பப்பட்ட வழியில் எண் Automations on பயன்முறையில் இருக்கும்: Meta easyCoexistence-க்கு டெலிவரி செய்யும், ஆட்டோமேஷன்கள் இன்னும் இயங்கலாம், ஒவ்வொரு Meta மாற்றத்தின் கையொப்பமிடப்பட்ட நகலும் உங்கள் Forward URL-க்குச் செல்லும். ஒரு மாறுபாட்டுக்கு முன்னனுப்பல் தேவையில்லை: ஒரு ஆட்டோமேஷனின் வெப்ஹூக் அழைப்பு படி மெசேஜை உங்கள் எண்ட்பாயிண்ட்டுக்கு POST செய்கிறது, நீங்கள் திருப்பும் {"reply"} ஐ 20 வினாடிகளுக்குள் அனுப்புகிறது; நகல் தடுப்பு, ஃபோன் இடைநிறுத்தம், 24 மணி நேரச் சோதனை ஆகியவை உங்களுக்காகச் செய்யப்படும்.
நேரடி வழியில் Meta தனது வெப்ஹூக்கை நேரடியாக உங்கள் எண்ட்பாயிண்ட்டுக்கு அனுப்பும், அது set_webhook_destination மூலம் அமைக்கப்படும், easyCoexistence மெசேஜ்களைப் பார்க்காது. அந்த எண்ணுக்கு ஆட்டோமேஷன்கள் அணைக்கப்பட்டிருக்கும், எனவே எல்லாப் பாதுகாப்புச் சோதனைகளும் உங்களுடையவை; இணைத்த 24 மணி நேரத்திற்குள் இலக்கு சேமிக்கப்பட்டால் 6 மாத வரலாற்று இறக்குமதியும் உங்களுடையது. கீழே உள்ள மாதிரிகள் மூன்று நுழைவுப் புள்ளிகளையும் ஒரே பகிரப்பட்ட மையத்தால் கையாளுகின்றன.
| Forwarded, signed | Direct from Meta | |
|---|---|---|
| Number mode | Automations on (managed) | Direct to your server |
| Body | One Meta change: id, event, received_at, connection, value | Meta's envelope: object, entry, changes |
| Authentication | X-EC-Signature, HMAC-SHA256 with a per-number secret | A secret in the URL path |
| Acknowledge | Any 2xx within 10 seconds | HTTP 200; Meta retries other codes |
| Retries | 7 attempts over about 33 hours | Up to 7 days |
| Reply | Graph API, or {"reply"} to a Call my webhook step | Graph API |
| History import | Not requested | Requested if saved within 24 hours of connecting |
Node.js-இல் ஏஜென்ட் ஒரு மெசேஜை எப்படி கையாளுகிறது?
agent.mjs இரண்டு வழிகளும் பகிர்ந்துகொள்ளும் தர்க்கத்தைக் கொண்டுள்ளது. அது வாடிக்கையாளரின் கடைசி மெசேஜ் நேரத்தைப் பதிவு செய்கிறது; smb_message_echoes நிகழ்வு WhatsApp Business ஆப்பிலிருந்து யாரோ பதிலளித்ததைக் காட்டும்போது (easyCoexistence ஆட்டோமேஷன்கள் பயன்படுத்தும் இயல்புநிலை), அந்த அரட்டையில் 4 மணி நேரம் பின்வாங்குகிறது; ஏற்கனவே கையாளப்பட்ட மெசேஜ் ஐடியைத் தவிர்க்கிறது, 24 மணி நேர சாளரத்திற்குள் மட்டுமே அனுப்புகிறது. சாளரம் மெசேஜ் உங்களை வந்தடைந்த நேரத்தில் இருந்து அல்ல, மெசேஜின் சொந்த நேரமுத்திரையில் இருந்து அளவிடப்படுகிறது; ஏனெனில் மறுமுயற்சி செய்யப்பட்ட டெலிவரி மணிநேரம் கழித்து வரலாம்.
பயனர்கள் BSUID (from_user_id, அல்லது echoes-இல் to_user_id) மூலம் அடையாளம் காணப்படுகின்றனர், ஃபோன் எண் மாற்றாக இருக்கும்; BSUID மட்டுமே தெரிந்த பயனருக்கு to-க்குப் பதிலாக recipient பயன்படுத்தி பதில் அனுப்பப்படும். மாடல் அழைப்பு எந்த OpenAI-இணக்கமான chat completions API-ஐயும் பயன்படுத்துகிறது; விரும்பினால் உங்கள் வழங்குநரின் SDK-ஐப் பயன்படுத்தலாம்.
// agent.mjs: what the agent does with one Meta change, whichever route brought it.
const DAY = 24 * 3600 * 1000;
const PAUSE = 4 * 3600 * 1000; // quiet time after a person replies (automations default to 4 h)
const seen = new Set(); // handled ids: use Redis or your database in production
const lastInbound = new Map(); // user -> ms of their last message
const quietUntil = new Map(); // user -> ms until which a person has the chat
export function firstTime(id) {
if (seen.has(id)) return false;
seen.add(id);
return true;
}
export async function handleChange(field, value) {
if (field === "smb_message_echoes") {
// Someone answered from the WhatsApp Business app: step back on that chat.
for (const e of value.message_echoes ?? []) {
quietUntil.set(e.to_user_id ?? e.to, Number(e.timestamp) * 1000 + PAUSE);
}
return;
}
if (field !== "messages") return; // statuses ride in value.statuses: ignored here
for (const m of value.messages ?? []) {
if (!firstTime(m.id)) continue; // Meta delivered this message before
const user = m.from_user_id ?? m.from; // BSUID first, phone number as fallback
lastInbound.set(user, Math.max(Number(m.timestamp) * 1000, lastInbound.get(user) ?? 0));
if ((quietUntil.get(user) ?? 0) > Date.now()) continue; // a person has this chat
if (m.type !== "text") continue; // media: fetch it by id first (see the FAQ)
const reply = await askModel([{ role: "user", content: m.text.body }]);
if (!reply) continue;
if (Date.now() - lastInbound.get(user) >= DAY) continue; // window closed: template only
await sendText({ phone: m.from, bsuid: m.from_user_id }, reply);
}
}
// Any OpenAI-compatible chat completions API (OpenAI, OpenRouter...).
export async function askModel(turns) {
const res = await fetch(`${process.env.AI_BASE_URL}/chat/completions`, {
method: "POST",
headers: { Authorization: `Bearer ${process.env.AI_KEY}`, "Content-Type": "application/json" },
body: JSON.stringify({
model: process.env.AI_MODEL,
messages: [{ role: "system", content: process.env.AI_INSTRUCTIONS ?? "Answer briefly." }, ...turns],
}),
});
if (!res.ok) throw new Error(`AI provider answered ${res.status}`);
const data = await res.json();
return data.choices?.[0]?.message?.content?.trim() ?? "";
}
// send_endpoint and access_token come from get_api_credentials.
async function sendText({ phone, bsuid }, text) {
const res = await fetch(process.env.SEND_ENDPOINT, {
method: "POST",
headers: { Authorization: `Bearer ${process.env.WA_TOKEN}`, "Content-Type": "application/json" },
body: JSON.stringify({
messaging_product: "whatsapp",
recipient_type: "individual",
...(phone ? { to: phone } : { recipient: bsuid }), // a BSUID-only user gets recipient
type: "text",
text: { body: text.slice(0, 4096) },
}),
});
if (!res.ok) throw new Error(`Graph API answered ${res.status}: ${await res.text()}`);
}Node.js-இல் நிகழ்வுகளை எப்படிச் சரிபார்த்து வழிநடத்துவது?
server.mjs மூன்று நுழைவுப் புள்ளிகளையும் வெளிப்படுத்துகிறது. /ec/forward நிர்வகிக்கப்பட்ட எண்களின் முன்னனுப்பல்களை ஏற்கிறது: அந்த எண்ணின் forward secret-உடன் மூலப் பைட்டுகளில் X-EC-Signature-ஐ சரிபார்க்கிறது, எந்த வேலைக்கும் முன்பே 200 அளிக்கிறது, ஏற்கனவே ஏற்ற டெலிவரி ஐடியைத் தவிர்க்கிறது; ஏனெனில் மறுமுயற்சியில் அதே ஐடியும் புதிய கையொப்பமும் வரும். உடலில் உள்ள event என்பது Meta-வின் புலப் பெயர், value என்பது Meta-வின் change, மாறாமல். /ec/agent ஒரு வெப்ஹூக் அழைப்பு படிக்குப் பதிலளிக்கிறது, அந்த ஆட்டோமேஷனின் சொந்த Signing secret உடன் கையொப்பமிடப்பட்டது, வரலாற்றை அரட்டைத் திருப்பங்களாக மாற்றுகிறது. /meta/:secret நேரடி வழி: Meta-வின் GET handshake-க்கு மூல hub.challenge உடன் பதிலளிக்கிறது, POST-களை secret பாதையில் மட்டுமே ஏற்கிறது.
HMAC விசை முழு ரகசியம், whsec_ முன்னொட்டுடன், UTF-8 உரையாக. express.raw பைட்டுகளைப் பாதுகாக்கிறது; அதன் 5 MB வரம்பு 3 MB வரையிலான Meta பேலோடுகளுக்கு இடம் விடுகிறது.
// server.mjs: Node 18+, npm i express, then node server.mjs
import crypto from "node:crypto";
import express from "express";
import { askModel, firstTime, handleChange } from "./agent.mjs";
const app = express();
// X-EC-Signature: t=<unix>,v1=<hex HMAC-SHA256 of "<t>.<raw body>">, keyed with the whole secret.
export function verifyEc(raw, header, secret, toleranceSec = 300) {
const m = /^t=(\d+),v1=([0-9a-f]{64})$/.exec(String(header ?? "").trim());
if (!m || !Buffer.isBuffer(raw) || !secret) return false;
if (Math.abs(Date.now() / 1000 - Number(m[1])) > toleranceSec) return false; // stale or replayed
const expected = crypto.createHmac("sha256", secret).update(`${m[1]}.`).update(raw).digest();
return crypto.timingSafeEqual(expected, Buffer.from(m[2], "hex"));
}
function sameSecret(a, b) {
const x = Buffer.from(String(a)), y = Buffer.from(String(b ?? ""));
return x.length === y.length && crypto.timingSafeEqual(x, y);
}
// Route A, forwarded: a managed number's Forward URL. One Meta change per POST.
app.post("/ec/forward", express.raw({ type: "*/*", limit: "5mb" }), (req, res) => {
if (!verifyEc(req.body, req.get("X-EC-Signature"), process.env.EC_FORWARD_SECRET)) return res.sendStatus(401);
res.sendStatus(200); // acknowledge inside 10 s, then work
const d = JSON.parse(req.body.toString("utf8"));
if (!firstTime(`delivery:${d.id}`)) return; // a retry of a delivery already taken
handleChange(d.event, d.value).catch(console.error); // d.event is the Meta field name
});
// Route A, synchronous: a "Call my webhook" step. Answer {"reply"} within 20 s.
app.post("/ec/agent", express.raw({ type: "*/*", limit: "1mb" }), async (req, res) => {
if (!verifyEc(req.body, req.get("X-EC-Signature"), process.env.EC_AUTOMATION_SECRET)) return res.sendStatus(401);
const step = JSON.parse(req.body.toString("utf8"));
const turns = step.history.map((h) => ({ role: h.direction === "in" ? "user" : "assistant", content: h.text }));
while (turns[0]?.role === "assistant") turns.shift();
if (!turns.length) turns.push({ role: "user", content: step.message?.text ?? "" }); // tests carry no history
res.json({ reply: await askModel(turns) }); // step.dry_run is true on "Test it"
});
// Route B, direct: Meta's own envelope. The secret path is the credential.
app.get("/meta/:secret", (req, res) => {
if (!sameSecret(req.params.secret, process.env.PATH_SECRET)) return res.sendStatus(404);
if (req.query["hub.mode"] === "subscribe" && req.query["hub.verify_token"] === process.env.VERIFY_TOKEN) {
return res.type("text/plain").send(String(req.query["hub.challenge"]));
}
res.sendStatus(403);
});
app.post("/meta/:secret", express.json({ limit: "5mb" }), (req, res) => {
if (!sameSecret(req.params.secret, process.env.PATH_SECRET)) return res.sendStatus(404);
res.sendStatus(200); // Meta retries anything but 200
for (const entry of req.body.entry ?? []) {
for (const change of entry.changes ?? []) handleChange(change.field, change.value).catch(console.error);
}
});
app.listen(process.env.PORT ?? 3000);அதே ஏஜென்ட் Python-இல் எப்படி இருக்கும்?
அதே மூன்று வழிகளும் அதே விதிகளும் கொண்ட ஒரே Flask கோப்பு. HMAC-க்கு request.get_data() மூலப் உடலைத் தருகிறது, நிலையான-நேர ஒப்பீட்டுக்கு hmac.compare_digest பயன்படுகிறது, 200 அளித்த பிறகு வேலை பின்னணி த்ரெட்டில் நடக்கிறது; எனவே easyCoexistence-உம் Meta-வும் உங்கள் மாடலுக்காகக் காத்திருப்பதில்லை. உருவாக்கத்தின்போது flask --app agent run மூலமும், உற்பத்தியில் gunicorn அல்லது வேறு WSGI சர்வருக்குப் பின்னாலும் இயக்குங்கள்.
நினைவகத்திலுள்ள செட் மற்றும் அகராதிகள் ஒரே செயல்முறைக்குப் பொருந்தும். பல workers அல்லது நிகழ்வுகளுடன், அவற்றை Redis அல்லது உங்கள் தரவுத்தளத்திற்கு நகர்த்துங்கள்; மெசேஜ் ஐடிகளுக்கு காலாவதியுடன் set-if-absent எழுத்தைப் பயன்படுத்துங்கள், இல்லையெனில் இரண்டு workers ஒரே மெசேஜுக்குப் பதிலளிக்கும்.
# agent.py: pip install flask requests, then flask --app agent run
import hashlib, hmac, json, os, re, threading, time
import requests
from flask import Flask, abort, request
app = Flask(__name__)
DAY, PAUSE = 24 * 3600, 4 * 3600
seen, last_inbound, quiet_until = set(), {}, {} # use Redis or a database in production
lock = threading.Lock()
def verify_ec(raw: bytes, header: str, secret: str, tolerance: int = 300) -> bool:
m = re.fullmatch(r"t=([0-9]+),v1=([0-9a-f]{64})", (header or "").strip())
if not m or not secret or abs(time.time() - int(m[1])) > tolerance:
return False
expected = hmac.new(secret.encode(), m[1].encode() + b"." + raw, hashlib.sha256).hexdigest()
return hmac.compare_digest(expected, m[2])
def first_time(key: str) -> bool:
with lock:
if key in seen:
return False
seen.add(key)
return True
def ask_model(turns: list) -> str: # any OpenAI-compatible chat completions API
r = requests.post(f"{os.environ['AI_BASE_URL']}/chat/completions", timeout=30,
headers={"Authorization": f"Bearer {os.environ['AI_KEY']}"},
json={"model": os.environ["AI_MODEL"], "messages": [
{"role": "system", "content": os.environ.get("AI_INSTRUCTIONS", "Answer briefly.")}, *turns]})
r.raise_for_status()
return (r.json()["choices"][0]["message"]["content"] or "").strip()
def send_text(phone, bsuid, text: str) -> None: # SEND_ENDPOINT and WA_TOKEN: get_api_credentials
to = {"to": phone} if phone else {"recipient": bsuid}
r = requests.post(os.environ["SEND_ENDPOINT"], timeout=15,
headers={"Authorization": f"Bearer {os.environ['WA_TOKEN']}"},
json={"messaging_product": "whatsapp", "recipient_type": "individual", **to,
"type": "text", "text": {"body": text[:4096]}})
r.raise_for_status()
def handle_change(field: str, value: dict) -> None:
if field == "smb_message_echoes": # a person answered from the app: step back
for e in value.get("message_echoes", []):
quiet_until[e.get("to_user_id") or e.get("to")] = int(e["timestamp"]) + PAUSE
return
if field != "messages":
return
for m in value.get("messages", []):
if not first_time(m["id"]): # Meta delivered this message before
continue
user = m.get("from_user_id") or m.get("from")
last_inbound[user] = max(int(m["timestamp"]), last_inbound.get(user, 0))
if quiet_until.get(user, 0) > time.time() or m.get("type") != "text":
continue
reply = ask_model([{"role": "user", "content": m["text"]["body"]}])
if reply and time.time() - last_inbound[user] < DAY: # past 24 h: template only
send_text(m.get("from"), m.get("from_user_id"), reply)
def later(field, value):
threading.Thread(target=handle_change, args=(field, value), daemon=True).start()
@app.post("/ec/forward") # route A: a managed number's Forward URL
def forward():
raw = request.get_data()
if not verify_ec(raw, request.headers.get("X-EC-Signature", ""), os.environ["EC_FORWARD_SECRET"]):
abort(401)
d = json.loads(raw)
if first_time("delivery:" + d["id"]): # skip retries of a delivery already taken
later(d["event"], d["value"])
return "", 200
@app.post("/ec/agent") # route A: a "Call my webhook" step, answer within 20 s
def agent_step():
raw = request.get_data()
if not verify_ec(raw, request.headers.get("X-EC-Signature", ""), os.environ["EC_AUTOMATION_SECRET"]):
abort(401)
step = json.loads(raw)
turns = [{"role": "user" if h["direction"] == "in" else "assistant", "content": h["text"]}
for h in step["history"]]
while turns and turns[0]["role"] == "assistant":
turns.pop(0)
turns = turns or [{"role": "user", "content": step["message"]["text"] or ""}]
return {"reply": ask_model(turns)}
@app.get("/meta/<secret>") # route B: Meta's GET handshake
def meta_handshake(secret):
if not hmac.compare_digest(secret.encode(), os.environ["PATH_SECRET"].encode()):
abort(404)
if (request.args.get("hub.mode") == "subscribe"
and request.args.get("hub.verify_token") == os.environ["VERIFY_TOKEN"]):
return request.args.get("hub.challenge", ""), 200, {"Content-Type": "text/plain"}
abort(403)
@app.post("/meta/<secret>") # route B: Meta's envelope, straight from Meta
def meta_events(secret):
if not hmac.compare_digest(secret.encode(), os.environ["PATH_SECRET"].encode()):
abort(404)
for entry in (request.get_json(silent=True) or {}).get("entry", []):
for change in entry.get("changes", []):
later(change.get("field"), change.get("value", {}))
return "", 200நகல் பதில்களை எப்படித் தவிர்ப்பது?
நகல்களுக்கு ஆறு பொதுவான காரணங்கள் உள்ளன; மேலே உள்ள மாதிரிகள் முதல் ஐந்தைக் கையாளுகின்றன:
- Meta-வின் மறுமுயற்சிகள். HTTP 200 அல்லாத எதற்கும் பிறகு நேரடி வெப்ஹூக் 7 நாட்கள் வரை மறுமுயற்சி செய்யப்படுகிறது; மெசேஜ் ஐடிகளின் சேமிப்பை வைத்து ஏற்கனவே கையாளப்பட்ட ஐடிகளைத் தவிர்க்கவும்.
- முன்னனுப்பல் மறுமுயற்சிகள். 2xx கிடைக்காத டெலிவரியை easyCoexistence 10 வினாடிகளுக்குப் பிறகு அதே ஐடியுடன் மறுமுயற்சி செய்கிறது; ஏற்கனவே ஏற்ற ஐடிகளைத் தவிர்க்கவும், பிறகு மெசேஜ் ஐடியில் நகலை நீக்கவும், ஏனெனில் Meta மீண்டும் அனுப்பும் மாற்றம் புதிய ஐடியுடன் மீண்டும் முன்னனுப்பப்படும்.
- மெதுவான ஒப்புகைகள். முதலில் பதிலளித்து பிறகு வேலை செய்யுங்கள்; மாடலுக்காகக் காத்திருக்கும் கையாளி நேரம் முடிந்துவிடும், அதே நிகழ்வு மீண்டும் வரும்.
- ஃபோனில் ஒருவர்.
smb_message_echoesநிகழ்வு ஒருவர் ஆப்பிலிருந்து பதிலளித்ததைக் குறிக்கிறது; அந்த அரட்டையில் சில மணி நேரம் அமைதியாக இருங்கள். - பல workers. நினைவகச் செட்டுகள் செயல்முறைகளுக்கிடையே பகிரப்படாது; சேமிப்புகளை Redis அல்லது உங்கள் தரவுத்தளத்திற்கு நகர்த்துங்கள்.
- இரண்டு பதிலளிப்பவர்கள். ஒரே அரட்டைகளில் AI-பதில் ஆட்டோமேஷனும் உங்கள் சொந்த ஏஜென்டும் இரண்டும் பதிலளிக்கும்; உங்கள் Graph API அனுப்பல்கள் எக்கோக்கள் அல்ல, எனவே ஆட்டோமேஷன்களை இடைநிறுத்தாது. ஒரு எண்ணுக்கு ஒரே பதிலளிப்பவரைத் தேர்ந்தெடுங்கள்.
ரகசியங்களும் நற்சான்றுகளும் எங்கிருந்து வருகின்றன?
டாஷ்போர்டிலிருந்து அல்லது MCP connector-இலிருந்து; அவை உங்கள் சர்வரின் சூழலில் மட்டுமே இருக்க வேண்டும். get_api_credentials graph_api_base, waba_id, phone_number_id, send_endpoint மற்றும் access_token ஐத் திருப்பும்; access_token என்பது வணிகத்தின் சொந்த டோக்கன். எண்ணின் பக்கம் உங்கள் சொந்த அமைப்புடன் இணைக்கும் பகுதியின் கீழ் அதே மதிப்புகளைக் காட்டுகிறது. access_token null எனில், கணினியிலிருந்து மீண்டும் இணை மூலம் எண்ணை மீண்டும் இணைத்து டோக்கனை வழங்குங்கள். டோக்கனை கடவுச்சொல் போலக் கருதுங்கள்; அதை வைத்திருக்கும் எவரும் வணிகத்தின் பெயரில் மெசேஜ் அனுப்ப முடியும்.
பொதுவான தவறுகள்
- JSON மீண்டும் வரிசைப்படுத்தப்பட்ட உடலில் HMAC-ஐச் சரிபார்த்தல். Python-இன் json.dumps இயல்பாக பிரிப்பான்களுக்குப் பிறகு இடைவெளிகளைச் சேர்க்கும்; எனவே பாகுபடுத்தி மீண்டும் வெளியிடப்பட்ட உடல் பொருந்தாது; மூலப் பைட்டுகளைச் சரிபார்க்கவும்.
- ரகசியத்தை Base64-decode செய்வது அல்லது அதன் whsec_ முன்னொட்டை நீக்குவது. விசை என்பது முழு சரமும் UTF-8 உரையாக, உங்களுக்கு ஒருமுறை காட்டப்பட்டபடியே.
- நேரடி வழியில் உங்கள் சொந்த Meta app secret-உடன் X-Hub-Signature-256-ஐ சரிபார்ப்பது. Meta easyCoexistence-இன் app secret-உடன் கையொப்பமிடுகிறது, அது பகிரப்படுவதில்லை; எனவே உண்மையான நிகழ்வுகள் தோல்வியடையும்; பாதை ரகசியத்தால் அங்கீகரிக்கவும்.
- வருகை நேரத்திலிருந்து சாளரத்தைப் படித்தல். மணி நேரம் கழித்து மறுமுயற்சி செய்யப்பட்ட முன்னனுப்பல் இன்னும் Meta-வின் அசல் நேர முத்திரையைக் கொண்டிருக்கும்; அதனுடன் ஒப்பிடுங்கள், இல்லையெனில் ஏஜென்ட் 24 மணி நேரத்திற்குப் பிறகு பதிலளிக்கும், Meta அனுப்பலை மறுக்கும்.
ஒவ்வொரு எண்ணும் 24/7 கண்காணிக்கப்படுகிறது, இணைப்பு துண்டிக்கப்பட்டால் எச்சரிக்கைகள் வரும். ஒரு எண்ணுக்கு மாதம் US$ 9 முதல் US$ 0.75 வரை, எண்கள் சேர சேரக் குறையும்; முதல் 3 நாட்கள் இலவசம்.
அடிக்கடி கேட்கப்படும் கேள்விகள்
ஏஜென்ட் குரல் குறிப்புகளையும் புகைப்படங்களையும் புரிந்துகொள்ள முடியுமா?
ஆம், உங்கள் சொந்த குறியீட்டுடன். Meta-வின் பேலோடில் மீடியா ஐடி உள்ளது: GET /<media-id> மற்றும் எண்ணின் டோக்கனுடன் அதைப் பதிவிறக்குங்கள், திருப்பப்பட்ட URL-ஐ அதே Authorization தலைப்புடன் பெறுங்கள், பிறகு உங்கள் மாடலுடன் படியெடுக்கவோ விவரிக்கவோ செய்யுங்கள். ஆட்டோமேஷன்கள் [voice message] போன்ற இடப்பிடிப்புகளை மட்டுமே பார்க்கும்.
மாதிரிகளுக்கு எந்த மாடல்களைப் பயன்படுத்தலாம்?
OpenAI-இணக்கமான chat completions எண்ட்பாயிண்ட்டுக்குப் பின்னால் உள்ள எந்த மாடலும், OpenAI-இன் மாடல்களும் OpenRouter வழியாக அணுகப்படுபவையும் உட்பட; அல்லது askModel மற்றும் ask_model-ஐ உங்கள் வழங்குநரின் SDK-ஆல் மாற்றுங்கள். easyCoexistence AI-க்கு ஒருபோதும் கட்டணம் வசூலிப்பதில்லை: உங்கள் வழங்குநர் நேரடியாக உங்களுக்குக் கட்டணம் விதிப்பார்.
ஏஜென்ட் ஓர் உரையாடலைத் தொடங்க முடியுமா?
அங்கீகரிக்கப்பட்ட டெம்ப்ளேட் மூலம் மட்டுமே, அதே send எண்ட்பாயிண்ட்டுக்கு `type` மதிப்பை `template` என அமைத்து அனுப்பப்படும். Coexistence எண்ணில் டெம்ப்ளேட்கள் API வழியாக மட்டுமே செல்லும், ஃபோன் ஆப்பிலிருந்து ஒருபோதும் இல்லை; Meta அவற்றை வணிகத்தின் சொந்த WhatsApp Business Account-க்கு ஒவ்வொரு மெசேஜுக்கும் கட்டணம் விதிக்கும்.
ஒரே ஏஜென்ட் பல எண்களுக்குச் சேவை செய்ய முடியுமா?
ஆம். value.metadata.phone_number_id அல்லது connection.phone_number_id மூலம் வழிநடத்துங்கள்; ஒவ்வொரு எண்ணுக்கும் அதனுடையதே என்பதால் ஒரு send எண்ட்பாயிண்ட், ஒரு டோக்கன் மற்றும் ஒரு forward secret ஐ வைத்திருங்கள்.
தொடர்ந்து படிக்கவும்
தொடங்கத் தயாரா?
மாதங்கள் ஆகாமல், சில நிமிடங்களில் WhatsApp Coexistence-ஐ அமைக்குங்கள். ஆப்ஸ் போனில் தொடர்ந்து இயங்கும்.
இலவச ட்ரையலைத் தொடங்குங்கள்இதில் சரிபார்க்கப்பட்டது: