Anubis MCP

Anubis MCP provides both client and server implementations within a single Elixir library, allowing developers to build MCP-enabled applications that can simultaneously act as clients connecting to external MCP servers and as servers exposing capabilities to AI assistants. The architecture centers on Anubis.Server and Anubis.Client modules with shared transport abstraction, enabling code reuse and consistent patterns across bidirectional communication. This dual-mode design leverages Elixir's concurrency primitives (Process.send_after/3 for timeouts, GenServer patterns) to manage request state and session lifecycle.

Anubis MCP abstracts transport mechanisms through Elixir behavior modules, allowing the same client and server code to operate over STDIO, StreamableHTTP, WebSocket, and SSE transports without code changes. Each transport implementation (e.g., Anubis.Server.Transport.StreamableHTTP.Plug for Phoenix/Plug integration) handles serialization, connection lifecycle, and message framing independently. The behavior-based design enables runtime transport selection and seamless integration with existing Elixir web frameworks via Plug middleware.

Anubis MCP includes extensive documentation covering core concepts, architecture patterns, and step-by-step tutorials for building clients and servers. Example servers demonstrate common patterns and best practices, enabling developers to quickly understand MCP concepts and implement their own servers. The documentation is organized by use case (client building, server building, transport selection) and includes API reference material.

Anubis MCP leverages Elixir's lightweight process model and OTP supervision trees to enable thousands of concurrent MCP operations with minimal resource overhead. Each MCP client connection, server session, or request can be managed by independent Elixir processes, enabling natural parallelism without explicit threading or async/await syntax. The OTP application framework provides fault tolerance, automatic process restart, and distributed deployment capabilities.

Anubis MCP provides a component system (Tools, Resources, Prompts) that developers register with Anubis.Server.Frame, which maintains session state including registered components and pagination settings. Components are defined as Elixir modules implementing specific behaviors, enabling type-safe, composable capability definitions. The Frame state management handles component lifecycle, discovery, and pagination for large capability sets, abstracting the complexity of MCP's capability advertisement protocol.

Anubis MCP includes a Schema DSL that enables developers to define tool parameters and resource schemas using Elixir syntax, generating MCP-compliant JSON Schema automatically. This DSL abstracts JSON Schema complexity, providing a higher-level interface for specifying input/output types, validation rules, and documentation. The schema definitions are compiled into MCP protocol messages, ensuring type consistency between Elixir code and AI assistant expectations.

Anubis MCP's client implementation (Anubis.Client.State) manages pending requests using Anubis.Client.Request structs and handles timeout timers via Elixir's Process.send_after/3, enabling automatic request cleanup and timeout detection without external timer libraries. The state machine tracks request lifecycle from initiation through response receipt or timeout, supporting concurrent requests with independent timeout policies. This design leverages Elixir's lightweight process model to handle thousands of concurrent requests with minimal overhead.

Anubis MCP integrates with Phoenix and Plug applications through Anubis.Server.Transport.StreamableHTTP.Plug, enabling MCP servers to be deployed as HTTP endpoints within existing web applications. The Plug middleware handles HTTP request/response serialization, streaming response bodies for long-running operations, and connection lifecycle management. This integration allows developers to expose MCP capabilities alongside traditional REST APIs in a single Phoenix application.

Anubis MCP provides WebSocket transport support for both client and server implementations, with client-side WebSocket connections handled via the :gun HTTP client library. This enables real-time, bidirectional MCP communication over WebSocket, supporting long-lived connections with low-latency message delivery. The WebSocket transport is suitable for interactive AI assistants and real-time tool execution scenarios where HTTP request-response latency is unacceptable.

Anubis MCP supports STDIO transport, enabling MCP servers to be invoked as command-line tools that communicate via standard input/output streams. This transport is ideal for integrating MCP servers with AI assistants and CLI tools that expect subprocess-based tool execution. The STDIO transport handles message framing, serialization, and process lifecycle management, abstracting the complexity of subprocess communication.

Anubis MCP integrates with Burrito, a Mix-based build system that compiles Elixir applications into standalone binaries for macOS, Linux, and Windows. This enables developers to distribute MCP servers as single executables without requiring Elixir runtime installation on target machines. The build system handles dependency bundling, platform-specific compilation, and binary optimization, simplifying deployment and distribution.

Anubis MCP provides built-in testing utilities and interactive CLI tools for validating MCP server implementations during development. The testing infrastructure includes fixtures, mock transports, and assertion helpers that enable developers to test client-server interactions without external dependencies. Interactive CLI tools allow manual testing and debugging of MCP servers, supporting rapid iteration during development.