# Ejecución del servidor LLM en un servidor separado

En esta sección se describe la configuración para ejecutar solo el servidor LLM en un servidor separado, sin los demás componentes del Sherpa AI Server.

### Cuándo es necesario

Ejecutar el servidor LLM en un servidor separado es útil cuando:

* Es necesario distribuir la carga entre servidores
* El servidor LLM requiere GPU potentes y es mejor trasladarlo a un servidor separado
* Se requiere escalado: varios servidores LLM para equilibrar la carga
* Es necesario aislar el servidor LLM de la aplicación principal

### Requisitos

* Servidor con GPU NVIDIA (CUDA 11.8+)
* Docker y Docker Compose instalados
* NVIDIA Container Toolkit instalado
* Modelos LLM cargados en el directorio `llm-server/models/`

### Configuración

#### Paso 1: Preparación del servidor

Asegúrese de que en el servidor estén instalados todos los componentes necesarios

```bash
# Verifique la GPU
nvidia-smi

# Verifique Docker
docker --version
docker compose version
```

#### Paso 2: Preparación de archivos

Copie en el servidor los siguientes archivos y directorios:

```bash
# Archivos necesarios:
# - docker-compose.yml (o docker-compose.main.yml)
# - archivo .env con configuraciones
# - llm-server/models/ - directorio con modelos
# - llm-server/templates/ - directorio con plantillas (si se utiliza)
```

#### Paso 3: Comentando servicios innecesarios

Abra el archivo `docker-compose.yml` y comente todos los servicios excepto `aiserver-llm-server`.

**Ejemplo: Servicios comentados**

```yaml
services:

  # aiserver-pg:
  #   container_name: aiserver-pg
  #   image: aiserver-pg:latest
  #   ...

  # aiserver-embed:
  #   container_name: aiserver-embed
  #   ...

  # aiserver:
  #   container_name: aiserver
  #   ...

  # Único servicio activo:
  aiserver-llm-server:
    container_name: aiserver-llm-server
    image: aiserver-llm-server:latest
    restart: always
    env_file:
      - .env
    ports:
      - 3003:8000
    ipc: host
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [ gpu ]
    volumes:
      - "./llm-server/models:/model-store"
      - "./llm-server/templates:/model-templates"
    networks:
      - llm-net

  # aiserver-code_interpreter:
  #   ...

  # aiserver-whisper:
  #   ...

  # aiserver-bge_reranker:
  #   ...
```

#### Paso 5: Configuración de variables de entorno

Cree o edite el archivo `.env` con la configuración del servidor LLM:

```bash
# Configuración del servidor LLM
LLM_CUDA_VISIBLE_DEVICES=0
LLM_TENSOR_PARALLEL_SIZE=1
LLM_GPU_MEMORY_UTILIZATION=0.90
LLM_COMPLETION_MODEL_NAME=/model-store/meta-llama/Meta-Llama-3-8B-Instruct
LLM_DTYPE=auto
LLM_TRUST_REMOTE_CODE=false
LLM_QUANTIZATION=false
LLM_MAX_MODEL_LEN=8192
LLM_HOST=0.0.0.0
LLM_PORT=8000
LLM_MAX_NUM_BATCHED_TOKENS=16384
LLM_MAX_NUM_SEQS=16
LLM_ENABLE_TOOLS=true
LLM_TOOL_CALL_PARSER=llama3_json
LLM_EXCLUDE_TOOLS_WHEN_NONE=true
```

**Importante:**

* Asegúrese de que la ruta al modelo sea correcta: `LLM_COMPLETION_MODEL_NAME=/model-store/nombre-del-modelo`

#### Paso 6: Verificación de la configuración

Antes de iniciar, verifique la configuración:

```bash
# Verifique la sintaxis del archivo docker-compose
docker compose -f docker-compose.yml config

# Verifique que el puerto esté libre
netstat -tuln | grep 3003

# Verifique la existencia del modelo
ls -la llm-server/models/
```

#### Paso 7: Ejecución del servidor LLM

```bash
# Inicie solo el servidor LLM
docker compose -f docker-compose.yml up -d aiserver-llm-server

# O inicie todo (pero solo se iniciarán los servicios no comentados)
docker compose -f docker-compose.yml up -d

# Verifique el estado
docker compose -f docker-compose.yml ps
```

**Resultado esperado:** Solo debe iniciarse el contenedor `aiserver-llm-server`.

#### Paso 8: Verificación del funcionamiento

```bash
# Verifique los registros
docker logs aiserver-llm-server

# Verifique el uso de GPU
nvidia-smi

# Verifique la disponibilidad de la API (debe devolver información sobre el modelo)
curl http://localhost:3003/v1/models
```

**Resultado esperado:**

* El contenedor debe iniciarse correctamente
* No debe haber errores críticos en los registros
* La API debe responder a las solicitudes
* La GPU debe utilizarse para cargar el modelo

### Conexión desde otro servidor

Si el servidor LLM se ejecuta en un servidor separado, configure la conexión desde el servidor principal.

#### En el servidor principal

En el archivo `.env` del servidor principal, indique la dirección del servidor LLM:

```bash
# Dirección del servidor LLM (reemplácelo con la IP o dominio de su servidor LLM)
LLM_SERVER_URL=http://192.168.1.100:3003
# o
LLM_SERVER_URL=http://llm-server.ejemplo.com:3003
```

### Configuración mínima de docker-compose

Ejemplo de un `docker-compose.yml` mínimo solo para el servidor LLM:

```yaml
services:
  aiserver-llm-server:
    container_name: aiserver-llm-server
    image: aiserver-llm-server:latest
    restart: always
    env_file:
      - .env
    ports:
      - "3003:8000"
    ipc: host
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [ gpu ]
    volumes:
      - "./llm-server/models:/model-store"
      - "./llm-server/templates:/model-templates"
    networks:
      - llm-net

networks:
  llm-net:
    name: llm-net
    driver: bridge
```

Guarde este archivo como `docker-compose.llm-only.yml` y utilice:

```bash
docker compose -f docker-compose.llm-only.yml up -d
```

### Problemas posibles

#### El contenedor no se inicia

**Problema:** El contenedor falla inmediatamente después de iniciar.

**Solución:**

1. Verifique los registros: `docker logs aiserver-llm-server`
2. Asegúrese de que la GPU esté disponible: `nvidia-smi`
3. Verifique que el modelo exista: `ls -la llm-server/models/`
4. Verifique los permisos de acceso al directorio de modelos

#### El modelo no se carga

**Problema:** Errores al cargar el modelo.

**Solución:**

1. Verifique la ruta al modelo en `.env`: `LLM_COMPLETION_MODEL_NAME`
2. Asegúrese de que el modelo esté cargado: `ls -la llm-server/models/`
3. Verifique los registros en busca de errores de carga: `docker logs aiserver-llm-server | grep -i error`

#### Memoria GPU insuficiente

**Problema:** El modelo no cabe en la memoria GPU.

**Solución:**

* Reduzca `LLM_GPU_MEMORY_UTILIZATION` en `.env`
* Utilice la versión cuantizada del modelo (configure `LLM_QUANTIZATION=true`)
* Utilice un modelo de menor tamaño

#### El puerto no está disponible externamente

**Problema:** No puedo conectarme al servidor LLM desde otro servidor.

**Solución:**

1. Verifique el firewall: `sudo ufw status`
2. Verifique que el puerto esté expuesto: `docker port aiserver-llm-server`
3. Verifique la configuración de red de Docker

### Monitoreo

Para monitorear el funcionamiento del servidor LLM:

```bash
# Estado del contenedor
docker ps | grep llm-server

# Uso de recursos
docker stats aiserver-llm-server

# Uso de GPU
watch -n 1 nvidia-smi

# Registros en tiempo real
docker logs -f aiserver-llm-server

# Verificación de la API
curl http://localhost:3003/health
curl http://localhost:3003/v1/models
```

### Optimización del rendimiento

Para optimizar el rendimiento del servidor LLM:

1. **Configuración de la memoria GPU:**

   ```bash
   LLM_GPU_MEMORY_UTILIZATION=0.90  # Utilice la máxima memoria disponible
   ```
2. **Configuración de batching:**

   ```bash
   LLM_MAX_NUM_BATCHED_TOKENS=16384
   LLM_MAX_NUM_SEQS=16
   ```
3. **Uso de cuantización:**

   ```bash
   LLM_QUANTIZATION=true  # Para modelos con soporte de cuantización
   ```

Después de completar todos los pasos, debe tener el servidor LLM ejecutándose solo en un servidor separado, que se puede utilizar desde el servidor principal o desde otras aplicaciones a través de la API en el puerto 3003.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.sherparpa.ru/es/sherpa-ai/sherpa-ai-server/ustanovka-sherpa-ai-server/zapusk-llm-servera-na-otdelnom-servere.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.