# Se fala MCP, fala Maguyva.

Canonical source: https://maguyva.ai/pt-br/for-anything

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

A integração não é por ferramenta — é o protocolo. O Maguyva é um servidor MCP padrão numa única URL, então qualquer ambiente em que o seu agente rode (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity, Zed, Cline, ou algo que você mesmo construiu) recebe o mesmo mapa consultável do seu repositório. Indexe uma vez, e todo cliente que você conectar faz as mesmas perguntas fundamentadas.

> Um servidor MCP. Todos os clientes. Sem plugin por ferramenta, sem lock-in.

## O que cada camada faz

Quatro peças. Cada uma com uma função.

### Qualquer cliente MCP

23 clientes documentados, incluindo Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, ou seu próprio agente.

### MCP

O padrão aberto que todos eles já falam.

### Maguyva

Um servidor MCP. Fatos do repositório, fundamentados, devolvidos com file:line.

### Por workspace, não por usuário

Agentes não geram cobranças por usuário. [Ver preços](https://maguyva.ai/pt-br/pricing)

## O MCP é a integração. Adote-o como padrão.

O protocolo aberto é a escolha certa, não um workaround. Construir sobre o [MCP](https://modelcontextprotocol.io/docs/getting-started/intro) em vez de um plugin por ferramenta é exatamente como você evita reintegrar toda vez que um agente melhor é lançado. É o lugar certo para:

- Um único bloco de configuração de servidor que funciona em qualquer cliente compatível.
- Ferramentas e recursos portáteis entre editores, CLIs e agentes.
- Um limite de integração que a sua equipe de segurança pode revisar uma vez só, não por fornecedor.
- Liberdade para trocar de cliente sem reconstruir a sua stack de contexto.

Continue fazendo isso. Padronizar no MCP é o caminho.

Mas um protocolo é um cano. Ele carrega a pergunta e a resposta — ele não *conhece* a sua base de código. Precisa ter algo do outro lado que de fato mapeie seus símbolos, call-sites e dependências.

## Onde o contexto por ferramenta para de escalar

Quatro modos de falha que nenhum arquivo de regras de um único agente consegue resolver.

### // toda ferramenta recomeça do zero

Escolha um agente novo e ele começa cego no seu repositório de novo. Você recola os mesmos arquivos, refixa o mesmo contexto, reescreve as mesmas regras. O trabalho não é transferido porque nunca foi uma camada compartilhada.

### // arquivos de regras não viajam

`CLAUDE.md`, `.cursor/rules`, `AGENTS.md` — cada um é por ferramenta, e nenhum é um índice consultável do seu código. Troque de cliente e o mapa que você construiu à mão fica para trás.

### // lock-in de integração é um imposto

Conectar contexto detalhado da base de código a um plugin de um único fornecedor significa que, no dia em que você testar outro agente, precisa reconstruir tudo. Quanto melhor o seu contexto, mais caro fica sair.

### // o protocolo é um cano, não um mapa

O MCP move ferramentas e contexto entre cliente e servidor. Ele não conhece seus símbolos, call-sites ou grafo de dependências. Precisa ter algo do outro lado que de fato responda à pergunta.

## O Maguyva é a camada do outro lado do protocolo

Não é outro agente. É o servidor de contexto de repositório que qualquer cliente MCP pode chamar:

- **Um endpoint, todo cliente**: o mesmo `https://maguyva.tools/mcp` atende Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, ou um script que você escreveu hoje de manhã.
- **Semântica + AST + grafo + texto**: busque por significado, estrutura, dependência ou literal. Cada resultado retorna um caminho de arquivo e número de linha, seja qual for o cliente que perguntou.
- **Contexto por branch, entre pacotes**: O Maguyva vê a versão do código que o agente está editando, em todos os pacotes do monorepo.
- **Sem lock-in**: troque de agente quando quiser; a camada de contexto não muda de lugar. Preço por workspace, não por usuário — indexe 1 repositório ou 50.

> O seu cliente fala MCP.
> O Maguyva é quem responde *quando ele pergunta sobre o seu código.*

## Três fluxos de trabalho, idênticos em qualquer cliente

Entre pacotes, entre linguagens. O cliente muda; a resposta fundamentada não.

### 01. Encontre o fluxo de auth entre pacotes, a partir de qualquer agente

```text
agent> onde acontece a autenticação nesse monorepo?

graph::query("authentication flow")
  packages/web/src/auth/session.ts:42       middleware
  packages/api/src/auth/jwt.ts:88           verificação do token
  packages/shared/src/auth/types.ts:12      AuthContext
  packages/admin/src/auth/admin-only.ts:31  controle RBAC

→ 4 pontos de entrada em 4 pacotes, ranqueados por densidade de call-sites.
[exit 0]
```

Claude Code, Cursor, ou o seu próprio script — não importa qual cliente enviou a consulta. Os mesmos quatro arquivos voltam na mesma ordem, fundamentados no grafo real.

### 02. Encontre a implementação real, não o stub de teste

```text
agent> como o normalizePhoneNumber trata o E.164?

semantic::query("normalize phone E.164")
  packages/shared/util/phone.ts:88     normalizePhoneNumber()  ← impl real
  packages/api/test/phone.spec.ts:14   jest.mock(...)          ← stub
[exit 0]
```

Nomes mentem. Mocks fazem sombra no código real. O Maguyva ranqueia a implementação real acima do mock de teste — do mesmo jeito para todo cliente que perguntar.

### 03. Confira o raio de impacto antes de uma refatoração

```text
agent> o que chama QueueDispatcher.publish em todo o monorepo?

graph::callers(QueueDispatcher.publish)
  3 em packages/billing/*
  1 em packages/audit/*
  1 em packages/notifications/*
  1 em services/python-worker/*  ← entre linguagens via stub gRPC
[exit 0]
```

Entre pacotes, e entre linguagens num repositório poliglota, os call-sites aparecem inline. Troque de agente amanhã e o raio de impacto continua lá, porque ele vive no servidor, não no cliente.

## Configuração com qualquer cliente MCP

Três passos. Plano Free: 3 repositórios, Até 50 mil linhas de repositório indexadas, sem cartão.

### 01. Indexe um repositório em maguyva.ai

Escolha um que você conheça bem para poder verificar as respostas. O Plano Free cobre 3 repositórios, Até 50 mil linhas de repositório indexadas.

### 02. Adicione o Maguyva como servidor MCP em qualquer cliente que você usar

```json
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}
```

### 03. Faça uma pergunta cuja resposta você já saiba

Comece com um repositório e uma pergunta verificável, tipo “o que chama `formatInvoice` entre pacotes?” Se a resposta bater com o que você diria, qualquer outro cliente que você apontar para ele vai receber o mesmo resultado fundamentado.

Instruções por cliente (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity e mais) ficam nos [docs de compatibilidade do Maguyva](https://maguyva.ai/pt-br/docs/compatibility).

## Indexe um repositório que você já conhece.

Conecte qualquer cliente MCP. Faça uma pergunta cuja resposta você consiga verificar.

## Fontes

- [MCP: introdução oficial](https://modelcontextprotocol.io/docs/getting-started/intro)
- [MCP: clientes de exemplo](https://modelcontextprotocol.io/clients)
- [Maguyva: compatibilidade e clientes](https://maguyva.ai/pt-br/docs/compatibility)
- [Maguyva: stack e segurança](https://maguyva.ai/pt-br/stack)
- [Maguyva: preços (por workspace, não por usuário)](https://maguyva.ai/pt-br/pricing)