Crea un flujo de contenido automático con el servidor MCP de Endata

Paso 1 2 minutos

Crea una clave de API con permisos acotados

En Configuración → Desarrollador → Claves API, crea una clave solo con los permisos que necesita el flujo.

Las claves pertenecen a un proyecto y empiezan con fsk_. Las crea un propietario y cada una lleva permisos. Las herramientas fuera de los permisos de una clave ni siquiera se le muestran al agente, así que una clave acotada también da una lista de herramientas más corta y clara.

Para este flujo, otorga editorial:read, editorial:write y publishing:manage. Deja desactivados administration:manage y organization:manage, a menos que el agente realmente administre dominios, integraciones o miembros del equipo.

Paso 2 2 minutos

Conecta tu cliente MCP

Agrega el servidor a Claude Code, a Codex o a cualquier cliente que hable Streamable HTTP.

Claude Code

{
  "mcpServers": {
    "endata": {
      "type": "http",
      "url": "https://app.endata.com/mcp",
      "headers": { "Authorization": "Bearer ${ENDATA_API_KEY}" }
    }
  }
}

Codex

[mcp_servers.endata]
url = "https://app.endata.com/mcp"
bearer_token_env_var = "ENDATA_API_KEY"

Tu propio código

El servidor es Streamable HTTP sin estado y solo acepta POST, así que el SDK oficial se conecta sin manejar sesiones. El pequeño asistente call de abajo se usa en todos los pasos siguientes.

// npm install @modelcontextprotocol/sdk
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from
  "@modelcontextprotocol/sdk/client/streamableHttp.js";

const publicationId = process.env.ENDATA_PUBLICATION_ID;
const client = new Client({ name: "answer-pipeline", version: "1.0.0" });
await client.connect(new StreamableHTTPClientTransport(
  new URL("https://app.endata.com/mcp"),
  { requestInit: { headers: {
    Authorization: `Bearer ${process.env.ENDATA_API_KEY}`,
  } } },
));

// Every tool takes { publicationId, input } and returns JSON as text.
async function call(name, input = {}, extra = {}) {
  const result = await client.callTool({
    name,
    arguments: { publicationId, input, ...extra },
  });
  const value = JSON.parse(result.content[0].text);
  if (result.isError) throw new Error(`${name}: ${value.message}`);
  return value;
}

Paso 3 1 minuto

Encuentra las preguntas que vale la pena responder

Llama a questions_list con el filtro to-answer, o agrega una pregunta con question_create.

Una pregunta es la unidad de trabajo: algo que pregunta un cliente y para lo cual el negocio debería tener la mejor respuesta. Las preguntas llegan de las sugerencias de Endata, de las brechas de tu informe de visibilidad en IA o de ti.

// Questions still waiting for an answer, highest priority first.
const { questions } = await call("questions_list", {
  filter: "to-answer",
  limit: 10,
});

// Or add one of your own: a gap from your AI Visibility report, say.
const added = await call("question_create", {
  text: "How much cyber insurance does a 40-person firm need?",
  customers: "Owners of professional services firms",
});

questions_list devuelve questions, counts por estado y un summary. Los filtros incluyen to-answer, needs-update (respondida, pero las noticias cambiaron o la respuesta quedó desactualizada), open y all. discovery_read da una vista más amplia: qué porcentaje de las preguntas de los clientes has respondido y qué responder a continuación.

Paso 4 Unos minutos, sin supervisión

Investiga y redacta la respuesta

Llama a question_research para reunir evidencia y escribir un borrador con citas.

La investigación busca en los últimos 30 días de noticias y fuentes web para esa pregunta, conserva hasta ocho piezas de evidencia y escribe una respuesta que las cita. Se ejecuta en segundo plano y descuenta de la asignación mensual de respuestas investigadas del plan.

// Research the question and draft its answer. This runs in the
// background and counts against the plan's monthly answers.
const question = questions[0];
await call("question_research", { questionId: question.id });

// Optional: add what only the business knows, attributed to it.
await call("question_perspective", {
  questionId: question.id,
  text: "We size cover from the client's largest single contract, not headcount.",
});

question_perspective es el paso que la mayoría de los flujos omite y no debería. Agrega la opinión propia del negocio, atribuida a un autor con nombre, que es lo que hace que la respuesta sea más que un resumen de páginas ajenas.

Paso 5 2 minutos

Lee el borrador y su evidencia

Llama a question_read y answer_read, y conserva el draftRevision que revisaste.

// When research is done ("question.researched" webhook, or poll),
// read the draft and the evidence behind it.
const detail = await call("question_read", { questionId: question.id });
const answer = await call("answer_read", { questionId: question.id });

console.log(answer.content);        // the draft
console.log(answer.pending);        // true: readers do not see it yet
console.log(answer.draftRevision);  // the exact revision you reviewed

Aquí es donde un agente se gana su lugar. Pídele que compare el borrador con la evidencia que devuelve question_read, que marque cualquier afirmación sin fuente y que guarde un borrador mejorado con answer_update, que recibe el contenido y el expectedRevision en que se basó, para que dos editores no se sobrescriban entre sí. answer_preview devuelve la página tal como se publicaría.

Paso 6 1 minuto

Publica, con una persona en el circuito

Llama a prepare_action, muéstrale su resumen a una persona y luego llama a answer_publish con el token de confirmación.

Publicar, despublicar, compartir y los cambios administrativos se marcan como consecuentes. Endata no deja que una clave sin supervisión los realice por defecto. Hay dos caminos, y debes elegir con criterio:

// Publishing is consequential. Prepare the exact action first:
const prepared = await client.callTool({
  name: "prepare_action",
  arguments: {
    publicationId,
    operation: "answer_publish",
    input: { questionId: question.id, revisionId: answer.draftRevision },
  },
});
const { confirmationToken } = JSON.parse(prepared.content[0].text);

// Show the summary to a person. Once they agree, within 10 minutes:
const live = await call(
  "answer_publish",
  { questionId: question.id, revisionId: answer.draftRevision },
  { confirmationToken, requestKey: `publish-${answer.draftRevision}` },
);

requestKey hace la llamada idempotente: un reintento con la misma clave y la misma entrada devuelve el primer resultado y no publica dos veces. La respuesta se publica al instante en /questions/<slug> de la publicación, y answer.url en el resultado es su dirección.

Paso 7 Opcional

Comparte artículos y escucha eventos

Usa article_share para publicar artículos en las redes conectadas, y webhooks para reaccionar cuando algo se publica.

Compartir funciona con los artículos, las notas de noticias que Endata escribe sobre tus temas, no con las respuestas. connections_list devuelve las cuentas conectadas; article_share recibe un articleId, un connectionId, tu commentary y cuándo enviarlo (now, at una hora, o cuando esté published). Es consecuente, así que se aplica la misma regla de confirmación.

Los webhooks cierran el ciclo. Hasta 10 endpoints HTTPS por proyecto reciben eventos firmados como question.answered, question.updated, article.approved y share.sent. La entrega es al menos una vez, con ocho intentos en unas 22 horas, así que haz el receptor idempotente y verifica la firma:

import { createHmac, timingSafeEqual } from "node:crypto";

// Pass the exact, unmodified UTF-8 request body and request headers.
function verifyWebhook(rawBody, headers, secret) {
  const timestamp = headers.get("Webhook-Timestamp");
  const signature = headers.get("Webhook-Signature");
  if (!timestamp || !/^\d+$/.test(timestamp)) return false;
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 300) return false;
  if (!/^v1=[a-f0-9]{64}$/.test(signature || "")) return false;

  const expected = createHmac("sha256", secret)
    .update(timestamp + "." + rawBody, "utf8")
    .digest();
  const received = Buffer.from(signature.slice(3), "hex");
  return timingSafeEqual(expected, received);
}
// After verification, parse and validate the event.
// Atomically persist it with a unique constraint on Webhook-Id.
// Return 2xx after persistence; duplicate events should also return 2xx.
// Process asynchronously and reconcile current state through the API.