Exograph

Local CodeQL-style code search for Elixir, backed by Postgres and ExAST.

Exograph indexes Elixir source code into normalized Ecto/Postgres tables: files, AST fragments, comments, definitions, references, package versions, and optional Reach call graph facts. You can then query that index with structural AST patterns, text search, symbol/reference filters, and Ecto-shaped joins.

Exograph was originally built to stress-test Reach and ExAST on larger real-world codebases and Hex package sets. It is now a reusable local/self-hosted code intelligence layer for Elixir tooling.

What is Exograph?

Exograph is:

• a library for indexing Elixir source code into Postgres
• a set of Ecto schemas and migrations for normalized code facts
• a structural search engine using ExAST for exact AST verification
• an optional Reach-backed call graph index
• a foundation for CodeQL-like Elixir queries over one project or many package versions

Exograph is not currently:

• a hosted search service
• a language server
• a general multi-language analyzer
• a replacement for ExAST or Reach

Why?

Use Exograph when text search is not enough:

• find functions matching an AST shape
• search definitions and references across packages
• ask “which private functions call Repo.transaction/1?”
• index multiple Hex package versions into one database
• combine relational filters with exact ExAST verification
• persist Reach call graph facts for caller/callee queries

Installation

def deps do
  [
    {:exograph, "~> 0.4"}
  ]
end

Exograph currently requires Postgres. ParadeDB's pg_search extension is optional and enables BM25-backed text/code-fact retrieval.

Quickstart

Point Exograph at Elixir source and an Ecto repo:

{:ok, index} =
  Exograph.index("lib",
    repo: MyApp.Repo,
    migrate?: true
  )

{:ok, hits} = Exograph.search(index, "Repo.get!(_, _)")

Exograph uses Postgres for candidate retrieval and ExAST for exact structural verification.

Web UI

Exograph includes an embedded web interface for exploring indexes:

mix exograph.web --prefix myindex --port 4200

Features:

• Monaco editor with Elixir syntax highlighting and autocompletion
• Structural and full-text search modes
• IDE-style error diagnostics
• Collapsible results grouped by package with code previews
• Hex.pm links on package names

JSON API

The web server also exposes a JSON API:

POST /api/search   — structural or text search
POST /api/query    — DSL query execution
GET  /api/packages — list indexed packages
GET  /api/stats    — index statistics

Cursor pagination via cursor/next_cursor. Rate limited (60 req/min).

Query with code facts

Use Exograph.DSL when you want to combine structural AST patterns with indexed facts such as references or call edges:

import Exograph.DSL

query =
  from(f in Fragment,
    join: r in assoc(f, :references),
    where: r.qualified_name == "Repo.transaction/1",
    where: matches(f, "def _ do ... end")
  )

{:ok, hits} = Exograph.all(index, query)

Reach call graph facts can also be queried directly:

Exograph.search_callers(index, "Repo.transaction/1")
Exograph.search_callees(index, "MyApp.Accounts.update_user/2")

How it compares

Features

• ExAST-backed structural search with exact verification
• normalized Ecto/Postgres storage for files, fragments, comments, definitions, references, packages, versions, and call edges
• package/version-scoped indexes for Hex or other source archives
• optional Reach call graph extraction
• optional ParadeDB BM25 text/fact retrieval
• ExDNA-powered structural similarity
• Mix tasks for indexing and searching

Documentation

Status

Exograph is early-stage. The current focus is a reliable Postgres-backed index and query layer for Elixir-specific code intelligence.

The core design is stable:

• ExAST remains the semantic authority for structural matches
• Reach is an optional semantic extractor
• Postgres is the built-in production backend
• ParadeDB is optional acceleration for text/code-fact search

License

MIT.