MCP (Model Context Protocol) é um protocolo aberto que descreve como conectar ferramentas externas e fontes de dados ao modelo de linguagem: um sistema de arquivos, documentação, rastreador de tarefas, rastreador de bugs ou seu próprio serviço. Em vez de incorporar cada ferramenta ao agente, você configura um servidor MCP separado e o agente se comunica com ele de acordo com o esquema padrão.
OpenCode oferece suporte a MCP pronto para uso: tanto servidores locais, que são iniciados por um processo filho, quanto servidores remotos, acessíveis via HTTP. Um ponto importante é que toda a camada MCP é implementada do lado do próprio OpenCode, e não do lado do provedor do modelo. Portanto, o DeepSeek recebe ferramentas MCP como funções normais na solicitação, e não precisa saber nada sobre o protocolo em si.
Neste post, veremos como adicionar um servidor local e remoto, como obter autorização, como não se afogar em tokens e o que considerar ao trabalhar com modelos DeepSeek.
O que você precisa
Para funcionar você precisa de três coisas:
- OpenCode instalado. Se o agente ainda não estiver configurado, discuti o procedimento para instalar e conectar o DeepSeek em uma nota separada.
- Node.js e npx. Necessário para servidores MCP locais, que são distribuídos como pacotes npm.
- Chaves de acesso. Somente para servidores remotos que requerem autorização. Servidores públicos como o Context7 funcionam sem chave, mas com limites mais baixos.
Como funciona
Os servidores são descritos na configuração do OpenCode no bloco mcp. Cada servidor possui um nome exclusivo pelo qual pode ser mencionado em uma solicitação. As ferramentas do servidor são registradas com esse prefixo de nome, portanto, não há conflitos entre servidores diferentes.
Após a conexão, as ferramentas MCP ficam disponíveis para os modelos junto com as integradas: leitura de arquivos, edição de código e execução de comandos. Do ponto de vista do DeepSeek, essas são funções comuns que um agente pode chamar – e é por isso que o pacote funciona sem qualquer suporte MCP no lado da API do modelo.
Servidor local
A maneira mais fácil de se familiarizar com o mecanismo é o servidor de teste @modelcontextprotocol/server-everything. Vamos adicioná-lo ao arquivo opencode.json na raiz do projeto:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"mcp_everything": {
"type": "local",
"command": ["npx", "-y", "@modelcontextprotocol/server-everything"]
}
}
}
O campo comando é o comando de inicialização do servidor e seus argumentos na forma de um array. Após reiniciar o OpenCode, as ferramentas aparecerão na sessão e poderão ser solicitadas explicitamente:
используй инструмент mcp_everything, чтобы сложить 3 и 4
O servidor local possui vários campos mais úteis. environment define as variáveis de ambiente do processo, cwd – o diretório de trabalho, timeout – tempo limite da solicitação em milissegundos e enabled permite desabilitar temporariamente o servidor sem removê-lo da configuração.
Servidor remoto
Servidores remotos são mais convenientes: você não precisa executar nada localmente e podem ser acessados via URL. Um bom exemplo é o Context7, que procura documentação de biblioteca atualizada. Ele se conecta sem chave:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"context7": {
"type": "remote",
"url": "https://mcp.context7.com/mcp"
}
}
}
Se você possui uma conta Context7 gratuita, o segredo é aumentar os limites. Os cabeçalhos são transmitidos através do bloco headers e é conveniente manter a própria chave em uma variável de ambiente:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"context7": {
"type": "remote",
"url": "https://mcp.context7.com/mcp",
"headers": {
"CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}"
}
}
}
}
A construção {env:NAME} substitui o valor da variável de ambiente ao carregar a configuração, para que a chave não acabe no repositório. Antes de iniciar o agente, a variável deve ser exportada no terminal.
Outro servidor público útil é o Grep da Vercel, procure exemplos de código no GitHub:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"gh_grep": {
"type": "remote",
"url": "https://mcp.grep.app"
}
}
}
Autorização via OAuth
Alguns servidores remotos requerem OAuth. O OpenCode pode passar por esse cenário sozinho: ele percebe a resposta 401, aciona a autorização e salva os tokens. Para Sentry, basta especificar o servidor:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"sentry": {
"type": "remote",
"url": "https://mcp.sentry.dev/mcp",
"oauth": {}
}
}
}
Depois disso, a autorização pode ser iniciada manualmente – o navegador será aberto:
opencode mcp auth sentry
Os comandos de serviço também são úteis no trabalho diário. opencode mcp list mostra servidores e status de autorização, opencode mcp logout exclui tokens armazenados e opencode mcp debug verifica a conectividade de rede e a descoberta OAuth para um servidor específico. Os tokens são armazenados localmente no arquivo ~/.local/share/opencode/mcp-auth.json.
Se o servidor não usar OAuth, mas uma chave de API normal, a autorização automática deverá ser desabilitada, caso contrário, o OpenCode tentará passar o OAuth onde não for necessário:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"my-api-key-server": {
"type": "remote",
"url": "https://mcp.example.com/mcp",
"oauth": false,
"headers": {
"Authorization": "Bearer {env:MY_API_KEY}"
}
}
}
}
Gerenciamento de ferramentas
As ferramentas MCP consomem contexto: cada servidor adiciona descrições de suas funções à solicitação. Portanto, é melhor manter desligados os servidores que raramente são necessários. Isso pode ser feito globalmente através do bloco tools:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"my-mcp-foo": {
"type": "local",
"command": ["npx", "-y", "my-mcp-command-foo"]
},
"my-mcp-bar": {
"type": "local",
"command": ["npx", "-y", "my-mcp-command-bar"]
}
},
"tools": {
"my-mcp*": false
}
}
O modelo my-mcp* desativa todas as ferramentas cujo nome começa com este prefixo. Se houver muitos servidores, faz mais sentido desativá-los globalmente e ativá-los localmente para um agente específico:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"my-mcp": {
"type": "local",
"command": ["npx", "-y", "my-mcp-command"],
"enabled": true
}
},
"tools": {
"my-mcp*": false
},
"agent": {
"my-agent": {
"tools": {
"my-mcp*": true
}
}
}
}
Recursos do DeepSeek
A conexão com o DeepSeek funciona porque os modelos suportam funções de chamada e as ferramentas MCP para eles parecem funções comuns. O próprio DeepSeek não conecta servidores MCP e não deveria: a conexão é controlada pelo OpenCode.
O que você deve prestar atenção:
- Selecionando um modelo. Para edições rotineiras e pequenas, deepseek-flash é suficiente. Para tarefas em que você precisa manter muito contexto em mente e selecionar cuidadosamente uma ferramenta, é melhor fornecer deepseek-v4-pro.
- Tamanho do contexto. Servidores pesados como o GitHub MCP adicionam muitos tokens e, junto com um projeto grande, atingem facilmente o limite. Ative-os apenas durante uma tarefa específica.
- Custo Os esquemas de ferramentas são enviados com cada solicitação, portanto, quanto mais servidores incluídos, mais cara será cada iteração. Você paga diretamente ao provedor, então os servidores extras ficam visíveis na sua conta.
- Dicas para o agente. É mais seguro não confiar na engenhosidade do modelo, mas nomear diretamente o servidor na solicitação ou escrever uma regra em AGENTS.md.
Um exemplo de regra para AGENTS.md, para que o próprio agente acesse a fonte necessária:
Когда нужно посмотреть документацию библиотеки, используй инструменты context7.
Receita prática
Para o trabalho diário, dois servidores geralmente são suficientes: Context7 para documentação e um servidor restrito para uma tarefa específica – por exemplo, Sentry para analisar erros ou Grep para procurar exemplos de código. É melhor manter o resto desligado e ligá-lo conforme necessário.
Meu procedimento é o seguinte: adiciono o servidor em opencode.json, reinicio o OpenCode, verifico a lista em opencode mcp list e faço uma pergunta de teste que menciona explicitamente o servidor. Se a ferramenta não for chamada, procuro opencode mcp debug e o tempo limite – um servidor lento pode não ter tempo para responder nos 30 segundos alocados.
No que prestar atenção
Alguns pontos práticos. Os servidores MCP são códigos confiáveis: o servidor local é executado em sua máquina com seus direitos e você envia dados de solicitação para o remoto. Portanto, a instalação de servidores aleatórios da Internet deve ser feita com o mesmo cuidado que qualquer CLI de terceiros.
Mantenha chaves e tokens em variáveis de ambiente e não faça commit no repositório. O OpenCode armazena tokens OAuth localmente, mas em uma máquina compartilhada também vale a pena considerar isso: opencode mcp logout os exclui quando o acesso não é mais necessário.
E mais uma coisa: não ligue tudo de uma vez. O MCP acrescenta ferramentas ao contexto, e contexto é dinheiro e qualidade de resposta. Dois ou três servidores realmente necessários funcionam muito melhor do que dez conectados, apenas para garantir.
Links
https://opencode.ai/docs/mcp-servers/
https://opencode.ai/docs/config/
https://modelcontextprotocol.io/
https://github.com/upstash/context7
https://mcp.sentry.dev
https://mcp.grep.app
https://github.com/anomalyco/opencode
Fontes
https://opencode.ai/docs/mcp-servers/
https://modelcontextprotocol.io/
https://api-docs.deepseek.com/
https://api-docs.deepseek.com/quick_start/agent_integrations/opencode
Leave a Reply