Contents

• Core Tools
• Machine Learning
  • Traditional Machine Learning
  • Deep Learning
  • Computer Vision
  • Vector Search & Similarity
• Generative AI
  • LLM Tools
  • Agent Frameworks
  • Development Tools
• Livebooks & Examples
• Resources
  • Books
  • Videos
  • Articles
  • Discussions

Core Tools

• Nx - Tensors for Elixir with compilation to CPU/GPU. It is the base for a lot of other libraries.
• Explorer - Series and dataframes for data exploration in Elixir.
• Livebook - Write interactive and collaborative notebooks, with integrations to databases, messaging, visualization and more.
• Kino - Render rich and interactive output. Used in Livebook.
• Pythonx - Embeds a Python interpreter directly into Elixir via NIF, running in the same OS process as the BEAM. Enables Elixir apps and Livebooks to call Python ML libraries directly.
• EMLX - Nx backend and compiler for Apple MLX. Runs Nx, Axon and Bumblebee on Apple Silicon GPUs.
• Emily - Alternative MLX-based Nx backend with fused transformer kernels, running Nx.Serving and Bumblebee on Metal.
• Handoff - Nx-compatible library for building and executing distributed DAGs of dependent functions across BEAM nodes, with per-node cost and allocation requirements.
• NxSignal - Digital signal processing on Nx: FFT, filters and spectrograms. The DSP layer Bumblebee's audio models build on.
• Tokenizers - Bindings to Hugging Face Tokenizers. The tokenization layer used by Bumblebee.

Machine Learning

Traditional Machine Learning

• Scholar - Traditional machine learning tools built on top of Nx. Implements algorithms for:
  • Classification
  • Regression
  • Clustering
  • Dimensionality reduction
  • Metrics and preprocessing
• EXGBoost - Decision Trees implemented using the XGBoost C API.
• Mockinjay - Implementation of Microsoft's Hummingbird library for converting trained Decision Tree models into Nx tensor computations.
• Soothsayer - Time series forecasting library inspired by Facebook's Prophet and NeuralProphet.
• Ulam - Elixir interface to Stan, a probabilist programming language.
• eXMC - Probabilistic programming on the BEAM inspired by PyMC: declarative models, NUTS sampling and Bayesian diagnostics on Nx tensors.

Deep Learning

• Axon - Neural Networks for Elixir. Built with Nx.
• Bumblebee - Pre-trained neural network models on top of Axon. Provides integration with Hugging Face.
• Ortex - Wrapper around ONNX. Enables you to run ONNX models using Nx.
• Edifice - Catalog of ready-to-use neural network architectures for Nx/Axon, from MLPs and transformers to Mamba, GNNs and VAEs, behind a uniform build API.
• LlamaCppEx - llama.cpp bindings for running GGUF models locally on Metal, CUDA, Vulkan or CPU, with Hugging Face Hub downloads, streaming and structured output.

Computer Vision

• Evision - OpenCV bindings for Elixir/Erlang.
• NxImage - Image processing in Nx.
• YOLO - Real-time object detection using YOLOv8 models with 38ms processing time and optional Rust NIF for performance.
• ImageVision - Classification, detection, segmentation, background removal, captioning and zero-shot labels for Image structs, backed by Bumblebee.

Vector Search & Similarity

• hnswlib - Elixir binding for the hnswlib approximate nearest neighbour library. In-process vector search with precompiled NIFs.
• Leidenfold - Elixir bindings for the Leiden community detection algorithm.
• Qdrant - Client for the Qdrant vector database REST API.
• Stephen - ColBERT-style neural retrieval for Elixir.
• Turbopuffer - Client for the Turbopuffer vector and BM25 full-text search API, with hybrid search.
• Vettore - In-memory vector database on ETS with Rust-accelerated distance functions and HNSW indexing.

Generative AI

LLM Tools

• Arcana - Embeddable RAG library for Elixir/Phoenix with agentic pipelines and dashboard.
• Aludel - Phoenix-native LLM evaluation workbench: prompt tests, model comparison, rubric-based LLM judges, red-team suites, ExUnit assertions and CI gates.
• Anthropix - Anthropic Messages API client with streaming and tool use.
• AshAi - Structured outputs, vectorization and tool calling for your Ash application with LangChain integration and MCP server capabilities.
• ClaudeCode - SDK for embedding Claude as an agentic AI in Elixir apps with tool calling and MCP integration.
• LLM Composer - Multi-provider LLM library with routing, fallback, streaming, and cost tracking for OpenAI, Anthropic, Gemini, and more.
• ReqLLM - A Req-based package to call LLM APIs that standardizes the API calls and responses for LLM providers.
• Chunx - Text chunking with token, word, sentence and semantic strategies, ported from Chonkie.
• ClaudeAgentSDK - Elixir SDK for the Claude Code CLI with streaming and session management.
• DSPEx - DSPy port for Elixir with data-driven prompt optimization.
• ExOpenAI - OpenAI SDK generated from the API spec, with full typespecs, docs and streaming, so new endpoints land quickly.
• extractous_ex - Text and metadata extraction from PDFs, Office documents and more via the Extractous Rust library. Document ingestion for RAG pipelines.
• Gemini.ex - Elixir client for Google Gemini LLM supporting both AI Studio and Vertex AI.
• GenAI - Multi-provider generative AI client with chat threads, media jobs and plugin extensions. Supports Anthropic, Gemini, OpenAI, Groq and local llama.cpp.
• Hallmark - Hallucination detection using Vectara's HHEM model, running locally on Bumblebee.
• Handwave - LLM-powered control flow for Elixir: conditional logic, text rewriting, and routing decisions via natural language rather than code.
• Honeycomb - Fast LLM inference service and library built on Elixir, Bumblebee, and EXLA with OpenAI API compatibility.
• Instructor.ex - Structured outputs from LLMs using Ecto schemas. Works with OpenAI, llama.cpp and Bumblebee.
• just_bash - Pure-Elixir bash interpreter and virtual filesystem for sandboxing agent tool calls, built by Knock to run a production agent.
• JsonRemedy - JSON repair library for fixing malformed LLM outputs.
• InstructorLite - Lightweight structured outputs for LLMs using JSON schemas with multi-provider support including OpenAI, Anthropic, and Gemini.
• Mentor - Library for generating validated structured outputs from LLMs with automatic retries and schema validation.
• Mistral - Open-source Elixir client for the Mistral AI API covering chat completions, function calling, embeddings, streaming, OCR, fine-tuning, and batch processing.
• Ollama-ex - Elixir client for Ollama API with support for completions, chat, tools, and function calling.
• OpenAI.ex - OpenAI API client with streaming, file uploads, and Azure OpenAI support.
• Rag - Library for building Retrieval Augmented Generation (RAG) systems with support for vector stores like pgvector and chroma.
• TOON - Token-Oriented Object Notation encoder and decoder for compact LLM prompts.
• TextChunker - Semantic text chunking library optimized for vector embedding and RAG applications.
• xberg - Document intelligence for RAG ingestion (parsing, OCR, tables, chunking across 100+ formats) with a Rust core and first-party Elixir bindings.
• Tribunal - LLM evaluation framework that provides tools for evaluating and testing LLM outputs, detecting hallucinations, and measuring response quality

Agent Frameworks

• A2A - Elixir implementation of the Agent-to-Agent (A2A) protocol with GenServer-based agents, JSON-RPC 2.0 dispatch, SSE streaming, skill-based discovery, and fleet supervision.
• A2UI - Phoenix LiveView renderer for the Agent-to-UI (A2UI) protocol, converting declarative JSONL agent messages into native LiveView components with two-way data binding.
• Bazaar - Elixir SDK for serving AI agent commerce protocols (UCP and ACP) from a single Phoenix handler. Supports Google Shopping agents (UCP) and OpenAI/Stripe agents (ACP) with automatic request/response translation between protocols.
• Alloy - Minimal, OTP-native completion and tool-call loop. Provider-agnostic, with cost guards, and deliberately not a framework.
• BeamWeaver - LangChain, LangGraph and Deep Agents patterns as native OTP workflows, with tools, memory, human-in-the-loop and tracing.
• Jido - Framework for building autonomous, distributed agent systems with modular actions, stateful agents, and sensors. AI-framework agnostic.
• Jido.AI - LLM integration layer for Jido. Provides actions and reasoning strategies (ReAct, Chain-of-Thought, Tree-of-Thoughts) for building intelligent agents with OpenAI, Anthropic, and other providers.
• LangEx - LangGraph-style graph orchestration for durable, human-in-the-loop LLM agents.
• Legion - Runtime for AI agents that live inside your Elixir app and act by writing code, run in monitored sandboxes, with tools defined as Elixir modules. By Software Mansion.
• LangChain - Framework for developing applications powered by language models, with support for OpenAI, Anthropic, Google, and Bumblebee models.
• Sagents - Framework for interactive AI agents with OTP supervision, middleware composition, human-in-the-loop approvals, sub-agent delegation, and a Phoenix LiveView debugger.
• SwarmEx - Lightweight library for AI agent orchestration with built-in telemetry and tool integration.
• Synapse - Multi-agent orchestration framework with Postgres persistence.

Development Tools

• AgentObs - LLM agent observability with telemetry, token tracking, and OpenTelemetry spans following OpenInference conventions.
• Alike - Semantic similarity testing library using a wave operator (<~>) for assertions. Tests whether sentences convey the same meaning rather than exact matches, ideal for validating LLM outputs.
• Beamlens - AI-powered runtime intelligence for the BEAM. Lives in your supervision tree and uses LLMs to explain metrics, diagnose incidents, detect anomalies, and trace message queue bottlenecks.
• claude-code-elixir - Collection of Claude Code plugins for Elixir development. Includes LSP integration, formatting and compilation hooks, and thinking skills for Elixir, Phoenix, Ecto, and OTP patterns.
• Elixir Agent Tools - Elixir development skills for coding agents (language idioms, Phoenix, Ecto, OTP, Oban), with optional Mix checks and Expert language server integration. Works with Claude Code, Codex and OpenCode.
• Evals - Tool for evaluating AI language models on Elixir code generation with side-by-side model comparisons and automated testing.
• llm_db - LLM model metadata database with O(1) lookups for provider capabilities, pricing, and context limits. Packaged as a dependency snapshot with no runtime network calls needed.
• LlmGuard - AI firewall with prompt injection detection, PII redaction, and jailbreak prevention for LLM applications.
• ExSlop - Credo checks that catch AI-generated code slop: blanket rescues, narrator docs, N+1 queries and more.
• HexDocs MCP - Enables semantic search of Elixir package documentation for AI assistants via Model Context Protocol (MCP).
• Anubis MCP - SDK for the Model Context Protocol (MCP) with support for multiple transport options (STDIO, HTTP/SSE, WebSocket).
• ex_mcp - Complete Elixir implementation of the Model Context Protocol (v2025-11-25) with client and server support, multiple transports including native BEAM, and 2600+ tests.
• Phantom MCP - MCP server framework for Plug with Streamable HTTP and stdio transports.
• Symphony - OpenAI's reference implementation, written in Elixir, of an orchestrator that runs Codex coding agents against an issue tracker in isolated per-issue workspaces.
• Tidewave Phoenix - AI-powered development assistant for Phoenix web applications that connects editor AI assistants to web framework runtime via MCP.
• Usage Rules - Tool for synchronizing LLM rules files with dependencies to prevent AI hallucinations and ensure consistent usage patterns.

Livebooks & Examples

• José Valim's Livebooks - Livebooks that José used for talks and Advent of Code.
• Programming Machine Learning - Livebook notebooks with code examples for the Programming Machine Learning book by Paolo Perrotta
• Machine Learning in Elixir - Livebooks following along with the book Machine Learning in Elixir by Sean Moriarity
• Asynchronous Processing in Elixir - Interactive guide using Livebook to asynchronous data processing in Elixir.

Resources

Books

• Machine Learning in Elixir - Learning to Learn with Nx and Axon (by Sean Moriarity)
• Genetic Algorithms in Elixir - Solve Problems Using Evolution (by Sean Moriarity)

Videos

• (2026) Keynote: Exoskeletons, not Autopilots - Zach Daniel
• (2026) AI-Powered Search at Scale - Jeff Weiss
• (2026) Building Real-Time AI Agents with Elixir - Kimutai Kiprotich
• (2026) What if you could build production-ready RAG entirely in Elixir? - George Guimarães
• (2026) Arbor: AI Agent Orchestration on the BEAM - Hysun Chung
• (2025) Structured Generation and Logits Processing with Elixir - Chris Beck
• (2025) Detecting Confident Nonsense: Testing LLM-Driven Apps - Hernan Rivas Acosta
• (2025) Concurrent AI Evaluation: Scaling Model Performance Monitoring with OTP - Ramiro Matteoda
• (2025) Beyond GenServers: Declarative AI Flows with gen_statem - Coby Benveniste
• (2025) MoodBot: Raising a Tiny Robot with Elixir, Nerves, and AI - Carsten Rösnick-Neugebauer
• (2025) Teaching the BEAM to See - Alvise Susmel
• (2025) Keynote: A Survival Guide for the AI Age - Josh Price
• (2025) Smarter Apps with Ash and the Model Context Protocol - Josh Price
• (2025) Nerves of Vision - Alvise Susmel
• (2025) Who is doing the thinking? - Bruce Tate
• (2025) AI Agents - Elixir is all you need - Daniel Kentfield
• (2025) You can build an AI agent - Dennis Beatty
• (2025) Hey Ash, Let's Chat! Building Conversational AI with Ash AI - Jinkyou Son
• (2025) Vibe Coding with Elixir: Harnessing AI to Build Real-World Apps - Micah Woods
• (2025) Handoff: a new Nx-compatible library for distributed DAGs - Paulo Valente
• (2025) Scaling Edge AI with Elixir and Nerves - Vittoria Bitton & Paulo Valente
• (2025) Code Intelligence and RAG in Elixir with rag.ex - Chris Beck
• (2025) Meta Programming in Elixir: Dynamic Function Calling with LLMs - Conor Sinclair
• (2025) Ash AI Launch - Zach Daniel
• (2025) Whisperer: An Elixir-based Multi-Agent Workflow Framework - Sola Aremu & Ridwan Otun
• (2025) Keynote: Elixir's AI Future - Chris McCord
• (2025) Keynote: Designing LLM Native systems - Sean Moriarity
• (2025) Full-Stack AI with Elixir - George Guimarães
• (2025) Keynote: Code Generators are Dead. Long Live Code Generators - Chris McCord
• (2024) Ship it! A Roadmap for Putting Nx into Production - Christopher Grainger
• (2024) Using LLMs and AI Agents to super power your Phoenix apps - Byron Saltysiak
• (2024) Soothsayer: Using NeuralProphet, Nx and Livebook to Forecast Business Data in Elixir - George Guimarães
• (2023) A year in production with Machine Learning on the BEAM (Explorer, Scholar, Bumblebee, Livebook)
• (2023) Nx-powered decision trees (Nx, EXGBoost)
• (2023) Building AI apps with Elixir
• (2023) MLOps in Elixir: Simplifying traditional MLOps with Elixir (Nx, Bumbleblee)
• (2023) Fine-tuning language models with Axon (Axon)
• (2023) Data wrangling with Livebook and Explorer (Livebook, Explorer)
• (2022) The Future AI Stack by Chris Grainer (Explorer, Axon)
• (2022) Announcing Bumblebee: pre-trained machine learning models for GPT2, StableDiffusion, and more (Livebook, Bumblebee)
• (2022) Axon: functional programming for deep learning (Axon)

Articles

• (2026) Why Elixir is the best language for AI - José Valim makes a data-backed case for Elixir in the AI era: immutability, first-class docs, operational simplicity, and runtime introspection.
• (2026) Your Agent Framework Is Just a Bad Clone of Elixir - George Guimarães argues that Python agent frameworks are independently rediscovering BEAM primitives, and Elixir already solves the hard parts of long-lived agent connections.
• (2026) Distributed Python dataframes and machine learning with Livebook and Elixir - José Valim runs Python across a cluster from Livebook: Pythonx with reproducible uv environments, zero-copy Arrow between Explorer and pandas, and Python workers on Fly or Kubernetes over Erlang distribution.
• (2026) Karlo Šmid's "Build an LLM from Scratch in Elixir" series, an Nx/Axon port of Sebastian Raschka's book: Working with Text Data, The Attention Mechanism in Elixir, Implementing a GPT model from scratch, Pretraining on unlabeled data and Fine-tuning for classification, which fine-tunes GPT-2 for SMS spam detection in Nx.
• (2026) Sherlock: from Hackathon to company-wide AI assistant - Remote's engineering team builds a Phoenix, LiveView and Ash chat assistant that lets non-engineers query the codebase, streaming from OpenCode via Req.
• (2026) Why I moved from Python to Elixir for AI work, and what I found on the other side - Alessandro Usseglio Viretta on preemptive scheduling versus async/await for long-running LLM calls.
• (2026) BEAM Is a Suspiciously Good Fit for Agents - Tyler O'Briant maps agent runtime requirements onto processes, supervision and message passing.
• (2026) Elixir, Clojure, or Python for LLM Agents? Our Experience with All Three - Artem Barmin compares building the same agent system in three languages and where each one breaks down.
• (2025) Embedding Python in Elixir, it's Fine - Jonatan Kłosko introduces Pythonx: embedding Python directly in the BEAM via NIF with automatic virtual env management and same-process memory sharing.
• (2025) Building a MCP Server in Elixir - Hashrocket walks through building a real MCP server using Anubis, letting AI tools like Claude Code and Cursor interact directly with a Phoenix app.
• (2024) Elixir and Machine Learning in 2024 so far - José Valim's mid-year ecosystem update covering Nx's move to MLIR, Apple Silicon support, Explorer's Arrow improvements, and structured outputs via instructor_ex.
• (2024) What I mean when I say ML in Elixir is production-ready - Christopher Grainger makes the case for production ML on the BEAM: Nx.Serving for distributed batching, actor model for model supervision, and native integration with Phoenix, Oban, and Broadway.
• (2024) AI GPU Clusters, From Your Laptop, With Livebook - Chris McCord and José Valim demonstrate scaling to 64 GPU machines simultaneously from a local Livebook using FLAME and Nx's native BEAM clustering.
• (2024) Training LoRA Models with Axon - Sean Moriarity's deep dive on fine-tuning LLMs in pure Elixir using LoRA and Axon's graph rewriting APIs.
• (2024) Implementing Natural Conversational Agents with Elixir - Sean Moriarity builds a voice AI assistant with Whisper, GPT-3.5, and ElevenLabs in Elixir, reducing latency from 4.5s to ~1s with Silero VAD and GPU acceleration.
• (2023) From Python to Elixir Machine Learning - Nice wrapup on what you gain from the Elixir ecosystem for Machine Learning.

Discussions

• State of developing agents with Elixir (not coding agents) - ElixirForum thread (2026) surveying the agent frameworks, gaps and production experiences in the ecosystem.
• Elixir is the productivity language of the Agentic era - ElixirForum thread (2026) on why coding agents produce better Elixir than most languages.
• OpenAI released a library that uses Elixir to orchestrate AI agents - ElixirForum discussion (2026) of Symphony and what it says about the BEAM for agent orchestration.
• Nx ecosystem 0.13 library updates - Paulo Valente's release notes (2026) across Nx, EXLA, Torchx, EMLX and friends.
• ElixirConf EU 2026: list of talks, slides and links - Community-maintained index of the conference's talks.

Contributions

Contributions welcome! Read the contribution guidelines first.

License

This project is licensed under the CC0 License. Feel free to use, share, and adapt the content.