Anchord

Servidor MCP remoto alojado para resolución de identidad y protecciones de escritura.

Documentación

Servidor MCP de Anchord

Resolución de identidad y comprobaciones de seguridad previas a la escritura para agentes de IA.

Un servidor MCP que brinda a los agentes de IA acceso a la API de resolución de identidad de Anchord. Resuelve empresas y personas a AnchorIDs canónicos, ejecuta comprobaciones de seguridad previas a la escritura y exporta registros de oro, a través de la interfaz estándar de herramientas MCP.

Respaldado por API alojada. Este servidor MCP es un proxy ligero hacia la plataforma SaaS de Anchord. Toda la puntuación, coincidencia, validación y persistencia de datos ocurren en el lado del servidor. No se ejecuta lógica de negocio localmente.

Solo lectura por diseño. Anchord nunca escribe en tus sistemas externos (CRMs, bases de datos, etc.). guard_write evalúa una escritura propuesta y devuelve permitida/bloqueada; el llamador decide si proceder.

Inicio rápido

1. Obtén una clave de API

Regístrate en app.anchord.ai/signup y crea una clave de API en Configuración > Claves de API.

2. Ejecuta con npx (sin instalación)

ANCHORD_API_KEY=<YOUR_ANCHORD_API_KEY> npx -y @anchord/mcp-server

Eso es todo. El servidor se inicia a través de stdio y está listo para clientes MCP.

3. O conéctate al servidor remoto alojado (cero instalación)

No se necesita instalación local. Apunta cualquier cliente MCP que admita transporte HTTP remoto al endpoint alojado:

{
  "mcpServers": {
    "anchord": {
      "url": "https://mcp.anchord.ai/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_ANCHORD_API_KEY>"
      }
    }
  }
}

Consulta docs/remote.md para obtener todos los detalles, notas de compatibilidad de clientes y una alternativa local si tu cliente aún no admite MCP remoto.

Configuración del cliente MCP

Cursor (stdio local)

Agrega a .cursor/mcp.json (espacio de trabajo) o ~/.cursor/mcp.json (global):

{
  "mcpServers": {
    "anchord": {
      "command": "npx",
      "args": ["-y", "@anchord/mcp-server"],
      "env": {
        "ANCHORD_API_KEY": "<YOUR_ANCHORD_API_KEY>"
      }
    }
  }
}

Consulta examples/cursor-mcp.json.

Claude Desktop

Agrega a la configuración de tu Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json en macOS, %APPDATA%\Claude\claude_desktop_config.json en Windows):

{
  "mcpServers": {
    "anchord": {
      "command": "npx",
      "args": ["-y", "@anchord/mcp-server"],
      "env": {
        "ANCHORD_API_KEY": "<YOUR_ANCHORD_API_KEY>"
      }
    }
  }
}

Consulta examples/claude-desktop-config.json.

MCP remoto (para clientes que admiten transporte HTTP)

Para acceso remoto sin instalación, usa el endpoint alojado en lugar de un proceso stdio local. Esto funciona con cualquier cliente MCP que admita el formato de configuración url + headers:

{
  "mcpServers": {
    "anchord": {
      "url": "https://mcp.anchord.ai/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_ANCHORD_API_KEY>"
      }
    }
  }
}

No se requiere Node.js, npx ni Docker. Si tu cliente aún no admite MCP remoto, usa la configuración stdio local anterior. Consulta docs/remote.md para obtener todos los detalles.

Docker

docker build -t anchord-mcp .
echo '{"jsonrpc":"2.0","id":1,"method":"initialize",...}' | \
  docker run --rm -i -e ANCHORD_API_KEY=<YOUR_ANCHORD_API_KEY> anchord-mcp

O usa el archivo compose para pruebas locales:

cp examples/env.example .env
# Edit .env with your API key
docker compose up

Variables de entorno

Variable	Requerida	Predeterminado	Descripción
`ANCHORD_API_KEY`	Sí	—	Tu clave de API de Anchord (token Bearer)
`ANCHORD_API_BASE_URL`	No	`https://api.anchord.ai`	URL base de la API

Consulta docs/auth.md para obtener detalles sobre la autenticación y el alcance del tenant.

Herramientas disponibles

Herramienta	Descripción
`resolve_company`	Resuelve una empresa a un AnchorID canónico
`resolve_company_batch`	Resolución de empresas por lotes (máx. 200)
`resolve_person`	Resuelve una persona a un AnchorID canónico
`resolve_person_batch`	Resolución de personas por lotes (máx. 200)
`get_entity`	Obtiene un AnchorID con registros vinculados opcionales
`get_entity_export`	Exporta el registro de oro para un AnchorID
`link_source_record`	Vincula un registro fuente a un AnchorID
`unlink_source_record`	Eliminación suave de un vínculo de registro fuente
`guard_write`	Comprobación de seguridad previa a la escritura (solo evaluación)
`guard_write_batch`	Comprobación de seguridad previa a la escritura por lotes (máx. 200)
`ingest_record`	Ingresa un registro fuente en Anchord

Referencia completa de parámetros: docs/tools.md

Flujo de trabajo seguro para agentes

La secuencia recomendada para agentes que escriben en sistemas externos:

1. ingest_record        Push the source record into Anchord
                        (optional if using OAuth integrations)

2. resolve_company      Match to a canonical AnchorID
   or resolve_person    → status: resolved | not_found | needs_review

3. IF needs_review      STOP. Do not write.
                        Surface candidates to the user.
                        Direct them to the Review Queue.

4. guard_write          Evaluate the proposed write
                        → allowed: true | false (with block codes)

5. IF allowed           The agent performs the external write.
                        Anchord never writes.

6. Log request_id       Every response includes a request_id
                        for audit trail and debugging.

Usa get_entity o get_entity_export en cualquier momento para inspeccionar los detalles del AnchorID o recuperar el registro de oro fusionado.

Manejo de `needs_review`

Solo resolve_* devuelve needs_review. Significa que Anchord encontró múltiples coincidencias plausibles y no puede resolver automáticamente con confianza.

Para agentes:

No escribas. Los datos son ambiguos.
Presenta los candidatos al usuario: la respuesta incluye IDs de entidad y puntuaciones de coincidencia.
Dirige al usuario a la Cola de revisión: https://app.anchord.ai/app/queues/needs-review
Reintenta más tarde. Una vez que un humano resuelve la ambigüedad, las llamadas de resolución posteriores devuelven resolved.

Ejemplo de mensaje de agente:

Intenté resolver "Acme Corp" pero Anchord encontró múltiples coincidencias posibles. Un humano necesita revisar esto en la Cola de revisión. Reintentaré después de que se resuelva.

Manejo de errores

Cuando la API devuelve 4xx/5xx, la respuesta de la herramienta MCP se marca como isError: true con una carga útil estructurada:

{
  "error": "[422] BATCH_TOO_LARGE: Batch size must not exceed 100 records. (request_id: req_01ABC123)",
  "status_code": 422,
  "request_id": "req_01ABC123",
  "details": { "records": ["Too many records."] }
}

request_id siempre está presente: del cuerpo de la respuesta de la API, del encabezado x-request-id o de un UUID generado por el cliente.
details contiene errores de validación cuando están disponibles (null para errores que no son JSON).
Las claves de API nunca se incluyen en los mensajes de error.

Arquitectura

Local (stdio)

MCP Client (Cursor / Claude Desktop / etc.)
    │  stdio (JSON-RPC)
    ▼
┌──────────────┐
│  MCP Server  │  Node.js + TypeScript
│  (this pkg)  │  Zod schemas · no business logic
└──────┬───────┘
       │  HTTPS + Bearer auth
       ▼
┌──────────────┐
│  Anchord API │  Hosted SaaS — scoring, matching,
│              │  persistence, tenant isolation
└──────────────┘

Remoto alojado (HTTP)

MCP Client
    │  HTTPS POST + Bearer token
    ▼
┌────────────────────────┐
│  mcp.anchord.ai        │  CloudFront (TLS, routing)
└───────────┬────────────┘
            ▼
┌────────────────────────┐
│  Lambda (stateless)    │  Per-request MCP server
│  Bearer → ApiClient    │  No stored secrets
└───────────┬────────────┘
            │  HTTPS + Bearer auth
            ▼
┌────────────────────────┐
│  Anchord API           │  Same hosted SaaS backend
└────────────────────────┘

Ambas rutas exponen las mismas 11 herramientas MCP y se conectan a la misma API.

Preguntas frecuentes

¿Anchord se aloja por sí mismo?

No. Anchord es una plataforma SaaS alojada. Este servidor MCP es un cliente ligero que llama a la API de Anchord. Necesitas una clave de API de app.anchord.ai/signup.

¿Anchord escribe en mis CRMs?

No. Anchord es estrictamente de solo lectura. Lee datos de sistemas conectados (Salesforce, HubSpot, Stripe) para construir gráficos de identidad, pero nunca escribe de vuelta. guard_write devuelve una decisión: el llamador realiza cualquier escritura real.

¿Con qué sistemas funciona Anchord?

Anchord tiene integraciones OAuth para Salesforce, HubSpot y Stripe. También puedes enviar registros desde cualquier sistema mediante la herramienta ingest_record o la API REST.

¿Qué sucede cuando hay ambigüedad?

Cuando resolve_* devuelve needs_review, significa que múltiples AnchorIDs candidatos coincidieron con confianza similar. El agente debe detenerse, presentar los candidatos a un humano y dirigirlo a la Cola de revisión de Anchord. Una vez resuelto, las llamadas posteriores devuelven resolved.

¿Cuáles son los límites de velocidad?

120 solicitudes/minuto por tenant. Los endpoints por lotes aceptan hasta 200 elementos (resolver, proteger) o 100 registros (ingestar). Se aplican cuotas mensuales y diarias según el plan. Consulta docs/auth.md.

Enlaces

Licencia

MIT