rime

rime is a minimal MCP server implemented in Rust intended for Nix tooling workflows. It exposes a collection of subcommands under categories like Nix, NixOS, Home Manager, nvf, Nixhub, and general tools, enabling users to evaluate expressions, fetch package data, search documentation, and retrieve metadata related to Nix/NixOS configurations. You can run the server locally and connect to it using standard MCP client integrations, then invoke the provided tools (e.g., nix_evaluate, nix_packages_search, nix_flakes_show) to interact with Nix ecosystems through MCP endpoints. The server is designed to integrate with common developer tooling across environments that rely on Nix and related technologies.

To use the server, start it using the recommended stdio interface, which routes the server’s I/O through standard input/output streams. Once running, you can access the various tool commands via your MCP client by referencing the server name (rime) and the specific tool you want to execute, such as nix_evaluate to evaluate a Nix expression or nix_packages_search to search for packages in a given installable. The README provides concrete usage snippets for integrating rime with codex, opencode, Gemini Code, VSCode, and Zed configuration files, illustrating how to wire the server into multiple editors and automation tools. These integrations show how the MCP server can be queried to retrieve results and metadata in a developer-friendly workflow.

In practice, you would connect to rime from your environment-specific configuration (e.g., codex config, opencode config, or your editor’s MCP settings) and then issue tool commands through the MCP protocol. The server’s capabilities span Nix evaluation, package search, dependency reasoning, flake metadata, and configuration checks, among others, enabling automated tooling and scripted workflows around Nix-based development and system configuration.

Prerequisites:

• Install Nix and ensure nix is on your PATH.
• Build the rime MCP server from source using the provided build system (Rust). Follow the repository’s standard build steps.

Step-by-step:

1. Install dependencies and build the server

   • Ensure you have Rust toolchain installed (rustup, cargo).
   • From the repository root, run the build command specified in the README, typically something like: nix build .#rime

2. Run the server

   • After a successful build, start the server in stdio mode (as per the README example): ./result/bin/rime stdio
   • The server will listen for MCP tool invocations via standard input/output. Ensure your MCP client is configured to communicate with the rime server using the same interface.

3. Optional integration steps

   • If you use IDE integrations (OpenAI Codex, Gemini Code, VSCode, Zed, etc.), follow the snippet formats shown in the README to wire up the rime server with your editor or automation tool. These examples generally involve adding an entry for the server named rime with the command pointing to the built binary and the appropriate stdio argument (stdio).

Notes:

• The build and run steps assume a Rust-based project that produces a binary at ./result/bin/rime. If your environment uses a different output path, adjust the command accordingly.
• If you prefer a different invocation (e.g., http mode), use the http subcommand as shown in the README (when supported by the binary).

Tips and common issues:

• Ensure nix is installed and available on PATH before building.
• If the server cannot start, verify that the build completed successfully and that the path ./result/bin/rime exists.
• When configuring editor integrations, ensure you reference the correct absolute path to the built binary and use the stdio argument as shown in the examples.
• When using IPv4/hosted modes (e.g., http), make sure the host/port you specify are accessible from your client environment.
• Keep the rime server updated alongside your Nix tooling to benefit from the latest features for Nix/NixOS/Home Manager, nvf, and related tooling.