Ollama: Exercícios Abrangentes da Fase 1

Q: P: O que devo fazer se o script de ponta a ponta falha em algum passo?

R: Verifique cada passo individualmente. Primeiro ollama --version, depois curl localhost:11434/api/tags, solucionando camada por camada. 90% dos problemas são serviço não iniciado ou Modelo não baixado.

Exercícios abrangentes da Fase 1 são o ponto de verificação prática que testa seu aprendizado das primeiras 5 aulas — da configuração zero às chamadas de API, tudo de uma vez.

💡 Dica: Esta aula prática está intimamente ligada às primeiras 5 aulas. Recomendamos completá-las em ordem: domine instalação e configuração (Aula 2), básicos do CLI (Aula 3), gerenciamento de Modelos (Aula 4), API REST (Aula 5), então retorne para os exercícios abrangentes. Não pule etapas — você pode encontrar conceitos e comandos desconhecidos.

📋 Pré-requisitos: Você precisa dominar o seguinte primeiro

Aula 1: Conceitos de IA Local e Visão Geral do Ambiente

Aula 2: Instalação e Configuração de Ambiente do Ollama

Aula 3: Interação Básica via CLI

Aula 4: Gerenciamento de Modelos

Aula 5: Fundamentos da API REST

1. O Que Você Vai Aprender

Prática hands-on do fluxo completo de Implantação de ponta a ponta
Teste em lote via script Shell da qualidade de resposta de Modelos
Construção de um chatbot simples com curl
Método de verificação de viabilidade de PoC local da Alice
Autoavaliação e direção de preparação para a Fase 2

2. Uma História Real de Uma CTO de Startup

ℹ️ Info: O objetivo de um PoC (Proof of Concept) é "verificar viabilidade" em vez de "execução perfeita." Provar que o pipeline central funciona com a velocidade mais rápida conquista confiança da equipe e orçamento subsequente. Não se fixe na precisão do Modelo ou qualidade do código durante a fase de PoC.

⚠️ Aviso: Ao fazer verificação PoC de ponta a ponta, certifique-se de verificar o efeito "cold start" na latência da API — a primeira requisição precisa carregar o Modelo (5-30 segundos), e apenas requisições subsequentes refletem a verdadeira latência de Inferência. Envie uma requisição de aquecimento primeiro, depois comece a cronometrar.

(1) O Problema: Só Teoria Não Convençe a Equipe

Alice completou as primeiras 5 aulas, mas a equipe ainda tinha dúvidas sobre IA local: "Funciona mesmo? A qualidade é boa o suficiente?" Ela precisa de um PoC de ponta a ponta para provar que IA local é viável antes de conseguir orçamento para servidores GPU.

(2) A Solução: PoC de Ponta a Ponta em 30 Minutos

Da instalação ao protótipo de atendimento interativo, Alice completou a verificação completa do pipeline em 30 minutos:

BASH

# Step 1: Install
curl -fsSL https://ollama.com/install.sh | sh

# Step 2: Pull model
ollama pull qwen2.5

# Step 3: API test
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5",
  "messages": [{"role": "user", "content": "Hello"}],
  "stream": false
}'

3. Exercício 1: Fluxo Completo de Ponta a Ponta

ℹ️ Nota: O objetivo central da verificação de ponta a ponta é "provar que o pipeline funciona" — da instalação às chamadas de API, cada passo é bem-sucedido. Não busque qualidade de saída do Modelo nesta etapa; isso é para otimização posterior. Comece com o menor Modelo (3B) para verificação rápida — é muito mais eficiente que depurar com um Modelo grande.

💡 Dica: A chave de um PoC de ponta a ponta é "verificar viabilidade rapidamente", não perfeição. Use o menor Modelo (3B) primeiro para verificar que o pipeline funciona, depois troque para o Modelo alvo para testes de qualidade. Isso é muito mais eficiente que baixar um Modelo grande de imediato.

(1) Do Zero à Chamada de API

Complete os seguintes passos em ordem, verificando cada passo antes de prosseguir:

flowchart LR
    A[Instalar Ollama] --> B[Verificar Serviço]
    B --> C[Baixar Modelo]
    C --> D[Teste CLI]
    D --> E[Teste REST API]
    E --> F[Integração Script]

Passo	Ação	Comando de Verificação
1	Instalar Ollama	`ollama --version`
2	Confirmar serviço rodando	`curl http://localhost:11434/api/tags`
3	Baixar qwen2.5	`ollama pull qwen2.5`
4	Teste de interação CLI	`ollama run qwen2.5 "Hello"`
5	Teste REST API	chamada curl a /api/chat
6	Teste de integração script	Chamada em lote via script Shell

▶ Exemplo 1: Script de Verificação de Ponta a Ponta

BASH

#!/bin/bash
# End-to-end verification script
set -e

echo "=== Step 1: Verify Installation ==="
ollama --version

echo "=== Step 2: Verify Service ==="
curl -s http://localhost:11434/api/tags | python3 -m json.tool > /dev/null
echo "Service is running."

echo "=== Step 3: Pull Model ==="
ollama pull qwen2.5

echo "=== Step 4: CLI Test ==="
ollama run qwen2.5 "Say hello in one sentence"

echo "=== Step 5: REST API Test ==="
curl -s http://localhost:11434/api/chat -d '{
  "model": "qwen2.5",
  "messages": [{"role": "user", "content": "Hello"}],
  "stream": false
}' | python3 -c "import sys,json; print('API works:', json.load(sys.stdin)['message']['content'][:50])"

echo "=== All Steps Passed ==="

Saída：

TEXT

I'm a helpful AI assistant running locally on your machine...

4. Exercício 2: Teste em Lote da Qualidade de Resposta dos Modelos

(1) Comparando Saída entre Modelos com Diferentes Contagens de Parâmetros

Use o mesmo conjunto de perguntas para testar diferentes Modelos, avaliando velocidade e qualidade:

Dimensão de Teste	Modelo 3B	Modelo 8B	Modelo Embedding
Velocidade de resposta	Rápida (30+ tok/s)	Média (15-20 tok/s)	Rápida (apenas vetores)
Qualidade em chinês	Basicamente usável	Fluente e natural	Não aplicável
Capacidade de raciocínio	Tarefas simples	Complexidade moderada	Não aplicável
Uso de recursos	4GB RAM	8GB RAM	300MB RAM

▶ Exemplo 2: Comparação de Qualidade de Modelos em Lote

BASH

#!/bin/bash
# Batch test different models with the same questions

QUESTIONS=(
    "What is the return policy for electronics?"
    "Translate to French: Free shipping on orders over $50"
    "Write a SQL query to find top 10 customers by revenue"
)

MODELS=("llama3.2:3b" "llama3.1:8b" "qwen2.5:7b")

for model in "${MODELS[@]}"; do
    echo "=== Model: $model ==="
    for q in "${QUESTIONS[@]}"; do
        echo "Q: $q"
        start=$(date +%s%N)
        response=$(curl -s http://localhost:11434/api/chat -d "{
            \"model\": \"$model\",
            \"messages\": [{\"role\": \"user\", \"content\": \"$q\"}],
            \"stream\": false,
            \"options\": {\"temperature\": 0.3}
        }" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['message']['content'][:100])")
        end=$(date +%s%N)
        elapsed=$(( (end - start) / 1000000 ))
        echo "A: ${response}..."
        echo "Time: ${elapsed}ms"
        echo ""
    done
done

Saída：

TEXT

{"status":"ok","data":{}}

5. Exercício 3: Script de Chatbot com curl

(1) Design de Script de Chat Interativo

Implemente um chatbot simples usando um script Shell, mantendo manualmente o histórico de conversa:

flowchart TD
    A[Iniciar Sessão] --> B[Ler Entrada do Usuário]
    B --> C{Entrada == /quit?}
    C -->|Sim| D[Sair]
    C -->|Não| E[Adicionar ao Array Messages]
    E --> F[Chamar /api/chat]
    F --> G[Imprimir Resposta]
    G --> H[Adicionar Resposta a Messages]
    H --> B

▶ Exemplo 3: Chatbot Interativo

BASH

#!/bin/bash
# Simple interactive chatbot using curl

API="http://localhost:11434/api/chat"
MODEL="qwen2.5"
MESSAGES='[{"role":"system","content":"You are a helpful assistant. Be concise."}]'

echo "ChatBot (type /quit to exit)"
echo "--------------------------------"

while true; do
    read -p "You: " input
    if [ "$input" = "/quit" ]; then
        echo "Goodbye!"
        break
    fi

    # Append user message
    MESSAGES=$(echo "$MESSAGES" | python3 -c "
import sys, json
msgs = json.load(sys.stdin)
msgs.append({'role': 'user', 'content': '$input'})
print(json.dumps(msgs))
")

    # Call API
    response=$(curl -s "$API" -d "{
        \"model\": \"$MODEL\",
        \"messages\": $MESSAGES,
        \"stream\": false,
        \"options\": {\"temperature\": 0.5}
    }")

    # Extract and print response
    content=$(echo "$response" | python3 -c "import sys,json; print(json.load(sys.stdin)['message']['content'])")
    echo "Bot: $content"

    # Append assistant response
    MESSAGES=$(echo "$MESSAGES" | python3 -c "
import sys, json
msgs = json.load(sys.stdin)
msgs.append({'role': 'assistant', 'content': '''$content'''})
print(json.dumps(msgs))
")
    echo ""
done

Saída：

TEXT

{"status":"ok","data":{}}

6. Verificação de Viabilidade do PoC Local da Alice

(1) Dimensões de Avaliação do PoC

Dimensão	Item de Verificação	Alvo
Funcionalidade	Pode responder corretamente a perguntas comuns	Precisão > 80%
Latência	Tempo de resposta do primeiro token	< 500ms
Vazão	Requisições processadas por minuto	> 10 req/min
Custo	Investimento em hardware vs economia na nuvem	Retorno em até 6 meses
Privacidade	Os dados saem do local	0 vazamento

▶ Exemplo 4: Script de Benchmark de Desempenho do PoC

BASH

#!/bin/bash
# Quick PoC benchmark for local AI

API="http://localhost:11434/api/chat"
MODEL="qwen2.5"
REQUESTS=10

echo "=== Local AI PoC Benchmark ==="
echo "Model: $MODEL"
echo "Requests: $REQUESTS"
echo ""

total_time=0
total_tokens=0

for i in $(seq 1 $REQUESTS); do
    start=$(date +%s%N)
    response=$(curl -s "$API" -d "{
        \"model\": \"$MODEL\",
        \"messages\": [{\"role\": \"user\", \"content\": \"Explain the return policy briefly\"}],
        \"stream\": false,
        \"options\": {\"temperature\": 0.3}
    }")
    end=$(date +%s%N)

    elapsed_ms=$(( (end - start) / 1000000 ))
    tokens=$(echo "$response" | python3 -c "import sys,json; print(json.load(sys.stdin).get('eval_count', 0))")

    total_time=$((total_time + elapsed_ms))
    total_tokens=$((total_tokens + tokens))
    echo "Request $i: ${elapsed_ms}ms, ${tokens} tokens"
done

avg_time=$((total_time / REQUESTS))
avg_tokens=$((total_tokens / REQUESTS))
tput=$((total_tokens * 1000 / total_time))

echo ""
echo "=== Results ==="
echo "Avg latency: ${avg_time}ms"
echo "Avg tokens:  ${avg_tokens}"
echo "Throughput:  ${tput} tokens/s"
echo "Target met:  $([ $avg_time -lt 5000 ] && echo 'YES' || echo 'NO')"

Saída：

TEXT

{"status":"ok","data":{}}

▶ Exemplo 5: Verificação do Checklist de Autoavaliação

BASH

#!/bin/bash
# Phase 1 self-assessment checklist

echo "=== Phase 1 Self-Assessment ==="
echo ""

checks=0
total=6

# Check 1: Ollama installed
if command -v ollama &> /dev/null; then
    echo "[PASS] Ollama is installed"
    ((checks++))
else
    echo "[FAIL] Ollama is not installed"
fi

# Check 2: Service running
if curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then
    echo "[PASS] Ollama service is running"
    ((checks++))
else
    echo "[FAIL] Ollama service is not running"
fi

# Check 3: At least one model available
model_count=$(ollama list 2>/dev/null | tail -n +2 | wc -l)
if [ "$model_count" -gt 0 ]; then
    echo "[PASS] $model_count model(s) available"
    ((checks++))
else
    echo "[FAIL] No models pulled"
fi

# Check 4: CLI interaction works
if ollama run llama3.2 "test" > /dev/null 2>&1; then
    echo "[PASS] CLI interaction works"
    ((checks++))
else
    echo "[FAIL] CLI interaction failed"
fi

# Check 5: REST API responds
if curl -s http://localhost:11434/api/generate -d '{"model":"llama3.2","prompt":"hi","stream":false}' > /dev/null 2>&1; then
    echo "[PASS] REST API responds"
    ((checks++))
else
    echo "[FAIL] REST API not responding"
fi

# Check 6: Streaming works
if curl -s http://localhost:11434/api/chat -d '{"model":"llama3.2","messages":[{"role":"user","content":"hi"}]}' | grep -q '"done":true'; then
    echo "[PASS] Streaming API works"
    ((checks++))
else
    echo "[FAIL] Streaming API failed"
fi

echo ""
echo "Score: $checks / $total"
if [ "$checks" -eq "$total" ]; then
    echo "✅ Ready for Phase 2!"
else
    echo "⚠️ Review failed items before proceeding."
fi

Saída：

TEXT

I'm a helpful AI assistant running locally on your machine...

7. Exemplo Abrangente: Fluxo de Verificação de Ponta a Ponta Completo

BASH

#!/bin/bash
# ============================================
# Comprehensive: Full Phase 1 E2E workflow
# Install → Configure → Pull → Test → Report
# ============================================

set -e
REPORT="phase1_report_$(date +%Y%m%d_%H%M%S).txt"

echo "Phase 1 E2E Workflow" | tee "$REPORT"
echo "====================" | tee -a "$REPORT"
echo "" | tee -a "$REPORT"

# Step 1: Install verification
echo "## Installation" | tee -a "$REPORT"
echo "Ollama: $(ollama --version 2>&1)" | tee -a "$REPORT"
echo "OS: $(uname -s) $(uname -m)" | tee -a "$REPORT"
echo "RAM: $(free -g | awk '/^Mem:/{print $2}')GB" | tee -a "$REPORT"
if command -v nvidia-smi &> /dev/null; then
    echo "GPU: $(nvidia-smi --query-gpu=name --format=csv,noheader)" | tee -a "$REPORT"
else
    echo "GPU: CPU-only mode" | tee -a "$REPORT"
fi
echo "" | tee -a "$REPORT"

# Step 2: Pull SupportBot model stack
echo "## Model Stack" | tee -a "$REPORT"
ollama pull qwen2.5 2>&1 | tail -1 | tee -a "$REPORT"
ollama pull llama3.2:3b 2>&1 | tail -1 | tee -a "$REPORT"
ollama pull nomic-embed-text 2>&1 | tail -1 | tee -a "$REPORT"
echo "" | tee -a "$REPORT"

# Step 3: Quality test with 3 questions
echo "## Quality Test" | tee -a "$REPORT"
questions=(
    "What is your return policy?"
    "How do I track my order?"
    "Do you ship internationally?"
)
for q in "${questions[@]}"; do
    echo "Q: $q" | tee -a "$REPORT"
    answer=$(curl -s http://localhost:11434/api/chat -d "{
        \"model\": \"qwen2.5\",
        \"messages\": [{\"role\": \"system\", \"content\": \"You are an e-commerce support agent. Be concise.\"},
                       {\"role\": \"user\", \"content\": \"$q\"}],
        \"stream\": false,
        \"options\": {\"temperature\": 0.3}
    }" | python3 -c "import sys,json; print(json.load(sys.stdin)['message']['content'][:120])")
    echo "A: $answer" | tee -a "$REPORT"
    echo "" | tee -a "$REPORT"
done

# Step 4: Performance benchmark
echo "## Benchmark" | tee -a "$REPORT"
start=$(date +%s%N)
curl -s http://localhost:11434/api/chat -d '{
    "model": "qwen2.5",
    "messages": [{"role": "user", "content": "Hello"}],
    "stream": false
}' > /dev/null
end=$(date +%s%N)
latency=$(( (end - start) / 1000000 ))
echo "Single request latency: ${latency}ms" | tee -a "$REPORT"
echo "Target < 5000ms: $([ $latency -lt 5000 ] && echo PASS || echo FAIL)" | tee -a "$REPORT"
echo "" | tee -a "$REPORT"

echo "Report saved: $REPORT"

❓ Perguntas Frequentes

P: O que devo fazer se o script de ponta a ponta falha em algum passo? R: Verifique cada passo individualmente. Primeiro ollama --version, depois curl localhost:11434/api/tags, solucionando camada por camada. 90% dos problemas são serviço não iniciado ou Modelo não baixado.

P: O carregamento do Modelo é lento durante testes em lote, o que posso fazer? R: A primeira chamada precisa carregar o Modelo na memória (cold start). Defina OLLAMA_KEEP_ALIVE=30m para manter o Modelo na memória, e requisições subsequentes respondem em segundos.

P: E se o histórico de conversa do script do chatbot ficar muito longo? R: Um array messages crescente consome a janela de contexto. Recomendamos implementar uma janela deslizante — mantendo apenas as últimas 10 rodadas e descartando as anteriores. Ou periodicamente resumir e comprimir.

P: Resultados do benchmark PoC são inconsistentes, o que devo fazer? R: A primeira requisição inclui o tempo de carregamento do Modelo (viés de cold start). Recomendamos descartar as primeiras 2 requisições e tirar a média das próximas 10. Garanta que não há outra carga durante os testes.

P: Que conhecimento prévio é necessário para a Fase 2? R: Básicos de Python (funções, classes, async/await), experiência com chamadas de API HTTP, conceitos básicos de Docker. A Aula 7 começa o SDK Python; recomendamos se familiarizar com Python antes.

P: Como sei se estou pronto para a Fase 2? R: Complete o checklist de autoavaliação 6/6 itens e seja capaz de construir independentemente um script de diálogo de múltiplas rodadas com curl — então você está pronto para a Fase 2.

📖 Resumo

Fluxo de ponta a ponta: Instalar → Verificar serviço → Baixar Modelo → Teste CLI → Chamada API → Integração script
Testes em lote podem comparar qualidade de resposta e velocidade entre diferentes Modelos
Um chatbot com curl é a melhor forma prática de entender a API REST
Verificação PoC foca em cinco dimensões: funcionalidade, latência, vazão, custo, privacidade
Checklist de autoavaliação garante que cada habilidade é verdadeiramente dominada
A Fase 2 cobrirá SDK Python, Modelfile, aceleração GPU e outros recursos centrais

📝 Exercícios

Básico (Dificuldade ⭐): Complete cada passo do script de verificação de ponta a ponta, garantindo que todos passem, e salve capturas de tela dos resultados.
Intermediário (Dificuldade ⭐⭐): Execute o script de comparação de qualidade de Modelos em lote, selecione 3 Modelos diferentes, registre tempos de resposta e pontuações de qualidade, e escreva um breve relatório de análise.
Avançado (Dificuldade ⭐⭐⭐): Complete uma verificação PoC completa para a empresa SaaS da Alice — escreva scripts de benchmark, registre dados de latência e vazão, calcule comparações de custo em 12 meses e produza um documento de relatório de viabilidade.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós