Ollama - LLMs Locais com Agentes AI

📥 Instalação do Ollama

O Ollama é uma ferramenta que permite executar modelos de linguagem grandes (LLMs) localmente no teu computador. É ideal para privacidade, custos e para desenvolver sem depender de APIs externas.

ℹ️ Requisitos de Hardware

RAM: Mínimo 8GB (16GB+ recomendado)
GPU: NVIDIA com CUDA ou Apple Silicon (M1/M2/M3)
Espaço: 10-50GB dependendo dos modelos

Instalação

bash

# Instalar via Homebrew
brew install ollama

# Ou descarregar diretamente de:
# https://ollama.com/download/mac

# Iniciar o serviço
ollama serve

# Verificar instalação
ollama --version

powershell

# Descarregar o instalador de:
# https://ollama.com/download/windows

# Executar o instalador e seguir as instruções

# Verificar instalação no PowerShell
ollama --version

# Ollama corre como serviço no Windows

bash

# Instalar com um comando
curl -fsSL https://ollama.com/install.sh | sh

# Iniciar o serviço
ollama serve

# Verificar instalação
ollama --version

📦 Modelos Disponíveis

O Ollama suporta diversos modelos, desde modelos pequenos e rápidos até modelos grandes e poderosos.

Tabela de Modelos

                            ┌────────────────────┬──────────┬──────────┬─────────────────────────┐
│      Modelo        │ Tamanho  │   RAM    │       Melhor Para       │
├────────────────────┼──────────┼──────────┼─────────────────────────┤
│ llama3.2:1b        │  1.2 GB  │   4 GB   │ Respostas rápidas       │
│ llama3.2:3b        │  2.0 GB  │   6 GB   │ Uso geral, rápido       │
│ llama3.1:8b        │  4.7 GB  │   8 GB   │ Uso geral equilibrado  │
│ llama3.1:70b       │  40 GB   │  48 GB   │ Tarefas complexas      │
│ mistral:7b         │  4.1 GB  │   8 GB   │ Código, raciocínio     │
│ codellama:34b      │  19 GB   │  24 GB   │ Programação avançada    │
│ phi3:mini          │  2.3 GB  │   4 GB   │ Dispositivos fracos     │
│ gemma2:9b          │  5.5 GB  │  10 GB   │ Multilingual, eficiente │
│ qwen2.5:7b        │  4.7 GB  │   8 GB   │ Multilingual, código   │
└────────────────────┴──────────┴──────────┴─────────────────────────┘
                        

bash

# Descarregar um modelo
ollama pull llama3.1:8b

# Descarregar outros modelos populares
ollama pull mistral:7b
ollama pull codellama:34b
ollama pull phi3:mini

# Listar modelos instalados
ollama list

⌨️ Comandos Básicos

bash

# ========================================
# COMANDOS PRINCIPAIS DO OLLAMA
# ========================================

# Iniciar sessão interativa com um modelo
ollama run llama3.1:8b

# Fazer uma pergunta única (sem sessão interativa)
ollama run llama3.1:8b "Explica o que é machine learning"

# Listar todos os modelos instalados
ollama list

# Ver informações de um modelo específico
ollama show llama3.1:8b

# Remover um modelo
ollama rm llama3.1:8b

# Copiar um modelo (criar variante)
ollama cp llama3.1:8b meu-modelo

# Ver modelos em execução
ollama ps

# Parar um modelo em execução
ollama stop llama3.1:8b

# Atualizar um modelo
ollama pull llama3.1:8b

# Criar um modelo personalizado
ollama create meu-modelo -f Modelfile

API REST do Ollama

O Ollama expõe uma API REST local na porta 11434:

bash

# Gerar texto (POST /api/generate)
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Porquê que o céu é azul?",
  "stream": false
}'

# Chat (POST /api/chat)
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.1:8b",
  "messages": [
    {"role": "user", "content": "Olá, como estás?"}
  ]
}'

# Listar modelos (GET /api/tags)
curl http://localhost:11434/api/tags

🔗 Agentes com LangChain

O LangChain é uma framework que facilita a criação de agentes AI. Integra-se perfeitamente com o Ollama para criar agentes locais.

Instalação

bash

# Instalar dependências
pip install langchain langchain-community ollama

# Ou com pip mais recente
pip install langchain langchain-ollama

Agente Simples

python

from langchain_community.llms import Ollama
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool

# Inicializar o modelo local
llm = Ollama(model="llama3.1:8b")

# Definir ferramentas
def calculadora(expressao: str) -> str:
    """Calcula uma expressão matemática."""
    try:
        return str(eval(expressao))
    except Exception as e:
        return f"Erro: {e}"

def data_atual(query: str) -> str:
    """Retorna a data e hora atual."""
    from datetime import datetime
    return datetime.now().strftime("%d/%m/%Y %H:%M:%S")

# Criar ferramentas
ferramentas = [
    Tool(
        name="Calculadora",
        func=calculadora,
        description="Útil para cálculos matemáticos. Input: expressão matemática."
    ),
    Tool(
        name="DataHora",
        func=data_atual,
        description="Retorna a data e hora atual. Input: qualquer string."
    )
]

# Criar agente
agente = initialize_agent(
    ferramentas,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Executar o agente
resposta = agente.run("Qual é a raiz quadrada de 144? E que horas são?")
print(resposta)

Agente com Memória

python

from langchain_community.llms import Ollama
from langchain.memory import ConversationBufferMemory
from langchain.agents import initialize_agent, AgentType

# Inicializar modelo
llm = Ollama(model="llama3.1:8b")

# Criar memória
memoria = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# Criar agente com memória
agente = initialize_agent(
    tools=ferramentas,
    llm=llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memoria,
    verbose=True
)

# Agora o agente lembra-se da conversa
agente.run("O meu nome é João.")
agente.run("Qual é o meu nome?")  # O agente responderá "João"

🛠️ Tool Calling Nativo

O Ollama suporta tool calling nativo em modelos como Llama 3.1, permitindo que o modelo solicite a execução de ferramentas de forma estruturada.

python

import ollama

# Definir ferramentas disponíveis
ferramentas = [
    {
        "type": "function",
        "function": {
            "name": "obter_tempo",
            "description": "Obter o tempo atual para uma cidade",
            "parameters": {
                "type": "object",
                "properties": {
                    "cidade": {
                        "type": "string",
                        "description": "Nome da cidade"
                    }
                },
                "required": ["cidade"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calcular",
            "description": "Realizar cálculos matemáticos",
            "parameters": {
                "type": "object",
                "properties": {
                    "expressao": {
                        "type": "string",
                        "description": "Expressão matemática"
                    }
                },
                "required": ["expressao"]
            }
        }
    }
]

# Fazer pedido ao modelo
resposta = ollama.chat(
    model='llama3.1:8b',
    messages=[{'role': 'user', 'content': 'Qual é o tempo em Lisboa?'}],
    tools=ferramentas,
)

# Verificar se o modelo quer chamar uma ferramenta
if resposta.get('message', {}).get('tool_calls'):
    for tool_call in resposta['message']['tool_calls']:
        funcao = tool_call['function']['name']
        argumentos = tool_call['function']['arguments']

        print(f"O modelo quer chamar: {funcao}")
        print(f"Com argumentos: {argumentos}")

        # Executar a ferramenta
        if funcao == "obter_tempo":
            resultado = obter_tempo(argumentos['cidade'])
        elif funcao == "calcular":
            resultado = calcular(argumentos['expressao'])

        # Devolver resultado ao modelo
        resposta_final = ollama.chat(
            model='llama3.1:8b',
            messages=[
                {'role': 'user', 'content': 'Qual é o tempo em Lisboa?'},
                resposta['message'],
                {'role': 'tool', 'content': resultado}
            ]
        )
        print(resposta_final['message']['content'])

💡 Exemplos Práticos

Agente Pesquisador Web

python

from langchain_community.llms import Ollama
from langchain.agents import initialize_agent, AgentType
from langchain.tools import DuckDuckGoSearchRun

# Modelo local
llm = Ollama(model="llama3.1:8b")

# Ferramenta de pesquisa
pesquisa = DuckDuckGoSearchRun()

ferramentas = [
    Tool(
        name="PesquisaWeb",
        func=pesquisa.run,
        description="Pesquisa na web por informações. Input: query de pesquisa."
    )
]

# Criar agente pesquisador
agente_pesquisador = initialize_agent(
    ferramentas,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Usar o agente
resposta = agente_pesquisador.run(
    "Pesquisa sobre as últimas novidades em inteligência artificial em 2026"
)
print(resposta)

Agente Programador

python

from langchain_community.llms import Ollama
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
import subprocess

def executar_python(codigo: str) -> str:
    """Executa código Python e retorna o resultado."""
    try:
        resultado = subprocess.run(
            ['python', '-c', codigo],
            capture_output=True,
            text=True,
            timeout=30
        )
        return resultado.stdout or resultado.stderr
    except Exception as e:
        return f"Erro: {e}"

llm = Ollama(model="codellama:7b")

ferramentas = [
    Tool(
        name="PythonREPL",
        func=executar_python,
        description="Executa código Python. Input: código Python válido."
    )
]

agente_programador = initialize_agent(
    ferramentas,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Executar
resposta = agente_programador.run(
    "Calcula os primeiros 20 números da sequência de Fibonacci usando Python"
)
print(resposta)