> ## Documentation Index
> Fetch the complete documentation index at: https://chatcli.edilsonfreitas.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Receita: Servidor Remoto para Equipe

> Guia passo a passo para configurar um servidor ChatCLI centralizado para toda a equipe, com autenticação, TLS e múltiplos provedores.

Nesta receita, você vai configurar um servidor ChatCLI centralizado que atende toda a equipe de desenvolvimento. Cada membro pode conectar do seu terminal e usar a IA sem precisar gerenciar API keys individuais.

***

## Cenário

<CardGroup cols={2}>
  <Card title="Equipe Pequena" icon="users">
    5-10 desenvolvedores compartilhando recursos
  </Card>

  <Card title="API Keys Corporativas" icon="key">
    Servidor central com chaves gerenciadas
  </Card>

  <Card title="Acesso via Terminal" icon="terminal">
    Cada dev conecta do seu terminal local
  </Card>

  <Card title="Autenticação Flexível" icon="shield-halved">
    Token compartilhado ou credenciais próprias
  </Card>
</CardGroup>

***

<Steps>
  <Step title="Configurar o Servidor">
    <Tabs>
      <Tab title="Docker Compose (Simples)">
        Crie um arquivo `.env` no servidor:

        ```bash theme={"system"}
        # .env
        CHATCLI_SERVER_TOKEN=equipe-token-2024
        LLM_PROVIDER=CLAUDEAI
        ANTHROPIC_API_KEY=sk-ant-xxx-chave-corporativa
        ANTHROPIC_MODEL=claude-sonnet-4-6
        LOG_LEVEL=info
        ```

        Inicie com Docker Compose:

        ```bash theme={"system"}
        docker compose up -d
        ```
      </Tab>

      <Tab title="Binário Direto">
        ```bash theme={"system"}
        export CHATCLI_SERVER_TOKEN=equipe-token-2024
        export LLM_PROVIDER=CLAUDEAI
        export ANTHROPIC_API_KEY=sk-ant-xxx
        chatcli server --port 50051
        ```
      </Tab>

      <Tab title="Kubernetes (Helm)">
        ```bash theme={"system"}
        helm install chatcli oci://ghcr.io/diillson/charts/chatcli \
          --namespace tools --create-namespace \
          --set llm.provider=CLAUDEAI \
          --set secrets.anthropicApiKey=sk-ant-xxx \
          --set server.token=equipe-token-2024 \
          --set service.type=LoadBalancer
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Distribuir Acesso">
    Compartilhe com a equipe:

    ```bash theme={"system"}
    # Adicione ao .bashrc ou .zshrc de cada dev
    export CHATCLI_REMOTE_ADDR=servidor-ia:50051
    export CHATCLI_REMOTE_TOKEN=equipe-token-2024

    # Alias para acesso rápido
    alias cia='chatcli connect'
    ```
  </Step>

  <Step title="Cada Dev Conecta">
    ```bash theme={"system"}
    # Modo interativo
    chatcli connect

    # One-shot rápido
    chatcli connect -p "Explique o padrão Repository em Go"
    ```
  </Step>

  <Step title="Permitir Credenciais Próprias (Opcional)">
    Devs que preferem usar suas próprias credenciais podem fazê-lo:

    ```bash theme={"system"}
    # Dev que tem assinatura Claude Pro
    chatcli connect --use-local-auth

    # Dev que prefere OpenAI
    chatcli connect --provider OPENAI --llm-key sk-minha-chave-pessoal

    # Dev que usa GitHub Copilot
    chatcli connect --use-local-auth --provider COPILOT
    ```

    <Info>
      O servidor aceita ambos os modos simultaneamente. Devs podem usar as credenciais do servidor (padrão) ou fornecer suas próprias.
    </Info>
  </Step>

  <Step title="Adicionar TLS (Produção)">
    Para ambientes de produção, adicione TLS:

    ```bash theme={"system"}
    # Gerar certificados (ex: com Let's Encrypt ou certbot)
    # Ou usar mkcert para desenvolvimento

    # Iniciar com TLS
    chatcli server \
      --tls-cert /etc/chatcli/cert.pem \
      --tls-key /etc/chatcli/key.pem \
      --token equipe-token-2024
    ```

    Devs conectam com:

    ```bash theme={"system"}
    chatcli connect servidor:50051 --tls --token equipe-token-2024
    ```
  </Step>

  <Step title="Múltiplos Provedores">
    Configure o servidor com múltiplas API keys. Devs podem escolher o provedor:

    ```bash theme={"system"}
    # Servidor com OpenAI, Claude, Google AI e Copilot
    export OPENAI_API_KEY=sk-xxx
    export ANTHROPIC_API_KEY=sk-ant-xxx
    export GOOGLEAI_API_KEY=AIzaSy-xxx
    export GITHUB_COPILOT_TOKEN=ghu_xxx  # ou use /auth login github-copilot
    export LLM_PROVIDER=CLAUDEAI  # padrão
    chatcli server
    ```

    ```bash theme={"system"}
    # Dev escolhe o provedor
    chatcli connect --provider OPENAI
    chatcli connect --provider GOOGLEAI
    chatcli connect --provider COPILOT --use-local-auth
    chatcli connect  # usa o padrão (CLAUDEAI)
    ```
  </Step>

  <Step title="Compartilhar Agents, Skills e Plugins (Opcional)">
    Provisione agents, skills e plugins no servidor para que toda a equipe tenha acesso aos mesmos recursos:

    <Tabs>
      <Tab title="Via Helm">
        ```bash theme={"system"}
        helm install chatcli oci://ghcr.io/diillson/charts/chatcli \
          --namespace tools --create-namespace \
          --set llm.provider=CLAUDEAI \
          --set secrets.anthropicApiKey=sk-ant-xxx \
          --set server.token=equipe-token-2024 \
          --set agents.enabled=true \
          --set-file agents.definitions.devops-senior\\.md=agents/devops-senior.md \
          --set skills.enabled=true \
          --set-file skills.definitions.k8s-best-practices\\.md=skills/k8s-best-practices.md \
          --set plugins.enabled=true \
          --set plugins.initImage=myregistry/chatcli-plugins:latest
        ```
      </Tab>

      <Tab title="Via ConfigMaps">
        ```bash theme={"system"}
        # Criar ConfigMap com agents
        kubectl create configmap chatcli-agents \
          --from-file=devops-senior.md=agents/devops-senior.md \
          --from-file=go-expert.md=agents/go-expert.md \
          -n tools

        # Referenciar no Helm
        helm install chatcli oci://ghcr.io/diillson/charts/chatcli \
          --set agents.enabled=true \
          --set agents.existingConfigMap=chatcli-agents
        ```
      </Tab>

      <Tab title="Via Skill Registry">
        Além de provisionar skills via ConfigMaps, você pode habilitar o **Skill Registry** para buscar e instalar skills de registries remotos diretamente no servidor:

        ```bash theme={"system"}
        helm install chatcli oci://ghcr.io/diillson/charts/chatcli \
          --set skillRegistry.enabled=true \
          --set skillRegistry.registryUrls="https://skills.mycompany.com/api/v1"
        ```

        Depois de conectar ao servidor, use os comandos `/skill` para gerenciar skills:

        ```bash theme={"system"}
        /skill search kubernetes     # Busca em todos os registries
        /skill install k8s-ops       # Instala no servidor
        /agent skills                # Verifica que a skill está disponível
        ```
      </Tab>
    </Tabs>

    Quando os devs conectam, eles veem automaticamente os recursos do servidor:

    ```text theme={"system"}
    Connected to ChatCLI server (version: 1.3.0, provider: CLAUDEAI, model: claude-sonnet-4-6)
     Server has 2 plugins, 2 agents, 3 skills available
    ```
  </Step>
</Steps>

***

## Dicas de Operação

<AccordionGroup>
  <Accordion title="Logs do Servidor">
    ```bash theme={"system"}
    # Docker
    docker logs chatcli-server -f

    # Kubernetes
    kubectl logs -f deployment/chatcli -n tools
    ```
  </Accordion>

  <Accordion title="Health Check">
    ```bash theme={"system"}
    # O Dockerfile inclui health check integrado
    docker inspect chatcli-server --format='{{.State.Health.Status}}'
    ```
  </Accordion>

  <Accordion title="Monitoramento de Uso">
    Configure `LOG_LEVEL=info` no servidor para registrar cada request com provider e modelo utilizado.
  </Accordion>

  <Accordion title="Backup de Sessões">
    ```bash theme={"system"}
    # Docker: volumes persistentes
    docker cp chatcli-server:/home/chatcli/.chatcli/sessions ./backup/

    # Kubernetes: PVC já configurado no Helm chart
    ```
  </Accordion>

  <Accordion title="Sessões Remotas">
    Quando conectado a um servidor, os comandos `/session` interagem com **ambos** local e remoto:

    * **`/session save`** pergunta onde salvar: local, remoto ou ambos
    * **`/session list`** exibe sessões de ambos em seções separadas
    * **`/session load`** busca em ambos; se encontrada nos dois, pergunta de qual carregar
    * **`/session delete`** verifica ambos; se encontrada nos dois, pergunta de qual remover

    Isso permite que devs salvem sessões no servidor para compartilhar com a equipe, ou localmente para uso offline.
  </Accordion>
</AccordionGroup>

***

## Resumo

| Componente    | Configuração                                                                        |
| ------------- | ----------------------------------------------------------------------------------- |
| Servidor      | `chatcli server --token X`                                                          |
| Cliente       | `chatcli connect --token X`                                                         |
| Env Vars      | `CHATCLI_REMOTE_ADDR`, `CHATCLI_REMOTE_TOKEN`                                       |
| TLS           | `--tls-cert`, `--tls-key` (servidor) / `--tls` (cliente)                            |
| Credenciais   | Servidor (padrão) ou cliente (`--llm-key` / `--use-local-auth`)                     |
| Agents/Skills | `agents.enabled=true` + ConfigMap (Helm) ou `agents.configMapRef` (Operator)        |
| Plugins       | `plugins.enabled=true` + init container ou PVC (Helm) ou `plugins.image` (Operator) |