Servidor MCP de Unsloth

Un servidor MCP para Unsloth : una biblioteca que hace que el ajuste de LLM sea dos veces más rápido con un 80 % menos de memoria.

¿Qué es Unsloth?

Unsloth es una biblioteca que mejora drásticamente la eficiencia del ajuste de modelos de lenguaje grandes:

• Velocidad : ajuste fino 2 veces más rápido en comparación con los métodos estándar

• Memoria : 80 % menos de uso de VRAM, lo que permite ajustar modelos más grandes en GPU de consumo

• Longitud del contexto : longitudes de contexto hasta 13 veces más largas (por ejemplo, 89 000 tokens para Llama 3.3 en GPU de 80 GB)

• Precisión : Sin pérdida de calidad ni rendimiento del modelo.

Unsloth logra estas mejoras a través de kernels CUDA personalizados escritos en el lenguaje Triton de OpenAI, retropropagación optimizada y cuantificación dinámica de 4 bits.

Related MCP server: Model Context Protocol (MCP) Server

Características

• Optimizar el ajuste fino para Llama, Mistral, Phi, Gemma y otros modelos

• Cuantización de 4 bits para un entrenamiento eficiente

• Soporte de longitud de contexto extendida

• API simple para carga, ajuste e inferencia de modelos

• Exportar a varios formatos (GGUF, Hugging Face, etc.)

Inicio rápido

1. Instalar Unsloth: pip install unsloth

2. Instalar y construir el servidor:

   cd unsloth-server
   npm install
   npm run build

3. Agregar a la configuración de MCP:

   {
     "mcpServers": {
       "unsloth-server": {
         "command": "node",
         "args": ["/path/to/unsloth-server/build/index.js"],
         "env": {
           "HUGGINGFACE_TOKEN": "your_token_here" // Optional
         },
         "disabled": false,
         "autoApprove": []
       }
     }
   }

Herramientas disponibles

comprobar_instalación

Verifique si Unsloth está instalado correctamente en su sistema.

Parámetros : Ninguno

Ejemplo :

const result = await use_mcp_tool({
  server_name: "unsloth-server",
  tool_name: "check_installation",
  arguments: {}
});

lista_de_modelos_compatibles

Obtén una lista de todos los modelos compatibles con Unsloth, incluidas las variantes Llama, Mistral, Phi y Gemma.

Parámetros : Ninguno

Ejemplo :

const result = await use_mcp_tool({
  server_name: "unsloth-server",
  tool_name: "list_supported_models",
  arguments: {}
});

modelo de carga

Cargue un modelo previamente entrenado con optimizaciones de Unsloth para una inferencia y un ajuste más rápidos.

Parámetros :

• model_name (obligatorio): Nombre del modelo a cargar (p. ej., "unsloth/Llama-3.2-1B")

• max_seq_length (opcional): Longitud máxima de secuencia para el modelo (predeterminado: 2048)

• load_in_4bit (opcional): si se debe cargar el modelo en cuantificación de 4 bits (valor predeterminado: verdadero)

• use_gradient_checkpointing (opcional): si se deben utilizar puntos de control de gradiente para ahorrar memoria (valor predeterminado: verdadero)

Ejemplo :

const result = await use_mcp_tool({
  server_name: "unsloth-server",
  tool_name: "load_model",
  arguments: {
    model_name: "unsloth/Llama-3.2-1B",
    max_seq_length: 4096,
    load_in_4bit: true
  }
});

modelo de ajuste fino

Ajuste un modelo con optimizaciones de Unsloth utilizando técnicas LoRA/QLoRA.

Parámetros :

• model_name (obligatorio): Nombre del modelo a ajustar

• dataset_name (obligatorio): Nombre del conjunto de datos que se utilizará para el ajuste fino

• output_dir (obligatorio): Directorio para guardar el modelo ajustado

• max_seq_length (opcional): Longitud máxima de secuencia para entrenamiento (predeterminado: 2048)

• lora_rank (opcional): rango para el ajuste fino de LoRA (predeterminado: 16)

• lora_alpha (opcional): Alfa para el ajuste fino de LoRA (valor predeterminado: 16)

• batch_size (opcional): tamaño del lote para entrenamiento (predeterminado: 2)

• gradient_accumulation_steps (opcional): Número de pasos de acumulación de gradiente (predeterminado: 4)

• learning_rate (opcional): tasa de aprendizaje para el entrenamiento (predeterminado: 2e-4)

• max_steps (opcional): Número máximo de pasos de entrenamiento (predeterminado: 100)

• dataset_text_field (opcional): Campo en el conjunto de datos que contiene el texto (predeterminado: 'texto')

• load_in_4bit (opcional): si se debe utilizar cuantificación de 4 bits (valor predeterminado: verdadero)

Ejemplo :

const result = await use_mcp_tool({
  server_name: "unsloth-server",
  tool_name: "finetune_model",
  arguments: {
    model_name: "unsloth/Llama-3.2-1B",
    dataset_name: "tatsu-lab/alpaca",
    output_dir: "./fine-tuned-model",
    max_steps: 100,
    batch_size: 2,
    learning_rate: 2e-4
  }
});

generar_texto

Genere texto utilizando un modelo Unsloth perfeccionado.

Parámetros :

• model_path (obligatorio): Ruta al modelo ajustado

• prompt (obligatorio): Solicitud de generación de texto

• max_new_tokens (opcional): Número máximo de tokens a generar (predeterminado: 256)

• temperature (opcional): Temperatura para la generación de texto (predeterminado: 0,7)

• top_p (opcional): Top-p para generación de texto (predeterminado: 0.9)

Ejemplo :

const result = await use_mcp_tool({
  server_name: "unsloth-server",
  tool_name: "generate_text",
  arguments: {
    model_path: "./fine-tuned-model",
    prompt: "Write a short story about a robot learning to paint:",
    max_new_tokens: 512,
    temperature: 0.8
  }
});

modelo_de_exportación

Exporte un modelo Unsloth ajustado a varios formatos para su implementación.

Parámetros :

• model_path (obligatorio): Ruta al modelo ajustado

• export_format (obligatorio): Formato al que se exportará (gguf, ollama, vllm, huggingface)

• output_path (obligatorio): Ruta para guardar el modelo exportado

• quantization_bits (opcional): Bits para cuantificación (para exportación GGUF) (valor predeterminado: 4)

Ejemplo :

const result = await use_mcp_tool({
  server_name: "unsloth-server",
  tool_name: "export_model",
  arguments: {
    model_path: "./fine-tuned-model",
    export_format: "gguf",
    output_path: "./exported-model.gguf",
    quantization_bits: 4
  }
});

Uso avanzado

Conjuntos de datos personalizados

Puede utilizar conjuntos de datos personalizados formateándolos correctamente y alojándolos en Hugging Face o proporcionando una ruta local:

const result = await use_mcp_tool({
  server_name: "unsloth-server",
  tool_name: "finetune_model",
  arguments: {
    model_name: "unsloth/Llama-3.2-1B",
    dataset_name: "json",
    data_files: {"train": "path/to/your/data.json"},
    output_dir: "./fine-tuned-model"
  }
});

Optimización de la memoria

Para modelos grandes con hardware limitado:

• Reducir el tamaño del lote y aumentar los pasos de acumulación de gradiente

• Utilice cuantificación de 4 bits

• Habilitar puntos de control de gradiente

• Reducir la longitud de la secuencia si es posible

Solución de problemas

Problemas comunes

1. CUDA sin memoria : reduzca el tamaño del lote, utilice cuantificación de 4 bits o pruebe un modelo más pequeño

2. Errores de importación : asegúrese de tener instaladas las versiones correctas de Torch, Transformers y Unsloth.

3. Modelo no encontrado : comprueba que estás usando un nombre de modelo compatible o que tienes acceso a modelos privados

Compatibilidad de versiones

• Python: 3.10, 3.11 o 3.12 (no 3.13)

• CUDA: se recomienda 11.8 o 12.1+

• PyTorch: se recomienda la versión 2.0+

Puntos de referencia de rendimiento

Requisitos

• Python 3.10-3.12

• GPU NVIDIA con soporte CUDA (recomendado)

• Node.js y npm

Licencia

Apache-2.0