MCP-Mem0

Integra memoria a largo plazo en agentes de IA usando Mem0.

Documentación

SFCore TH Dev: Integración de CumulusCI para Agentes de IA

Una implementación del servidor Model Context Protocol (MCP) integrado con CumulusCI para proporcionar a los agentes de IA capacidades de desarrollo de Salesforce.

Este servidor permite que los agentes de IA interactúen con comandos de CumulusCI sin que los desarrolladores necesiten recordar la sintaxis compleja de la CLI.

Descripción General

Este proyecto demuestra cómo construir un servidor MCP que permite a los agentes de IA ejecutar operaciones de CumulusCI para flujos de trabajo de desarrollo de Salesforce. Sirve como base para crear integraciones CCI más completas.

La implementación sigue las mejores prácticas establecidas por Anthropic para construir servidores MCP, permitiendo una integración perfecta con cualquier cliente compatible con MCP.

Características

El servidor actualmente proporciona una operación esencial de CCI:

create_scratch_org: Crear una nueva scratch org usando el flujo dev_org de CCI

Requisitos Previos

Python 3.12+
Acceso a una org de Salesforce (Dev Hub para scratch orgs)
Docker si se ejecuta el servidor MCP como contenedor (recomendado)

Configuración del Entorno

El servidor MCP proporciona verificación de instalación de CCI e instrucciones de configuración. Cuando encuentres errores de comando CCI no encontrado, usa la herramienta check_cci_installation que te guiará a través de:

# Check if CCI is installed
cci version

# Install CCI if not present
pipx install cumulusci-plus-azure-devops

# Upgrade CCI if needed
pipx install cumulusci-plus-azure-devops --force

Instalación

Usando uv

Instala uv si no lo tienes:
```
pip install uv
```

Clona este repositorio:

git clone <your-repo-url>
cd sfcore-th-dev

Instala las dependencias:
```
uv pip install -e .
```
Asegúrate de que CumulusCI esté instalado y configurado:
```
pip install cumulusci
cci org connect <your-dev-hub>
```

Usando Docker (Recomendado)

Construye la imagen Docker:

docker build -t ghcr.io/jorgesolebur/mcp-sfcore-th-dev:latest --build-arg PORT=8050 .

Sube al Registro de Contenedores de GitHub:

docker push ghcr.io/jorgesolebur/mcp-sfcore-th-dev:latest

Nota: Necesitarás autenticarte con el Registro de Contenedores de GitHub primero:

echo $GITHUB_TOKEN | docker login ghcr.io -u jorgesolebur --password-stdin

Configuración

Las siguientes variables de entorno se pueden configurar en tu archivo .env:

Variable	Descripción	Valor por Defecto
`TRANSPORT`	Protocolo de transporte (sse o stdio)	`sse`
`HOST`	Host al que vincularse al usar transporte SSE	`0.0.0.0`
`PORT`	Puerto para escuchar al usar transporte SSE	`8050`

El servidor depende de que CumulusCI esté correctamente configurado en el sistema donde se ejecuta.

Ejecutando el Servidor

Usando uv

Transporte SSE

# Set TRANSPORT=sse in .env then:
uv run src/main.py

El servidor MCP se ejecutará como un endpoint de API al que puedes conectarte con la configuración que se muestra a continuación.

Transporte Stdio

Con stdio, el cliente MCP puede iniciar el servidor MCP por sí mismo, por lo que no hay nada que ejecutar en este punto.

Usando Docker

Transporte SSE

docker run -d -p 8050:8050 ghcr.io/jorgesolebur/mcp-sfcore-th-dev:latest

El servidor MCP se ejecutará como un endpoint de API dentro del contenedor.

Transporte Stdio

Con stdio, el cliente MCP puede iniciar el contenedor del servidor MCP por sí mismo, por lo que no hay nada que ejecutar en este punto.

Integración con Clientes MCP

Configuración SSE

Una vez que tengas el servidor ejecutándose con transporte SSE, puedes conectarte a él usando esta configuración:

{
  "mcpServers": {
    "sfcore-th-dev": {
      "transport": "sse",
      "url": "http://localhost:8050/sse"
    }
  }
}

Nota para usuarios de Windsurf: Usa serverUrl en lugar de url en tu configuración:
{
  "mcpServers": {
    "sfcore-th-dev": {
      "transport": "sse",
      "serverUrl": "http://localhost:8050/sse"
    }
  }
}

Nota para usuarios de n8n: Usa host.docker.internal en lugar de localhost ya que n8n tiene que alcanzar fuera de su propio contenedor hacia la máquina host:

Entonces la URL completa en el nodo MCP sería: http://host.docker.internal:8050/sse

Asegúrate de actualizar el puerto si estás usando un valor diferente al 8050 predeterminado.

Python con Configuración Stdio

Agrega este servidor a tu configuración MCP para Claude Desktop, Windsurf o cualquier otro cliente MCP:

{
  "mcpServers": {
    "sfcore-th-dev": {
      "command": "your/path/to/sfcore-th-dev/.venv/Scripts/python.exe",
      "args": ["your/path/to/sfcore-th-dev/src/main.py"],
      "env": {
        "TRANSPORT": "stdio"
      }
    }
  }
}

Docker con Configuración Stdio

{
  "mcpServers": {
    "sfcore-th-dev": {
      "command": "docker",
      "args": ["run", "--rm", "-i", 
               "-e", "TRANSPORT", 
               "ghcr.io/jorgesolebur/mcp-sfcore-th-dev:latest"],
      "env": {
        "TRANSPORT": "stdio"
      }
    }
  }
}

Extendiendo el Servidor

Esta plantilla proporciona una base para construir integraciones CCI más completas. Para agregar nuevas herramientas CCI:

Crea un nuevo método @mcp.tool()
Usa la función de utilidad get_cci_command_instructions() para un comportamiento consistente

Ejemplo:

@mcp.tool()
async def deploy_to_org(org_name: str = "dev") -> str:
    command = f"cci flow run deploy --org {org_name}"
    purpose = f"Deploy to org '{org_name}'"
    return get_cci_command_instructions(command, purpose)

Esto asegura que todas las herramientas tengan ejecución de comandos y manejo de errores consistentes.

Herramientas Disponibles

Configuración del Entorno

check_cci_installation: Verifica si CumulusCI está instalado y proporciona instrucciones de instalación/actualización

Gestión de Scratch Orgs

create_dev_scratch_org: Crea una scratch org de desarrollo usando cci flow run dev_org --org <org_name>
create_feature_scratch_org: Crea una scratch org de feature/QA usando cci flow run ci_feature_2gp --org <org_name>
create_beta_scratch_org: Crea una scratch org de beta/regresión usando cci flow run regression_org --org <org_name>
list_orgs: Lista todas las orgs conectadas de CumulusCI usando cci org list
open_org: Abre la org especificada en un navegador usando cci org browser --org <org_name>

Operaciones de Desarrollo

run_tests: Ejecuta pruebas Apex en una org especificada usando cci task run run_all_tests_locally --org <org_name>
retrieve_changes: Recupera cambios de metadatos de la org especificada usando cci task run retrieve_changes --org <org_name>
deploy: Despliega metadatos locales a la org especificada usando cci task run deploy --org <org_name>

Manejador Genérico de Tareas CCI

run_generic_cci_task: Maneja cualquier tarea CCI que no tenga una herramienta dedicada siguiendo un enfoque de 3 pasos:
1. Verifica si la tarea existe usando cci task list
2. Obtiene información y parámetros de la tarea usando cci task info o cci task run --help
3. Ejecuta la tarea con los parámetros apropiados después de recopilar los valores requeridos del usuario

Todas las herramientas CCI proporcionan orientación de configuración si es necesario y siguen patrones consistentes de manejo de errores.

Recursos MCP

El servidor proporciona documentación específica del framework a través de recursos MCP. Estos recursos dan a los agentes información contextual sobre prácticas y estándares de desarrollo.

Recursos Disponibles

Accede a los recursos usando el patrón de URI: framework://<framework-name>

framework://salesforce-triggers: Guías completas para desarrollar triggers de Apex
- Arquitectura del framework de triggers
- Implementación del patrón de handler
- Mejores prácticas y anti-patrones
- Estrategias de prueba
- Consideraciones de rendimiento
framework://salesforce-logging: Estándares de registro y mejores prácticas
- Implementación de logger personalizado
- Niveles de registro y guías de uso
- Consideraciones de rendimiento
- Estrategias de registro en producción
- Consideraciones de seguridad y privacidad
framework://salesforce-cache-manager: Framework de gestión de Platform Cache para optimización de rendimiento
- Tres tipos de caché: Organización, Sesión y Transacción
- Configuración declarativa con metadatos personalizados
- Ejemplos de uso y mejores prácticas
- Monitoreo de rendimiento y depuración
- Consideraciones de seguridad para datos en caché

Usando Recursos

Los agentes pueden solicitar documentación del framework cuando sea necesario:

{
  "method": "resources/read",
  "params": {
    "uri": "framework://salesforce-triggers"
  }
}

Esto proporciona acceso bajo demanda a guías específicas del framework sin saturar las descripciones de las herramientas.

Mejoras Futuras

Considera agregar:

Recursos adicionales del framework (LWC, Aura, Flows)
Más herramientas de operaciones CCI
Integración con pipelines de CI/CD
Flujos de trabajo de prueba avanzados