# Execução do servidor LLM em um servidor separado

Nesta seção, descrevemos a configuração para executar apenas o servidor LLM em um servidor separado, sem os demais componentes do Sherpa AI Server.

### Quando isso é necessário

Executar o servidor LLM em um servidor separado é útil quando:

* É necessário distribuir a carga entre servidores
* O servidor LLM requer GPUs poderosas e é melhor colocá-lo em um servidor separado
* É necessário escalonamento - vários servidores LLM para balanceamento de carga
* É preciso isolar o servidor LLM do aplicativo principal

### Requisitos

* Servidor com GPU NVIDIA (CUDA 11.8+)
* Docker e Docker Compose instalados
* NVIDIA Container Toolkit instalado
* Modelos LLM carregados no diretório `llm-server/models/`

### Configuração

#### Passo 1: Preparação do servidor

Certifique-se de que todos os componentes necessários estão instalados no servidor

```bash
# Verifique a GPU
nvidia-smi

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

#### Passo 2: Preparação dos arquivos

Copie os seguintes arquivos e diretórios para o servidor:

```bash
# Arquivos necessários:
# - docker-compose.yml (ou docker-compose.main.yml)
# - arquivo .env com as configurações
# - llm-server/models/ - diretório com os modelos
# - llm-server/templates/ - diretório com os templates (se utilizado)
```

#### Passo 3: Comentando serviços desnecessários

Abra o arquivo `docker-compose.yml` e comente todos os serviços, exceto `aiserver-llm-server`.

**Exemplo: Serviços comentados**

```yaml
services:

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

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

  # aiserver:
  #   container_name: aiserver
  #   ...

  # Único serviço ativo:
  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:
  #   ...
```

#### Passo 5: Configuração das variáveis de ambiente

Crie ou edite o arquivo `.env` com as configurações do servidor LLM:

```bash
# Configurações do 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:**

* Certifique-se de que o caminho para o modelo está correto: `LLM_COMPLETION_MODEL_NAME=/model-store/nome-do-modelo`

#### Passo 6: Verificação da configuração

Antes de iniciar, verifique a configuração:

```bash
# Verifique a sintaxe do arquivo docker-compose
docker compose -f docker-compose.yml config

# Verifique se a porta está livre
netstat -tuln | grep 3003

# Verifique a existência do modelo
ls -la llm-server/models/
```

#### Passo 7: Iniciando o servidor LLM

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

# Ou inicie tudo (mas apenas os serviços não comentados serão iniciados)
docker compose -f docker-compose.yml up -d

# Verifique o status
docker compose -f docker-compose.yml ps
```

**Resultado esperado:** Apenas o contêiner `aiserver-llm-server` deve ser iniciado.

#### Passo 8: Verificação do funcionamento

```bash
# Verifique os logs
docker logs aiserver-llm-server

# Verifique o uso da GPU
nvidia-smi

# Verifique a disponibilidade da API (deve retornar informações sobre o modelo)
curl http://localhost:3003/v1/models
```

**Resultado esperado:**

* O contêiner deve iniciar com sucesso
* Não deve haver erros críticos nos logs
* A API deve responder às solicitações
* A GPU deve ser utilizada para carregar o modelo

### Conexão de outro servidor

Se o servidor LLM estiver em um servidor separado, configure a conexão a partir do servidor principal.

#### No servidor principal

No arquivo `.env` do servidor principal, especifique o endereço do servidor LLM:

```bash
# Endereço do servidor LLM (substitua pelo IP ou domínio do seu servidor LLM)
LLM_SERVER_URL=http://192.168.1.100:3003
# ou
LLM_SERVER_URL=http://llm-server.example.com:3003
```

### Configuração mínima do docker-compose

Exemplo de um `docker-compose.yml` mínimo apenas para o 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
```

Salve este arquivo como `docker-compose.llm-only.yml` e use:

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

### Problemas potenciais

#### O contêiner não inicia

**Problema:** O contêiner falha imediatamente após o início.

**Solução:**

1. Verifique os logs: `docker logs aiserver-llm-server`
2. Certifique-se de que a GPU está disponível: `nvidia-smi`
3. Verifique se o modelo existe: `ls -la llm-server/models/`
4. Verifique as permissões do diretório dos modelos

#### O modelo não carrega

**Problema:** Erros ao carregar o modelo.

**Solução:**

1. Verifique o caminho do modelo no `.env`: `LLM_COMPLETION_MODEL_NAME`
2. Certifique-se de que o modelo está carregado: `ls -la llm-server/models/`
3. Verifique os logs para erros de carregamento: `docker logs aiserver-llm-server | grep -i error`

#### Memória GPU insuficiente

**Problema:** O modelo não cabe na memória da GPU.

**Solução:**

* Reduza `LLM_GPU_MEMORY_UTILIZATION` no `.env`
* Use a versão quantizada do modelo (defina `LLM_QUANTIZATION=true`)
* Utilize um modelo menor

#### Porta indisponível externamente

**Problema:** Não consigo conectar ao servidor LLM de outro servidor.

**Solução:**

1. Verifique o firewall: `sudo ufw status`
2. Verifique se a porta está mapeada: `docker port aiserver-llm-server`
3. Verifique as configurações de rede do Docker

### Monitoramento

Para monitorar o funcionamento do servidor LLM:

```bash
# Status do contêiner
docker ps | grep llm-server

# Uso de recursos
docker stats aiserver-llm-server

# Uso da GPU
watch -n 1 nvidia-smi

# Logs em tempo real
docker logs -f aiserver-llm-server

# Verificação da API
curl http://localhost:3003/health
curl http://localhost:3003/v1/models
```

### Otimização de desempenho

Para otimizar o desempenho do servidor LLM:

1. **Configuração da memória GPU:**

   ```bash
   LLM_GPU_MEMORY_UTILIZATION=0.90  # Use o máximo de memória disponível
   ```
2. **Configuração de batching:**

   ```bash
   LLM_MAX_NUM_BATCHED_TOKENS=16384
   LLM_MAX_NUM_SEQS=16
   ```
3. **Uso de quantização:**

   ```bash
   LLM_QUANTIZATION=true  # Para modelos com suporte a quantização
   ```

Após seguir todos os passos, você deve ter apenas o servidor LLM em um servidor separado, que pode ser utilizado a partir do servidor principal ou de outros aplicativos através da API na porta 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/pt/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.