c2code-cloud

Como usar o modelo de código que você recebeu acesso.

opencode instalar

Uma linha. Ele instala o opencode se ainda não houver, busca a configuração no servidor e já deixa tudo no lugar.

Linux e macOS

curl -fsSL https://c2code-cloud.prontdoc.com.br/opencode.sh | sh -s -- --token c2c_SEU_TOKEN

Windows (PowerShell)

irm https://c2code-cloud.prontdoc.com.br/opencode.ps1 | iex; Install-C2code -Token c2c_SEU_TOKEN

A configuração vai pra ~/.config/opencode/opencode.json. Se já existir um arquivo lá, ele guarda uma copia antes de trocar.

Atualizar depois

De tempos em tempos o modelo da sua categoria muda — outro modelo, outro limite de contexto, às vezes passa a aceitar print. O config no seu computador é um arquivo, então ele não acompanha sozinho: rode o mesmo comando de cima, sem token, que ele lê o seu do config já instalado.

curl -fsSL https://c2code-cloud.prontdoc.com.br/opencode.sh | sh

irm https://c2code-cloud.prontdoc.com.br/opencode.ps1 | iex; Install-C2code

Acrescente --só-config (ou -SoConfig) pra ele nem verificar a instalação do opencode e só regravar o config e as skills.

Junto vão as skills: instruções prontas que o opencode oferece ao modelo quando o assunto bate (deployar, por exemplo). Elas ficam em ~/.config/opencode/skill/c2code/ — uma pasta só nossa, reescrita inteira toda vez que você roda o instalador; as skills que você escrever em ~/.config/opencode/skill/<nome>/ ficam intactas.

E vão também as regras da casa, num ~/.config/opencode/AGENTS.md que vale em todo projeto. Como esse arquivo pode ser seu também, o que é nosso entra num bloco marcado (c2code:inicio / c2code:fim) e só ele é reescrito — o que você escrever fora do bloco fica.

Rode o mesmo comando de novo pra atualizar config, skills e regras.

Usar

opencode                       # abre a interface
opencode run "sua pergunta"    # uma pergunta só

pi instalar

O pi é outro agente de terminal. Mesmo acesso, mesmo modelo, as mesmas skills — muda só o programa.

Linux e macOS

curl -fsSL https://c2code-cloud.prontdoc.com.br/pi.sh | sh -s -- --token c2c_SEU_TOKEN

Windows (PowerShell)

irm https://c2code-cloud.prontdoc.com.br/pi.ps1 | iex; Install-C2codePi -Token c2c_SEU_TOKEN

O pi guarda a configuração em dois arquivos, e o instalador trata cada um como merece: ~/.pi/agent/models.json (só nosso) vai inteiro, e ~/.pi/agent/settings.json é mesclado — seu tema, seu editor e seus atalhos continuam onde estavam.

As skills vão pra ~/.pi/agent/skills/c2code/, com a mesma regra: pasta só nossa, reescrita inteira a cada rodada. As regras da casa vão pro ~/.pi/agent/AGENTS.md, no mesmo bloco marcado — o que você escreveu fora dele fica.

Rode o mesmo comando de novo pra atualizar configs, skills e regras.

Usar

pi                       # abre a interface
pi -p "sua pergunta"     # uma pergunta só

Ou a mao, se preferir

A configuração do opencode é um arquivo JSON que você pode baixar direto:

curl -H "Authorization: Bearer c2c_SEU_TOKEN" \
     https://c2code-cloud.prontdoc.com.br/me/opencode.json -o opencode.json

Grave em ~/.config/opencode/opencode.json. No Windows, %USERPROFILE%\.config\opencode\opencode.json.

As skills vem num pacote, no mesmo esquema:

mkdir -p ~/.config/opencode/skill/c2code
curl -H "Authorization: Bearer c2c_SEU_TOKEN" \
     https://c2code-cloud.prontdoc.com.br/me/skills.tar.gz | tar -xz -C ~/.config/opencode/skill/c2code

A mao isso só acrescenta. Quem também APAGA a skill que saiu de circulação é o instalador lá de cima, que reescreve a pasta inteira.

Do pi são dois arquivos, nas rotas https://c2code-cloud.prontdoc.com.br/me/pi/models.json e https://c2code-cloud.prontdoc.com.br/me/pi/settings.json — o primeiro vai inteiro pra ~/.pi/agent/, do segundo você copia as chaves pro seu. E as regras da casa saem em https://c2code-cloud.prontdoc.com.br/me/agents.md, já prontas pra colar no AGENTS.md do seu agente.

Onde rodar

Dentro da pasta do seu projeto: o agente lê e edita os arquivos dali.

Claude Code

O Claude Code fala o protocolo da Anthropic, e o nosso servidor também — o mesmo modelo, na mesma máquina, responde nos dois. Basta apontar a URL base pra ca:

export ANTHROPIC_BASE_URL=https://c2code-cloud.prontdoc.com.br/anthropic/vllm_oss_120b
export ANTHROPIC_AUTH_TOKEN=c2c_SEU_TOKEN
claude

Sem /v1 no fim: o Claude Code acrescenta sozinho. Você NÃO precisa dizer qual modelo usar — o servidor troca o nome pelo que a máquina está servindo, então os ANTHROPIC_DEFAULT_*_MODEL da documentacao dele são opcionais aqui.

Pra deixar fixo, sem exportar toda vez, o mesmo vai no ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://c2code-cloud.prontdoc.com.br/anthropic/vllm_oss_120b",
    "ANTHROPIC_AUTH_TOKEN": "c2c_SEU_TOKEN"
  }
}

Usar como API

O mesmo token funciona direto na API, sem opencode nenhum. Ela é compatível com a da OpenAI, então qualquer biblioteca que fale com a OpenAI serve — só troque a URL base e a chave.

O prefixo /ollama/ continua valendo e faz a mesma coisa que /openai/ — se você instalou antes, não precisa mexer.

curl

curl https://c2code-cloud.prontdoc.com.br/openai/vllm_oss_120b/v1/chat/completions \
  -H "Authorization: Bearer c2c_SEU_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MODELO",
    "messages": [{"role": "user", "content": "escreva um hello world em go"}]
  }'

O nome do model você descobre em GET /openai/vllm_oss_120b/v1/models — ele muda quando trocamos o modelo, então leia de lá em vez de fixar no código.

Python

from openai import OpenAI

cliente = OpenAI(
    base_url="https://c2code-cloud.prontdoc.com.br/openai/vllm_oss_120b/v1",
    api_key="c2c_SEU_TOKEN",
)

modelo = cliente.models.list().data[0].id

r = cliente.chat.completions.create(
    model=modelo,
    messages=[{"role": "user", "content": "escreva um hello world em go"}],
)
print(r.choices[0].message.content)

Streaming (stream=True) e chamada de ferramenta (tools) funcionam como na OpenAI.

Quantas chamadas ao mesmo tempo

Janela aberta e parada não ocupa nada: o limite só vale enquanto o modelo está de fato gerando resposta.

Os números existem pra garantir velocidade, não pra racionar. A máquina sustenta 32 chamadas simultaneas no total mantendo pelo menos 60 tokens por segundo em cada uma; acima disso a velocidade de todo mundo cai sem ninguém ganhar nada. O teto de 4 por acesso é o que impede um script paralelo de ocupar a máquina inteira enquanto os outros esperam.

Se você recebeu 429, a resposta traz o cabeçalho Retry-After com quantos segundos esperar. Tratar isso é uma linha na maioria das bibliotecas, e é o comportamento certo.

Quanto o modelo pensa antes de responder

O modelo principal raciocina antes de responder, e esse raciocínio gasta orçamento de saída. Quanto ele pensa é controlado por reasoning_effort, e o instalador já grava o padrão da casa: medium.

Você pode mudar, e o que estiver no seu arquivo ganha — o servidor não mexe no que você manda.

opencode

Em ~/.config/opencode/opencode.json, dentro do modelo:

"provider": {{ "c2code": {{ "models": {{ "vllm_oss_120b": {{
  "options": {{ "reasoning_effort": "low" }}
}} }} }} }}

pi

Em ~/.pi/agent/models.json, no modelo:

"samplingParams": {{ "reasoning_effort": "low" }}

Claude Code, ou chamada na mao

E campo do corpo da requisicao:

"reasoning_effort": "low"

Se a resposta vier vazia, quase sempre é isto: o max_tokens apertado acabou dentro do raciocínio. O certo não é aumentar o teto — é pedir low.

Outros ajustes no seu config

O instalador grava um arquivo com os padrões da casa. Tudo ali é seu — o servidor lê só o token e o modelo; o resto é o seu cliente decidindo. Rodar o instalador de novo sobrescreve o arquivo, então anote o que você mudou.

Amostragem: quão previsível a resposta é

No opencode, em provider.c2code.models.vllm_oss_120b.options; no pi, em samplingParams. Nomes diferentes, mesma coisa:

Quanto do histórico sobrevive

A conversa cresce até estourar a janela; a compactação resume o que ficou para tras. No opencode, bloco compaction:

"compaction": {{
  "auto": true,              // resume sozinho quando aperta
  "prune": true,             // joga fora saída velha de ferramenta primeiro
  "tail_turns": 6,           // últimos N turnos ficam intactos
  "preserve_recent_tokens": 24000
}}

Se o modelo esquece o que você falou ha pouco, aumente preserve_recent_tokens. Se as sessões estão estourando contexto, diminua. No pi o campo equivalente é keepRecentTokens.

Quanto uma ferramenta pode devolver

"tool_output": {{ "max_lines": 500, "max_bytes": 20000 }}

Um cat de arquivo grande ou um log inteiro entrando cru é a forma mais rápida de estourar a janela sem o modelo ter lido nada útil. Aumente se o seu trabalho é ler arquivo grande de propósito.

Quantos passos por turno

"agent": {{ "build": {{ "steps": 80 }} }}

Quantas ações o agente encadeia antes de devolver a palavra. Baixo demais para tarefa longa no meio; alto demais deixa ele insistindo num caminho errado.

O que você pode barrar

"permission": {{ "bash": {{ "rm -rf *": "deny", "sed -i *": "deny" }} }}

Vem com esses dois negados porque são os que estragam arquivo em silêncio. Acrescente o que quiser — é o seu cliente, na sua máquina.

Se você editar e algo parar de funcionar

Apague o arquivo e rode o instalador de novo. Ele reescreve do zero com os padrões da casa.

O que o playground não faz

A página de teste no navegador é só conversa — nenhuma ferramenta ligada. Lá ele não executa comando, não lê nem cria arquivo, não recebe anexo, não gera arquivo pra download, não pesquisa na web e não lembra da conversa anterior.

Ele escreve e revisa código, explica erro que você colar e projeta solução. Para editar arquivos de verdade e rodar teste, use no seu editor com o opencode — e aí as ferramentas existem.

Quando der erro

Perguntas rapidas