Assistente de código por IA — construindo ferramentas semelhantes ao Cursor com Claude e GPT

O cenário da IA para código, em resumo

Cursor, Aider, Cline, Continue.dev, o próprio Claude Code — todos se apoiam nos mesmos três ou quatro LLMs de fronteira. O diferencial não é o modelo; é o loop agêntico ao redor dele, a indexação de arquivos, a aplicação de diffs e a experiência do usuário. Se você está criando um desses produtos (ou um copiloto de programação dentro do seu próprio produto para desenvolvedores), esta página apresenta o menu de modelos, a realidade dos custos e o orçamento de latência.

Menu de modelos para fluxos de programação

• Claude Haiku 4.5 (claude-haiku-4-5) — autocompletar (~$0,0001-0.0005 por conclusão). O campeão de latência; tempo até o primeiro token em streaming compatível com uma chamada direta ao provedor
• Claude Sonnet 5 (claude-sonnet-5) — conversa com a base de código, edições em vários arquivos e loops agênticos. O modelo de trabalho no nível do Cursor, a $1,40 / $7,00 por 1M
• Claude Opus 5 (claude-opus-5) — revisão profunda, crítica de arquitetura e auditoria de segurança. Mais lento (P50 ~3s), mas o melhor raciocinador, a $3,50 / $17,50 por 1M
• GPT-5.6 Sol (gpt-5-6-sol) — modelo da OpenAI ajustado para código: qualidade comparável, preferências estilísticas diferentes

Os dois fluxos principais

import json
from openai import OpenAI
client = OpenAI(api_key="sk-kn-...", base_url="https://api.kunavo.com/v1")

# Code completion (autocomplete-as-you-type)
def complete(file_content: str, cursor_offset: int, file_path: str) -> str:
    before = file_content[:cursor_offset]
    after = file_content[cursor_offset:]
    resp = client.chat.completions.create(
        model="claude-haiku-4-5",   # FAST for IDE latency
        messages=[
            {"role": "system", "content": (
                "Complete the code at the cursor. Output ONLY the inserted "
                "text — no markdown, no explanation."
            )},
            {"role": "user", "content": (
                f"<file path=\"{file_path}\">\n{before}<CURSOR>{after}\n</file>"
            )},
        ],
        max_tokens=200,
        stop=["<CURSOR>", "</file>"],
    )
    return resp.choices[0].message.content

# Code review (heavier model). Claude enforces a json_schema
# response_format; json_object it does not.
REVIEW = {
    "type": "object",
    "properties": {
        "comments": {"type": "array", "items": {
            "type": "object",
            "properties": {"file": {"type": "string"},
                           "line": {"type": "integer"},
                           "comment": {"type": "string"}},
            "required": ["file", "line", "comment"],
            "additionalProperties": False,
        }},
        "verdict": {"type": "string", "enum": ["approve", "request_changes"]},
    },
    "required": ["comments", "verdict"],
    "additionalProperties": False,
}

def review(diff: str, conventions: str) -> dict:
    resp = client.chat.completions.create(
        model="claude-opus-5",
        messages=[
            {"role": "system", "content": [{
                "type": "text",
                "text": conventions,  # team style guide, security policy
                "cache_control": {"type": "ephemeral"},
            }]},
            {"role": "user", "content": f"Review this diff.\n\n{diff}"},
        ],
        response_format={"type": "json_schema",
                         "json_schema": {"name": "review", "schema": REVIEW}},
        max_tokens=2000,
    )
    return json.loads(resp.choices[0].message.content)

Orçamento de latência por recurso

• Autocompletar inline: TTFT deve ser <200ms. Claude Haiku 4.5. Transmita a saída e aborte quando o cursor se mover
• Conversa com a base de código: TTFT <500ms é aceitável. Sonnet + streaming. Mostre a resposta enquanto ela é gerada
• Edição/refatoração em vários arquivos: 5-30s é normal. Mostre o progresso, execute em segundo plano e apresente o diff para revisão
• Revisão de PR: 10-60s é aceitável. O Opus faz a análise profunda; formate como comentários acionáveis

Economia de custos de um produto de programação

Consumo realista por desenvolvedor por mês (usuário intenso):

• ~500 conclusões/dia × Haiku ~$0,0003 = $0,15/dia = $4-5/mês
• ~30 sessões de chat/dia × Sonnet ~$0,05 = $1,50/dia = $30-45/mês
• ~3 revisões de PR/semana × Opus ~$0,30 = $1/semana = $4/mês
• Usuário avançado intenso: ~$40-55/mês em custos de API
• Usuário médio: ~$10-15/mês

A maioria dos produtos de IA para programação cobra $20/usuário/mês — há margem, mas ela é apertada para usuários avançados. O cache de prompts é essencial: o contexto do workspace (estrutura de arquivos, convenções e arquivos recentes) vai para o cache; apenas o contexto da edição imediata é novo em cada chamada. Economiza 50-70% nas entradas. Como configurar o cache.

Padrões arquiteturais para copiar

• Prompting FIM (Fill-in-Middle): em vez de “complete a partir daqui”, passe before<CURSOR>after para que o modelo use os dois lados
• Sequências de parada: stop=["<CURSOR>", "</file>", "```\n"] impede que o modelo invente conteúdo além da conclusão solicitada
• Uso de ferramentas para edições em vários arquivos: não peça ao modelo para gerar 5 arquivos em uma única resposta. Use tools=[{name: 'edit_file', ...}] para que ele produza edições estruturadas que você aplica atomicamente
• Decodificação especulativa via streaming: mostre os primeiros ~50 tokens assim que chegarem; os usuários escolherão o correto mesmo antes de a resposta completa terminar

Troque de provedor em segundos

A Kunavo é compatível com o protocolo da OpenAI. Se você criou seu assistente com o SDK da OpenAI, troque base_url e terá acesso a Claude e GPT no mesmo código. Consulte Chamando Claude com o SDK da OpenAI para a migração.

Comece em: /app/signup — pagamento conforme o uso a partir de uma recarga de $10 (~30.000 chamadas de autocompletar), sem expiração do saldo. Referência do endpoint em /docs/chat e API Messages nativa da Anthropic em /docs/messages.

Perguntas frequentes