# Cloud (Gemini) — SDK oficial do Google
pip install google-genai

# Local (Ollama) — apenas requests, que já vem com Python
pip install requests

# Instalar SDK
!pip install google-genai

from google import genai
from google.genai import types
import os

# Configurar API key (novo SDK: usar Client)
from google.colab import userdata
client = genai.Client(api_key=userdata.get('GEMINI_API_KEY'))

# Mensagem simples (novo SDK)
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="Olá! Qual é a capital do Brasil?"
)
print(response.text)

# Com histórico de conversa (chat)
chat = client.chats.create(model="gemini-2.0-flash")
response1 = chat.send_message("Olá!")
print(response1.text)

response2 = chat.send_message("Qual é a capital do Brasil?")
print(response2.text)

# Com instruções de sistema (novo SDK)
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="O que é uma lista?",
    config=types.GenerateContentConfig(
        system_instruction="Você é um tutor de Python. Responda de forma didática."
    )
)
print(response.text)

# Novo SDK: usar types.GenerateContentConfig
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="Conte uma piada",
    config=types.GenerateContentConfig(
        temperature=0.7,        # 0.0 (determinístico) a 2.0 (criativo)
        max_output_tokens=100,  # Limite de tokens na resposta
        top_p=0.95,             # Nucleus sampling
        top_k=40                # Top-k sampling
    )
)
print(response.text)

from google.api_core.exceptions import NotFound, PermissionDenied, ResourceExhausted

try:
    response = client.models.generate_content(
        model="gemini-2.0-flash",
        contents="Olá!"
    )
    print(response.text)
except PermissionDenied:
    print("❌ API key inválida ou sem permissão")
except ResourceExhausted:
    print("⚠️ Limite de tokens excedido. Aguarde.")
except NotFound:
    print("❌ Modelo não encontrado")
except Exception as e:
    print(f"Erro: {e}")

# Instalar SDK
!pip install google-genai

from google import genai
from google.genai import types
from google.colab import userdata

# Configurar (novo SDK)
client = genai.Client(api_key=userdata.get('GEMINI_API_KEY'))

# Criar chat
chat = client.chats.create(model="gemini-2.0-flash")

while True:
    pergunta = input("Você: ")
    if pergunta.lower() in ['sair', 'exit', 'quit']:
        break

    resposta = chat.send_message(pergunta)
    print(f"IA: {resposta.text}\n")

# Célula 1: Verificar GPU
# Vá em Runtime → Change runtime type → T4 GPU
!nvidia-smi

# Célula 2: Instalar Ollama + dependências
!apt-get install -y zstd pciutils lshw > /dev/null 2>&1
!curl -fsSL https://ollama.com/install.sh | sh

import os
os.environ["LD_LIBRARY_PATH"] = "/usr/lib64-nvidia:" + os.environ.get("LD_LIBRARY_PATH", "")

print("✅ Ollama instalado!")

# Célula 3: Iniciar servidor + baixar modelo
import subprocess, time, requests

subprocess.run(["pkill", "-f", "ollama"], capture_output=True)
time.sleep(1)

# Manter modelo carregado indefinidamente (sem isso, descarrega após 5 min)
os.environ["OLLAMA_KEEP_ALIVE"] = "-1"

subprocess.Popen(
    ["ollama", "serve"],
    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
    env={**os.environ}
)

print("⏳ Aguardando Ollama iniciar...")
for i in range(30):
    try:
        r = requests.get("http://localhost:11434/api/tags", timeout=2)
        if r.status_code == 200:
            print("✅ Ollama rodando!")
            break
    except:
        time.sleep(1)

# Baixar modelo (~7.2 GB para gemma4:e2b, ~2.7 GB para qwen3.5:4b)
!ollama pull gemma4:e2b

import requests
import json

OLLAMA_URL = "http://localhost:11434/api/chat"
MODEL = "gemma4:e2b"

def chat(messages, model=None, stream=False):
    """Envia mensagens pro Ollama e retorna a resposta.

    Args:
        messages: lista [{"role": "...", "content": "..."}]
        model: nome do modelo (padrão: gemma4:e2b)
        stream: se True, retorna response object para iterar

    Returns:
        dict com a resposta (ou response se stream=True)
    """
    if model is None:
        model = MODEL
    payload = {"model": model, "messages": messages, "stream": stream, "keep_alive": -1}
    response = requests.post(OLLAMA_URL, json=payload, timeout=300)
    if response.status_code != 200:
        raise Exception(f"Erro {response.status_code}: {response.text}")
    return response if stream else response.json()

# Teste
resultado = chat([
    {"role": "system", "content": "Você é um assistente útil. Responda em português."},
    {"role": "user", "content": "Qual é a capital de Minas Gerais?"}
])
print(f"🤖 {resultado['message']['content']}")
print(f"📊 Tokens: prompt={resultado.get('prompt_eval_count', '?')}, "
      f"completion={resultado.get('eval_count', '?')}")

historico = [
    {"role": "system", "content": "Você é um assistente útil. Responda em português. Seja conciso."}
]

historico.append({"role": "user", "content": "Meu nome é Lucas e eu ense IA."})
r1 = chat(historico)
historico.append({"role": "assistant", "content": r1["message"]["content"]})
print(f"🤖: {r1['message']['content']}")

historico.append({"role": "user", "content": "Qual é o meu nome?"})
r2 = chat(historico)
historico.append({"role": "assistant", "content": r2["message"]["content"]})
print(f"🤖: {r2['message']['content']}")

resultado = chat([
    {"role": "system", "content": "Você é um assistente útil. Responda em português."},
    {"role": "user", "content": "Quantos números primos existem entre 1 e 20? /think"}
])

msg = resultado["message"]
thinking = msg.get("thinking", "(sem thinking)")
content = msg.get("content", "")
print(f"💭 Thinking:\n{thinking[:500]}...")
print(f"\n🤖 Resposta: {content}")

print("🤖 ", end="")
response = chat(
    [
        {"role": "system", "content": "Você é um assistente útil. Responda em português."},
        {"role": "user", "content": "Explique o que é uma API em 3 frases."}
    ],
    stream=True
)
for line in response.iter_lines():
    if line:
        chunk = json.loads(line)
        if "message" in chunk and "content" in chunk["message"]:
            print(chunk["message"]["content"], end="", flush=True)
print()

def perguntar(mensagem, url, model, api_key=None, system="Você é um assistente útil."):
    """Faz uma pergunta a qualquer API de LLM usando requests.post().

    Args:
        mensagem: pergunta do usuário
        url: URL da API (Gemini ou Ollama)
        model: nome do modelo
        api_key: API key (None para Ollama)
        system: instrução de sistema
    """
    # Implemente aqui
    pass

historico = {"mensagens": [{"role": "system", "content": "Você é um assistente útil. Responda em português."}]}

def conversar(mensagem):
    """Adiciona mensagem ao histórico, chama a API, retorna resposta."""
    # Implemente
    pass

def ver_historico():
    """Retorna histórico sem o system prompt."""
    # Implemente
    pass

def limpar_historico():
    """Limpa histórico mantendo system prompt."""
    # Implemente
    pass