# Elixir no Maguyva: grafos de código para apps Phoenix e OTP

Canonical source: https://maguyva.ai/pt-br/languages/elixir

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).

O Maguyva oferece suporte a Elixir com AST, símbolos e grafo, para que agentes de IA sigam módulos, behaviours, protocolos e structs em código Phoenix e OTP.

## Panorama de suporte

- Nível: Suporte a AST e símbolos
- Programação
- Extensões: .ex, .exs
- Parsing real de AST para busca com consciência de sintaxe e contexto estrutural.
- Símbolos nomeados alimentam a busca semântica e as referências cruzadas. A navegação por grafo fica disponível quando a extração de relações está habilitada.
- Esta linguagem fornece símbolos e relações para a busca orientada por grafo; os tipos de aresta compatíveis variam de acordo com seus construtos nativos.
- A análise de AST e a extração de símbolos estão disponíveis.

## Uso ideal

- Aplicações Phoenix em que controllers, LiveViews, contextos e schemas do Ecto chamam uns aos outros em muitos módulos.
- Sistemas OTP construídos com GenServers, supervisores e tasks.
- Bibliotecas e projetos umbrella com protocolos implementados para muitos tipos.

## Fluxos de trabalho de agente

- Encontrar todos os chamadores de uma função de contexto antes de mudar o formato do seu retorno.
- Listar quais módulos implementam um behaviour ou protocolo antes de adicionar um callback.
- Rastrear uma requisição de um controller Phoenix até a camada do Ecto.

## Onde Elixir derruba ferramentas de IA superficiais

Quase tudo em Elixir é uma chamada de macro. `defmodule`, `def`, `use`, `alias` e `@impl` são analisados como chamadas, e `use GenServer` traz comportamento que nunca aparece no arquivo. Uma ferramenta que só vê a sintaxe de chamada não distingue uma definição de uma dependência, nem um callback de GenServer de um helper.

O Maguyva transforma essas macros em relações, para que um agente veja quais módulos implementam um behaviour e quem chama uma função de contexto.

## O que o Maguyva extrai em Elixir

O Maguyva cobre arquivos `.ex` e `.exs`. As macros do Elixir viram relações:

- `alias`, `import` e `require` registram imports.
- `use` registra um import. Para behaviours de OTP e de frameworks como `GenServer`, `Supervisor`, `Agent`, `Task`, `Phoenix.Controller`, `Phoenix.LiveView` e `Ecto.Schema`, também registra que o módulo implementa esse behaviour.
- Atributos `@behaviour` e blocos `defimpl` registram a implementação de um behaviour ou protocolo.
- Atributos de módulo reservados como `@doc`, `@spec`, `@impl` e `@callback` são registrados como anotações da função seguinte. Atributos de valor como `@timeout 5_000` não são.
- Literais de struct `%User{}` contam como instanciação, `raise` registra um throw, e `rescue` e `catch` registram um catch.

Macros da linguagem como `def`, `defp`, `defmodule`, `case` e `with` são filtradas das chamadas, então o grafo de chamadas mostra as suas funções.

## Exemplos de prompts para agentes

- "Quem chama `Accounts.register_user`, e de quais controllers?" (`find_symbol`, depois `dependency_search` incoming)
- "Quais módulos implementam `GenServer`?" (`dependency_search`)
- "Rastreie uma requisição de checkout do controller até o banco de dados." (`get_task_context`)

## Limitações conhecidas

- As formas nomeadas `def`, `defmodule`, `alias` e `import` são nós de chamada na gramática, então em `structural_search` só o preset `functions` retorna resultados, e apenas para funções `fn` anônimas. Use `find_symbol` para funções e módulos nomeados.
- Cerca de 55 chamadas da biblioteca padrão, como `IO.puts`, `String.*`, `Enum.take` e `Process.*`, são filtradas das relações. Use `text_pattern_search` para encontrá-las.
- Elixir não tem herança de classes, então as relações de herança estão marcadas como não aplicáveis.

## Próximos passos

Conecte um repositório pelo [início rápido](/pt-br/docs/quickstart) e depois confira a matriz de suporte na [página de compatibilidade](/pt-br/docs/compatibility). Para outras bases de código funcionais, leia o [guia de Haskell](/pt-br/languages/haskell).

## Detalhes do motor

- O suporte a Elixir cobre `.ex` e `.exs`. `alias`, `import`, `require` e `use` registram imports.
- `use GenServer` e outros behaviours de OTP e de frameworks da lista, `@behaviour` e `defimpl` registram relações de implementação.
- Atributos reservados como `@spec` e `@impl` anotam a função seguinte, e literais `%Struct{}` contam como instanciação.

## Pontos de entrada MCP úteis

- `find_symbol`: Use para uma função de contexto ou módulo quando precisar da definição e dos chamadores; os presets estruturais não selecionam formas `def` nomeadas.
- `dependency_search`: Use a travessia incoming em um behaviour ou protocolo para ver quais módulos o implementam.
- `get_task_context`: Use para prompts como "rastreie uma requisição de checkout do controller até o banco de dados".