Comece a usar o C2Code

Oopencode instalar

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

curl -fsSL https://c2code.ia.br/opencode.sh | sh -s -- --token c2c_SEU_TOKEN

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

Atualizar depois

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

curl -fsSL https://c2code.ia.br/opencode.sh | sh

irm https://c2code.ia.br/opencode.ps1 | iex; Install-C2code

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

πpi instalar

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

curl -fsSL https://c2code.ia.br/pi.sh | sh -s -- --token c2c_SEU_TOKEN

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

Pra usar: pi abre a interface; pi -p "sua pergunta" faz uma pergunta só. Rode o mesmo comando de novo pra atualizar configs, skills e regras.

CClaude Code instalar

O Claude Code, da Anthropic, fala o protocolo dela — e o nosso servidor também: o mesmo modelo, na mesma máquina, responde nos dois.

curl -fsSL https://c2code.ia.br/claude.sh | sh -s -- --token c2c_SEU_TOKEN

irm https://c2code.ia.br/claude.ps1 | iex; Install-C2codeClaude -Token c2c_SEU_TOKEN

A configuração vai pra ~/.claude/settings.json — mesclada, não sobrescrita: permissões, hooks e statusline que você já tinha continuam lá; só o bloco env (e o c2code) são nossos. Se o Claude Code ainda não estiver instalado, o comando instala sozinho.

Junto vão as skills em ~/.claude/skills/, os subagentes em ~/.claude/agents/ e as regras da casa num bloco marcado do ~/.claude/CLAUDE.md. Pra atualizar, rode o mesmo comando sem token.

Sem instalador

Basta apontar a URL base — sem /v1 no fim. Não precisa dizer qual modelo usar: o servidor troca o nome pelo que a máquina está servindo.

export ANTHROPIC_BASE_URL=https://c2code.ia.br/anthropic
export ANTHROPIC_AUTH_TOKEN=c2c_SEU_TOKEN
claude

Pra deixar fixo, o mesmo vai no ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://c2code.ia.br/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "c2c_SEU_TOKEN"
  }
}

Configurar à mão

Se preferir não rodar instalador, tudo o que ele grava está disponível pra baixar com o seu token.

Config do opencode

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

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

Skills

pacote=$(mktemp)
curl -f -H "Authorization: Bearer c2c_SEU_TOKEN" \
     https://c2code.ia.br/me/skills.tar.gz -o "$pacote" \
  && rm -rf ~/.config/opencode/skill/c2code \
  && mkdir -p ~/.config/opencode/skill/c2code \
  && tar -xzf "$pacote" -C ~/.config/opencode/skill/c2code
rm -f "$pacote"

O rm -rf só roda se o download deu certo — e é ele que apaga a skill que saiu de circulação. A pasta é só do C2Code; as suas não são tocadas.

Comandos customizados

/update-c2code, /revisar, /verificar e /bug vão pra ~/.config/opencode/commands/ com prefixo c2code-, que separa os nossos dos seus:

pacote=$(mktemp)
curl -f -H "Authorization: Bearer c2c_SEU_TOKEN" \
     https://c2code.ia.br/me/commands.tar.gz -o "$pacote" \
  && rm -f ~/.config/opencode/commands/c2code-*.md \
  && mkdir -p ~/.config/opencode/commands \
  && tar -xzf "$pacote" -C ~/.config/opencode/commands
rm -f "$pacote"

pi e regras da casa

Do pi são dois arquivos: https://c2code.ia.br/me/pi/models.json vai inteiro pra ~/.pi/agent/, e de https://c2code.ia.br/me/pi/settings.json você copia as chaves pro seu. As regras da casa saem em https://c2code.ia.br/me/agents.md, prontas pra colar no AGENTS.md do seu agente.

{}Usar como API

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

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

from openai import OpenAI

cliente = OpenAI(
    base_url="https://c2code.ia.br/openai/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)

curl https://c2code.ia.br/openai/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/v1/models — ele muda quando trocamos o modelo, então leia de lá em vez de fixar no código. Streaming (stream=True) e chamada de ferramenta (tools) funcionam como na OpenAI.

Chamadas ao mesmo tempo

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

Os números existem pra garantir velocidade, não pra racionar. A máquina sustenta 32 chamadas simultâneas 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 por acesso impede um script paralelo de ocupar a máquina inteira enquanto os outros esperam.

Recebeu 429? A resposta traz o cabeçalho Retry-After com quantos segundos esperar. Tratar isso é uma linha na maioria das bibliotecas.

Quanto o modelo pensa

O modelo principal raciocina antes de responder, e esse raciocínio gasta orçamento de saída. Quem controla é o reasoning_effort; o instalador grava o padrão da casa, medium, e o que estiver no seu arquivo ganha.

"provider": { "c2code": { "models": { "c2code-premium": {
  "options": { "reasoning_effort": "low" }
} } } }

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

"reasoning_effort": "low"

Resposta vazia? Quase sempre 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 os padrões da casa. Tudo ali é seu — o servidor lê só o token e o modelo. Rodar o instalador de novo sobrescreve o arquivo, então anote o que você mudou.

Amostragem

No opencode, em provider.c2code.models.c2code-premium.options; no pi, em samplingParams.

Quanto do histórico sobrevive

"compaction": {
  "auto": true,
  "prune": true,
  "tail_turns": 6,
  "preserve_recent_tokens": 24000
}

Se o modelo esquece o que você falou há pouco, aumente preserve_recent_tokens. Se as sessões estouram o contexto, diminua. No pi o equivalente é keepRecentTokens.

Quanto uma ferramenta pode devolver

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

Um cat de arquivo grande entrando cru estoura 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 } }

Baixo demais para tarefa longa no meio; alto demais deixa o agente 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. Editou e parou de funcionar? Apague o arquivo e rode o instalador de novo.

O que o playground faz

Pra editar arquivos e rodar testes de verdade, use um agente no seu editor — aí as ferramentas existem.

Quando der erro

Reinstalar do zero

Erro estranho, que não está na lista acima? A saída mais confiável é desinstalar e instalar de novo: apaga configuração velha, cache e, se for o caso, o programa — e o instalador reconstrói tudo.

# apaga a configuração, as skills e os comandos que o instalador gravou
rm -rf ~/.config/opencode
# se o problema for no próprio programa (instalador oficial)
rm -rf ~/.opencode
# reinstala tudo
curl -fsSL https://c2code.ia.br/opencode.sh | sh -s -- --token c2c_SEU_TOKEN

# apaga a configuração, as skills e as regras que o instalador gravou
rm -rf ~/.pi/agent
# se o problema for no próprio programa
npm uninstall -g @earendil-works/pi-coding-agent
# reinstala tudo
curl -fsSL https://c2code.ia.br/pi.sh | sh -s -- --token c2c_SEU_TOKEN

# apaga a configuração, as skills e os subagentes que o instalador gravou
rm -rf ~/.claude
# se o problema for no próprio programa (instalador oficial)
rm -f ~/.local/bin/claude
# reinstala tudo
curl -fsSL https://c2code.ia.br/claude.sh | sh -s -- --token c2c_SEU_TOKEN

No Windows, apague o caminho equivalente em %USERPROFILE% e rode o .ps1 de cada agente, nas seções acima.

Perguntas rápidas