Pular para o conteúdo principal
OpenCode é um agente de programação com IA (Coding Agent) open source voltado para desenvolvedores, com foco em uma experiência “nativa do terminal”: por meio de TUI/CLI, ele permite realizar fluxos de trabalho como discussão de requisitos, geração de código, refatoração, explicação e depuração diretamente na linha de comando. Ele enfatiza a independência de modelo, podendo se conectar a diversos serviços de modelos, como Claude, GPT e Gemini, além de oferecer suporte a interfaces locais ou compatíveis com OpenAI, facilitando a escolha entre custo, desempenho e privacidade. O OpenCode também fornece um mecanismo extensível de plugins/ferramentas e um sistema de configuração que permite incorporar contexto do projeto, execução de comandos e outras capacidades a fluxos automatizados, sendo adequado para usuários intensivos de terminal e equipes que desejam personalizar fluxos de trabalho de programação com IA.

Instalação e integração

Instalação

curl -fsSL https://opencode.ai/install | bash
Para outros métodos de instalação, consulte o site oficial do OpenCode: https://opencode.ai/docs/#install

Iniciar o OpenCode

cd /path/to/project  # 进入项目路径

opencode  # 启动 OpenCode

Integrar à JieKou API

  • Configuração global: ~/.config/opencode/opencode.json
  • Configuração do projeto: opencode.json no diretório raiz do projeto
(Se não houver um opencode.json, você pode criá-lo manualmente) A configuração é a seguinte:
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "JieKou",
      "options": {
        "baseURL": "https://api.highwayapi.ai/openai/v1"
      },
      "models": {
        "claude-sonnet-4-5-20250929": {
          "name": "claude-sonnet-4-5-20250929"
        },
        "gpt-5.2": {
          "name": "gpt-5.2"
        },
      }
    }
  }
}
Ao configurar um provedor de terceiros, é necessário escolher o pacote npm correto:
Pacote npmTipo de APICenário aplicável
@ai-sdk/openai-compatibleChat Completion APIGPT, Claude e a maioria dos outros modelos
@ai-sdk/openaiResponse APIModelos da série Codex
Observação: modelos Codex (como gpt-5.1-codex) precisam usar @ai-sdk/openai (Response API); outros modelos usam @ai-sdk/openai-compatible (Chat Completion API).

Configurar a KEY

Entre no opencode, use /connect para selecionar o provedor, preencha a API KEY e pressione enter para confirmar. opencode_input_api_key

Começar a usar

Após conectar o provedor, você pode usar o comando /models para selecionar o modelo. opencode_choose_model

Outros usos

Exemplo: configuração de MCP local (usando um MCP de cálculo como exemplo)

  1. Use python + MCP SDK para escrever o código do mcp server da calculadora e salve-o em um caminho local
import asyncio
import math
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

# Create server instance
server = Server("calculator")

@server.list_tools()
async def list_tools() -> list[Tool]:
    """List available calculator tools."""
    return [
        Tool(
            name="add",
            description="Add two numbers",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="subtract",
            description="Subtract second number from first number",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number to subtract"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="multiply",
            description="Multiply two numbers",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="divide",
            description="Divide first number by second number",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "Dividend"},
                    "b": {"type": "number", "description": "Divisor"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="power",
            description="Raise a number to a power",
            inputSchema={
                "type": "object",
                "properties": {
                    "base": {"type": "number", "description": "Base number"},
                    "exponent": {"type": "number", "description": "Exponent"},
                },
                "required": ["base", "exponent"],
            },
        ),
        Tool(
            name="sqrt",
            description="Calculate square root of a number",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "Number to calculate square root of"},
                },
                "required": ["a"],
            },
        ),
        Tool(
            name="modulo",
            description="Calculate remainder of division",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "Dividend"},
                    "b": {"type": "number", "description": "Divisor"},
                },
                "required": ["a", "b"],
            },
        ),
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    """Handle tool calls for calculator operations."""
    try:
        if name == "add":
            result = arguments["a"] + arguments["b"]
        elif name == "subtract":
            result = arguments["a"] - arguments["b"]
        elif name == "multiply":
            result = arguments["a"] * arguments["b"]
        elif name == "divide":
            if arguments["b"] == 0:
                return [TextContent(type="text", text="Error: Division by zero")]
            result = arguments["a"] / arguments["b"]
        elif name == "power":
            result = math.pow(arguments["base"], arguments["exponent"])
        elif name == "sqrt":
            if arguments["a"] < 0:
                return [TextContent(type="text", text="Error: Cannot calculate square root of negative number")]
            result = math.sqrt(arguments["a"])
        elif name == "modulo":
            if arguments["b"] == 0:
                return [TextContent(type="text", text="Error: Modulo by zero")]
            result = arguments["a"] % arguments["b"]
        else:
            return [TextContent(type="text", text=f"Error: Unknown tool '{name}'")]

        return [TextContent(type="text", text=str(result))]

    except Exception as e:
        return [TextContent(type="text", text=f"Error: {str(e)}")]

async def main():
    """Run the calculator MCP server."""
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

  1. Adicione o mcp local ao opencode.json
{
  "mcp": {
    "calc_mcp": {
      "type": "local",
      "command": ["python3", "{your_local_path}/calc_mcp.py"],
      "enabled": true
    }
  }
}
  1. Use /mcps para verificar o status da conexão do mcp. Quando estiver no estado Enabled, você pode solicitar que o opencode faça a chamada.
opencode_mcp