Desvendando o Ollama: Construindo um Playground com Ollama e Open WebUI com Llama3 & Llava
Introdução
Neste artigo, vamos construir um playground com Ollama e o Open WebUI para explorarmos diversos modelos LLMs como Llama3 e Llava. Você descobrirá como essas ferramentas oferecem um ambiente intuitivo para utilizar e aprimorar LLMs de última geração de maneira local em sua máquina.
LLM (Large Language Model)
Antes de mergulharmos no playground, é importante reiterar o conceito de LLM, uma sigla que será frequentemente mencionada ao longo deste artigo.
LLM (Large Language Model) é um tipo de inteligência artificial projetada para entender e gerar linguagem humana em grande escala. Esses modelos são treinados em enormes conjuntos de texto para aprender padrões de linguagem e contextos complexos.
Eles podem realizar uma variedade de tarefas relacionadas à linguagem, como tradução, geração de texto, resposta a perguntas e muito mais. LLMs como o GPT (Generative Pre-trained Transformer) são exemplos populares que têm sido usados em várias aplicações, desde assistentes virtuais até análise de texto em larga escala. Em resumo, uma LLM é uma ferramenta poderosa para lidar com tarefas que envolvem compreensão e geração de texto em larga escala.
Preparando o Ambiente
Antes de iniciarmos a configuração e instalação do nosso playground com Ollama e Open WebUI, é crucial garantir que tenhamos todas as ferramentas necessárias instaladas corretamente em nosso ambiente.
Seguem abaixo os pré-requisitos necessários para a configuração do playground no ambiente local.
Software:
- Docker: Utilizaremos para a execução local do Open WebUI.
Hardware:
- 16 Gb de Memória RAM: Memória mínima recomendada para a execução local das ferramentas e LLMs.
- 10 Gb de Espaço em Disco: Espaço estimado para a instalação das ferramentas e LLMs.
Ollama
O Ollama (Open-source Large Language Model Accelerator) é um framework open-source desenvolvido com o objetivo de facilitar e simplificar a execução de LLMs por indivíduos e organizações. Para facilitar o entendimento, podemos interpretar o Ollama como uma ferramenta equivalente ao Docker, mas com foco em facilitar a customização e execução de LLMs.
Para realizarmos a instalação do Ollama, podemos acessar diretamente a aba de Download no site oficial do Ollama e realizarmos a instalação do seu respectivo sistema operacional.
Com a instalação realizada com sucesso, podemos verificar via terminal a versão instalada:
$ ollama -v
ollama version is 0.1.30Com o Ollama em mãos, vamos realizar a primeira execução local de um LLM, para isso iremos utilizar o llama3 da Meta, presente na biblioteca de LLMs do Ollama.
É importante nos atentarmos as versões disponíveis do llama3, quanto maior o tamanho da LLM, maior será o espaço livre e memória RAM necessária para a execução da LLM.
Para nosso teste iremos realizar a execução do modelo 8b, sendo ele o mais leve, que atualmente também é o latest. Para isso, podemos executar o seguinte comando:
$ ollama run llama3:8b
pulling manifest
pulling 00e1317cbf74... 100% ▕████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 4.7 GB
pulling 4fa551d4f938... 100% ▕████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 12 KB
pulling 8ab4849b038c... 100% ▕████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 254 B
pulling 577073ffcc6c... 100% ▕████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 110 B
pulling ad1518640c43... 100% ▕████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 483 B
verifying sha256 digest
writing manifest
removing any unused layers
success
>>> Send a message (/? for help)Com isso, temos nosso LLM llama3 em execução, a partir desse momento podemos testa-lo com alguma pergunta:
>>> Why is the sky blue?
The color of the sky is a fascinating topic. The short answer is that the sky appears blue because of the way that light scatters when it enters Earth's atmosphere.
Here's what happens:
1. **Solar radiation**: When sunlight from the sun hits our atmosphere, it contains all the colors of the visible spectrum (red, orange, yellow, green, blue, indigo, and violet).
2. **Scattering**: As this light travels through the atmosphere, it encounters tiny molecules of gases like nitrogen (N2) and oxygen (O2). These molecules scatter the shorter, blue wavelengths more than the longer, red wavelengths.
3. **Rayleigh scattering**: The scattering effect is most pronounced for blue light because it's scattered by the smaller molecules in the atmosphere, a phenomenon known as Rayleigh scattering. This scattering is more efficient at shorter wavelengths, like blue and
violet.
4. **Atmospheric conditions**: Other factors can influence the color of the sky, such as:
* Dust, pollution, and water vapor: These particles can scatter light in different ways, making the sky appear hazy or gray.
* Atmospheric pressure and temperature: Changes in these conditions can affect the scattering patterns, leading to variations in the apparent blue-ness of the sky.
So, when you combine all these factors, the blue color we see in the sky is a result of the selective scattering of shorter wavelengths (like blue light) by the tiny molecules in our atmosphere. That's why the sky typically appears blue during the daytime!
(Note: During sunrise and sunset, the longer wavelengths like red and orange can dominate due to different scattering patterns, making the sky appear more orange or reddish.)
>>> Send a message (/? for help)O Ollama também possibilita que realizemos chamadas via HTTP aos modelos em execução, podemos testar da seguinte maneira via cURL:
$ curl -X POST http://localhost:11434/api/generate -d '{
"model": "llama3:8b",
"promp"
}'
{"model":"llama3:8b","created_at":"2024-04-28T21:09:05.748986Z","response":"What","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:05.957747Z","response":" a","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:06.179344Z","response":" great","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:06.392793Z","response":" question","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:06.603498Z","response":"!\n\n","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:06.81421Z","response":"The","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:07.016849Z","response":" sky","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:07.246232Z","response":" appears","done":false}
{"model":"llama3:8b","created_at":"2024-04-28T21:09:07.470821Z","response":" blue","done":false}
...Onde podemos perceber uma formatação inesperada de retorno HTTP, para facilitar a interação com os modelos a partir de uma interface semelhante ao ChatGPT, iremos explorar o Open WebUI.
Open WebUI
O Open WebUI é uma WebUI extensível, self-hosted, rica em recursos e intuitiva com compatibilidade de múltiplos executores de LLM como o Ollama e as APIs da OpenAI.
Para executarmos localmente nossa Open WebUI e integrarmos com o Ollama, iremos utilizar o Docker, seguindo a documentação para execução com Docker. Como estamos executando o Ollama localmente e desejamos integrar com o mesmo, podemos executar o seguinte comando:
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:mainFeito isso, podemos acessar localmente a interface no endereço: http://localhost:3000/.
Onde podemos criar uma rápida e simples no Open WebUI com nome, e-mail e senha para acessarmos:
Assim acessarmos a interface principal, muito semelhante a interface do ChatGPT. Para selecionarmos o LLM que estamos executando via Ollama, podemos selecionar em "Select a Model > llama3:8b" no canto superior da interface:
Feito isso, podemos testar nossa LLM como anteriormente:
Para seguirmos testando outras LLMs e customizações, podemos remover o modelo em execução por limitações de Hardware. Para isso, podemos realizar tanto via interface no botão de engrenagem no canto superior direito em "Settings > Models > Delete a model > llama3:b":
Quanto também podemos realizar a deleção do modelo via CLI:
$ ollama list
NAME ID SIZE MODIFIED
llama3:8b a6990ed6be41 4.7 GB 23 minutes ago
$ ollama rm llama3:8b
deleted 'llama3:8b'
$ ollama list
NAME ID SIZE MODIFIEDCustomizando nosso primeiro LLM
Para customizarmos nosso primeiro LLM, iremos utilizar o Modelfile, que na nossa analogia anterior podemos entender como o nosso conhecido Dockerfile. Para isso, podemos realizar a customização tanto via interface UI, quanto via CLI.
No Open WebUI, podemos acessar no menu lateral esquerdo a aba "Modelfiles" e selecionar a opção "Create a modelfile". Onde vale ressaltar a possibilidade de explorar Modelfiles da comunidade.
Na criação de um novo Modelfile, vamos customizar um LLM a partir do llama3, presente na biblioteca do Ollama, mas com o objetivo de criar um assistente simples que responde apenas com Sim ou Não, iremos chama-lo de "".
Para isso, podemos definir o nosso Modelfile da seguinte forma:
FROM llama3:8b
SYSTEM """
You must answer all the questions with only yes or no, acting as an assistant
"""Para criarmos a customização via WebUI, podemos preencher da seguinte forma:
Caso deseje criar via CLI do Ollama, criar o arquivo localmente e executar o seguinte comando:
ollama create llama3-yes-or-no-assistant -f ./ModelfileFeito isso, aguardamos a criação do modelo e podemos criar um novo Chat, selecionar nosso novo modelo e testa-lo:
Onde validamos com sucesso o funcionamento do mesmo, se tratando de um assistente simples com um objetivo claro, mas a partir desse tipo de customização podemos usar a criatividade para testar e resolver problemas com LLMs customizadas.
Para aprofundar nas customizações e estudos sobre Modelfiles, recomendo a leitura do README presente no repositório do Ollama no GitHub:
Nele são apresentadas as instruções disponíveis, como o "TEMPLATE" utilizado para informar o prompt que desejamos informar ao modelo llama3 que informamos via instrução "FROM".
Outra instrução importante é o "PARAMETER" que permite configurarmos parâmetros do modelo como a "temperature", que quão maior seja o valor definido, mais criativo será o modelo (valores entre 0 a 1, o padrão é 0.8), exemplo:
FROM llama3:8b
PARAMETER temperature 1
SYSTEM """
You must answer all the questions with only yes or no, acting as an assistant
"""Confira outros parâmetros disponíveis para customização:
Executando LLM para analise de Imagens
Vamos agora explorar o llava, que é um modelo multimodal que combina um codificador de visão, Vicuna para compreensão visual e linguística de uso geral, dessa forma, podemos realizar a analise de imagens.
Para executarmos é simples, podemos realizar a execução via CLI:
ollama run llavaFeito isso, podemos criar um novo Chat e selecionarmos o modelo llava. Com ele podemos selecionar alguma imagem, no caso fiz o download de uma imagem de gatinhos na grama e pedi para que o llava analisasse a fim de identificar cachorros na imagem.
Sendo então mais um LLM poderoso para explorarmos a fim de customizarmos com objetivos específicos.
Para realizarmos a deleção do modelo, podemos executar o seguinte comando:
ollama rm llavaGerenciando Prompts
A fim de gerenciar os nossos prompts, o Open WebUI disponibiliza no menu lateral esquerdo a aba "Prompt". Nela é possivel realizar a criação de Prompts além de explorar prompts disponíveis pela comunidade.
Para criarmos nosso próprio prompt é simples, basta selecionarmos o botão adicionar no canto superior direito do menu:
E definirmos o título, comando e prompt em si, e ao final salvarmos.
Feito isso, podemos criar um novo chat e utilizarmos o comando informado para executarmos o prompt, nesse caso o comando "/sky-blue":
Possibilitando o gerenciamento e versionamento de prompts grandes e complexos com facilidade.
Conclusão
O Ollama é uma ferramenta essencial, que veio com o objetivo de simplificar e facilitar a execução de LLMs. Escrevi esse artigo com o objetivo de ser um guia de primeiro contato com a ferramenta, mas a partir dessa introdução temos um mar de possibilidades e funcionalidades para customizarmos nossas próprias LLMs, além da ferramenta estar em continuo desenvolvimento pela comunidade.
A integração do Ollama com o Open WebUI é poderosíssima, além do Chat com uma interface amigável, permite o gerenciamento de Prompts e customizar Modelfiles pela WebUI, além da integração com outros executores de LLM como a OpenAI, de forma local.
Outro ponto forte do Ollama é a possibilidade de executar o mesmo em clusters Kubernetes, inclusive por meio do Helm. Permitindo dessa forma escalabilidade necessária quando pensamos na produtização LLMs.
Por fim, o Ollama permite a execução de LLMs presentes no HuggingFace em formato GGUF ou PyTorch & Safetensors, que devo explorar em um próximo artigo em breve. 😉
São apenas algumas das diversas funcionalidades que explorei até aqui, como mencionei anteriormente, se trata de um mar de possibilidades que ainda podemos explorar com essas ferramentas, espero que tenham gostado desse conteúdo.
Obrigado pela sua atenção! E até breve 😄
