Generect MCP

Generect MCP conecta tu base de datos de leads en vivo directamente a modelos de IA como OpenAI o Claude sin exportaciones ni demoras. Transmite datos de contacto enriquecidos y actualizados (cargos, firmografía, señales) directamente a los prompts para que los LLMs puedan personalizar, puntuar y recomendar leads automáticamente en tiempo real.

GitHub

Documentación

Servidor MCP de Generect Live API

Servidor MCP mínimo que expone herramientas de Generect Live API para generación de leads B2B y búsqueda de empresas.

Obtén tu clave de API

Regístrate y obtén tu clave de API en https://beta.generect.com

Servidor MCP remoto (OAuth - Recomendado)

Este servidor MCP implementa la autorización OAuth 2.1 según lo especificado por el Model Context Protocol.

Usa nuestro servidor MCP alojado con cualquier cliente MCP compatible con OAuth:

{
  "mcpServers": {
    "generect": {
      "url": "https://mcp.generect.com/mcp",
      "type": "http"
    }
  }
}

Cuando te conectes por primera vez, el cliente iniciará un flujo OAuth:

Serás redirigido a la página de autorización
Ingresa tu token de API de Generect desde beta.generect.com
Autoriza al cliente para acceder a tu API
El cliente recibe un token de acceso y ahora puede usar las herramientas MCP

Endpoints de OAuth

Endpoint	Descripción
`/.well-known/oauth-protected-resource`	Metadatos de recurso protegido (RFC 9728)
`/.well-known/oauth-authorization-server`	Metadatos del servidor de autorización (RFC 8414)
`/.well-known/jwks.json`	Conjunto de claves JSON Web para verificación de tokens
`/oauth/authorize`	Endpoint de autorización (inicio de sesión + consentimiento)
`/oauth/token`	Endpoint de token
`/oauth/register`	Registro dinámico de clientes (RFC 7591)

Clave de API directa (sin OAuth)

Si tu cliente MCP no puede completar el flujo OAuth, puedes pasar la clave de API directamente mediante el encabezado Authorization. El servidor acepta cualquiera de:

Authorization: YOUR_API_KEY
Authorization: Bearer YOUR_API_KEY
Authorization: Token YOUR_API_KEY
Authorization: Bearer Token YOUR_API_KEY   (legacy)

Ejemplo para mcp-remote:

{
  "mcpServers": {
    "generect": {
      "command": "mcp-remote",
      "args": [
        "https://mcp.generect.com/mcp",
        "--header",
        "Authorization: Bearer YOUR_API_KEY"
      ]
    }
  }
}

Instalación local (Alternativa)

Para desarrollo local o cuando no se necesita OAuth:

Requisitos: Node >= 18
Configura el entorno:

GENERECT_API_BASE=https://api.generect.com
GENERECT_API_KEY=Token <api-key>
GENERECT_TIMEOUT_MS=300000
JWT_SIGNING_KEY=<your-secret-key-for-jwt-signing>
TOKEN_ENCRYPTION_KEY=<32-byte-hex-key-for-token-encryption>

Desarrollo local (opcional)

npm install
npm run dev:http

Compila e inicia (servidor stdio)

npm run build && npm start

Registro (Logging)

El servidor emite una línea de registro JSON estructurada por evento a stderr (stdout está reservado para el protocolo MCP stdio). El registro de metadatos está activado por defecto; establece MCP_LOG=0 para desactivarlo por completo.

Privacidad: los payloads se redactan por defecto. Los payloads de solicitud/respuesta pueden contener datos personales de prospectos (nombres, dominios de empresas, correos generados). Por defecto, estos valores no se registran textualmente: cada uno se reduce a un marcador de forma no identificable (p. ej., "first_name": "<str:4>"), para que puedas ver qué campos se enviaron sin registrar los datos en sí. Establece MCP_LOG_PAYLOADS=1 para registrar payloads textualmente, pensado para depuración de corta duración, con el consentimiento del propietario de los datos.

Eventos:

`event`	Cuándo	Campos clave
`tool_call`	El LLM invoca una herramienta	`reqId`, `tool`, `input` (redactado a menos que `MCP_LOG_PAYLOADS=1`)
`api_request`	Llamada saliente a la API de Generect	`url`, `method`, `body` (redactado a menos que `MCP_LOG_PAYLOADS=1`; nunca el token)
`api_response`	La API de Generect respondió	`url`, `status`, `ms`
`tool_result`	Resultado devuelto al LLM	`reqId`, `tool`, `ms`, `output` (redactado a menos que `MCP_LOG_PAYLOADS=1`)
`tool_error` / `api_error`	Falla	`reqId`/`url`, `error`, `ms`

reqId correlaciona un tool_call con su tool_result. Establece MCP_DEBUG=1 para obtener salida adicional detallada.

El servidor alojado se ejecuta bajo PM2 (no Docker). Consulta los registros en el host con:

pm2 logs generect-mcp                                # live
pm2 logs generect-mcp --err                          # errors only
grep tool_call ~/.pm2/logs/generect-mcp-out.log      # only LLM tool inputs

Herramientas

search_leads: Busca leads por filtros ICP (soporta timeout_ms)
search_companies: Busca empresas por filtros ICP (soporta timeout_ms)
generate_email: Genera correo por nombre/apellido y dominio (soporta timeout_ms)
get_lead_by_url: Obtén lead de LinkedIn por URL de perfil (soporta timeout_ms)
health: Verificación rápida de salud contra la API (opcional url, soporta timeout_ms)

Integración con Cursor (extracto de settings.json)

{
  "mcpServers": {
    "generect-liveapi": {
      "command": "node",
      "args": ["./node_modules/tsx/dist/cli.mjs", "src/server.ts"],
      "env": {
        "GENERECT_API_BASE": "https://api.generect.com",
        "GENERECT_API_KEY": "Token YOUR_API_KEY",
        "GENERECT_TIMEOUT_MS": "300000"
      }
    }
  }
}

Configuración de Claude Desktop (MCP)

Agrega a ~/.claude/claude_desktop_config.json (o mediante UI → Servidores MCP). Recomendado: ejecutar vía npx para que los usuarios no instalen nada globalmente.

{
  "mcpServers": {
    "generect-api": {
      "command": "npx",
      "args": ["-y", "generect-ultimate-mcp@latest"],
      "env": {
        "GENERECT_API_BASE": "https://api.generect.com",
        "GENERECT_API_KEY": "Token YOUR_API_KEY",
        "GENERECT_TIMEOUT_MS": "300000",
        "MCP_DEBUG": "0"
      }
    }
  }
}

Nota para macOS: Si Claude muestra "spawn npx ENOENT" o lanza una versión anterior de Node vía nvm, establece command a la ruta absoluta de npx y/o sobrescribe PATH:

{
  "command": "/usr/local/bin/npx",
  "env": { "PATH": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin" }
}

Alternativa sin npx:

npm i -g generect-ultimate-mcp

Luego usa:

{ "command": "/usr/local/bin/generect-mcp", "args": [] }

Despliegue (producción, PM2)

El servidor alojado (https://mcp.generect.com) se ejecuta bajo PM2 en el host, con nginx (TLS) al frente. El proceso está definido por ecosystem.config.js:

npm ci && npm run build
pm2 start ecosystem.config.js      # or: pm2 reload ecosystem.config.js
pm2 save                           # persist the process list for reboot
# once, as root, so it survives reboots:
#   pm2 startup systemd -u mcp_user --hp /home/mcp_user

Solo instancia única. El estado de OAuth (clientes registrados, códigos de autorización) y las sesiones MCP se mantienen en memoria, por lo que el servidor debe ejecutarse como una sola instancia. El escalado horizontal requiere un almacén compartido (p. ej., Redis) primero; consulta ecosystem.config.js.

Secretos requeridos (fail-closed). En producción (NODE_ENV=production), el servidor se niega a iniciar a menos que JWT_SIGNING_KEY esté configurado con un valor fuerte y no predeterminado; nunca recurre a un valor predeterminado codificado ni a una clave efímera. TOKEN_ENCRYPTION_KEY, si se establece, debe tener exactamente 64 caracteres hexadecimales (32 bytes).

Docker

Docker es compatible para ejecuciones locales/alternativas. Compila localmente:

docker build -t ghcr.io/generect/generect_mcp:local .

Ejecuta el servidor en un contenedor (nota: se requieren los mismos secretos de producción; un valor predeterminado inseguro hará que el contenedor salga al inicio):

docker run --rm \
  -e NODE_ENV=production \
  -e GENERECT_API_BASE=https://api.generect.com \
  -e GENERECT_API_KEY="Token YOUR_API_KEY" \
  -e JWT_SIGNING_KEY="a-strong-random-secret" \
  -e TOKEN_ENCRYPTION_KEY="0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" \
  -e OAUTH_BASE_URL=https://your-domain.com \
  -p 3000:3000 \
  ghcr.io/generect/generect_mcp:local

Remoto vía SSH (avanzado)

Algunos clientes MCP permiten iniciar el servidor vía SSH, usando stdio sobre la sesión SSH. Ejemplo de configuración:

{
  "mcpServers": {
    "generect-remote": {
      "command": "ssh",
      "args": [
        "user@remote-host",
        "-T",
        "node",
        "/opt/generect_mcp/dist/server.js"
      ],
      "env": {
        "GENERECT_API_BASE": "https://api.generect.com",
        "GENERECT_API_KEY": "Token YOUR_API_KEY",
        "GENERECT_TIMEOUT_MS": "300000"
      }
    }
  }
}

Ayudantes de prueba local

Ejecuta una verificación de salud simple contra la API:

npm run health -- <api-key>

Llama a herramientas mediante un cliente MCP local:

npm run mcp:client -- <api-key>

Notas de seguridad

Los tokens OAuth son JWTs firmados por el servidor y contienen tu token de API cifrado
El cifrado de tokens usa AES-256-GCM con una clave de TOKEN_ENCRYPTION_KEY (o derivada de JWT_SIGNING_KEY)
Secretos fail-closed — en producción, el servidor se niega a iniciar con un JWT_SIGNING_KEY faltante o con un valor predeterminado conocido, y nunca publica material de clave simétrica en el JWKS
Tokens limitados y renovables — los tokens de acceso expiran (por defecto 30 días, ACCESS_TOKEN_TTL_SECONDS) y se renuevan mediante una concesión refresh_token; los tokens de actualización se rotan al usarse y son revocables en POST /oauth/revoke (RFC 7009). Los tokens emitidos antes de este cambio siguen siendo válidos (sin re-autenticación forzada)
PKCE es obligatorio para todos los flujos de código de autorización (método S256)
Registro dinámico de clientes permite que cualquier cliente MCP se auto-registre, pero ahora está limitado por IP (MCP_REGISTER_RATE_MAX, por defecto 60/hora) y el almacén de clientes está limitado (MCP_MAX_CLIENTS, por defecto 5000, evicción LRU que nunca elimina un cliente en uso)
Obtención de metadatos protegida contra SSRF — el flujo de documento de metadatos de ID de cliente (MCP_ENABLE_CIMD, activado por defecto) solo obtiene URLs https que resuelven exclusivamente a IPs públicas, sin seguir redirecciones, con un tiempo de espera estricto y un límite de tamaño de respuesta (bloquea destinos loopback / RFC1918 / link-local / metadatos de nube)
La validación de tokens falla cerrada — si Generect no puede confirmar un token durante el inicio de sesión (error ascendente), el servidor se niega a emitir un token de acceso en lugar de asumir su validez
Fijación de audiencia + algoritmo asegura que los tokens solo se usen con este servidor MCP y solo mediante el algoritmo de firma esperado

Configuración (variables de entorno relevantes para seguridad)

Var	Predeterminado	Efecto
`ACCESS_TOKEN_TTL_SECONDS`	`2592000` (30d)	Vida útil del token de acceso
`REFRESH_TOKEN_TTL_SECONDS`	`7776000` (90d)	Vida útil del token de actualización
`MCP_MAX_CLIENTS`	`5000`	Límite del almacén de clientes DCR en memoria
`MCP_REGISTER_RATE_MAX`	`60`	Máximo de llamadas `/oauth/register` por IP por ventana
`MCP_REGISTER_RATE_WINDOW_MS`	`3600000` (1h)	Ventana de límite de tasa
`MCP_ENABLE_CIMD`	`true`	Permitir ID de cliente como URL de metadatos (protegido contra SSRF)
`MCP_ALLOWED_REDIRECT_DOMAINS`	—	Nombres de host de redirección adicionales permitidos (separados por comas)

Privacidad de registros — los payloads de prospectos se redactan de los registros por defecto (MCP_LOG_PAYLOADS=1 para optar por participar)