22 e 25 SET 2026 · Terça e quinta · 19h às 22hAnhembi Morumbi · São Paulo

Do zero à sua VPS.

Primeiro abra o Cloud Shell. Depois crie a rede e a máquina, conecte e instale seu agente. O IP da VPS aparece ao concluir a criação.

Materiais complementares: curadoria do Carlão e referências do César

1. Abra o terminal da Oracle.

  1. Entre em cloud.oracle.com com a conta da equipe. Se ainda não recebeu o acesso, peça à organização.
  2. Escolha a região no topo do console. Clique no ícone de terminal e em Cloud Shell. Ele abre na parte de baixo da página.
  3. No menu Network do próprio Cloud Shell, escolha Public network e espere conectar. Isso permite baixar o kit e acessar sua futura VPS.

Deu certo: você vê um terminal com cloudshell no início da linha. A VPS será criada no passo 3. Não precisa de IP nem de chave SSH agora.

Não aparece Public network ou o download não funciona

O acesso público depende das permissões da conta. Peça ao mentor ou administrador para habilitar o recurso cloud-shell-public-network; após a alteração, reinicie a sessão. Criar a rede da VPS não libera a rede do Cloud Shell.

Orientação oficial de rede e permissões do Cloud Shell.

Cloud Shell aberto: seguir para conta e região

2. Informe a conta e a região.

São os únicos dados necessários para o comando de criação. A chave SSH e o IP da VPS serão gerados depois; a rede será configurada pelo kit.

É o identificador da conta ou da pasta de recursos da equipe. Para a conta: perfil → Tenancy → OCID → Copy. Se a organização indicou um compartment, use o OCID dele em Identity & Security → Compartments.

Cole o OCID completo para preencher os comandos da conta.

Use a região selecionada no console e mostrada no Cloud Shell, por exemplo sa-saopaulo-1. A rede e a VPS serão criadas juntas nessa região.

Só OCID, IP e região do Compute ficam salvos neste navegador. Nenhum dado é enviado pelo formulário.

3. Crie a rede e a VPS.

Execute no Cloud Shell aberto no passo 1. Este caminho cria uma VPS pequena para o app e agentes com IA externa. Uma pessoa da equipe executa; as demais podem começar o projeto no notebook. A máquina e o disco podem consumir os créditos da conta.

O kit cria, em ordem: rede, acesso à internet, subnet pública, chave SSH e máquina Ubuntu. Você não precisa montar a rede no console antes.

O que o kit configura na rede?

A rede vem antes da máquina. No caminho por script, o kit faz a sequência abaixo automaticamente. Não é preciso criar outra VCN no console.

  1. VCN: cria uma rede dedicada à equipe, com faixa 10.42.0.0/16.
  2. Internet Gateway e rota: conecta a rede à internet com a rota 0.0.0.0/0.
  3. Subnet pública: cria 10.42.0.0/24, permite IP público e configura as regras. SSH 22 fica restrito ao seu IP de saída; 80, 443 e 3000 atendem a aplicação.
  4. Compute: só então cria a VPS Ubuntu 24.04 nessa subnet, com chave SSH e IP público.

As portas de IA 4400 e 4411 ficam locais. A saída para a internet permite baixar o kit, dependências e modelos. Os recursos são criados no compartment e na região informados.

No Cloud Shell
(
set -e
cd "$HOME"
curl --connect-timeout 10 --max-time 90 -fL https://hackinova-anhembi.vercel.app/downloads/kit-oci-anhembi.zip -o kit-oci-anhembi.zip
python3 -m zipfile -e kit-oci-anhembi.zip .
)

No Cloud Shell
python3 "$HOME/kit-oci-anhembi/criar-vps.py" \
  --compartment "COLE_O_OCID_DO_COMPARTMENT" \
  --region "COLE_A_REGIAO_ESCOLHIDA" \
  --shape VM.Standard.E5.Flex --ocpus 1 --memory 8 --boot-size 50

O IP de saída do Cloud Shell é detectado automaticamente para liberar SSH só desse terminal. Esse endereço pertence ao terminal; o IP da VPS só aparece quando a máquina estiver pronta.

Deu certo: apareceu 5/5 VPS criada, o IP público e um comando ssh. Só então siga para entrar na VPS. Se houve erro, use a ajuda abaixo antes de repetir.

Deu “Out of host capacity” ou a criação foi interrompida?

Confira o registro local e o console: pode haver rede ou instância já criada. O script não troca sozinho para um shape mais caro e não fica criando máquinas em loop. Se o registro já contém instance_id, repita o comando original com --resume: ele só espera essa instância e consulta o IP, sem criar outra. Se falhou antes disso, revise os recursos parciais com o mentor. Só arquive o registro após decidir o destino desses recursos.

Prefiro criar a rede e a VPS pelo console
  1. Em Networking → Virtual cloud networks, abra Start VCN Wizard → Create VCN with Internet Connectivity. Use o compartment da equipe e dê um nome à rede.
  2. Confirme que a subnet pública usa uma tabela de rotas com 0.0.0.0/0 → Internet Gateway e permite IP público. Para este fluxo, escolha essa subnet.
  3. Na Security List da subnet, autorize TCP 22 com origem igual ao IP de saída do terminal, seguido de /32. Para a demo pública, autorize TCP 3000 com origem 0.0.0.0/0. Mantenha a saída para internet. Não abra 4400 ou 4411.
  4. Agora vá a Compute → Instances → Create instance. Escolha Ubuntu 24.04 e um tamanho compatível. Em Networking, selecione a VCN e a subnet pública que acabou de criar e habilite IP público.
  5. Baixe e guarde a chave SSH privada, espere a instância ficar Running e copie o IP público nas caixinhas deste guia. Conecte como ubuntu; o primeiro boot pode levar alguns minutos.

Este é um caminho alternativo ao script. O wizard pode criar gateways e uma subnet privada adicionais. Confira os recursos e custos no console.

Wizard de rede da Oracle · Criar a instância.

Avançado: preciso de uma VPS maior para modelo próprio

Para Nemotron, use --shape VM.Standard.A2.Flex --ocpus 19 --memory 38 --boot-size 150 no lugar dos parâmetros de tamanho acima. O script tenta uma instância e não troca automaticamente para um shape mais caro. Se houver erro de quota ou capacidade, confira os recursos parciais e use o caminho com IA externa enquanto resolve com o mentor.

4. Entre na VPS que acabou de criar.

Continue quando o terminal mostrar 5/5 VPS criada. O jeito mais direto é copiar o comando ssh -i ... ubuntu@... que ele imprimiu e executar no mesmo Cloud Shell.

Também pode usar este bloco: ele lê o IP e a chave do registro salvo pelo kit. Não precisa digitar nenhum dos dois.

No mesmo Cloud Shell — depois da criação
python3 "$HOME/kit-oci-anhembi/conectar-vps.py"

Na primeira conexão, confira a instância e confirme a pergunta de SSH. Deu certo: o início da linha mudou para ubuntu@health-.... Agora você está dentro da VPS. Se der timeout, espere o primeiro boot e consulte a ajuda de SSH.

Já tenho VPS, criei pelo console ou vou usar o notebook

Agora que a VPS existe, copie o IP público em Compute → Instances → sua instância. Os campos abaixo preenchem os comandos de SSH, SCP e o link da demo. Para acessar pelo notebook, autorize também o IP de saída dele na regra TCP 22 da rede.

Copie o IP da instância criada. Este é o endereço do servidor; o IP da sua conexão é outro campo no gerador.

Quando tiver o IP, os comandos SSH, SCP, túnel e o endereço da demo serão preenchidos.

Preencher também o caminho da chave SSH
Opcional: copie o caminho que aparece depois de ssh -i ao criar a VPS. No notebook, use o caminho para onde você transferiu a chave. Cole só o caminho, nunca o conteúdo da chave.

Sem esse campo, SUA_CHAVE_SSH permanece nos comandos para você substituir.

No Cloud Shell ou no seu notebook — substitua chave e IP
ssh -i SUA_CHAVE_SSH ubuntu@IP_DA_VPS

Já entrei na VPS: instalar o agente

5. Instale e abra seu agente.

Para seguir na VPS: confira ubuntu@ no início da linha. Execute o bloco de instalação abaixo. Se escolheu trabalhar no notebook, use um terminal Linux, macOS ou WSL ali.

Um agente de programação lê arquivos, propõe e aplica alterações e executa ferramentas no terminal. O modelo é a IA que orienta esse trabalho. A VPS é a máquina que hospeda seus arquivos e sua aplicação.

No seu computador Linux/WSL/macOS ou dentro da VPS
(
set -e
cd "$HOME"
curl --connect-timeout 10 --max-time 90 -fL https://hackinova-anhembi.vercel.app/downloads/kit-oci-anhembi.zip -o kit-oci-anhembi.zip
python3 -m zipfile -e kit-oci-anhembi.zip .
bash kit-oci-anhembi/instalar-agentes.sh todos
export PATH="$HOME/.local/bin:$HOME/.opencode/bin:$PATH"
mkdir -p ~/health-ai
cd ~/health-ai
opencode
)

AgenteComo ajudaIA e integrações
OpenCodeDesenvolvimento pelo terminal, com leitura, edição e execução de comandos.Tem modelos Free no catálogo e suporte nativo a MCP. Também conecta ao Nemotron via LiteLLM.
Pi AgentAgente enxuto e extensível, com ferramentas de leitura, escrita, edição e shell.Conecta ao Nemotron neste kit. CLI e SDK funcionam pelo terminal; MCP requer extensão no Pi 0.85.1.
Devin CLIAgente da Cognition que trabalha nos arquivos da máquina onde foi aberto.Tem MCP e usa os modelos disponíveis na sua conta Devin. Neste guia, o Nemotron conecta ao Pi e ao OpenCode.

Para começar a construir: use um modelo Free no OpenCode ou a cota gratuita do Devin. Depois acrescente os serviços OCI que seu app precisa. Assim, a equipe pode programar enquanto prepara a infraestrutura.

Pré-requisitos: Python 3.12 ou mais recente e curl. Na VPS, use o usuário ubuntu. No Windows, siga pelo WSL. O instalador fixa as versões verificadas e instala Node para o Pi quando necessário.

OpenCode: escolha um modelo Free

Dentro do OpenCode, use /models e escolha uma opção marcada como gratuita. Em 12/09/2026, a documentação lista Big Pickle, MiMo-V2.5 Free, Ling 3.0 Flash Fin Free, Nemotron 3 Ultra Free e Nemotron 3.5 Lightning Free.

São ofertas com disponibilidade e limites variáveis. Confira preço zero no seletor; um nome que contém “Contributor Free” não garante as mesmas condições. Para essas opções, abra opencode; o atalho opencode-oci seleciona o modelo da VPS.

As chamadas saem para um provedor externo à Oracle. Use apenas código e dados fictícios do desafio: algumas ofertas gratuitas registram conteúdo ou permitem uso para melhoria dos modelos. Catálogo, preços e privacidade do OpenCode.

Devin CLI: conta Free e login

O plano Free oferece uma cota reduzida para agentes e seleção limitada de modelos. Entre com sua conta, abra devin na pasta do projeto e use /model para escolher uma opção gratuita disponível. Não é uso ilimitado; promoções podem mudar.

Dentro da VPS por SSH
devin auth login --force-manual-token-flow
# Complete o login pelo endereço mostrado; cole o token apenas no terminal.
devin

No seu computador, também pode usar devin auth login com o fluxo do navegador. A Cognition anuncia uma promoção de SWE-2 no Desktop/CLI até 10/10/2026; confira a elegibilidade e os limites na sua conta. Plano Free e condições atuais · Guia oficial do Devin CLI.

Os US$ 300 da Oracle pagam recursos elegíveis na OCI. Não viram saldo de OpenCode, Devin ou outro provedor externo. Nenhum plano pago externo é contratado pelo kit.

Quer que o agente entenda de OCI? Instale as 37 skills de OCI e as ferramentas MCP somente leitura: ajudam com autenticação, rede, capacidade, IA e custo. É opcional e leva dois minutos.

6. Confira a demo pela internet.

Depois de instalar o agente, peça para criar o app e executar em 0.0.0.0:3000. Para conferir apenas a conexão, use o teste de rede abaixo.

Na VPS, libere a porta 3000 no firewall local e faça sua aplicação escutar em 0.0.0.0:3000. A regra da VCN e a regra do Ubuntu precisam permitir a mesma porta. Este comando mantém a liberação após reiniciar:

Dentro da VPS — somente a porta da aplicação
bash "$HOME/kit-oci-anhembi/preparar-demo.sh"

Ajuste o caminho se extraiu o kit em outra pasta. O link da demo é http://IP_DA_VPS:3000. Se usar UFW ou outro firewall próprio, confirme a regra com o mentor. Use dados fictícios.

Testar a rede antes de ter um app pronto

Execute na VPS. O servidor serve apenas uma pasta temporária com uma página de teste. Abra o endereço da demo no notebook; depois volte ao terminal e pressione Ctrl+C para liberar a porta para seu app.

Dentro da VPS — após liberar a porta
(
demo_dir="$(mktemp -d)"
trap 'rm -rf -- "$demo_dir"' EXIT
printf '%s\n' '<h1>Hack Inova: rede e VPS funcionando</h1>' > "$demo_dir/index.html"
python3 -m http.server 3000 --bind 0.0.0.0 --directory "$demo_dir"
)

Escolha um dos dois caminhos.

EscolhaOnde o agente rodaOnde o app roda
A. Tudo na VPSDentro da VPS, depois de entrar por SSH pelo Cloud Shell ou notebook.Na VPS. Edição, build e testes acontecem lá.
B. Agente no notebookNo seu computador, editando o projeto local e usando SSH para comandos remotos.Na VPS após o deploy. Defina onde fazer o build, principalmente se a VPS for ARM.

Em ambos, entregue o manual OCI ao agente. A escolha do modelo é independente: use uma opção Free externa ou configure Pi/OpenCode com a IA da VPS.

1. Agente dentro da VPS

Conecte usando o comando SSH do passo 4. Depois continue dentro da VPS.

Abra o Cloud Shell no console Oracle ou um terminal no notebook, conecte por SSH e só então inicie o agente. Depois do SSH, os arquivos, comandos, builds e testes rodam na VPS.

Quando o prompt mudar para a VPS, instale os agentes pelo roteiro desta página. Depois execute:

Dentro da VPS, com os agentes instalados
export PATH="$HOME/.local/bin:$HOME/.opencode/bin:$PATH"
mkdir -p ~/health-ai
cd ~/health-ai
opencode
# Ou: devin, pi-oci ou opencode-oci, conforme a configuração.

Cloud Shell é um terminal separado da VPS. Ele ajuda a criar recursos e abrir SSH. O modelo de 18,9 GB deve rodar no Compute grande. Para continuar uma sessão após desconectar, na VPS use tmux new -As health antes de iniciar o agente; volte com tmux attach -t health.

2. Agente no seu computador, VPS por SSH

Instale o agente no Linux, macOS ou WSL e abra o projeto local. Ele pode editar os arquivos do notebook e executar comandos remotos com ssh, além de transferir arquivos com scp. Diga explicitamente qual máquina deve executar cada tarefa.

Traga sua chave SSH com segurança e autorize o IP de saída do notebook na regra SSH da OCI. Se também usar Cloud Shell, autorize separadamente o IP dele. A chave SSH entra no Linux; as credenciais OCI autorizam operações na nuvem.

Usar o Nemotron da VPS no Pi ou OpenCode do notebook

Depois de instalar o modelo e o gateway, mantenha este túnel aberto em um terminal do notebook:

No notebook — mantenha este terminal aberto
ssh -N -o ExitOnForwardFailure=yes   -L 127.0.0.1:4400:127.0.0.1:4400   -i SUA_CHAVE_SSH ubuntu@IP_DA_VPS

Em outro terminal, transfira a chave do gateway por SSH e configure os agentes. Ela fica em arquivo privado, fora do projeto:

No notebook — na pasta extraída do kit
mkdir -p ~/.config/hackinova-oci
chmod 700 ~/.config/hackinova-oci
scp -i SUA_CHAVE_SSH   ubuntu@IP_DA_VPS:~/.config/hackinova-oci/gateway.key   ~/.config/hackinova-oci/gateway.key
chmod 600 ~/.config/hackinova-oci/gateway.key
python3 configurar-agentes.py
# Na pasta do projeto, escolha um:
pi-oci
# Ou: opencode-oci

O túnel transporta chamadas ao modelo. Para administrar a VPS, o agente continua usando SSH ou as ferramentas OCI autorizadas. Modelos Free externos dispensam esse túnel.

Entregue o roteiro Oracle ao agente.

O arquivo OCI-AGENTE.md orienta o Pi, OpenCode ou Devin a construir o app: reconhecer o ambiente, conferir rede e credenciais, usar CLI/SDK/MCP e os serviços Oracle, testar o build e entregar a demo. Ele explica os dois caminhos e inclui exemplos para Object Storage, Vision, documentos e Speech.

Baixar modelo sem preencher

A versão preenchida usa OCID, IP e região do Compute das caixinhas. Nenhuma chave privada é incluída. Escolha o caminho A ou B com o agente.

Coloque o arquivo na pasta do projeto onde o agente está rodando. Você também pode baixar o modelo pelo terminal:

No terminal do agente, dentro do projeto
curl -fL https://hackinova-anhembi.vercel.app/oci-agente.md -o OCI-AGENTE.md

Depois, cole este pedido na conversa do agente:

Mensagem para Pi, OpenCode ou Devin
Leia OCI-AGENTE.md e as regras deste repositório antes de começar.
Vamos construir a demo do desafio da nossa equipe usando a Oracle.
Identifique onde você está rodando e confirme comigo o caminho A (agente na VPS) ou B (agente no notebook, VPS por SSH), o desafio e o compartment se ainda não estiverem definidos.
Inspecione o projeto, valide o acesso e proponha a menor integração Oracle que faça o fluxo funcionar. Implemente, execute testes e build e valide a demo na VPS.
Registre os recursos e custos estimados em OCI-RECURSOS.md e os comandos no README. Use dados sintéticos. Entregue a URL e diga exatamente o que foi testado e o que ainda depende de acesso.

Baixar o arquivo não instala ferramentas nem dá permissão na OCI. As credenciais precisam estar configuradas no ambiente que executará as chamadas.

US$ 300 para a infraestrutura da equipe.

Uma conta com US$ 300 por equipe. Confira saldo, validade, região e limites no console antes de criar a máquina. O trial público padrão oferece até 30 dias; siga as condições da conta entregue à equipe.

Seu objetivoCompute sugeridoO que esperar
Construir o app com IA externaA1 1 OCPU / 6 GB ou E5 1 OCPU / 8 GBApp e agente na VPS; a inferência fica no provedor escolhido.
Experimentar Nemotron na própria OCIA2 19 OCPUs / 38 GB; boot de 150 GBPerfil usado no laboratório, sem GPU. A criação depende da quota e capacidade da conta/região.

Referência para A2: 19 × US$ 0,014 + 38 × US$ 0,002 = US$ 0,342 por hora, ou cerca de US$ 3,42 em 10 horas, somente Compute. Disco, outros serviços, impostos e condições da conta são adicionais. A VPS pequena não comporta este Nemotron.

CPU tem limite: o modelo gera cerca de 24 tokens/s no microbenchmark do laboratório, mas leitura de contexto e várias chamadas de ferramentas podem levar dezenas de segundos ou minutos. Uma única instância de inferência atende uma requisição por vez. Não prometa a mesma velocidade para toda a equipe.

Defina orçamento e acompanhe consumo. Um alerta de budget não desliga recursos. Ao encerrar, remova os recursos da equipe que não serão usados; parar uma VM pode manter custos de disco. Não é necessário fazer upgrade para conta paga para seguir este roteiro dentro dos recursos liberados no trial.

Condições do Free Tier · Preços de Compute. Referências verificadas em 12/09/2026.

Avançado: personalize seu script.

O caminho do zero está nos passos 1 a 5 acima. Use este gerador para escolher outro tamanho, instalar agentes ou configurar a IA. Para criar a VPS, informe apenas conta e região; o IP de saída será detectado no Cloud Shell.

Você vai gerar um script para o Cloud Shell, o terminal dentro do console Oracle. Depois, entre na VPS criada e volte para preparar a IA.

Copie em Identity & Security → Compartments → seu compartment → OCID. Confirme qual usar com a organização. O OCID também é atualizado nas caixinhas do guia.
A mesma região da VCN, subnet e VPS; sincronizada com as caixinhas do guia.
Disponibilidade e custo dependem da sua conta. O script tenta uma instância com o tamanho escolhido.
Avançado: liberar SSH para outro terminal
Deixe vazio para o caminho normal. Só preencha se outra conexão, como o notebook, fará SSH. Nesse outro terminal, execute curl -fsS https://api.ipify.org e cole o IPv4. Não é o IP da VPS.

Os scripts são montados neste navegador, sem envio dos campos. Só o OCID, o IP e a região do Compute das caixinhas acima são lembrados localmente. Não cole chaves privadas nem senhas.

Você não precisa montar os comandos.

  1. Preencha os dados da sua conta. As dicas mostram onde encontrar cada um.
  2. Clique em Gerar script. Os valores entram nos comandos automaticamente.
  3. Copie o bloco inteiro e cole no terminal indicado.

Criar a VPS e preparar a IA são duas etapas: a primeira roda no Cloud Shell; a segunda, dentro da VPS.

Prefiro seguir o guia passo a passo

Prefere acompanhar cada etapa?

O guia abaixo explica o que os scripts fazem e ajuda se aparecer algum erro. Ir para a solução de problemas.

Ferramentas extras: gateway e integrações OCI.

Na VPS Ubuntu 24.04, o instalador prepara Git, tmux, Python, OCI CLI/SDK e LiteLLM em ambientes separados. Instale o Nemotron somente no perfil grande; o uso de agentes com modelos externos não exige o gateway.

Dentro da VPS
curl -fL https://hackinova-anhembi.vercel.app/downloads/kit-oci-anhembi.zip -o kit-oci-anhembi.zip
python3 -m zipfile -e kit-oci-anhembi.zip .
cd kit-oci-anhembi
bash instalar-vps.sh

Resultado: gateway em ~/.local/share/hackinova-oci/ e CLI em ~/.local/bin/oci-hackinova. O instalador não cria recursos na nuvem.

O pacote também inclui instaladores de Pi, OpenCode, Devin e Nemotron, configuração dos dois agentes para o gateway e controles de contexto para o Pi em CPU.

Credenciais para controlar a OCI.

Este passo é necessário para CLI, SDK, MCP e para o serviço gerenciado Generative AI. Consultar o Nemotron pelo gateway local não exige uma chave de assinatura OCI. Configure a credencial na máquina onde a ferramenta OCI será executada.

O arquivo deve conter user, fingerprint, tenancy, region e key_file. Ajuste key_file para o caminho real da chave privada. As permissões são as do seu usuário; o kit não concede acesso de administrador.

Dentro da VPS
mkdir -p ~/.oci
chmod 700 ~/.oci
nano ~/.oci/config
chmod 600 ~/.oci/config
# Ajuste para o nome real do arquivo que você transferiu:
chmod 600 ~/.oci/api_key.pem
~/.local/bin/oci-hackinova os ns get

Para transferir do Cloud Shell, use scp -i SUA_CHAVE_SSH ARQUIVO ubuntu@IP_DA_VPS:~/.oci/, depois de criar a pasta na VPS. O teste de namespace confirma a assinatura da requisição; o uso de Generative AI também depende de permissão no compartment escolhido.

Passo a passo oficial: chave de assinatura e configuração OCI. Mantenha a chave privada fora do projeto e do site.

A chave SSH abre o terminal da VPS. A chave de assinatura OCI autoriza chamadas à nuvem com as permissões do usuário. A chave do gateway autentica chamadas ao modelo. São três credenciais diferentes.

No seu perfil do console: API Keys → Add API Key. Cadastre a chave pública, guarde a privada e copie a configuração fornecida para ~/.oci/config, ajustando key_file. O Cloud Shell já tem sua própria autenticação; ela não é transferida automaticamente por SSH.

SSH, CLI, SDK e MCP: quem faz o quê?

O agente executa ferramentas com as permissões que você disponibilizar. Restrinja o trabalho ao compartment da equipe, registre os recursos criados e revise comandos que alteram infraestrutura.

  • SSH: executa comandos no Linux da VPS.
  • OCI CLI: administra recursos pela linha de comando. No kit: ~/.local/bin/oci-hackinova.
  • OCI SDK: permite usar as APIs em Python; o ambiente da CLI já inclui o pacote oci.
  • MCP: apresenta ferramentas OCI ao agente. OpenCode e Devin têm suporte nativo. No Pi 0.85.1, use CLI/SDK ou uma extensão MCP escolhida pela equipe.
MCP oficial da Oracle: configuração opcional

O servidor oracle.oci-cloud-mcp-server precisa de credencial OCI válida no ambiente em que roda. Com uv disponível, o comando é uvx --python 3.13 oracle.oci-cloud-mcp-server@2.2.3. O servidor expõe operações autorizadas pelo IAM; não é somente leitura por padrão.

No OpenCode, adicione ao arquivo de configuração do agente (preservando os demais campos):

Trecho JSON para a configuração do OpenCode
{
  "mcp": {
    "oci": {
      "type": "local",
      "command": ["uvx", "--python", "3.13", "oracle.oci-cloud-mcp-server@2.2.3"],
      "environment": {"OCI_CONFIG_PROFILE": "DEFAULT", "FASTMCP_LOG_LEVEL": "ERROR"},
      "enabled": true
    }
  }
}

No Devin, use o formato próprio em ~/.config/devin/mcp_config.json, com mcpServers, command e args. Não copie o JSON do OpenCode sem adaptar. O kit não ativa servidores MCP automaticamente.

Servidor oficial Oracle e pré-requisitos · MCP no OpenCode · MCP no Devin.

Compute grande: instale seu modelo.

Com o perfil grande pronto, instale NVIDIA Nemotron 3.5 Lightning 30B-A3B Q4_0. O kit baixa os pesos de 18,9 GB e o llama.cpp b10917, verifica SHA256 e cria um serviço que volta após reiniciar a VPS. Requer pelo menos 30 GiB de RAM e 40 GiB livres no disco.

Dentro da VPS grande, após instalar-vps.sh
python3 ~/.local/share/hackinova-oci/instalar-nemotron.py
# Aguarde o carregamento: HTTP 503 durante a inicialização é esperado.
curl -fsS http://127.0.0.1:4411/health
# Para acompanhar:
sudo journalctl -u hackinova-nemotron.service -n 30 --no-pager

Continue quando /health retornar HTTP 200. O modelo fica em 127.0.0.1:4411, com chave privada, contexto de 16k e uma requisição por vez. O carregamento a frio pode levar vários minutos. O gerador acima aguarda a prontidão automaticamente.

Pi / OpenCode / appLiteLLM na VPSNemotron no Compute

Esse é o caminho do modelo próprio. Ao escolher uma opção Free no OpenCode ou no Devin, a inferência fica no provedor externo. Os blocos abaixo indicam em qual terminal executar.

Conecte o modelo ao gateway LiteLLM.

O LiteLLM oferece uma API compatível com OpenAI para o app, o Pi e o OpenCode. No caminho Compute, ele encaminha a chamada ao Nemotron da própria VPS. O alias usado pelos clientes é saude.

Dentro da VPS, após o Nemotron ficar pronto
python3 ~/.local/share/hackinova-oci/configurar-gateway.py --provider local
bash ~/.local/share/hackinova-oci/gateway.sh start
python3 ~/.local/share/hackinova-oci/testar-gateway.py
# Após o teste local passar, faça uma chamada real:
python3 ~/.local/share/hackinova-oci/testar-gateway.py --chat

O script cria ~/.config/hackinova-oci/gateway.key e configura os agentes sem exibir a chave. O gateway atende em http://127.0.0.1:4400/v1. Nunca libere 4400 ou 4411 publicamente; no notebook, use o túnel SSH.

O gateway roda em tmux. Depois de reiniciar a VPS, rode gateway.sh start de novo. Para trocar o provider, primeiro pare com gateway.sh stop, configure e inicie.

Outra possibilidade: Generative AI gerenciado

Use esta opção somente se o Playground funcionar com o modelo na conta e região da equipe. Crédito de trial não garante acesso a todos os modelos ou serviços. A restrição encontrada na conta do laboratório não comprova uma remoção global do GenAI dos trials.

Configure a chave OCI no passo de credenciais, confirme o ID on-demand no Playground e execute:

Dentro da VPS — alternativa ao provider local
python3 ~/.local/share/hackinova-oci/configurar-gateway.py   --provider oci   --compartment "COLE_O_OCID_DO_COMPARTMENT"   --region "COLE_A_REGIAO_DO_GENERATIVE_AI"   --model "COLE_O_ID_DO_MODELO_ON_DEMAND"
bash ~/.local/share/hackinova-oci/gateway.sh start
python3 ~/.local/share/hackinova-oci/testar-gateway.py --chat

Essa chamada usa o serviço gerenciado e sua cobrança por consumo. Se estiver bloqueado, siga com o modelo em Compute ou com os modelos externos gratuitos. Documentação do Generative AI.

Pi e OpenCode com o modelo da VPS.

Depois de instalar os agentes e configurar o gateway, entre na pasta do projeto e escolha um dos atalhos. Os dois usam a mesma API local e o modelo oracle/saude.

Na VPS ou no notebook com o túnel aberto
export PATH="$HOME/.local/bin:$HOME/.opencode/bin:$PATH"
cd ~/health-ai
pi-oci

Alternativa ao Pi, no mesmo ambiente
cd ~/health-ai
opencode-oci

No Pi, a extensão do kit limita saídas longas, guarda o texto completo em arquivo privado e permite ajustar chamadas por pedido: /oci-budget 3 para consultas curtas ou /oci-budget 24 para programação. /oci-status e /oci-arquivos consultam o sistema diretamente. Esses controles reduzem desperdício; não corrigem todos os erros do modelo.

Se a inferência em CPU atrapalhar, encerre o agente e abra opencode com uma opção Free em /models, ou use devin com sua cota gratuita. O app pode continuar chamando o Nemotron da OCI.

Pi Agent · Providers do OpenCode.

Use a IA no seu app.

No backend da VPS, use o modelo saude, a base http://127.0.0.1:4400/v1 e o conteúdo de gateway.key como Bearer token. O exemplo Python já faz isso:

Dentro da VPS
python3 ~/.local/share/hackinova-oci/chamar-ia.py \
  "Crie uma tarefa administrativa fictícia de retorno em 30 dias. Sem orientação clínica."

O navegador chama seu backend; o backend chama o gateway. A chave do gateway não entra no JavaScript público. Para desenvolver no notebook com a VPS remota, abra um túnel SSH:

No seu notebook
ssh -N -o ExitOnForwardFailure=yes -L 127.0.0.1:4400:127.0.0.1:4400 -i SUA_CHAVE_SSH ubuntu@IP_DA_VPS

Com o túnel aberto, seu backend local usa a mesma URL, com a chave do gateway obtida por transferência segura. Se o backend rodar em um container, 127.0.0.1 será o próprio container; configure a rede com o mentor.

Comandos de socorro.

Dentro da VPS
bash ~/.local/share/hackinova-oci/gateway.sh status
bash ~/.local/share/hackinova-oci/gateway.sh logs
# Para sair dos logs sem parar: Ctrl+B, depois D
# Para parar:
bash ~/.local/share/hackinova-oci/gateway.sh stop

SintomaO que verificar
SSH demora ou dá timeoutEspere o primeiro boot; confira IP público, subnet pública, rota para Internet Gateway e regra TCP 22 com o IP de saída atual do terminal. Cloud Shell e notebook podem ter IPs diferentes.
Permission denied (publickey)Use o usuário ubuntu e a chave privada correspondente à chave pública da instância. No Linux/macOS, ajuste chmod 600 no arquivo da chave.
Demo não abre na porta 3000Confirme o app em 0.0.0.0:3000, a regra TCP 3000 na VCN e preparar-demo.sh no Ubuntu. Primeiro teste curl http://127.0.0.1:3000 dentro da VPS.
Conexão recusada em 4400Gateway ainda iniciando ou sessão encerrada; confira status e logs.
401Confira a chave do gateway. No GenAI, confira também a assinatura OCI; são credenciais distintas.
403 / NotAuthorizedOrNotFoundPolíticas do usuário, compartment e acesso ao serviço.
Modelo não encontrado / 404No Compute, confira o serviço Nemotron e o alias saude. No GenAI, confirme ID, região e acesso.
429 ou limite excedidoQuota, consumo, tamanho da requisição e concorrência.
OpenCode não encontra o providerUse opencode-oci e confira se o projeto sobrescreve a configuração.
CPU demora ou acumula pedidosReduza contexto e concorrência, use consultas por trecho. Para programar, experimente OpenCode Free ou a cota Free do Devin.

Baixar o manual OCI para o agente · Explorar os serviços Oracle