MCP en empresa: conecta tus agentes IA con CRM, ERP y APIs internas

Para conectar un agente IA con tus sistemas internos, necesitas tres piezas: un servidor MCP que exponga tus datos, un cliente que lo consuma (tu agente), y reglas de autorización que definan qué puede leer y qué puede ejecutar. Esta guía muestra cómo montarlo con ejemplos reales de CRM y ERP.

Por qué un agente sin acceso a tus sistemas no sirve

Un agente IA que solo responde texto aporta poco en un entorno de negocio real. El valor aparece cuando el agente puede leer el estado actual de tu CRM, actualizar registros en tu ERP, consultar inventario en tiempo real y actuar sobre esos datos sin que nadie se lo dicte manualmente.

El problema hasta 2024 era que cada integración requería código custom por sistema. Con el protocolo MCP (Model Context Protocol, publicado por Anthropic en noviembre de 2024 y adoptado desde entonces por OpenAI, Google y Microsoft), el agente se conecta a cualquier sistema que exponga un servidor MCP sin reescribir el agente ni duplicar lógica.

A septiembre de 2026, más de 3.800 servidores MCP están publicados en el registro oficial de Anthropic. Los de mayor adopción enterprise son Salesforce, SAP, HubSpot, Odoo y Jira. La automatización con IA sobre datos reales deja de ser un proyecto de seis meses y se convierte en una integración de dos semanas.

Requisitos previos

• Node.js 22+ o Python 3.11+ en el servidor donde correrá el MCP
• Acceso a la API de tu CRM o ERP (clave de API o token OAuth 2.0)
• Un agente IA que soporte el protocolo MCP: Claude 3.5+, GPT-4o con tool use, Gemini 2.5 Pro
• Conocimiento básico de REST o XML-RPC (no se requiere ser experto en el sistema interno)

Cómo funciona MCP en un entorno empresa

MCP es un protocolo cliente-servidor donde:

• El servidor MCP expone funciones (tools) y datos (resources) de tus sistemas internos con nombres descriptivos.
• El cliente MCP es tu agente IA. Descubre las funciones disponibles, las invoca cuando las necesita y procesa el resultado.
• El transporte puede ser stdio (proceso local, solo desarrollo) o SSE/HTTPS (servidor remoto, producción). En empresa, SSE sobre HTTPS es el estándar porque permite que múltiples agentes se conecten al mismo servidor simultáneamente.

El agente no ve tu base de datos ni tus tablas. Ve funciones: obtener_estado_oportunidad(id), actualizar_pipeline(id, etapa), buscar_contacto(email). Tú controlas qué expones y con qué permisos.

Montar un servidor MCP para tu CRM (ejemplo: HubSpot)

Instala el SDK oficial de MCP:

npm install @modelcontextprotocol/sdk zod

Servidor MCP con dos tools de HubSpot:

import { McpServer } from #43a047">"@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from #43a047">"@modelcontextprotocol/sdk/server/stdio.js";
import { z } from #43a047">"zod";

const HUBSPOT_TOKEN = process.env.HUBSPOT_TOKEN;
const BASE_URL = #43a047">"https://api.hubapi.com";

const server = new McpServer({
  name: #43a047">"hubspot-empresa",
  version: #43a047">"1.0.0",
});

server.tool(
  #43a047">"buscar_contacto",
  #43a047">"Busca un contacto por email y retorna su etapa de ciclo de vida",
  { email: z.string().email() },
  async ({ email }) => {
    const res = await fetch(#43a047">`${BASE_URL}/crm/v3/objects/contacts/search`, {
      method: #43a047">"POST",
      headers: {
        Authorization: #43a047">`Bearer ${HUBSPOT_TOKEN}`,
        #43a047">"Content-Type": "application/json",
      },
      body: JSON.stringify({
        filterGroups: [{
          filters: [{ propertyName: #43a047">"email", operator: "EQ", value: email }],
        }],
        properties: [#43a047">"firstname", "lastname", "lifecyclestage", "phone"],
      }),
    });
    const data = await res.json();
    return {
      content: [{ type: #43a047">"text", text: JSON.stringify(data.results[0] ?? null) }],
    };
  }
);

server.tool(
  #43a047">"avanzar_deal_a_etapa",
  #43a047">"Mueve un deal de HubSpot a la etapa especificada. Requiere justificación antes de ejecutar.",
  { dealId: z.string(), etapa: z.string() },
  async ({ dealId, etapa }) => {
    const res = await fetch(#43a047">`${BASE_URL}/crm/v3/objects/deals/${dealId}`, {
      method: #43a047">"PATCH",
      headers: {
        Authorization: #43a047">`Bearer ${HUBSPOT_TOKEN}`,
        #43a047">"Content-Type": "application/json",
      },
      body: JSON.stringify({ properties: { dealstage: etapa } }),
    });
    const data = await res.json();
    return { content: [{ type: #43a047">"text", text: JSON.stringify(data) }] };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Conectar un ERP (ejemplo: Odoo vía XML-RPC)

Odoo expone XML-RPC de forma nativa desde la versión 14. En Python con FastMCP:

from mcp.server.fastmcp import FastMCP
import xmlrpc.client, os

mcp = FastMCP(#43a047">"odoo-erp")

URL = os.environ[#43a047">"ODOO_URL"]
DB  = os.environ[#43a047">"ODOO_DB"]
UID = int(os.environ[#43a047">"ODOO_UID"])
PWD = os.environ[#43a047">"ODOO_PASSWORD"]

models = xmlrpc.client.ServerProxy(f#43a047">"{URL}/xmlrpc/2/object")

@mcp.tool()
def consultar_stock(product_id: int) -> list:
    #43a047">"""Retorna el stock disponible de un producto en todos los almacenes."""
    return models.execute_kw(
        DB, UID, PWD,
        #43a047">"stock.quant", "search_read",
        [[[#43a047">"product_id", "=", product_id]]],
        {#43a047">"fields": ["location_id", "quantity"], "limit": 20},
    )

@mcp.tool()
def crear_orden_compra(product_id: int, cantidad: float, proveedor_id: int) -> dict:
    #43a047">"""Crea una orden de compra para reponer inventario. Registra la acción en log antes de ejecutar."""
    order_id = models.execute_kw(
        DB, UID, PWD,
        #43a047">"purchase.order", "create",
        [{#43a047">"partner_id": proveedor_id,
          #43a047">"order_line": [(0, 0, {"product_id": product_id, "product_qty": cantidad})]}],
    )
    return {#43a047">"order_id": order_id, "status": "created"}

if __name__ == #43a047">"__main__":
    mcp.run()

Con esto, un agente multi-agente IA puede detectar que el stock de un insumo cayó bajo el mínimo, identificar el proveedor habitual en Odoo y emitir la orden de compra, sin intervención humana. El equipo recibe la notificación del pedido ya creado.

Reglas de autorización: qué puede y qué no puede hacer el agente

En producción aplicamos cuatro principios:

Lectura libre, escritura gateada. El agente lee cualquier registro sin restricción. Las mutaciones (crear, actualizar, borrar) requieren que el agente incluya una justificación en el payload antes de ejecutar. El servidor MCP la registra.

Scopes mínimos por tool. Cada tool recibe el token con el perfil más restringido que necesita en tu CRM o ERP. El agente no tiene un token global.

Log estructurado obligatorio. Cada llamada al servidor MCP escribe: timestamp, agente que invocó, tool, parámetros y resultado. Auditable en treinta segundos.

Rate limiting por agente. El servidor aplica límites de llamadas por agente para evitar bucles accidentales que contaminen tus registros.

Arquitectura del sistema

[Agente IA (Claude / GPT-4o)]
         │  MCP over SSE/HTTPS
         ▼
[Servidor MCP empresa]──── auth middleware ────► [Log estructurado]
      │           │
      ▼           ▼
 [HubSpot]    [Odoo ERP]
  REST v3     XML-RPC

El servidor MCP es el único punto de contacto entre los agentes y tus sistemas internos. Los agentes no llaman directamente a las APIs del CRM ni del ERP. Esto simplifica la auditoría, centraliza el control de acceso y permite reemplazar cualquier sistema subyacente sin tocar el agente.

Lo que aprendimos implementándolo en producción

1. Los nombres de los tools importan más que los parámetros. El agente decide qué tool usar por el nombre y la descripción. avanzar_deal_a_etapa_cerrado_ganado funciona mejor que update_deal. La ambigüedad produce errores que no se ven en pruebas pero sí en producción.

2. Empezar con demasiados tools es un anti-patrón. Con 40 tools, la precisión del agente fue de 71%. Al recortar a 12 tools con responsabilidades claras, subió a 94%. Menos es más.

3. El protocolo SSE aguanta volumen enterprise. Con 8 agentes concurrentes consultando el mismo servidor MCP, la latencia media fue de 280 ms sobre HTTPS en nuestra infraestructura en VPS Contabo.

4. Lo que el agente no necesita ejecutar, no lo expongas. Si el agente no debe borrar registros, no crees un tool de delete. La superficie de riesgo es lo que expones en el servidor MCP, no lo que el agente "promete no hacer".

5. MCP se apoya en tu sistema de permisos existente, no lo reemplaza. El token que le das al servidor MCP debe ser el de menor privilegio posible en tu CRM o ERP. MCP agrega orquestación, no seguridad desde cero.

En resumen

• MCP es el estándar para conectar agentes IA con sistemas internos sin código custom por modelo de IA
• Expones tools con nombres descriptivos: el agente decide cuándo usarlos y con qué parámetros
• La regla clave: lectura libre, escritura con log y justificación del agente antes de ejecutar
• Empezar con 10 a 15 tools bien nombrados produce mejor precisión que 40 herramientas genéricas
• El servidor MCP es el único punto de integración: simplifica auditoría y control de acceso
• Servidores MCP enterprise verificados disponibles para Salesforce, SAP, HubSpot, Odoo y Jira

Si quieres implementar MCP en tu empresa sin construirlo desde cero, en AgentesNexo lo hacemos por ti. Escríbenos en agentesnexo.com o por WhatsApp al +591 67564218.