Start Início rápido

Patrocinado porUrdidura

O terminal inteligente para desenvolvedores

Nota importante sobre as funções e privacidade do usuário:

Criação do administrador:A primeira conta criada nos ganhos abertos da webuiPrivilégios de administrador, controlando o gerenciamento de usuários e as configurações do sistema.
Registros de usuário:As inscrições subsequentes começam comPendentestatus, exigindo a aprovação do administrador para acesso.
Privacidade e segurança de dados: Todos os seus dados, incluindo detalhes de login, éarmazenado localmenteno seu dispositivo. Nullcore garanteConfidencialidade estritaeSem solicitações externasPara privacidade e segurança aprimoradas.
- Todos os modelos são privados por padrão.Os modelos devem ser explicitamente compartilhados por meio de grupos ou serem tornados públicos. Se um modelo for atribuído a um grupo, apenas os membros desse grupo poderão vê -lo. Se um modelo for tornado público, qualquer pessoa na instância poderá vê -lo.

Escolha o seu método de instalação preferido abaixo:

Docker: Oficialmente suportado e recomendado para a maioria dos usuários
Python:Adequado para ambientes de baixo resistência ou aqueles que desejam uma configuração manual
Kubernetes:Ideal para implantações corporativas que requerem escala e orquestração

Docker
Python
Kubernetes
Terceiro

Docker
Docker compor
Podman
Podman Kube Play
Docker Swarm

Iniciar rápido com Docker 🐳

Siga estas etapas para instalar o Nullcore com o Docker.

Etapa 1: Puxe a imagem aberta da webui

Comece puxando a mais recente imagem aberta do Webui Docker do Registro de Container Github.

Docker Pull ghcr.io/open-webui/open-webui:Main

Etapa 2: execute o contêiner

Execute o contêiner com configurações padrão. Este comando inclui um mapeamento de volume para garantir o armazenamento persistente de dados.

Docker Run -d -p 3000: 8080 -V Open-Webui:/App/backend/data-Name Open-Webui Ghcr.io/open-webui/open-webui:Main

Bandeiras importantes

Mapeamento de volume (-v open-webui:/app/backend/data: Garante o armazenamento persistente de seus dados. Isso impede a perda de dados entre as reinicializações do contêiner.
Mapeamento de portas (-p 3000:8080: Exponha o webui na porta 3000 da sua máquina local.

Usando suporte da GPU

Para suporte da GPU da NVIDIA, adicione--gpus allpara odocker runcomando:

Docker Run -D -P 3000: 8080--GPUS ALL -V Open-Webui:/App/backend/Data-Name Open-Webui ghcr.io/open-webui/open-webui:cuda

Para ignorar a página de login para uma configuração de um usuário único, defina oWEBUI_AUTHVariável de ambiente paraFalse

Docker Run -d -p 3000: 8080 -e webui_auth = false -v Open -Webui:/App/backend/data -Name Open -Webui ghcr.io/open-webui/open-webui:Main

aviso

Você não pode alternar entre o modo de usuário único e o modo de contas múltiplas após essa alteração.

Configuração avançada: conectando -se a Ollama em um servidor diferente

Para conectar o Nullcore a um servidor ollama localizado em outro host, adicione oOLLAMA_BASE_URLVariável de ambiente:

Docker Run -d -p 3000: 8080 -e ollama_base_url = https: //example.com -V Open -Webui:/App/backend/data - -name Open -Webui ---restart sempre ghcr.io/open-webui/open-webui:main

Acesse o webui

Depois que o contêiner estiver em execução, acesse o Nullcore em:

http: // localhost: 3000

Para obter ajuda detalhada em cada bandeira do Docker, consulteDocumentação do Docker

Atualização

Para atualizar a instalação local do Docker para a versão mais recente, você pode usarTorre de vigiaou atualizar manualmente o contêiner.

Opção 1: Usando a Torre de Vigia

ComTorre de vigia, você pode automatizar o processo de atualização:

Docker Run--rm --volume /var/run/docker.sock:/var/run/docker.sock Contera

(Substituiropen-webuicom o nome do seu contêiner, se for diferente.)

Opção 2: Atualização manual

Pare e remova o contêiner atual:
```
Docker RM -F Open -Webui
```

Puxe a versão mais recente:

Docker Pull ghcr.io/open-webui/open-webui:Main

Inicie o contêiner novamente:

Docker Run -d -p 3000: 8080 -V Open-Webui:/App/backend/data-Name Open-Webui Ghcr.io/open-webui/open-webui:Main

Ambos os métodos atualizarão sua instância do Docker e executando a compilação mais recente.

DOCKER COMPOSE CONFIGURAÇÃO

O uso do Docker compor simplifica o gerenciamento de aplicativos do Docker multi-container.

Se você não tem o Docker instalado, confira nossoTutorial de instalação do Docker

Docker Compose requer um pacote adicional,docker-compose-v2

Aviso:Tutoriais mais antigos do Docker Compose podem fazer referência à versão 1 Sintaxe, que usa comandos comodocker-compose build. Certifique -se de usar a sintaxe da versão 2, que usa comandos comodocker compose build(Observe o espaço em vez de um hífen).

Exemplo`docker-compose.yml`

Aqui está um exemplo de arquivo de configuração para configurar o Nullcore com o Docker Compose:

serviços
  nullcore
    imagemghcr.io/openwebui/abertowebuiprincipal
    portas
       "3000: 8080"
    volumes
      abrirwebui/app/back -end/dados
volumes
abrirwebui

Iniciando os serviços

Para iniciar seus serviços, execute o seguinte comando:

Docker compõe -d

Script auxiliar

Um script auxiliar útil chamadorun-compose.shestá incluído na base de código. Esse script auxilia na escolha de quais docker compõe arquivos a serem incluídos em sua implantação, simplificando o processo de configuração.

Observação:Para o suporte da GPU da NVIDIA, você muda a imagem deghcr.io/open-webui/open-webui:mainparaghcr.io/open-webui/open-webui:cudae adicione o seguinte à sua definição de serviço nodocker-compose.ymlarquivo:

implantar
  recursos
    reservas
      dispositivos
         motoristanvidia
          contartodos
          recursos [[GPU

Essa configuração garante que seu aplicativo possa aproveitar os recursos da GPU, quando disponíveis.

Usando podman

O Podman é um mecanismo de contêiner sem daemon para desenvolver, gerenciar e executar contêineres OCI.

Comandos básicos

Execute um contêiner:

podman run -d - -name nullcore -p 3000: 8080 -V Open -webui:/app/backend/data ghcr.io/open-webui/open-webui:Main

Lista de contêineres em execução:
```
Podman PS
```

Networking com Podman

Se surgirem problemas de rede, use o SLIRP4NETNS para ajustar as configurações de rede do pod para permitir que o contêiner acesse as portas do seu computador.

Certifique -se de que você temSlirp4Netns instalado, remova o recipiente anterior se houver usandopodman rme iniciar um novo contêiner com

podman run -d - -network = slirp4Netns: allow_host_loopback = true -name nullcore -p 3000: 8080 -V Open -webui:/app/backend/data ghcr.io/open-webui/open-webui:main

Se você estiver usando o Ollama do seu computador (não executando dentro de um contêiner),

Uma vez dentro do Open-Webui, navegue para Configurações> Configurações do Admin> Conexões e crie uma nova conexão da API Ollama comhttp://10.0.2.2:[OLLAMA PORT]. Por padrão, o porto Ollama é 11434.

Consulte o podmandocumentaçãoPara configurações avançadas.

Configuração de jogo de podman kube

O Podman suporta Kubernetes Like-Syntax para implantar recursos como pods, volumes sem a sobrecarga de um cluster Kubernetes completo.Mais sobre o Kube Play

Se você não tem o podman instalado, confiraSite oficial de Podman

Exemplo`play.yaml`

Aqui está um exemplo de um arquivo de reprodução do Podman Kube para implantar:

APIVERSIONv1
tipoPod
Metadados
  nomeabrirwebui
espec
  contêineres
     nomerecipiente
      imagemghcr.io/openwebui/abertowebuiprincipal
      portas
         nomehttp
          Containerport 8080
          Hostport 3000
      Volumemounts
         MountPath/app/back -end/dados
          nomedados
  volumes
     nomedados
      PersistenteVolumeclaim
        reivindicaçãoabrirwebuiPVC
----
APIVERSIONv1
tipoPersistenteVolumeclaim
Metadados
  nomeabrirwebuiPVC
espec
  AccessModes
    ReadWriteonce
  recursos
    solicitações
      armazenar5GI

Iniciando

Para iniciar seu pod, execute o seguinte comando:

Podman Kube Play ./play.yaml

Usando suporte da GPU

Para suporte à GPU da NVIDIA, você precisa substituir a imagem do contêiner porghcr.io/open-webui/open-webui:cudae precisam especificar o dispositivo (GPU) necessário nos limites dos recursos do pod conforme seguinte:

      [[
      recursos
        limites
          nvidia.com/gpu=all 1
      [[

importante

Para ter com êxito o contêiner de webui com sucesso o (s) GPU (s), Você precisará ter a interface do dispositivo de contêiner (CDI) para a GPU que deseja acessar instalado na sua máquina podman. Você pode verificarAcesso ao contêiner de gpu de podman

Docker Swarm

Este método de instalação requer conhecimento sobre enxames do Docker, pois utiliza um arquivo de pilha para implantar 3 contêineres separados como serviços em um enxame do Docker.

Inclui recipientes isolados de Chromadb, Ollama e nullcore. Além disso, existem pré-preenchidosVariáveis de ambientePara ilustrar ainda mais a configuração.

Escolha o comando apropriado com base em sua configuração de hardware:

Antes de começar

Os diretórios para seus volumes precisam ser criados no host ou você pode especificar um local ou volume personalizado.

O exemplo atual utiliza um diretor isoladodata, que está dentro do mesmo dir que odocker-stack.yaml
- Por exemplo
```
MKDIR -P Data/Open -Webui Data/Chromadb Data/Ollama
```

Com suporte à GPU

Docker-Stack.yaml

versão '3,9'

serviços
  nullcore
    imagemghcr.io/openwebui/abertowebuiprincipal
    depende_on
        Chromadb
        Ollama
    volumes
      ./data/openwebui/app/back -end/dados
    ambiente
      Data_dir/app/back -end/dados
      Ollama_base_urlshttp// ollama11434
      Chroma_http_port 8000
      Croma_http_hostChromadb
      Chroma_tenantdefault_tenant
      Vetor_dbChroma
      Webui_nameChatbot incrível
      Cors_allow_origin  # Este é o padrão atual, precisará mudar antes de ir ao ar
      Rag_embedding_engineOllama
      Rag_embedding_modelNomicincorporartextov1.5
      Rag_embedding_model_trust_remote_code "Verdadeiro"
    portas
       alvo 8080
        publicado 8080
        modosobreposição
    implantar
      réplicas 1
      RESTART_POLICY
        doençaqualquer
        atraso5s
        max_attempts 3

  Chromadb
    nome do hostChromadb
    imagemChromadb/Chroma0.5.15
    volumes
      ./data/chromadb/Chroma/Chroma
    ambiente
      Is_persistent = true
      Allow_reset = true
      Persist_directory =/croma/croma
    portas 
       alvo 8000
        publicado 8000
        modosobreposição
    implantar
      réplicas 1
      RESTART_POLICY
        doençaqualquer
        atraso5s
        max_attempts 3
    HealthCheck 
      teste [["CMD-shell", Assim, "Curl localhost: 8000/API/V1/Heartbeat || Exit 1"
      intervalo10s
      tentativas 2
      start_period5s
      tempo esgotado10s

  Ollama
    imagemOllama/Ollamamais recente
    nome do hostOllama
    portas
       alvo 11434
        publicado 11434
        modosobreposição
    implantar
      recursos
        reservas
          genérico_resources
             discrete_resource_spec
                tipo "Nvidia-gpu"
                valor 0
      réplicas 1
      RESTART_POLICY
        doençaqualquer
        atraso5s
        max_attempts 3
    volumes
      ./data/ollama/root/.ollama

Requisitos adicionais
1. Verifique se o CUDA está ativado, siga as instruções do sistema operacional e da GPU para isso.
2. Ativar suporte à GPU do Docker, vejaNVIDIA Container Toolkit
3. Siga oGuie aqui sobre a configuração do Docker Swarm para com sua GPU
- GarantirRecurso da GPUestá ativado em/etc/nvidia-container-runtime/config.tomle ativar a publicidade de recursos da GPU, descommentando oswarm-resource = "DOCKER_RESOURCE_GPU". O daemon do Docker deve ser reiniciado após atualizar esses arquivos em cada nó.

Com suporte da CPU

Modificar o serviço ollama dentrodocker-stack.yamle remova as linhas parageneric_resources:

    Ollama
  imagemOllama/Ollamamais recente
  nome do hostOllama
  portas
     alvo 11434
      publicado 11434
      modosobreposição
  implantar
    réplicas 1
    RESTART_POLICY
      doençaqualquer
      atraso5s
      max_attempts 3
  volumes
    ./data/ollama/root/.ollama

Implante pilha do Docker

Docker Stack Implement -C Docker-Stack.yaml -d Super-Awome-AI

UV
CONDA
Venv
Desenvolvimento

Instalação com`uv`

OuvO Runtime Manager garante gerenciamento de ambiente Python sem costura para aplicativos como o Nullcore. Siga estas etapas para começar:

1. Instale`uv`

Escolha o comando de instalação apropriado para o seu sistema operacional:

MacOS/Linux

Curl -lssf https://astral.sh/uv/install.sh | sh

Windows

PowerShell -ExecutionPolicy Bypass -C "Irm https://astral.sh/uv/install.ps1 | iex"

2. Execute o Nullcore

Uma vezuvestá instalado, a execução do Nullcore é uma brisa. Use o comando abaixo, garantindo definir oDATA_DIRVariável de ambiente para evitar a perda de dados. Os caminhos de exemplo são fornecidos para cada plataforma:

MacOS/Linux

Data_dir = ~/.open-webui uvx-python 3.11 webui@mais recente

Windows(PowerShell):

$ Env: data_dir = "C: \ Open-Webui \ Data"; UVX-Python 3.11 Open-webui@mais recente saque

Atualizando com Python

Para atualizar o seu instalado localmenteOpen-Webuipacote para a versão mais recente usandopip, siga estas etapas simples:

PIP Install -u Open -Webui

O-U(ou--upgrade) A bandeira garante quepipAtualiza o pacote para a versão mais recente disponível.

É isso! SeuOpen-WebuiO pacote agora está atualizado e pronto para uso.

Instale com conda

Crie um ambiente de conda:

conda create -n aberto webui python = 3.11

Ative o ambiente:
```
O CONDA Ativa a Webui Open
```
Instale o Nullcore:
```
PIP Instale o Open-Webui
```
Inicie o servidor:
```
Aberta-webui serve
```

Atualizando com Python

Para atualizar o seu instalado localmenteOpen-Webuipacote para a versão mais recente usandopip, siga estas etapas simples:

PIP Install -u Open -Webui

O-U(ou--upgrade) A bandeira garante quepipAtualiza o pacote para a versão mais recente disponível.

É isso! SeuOpen-WebuiO pacote agora está atualizado e pronto para uso.

Usando ambientes virtuais

Criar ambientes python isolados usandovenv

Passos

Crie um ambiente virtual:
```
python3 -m venv venv
```
Ative o ambiente virtual:
- No Linux/MacOS:
```
fonte VENV/BIN/ativação
```
- No Windows:
```
venv \ scripts \ ativar
```
Instale o Nullcore:
```
PIP Instale o Open-Webui
```
Inicie o servidor:
```
Aberta-webui serve
```

Atualizando com Python

Para atualizar o seu instalado localmenteOpen-Webuipacote para a versão mais recente usandopip, siga estas etapas simples:

PIP Install -u Open -Webui

O-U(ou--upgrade) A bandeira garante quepipAtualiza o pacote para a versão mais recente disponível.

É isso! SeuOpen-WebuiO pacote agora está atualizado e pronto para uso.

Leme

Helm Setup para Kubernetes

Helm ajuda você a gerenciar aplicativos Kubernetes.

Pré -requisitos

O cluster Kubernetes está configurado.
Helm está instalado.

Passos

Adicionar repositório aberto de helm helm:

Helm repo Add Open-Webui https://open-webui.github.io/helm-charts
Helm Repo Atualização

Instale o gráfico Nullcore:

Helm Install nullcore Open-Webui/Open-Webui

Verifique a instalação:
```
Kubectl Obtenha vagens
```

aviso

Se você pretende dimensionar o webui aberto usando vários nós/pods/trabalhadores em um ambiente em cluster, precisará configurar um banco de dados de valor-chave NoSQL. Existem algunsvariáveis de ambienteIsso precisa ser definido com o mesmo valor para todas as instâncias de serviço, caso contrário, problemas de consistência, sessões com defeito e outros problemas ocorrerão!

Acesse o webui

Configure o encaminhamento de porta ou o balanceamento de carga para acessar o Webui aberto de fora do cluster.

PRÓXIMOS PASSOS

Depois de instalar, visite:

http: // localhost: 3000Para acessar o Nullcore.
ouhttp: // localhost: 8080/Ao usar uma implantação do Python.

Agora você está pronto para começar a usar o Nullcore!

Usando o Nullcore com Ollama

Se você está usando o Nullcore com Ollama, não deixe de conferir nossoComeçando com o Guia OllamaPara aprender a gerenciar suas instâncias de Ollama com o Nullcore.

Junte -se à comunidade

Precisar de ajuda? Tem perguntas? Junte -se à nossa comunidade:

Mantenha -se atualizado com os recursos mais recentes, dicas de solução de problemas e anúncios!

Iniciar rápido com Docker 🐳

Etapa 1: Puxe a imagem aberta da webui

Etapa 2: execute o contêiner

Bandeiras importantes

Usando suporte da GPU

Modo de usuário único (desativando o login)

Configuração avançada: conectando -se a Ollama em um servidor diferente

Acesse o webui

Atualização

Opção 1: Usando a Torre de Vigia

Opção 2: Atualização manual

Exemplodocker-compose.yml

Iniciando os serviços

Script auxiliar

Comandos básicos

Networking com Podman

Exemploplay.yaml

Iniciando

Usando suporte da GPU

Docker Swarm

Docker-Stack.yaml

Instalação comuv

1. Instaleuv

2. Execute o Nullcore

Passos

Configuração de desenvolvimento

Pré -requisitos

Passos

Acesse o webui

Instalação do Pinokio.com

Integrações adicionais de terceiros

PRÓXIMOS PASSOS

Usando o Nullcore com Ollama

Junte -se à comunidade

Exemplo`docker-compose.yml`

Exemplo`play.yaml`

Instalação com`uv`

1. Instale`uv`