# RimSage [Health: Active]

**Category:** 🎮 Gaming  
**Repository:** https://github.com/realloon/RimSage  
**GitHub Stars:** 100  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/rimsage

## Description
An MCP server that enables searching and browsing of RimWorld source code.

## Tools
Capabilities this server exposes over MCP:

- **search_source** — Search RimWorld source code using regex.
- **read_file** — Read source file.
- **list_directory** — List contents of a directory.
- **get_def_details** — Get XML of a Def.
- **search_defs** — Search Def indices by partial name or label.
- **read_csharp_symbol** — Read a C# type or method definition.

## Claude Desktop Quick Installation
Remote MCP endpoint (confidence: high). Install path detected from listing signals. Add as a URL/SSE server in your client:

```json
"mcpServers": {
  "rimsage": {
    "url": "https://mcp.rimsage.com/mcp"
  }
}
```

## Documentation

## What RimSage does

Its tools cover both text-oriented code exploration and RimWorld-specific data inspection:

- `search_source` searches indexed RimWorld source code.
- `read_file` returns the contents of a selected file.
- `list_directory` inspects available directory entries.
- `search_defs` searches RimWorld Defs.
- `get_def_details` retrieves raw or merged Def XML.
- `read_csharp_symbol` reads the definition of a C# type or method.

This combination lets an agent move from a broad source search to a particular file, symbol, or Def without relying only on plain-text grep results.

## How it works

The project can be used through the hosted MCP endpoint at `https://mcp.rimsage.com/mcp`, which provides a ready-to-use service for supported MCP clients. For local use, RimSage runs with stdio transport. It also includes a Streamable HTTP development mode.

A self-hosted installation builds indexes from two local inputs: a RimWorld installation or root directory for Def data, and a decompiled C# source project. The indexed data is then queried by the MCP tools. Local deployment therefore requires access to the relevant RimWorld files and decompiled source before an agent can search them.

## Setup and configuration

The self-hosted workflow requires Bun and ripgrep. After cloning the repository, install its package dependencies with Bun, import the Defs and C# source, and build the project:

```sh
bun install
bun run src/scripts/import-defs /path/to/your/rimworld/root/path
bun run src/scripts/import-csharp /path/to/decompiled/source/root/path
bun run build
```

Run the local stdio server with:

```sh
bun run start
```

The repository also provides a Streamable HTTP start command:

```sh
bun run start:http
```

An MCP client can launch the stdio server with a configuration similar to this:

```json
{
  "mcpServers": {
    "rimsage": {
      "command": "bun",
      "args": ["run", "/path/to/this/repo"]
    }
  }
}
```

Replace the repository path with the location of the local checkout. Client-specific connection instructions are available through the project's integration wiki.

## Tools and capabilities

The source-search tools support code navigation at several levels. Agents can search indexed source, inspect directory structure, open individual files, and read C# type or method definitions. RimSage also treats RimWorld Defs as a separate searchable data set, with support for finding matching Defs and retrieving either their raw or merged XML representation.

These capabilities are useful when investigating how a game system is implemented, locating the code behind a Def, checking inherited or merged Def values, or examining a specific C# symbol during mod development.

## Limitations and notes

Local deployment depends on a prepared index and does not operate from only the repository checkout. You need local RimWorld files and a decompiled C# project to populate the index. The project states that using those materials is allowed under the RimWorld EULA; users remain responsible for following the applicable license terms.

The hosted endpoint avoids the local indexing workflow, while the self-hosted option keeps the source inputs and server process in the local environment. Bun and ripgrep are required for the documented self-hosted setup.

_Full upstream README: https://allmcps.com/mcp/rimsage/readme_

