Se connecterCommencer l’essai gratuit
easyCoexistence API officielles

Utiliser les outils de réseaux sociaux dans le Vercel AI SDK : Instagram, TikTok et plus

Le Vercel AI SDK reçoit des outils de réseaux sociaux pour Instagram, TikTok, Facebook, WhatsApp et d'autres canaux, depuis le serveur MCP d'easyCoexistence. createMCPClient, du package @ai-sdk/mcp, ouvre une connexion HTTP vers https://easycoexistence.com/api/mcp. Un OAuthClientProvider que vous écrivez gère l'authentification, et les outils du client, obtenus via tools(), passent dans generateText ou streamText pour publier, planifier, répondre aux commentaires et aux DM et lire les statistiques via l'API officielle de chaque réseau.

auth()

La fonction de @ai-sdk/mcp qui termine un callback OAuth à partir de serverUrl et de l'authorizationCode, plus callbackState et callbackIssuer lorsqu'ils sont présents.

isStepCount(1)

Le stopWhen par défaut de generateText : le modèle ne lit le résultat d'un outil que si stopWhen autorise davantage d'étapes.

HTTP

Le transport MCP que le Vercel AI SDK recommande en production ; son transport stdio est réservé aux serveurs locaux.

1 hour

La durée de vie d'un token d'accès MCP d'easyCoexistence ; son refresh token dure 60 jours et est remplacé à chaque rafraîchissement.

1,000 bytes

La taille maximale d'un DM Instagram, mesurée en UTF-8 : les accents et les emojis en prennent davantage.

Comment le Vercel AI SDK s'authentifie-t-il auprès d'easyCoexistence ?

Via un OAuthClientProvider que vous implémentez sur votre propre stockage, piloté par la fonction auth() du Vercel AI SDK. Le premier appel enregistre votre application auprès d'easyCoexistence comme client public, sauvegarde le verifier PKCE et vous fournit l'URL de consentement via redirectToAuthorization ; il renvoie REDIRECT, et votre route y envoie l'utilisateur. easyCoexistence redirige ensuite vers votre callback avec un code, et un second appel à auth() avec authorizationCode l'échange contre des tokens. Une fois les tokens stockés, auth() utilise le refresh token pour en obtenir une nouvelle paire au lieu de renvoyer l'utilisateur. Gardez redirectUrl et les redirect_uris enregistrés strictement identiques, car easyCoexistence les compare à la lettre.

An OAuthClientProvider over your database, with the two routes it needs
import { auth, type OAuthClientProvider } from "@ai-sdk/mcp";

export const MCP_URL = "https://easycoexistence.com/api/mcp";
const CALLBACK = "https://app.example.com/api/easycoexistence/callback";

// db is your own key-value store (Postgres, Redis, Vercel KV); one set of keys per user
export function easyAuth(userId: string): OAuthClientProvider {
  const k = (name: string) => "easycoexistence:" + userId + ":" + name;
  return {
    get redirectUrl() { return CALLBACK; },
    get clientMetadata() {
      return {
        client_name: "Acme app", // shown on easyCoexistence's consent screen
        redirect_uris: [CALLBACK],
        grant_types: ["authorization_code", "refresh_token"],
        response_types: ["code"],
        token_endpoint_auth_method: "none", // easyCoexistence registers public clients
      };
    },
    clientInformation: () => db.get(k("client")),
    saveClientInformation: (info) => db.set(k("client"), info),
    isClientInformationDynamicallyRegistered: async () => Boolean(await db.get(k("client"))),
    tokens: () => db.get(k("tokens")),
    saveTokens: (tokens) => db.set(k("tokens"), tokens),
    saveCodeVerifier: (verifier) => db.set(k("verifier"), verifier),
    codeVerifier: () => db.get(k("verifier")),
    redirectToAuthorization: (url) => db.set(k("sign-in"), url.href),
  };
}

// GET /api/easycoexistence/connect: send the user to the consent screen
export async function connect(userId: string) {
  const result = await auth(easyAuth(userId), { serverUrl: MCP_URL });
  if (result === "AUTHORIZED") return new Response("Already connected");
  return Response.redirect(await db.get("easycoexistence:" + userId + ":sign-in"));
}

// GET /api/easycoexistence/callback: trade the code for tokens
export async function callback(req: Request, userId: string) {
  const code = new URL(req.url).searchParams.get("code");
  if (!code) return new Response("Sign-in was cancelled", { status: 400 });
  await auth(easyAuth(userId), { serverUrl: MCP_URL, authorizationCode: code });
  return Response.redirect("https://app.example.com/settings");
}

Comment les outils parviennent-ils à generateText ?

Depuis createMCPClient avec le transport HTTP, l'URL d'easyCoexistence et le provider. tools() renvoie les outils du serveur sous forme d'outils du Vercel AI SDK ; retenez par leur nom ceux dont la tâche a besoin et passez-les à generateText ou streamText. Réglez stopWhen avec isStepCount, car par défaut l'appel s'arrête après une étape et le modèle ne lit jamais ce que reply_to_comment a renvoyé. Placez les règles du réseau dans instructions, le paramètre que la référence actuelle utilise pour le comportement du modèle. Fermez le client dans un bloc finally, ou dans le callback onEnd de streamText, pour qu'aucune connexion ne reste ouverte.

Reply to one forwarded comment or DM with a filtered set of tools
import { createMCPClient } from "@ai-sdk/mcp";
import { generateText, isStepCount, type LanguageModel } from "ai";
import { easyAuth, MCP_URL } from "./easycoexistence-auth";

const REPLY_TOOLS = new Set(["list_social_comments", "reply_to_comment", "hide_comment", "send_social_dm"]);

export async function replyToEvent(userId: string, model: LanguageModel, event: unknown) {
  const mcp = await createMCPClient({
    transport: { type: "http", url: MCP_URL, authProvider: easyAuth(userId) },
  });
  try {
    const tools = Object.fromEntries(
      Object.entries(await mcp.tools()).filter(([name]) => REPLY_TOOLS.has(name)),
    );
    const { text } = await generateText({
      model,
      tools,
      stopWhen: isStepCount(4),
      instructions:
        "Reply to comments and DMs for Acme on the event's account_id. TikTok replies are public " +
        "and need the video ID as post_id. Instagram DMs only go to people who wrote in the last 24 hours.",
      prompt: JSON.stringify(event),
    });
    return text;
  } finally {
    await mcp.close();
  }
}

Où conserver les tokens sur un hébergeur serverless ?

Dans un endroit qui survit à une invocation : une ligne de base de données, Redis ou un magasin clé-valeur, indexé par l'utilisateur de votre application auquel les tokens appartiennent. Une fonction sur Vercel ou une autre plateforme serverless démarre sans rien en mémoire ; un provider qui garde les tokens dans une variable renvoie donc l'utilisateur à l'écran de consentement après un cold start. Les tokens d'accès durent une heure et les refresh tokens 60 jours, chacun étant remplacé à chaque utilisation, donc une application qui appelle les outils au moins une fois tous les 60 jours reste connectée. Gardez l'enregistrement du client à côté des tokens, car le provider lit les deux à chaque connexion.

Comment les commentaires et les DM arrivent-ils dans l'application ?

Sous forme de POST signés vers un gestionnaire de route, que set_social_webhook_destination enregistre pour un compte et qui reçoit ensuite les commentaires, mentions et DM Instagram et Facebook, ainsi que les commentaires TikTok. Chaque corps contient platform, account_id, external_id et entry, l'événement du réseau tel qu'il a été envoyé. Lisez le corps comme texte, vérifiez X-EC-Signature par rapport à celui-ci avec le secret de signature du compte, et répondez vite : easyCoexistence accorde 8 secondes à la route et envoie chaque événement une seule fois, sans nouvelle tentative. Mettez l'événement dans une file d'attente et laissez un worker appeler replyToEvent avec lui, pour que le temps du modèle ne compte jamais dans ces 8 secondes.

Que permet chaque réseau au modèle ?

Autant que l'API du compte le permet, ce que les instructions doivent détailler :

  • Instagram : publications, Reels et Stories avec images JPEG ; réponses aux DM uniquement aux personnes ayant écrit dans les 24 dernières heures, en 1 000 octets au maximum.
  • Facebook : publications de Page, réponses aux commentaires et réponses Messenger dans les mêmes 24 heures.
  • TikTok : vidéos et publications photo ; réponses aux commentaires toujours publiques, avec l'ID de la vidéo comme post_id, et aucun DM.
  • WhatsApp : send_message dans les 24 heures suivant le dernier message du client, send_template pour tous les autres.
  • YouTube et LinkedIn : envois et publications sur demande de l'utilisateur, réponses aux commentaires et statistiques ; aucun des deux ne transmet d'événements, donc l'application lit les nouveaux commentaires selon un planning.

Erreurs courantes

  • Laisser stopWhen à sa valeur par défaut. generateText s'arrête après la première étape, donc le modèle appelle reply_to_comment et ne saura jamais si la réponse est partie ; autorisez quelques étapes avec isStepCount.
  • Garder les tokens dans une variable de niveau module sur un hébergeur serverless. Au prochain cold start il n'y en a plus, et l'utilisateur retombe sur l'écran de consentement ; enregistrez-les là où tokens() et saveTokens() atteignent une base de données.
  • Enregistrer une URL de redirection et en envoyer une autre. easyCoexistence vérifie redirect_uri à la lettre face à l'enregistrement, donc une barre finale ou un chemin différent termine l'authentification sur une page d'erreur.
  • Répondre à l'activité propre du compte. Instagram renvoie les DM envoyés par le compte sous forme d'échos et ses réponses publiques reviennent comme commentaires ; ignorez les deux avant que le message n'atteigne le modèle.
Faire cela avec EasyCoexistence

easyCoexistence donne à vos agents construits avec le Vercel AI SDK un accès à vos clients sur WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn et d'autres canaux, chacun via son API officielle : outils MCP derrière une authentification OAuth, événements signés pour les commentaires et les DM, et une file de publication programmable jusqu'à 90 jours à l'avance, avec chaque connexion surveillée 24/7. De US$ 9 à US$ 0,75 par connexion et par mois, qui baisse à mesure que vous ajoutez des connexions, avec un essai gratuit de 3 jours.

Questions fréquemment posées

Ceci nécessite-t-il Next.js ou un hébergement Vercel ?

Non. Le Vercel AI SDK fonctionne dans Node.js, donc tout hébergeur qui sert une route HTTPS convient, et le client MCP n'a besoin que d'un accès HTTPS sortant vers easycoexistence.com.

Une interface de chat peut-elle diffuser les appels d'outils ?

Oui. Passez les mêmes outils à streamText et fermez le client MCP dans son callback onEnd, comme la documentation du Vercel AI SDK le recommande pour les réponses en flux.

La même application peut-elle répondre aux messages WhatsApp ?

Oui. Les outils du numéro passent par le même client : list_numbers pour le connection_id, puis send_message dans les 24 heures suivant le dernier message du client. Le guide du Vercel AI SDK pour WhatsApp explique comment les recevoir.

Combien coûte easyCoexistence pour une application Vercel AI SDK ?

De US$ 9 à US$ 0,75 par connexion et par mois, qui baisse à mesure que vous ajoutez des connexions, au même tarif sur chaque réseau. Le serveur MCP et la Partner API sont inclus, et un essai gratuit de 3 jours est offert.

Poursuivre la lecture

Connectez votre premier canal en deux minutes.

Aucune validation de plateforme à attendre. Connectez WhatsApp, Instagram, TikTok ou un autre canal, puis demandez à votre IA de publier, de répondre ou de faire un rapport, et regardez-la travailler.

  • 3 jours gratuits
  • Résiliable à tout moment
  • API officielles uniquement
  • Supervisé 24/7

Vérifié le