AnmeldenKostenlose Testphase starten
easyCoexistence Offizielle APIs

Social-Media-Tools im Vercel AI SDK nutzen: Instagram, TikTok und mehr

Das Vercel AI SDK erhält Social-Media-Tools für Instagram, TikTok, Facebook, WhatsApp und weitere Kanäle vom MCP-Server von easyCoexistence. createMCPClient aus dem Paket @ai-sdk/mcp öffnet eine HTTP-Verbindung zu https://easycoexistence.com/api/mcp, ein OAuthClientProvider, den Sie schreiben, übernimmt die Anmeldung, und die tools() des Clients werden an generateText oder streamText übergeben, um zu veröffentlichen, zu planen, auf Kommentare und DMs zu antworten und Insights über die offizielle API jedes Netzwerks abzurufen.

auth()

Die Funktion aus @ai-sdk/mcp, die einen OAuth-Callback abschließt, mit serverUrl und authorizationCode, plus callbackState und callbackIssuer, wenn vorhanden.

isStepCount(1)

Der Standardwert von stopWhen bei generateText, sodass das Modell das Ergebnis eines Tools nur liest, wenn stopWhen weitere Schritte erlaubt.

HTTP

Der MCP-Transport, den das AI SDK für den Produktivbetrieb empfiehlt; sein stdio-Transport ist nur für lokale Server gedacht.

1 hour

Die Lebensdauer eines MCP-Zugriffstokens von easyCoexistence; sein Refresh-Token gilt 60 Tage und wird bei jeder Erneuerung ersetzt.

1,000 bytes

Die Länge, die eine Instagram-DM höchstens fassen kann, gemessen in UTF-8, sodass Akzente und Emojis mehr Platz brauchen.

Wie meldet sich das AI SDK bei easyCoexistence an?

Über einen OAuthClientProvider, den Sie auf Ihrem eigenen Speicher implementieren und den die auth()-Funktion des AI SDK steuert. Der erste Aufruf registriert Ihre App bei easyCoexistence als öffentlichen Client, speichert den PKCE-Verifier und übergibt die Zustimmungs-URL über redirectToAuthorization; er gibt REDIRECT zurück, und Ihre Route leitet den Nutzer dorthin. easyCoexistence leitet dann an Ihren Callback mit einem Code weiter, und ein zweiter auth()-Aufruf mit authorizationCode tauscht ihn gegen Tokens. Sobald die Tokens gespeichert sind, nutzt auth() das Refresh-Token für ein neues Paar, statt den Nutzer zurück zur Zustimmung zu schicken. Halten Sie redirectUrl und die registrierten redirect_uris identisch, da easyCoexistence sie genau abgleicht.

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");
}

Wie gelangen die Tools zu generateText?

Von createMCPClient mit dem HTTP-Transport, der easyCoexistence-URL und dem Provider. tools() liefert die Tools des Servers als AI-SDK-Tools; behalten Sie die, die die Aufgabe braucht, per Name und übergeben Sie sie an generateText oder streamText. Setzen Sie stopWhen mit isStepCount, denn standardmäßig stoppt der Aufruf nach einem Schritt, und das Modell liest nie, was reply_to_comment zurückgegeben hat. Legen Sie die Regeln für das Netzwerk in instructions ab, dem Parameter, den die aktuelle Referenz für das Verhalten des Modells verwendet. Schließen Sie den Client in einem finally-Block oder im onEnd-Callback von streamText, damit keine Verbindung offen bleibt.

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();
  }
}

Wo sollten die Tokens auf einem Serverless-Host liegen?

An einem Ort, der einen einzelnen Aufruf überdauert: in einer Datenbankzeile, Redis oder einem Key-Value-Store, zugeordnet dem Nutzer Ihrer App, dem die Tokens gehören. Eine Funktion auf Vercel oder einer anderen Serverless-Plattform startet ohne Speicher im Arbeitsspeicher, daher schickt ein Provider, der Tokens in einer Variablen hält, den Nutzer nach einem Cold Start zurück zum Zustimmungsbildschirm. Zugriffstokens gelten eine Stunde, Refresh-Tokens 60 Tage, und bei jeder Verwendung gibt es ein neues Refresh-Token; eine App, die die Tools mindestens einmal in 60 Tagen aufruft, bleibt daher angemeldet. Bewahren Sie die Client-Registrierung neben den Tokens auf, da der Provider bei jeder Verbindung beides liest.

Wie gelangen Kommentare und DMs zur App?

Als signierte POST-Anfragen an einen Route-Handler, den set_social_webhook_destination für ein Konto registriert und der danach Instagram- und Facebook-Kommentare, Erwähnungen und DMs sowie TikTok-Kommentare empfängt. Jeder Body enthält platform, account_id, external_id und entry, das Ereignis des Netzwerks, so wie es gesendet wurde. Lesen Sie den Body als Text, prüfen Sie X-EC-Signature dagegen mit dem Signing-Secret des Kontos, und antworten Sie zügig: easyCoexistence gibt der Route 8 Sekunden und sendet jedes Ereignis einmal, ohne erneuten Versuch. Legen Sie das Ereignis in eine Queue und lassen Sie einen Worker replyToEvent damit aufrufen, damit die Zeit des Modells nie auf die 8 Sekunden angerechnet wird.

Was darf das Modell in jedem Netzwerk tun?

So viel, wie die API des Kontos erlaubt, was die Anweisungen genau beschreiben sollten:

  • Instagram: Beiträge, Reels und Stories mit JPEG-Bildern; DM-Antworten nur an Personen, die in den letzten 24 Stunden geschrieben haben, mit höchstens 1,000 Byte.
  • Facebook: Seitenbeiträge, Kommentarantworten und Messenger-Antworten innerhalb derselben 24 Stunden.
  • TikTok: Videos und Fotobeiträge; Kommentarantworten immer öffentlich, mit der Video-ID als post_id, und keine DMs.
  • WhatsApp: send_message innerhalb von 24 Stunden nach der letzten Nachricht des Kunden, send_template für alle anderen.
  • YouTube und LinkedIn: Uploads und Beiträge auf Anfrage eines Nutzers, Kommentarantworten und Analysen; keines der beiden leitet Ereignisse weiter, daher liest die App neue Kommentare nach einem Zeitplan.

Häufige Fehler

  • stopWhen auf dem Standardwert lassen. generateText stoppt nach dem ersten Schritt, sodass das Modell reply_to_comment aufruft und nie erfährt, ob die Antwort gesendet wurde; erlauben Sie einige Schritte mit isStepCount.
  • Tokens in einer Variablen auf Modulebene auf einem Serverless-Host speichern. Beim nächsten Cold Start ist keine mehr da, und der Nutzer landet erneut auf dem Zustimmungsbildschirm; speichern Sie sie dort, wo tokens() und saveTokens() eine Datenbank erreichen.
  • Eine Redirect-URL registrieren und eine andere senden. easyCoexistence prüft redirect_uri genau gegen die Registrierung, daher beendet ein abschließender Schrägstrich oder ein anderer Pfad die Anmeldung mit einer Fehlerseite.
  • Auf die eigene Aktivität des Kontos antworten. Instagram sendet die DMs des Kontos als Echos zurück, und seine öffentlichen Antworten kommen als Kommentare zurück; überspringen Sie beides, bevor der Prompt das Modell erreicht.
Mit EasyCoexistence

easyCoexistence gibt den Agenten, die Sie mit dem Vercel AI SDK bauen, Reichweite zu Kunden auf WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn und weiteren Kanälen, jeweils über deren offizielle API: MCP-Tools hinter einer OAuth-Anmeldung, signierte Ereignisse für Kommentare und DMs sowie eine Posting-Queue bis zu 90 Tage im Voraus, wobei jede Verbindung rund um die Uhr überwacht wird. US$ 9 bis US$ 0.75 pro Verbindung und Monat, mit jeder weiteren Verbindung sinkend, die ersten 3 Tage kostenlos.

Häufig gestellte Fragen

Braucht das Next.js oder Vercel-Hosting?

Nein. Das AI SDK läuft in Node.js, daher funktioniert jeder Host, der eine HTTPS-Route bereitstellt, und der MCP-Client braucht nur ausgehendes HTTPS zu easycoexistence.com.

Kann eine Chat-Oberfläche die Tool-Aufrufe streamen?

Ja. Übergeben Sie dieselben Tools an streamText und schließen Sie den MCP-Client in seinem onEnd-Callback, wie das AI SDK es für gestreamte Antworten dokumentiert.

Kann dieselbe App auf WhatsApp-Nachrichten antworten?

Ja. Die Tools der Nummer kommen über denselben Client: list_numbers für die connection_id, danach send_message innerhalb von 24 Stunden nach der letzten Nachricht des Kunden. Die Anleitung des AI SDK zu WhatsApp behandelt den Empfang.

Was kostet easyCoexistence für eine App mit dem AI SDK?

US$ 9 bis US$ 0.75 pro Verbindung und Monat, mit jeder weiteren Verbindung sinkend, auf jedem Netzwerk gleich. Der MCP-Server und die Partner API sind enthalten, die ersten 3 Tage sind kostenlos.

Weiterlesen

Verbinden Sie Ihren ersten Kanal in zwei Minuten.

Keine Plattform-Prüfungen, auf die Sie warten müssen. Verbinden Sie WhatsApp, Instagram, TikTok oder einen anderen Kanal, bitten Sie dann Ihre KI, zu posten, zu antworten oder Berichte zu erstellen, und sehen Sie ihr bei der Arbeit zu.

  • 3 Tage kostenlos
  • Jederzeit kündbar
  • Nur offizielle APIs
  • Überwacht rund um die Uhr (24/7)

Verifiziert am