EntrarComeçar teste grátis
easyCoexistence APIs oficiais

Ferramentas de redes sociais no Vercel AI SDK: Instagram, TikTok e mais

O Vercel AI SDK ganha ferramentas de redes sociais para Instagram, TikTok, Facebook, WhatsApp e mais canais a partir do servidor MCP do easyCoexistence. createMCPClient, do pacote @ai-sdk/mcp, abre uma conexão HTTP com https://easycoexistence.com/api/mcp; um OAuthClientProvider que você escreve mantém o login; e o tools() do cliente entra em generateText ou streamText para publicar, agendar, responder comentários e DMs e ler métricas pela API oficial de cada rede.

auth()

A função do @ai-sdk/mcp que finaliza um callback OAuth a partir de serverUrl e do authorizationCode, além de callbackState e callbackIssuer quando presentes.

isStepCount(1)

O stopWhen padrão do generateText, de modo que o modelo só lê o resultado de uma ferramenta quando o stopWhen permite mais etapas.

HTTP

O transporte MCP que o AI SDK recomenda para produção; seu transporte stdio é feito apenas para servidores locais.

1 hour

A validade de um token de acesso MCP do easyCoexistence; seu refresh token dura 60 dias e é substituído a cada renovação.

1,000 bytes

O maior texto que uma DM do Instagram comporta, medido em UTF-8, de modo que acentos e emojis ocupam mais espaço.

Como o AI SDK faz login no easyCoexistence?

Por meio de um OAuthClientProvider que você implementa sobre seu próprio armazenamento, que a função auth() do AI SDK conduz. A primeira chamada registra seu app no easyCoexistence como cliente público, salva o verificador PKCE e entrega a URL de consentimento por meio de redirectToAuthorization; ela retorna REDIRECT, e sua rota envia o usuário para lá. O easyCoexistence então redireciona para o seu callback com um código, e uma segunda chamada de auth() com authorizationCode troca o código por tokens. Depois que os tokens estão guardados, auth() usa o refresh token para gerar um novo par, em vez de mandar o usuário de volta. Mantenha redirectUrl e os redirect_uris registrados idênticos, pois o easyCoexistence os compara exatamente.

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

Como as ferramentas chegam ao generateText?

A partir do createMCPClient com o transporte HTTP, a URL do easyCoexistence e o provider. tools() retorna as ferramentas do servidor como ferramentas do AI SDK; mantenha pelo nome as que a tarefa precisa e passe-as ao generateText ou streamText. Defina stopWhen com isStepCount, porque por padrão a chamada para após uma etapa e o modelo nunca lê o que reply_to_comment retornou. Coloque as regras de cada rede em instructions, o parâmetro que a referência atual usa para o comportamento do modelo. Feche o cliente em um bloco finally, ou no callback onEnd do streamText, para que nenhuma conexão fique aberta.

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

Onde os tokens devem ficar em um host serverless?

Em algum lugar que sobreviva a uma única invocação: uma linha de banco de dados, Redis ou um key-value store, indexado pelo usuário do seu app a quem os tokens pertencem. Uma função na Vercel ou em outra plataforma serverless começa sem nada na memória, então um provider que guarda tokens em uma variável manda o usuário de volta à tela de consentimento após um cold start. Tokens de acesso duram uma hora e refresh tokens 60 dias, com um novo refresh token a cada uso, então um app que chama as ferramentas pelo menos uma vez a cada 60 dias continua conectado. Guarde o registro do cliente junto com os tokens, pois o provider lê os dois a cada conexão.

Como comentários e DMs chegam ao app?

Como POSTs assinados para um route handler, que set_social_webhook_destination registra para uma conta e que então recebe comentários, menções e DMs do Instagram e do Facebook, além de comentários do TikTok. Cada corpo traz platform, account_id, external_id e entry, o evento da rede como foi enviado. Leia o corpo como texto, confira o X-EC-Signature contra ele com o segredo de assinatura da conta e responda rápido: o easyCoexistence dá ao route handler 8 segundos e envia cada evento uma única vez, sem repetir. Coloque o evento em uma fila e deixe um worker chamar replyToEvent com ele, para que o tempo do modelo nunca conte contra os 8 segundos.

O que cada rede permite ao modelo fazer?

Tudo o que a API da conta permite, o que as instruções devem detalhar:

  • Instagram: publicações, Reels e Stories com imagens JPEG; respostas de DM apenas para quem escreveu nas últimas 24 horas, com no máximo 1,000 bytes.
  • Facebook: publicações na Página, respostas a comentários e respostas no Messenger dentro das mesmas 24 horas.
  • TikTok: vídeos e publicações com fotos; respostas a comentários sempre públicas, com o ID do vídeo como post_id, e sem DMs.
  • WhatsApp: send_message dentro da janela de atendimento de 24 horas, a contar da última mensagem do cliente, e send_template para os demais casos.
  • YouTube e LinkedIn: envios e publicações quando um usuário pede, respostas a comentários e métricas; nenhum dos dois encaminha eventos, então o app lê os novos comentários em intervalos regulares.

Erros comuns

  • Deixar o stopWhen no padrão. O generateText para após a primeira etapa, então o modelo chama reply_to_comment e nunca fica sabendo se a resposta foi enviada; permita algumas etapas com isStepCount.
  • Guardar os tokens em uma variável de nível de módulo em um host serverless. No próximo cold start ela estará vazia, e o usuário cai na tela de consentimento de novo; salve-os onde tokens() e saveTokens() alcançam um banco de dados.
  • Registrar uma URL de redirecionamento e enviar outra. O easyCoexistence compara redirect_uri com o registro exatamente, então uma barra final ou um caminho diferente encerra o login em uma página de erro.
  • Responder à atividade da própria conta. O Instagram devolve as DMs da conta como ecos e suas respostas públicas voltam como comentários, então ignore os dois antes que o prompt chegue ao modelo.
Fazendo isso com o EasyCoexistence

O easyCoexistence dá aos agentes que você cria com o Vercel AI SDK alcance para clientes no WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn e mais canais, cada um pela sua API oficial: ferramentas MCP atrás de um login OAuth, eventos assinados para comentários e DMs e uma fila de publicações com até 90 dias de antecedência, com cada conexão monitorada 24/7. De US$ 9 a US$ 0.75 por conexão por mês, caindo conforme você adiciona conexões, com os primeiros 3 dias grátis.

O easyCoexistence é uma API e um servidor MCP multicanal que conecta agentes de IA, como o Claude e o ChatGPT, ao WhatsApp, Instagram, TikTok, Facebook e mais. No WhatsApp, ele usa o Coexistence: a empresa continua usando o número no app WhatsApp Business enquanto a IA trabalha pela API oficial da Meta.

Perguntas frequentes

Isso exige Next.js ou hospedagem na Vercel?

Não. O AI SDK roda em Node.js, então qualquer host que sirva uma rota HTTPS funciona, e o cliente MCP só precisa de HTTPS de saída para easycoexistence.com.

Uma interface de chat pode transmitir as chamadas de ferramentas?

Sim. Passe as mesmas ferramentas ao streamText e feche o cliente MCP no seu callback onEnd, como o AI SDK documenta para respostas transmitidas.

O mesmo app pode responder mensagens do WhatsApp?

Sim. As ferramentas do número chegam pelo mesmo cliente: list_numbers para obter o connection_id e, em seguida, send_message dentro da janela de atendimento de 24 horas, a contar da última mensagem do cliente. O guia do AI SDK para WhatsApp cobre como recebê-las.

Quanto custa o easyCoexistence para um app do AI SDK?

De US$ 9 a US$ 0.75 por conexão por mês, caindo conforme você adiciona conexões, o mesmo em cada rede. O servidor MCP e a Partner API estão incluídos, e os primeiros 3 dias são grátis.

Continue lendo

Conecte seu primeiro canal em dois minutos.

Sem esperar aprovação das plataformas. Conecte o WhatsApp, o Instagram, o TikTok ou outro canal, peça para a sua IA publicar, responder ou trazer os números, e veja funcionando.

  • 3 dias grátis
  • Cancele quando quiser
  • Só APIs oficiais
  • Monitorado 24/7

Verificado em