anubis

Anubis MCP is an Elixir-based implementation of the Model Context Protocol (MCP). It provides both a server and client library that let you expose tool capabilities to LLMs and call external tools through a defined MCP interface. The server supports configuring tools and handlers that can be invoked by clients, and the included examples demonstrate a plug-based and a Phoenix-based setup for streaming HTTP interactions. With Anubis, you can register tools (for example, text echo, upcasing, or domain-specific actions) and then call those tools from an MCP client to obtain structured responses that integrate with LLM prompts.

To use the server, run it in a suitable environment (the repository shows deployment via Plug or Phoenix) and expose an MCP endpoint at /mcp. You can register tools on startup (e.g., an echo tool that returns the input text) and then call the tool from a client module. The example client module demonstrates how to define a client, configure HTTP transport, and perform a tool call such as echo with a payload like {text: "hello"}. The server and client work together to enable dynamic tool invocations within the MCP protocol, leveraging Elixir's concurrency model for high performance and fault tolerance.

Prerequisites:

• Docker (for the recommended containerized run) or Elixir/Erlang development environment if you prefer running locally.
• If not using Docker, you will need a suitable Elixir project setup and dependencies as described in the Anubis MCP docs.

Option A: Run with Docker (recommended)

1. Install Docker on your system.
2. Pull or build the Anubis MCP Docker image. If you have a local image, skip to step 3. If not, you can build one from a Dockerfile that packages the Anubis MCP server.
3. Run the container: docker run -d --name anubis-mcp -p 4000:4000 anubis_mcp:latest This should start the MCP server and expose the endpoint at http://localhost:4000/mcp (depending on your image configuration).

Option B: Run locally with Elixir (if you prefer a non-Docker setup)

1. Ensure Elixir (and Erlang) is installed. Instructions vary by OS; see elixir-lang.org for details.
2. Create a new Mix project or use your existing app. Add the dependency for Anubis MCP as shown in the README: defp deps do [ {:anubis_mcp, "~> 0.17.1"} ] end
3. Run mix deps.get to fetch dependencies.
4. Implement your MCP server module and transport (Plug or Phoenix) as demonstrated in the Quick Start section of the README.
5. Start the application and navigate to the configured /mcp endpoint.

Prerequisites recap:

• Docker or Elixir/Erlang development environment
• Access to mix deps or Docker image as per chosen installation method

Tips and common notes:

• The server example shows a server that exposes a tool named "echo" with a simple text input. You can extend this to more complex tools and schemas as needed.
• If you’re deploying behind HTTP, you can use the StreamableHTTP transport (as shown in the examples) or adapt to your preferred transport mechanism (e.g., SSE or WebSocket-based approaches).
• Environment variables like MCP_PORT or MCP_LOG_LEVEL help you tailor runtime behavior when running inside containers or different environments.
• Ensure your client uses the correct protocol_version and structure for tool calls (e.g., calling a tool by name with the appropriate input map).
• The repository references Elixir-based implementations; there is no npm package name for this server, so npm_package is null. If you’re running a container, ensure the image tag matches your deployment.
• If you encounter issues with tool registration or lifecycle callbacks, review the init/2 and handle_tool/3 implementations in your server module for correct pattern matching and state management.