Iniciar sessãoIniciar teste gratuito
easyCoexistence APIs oficiais

Dê a uma crew do CrewAI ferramentas para Instagram, TikTok e WhatsApp

Uma crew do CrewAI recebe o Instagram, o TikTok, o WhatsApp e mais canais como ferramentas quando a lista mcps de cada agente inclui um MCPServerHTTP para https://easycoexistence.com/api/mcp, com um token de acesso OAuth da easyCoexistence no cabeçalho Authorization. O cliente MCP do CrewAI envia cabeçalhos em vez de executar um início de sessão, por isso a crew renova o token em cada kickoff, e as ferramentas personalizadas podem chegar à API de publicações com uma chave.

headers

O dicionário opcional de cabeçalhos HTTP do MCPServerHTTP, que a documentação do CrewAI mostra a levar um token bearer no Authorization.

create_static_tool_filter

As listas de permitidos e bloqueados das ferramentas de um servidor MCP do CrewAI, importadas de crewai.mcp.filters.

30 seconds

A espera predefinida do CrewAI por uma ligação MCP; um servidor que não consegue alcançar é registado como aviso e o agente mantém as restantes ferramentas.

1 hour

Quanto tempo dura um token de acesso MCP da easyCoexistence; um token de atualização, válido por 60 dias, obtém um novo par.

90 days

Com que antecedência a API de publicações da easyCoexistence agenda uma publicação, a partir de 1 minuto, e copia os ficheiros multimédia quando entra na fila.

Como é que um agente do CrewAI carrega as ferramentas da easyCoexistence?

Através do campo mcps, com um MCPServerHTTP por agente. Liga-se por Streamable HTTP, o valor predefinido do CrewAI para esta classe, e envia os cabeçalhos que lhe indicar, aqui um cabeçalho Authorization com um token de acesso da easyCoexistence. Um filtro estático de ferramentas, criado com create_static_tool_filter, dá a cada agente apenas as ferramentas de que a sua tarefa precisa, e cache_tools_list mantém a lista após a primeira ligação. O CrewAI liga-se sob pedido e, se um servidor não puder ser alcançado, regista um aviso e deixa o agente continuar com as restantes ferramentas, por isso leia o registo na primeira execução. O token de acesso vem do auxiliar da secção seguinte.

A two-agent crew, each with its own slice of the tools
from crewai import Agent, Crew, Task
from crewai.mcp import MCPServerHTTP
from crewai.mcp.filters import create_static_tool_filter

from easycoexistence_token import fresh_token

TOKEN = fresh_token()  # one per kickoff: an access token lasts an hour

def easycoexistence(*tools: str) -> MCPServerHTTP:
    return MCPServerHTTP(
        url="https://easycoexistence.com/api/mcp",
        headers={"Authorization": f"Bearer {TOKEN}"},
        streamable=True,
        cache_tools_list=True,
        tool_filter=create_static_tool_filter(allowed_tool_names=list(tools)),
    )

analyst = Agent(
    role="Social analyst",
    goal="Find which of last week's Instagram and TikTok posts reached the most people",
    backstory="You read the numbers before anyone writes a caption.",
    mcps=[easycoexistence("list_social_accounts", "list_social_posts", "get_social_insights")],
)
scheduler = Agent(
    role="Scheduler",
    goal="Queue next week's posts at the times the analyst recommends",
    backstory="You post only what the brief approves, always with scheduled_at.",
    mcps=[easycoexistence("list_social_accounts", "publish_instagram_post",
                          "publish_tiktok_post", "list_scheduled_posts")],
)

crew = Crew(
    agents=[analyst, scheduler],
    tasks=[
        Task(description="Rank last week's posts by reach and views.",
             expected_output="A ranked list with the best posting times", agent=analyst),
        Task(description="Schedule the three posts in {brief} for next week.",
             expected_output="The post_id of each queued post", agent=scheduler),
    ],
)
crew.kickoff(inputs={"brief": "<THE WEEK'S BRIEF>"})

De onde vem o token de acesso da crew?

De um único início de sessão no navegador, seguido de uma renovação a cada kickoff. O servidor MCP da easyCoexistence aceita apenas tokens OAuth: registo dinâmico de cliente, código de autorização com PKCE, tokens de acesso válidos durante uma hora e tokens de atualização válidos durante 60 dias. Execute uma vez o OAuthClientProvider do MCP Python SDK, num computador com navegador, e guarde o registo e os tokens que devolve; o auxiliar abaixo usa a linha 1.x do SDK, que o CrewAI instala. Antes de cada kickoff, fresh_token troca o token de atualização guardado, no endpoint de tokens da easyCoexistence, por um novo par e guarda-o, por isso uma crew que corra pelo menos uma vez em 60 dias nunca precisa do navegador outra vez. Guarde o ficheiro num cofre de segredos, não no repositório.

easycoexistence_token.py: sign in once, refresh per kickoff
import asyncio, json, webbrowser
from pathlib import Path
from urllib.parse import parse_qs, urlparse

import httpx
import requests
from pydantic import AnyUrl
from mcp import ClientSession
from mcp.client.auth import OAuthClientProvider
from mcp.client.streamable_http import streamable_http_client
from mcp.shared.auth import OAuthClientMetadata

URL = "https://easycoexistence.com/api/mcp"
SAVED = Path("easycoexistence-oauth.json")  # a secret store in production

class SaveToFile:  # the MCP SDK's TokenStorage, writing what the sign-in returns
    def __init__(self):
        self.saved = {}
    async def get_tokens(self): return None
    async def get_client_info(self): return None
    async def set_tokens(self, tokens): self._put("tokens", tokens)
    async def set_client_info(self, info): self._put("client", info)
    def _put(self, key, model):
        self.saved[key] = model.model_dump(mode="json")
        SAVED.write_text(json.dumps(self.saved))

async def open_browser(url: str) -> None:
    webbrowser.open(url)

async def code_from_redirect() -> tuple[str, str | None]:
    q = parse_qs(urlparse(input("Address after sign-in: ")).query)
    return q["code"][0], q.get("state", [None])[0]

async def sign_in_once() -> None:
    oauth = OAuthClientProvider(
        server_url=URL,
        client_metadata=OAuthClientMetadata(
            client_name="Acme crew", redirect_uris=[AnyUrl("http://localhost:3030/callback")], scope="mcp"),
        storage=SaveToFile(), redirect_handler=open_browser, callback_handler=code_from_redirect,
    )
    async with httpx.AsyncClient(auth=oauth) as http:
        async with streamable_http_client(URL, http_client=http) as (read, write, _):
            async with ClientSession(read, write) as session:
                await session.initialize()  # completes the sign-in and saves the tokens

def fresh_token() -> str:
    """Trade the saved refresh token for a new pair and return the access token."""
    saved = json.loads(SAVED.read_text())
    r = requests.post("https://easycoexistence.com/api/oauth/token", data={
        "grant_type": "refresh_token",
        "refresh_token": saved["tokens"]["refresh_token"],
        "client_id": saved["client"]["client_id"],
    }, timeout=30)
    r.raise_for_status()
    saved["tokens"] = r.json()  # a new refresh token comes with each refresh
    SAVED.write_text(json.dumps(saved))
    return saved["tokens"]["access_token"]

if __name__ == "__main__":
    asyncio.run(sign_in_once())

Como pode uma crew publicar sem o servidor MCP?

Com uma ferramenta personalizada que chama a API de publicações da easyCoexistence, o que serve uma crew iniciada por um agendador sem ninguém presente. Crie uma chave de API de parceiro no painel, que começa por ec_live_, e a ferramenta abaixo envia POST /api/v1/channels/:id/posts com o texto, o URL do ficheiro multimédia, o tipo e publish_at. A easyCoexistence copia o ficheiro quando a publicação entra na fila, recusa um URL que devolva uma página web ou o formato errado naquele momento, e publica a publicação na hora marcada; o cabeçalho Idempotency-Key impede que uma chamada repetida a coloque na fila duas vezes. A mesma chave lê os tokens atualizados das redes a partir de GET /api/v1/channels/:id?credentials=1.

A CrewAI tool that queues a post through the posts API
import hashlib, os

import requests
from crewai.tools import tool

@tool("Schedule a social post")
def schedule_post(account_id: str, text: str, media_url: str, media_type: str, publish_at: str) -> str:
    """Queue one post on a connected Instagram, TikTok or Facebook account.
    media_type is image or video; publish_at is ISO 8601 with a timezone, 1 minute to 90 days ahead."""
    key = hashlib.sha256(f"{account_id}|{publish_at}|{media_url}".encode()).hexdigest()
    r = requests.post(
        f"https://easycoexistence.com/api/v1/channels/{account_id}/posts",
        headers={"Authorization": f"Bearer {os.environ['EC_API_KEY']}", "Idempotency-Key": key},
        json={"text": text, "media": [{"url": media_url, "type": media_type}], "publish_at": publish_at},
        timeout=60,
    )
    return r.text  # the queued post, or why it was refused

Que agente da crew deve ter que ferramentas?

O menor número que lhe permita concluir a tarefa, porque um agente pode chamar qualquer ferramenta que tenha. Uma crew que planeie e publique uma semana de conteúdos divide o trabalho de modo que a leitura, a escrita e a publicação fiquem com agentes diferentes, e apenas um deles pode colocar algo no ar. Não dê ao redator nenhuma ferramenta da easyCoexistence: trabalha a partir das conclusões do analista e do briefing, e as suas legendas chegam ao agendador como resultado da tarefa. As ferramentas de publicação aceitam scheduled_at, por isso o agendador coloca as publicações na fila para as respetivas horas, em vez de publicar no momento em que é executado, e list_scheduled_posts permite-lhe confirmar o que está à espera. As publicações no LinkedIn ficam fora das crews: um agente redige cada uma a pedido, por exemplo no Claude ou no ChatGPT, e uma pessoa aprova-a antes de sair.

Analystlist_social_accounts, list_social_posts, get_social_insights, get_youtube_analytics
WriterNo easyCoexistence tools; drafts captions from the brief and the analyst's findings
Schedulerpublish_instagram_post, publish_tiktok_post, publish_facebook_post, list_scheduled_posts
Community managerlist_social_comments, reply_to_comment, hide_comment, send_social_dm

O que exigem as redes às publicações e respostas da crew?

As regras da API de cada rede, que devem constar dos objetivos e das histórias de fundo dos agentes:

  • Multimédia: um URL HTTPS público por ficheiro. O Instagram aceita imagens JPEG, as publicações de fotografia no TikTok aceitam JPEG ou WebP, e uma publicação numa Página do Facebook aceita uma foto ou um vídeo.
  • Horas: ISO 8601 com fuso horário, como 2026-11-20T09:00:00-03:00, de 1 minuto a 90 dias de antecedência.
  • Comentários: as respostas no TikTok são públicas e exigem o ID do vídeo como post_id; um comentário no Instagram ou no Facebook pode receber uma resposta privada no prazo de 7 dias.
  • Mensagens diretas: o Instagram e o Messenger aceitam respostas até 24 horas após a última mensagem da pessoa; o send_message do WhatsApp segue a mesma janela, e send_template chega a qualquer outra pessoa.
  • Eventos: um comentário ou mensagem direta só chega à crew pela sua própria rota, definida com set_social_webhook_destination, que pode chamar crew.kickoff com o evento.

Erros comuns

  • Iniciar uma crew com o token de ontem. Um token de acesso da easyCoexistence expira uma hora após ser emitido, e o CrewAI continua sem um servidor que não consegue alcançar, com apenas um aviso no registo; chame fresh_token a cada kickoff.
  • Dar a cada agente o servidor inteiro. Sem tool_filter, um analista vê também as ferramentas de publicação; passe create_static_tool_filter com os nomes de que a sua tarefa precisa.
  • Escrever publish_at ou scheduled_at sem deslocamento horário. A easyCoexistence recusa uma hora sem fuso horário, por isso termine-a em Z ou num deslocamento como -03:00.
  • Incluir no repositório o ficheiro de início de sessão guardado. O token de atualização dá a quem o tiver as ferramentas da conta durante até 60 dias, por isso guarde-o num cofre de segredos.
Fazer isto com a EasyCoexistence

A easyCoexistence dá aos seus agentes CrewAI alcance junto de clientes no WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn e mais canais, cada um através da sua API oficial: 35+ ferramentas MCP para a lista mcps de cada agente, uma API de publicações que coloca na fila até 90 dias à frente, e eventos assinados para comentários e mensagens diretas, com cada ligação monitorizada 24 horas por dia. De US$ 9 a US$ 0.75 por ligação por mês, descendo à medida que acrescenta ligações, com os primeiros 3 dias gratuitos.

Perguntas frequentes

O cliente MCP do CrewAI executa o início de sessão OAuth por si?

A documentação mostra cabeçalhos, variáveis de ambiente e parâmetros de consulta para autenticação, sem nenhum fluxo OAuth. Assim, a crew envia um token bearer que já tem, o que um início de sessão com o MCP Python SDK fornece.

Pode uma crew responder a comentários no seu próprio horário?

Sim. Um agente de gestão de comunidade com list_social_posts, list_social_comments e reply_to_comment pode percorrer os comentários novos a cada execução, que é também a forma de ler comentários do YouTube e do LinkedIn, já que nenhum dos dois envia eventos.

A crew pode enviar mensagens no WhatsApp?

Sim, com list_numbers, send_message e send_template no filtro de ferramentas de um agente. O send_message responde a clientes que escreveram nas últimas 24 horas, e o send_template envia um template aprovado a qualquer outra pessoa.

Quanto custa a easyCoexistence para uma crew do CrewAI?

De US$ 9 a US$ 0.75 por ligação por mês, descendo à medida que acrescenta ligações, e o mesmo em cada rede. O servidor MCP, a API de publicações e os eventos reencaminhados estão incluídos, com os primeiros 3 dias gratuitos.

Continue a ler

Ligue o seu primeiro canal em dois minutos.

Sem revisões de plataformas para esperar. Ligue o WhatsApp, o Instagram, o TikTok ou outro canal, peça depois à sua IA que publique, responda ou faça um relatório, e veja-a trabalhar.

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

Verificado em