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

# MCP Servers

> Conecte servidores MCP upstream ao Toqan Router com descoberta automática de ferramentas e exponha as ferramentas deles a Agents e MCP Gateways com listas de permissão.

Consulte [URLs e autenticação HTTP](/docs/pt-BR/reference/base-urls.md) e a referência da API para os formatos completos de solicitação e resposta.

Conecte servidores [Model Context Protocol](https://modelcontextprotocol.io) upstream ao **Toqan Router**. Depois da conexão, a descoberta de ferramentas acontece automaticamente e as ferramentas ficam disponíveis para **Agents** e **Gateways**.

> [!NOTE]
>
> Estes são **MCP Servers** de terceiros aos quais o Toqan Router se conecta. Trata-se de uma funcionalidade diferente do servidor MCP do próprio Toqan Router, ao qual os assistentes de programação se conectam para administrar o workspace.

O **MCP Portal** é a área do **AI Gateway** que gerencia **MCP Servers** e **MCP Gateways**.

## Casos de uso

* Conectar ferramentas SaaS de terceiros (Slack, Linear, Figma etc.) a agentes sem escrever integrações personalizadas.
* Expor APIs internas como ferramentas que os agentes podem chamar.
* Centralizar o gerenciamento de servidores MCP em vez de configurar conexões por ferramenta ou por agente.
* Compartilhar um único servidor MCP entre vários agentes e MCP Gateways, com controle sobre a exposição das ferramentas.

## Como funciona

Cada MCP Server registra um endpoint upstream. O **Toqan Router** se conecta a ele, descobre as ferramentas disponíveis e acompanha o estado da sincronização. As ferramentas podem ser expostas a todos os agentes, filtradas por uma lista de permissão ou ocultadas completamente.

Quando um servidor é vinculado a um MCP Gateway, o gateway roteia as chamadas de ferramentas e cuida da autenticação, para que os clientes precisem apenas da URL do gateway.

### Schemas de ferramentas

Os schemas de entrada das ferramentas são validados a cada sincronização.

**Dialetos suportados**: JSON Schema 2020-12 quando o schema omite `$schema`; declarações explícitas de draft-04, draft-06, draft-07, 2019-09 e 2020-12 são aceitas.

| Limite | Valor |
| - | - |
| Tamanho do schema | 256 KiB |
| Profundidade de aninhamento | 64 níveis |
| Nós por schema | 10.000 |

Uma sincronização falha quando há um schema de entrada ausente ou inválido, um dialeto não suportado ou um schema acima de um limite. O erro identifica a ferramenta e o campo do schema; corrija o schema upstream e sincronize novamente.

`$defs` e referências locais são resolvidos dentro do documento; uma referência a outro arquivo ou URL é bloqueada. Os schemas OpenAPI importados mantêm suas restrições, e um corpo de requisição que não pode se tornar argumentos de ferramenta planos permanece sob um argumento `body` ou `request_body`.

## Lista de MCP Servers

Abra **AI Gateway > MCP Portal** na barra lateral. A aba **MCP Servers** lista todos os servidores registrados, com uma linha por servidor:

* **Connection**: a chave do servidor, com o logotipo do provedor quando o servidor vem do catálogo
* **Tools**: a quantidade de ferramentas da última sincronização
* **Access**: quais projetos podem usar o servidor
* **Synced at**: quando o servidor foi sincronizado pela última vez
* **Created by**: o membro do workspace que o adicionou

> [!NOTE]
>
> As conexões MCP eram criadas anteriormente como uma **MCP Tool** em **Create Tools**. Esse tipo de ferramenta foi descontinuado, e as MCP Tools existentes agora aparecem aqui no **MCP Portal**.

## Configurar um MCP Server

Selecione **Create** na aba **MCP Servers**. A página de criação oferece três pontos de partida:

* **OpenAPI**: transforma uma API REST que publica um documento OpenAPI em ferramentas. Consulte [Criar a partir de uma especificação OpenAPI](#create-from-an-openapi-specification).
* **MCP URL**: conecta um servidor MCP existente pelo endpoint dele.
* **Catalog**: um provedor pré-configurado. Selecionar um deles preenche a URL de conexão e a autenticação esperada.

O restante desta seção aborda o caminho **MCP URL**.

1. **Preencha os detalhes gerais.**
   * **Key** (obrigatório): letras minúsculas, dígitos, `-` e `_`, com até 64 caracteres. Serve de prefixo para os nomes das ferramentas em um MCP Gateway e define `display_name`. A API também exige `default_tool_exposure`.
   * **Description** (opcional): uma observação sobre o que este servidor oferece.

2. **Defina a conexão.**
   * **Type**: **HTTP** (padrão) ou **SSE** para servidores com suporte a streaming.
   * **URL** (obrigatório): o endpoint do servidor MCP upstream.

3. **Configure a autenticação.**

   * **None** (padrão): para servidores públicos que não exigem credenciais.
   * **Static Headers**: envia headers fixos em todas as requisições. Os valores dos headers são armazenados criptografados e nunca são retornados pela API. Um placeholder `{{variable}}` mantém um valor fora do armazenamento: o servidor armazena apenas o nome, e o valor é fornecido quando o servidor é testado, sincronizado ou quando uma ferramenta é chamada. Os valores dos placeholders não são persistidos. Para expor recursos deste servidor em um **MCP Gateway**, forneça os mesmos valores de variáveis em cada requisição ao gateway em `params._meta["orq.ai/discoveryVariables"]`, indexados pelo MCP Server ID. Isso exige acesso de gerenciamento de MCP Servers em todo o workspace.
   * **OAuth Client Credentials**: autentica em um servidor de autorização OAuth 2.0 upstream usando o grant de client credentials. Preencha **Client ID**, **Client secret**, **Token URL** e, opcionalmente, **Scopes**. O secret é armazenado criptografado e nunca é retornado pela API. Consulte [Como funciona o OAuth Client Credentials](#how-oauth-client-credentials-works). Essa credencial é separada do fluxo OAuth que os clientes MCP usam para se conectar a um **MCP Gateway**.
   * **Per-user OAuth**: cada usuário conecta a própria conta pelo fluxo OAuth authorization code, e as chamadas de ferramentas são executadas com o token desse usuário. As configurações do cliente são opcionais e ficam em **Advanced configuration**. A opção aparece para conexões HTTP e SSE. Consulte [OAuth por usuário](#per-user-oauth).
   * **Enterprise managed (ID-JAG)**: chama o servidor por meio de um **MCP Gateway** em nome de cada usuário de SSO. A opção aparece quando o plano do workspace inclui SSO e a conexão não é OpenAPI. Ative o Cross App Access antes de depender dela: sem ele, o formulário avisa que as chamadas de ferramentas falham até que um administrador o habilite. Consulte [Autorização gerenciada pela empresa](#enterprise-managed-authorization).

4. **Teste a conexão.** Clique em **Test connection** para verificar o servidor antes de salvar. Para **Enterprise managed (ID-JAG)**, isso verifica a descoberta de autorização sem solicitar um token de usuário nem listar ferramentas. Os outros tipos de autenticação validam a conexão e retornam as ferramentas descobertas.

5. Clique em <kbd>Create</kbd>.

### Como funciona o OAuth Client Credentials

O **Toqan Router** gera um token de acesso quando precisa de um, nunca em intervalos programados:

* Quando **Test connection** é executado.
* Quando o servidor sincroniza suas ferramentas.
* Quando uma ferramenta é executada por um **Agent** ou um **MCP Gateway**.

Cada token é armazenado criptografado com a chave do workspace e reutilizado até ficar perto da expiração.

| Situação | O que acontece |
| - | - |
| O servidor de autorização retorna `expires_in` | O token é renovado 30 segundos antes de expirar. |
| O servidor de autorização omite `expires_in` | O token é reutilizado por 5 minutos. |
| Renovação | O grant de client credentials não tem refresh token, então o **Toqan Router** troca o mesmo **Client ID** e **Client secret** por um novo token. Nada precisa ser rotacionado manualmente. |

Os tokens não são compartilhados entre **MCP Servers**. Cada servidor mantém seu próprio token e sua própria conexão upstream, e uma alteração nas configurações de conexão ou de autenticação substitui o token.

Os **Scopes** são opcionais e separados por espaços. O **Toqan Router** os envia como o parâmetro `scope` na requisição de token (`auth.oauth.scopes` na API). Quando o endpoint de token recusa as credenciais, as chamadas de ferramentas por um **MCP Gateway** falham com `UPSTREAM_CREDENTIALS_UNAVAILABLE` e a resposta do endpoint, e **Test connection** e a sincronização reportam a mesma mensagem.

> [!NOTE]
>
> O endpoint de token deve responder diretamente via `https`, a partir de um host acessível pela internet pública, e redirecionamentos a partir da **Token URL** são recusados. A mesma regra se aplica à URL do servidor: requisições para redes privadas, de loopback e link-local são recusadas. Um **MCP Gateway** não tem lista de domínios permitidos, então a regra da internet pública é a única restrição de saída.

### OAuth por usuário

Use **Per-user OAuth** quando cada usuário precisar agir no servidor upstream com a própria conta. O **Toqan Router** executa o fluxo OAuth authorization code com PKCE uma vez por usuário e armazena os tokens de cada usuário separadamente. As chamadas de ferramentas de **Agents** e **MCP Gateways** usam então o token do usuário que fez a chamada.

Selecione **Per-user OAuth** em **Authentication**. Todos os campos do cliente são opcionais e ficam em **Advanced configuration**:

| Campo | Valor |
| - | - |
| **Client ID** | Um cliente pré-registrado no servidor de autorização upstream. Deixe em branco para que o **Toqan Router** registre um cliente automaticamente, por meio de um Client ID Metadata Document quando o servidor de autorização oferecer suporte, ou por registro dinâmico de cliente nos demais casos. |
| **Client secret** | O secret de um cliente confidencial pré-registrado. Exige um **Client ID**. |
| **Authorization server issuer** | Obrigatório quando um **Client ID** é definido. Fixa a descoberta nesse issuer. |
| **Resource URL** | O identificador de recurso publicado pelo servidor upstream. Deixe em branco para usar a URL do servidor. Precisa usar o mesmo esquema, host e porta efetiva da URL do servidor. |
| **Scopes** | Scopes opcionais a solicitar, separados por espaços. |

**Test connection** verifica se o servidor de autorização pode ser descoberto e, quando definido, se o issuer corresponde. Ele não conecta uma conta nem lista ferramentas. Use URLs fixas tanto em **URL** quanto em **Resource URL**: servidores por usuário rejeitam placeholders `{{variable}}` em qualquer um desses campos.

Em requisições à API, defina `auth.type` como `MCP_AUTH_TYPE_PER_USER_OAUTH` e, opcionalmente, informe `auth.oauth` com `client_id`, `client_secret`, `issuer`, `resource` e `scopes`. `token_url` é rejeitado, já que o endpoint de token é descoberto a partir do recurso. Consulte [Criar um MCP server](/docs/pt-BR/reference/mcp-gateway/create-an-mcp-server.md).

**Conectar uma conta**

* **Pela página de detalhes do servidor**: clique em **Connect account** e conclua o login no servidor upstream. A página passa a mostrar **Connected** e sincroniza as ferramentas do servidor. Quando uma conexão armazenada para de funcionar, o botão passa a exibir **Reconnect account**.
* **Por um Agent**: um servidor por usuário anexado e sem conexão mostra **Connect account** na configuração do **Agent**. Uma execução de **Agent** que chega ao servidor sem conexão falha com `Connect your account to this MCP server before using it.`
* **Por um MCP Gateway**: quando o usuário que faz a chamada não tem conexão, o gateway pede ao cliente MCP que abra um link de conexão (`Connect your account for <server>`). Clientes sem suporte a URL elicitation recebem o link em um erro de ferramenta. O link abre uma página **Connect account** que lista o servidor, o recurso, o cliente e os scopes. Clique em **Continue** para autorizar ou em **Decline** para interromper a operação pendente e, em seguida, repita a requisição pelo cliente. Requisições sem identidade de usuário falham com `This server requires a signed-in user connection.`

**Gerenciar conexões**

Abra **AI Gateway** → **Connections** para listar as conexões de contas com **Server**, **Scopes** e **Status** (**Connected**, **Connected via SSO**, **Disconnected** ou **Reconnect required**). Clique em **Disconnect** para deixar de usar uma conta; ela pode ser reconectada depois. As linhas de [autorização gerenciada pela empresa](#enterprise-managed-authorization) mostram **Connected via SSO** enquanto ativas e oferecem **Revoke token**, que descarta o token armazenado para que um novo seja solicitado por SSO na próxima chamada. Administradores podem alternar entre **My connections** e **All users**. O menu de detalhes do servidor também oferece **Disconnect account** para o usuário conectado.

### Autorização gerenciada pela empresa

Use **Enterprise managed** quando o provedor de identidade da organização controlar quais usuários podem acessar um **MCP Server** upstream. O **MCP Gateway** troca um identity assertion grant (ID-JAG) desse provedor por um token de acesso de usuário no servidor de autorização do servidor. Os usuários fazem login por SSO sem um fluxo de consentimento separado para cada servidor upstream.

Uma organização cujo provedor de identidade não consegue emitir ID-JAGs usa [OAuth por usuário](#per-user-oauth): cada usuário conecta a própria conta upstream, sem uma conexão SSO nem uma alteração no provedor de identidade.

Configure o Cross App Access em uma conexão SSO habilitada antes de criar, duplicar ou alterar um servidor para **Enterprise managed**. O provedor de identidade precisa suportar a emissão de ID-JAG. O servidor upstream precisa publicar metadados de recurso protegido OAuth, e seu servidor de autorização precisa aceitar ID-JAGs pelo grant JWT bearer. O suporte a SSO por si só não atende a esses requisitos.

Selecione **Enterprise managed (ID-JAG)** em **Authentication** e preencha:

| Campo | Valor |
| - | - |
| **Client ID** | O cliente OAuth registrado no servidor de autorização do servidor upstream. |
| **Client secret** | O secret desse cliente. Ao editar, deixe em branco para manter o secret armazenado se o client ID não tiver mudado. Insira um novo secret ao alterar o client ID. |
| **Scopes** | Scopes opcionais a solicitar, separados por espaços. |
| **Authorization server issuer** (em **Advanced configuration**) | Opcional. Fixa a descoberta nesse issuer; **Test connection** falha quando o servidor de autorização do servidor é outro. |
| **Resource URL** (em **Advanced configuration**) | O identificador de recurso publicado pelo servidor upstream. Deixe em branco para usar a URL do servidor. Ele precisa usar o mesmo esquema, host e porta efetiva da URL do servidor. |

Essas credenciais de cliente pertencem ao servidor de autorização upstream. Configure o cliente do provedor de identidade separadamente nas configurações de SSO. O **Toqan Router** descobre o endpoint de token upstream automaticamente e armazena o client secret criptografado.

Para requisições à API, defina `auth.type` como `MCP_AUTH_TYPE_ENTERPRISE_MANAGED` e forneça `auth.oauth` com `client_id`, `client_secret` e, opcionalmente, `resource` e `scopes`, o mesmo objeto usado pelo OAuth Client Credentials, sem `token_url`. O objeto `auth.enterprise` anterior foi substituído: requisições que ainda o enviam são aceitas (`auth.oauth` prevalece quando ambos estão presentes), e as respostas o retornam ao lado de `auth.oauth` até que ele seja removido. Consulte [Criar um servidor MCP](/docs/pt-BR/reference/mcp-gateway/create-an-mcp-server.md).

Use URLs fixas tanto em **URL** quanto em **Resource URL**. Servidores gerenciados pela empresa rejeitam placeholders `{{variable}}` em qualquer um desses campos.

Depois de salvar, faça login por SSO e sincronize o servidor para descobrir suas ferramentas. Use **Run tool** para verificar o acesso com a identidade do usuário conectado. Um **Test connection** bem-sucedido confirma apenas a descoberta; ele não confirma que as credenciais do cliente funcionam nem que o provedor de identidade permite o acesso.

### Solucionar problemas da autorização gerenciada pela empresa

| Erro ou sintoma | Ação |
| - | - |
| **Enterprise managed** não está disponível no formulário | Habilite uma conexão SSO e ative o Cross App Access. |
| `ENTERPRISE_AUTH_REAUTH_REQUIRED` ou `reauth_required` | Faça login por SSO novamente. Logins feitos antes da habilitação do Cross App Access não carregam a identity assertion necessária. Verifique o grant de Refresh Token do provedor de identidade se o acesso falhar novamente após a expiração do login. |
| `ENTERPRISE_AUTH_REQUIRES_USER` | Conecte-se como um usuário de SSO por meio do OAuth do gateway ou de uma chave de API pertencente a um usuário. Chaves de contas de serviço e chaves geradas por federação não podem autorizar chamadas de ferramentas gerenciadas pela empresa. |
| `ENTERPRISE_AUTH_POLICY_DENIED` | Verifique a atribuição de aplicativo e a política de acesso do usuário no provedor de identidade. |
| `ENTERPRISE_AUTH_IDP_CLIENT_REJECTED` | Verifique as credenciais do cliente nas configurações de SSO. |
| `ENTERPRISE_AUTH_CLIENT_REJECTED` | Verifique as credenciais do cliente no **MCP Server**. |
| `ENTERPRISE_AUTH_METADATA_UNAVAILABLE` ou `ENTERPRISE_AUTH_UNSUPPORTED` | Verifique a URL do recurso, a disponibilidade dos metadados e o suporte a ID-JAG do servidor de autorização upstream. |
| `ENTERPRISE_AUTH_TEMPORARILY_UNAVAILABLE` ou `ENTERPRISE_AUTH_RATE_LIMITED` | Tente novamente em instantes. |

## Criar a partir de uma especificação OpenAPI

Transforme uma API REST que publica um documento OpenAPI em um **MCP Server** sem precisar escrever ou hospedar um. Cada operação selecionada se torna uma ferramenta, e chamar a ferramenta envia a requisição HTTP para a API.

1. Selecione **Create** na aba **MCP Servers** e, em seguida, **Create** no card **OpenAPI**.
2. Em **Specification**, escolha uma **Source**:
   * **URL**: o endereço do documento. **Sync** o busca novamente para obter as alterações.
   * **Paste or upload**: um documento JSON ou YAML. O documento não é armazenado, então alterar as ferramentas depois exige carregar o documento novamente em **Settings**.
3. Clique em **Load operations** e selecione as operações a expor. As operações que não podem se tornar ferramentas são listadas em **Skipped operations**, com o motivo.
4. Verifique a **Base URL**: as requisições são enviadas para ela. Ela é preenchida a partir da primeira entrada de `servers` do documento.
5. Configure a **Authentication** com **None**, **Static Headers** (por exemplo, um header de chave de API ou `Authorization: Bearer {{token}}`) ou **OAuth Client Credentials**.
6. Clique em <kbd>Create</kbd>. As ferramentas ficam disponíveis imediatamente; não há nada para sincronizar.

| OpenAPI | Ferramenta |
| - | - |
| `operationId` | Nome da ferramenta; o método e o caminho quando não houver um. Limitado a letras, dígitos, `_` e `-`, com no máximo 64 caracteres |
| `summary` e `description` | Descrição da ferramenta |
| Parâmetros de caminho, query, header e cookie | Argumentos |
| Corpo de requisição JSON | Suas propriedades como argumentos, ou um único argumento `body` quando elas colidem com um parâmetro ou o corpo não é um objeto simples |
| `GET` e `HEAD` | Indicação de somente leitura |
| `DELETE` | Indicação de ação destrutiva |

O corpo da resposta é retornado como resultado da ferramenta. Uma resposta com status 400 ou superior é retornada como um erro de ferramenta que inclui o status e o corpo.

Limites:

* OpenAPI 3.0, 3.1 e 3.2. Documentos Swagger 2.0 são rejeitados.
* Apenas corpos de requisição JSON.
* No máximo 300 ferramentas por servidor e um documento de 10 MB.
* `$ref` para outros arquivos ou URLs não é seguido; as operações que usam um são ignoradas.
* A autenticação **Enterprise managed** não está disponível.
* As exportações para IDEs chegam aos servidores OpenAPI apenas por meio de um **MCP Gateway**.

Pela API, defina `connection.type` como `MCP_CONNECTION_TYPE_OPENAPI`, `connection.url` como a URL base e `openapi` como `document` ou `document_url`. `openapi.operations` lista os nomes das ferramentas a expor; deixe-o vazio para expor todas as operações.

```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
curl -X POST https://router.toqan.ai/eu/v2/mcp-servers \
  -H "Authorization: Bearer $TOQAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "petstore",
    "display_name": "petstore",
    "connection": {
      "type": "MCP_CONNECTION_TYPE_OPENAPI",
      "url": "https://petstore3.swagger.io/api/v3"
    },
    "auth": { "type": "MCP_AUTH_TYPE_NONE" },
    "default_tool_exposure": { "mode": "MCP_TOOL_EXPOSURE_MODE_ALL" },
    "openapi": {
      "document_url": "https://petstore3.swagger.io/api/v3/openapi.json",
      "operations": ["getPetById", "findPetsByStatus"]
    }
  }'
```

## Após a criação

Abra **Explorer** para navegar pelas **Tools**, **Skills** e **Resources** do servidor. As três abas aparecem em todos os servidores. **Resources** inclui tanto recursos individuais quanto templates de URI. Abra **Overview** para ver o status da sincronização e o tráfego, ou **Settings** para a conexão, a autenticação e o acesso por projeto.

Na página de detalhes do servidor:

* **Veja as ferramentas descobertas** em **Explorer → Tools**. Selecione uma ferramenta à esquerda para inspecionar sua descrição, argumentos e schema à direita. Use **Filters** para encontrar ferramentas **Read only**, **Destructive**, **Idempotent** ou **Open world**.
* **Inspecione o conteúdo dos recursos** em **Explorer → Resources**. Selecione um recurso para ler seu conteúdo atual. Para um template, informe os parâmetros e selecione **Read resource**. Use **Refresh** para lê-lo novamente. Para um MCP App, inspecione o HTML em **Source** e abra uma ferramenta relacionada para ver as entradas que ela aceita.
* **Controle a exposição das ferramentas** quando o servidor estiver vinculado a um **MCP Gateway**: marque as caixas de seleção das ferramentas na aba **MCP Servers** do gateway (consulte MCP Gateways). A exposição também aceita um filtro **read-only** na API. Ele mantém apenas as ferramentas que o servidor upstream anota como somente leitura (`readOnlyHint`). O gateway confia nessa anotação e não verifica o que a ferramenta faz.
* **Teste uma ferramenta** preenchendo os argumentos e clicando em **Run tool**. O teste invoca a ferramenta no servidor upstream e mostra a resposta.
* Selecione **Sync** em **Explorer** para atualizar o catálogo do servidor. As ferramentas recém-descobertas aparecem em **Tools**, e as ferramentas descobertas anteriormente que estão ausentes são marcadas como `MISSING`.
* Abra o menu da linha para **Sync**, **Edit** ou **Delete**. O menu de detalhes também oferece **Share**, para copiar o link da página, e **Duplicate**, para reutilizar a conexão e as configurações de ferramentas com uma nova chave.
* **Configure o acesso por projeto** na aba **Settings**. Em **Access control**, escolha **All projects** para compartilhar o servidor com todo o workspace, ou **Custom** e defina cada projeto como **Enabled** ou **Disabled**. Um **MCP Gateway** só pode vincular servidores cujo acesso por projeto o inclua.

As funções que podem criar, editar e excluir MCP Servers estão listadas em Funções e permissões.

## Excluir um servidor

Primeiro, desvincule o servidor de todos os **MCP Gateways**: a exclusão de um servidor que ainda está vinculado a um **MCP Gateway** falha.

> [tab] AI Studio
>
> Na aba **MCP Servers** do **MCP Gateway**, abra o menu da linha do servidor e escolha **Remove from gateway**.
>
> Em seguida, exclua o servidor pelo item **Delete** no menu da linha da lista de servidores, pelo item **Delete** no menu adicional da página de detalhes ou pelo botão <kbd>Delete Server</kbd> no rodapé do formulário **Settings**. Cada um pede confirmação.

> [tab] API e SDK
>
> **1. Desvincule o servidor**
>
> Leia os vínculos atuais do gateway com [GET /v2/mcp-gateways/{id}](/docs/pt-BR/reference/mcp-gateway/retrieve-an-mcp-gateway.md) e, em seguida, faça [PATCH /v2/mcp-gateways/{id}](/docs/pt-BR/reference/mcp-gateway/update-an-mcp-gateway.md) com `server_links` definido como os vínculos sem este servidor. Um array `server_links` vazio não altera nada, então, quando este servidor for o único vínculo do gateway, envie `clear_server_links: true`, o que desvincula todos os servidores do gateway. Cada entrada contém `mcp_server_id`, `alias` e `tool_exposure`. Consulte MCP Gateways para as regras de `server_links`.
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
> curl -X PATCH https://router.toqan.ai/eu/v2/mcp-gateways/<gateway-id> \
>   -H "Authorization: Bearer $TOQAN_API_KEY" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "server_links": [
>       {
>         "mcp_server_id": "mcp_server_01JQ0K5R8N2ZC7X4M9T3V6HWBE",
>         "alias": "weather",
>         "tool_exposure": { "mode": "MCP_TOOL_EXPOSURE_MODE_ALL" }
>       }
>     ]
>   }'
> ```
>
> **2. Exclua o servidor**
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
> curl -X DELETE https://router.toqan.ai/eu/v2/mcp-servers/<server-id> \
>   -H "Authorization: Bearer $TOQAN_API_KEY"
> ```
>
> > [!TIP]
> >
> > Consulte a [referência completa da API para excluir um servidor MCP](/docs/pt-BR/reference/mcp-gateway/delete-an-mcp-server.md).

## Monitorar o uso

A aba **Overview** reporta o uso de ferramentas do servidor, agregado em todos os **MCP Gateways** que o expõem. Ela abre nos últimos 7 dias, e o selo ao lado do título mostra o estado da sincronização, a quantidade de ferramentas descobertas e o horário da última sincronização.

Os cards e gráficos correspondem aos do **Overview** do gateway. Consulte Monitorar o uso para saber o que cada um mede. O escopo é diferente: esses números abrangem o servidor em todos os gateways aos quais ele está vinculado, em vez de um único gateway.

**Performance** adiciona **Tool latency**, P50 e P95 no período, e **Calls by gateway**, com a participação de cada gateway.

## Anexar a um Gateway

Vincule um servidor a um **MCP Gateway** para agrupá-lo com outros servidores por trás de um único endpoint voltado aos clientes. Consulte MCP Gateway para mais detalhes.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.