> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Configuração do MCP

> Como adicionar, configurar e gerenciar servidores MCP

<div id="adding-mcp-servers">
  ## Como adicionar servidores MCP
</div>

<div id="via-command-line">
  ### Pela linha de comando
</div>

A maneira mais rápida de adicionar um servidor MCP:

```bash theme={null}
# servidor stdio — apenas passe o comando após --
devin mcp add <name> -- <command> [args...]

# servidor HTTP — passe a URL como argumento posicional
devin mcp add <name> <URL>

# servidor HTTP — ou use a flag --url
devin mcp add <name> --url <URL>
```

O tipo de transporte é inferido automaticamente: uma URL implica HTTP (Streamable HTTP), e argumentos no final (ou `--command`) implicam stdio.

<Note>Servidores MCP remotos usam Streamable HTTP por padrão. Se o servidor responder com um erro HTTP 4xx, a CLI recorre a SSE na mesma URL. Defina `"transport": "sse"` explicitamente, se necessário — veja [fallback legado para SSE](#legacy-sse-fallback) abaixo.</Note>

Por padrão, os servidores são salvos no escopo **local** (`.devin/config.local.json`, ignorado pelo git). Use `-s`/`--scope` para alterar:

```bash theme={null}
devin mcp add -s project <name> <URL>   # compartilhado via .devin/config.json
devin mcp add -s user <name> <URL>      # global (~/.config/devin/config.json; %APPDATA%\devin\config.json no Windows)
```

Você também pode gerenciar servidores pela linha de comando:

```bash theme={null}
devin mcp list              # List all configured servers
devin mcp get <name>        # Show details for a specific server
devin mcp remove <name>     # Remove a configured server
devin mcp login <name>      # Authenticate with a server via OAuth
devin mcp logout <name>     # Remove stored OAuth credentials
devin mcp enable <name>     # Ativar um servidor desativado
devin mcp disable <name>    # Desativar um servidor sem removê-lo
```

<div id="via-config-file">
  ### Via arquivo de configuração
</div>

Adicione servidores diretamente à seção `mcpServers` do seu arquivo de configuração:

<Tabs>
  <Tab title="Configuração do projeto">
    ```json theme={null}
    // .devin/config.json
    {
      "mcpServers": {
        "server-name": {
          "command": "npx",
          "args": ["-y", "@company/mcp-server"],
          "env": {
            "API_KEY": "your-key"
          }
        }
      }
    }
    ```

    <Note>Os servidores no nível do projeto são compartilhados com sua equipe por meio do controle de versão.</Note>
  </Tab>

  <Tab title="Configuração do usuário">
    ```json theme={null}
    // ~/.config/devin/config.json
    {
      "mcpServers": {
        "my-server": {
          "command": "node",
          "args": ["/path/to/my-server.js"],
          "env": {}
        }
      }
    }
    ```

    <Note>Os servidores no nível do usuário se aplicam a todos os seus projetos.</Note>
  </Tab>

  <Tab title="Override local">
    ```json theme={null}
    // .devin/config.local.json
    {
      "mcpServers": {
        "server-name": {
          "command": "npx",
          "args": ["-y", "@company/mcp-server"],
          "env": {
            "API_KEY": "my-personal-key"
          }
        }
      }
    }
    ```

    <Note>As configurações locais não são rastreadas pelo Git — use-as para chaves de API pessoais.</Note>
  </Tab>
</Tabs>

***

<div id="server-configuration-options">
  ## Opções de configuração de servidor
</div>

Os servidores MCP podem ser configurados de duas formas: como um **comando local** (transporte stdio) ou como um **servidor remoto** (transporte HTTP).

<div id="local-command-stdio">
  ### Comando local (stdio)
</div>

| Campo      | Tipo      | Obrigatório | Descrição                                                                                                                   |
| ---------- | --------- | ----------- | --------------------------------------------------------------------------------------------------------------------------- |
| `command`  | string    | Sim         | O executável que será executado                                                                                             |
| `args`     | string\[] | Não         | Argumentos de linha de comando                                                                                              |
| `env`      | object    | Não         | Variáveis de ambiente a definir                                                                                             |
| `disabled` | boolean   | Não         | Defina como `true` para pular este servidor (consulte [Ativando e desativando servidores](#enabling-and-disabling-servers)) |

<div id="remote-server-streamable-http">
  ### Servidor remoto (Streamable HTTP)
</div>

| Campo               | Tipo    | Obrigatório | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ------------------- | ------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url`               | string  | Sim         | A URL do endpoint do servidor MCP                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transport`         | string  | Não         | `"http"` (Streamable HTTP, padrão para servidores baseados em URL) ou `"sse"` (SSE legado). Quando definido como `"http"` ou omitido, a CLI tenta primeiro Streamable HTTP e recorre ao SSE em caso de erros 4xx ([conforme a especificação](https://spec.modelcontextprotocol.io/specification/2025-03-26/basic/transports/#backwards-compatibility)). Defina `"sse"` explicitamente se o endpoint SSE do servidor estiver em um caminho diferente. |
| `headers`           | object  | Não         | Cabeçalhos HTTP personalizados para incluir nas requisições                                                                                                                                                                                                                                                                                                                                                                                          |
| `oauthClientId`     | string  | Não         | ID do cliente OAuth pré-registrado, para servidores que não oferecem suporte ao registro dinâmico de clientes (DCR), por exemplo, GitHub. Consulte a seção "Clientes OAuth pré-registrados" abaixo.                                                                                                                                                                                                                                                  |
| `oauthClientSecret` | string  | Não         | Segredo do cliente OAuth, para clientes confidenciais. Use em conjunto com `oauthClientId`.                                                                                                                                                                                                                                                                                                                                                          |
| `disabled`          | boolean | Não         | Defina como `true` para pular este servidor (consulte [Ativando e desativando servidores](#enabling-and-disabling-servers))                                                                                                                                                                                                                                                                                                                          |

<div id="examples">
  ### Exemplos
</div>

<AccordionGroup>
  <Accordion title="GitHub (stdio)">
    ```json theme={null}
    {
      "mcpServers": {
        "github": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-github"],
          "env": {
            "GITHUB_TOKEN": "ghp_..."
          }
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="Notion (HTTP com OAuth)">
    ```json theme={null}
    {
      "mcpServers": {
        "notion": {
          "url": "https://mcp.notion.com/mcp",
          "transport": "http"
        }
      }
    }
    ```

    <Note>Depois de adicionar um servidor com OAuth, execute `devin mcp login notion` para se autenticar. Consulte [Autenticação](#authentication) abaixo.</Note>
  </Accordion>

  <Accordion title="Linear (HTTP com OAuth)">
    ```json theme={null}
    {
      "mcpServers": {
        "linear": {
          "url": "https://mcp.linear.app/mcp",
          "transport": "http"
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="Atlassian / Jira (HTTP com OAuth)">
    ```json theme={null}
    {
      "mcpServers": {
        "atlassian": {
          "url": "https://mcp.atlassian.com/v1/mcp",
          "transport": "http"
        }
      }
    }
    ```

    <Note>Depois de adicionar, execute `devin mcp login atlassian` para se autenticar. Cada cliente MCP (Windsurf, Claude Code, Devin CLI) mantém sua própria sessão OAuth, então você precisa fazer login separadamente, mesmo que já tenha se autenticado em outra ferramenta.</Note>
  </Accordion>

  <Accordion title="Servidor personalizado (stdio)">
    ```json theme={null}
    {
      "mcpServers": {
        "my-tools": {
          "command": "python",
          "args": ["./scripts/mcp-server.py"],
          "env": {
            "DB_URL": "postgres://localhost/mydb"
          }
        }
      }
    }
    ```
  </Accordion>
</AccordionGroup>

***

<div id="authentication">
  ## Autenticação
</div>

Alguns servidores MCP remotos exigem autenticação OAuth. Depois de adicionar um servidor com autenticação OAuth à sua configuração, autentique-se usando o comando `login`:

```bash theme={null}
devin mcp login <server-name>
```

Por exemplo:

```bash theme={null}
devin mcp login notion    # Autenticar com o Notion
devin mcp login linear    # Autenticar com o Linear
```

Isso abre uma janela do navegador na qual você pode autorizar o acesso. Os tokens OAuth são armazenados localmente e atualizados automaticamente.

Se quiser, você pode solicitar escopos específicos do OAuth:

```bash theme={null}
devin mcp login notion --scopes read,write
```

Para remover credenciais OAuth armazenadas para um servidor:

```bash theme={null}
devin mcp logout <server-name>
```

<Note>
  Se o servidor oferecer suporte a OAuth, você também receberá automaticamente uma solicitação para se autenticar quando o servidor for usado pela primeira vez.
</Note>

<div id="pre-registered-oauth-clients">
  ### Clientes OAuth pré-registrados
</div>

A maioria dos servidores MCP baseados em OAuth oferece suporte ao [registro dinâmico de clientes](https://datatracker.ietf.org/doc/html/rfc7591) (DCR), então o Devin CLI se registra automaticamente e você não precisa fornecer nenhuma credencial de cliente.

Alguns provedores (por exemplo, GitHub) não oferecem suporte a DCR e, em vez disso, exigem um cliente OAuth **pré-registrado**. Nesses casos, informe o ID do cliente — e o client secret, se for um cliente confidencial — por meio de `oauthClientId` / `oauthClientSecret`:

```json theme={null}
{
  "mcpServers": {
    "my-server": {
      "url": "https://mcp.example.com/mcp",
      "transport": "http",
      "oauthClientId": "Iv1.abc123def456",
      "oauthClientSecret": "${env:MY_MCP_CLIENT_SECRET}"
    }
  }
}
```

Quando `oauthClientId` é definido, o Devin CLI não faz o registro dinâmico do cliente e usa o cliente pré-registrado por você durante o fluxo do OAuth. Execute `devin mcp login <name>` (ou acione o primeiro uso) para se autenticar normalmente.

Você também pode defini-los pela linha de comando ao adicionar um servidor ou fazer login nele:

```bash theme={null}
devin mcp add my-server <URL> --oauth-client-id <ID> --oauth-client-secret <SECRET>
devin mcp login my-server --oauth-client-id <ID> --oauth-client-secret <SECRET>
```

<Note>
  `oauthClientId` / `oauthClientSecret` são credenciais de cliente OAuth usadas durante o fluxo de autorização. **Não** são credenciais genéricas para cada requisição — se um servidor espera um token estático, use `headers` (HTTP) ou `env` (stdio).
</Note>

<Warning>
  Não faça commit de um client secret em uma configuração compartilhada. Referencie-o a partir de uma variável de ambiente (`${env:VAR}`), leia-o de um arquivo (`${file:/path}`) ou coloque-o em `.devin/config.local.json` (incluído no `.gitignore`). Consulte a seção "Gerenciando segredos" abaixo.
</Warning>

***

<div id="enabling-and-disabling-servers">
  ## Ativando e desativando servidores
</div>

Você pode desativar temporariamente um servidor MCP sem remover sua configuração. Um servidor desativado é ignorado durante a descoberta de ferramentas — suas ferramentas não aparecerão, e o processo do servidor não será iniciado.

```bash theme={null}
devin mcp disable <name>    # Desativar um servidor
devin mcp enable <name>     # Reativá-lo
```

Isso define a flag `"disabled": true` na entrada do servidor no arquivo de configuração. Use `-s`/`--scope` para selecionar um escopo específico:

```bash theme={null}
devin mcp disable -s project my-server
devin mcp enable -s user my-server
```

Também é possível definir a flag diretamente no arquivo de configuração:

```json theme={null}
{
  "mcpServers": {
    "my-server": {
      "command": "npx",
      "args": ["-y", "@company/mcp-server"],
      "disabled": true
    }
  }
}
```

<Note>Desabilitar é útil quando você quer manter a configuração de um servidor (incluindo variáveis de ambiente e credenciais OAuth), mas deixar de usá-lo temporariamente — por exemplo, para reduzir o tempo de inicialização ou isolar um problema.</Note>

***

<div id="managing-secrets">
  ## Gerenciando segredos
</div>

<Warning>
  Nunca faça commit de Chaves de API ou segredos no controle de versão. Use `.devin/config.local.json` para armazenar valores sensíveis.
</Warning>

Para projetos em equipe, o padrão recomendado é:

1. Defina o servidor em `.devin/config.json` com marcadores de posição ou sem variáveis de ambiente
2. Cada membro da equipe adiciona suas chaves pessoais em `.devin/config.local.json`

O arquivo de configuração local é automaticamente excluído do Git.

***

<div id="mcp-permissions">
  ## Permissões do MCP
</div>

Você pode aprovar previamente, negar ou exigir confirmação para ferramentas específicas do MCP na sua configuração de permissões:

```json theme={null}
{
  "permissions": {
    "allow": [
      "mcp__github__list_issues",
      "mcp__github__create_issue"
    ],
    "deny": [
      "mcp__github__delete_repo"
    ],
    "ask": [
      "mcp__linear__*"
    ]
  }
}
```

**Padrões de correspondência de permissão:**

| Padrão              | Corresponde a                                       |
| ------------------- | --------------------------------------------------- |
| `mcp__server__tool` | Uma ferramenta específica em um servidor específico |
| `mcp__server__*`    | Todas as ferramentas em um servidor específico      |
| `mcp__*`            | Todas as ferramentas MCP em todos os servidores     |

***

<div id="organization-restrictions">
  ## Restrições da organização
</div>

Se você faz parte de uma equipe Enterprise, seu administrador pode restringir a quais servidores MCP você pode se conectar. Um servidor que você configurou pode ser bloqueado se o MCP estiver desativado para a sua equipe ou se ele não estiver na lista de permissões da equipe nem em um **registro de MCP** aplicado — nesse caso, ele não se conectará e suas ferramentas não ficarão disponíveis. Consulte [Configurações da equipe — registro de MCP](/pt-BR/cli/enterprise/team-settings#mcp-registry) para mais detalhes.

***

<div id="troubleshooting">
  ## Solução de problemas
</div>

<AccordionGroup>
  <Accordion title="Autenticação necessária / erros de OAuth com servidores remotos">
    Se você vir erros como `Auth required` ou `AuthRequired` ao se conectar a um servidor MCP remoto, isso significa que o servidor exige autenticação OAuth.

    Execute:

    ```bash theme={null}
    devin mcp login <server-name>
    ```

    Cada cliente MCP se autentica de forma independente. Mesmo que você já tenha se autenticado no Windsurf ou no Claude Code, é preciso executar `devin mcp login` separadamente no Devin CLI.

    Para verificar seu status de autenticação, tente remover e adicionar as credenciais novamente:

    ```bash theme={null}
    devin mcp logout <server-name>
    devin mcp login <server-name>
    ```
  </Accordion>

  <Accordion title="O servidor não inicia">
    Verifique se o comando funciona fora do Devin CLI:

    ```bash theme={null}
    npx -y @modelcontextprotocol/server-github
    ```

    Confira se todas as variáveis de ambiente obrigatórias estão definidas.
  </Accordion>

  <Accordion title="Ferramentas não aparecem">
    Peça ao agente para listar os servidores MCP e as ferramentas. O servidor pode precisar de alguns instantes para inicializar.
  </Accordion>

  <Accordion title="Permissão negada">
    Verifique a configuração das suas permissões. Por padrão, as ferramentas MCP pedem aprovação. Adicione-as a `permissions.allow` para aprová-las automaticamente.
  </Accordion>

  <Accordion title="fallback legado para SSE">
    Ao se conectar a um servidor HTTP, o Devin CLI tenta primeiro **Streamable HTTP**. Se o servidor responder com um erro HTTP 4xx (por exemplo, 404 ou 405), ele recorre automaticamente a **SSE legado** na **mesma URL configurada**. Isso segue a [orientação de retrocompatibilidade da spec do MCP](https://spec.modelcontextprotocol.io/specification/2025-03-26/basic/transports/#backwards-compatibility).

    O fallback só é acionado em respostas 4xx — erros de conexão, timeouts e respostas 5xx são reportados diretamente, sem tentativa de SSE.

    Se o endpoint de SSE do seu servidor estiver em um caminho diferente (por exemplo, `/sse` em vez de `/mcp`), defina `"transport": "sse"` com a URL de SSE para se conectar diretamente, sem tentar Streamable HTTP antes.

    Se ambos os transportes falharem, a mensagem de erro incluirá detalhes das duas tentativas para ajudar na solução de problemas.
  </Accordion>
</AccordionGroup>