Sugestão: Uso do Google Colab, Google Drive, GROQ, LLM gratuita(llama) e Python

Se você usa a IA hoje deve ser via chat e para isso tem uma aplicação específica que provém esse acesso

Para acessar a LLM via programação foi criada uma restrição para que seu uso não virasse zona.
Para identificar sua aplicação você deve criar uma chave para a API de acesso.
Essa chave é gerada diretamente pela ferramenta de acesso a LLM/IA, neste exemplo, o Groq.
Para criar a chave de acesso você deve criar uma conta gratuita no Groq e seguir os passos para gerar a chave de API.

1-Acesse o site Groq .

2-Clique no link 'Start building'

3-Identifique-se com sua conta Google ou crie uma nova conta com seu e-mail. Sugiro a conta google porque vamos usar o google drive para armazenar os dados e o colab para executar o código python.

4-Clique em 'Playground'

5-Clique em 'API Keys'.

6-Se você não tem uma chave de API, clique em 'Create API Key' e digite um nome para sua chave API (Ex: GroqChaveApi).
Em seguida clique em 'Submit' e a chave da sua API será criada.

Se você já tem uma chave de api você verá ela nesta página e a sua validade é muito importante.

Importante: Salve o nome da sua chave API e o código dela porque não será possivel fazer isso mais tarde.

Todo projeto que faça a consulta a uma IA/LLM precisa suportar 3 passos fundamentais.
1-Interface com o usuário (entrada de dados, prompts, etc)
2-Processamento da solicitação (tratamento de dados, chamadas à API, etc)
3-Exibição dos resultados (formato de saída, apresentação, etc)

Para agrupar essas funcionalidades, você pode usar o Google Colab para criar um notebook que gerencie todas as etapas do processo.

Logicamente você vai ter que 'hospedar' esse jupiter notebook do Google Colab em algum lugar e o Google Drive é o local ideal para isso.

Você precisará apenas de uma conta no google. Abra o browser e selecione o aplicativo Google Drive.

No Google Drive Clique em 'Novo' e selecione 'Mais' e depois 'Google Colaboratory'.

Feito isso você tem o ambiente capaz de fazer a inteface com o usuário e com a LLM.

Você precisa conhecer os três itens básicos da ferramenta.

1-O item 'Texto' é tambem chamado de 'markdown' serve para você fazer anotações e documentar seu código.
É muito útil para identificar um trecho do código sem que você precise analisar ele e na codificação ajuda você a não confundir trechos semelhantes de código.
Tudo dentro dessas caixas é ignorado, ou seja, não é executado.

2-O item 'Código' é onde você escreve seu código Python.
Para executar o código digitado pressione o icone 'Play' à esquerda da caixa de código ou pressione 'Shift+Enter' no teclado.
Logo abaixo da caixa de código você verá o resultado da execução do código digitado.

3-O item 'Ambiente de Execução' tem as funcionalidades que afetam a execução do código.
O item mais usado desse link é 'Reiniciar sessão' que é muito utilizado quando fizemos uma declaração e precisamos mudar a declaração feita anteriormente. Por exemplo, importei a funcionalidade de uma biblioteca e cometi um erro e quero carregar outra. Sendo assim desejo liberar o componente antigo e carregar o novo evitando possíveis erros e conflitos em declarações.

Caso você não conheça o python ou as funcionalidades do Google Colab eu explicarei em cada passo o que esta sendo feito adicionando um comentário antes do código.
O comentário dentro do código deve ser precedido do caracter '#' e tudo que estiver depois do '#' será ignorado.
Contudo colocarei o comentário num campo texto antes do código.

Lembre-se que para acessar a LLM/IA você precisa da chave de acesso da API do Groq (API Key) e das siglas das IAs/LLMs que você quer acessar.

Item 1: Pressionar o link 'Texto' e adicionar o comentário/Markdown dentro dele explicando o que será feito.
Carregando a biblioteca groq

Item 2: Pressionar o link 'Código' e adicionar o código Python dentro dele.
!pip install -q groq

A chave da API é uma chave secreta e não deve ser colocada no código fonte ou em qualquer outro lugar.
Sendo assim vamos usar um componente chamado 'ambiente' (ou os em ingles) e o componente pegarSenha ( em ingles getpass ) para armazenar a senha.
Fazendo isso o notebook irá pedir para você digitar a senha. Ela não será exibida na tela e ao fechar o notebook ela será descartada.
Assim garantimos que a senha não será exposta e nem ficará gravada em algum lugar.

Item 3: Pressionar o link 'Texto' e adicionar o comentário/Markdown dentro dele explicando o que será feito.
Carregando a chave nas variáveis de ambiente

Item 4: Pressionar o link 'Código' e adicionar o código Python dentro dele.
import os import getpass
os.environ["GROQ_API_KEY"] = getpass.getpass()

ImportanteO texto 'GROQ_API_KEY' é o nome da chave do Groq(API KEY).
Caso você tenha dado outro nome a sua chave api mude o nome da variável.

Ao rodar este trecho de código será aberta uma caixa de diálogo pedindo para você digitar a chave da API do Groq. Digite/Cole a chave e pressione a tecla Enter.

Carregamos a chave de acesso ao Groq em nosso notebook mas ainda não enviamos a senha para o componente de acesso ao Groq. Vamos enviar.

Item 6: Pressionar o link 'Texto' e adicionar o comentário/Markdown dentro dele explicando o que será feito.
Carregando a chave da API Groq da interface no componente de acesso ao Groq e testando se carregou.

Item 7: Pressionar o link 'Código' e adicionar o código Python dentro dele.
from google.colab import userdata
GROQ_API_KEY = os.environ["GROQ_API_KEY"]
print("Chave carregada:", GROQ_API_KEY is not None)

Ao rodar este código temos a mensagem 'Chave carregada:YES' se tudo certo.

Item 9: Pressionar o link 'Texto' e adicionar o comentário/Markdown dentro dele explicando o que será feito.
Conectando com o Groq.

Item 10: Pressionar o link 'Código' e adicionar o código Python dentro dele.
from groq import Groq
client = Groq(api_key=GROQ_API_KEY)
print("Conexão com a Groq criada com sucesso!")

Ao rodar este código temos a mensagem 'Conexão com a Groq criada com sucesso!' se tudo certo.

Finalmente estamos prontos para enviar uma pergunta para a LLM.

Item 12: Pressionar o link 'Texto' e adicionar o comentário/Markdown dentro dele explicando o que será feito.
Enviando a pergunta para a LLM e exibindo a resposta.

Item 13: Pressionar o link 'Código' e adicionar o código Python dentro dele.
resposta = client.chat.completions.create(
   model="openai/gpt-oss-20b",
   messages=[
      {
         "role": "user",
         "content": "Qual é a IA mais poderosa para gerar texto disponível gratuitamente hoje ?"
      }
   ]
)
print(resposta.choices[0].message.content)

Importante: No exemplo acima usei a IA openai/gpt-oss-20b.
Quando você deu acesso as IAS (Controle de acesso e limites) você deve ter dado acesso a essa LLM naquele momento. Se não deu mude para a que você deu acesso.

Ao rodar este código temos a mensagem de resposta da LLM.

Se você seguiu a receita de bolo acima não deve ter maiores problemas.
Se teve baseie-se no exemplo abaixo:

Item 2: Pressionar o link 'Código' e adicionar o código Python dentro dele.
Deverá aparecer um V verde à esquerda da caixa indicando executado ok.

Item 2: Carregando a biblioteca groq.
Deverá aparecer um V verde à esquerda da caixa indicando executado ok.

Item 3:Carregando a chave nas variáveis de ambiente.
Digite na caixa de texto a chave da API que você criou no Groq.
Deverá aparecer um V verde à esquerda da caixa indicando executado ok.

Item 4: Carregando a chave da API Groq da interface no componente de acesso ao Groq e testando se carregou.
Deve exibir a mensagem : Chave carregada: True

Item 5: Conectando com o Groq
Deverá exibir a mensagem 'Conexão com a Groq criada com sucesso!'

Item 6: Enviando a pergunta para a LLM e exibindo a resposta.
Deverá exibir a resposta da LLM:

**Em termos de “poder” (capacidade de gerar textos coerentes, criativos e contextualizados), a resposta depende do que você entende por “gratuito”**:

| Tipo de acesso | Modelo | Disponibilidade gratuita | Observações |
|----------------|--------|--------------------------|-------------|
| **API/OpenAI Playground** | **GPT‑3.5‑turbo** | Sim (até 20 000 tokens gratuitos por mês, depois pagamento) | O modelo mais potente que o OpenAI oferece sem custo direto. É a base do ChatGPT gratuito que você encontra no site da OpenAI. |
| **ChatGPT (interface web)** | **GPT‑3.5‑turbo** (versão gratuita) | Sim | Você pode conversar com o modelo sem pagar, mas a quantidade de mensagens por dia é limitada. |
| **ChatGPT (interface web)** | **GPT‑4o (GPT‑4 o)** | Não (exclusivo para assinantes do ChatGPT Plus ou API paga) | Mais poderoso que o 3.5, mas não gratuito. |
| **Open‑source, roda no seu hardware** | **LLaMA 2 70B** | Sim (open‑source) | Muito potente, mas requer GPU(s) de alto desempenho e muita RAM. Não é “pronto‑para‑uso” sem infra‑estrutura. |
| **Open‑source, roda no seu hardware** | **Mistral 7B** | Sim | Menor que LLaMA 70B, mas ainda muito capaz para muitas tarefas. |
| **Open‑source, inference via serviços gratuitos** | **StableLM 1.8B/2.6B** | Sim (há Spaces no Hugging Face com uso gratuito limitado) | Modelos de menor escala, mas de boa qualidade. |
| **Open‑source, inference via Hugging Face Spaces** | **Claude 2 (via API de terceiros)** | Sim (há “free tier” limitado) | Menos potente que GPT‑3.5, mas ainda útil. |

### Qual é “o mais poderoso” de todos?

1. **Se você busca a maior qualidade de saída possível sem gastar dinheiro**  
   – **GPT‑3.5‑turbo** na API gratuita do OpenAI ou via ChatGPT gratuito. Ele é o modelo mais avançado que a OpenAI disponibiliza sem custo direto e oferece desempenho que costuma superar a maioria das soluções open‑source de tamanho comparável.

2. **Se você pode investir em hardware (GPUs de 24 GB+)**  
   – **LLaMA 2 70B** (ou o mesmo modelo “Meta” já está livre). Com o hardware certo, ele pode competir em qualidade com o GPT‑4, mas é mais exigente em recursos e requer tempo de treinamento/afinamento se quiser customizar.

3. **Se você precisa de algo que rode em um laptop ou CPU moderada**  
   – **Mistral 7B** ou **StableLM 2.6B** são escolhas sólidas. Eles são open‑source, livres de custos de API e já apresentam qualidade surpreendente.

### Dicas práticas

- **Para a maioria dos usos práticos (redação de posts, resumos, código, etc.)**: use o ChatGPT gratuito (GPT‑3.5‑turbo). É simples, não exige infraestrutura e já é robusto.
- **Para experimentos de pesquisa ou personalização**: baixe o LLaMA 2 70B ou Mistral 7B, configure um contêiner Docker com CUDA e comece a afinar com seus próprios dados.
- **Para aplicações com demanda de alto throughput**: combine a API do OpenAI (que oferece quotas gratuitas) com caching e batch processing para reduzir custos.

Deixei a resposta completa para não dizer que manipulei algo.

Também a pergunta eu nunca tinha feito a LLM.

Note que na resposta ele listou tanto as pagas como as gratuitas.

Listou também algumas LLMs 'Open Source' que você pode rodar localmente ( se você tiver um computador parrudo) e com isto não haverá limites do uso.
Veja o site HuggingFace para ter uma ideia das IAs e lá em baixo da página tem um item chamado 'Open Source' que são as LLMs que você pode baixar e instalar na sua máquina e muitas delas conseguem rodar até em um pendrive. Contudo, a resposta demora muito...quanto mais hardware melhor.

Note que no Groq temos acesso a diversas LLMs, pagas ou não.
Para testar as gratuitas são o suficiente e dão uma boa ideia do poder da LLM.
Contudo numa empresa assim que a funcionalidade 'escalar' para alguns funcionários provavelmente a empresa será obrigada a contratar uma LLM.
Como disse, cuidado antes de contratar porque você vai ficar amarrado nela e, talvez em outra pesquisa você ache uma LLM melhor e mais barata.

Seja bem vindo a era da IA. Boa sorte.