# Elixir in Maguyva: Code-Graphen für Phoenix- und OTP-Apps

Canonical source: https://maguyva.ai/de/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).

Maguyva unterstützt Elixir mit AST, Symbolen und Graph, damit KI-Agenten Module, Behaviours, Protokolle und Structs über Phoenix- und OTP-Code hinweg verfolgen.

## Unterstützungsüberblick

- Stufe: AST- und Symbol-Support
- Programmierung
- Dateiendungen: .ex, .exs
- Echtes AST-Parsing für syntaxbewusste Suche und strukturellen Kontext.
- Benannte Symbole speisen semantisches Lookup und Cross-Referenzierung. Graph-Navigation ist verfügbar, wenn die Beziehungsextraktion aktiviert ist.
- Diese Sprache liefert Symbole und Beziehungen für die graphgestützte Suche; die unterstützten Kantentypen variieren je nach nativen Konstrukten der Sprache.
- AST-Parsing und Symbolextraktion sind beide verfügbar.

## Am besten geeignet

- Phoenix-Anwendungen, in denen Controller, LiveViews, Contexts und Ecto-Schemas sich über viele Module hinweg aufrufen.
- OTP-Systeme aus GenServern, Supervisors und Tasks.
- Bibliotheken und Umbrella-Projekte mit Protokollen, die für viele Typen implementiert sind.

## Agentenabläufe

- Alle Aufrufer einer Context-Funktion finden, bevor sich die Form ihres Rückgabewerts ändert.
- Auflisten, welche Module ein Behaviour oder Protokoll implementieren, bevor ein Callback hinzukommt.
- Einen Request vom Phoenix-Controller bis in die Ecto-Schicht verfolgen.

## Wo Elixir oberflächliche KI-Tools ins Stolpern bringt

Fast alles in Elixir ist ein Makroaufruf. `defmodule`, `def`, `use`, `alias` und `@impl` werden alle als Aufrufe geparst, und `use GenServer` bringt Verhalten mit, das nie in der Datei steht. Ein Tool, das nur die Aufrufsyntax sieht, kann eine Definition nicht von einer Abhängigkeit unterscheiden und einen GenServer-Callback nicht von einem Helfer.

Maguyva bildet diese Makros auf Beziehungen ab, damit ein Agent sieht, welche Module ein Behaviour implementieren und wer eine Context-Funktion aufruft.

## Was Maguyva in Elixir extrahiert

Maguyva deckt `.ex`- und `.exs`-Dateien ab. Die Makros von Elixir werden so auf Beziehungen abgebildet:

- `alias`, `import` und `require` erfassen Importe.
- `use` erfasst einen Import. Bei OTP- und Framework-Behaviours wie `GenServer`, `Supervisor`, `Agent`, `Task`, `Phoenix.Controller`, `Phoenix.LiveView` und `Ecto.Schema` wird zusätzlich erfasst, dass das Modul dieses Behaviour implementiert.
- `@behaviour`-Attribute und `defimpl`-Blöcke erfassen die Implementierung eines Behaviours oder Protokolls.
- Reservierte Modulattribute wie `@doc`, `@spec`, `@impl` und `@callback` werden als Annotationen der folgenden Funktion erfasst. Wertattribute wie `@timeout 5_000` nicht.
- `%User{}`-Struct-Literale zählen als Instanziierung, `raise` erfasst ein Throw, `rescue` und `catch` erfassen ein Catch.

Sprachmakros wie `def`, `defp`, `defmodule`, `case` und `with` werden aus den Aufrufen gefiltert, sodass der Aufrufgraph deine Funktionen zeigt.

## Beispiel-Prompts für Agenten

- „Wer ruft `Accounts.register_user` auf, und aus welchen Controllern?“ (`find_symbol`, dann `dependency_search` incoming)
- „Welche Module implementieren `GenServer`?“ (`dependency_search`)
- „Verfolge einen Checkout-Request vom Controller bis zur Datenbank.“ (`get_task_context`)

## Bekannte Grenzen

- Benannte `def`-, `defmodule`-, `alias`- und `import`-Formen sind in der Grammatik Aufrufknoten. Deshalb liefert in `structural_search` nur das Preset `functions` Ergebnisse, und zwar nur für anonyme `fn`-Funktionen. Verwende `find_symbol` für benannte Funktionen und Module.
- Etwa 55 Aufrufe der Standardbibliothek, etwa `IO.puts`, `String.*`, `Enum.take` und `Process.*`, werden aus den Beziehungen gefiltert. Verwende dafür `text_pattern_search`.
- Elixir kennt keine Klassenvererbung, daher sind Vererbungsbeziehungen als nicht anwendbar markiert.

## Nächste Schritte

Verbinde ein Repository über den [Schnellstart](/de/docs/quickstart) und prüfe dann die Unterstützungsmatrix auf der [Kompatibilitätsseite](/de/docs/compatibility). Für andere funktionale Codebasen lies den [Haskell-Leitfaden](/de/languages/haskell).

## Engine-Einordnung

- Die Elixir-Unterstützung umfasst `.ex` und `.exs`. `alias`, `import`, `require` und `use` erfassen Importe.
- `use GenServer` und andere gelistete OTP- und Framework-Behaviours, `@behaviour` und `defimpl` erfassen Implementierungsbeziehungen.
- Reservierte Attribute wie `@spec` und `@impl` annotieren die nächste Funktion, und `%Struct{}`-Literale zählen als Instanziierung.

## Nützliche MCP-Einstiegspunkte

- `find_symbol`: Nutz es für eine Context-Funktion oder ein Modul, wenn du Definition und Aufrufer brauchst; strukturelle Presets wählen keine benannten `def`-Formen aus.
- `dependency_search`: Nutz die eingehende Traversierung auf einem Behaviour oder Protokoll, um zu sehen, welche Module es implementieren.
- `get_task_context`: Nutz es für Prompts wie „verfolge einen Checkout-Request vom Controller bis zur Datenbank“.