Operador del sistema MCP

Un servidor de Protocolo de Contexto de Modelo (MCP) para operaciones de Infraestructura como Código. Este servidor permite a los asistentes de IA interactuar con Ansible y Terraform, ejecutar playbooks y planes de Terraform, gestionar recursos en la nube y realizar otras operaciones de infraestructura directamente.
(Proyecto anteriormente conocido como mcp-ansible )

Proyectos de prueba de ejemplo

Todo el código en estas carpetas fue generado por Cline y mcp-sysoperator

Pila LAMP de AWS : todo el código Ansible para implementar una pila LAMP de ejemplo en AWS
AWS Terraform LAMP : código de Terraform y Ansible para implementar una pila LAMP

Todo el código se generó utilizando Claude 3.7 Sonnet (a través de OpenRouter), Cline y SysOperator

Características

Ejecutar playbooks de Ansible : ejecute playbooks de Ansible con soporte para parámetros como inventario, variables adicionales, etiquetas y límites
Lista de inventario : ver hosts y grupos desde un archivo de inventario de Ansible
Comprobar sintaxis : validar la sintaxis del libro de estrategias de Ansible sin ejecución
Lista de tareas : vista previa de las tareas que se ejecutarían mediante un libro de jugadas
Acceder al inventario predeterminado : acceda al archivo de inventario predeterminado de Ansible a través de la API de recursos
Integración con AWS : administre recursos de AWS (EC2, S3, VPC, CloudFormation, etc.)
Compatibilidad con Terraform : ejecuta comandos de Terraform (inicializa, planifica, aplica, destruye, genera, etc.)
Integración de tflocal : Pruebe las configuraciones de Terraform con LocalStack para el desarrollo de la nube local
Compatibilidad con LocalStack : pruebe las operaciones de AWS localmente usando LocalStack sin credenciales reales de AWS

Requisitos

Node.js 18 o superior
npm o hilo
Ansible instalado y en PATH
@modelcontextprotocol/sdk (instalado automáticamente)
Para operaciones de AWS: AWS CLI y credenciales válidas
Para LocalStack: LocalStack instalado y en ejecución, CLI de awslocal

Instalación

1. Clonar el repositorio

git clone https://github.com/tarnover/mcp-sysoperator.git
cd mcp-sysoperator

2. Instalar dependencias

npm install

3. Construya el servidor

npm run build

4. Configurar los ajustes de MCP

Agregue el servidor Ansible MCP a su archivo de configuración de MCP.

Para VSCode con la extensión Claude:

Edite el archivo en ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Para la aplicación de escritorio Claude:

macOS: Editar ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: Editar %APPDATA%\Claude\claude_desktop_config.json
Linux: Editar ~/.config/Claude/claude_desktop_config.json

Agregue lo siguiente a la sección mcpServers :

{
  "mcpServers": {
    "sysoperator": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-sysoperator/build/index.js"],
      "env": {}
    }
  }
}

Asegúrese de reemplazar /absolute/path/to/mcp-sysoperator con la ruta real a su instalación.

Ejemplos de uso

Una vez instalado y configurado, el servidor MCP proporciona las siguientes herramientas al asistente de IA:

1. Ejecutar un libro de jugadas

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>run_playbook</tool_name>
<arguments>
{
  "playbook": "/path/to/your/playbook.yml",
  "inventory": "/path/to/inventory.ini",
  "extraVars": {
    "var1": "value1",
    "var2": "value2"
  },
  "tags": "setup,configure",
  "limit": "webservers"
}
</arguments>
</use_mcp_tool>

2. Lista de inventario

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>list_inventory</tool_name>
<arguments>
{
  "inventory": "/path/to/inventory.ini"
}
</arguments>
</use_mcp_tool>

3. Verifique la sintaxis del libro de jugadas

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>check_syntax</tool_name>
<arguments>
{
  "playbook": "/path/to/your/playbook.yml"
}
</arguments>
</use_mcp_tool>

4. Enumere tareas en un libro de estrategias

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>list_tasks</tool_name>
<arguments>
{
  "playbook": "/path/to/your/playbook.yml"
}
</arguments>
</use_mcp_tool>

5. Acceder al recurso de inventario predeterminado

<access_mcp_resource>
<server_name>sysoperator</server_name>
<uri>sysoperator://inventory/default</uri>
</access_mcp_resource>

6. Operaciones de AWS S3

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>aws_s3</tool_name>
<arguments>
{
  "action": "list_buckets",
  "region": "us-east-1"
}
</arguments>
</use_mcp_tool>

7. Terraform Init y Plan

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>terraform</tool_name>
<arguments>
{
  "action": "init",
  "workingDir": "/path/to/terraform/project"
}
</arguments>
</use_mcp_tool>

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>terraform</tool_name>
<arguments>
{
  "action": "plan",
  "workingDir": "/path/to/terraform/project",
  "vars": {
    "instance_type": "t2.micro",
    "region": "us-west-2"
  }
}
</arguments>
</use_mcp_tool>

8. Terraform Aplicar

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>terraform</tool_name>
<arguments>
{
  "action": "apply",
  "workingDir": "/path/to/terraform/project",
  "autoApprove": true,
  "vars": {
    "instance_type": "t2.micro",
    "region": "us-west-2"
  }
}
</arguments>
</use_mcp_tool>

9. Terraform con LocalStack (tflocal)

<use_mcp_tool>
<server_name>sysoperator</server_name>
<tool_name>terraform</tool_name>
<arguments>
{
  "action": "apply",
  "workingDir": "/path/to/terraform/project",
  "useLocalstack": true,
  "autoApprove": true,
  "vars": {
    "instance_type": "t2.micro",
    "region": "us-west-2"
  }
}
</arguments>
</use_mcp_tool>

Integración de LocalStack

Este proyecto incluye la integración con LocalStack para probar las operaciones de AWS localmente sin credenciales reales de AWS. La integración con LocalStack permite:

Pruebe los playbooks de Ansible que utilizan servicios de AWS localmente
Desarrollar y probar operaciones de AWS sin incurrir en costos de AWS
Ejecute pruebas sin requerir credenciales reales de AWS
Valide su código de infraestructura antes de implementarlo en AWS real

Usando LocalStack

Consulte el archivo README de LocalStack para obtener instrucciones detalladas sobre el uso de la integración de LocalStack.

Inicio rápido:

# Install LocalStack and awslocal CLI
pip install localstack awscli-local

# Start LocalStack
localstack start

# Run the sample playbook
node localstack/run_sample_playbook.mjs

Desarrollo

Estructura del proyecto

mcp-sysoperator/
├── src/
│   ├── index.ts                  # Main entry point
│   └── ansible-mcp-server/       # Will be renamed in filesystem in future updates
│       ├── index.ts              # MCP SysOperator server implementation
│       ├── common/               # Common utilities and types
│       │   ├── errors.ts         # Error definitions
│       │   ├── types.ts          # Type and schema definitions
│       │   ├── utils.ts          # Utility functions
│       │   └── version.ts        # Version information
│       └── operations/           # Operation handlers
│           ├── ad_hoc.ts         # Ansible ad-hoc commands
│           ├── aws.ts            # AWS operations
│           ├── inventory.ts      # Ansible inventory operations
│           ├── playbooks.ts      # Ansible playbook operations
│           ├── terraform.ts      # Terraform operations
│           └── vault.ts          # Ansible vault operations
├── localstack/                   # LocalStack integration
│   ├── README.md                 # LocalStack documentation
│   ├── sample_playbook.yml       # Sample playbook for LocalStack
│   ├── inventory.ini             # Sample inventory for LocalStack
│   ├── run_sample_playbook.mjs   # Script to run sample playbook
│   └── utils.localstack.ts       # Modified utils for LocalStack
├── package.json                  # Project configuration and dependencies
├── tsconfig.json                 # TypeScript configuration
└── README.md                     # Documentation

Añadiendo nuevas funciones

Para agregar nuevas capacidades al servidor MCP:

Modificar src/ansible-mcp-server/index.ts (futuro: src/sysoperator/index.ts )
Agregue su nueva herramienta en el método setupToolHandlers
Implemente una función de controlador para su herramienta en el archivo de operaciones apropiado
Agregue la definición del esquema en common/types.ts
Reconstruir con npm run build

⚠️ Descargo de responsabilidad

SysOperator se encuentra actualmente en desarrollo activo y en pruebas exhaustivas. No se recomienda su uso en entornos de producción actualmente. El software podría experimentar cambios importantes, funciones incompletas o un comportamiento inesperado.

Úselo bajo su propio riesgo.

Licencia

Licencia MIT: consulte LICENCIA para obtener más detalles

MCP SysOperator

Integrations