### Load Custom Guides

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Examples of how to request custom guides using natural language.

```text
Load my API documentation guide.
```

```text
Can you show me the setup guide I imported?
```

```text
I need to see my custom user manual.
```

--------------------------------

### List Available Guides

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Examples of how to query for available guides across different libraries.

```text
What Rails guides are available?
```

```text
Show me all the Turbo documentation.
```

```text
List the available custom guides I've imported.
```

--------------------------------

### Troubleshooting: Guide Not Found Error

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Example of a 'Guide not found' error and its suggested solution.

```text
Guide 'invalid_guide' not found in Rails guides.
```

--------------------------------

### Switch Project and Get Overview

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Start by switching to the desired project and then get a general overview of the project's information.

```bash
railsMcpServer:switch_project project_name: "your-project-name"
```

```bash
railsMcpServer:execute_tool tool_name: "project_info"
```

--------------------------------

### Load Specific Rails Guide

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Examples of how to request specific Rails guides using natural language.

```text
Can you load the Rails getting started guide?
```

```text
I need to see the Active Record basics documentation.
```

```text
Show me the Rails routing guide.
```

--------------------------------

### Load Specific Kamal Guide

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Examples of how to request specific Kamal guides using natural language.

```text
Show me the Kamal installation guide.
```

```text
I need to understand Kamal deployment - can you load that documentation?
```

```text
Can you get the Kamal configuration overview?
```

--------------------------------

### Copilot Setup Steps Workflow

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/COPILOT_AGENT.md

A GitHub Actions workflow to set up Ruby, install Rails MCP Server, and install project dependencies. This YAML file should be placed at .github/workflows/copilot-setup-steps.yml.

```yaml
name: "Copilot Setup Steps"

on:
  workflow_dispatch:
  push:
    paths:
      - .github/workflows/copilot-setup-steps.yml
  pull_request:
    paths:
      - .github/workflows/copilot-setup-steps.yml

jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.3'
          bundler-cache: true

      - name: Install Rails MCP Server
        run: gem install rails-mcp-server

      - name: Install project dependencies
        run: bundle install

```

--------------------------------

### Execute Tool: Load Guide

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Use this tool to load documentation guides. Specify the library and guide name.

```ruby
execute_tool("load_guide", { library: "category", guide: "guide_name" })
```

--------------------------------

### Setup GitHub Actions Workflow

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Define a GitHub Actions workflow in .github/workflows/copilot-setup-steps.yml to install Ruby and the Rails MCP Server.

```yaml
name: "Copilot Setup Steps"

on: workflow_dispatch

jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.3'
          bundler-cache: true

      - name: Install Rails MCP Server
        run: gem install rails-mcp-server
```

--------------------------------

### Load Specific Turbo Guide

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Examples of how to request specific Turbo guides using natural language.

```text
Can you load the Turbo introduction guide?
```

```text
I'd like to see the Turbo Frames documentation.
```

```text
Show me the Turbo streams reference.
```

--------------------------------

### Download Turbo Guides

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Download official Turbo (Hotwire) framework guides using the command-line tool.

```bash
rails-mcp-server-download-resources turbo
```

--------------------------------

### Import Custom Guides

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Import custom markdown files as documentation guides using the command-line tool.

```bash
rails-mcp-server-download-resources --file /path/to/your/docs/
```

--------------------------------

### Load Guide Documentation

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Loads guide documentation for a specified library and guide. Requires library and guide names as parameters.

```ruby
load_guide (params: library, guide)
```

--------------------------------

### Load Framework Guides

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Load documentation guides for various Rails libraries. Specify the 'library' and optionally the 'guide' for more specific documentation.

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "getting_started" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "active_record_basics" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "turbo" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "stimulus" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "kamal" }
```

--------------------------------

### Download Rails Guides

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Download official Ruby on Rails guides using the command-line tool.

```bash
rails-mcp-server-download-resources rails
```

--------------------------------

### GitHub Actions Workflow for Copilot Setup

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/COPILOT_AGENT.md

Sets up a GitHub Actions workflow to install Ruby, the Rails MCP Server, project dependencies, and load the database schema. This workflow is triggered manually.

```yaml
name: "Copilot Setup Steps"

on: workflow_dispatch

jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.3'
          bundler-cache: true

      - name: Install Rails MCP Server
        run: gem install rails-mcp-server

      - name: Install dependencies
        run: bundle install

      - name: Setup database
        run: bin/rails db:schema:load
        env:
          RAILS_ENV: test
```

--------------------------------

### Load Documentation Guides

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Load documentation guides from various libraries like Rails, Turbo, Stimulus, Kamal, or custom sources. Specify the library and optionally a specific guide.

```ruby
execute_tool(tool_name: "load_guide", params: { library: "rails" })
```

```ruby
execute_tool(tool_name: "load_guide", params: { library: "rails", guide: "getting_started" })
```

```ruby
execute_tool(tool_name: "load_guide", params: { library: "turbo" })
```

```ruby
execute_tool(tool_name: "load_guide", params: { library: "stimulus" })
```

```ruby
execute_tool(tool_name: "load_guide", params: { library: "custom", guide: "tailwind" })
```

--------------------------------

### Load Specific Stimulus Guide

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Examples of how to request specific Stimulus guides using natural language.

```text
Load the Hello Stimulus tutorial for me.
```

```text
I need help with Stimulus controllers - can you show me that guide?
```

```text
Can you display the Stimulus targets reference?
```

--------------------------------

### Execute Rails Guide Tool

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use this tool to load and consult documentation for specific Rails guides. Ensure the 'rails' library and the desired 'guide' are correctly specified.

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "active_record_querying" }
```

--------------------------------

### List and Load Rails Guides

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Lists available guides for a specified library or loads a specific guide. Supports Rails, Turbo, Stimulus, Kamal, and custom libraries.

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "active_record_basics" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "getting_started" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "active_record_associations" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "turbo" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "stimulus" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "kamal" }
```

```ruby
railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "custom", guide: "tailwind" }
```

--------------------------------

### Install and Run MCP Inspector

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Install the MCP Inspector globally using npm and then run it with your Rails MCP Server path. This starts the server, launches the Inspector UI, and sets up an MCP Proxy.

```bash
npm -g install @modelcontextprotocol/inspector
```

```bash
npx @modelcontextprotocol/inspector /path/to/rails-mcp-server
```

--------------------------------

### Install Rails MCP Server and Configure Projects

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Install the gem using RubyGems and configure projects either interactively or by manually creating a projects.yml file.

```bash
gem install rails-mcp-server

# Interactive TUI for full setup (recommended)
rails-mcp-config

# Or manually configure projects
mkdir -p ~/.config/rails-mcp
cat > ~/.config/rails-mcp/projects.yml <<EOF
myapp: ~/projects/my-rails-app
store: /full/path/to/store-app
EOF
```

--------------------------------

### Activate Rails Project with `switch_project`

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Activates a specific Rails project from `projects.yml`. This tool must be called before other analyzer tools in multi-project setups. It returns a confirmation and a Quick Start guide.

```text
# MCP tool call (shown in pseudo-notation used by AI clients)
railsMcpServer:switch_project project_name: "myapp"

# Response includes confirmation and quick start:
# Switched to project: myapp at path: /home/you/projects/my-rails-app
#
# Quick Start:
# • Get project overview:  execute_tool("project_info")
# • Read a file:           execute_ruby("puts read_file('config/routes.rb')")
# • Find files:            execute_ruby("puts Dir.glob('app/models/*.rb').join('\n')")
# • Analyze models:        execute_tool("analyze_models", { model_name: "User" })
```

--------------------------------

### Troubleshooting: Resource Not Found Error

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Example of a 'Resource Not Found' error and its suggested solution.

```text
Error: Unknown resource: rails
```

--------------------------------

### Load Framework Documentation

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Accesses official documentation for Rails, Turbo, Stimulus, Kamal, or custom markdown files. Guides must be downloaded first.

```bash
# Download guides before first use
rails-mcp-server-download-resources rails
rails-mcp-server-download-resources turbo
rails-mcp-server-download-resources stimulus
rails-mcp-server-download-resources kamal
```

```bash
# Or import custom markdown docs
rails-mcp-server-download-resources --file /path/to/your/docs/
```

--------------------------------

### Install Rails MCP Server Gem

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Install the gem using the standard RubyGems command. This makes the server and configuration executables available in your PATH.

```bash
gem install rails-mcp-server
```

--------------------------------

### Download Rails Guides in Workflow

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/COPILOT_AGENT.md

Add a step to the GitHub Actions workflow to download Rails guides for the `load_guide` analyzer. This is a snippet for a YAML file.

```yaml
- name: Download Rails guides
  run: rails-mcp-server-download-resources rails

```

--------------------------------

### Install Gum for Enhanced TUI

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Optional step to install Gum, a tool that enhances the user interface of the configuration tool. Installation commands vary by operating system.

```bash
brew install gum        # macOS
```

```bash
sudo apt install gum    # Debian/Ubuntu
```

```bash
yay -S gum              # Arch Linux
```

--------------------------------

### Troubleshooting: Permission Error

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Example of a 'Source not readable' permission error.

```text
Error: Source not readable: /path/to/file
```

--------------------------------

### Get Project Overview

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Retrieves a general overview of the Rails project.

```ruby
project_info
```

--------------------------------

### Run Interactive Configuration Tool

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Launch the interactive configuration tool for managing projects, downloading guides, and integrating with Claude Desktop. Gum is recommended for an enhanced experience.

```bash
rails-mcp-config
```

--------------------------------

### Start Rails MCP Server in STDIO Mode

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Start the MCP server using the default Standard Input/Output mode for direct integration with clients. This is the default behavior.

```bash
rails-mcp-server
```

--------------------------------

### Start Rails MCP Server in HTTP Mode Binding to All Interfaces

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Start the HTTP server and bind it to all available network interfaces. This enables access from other machines on the local network, useful for testing.

```bash
rails-mcp-server --mode http --bind-all
```

--------------------------------

### Install and Run Node.js MCP Proxy

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Install the Node.js MCP proxy using npm and run it to bridge STDIO clients to the HTTP/SSE enabled Rails MCP Server.

```bash
# Install the Node.js based MCP proxy
npm install -g mcp-remote

# Run the proxy, pointing to your running Rails MCP Server
npx mcp-remote http://localhost:6029/mcp/sse
```

--------------------------------

### Run Rails MCP Setup Script for Claude Desktop

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Use this legacy script to automatically configure Claude Desktop integration. It creates necessary directories and project files.

```bash
rails-mcp-setup-claude
```

--------------------------------

### Resource URIs: Specific Guide

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

URIs for accessing specific guides within categories.

```uri
rails://guides/{guide_name}
```

```uri
turbo://guides/{guide_name}
```

```uri
stimulus://guides/{guide_name}
```

```uri
kamal://guides/{guide_name}
```

```uri
custom://guides/{guide_name}
```

--------------------------------

### Troubleshooting: Download Failure

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Example of a download failure message.

```text
failed (HTTP 404)
```

--------------------------------

### Start Rails MCP Server

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Launch the server in different modes (STDIO, HTTP) and with various options like custom ports, debug logging, binding to all interfaces, or single-project mode.

```bash
# STDIO mode — direct integration with Claude Desktop
rails-mcp-server

# HTTP mode on default port 6029
rails-mcp-server --mode http

# HTTP mode on custom port with debug logging
rails-mcp-server --mode http -p 8080 --log-level debug

# HTTP mode accessible from local network
rails-mcp-server --mode http --bind-all

# Single-project mode (GitHub Copilot Agent / running from Rails dir)
rails-mcp-server --single-project

# Endpoints when running in HTTP mode:
#   JSON-RPC: http://localhost:6029/mcp/messages
#   SSE:      http://localhost:6029/mcp/sse
```

--------------------------------

### Get Project Information

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Obtain general information about the project structure.

```ruby
railsMcpServer:execute_tool tool_name: "project_info"
```

--------------------------------

### Resource URIs: List Resources

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

URIs for listing available guides within specific categories.

```uri
rails://guides
```

```uri
turbo://guides
```

```uri
stimulus://guides
```

```uri
kamal://guides
```

```uri
custom://guides
```

--------------------------------

### Neovim MCP Server - Get Project Buffers

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Retrieves a list of files currently open in Neovim for a specified project.

```ruby
nvimMcpServer:get_project_buffers project_name: "your-project"
```

--------------------------------

### Analyze Controllers and Views

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Use the `analyze_controller_views` tool to get a list of all controllers in the application.

```bash
railsMcpServer:execute_tool tool_name: "analyze_controller_views" params: { detail_level: "names" }
```

--------------------------------

### Start Rails MCP Server in HTTP Mode on Custom Port

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Start the MCP server in HTTP mode on a specified custom port. This allows for flexible network configurations.

```bash
rails-mcp-server --mode http -p 8080
```

--------------------------------

### Get Database Schema

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Retrieve database schema information using the `get_schema` tool. This allows listing all tables, getting the schema for specific tables, or fetching the full schema with indexes.

```bash
railsMcpServer:execute_tool tool_name: "get_schema" params: { detail_level: "tables" }
```

```bash
railsMcpServer:execute_tool tool_name: "get_schema" params: { table_name: "users" }
```

```bash
railsMcpServer:execute_tool tool_name: "get_schema" params: { table_names: ["users", "posts"] }
```

```bash
railsMcpServer:execute_tool tool_name: "get_schema"
```

--------------------------------

### Retrieve Project Information

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Use this tool to get comprehensive project details such as Rails version and directory structure.

```ruby
execute_tool(tool_name: "project_info")
```

--------------------------------

### Get Summary Detail Level for Rails Routes

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use the `get_routes` tool with `detail_level: "summary"` and controller specified to get a summarized view of routes for a particular controller.

```ruby
railsMcpServer:execute_tool tool_name: "get_routes" params: { controller: "orders", detail_level: "summary" }
```

--------------------------------

### List All Model Names

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use the `analyze_models` tool with `detail_level: "names"` to get a list of all model names in the application. This is a quick way to inventory your models.

```ruby
railsMcpServer:execute_tool tool_name: "analyze_models" params: { detail_level: "names" }
```

--------------------------------

### Import Custom Markdown Files into Rails MCP Server

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Import your own markdown documentation files into the Custom guides category. Use the `--file` option with a path to a single file or a directory. The system normalizes filenames and handles duplicates.

```bash
# Import a single markdown file
rails-mcp-server-download-resources --file /path/to/guide.md

# Force import even if file hasn't changed
rails-mcp-server-download-resources --force --file /path/to/api-docs.md
```

```bash
# Import all markdown files from a directory
rails-mcp-server-download-resources --file /path/to/docs/

# Verbose import with progress information
rails-mcp-server-download-resources --verbose --file /path/to/project-docs/
```

--------------------------------

### Configure GitHub Copilot Agent Integration

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Configure Rails MCP Server for use within GitHub Copilot's ephemeral Actions environment using a JSON configuration file and a workflow setup.

```json
// .github/copilot/mcp.json
{
  "mcpServers": {
    "rails": {
      "type": "local",
      "command": "rails-mcp-server",
      "args": ["--single-project"],
      "tools": ["switch_project", "search_tools", "execute_tool", "execute_ruby"]
    }
  }
}
```

```yaml
# .github/workflows/copilot-setup-steps.yml
name: "Copilot Setup Steps"
on: workflow_dispatch
jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v4
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.3'
          bundler-cache: true
      - run: gem install rails-mcp-server
      - run: bundle install
      - run: rails-mcp-server-download-resources rails
      - run: bin/rails db:schema:load
        env:
          RAILS_ENV: test
```

--------------------------------

### Get Database Schema

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Retrieve the schema information for a specific database table.

```ruby
railsMcpServer:execute_tool tool_name: "get_schema" params: { table_name: "transactions" }
```

--------------------------------

### Get Routes by Controller

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Retrieve routing information filtered by controller name.

```ruby
railsMcpServer:execute_tool tool_name: "get_routes" params: { controller: "transactions" }
```

--------------------------------

### Get Database Schema Information

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Fetches database schema details. Can retrieve the structure of a specific table or a list of all tables.

```ruby
get_schema (params: table_name)
```

```ruby
get_schema (params: detail_level: "tables")
```

--------------------------------

### Get Routes

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Use the `get_routes` tool to inspect application routes. You can filter routes by controller, HTTP verb, path, or retrieve only named routes. As a fallback, you can read the `config/routes.rb` file.

```bash
railsMcpServer:execute_tool tool_name: "get_routes"
```

```bash
railsMcpServer:execute_tool tool_name: "get_routes" params: { controller: "users" }
```

```bash
railsMcpServer:execute_tool tool_name: "get_routes" params: { verb: "POST" }
```

```bash
railsMcpServer:execute_tool tool_name: "get_routes" params: { path_contains: "api" }
```

```bash
railsMcpServer:execute_tool tool_name: "get_routes" params: { named_only: true }
```

```ruby
railsMcpServer:execute_ruby code: "puts read_file('config/routes.rb')"
```

--------------------------------

### Controller-View Analysis Summary

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Get a summary of all controllers, including their actions and associated views, by using `detail_level: "summary"`. This provides a high-level overview of controller-view relationships.

```ruby
railsMcpServer:execute_tool tool_name: "analyze_controller_views" params: { detail_level: "summary" }
```

--------------------------------

### Get Full Database Schema

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Retrieve the complete database schema, including all tables and indexes, by calling the `get_schema` tool without any parameters. This provides a comprehensive view of the database structure.

```ruby
railsMcpServer:execute_tool tool_name: "get_schema"
```

--------------------------------

### Analyze Models

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Use the `analyze_models` tool to inspect models, including their associations, validations, and callbacks. You can analyze specific models, multiple models, or get a quick list of names.

```bash
railsMcpServer:execute_tool tool_name: "analyze_models"
```

```bash
railsMcpServer:execute_tool tool_name: "analyze_models" params: { model_name: "User" }
```

```bash
railsMcpServer:execute_tool tool_name: "analyze_models" params: { model_names: ["User", "Post", "Comment"] }
```

```bash
railsMcpServer:execute_tool tool_name: "analyze_models" params: { detail_level: "names" }
```

```bash
railsMcpServer:execute_tool tool_name: "analyze_models" params: { model_name: "User", analysis_type: "full" }
```

--------------------------------

### Agent Workflow - Project Activation and Overview

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Initiates an agent workflow by activating a specific project and then retrieving general project information.

```ruby
# Step 1: Activate the project
railsMcpServer:switch_project project_name: "ecommerce"

# Step 2: Get project overview
railsMcpServer:execute_tool tool_name: "project_info"
```

--------------------------------

### Search Available Tools

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Use these commands to discover available tools, optionally filtering by category or a search query.

```bash
railsMcpServer:search_tools
```

```bash
railsMcpServer:search_tools category: "models"
```

```bash
railsMcpServer:search_tools query: "routes"
```

--------------------------------

### Download Predefined Rails MCP Server Resources

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Use these commands to download official documentation resources for Rails, Turbo, Stimulus, and Kamal. Ensure the `rails-mcp-server-download-resources` command is available in your PATH.

```bash
# Download Rails guides
rails-mcp-server-download-resources rails

# Download Turbo guides  
rails-mcp-server-download-resources turbo

# Download Stimulus guides
rails-mcp-server-download-resources stimulus

# Download Kamal guides
rails-mcp-server-download-resources kamal
```

```bash
# Force download even if files haven't changed
rails-mcp-server-download-resources --force rails

# Verbose output to see download progress
rails-mcp-server-download-resources --verbose turbo

# Combine options
rails-mcp-server-download-resources --verbose --force stimulus
```

--------------------------------

### Start Rails MCP Server in HTTP Mode

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Start the MCP server in HTTP mode, which provides JSON-RPC and SSE endpoints. The default port is 6029.

```bash
rails-mcp-server --mode http
```

--------------------------------

### Project Configuration - Environment Variable and Auto-detection

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Configures the active project using environment variables (highest priority), auto-detection, or projects.yml. Demonstrates setting the environment variable and using auto-detection.

```bash
# Priority 1: Environment variable — bypasses projects.yml entirely
export RAILS_MCP_PROJECT_PATH=/path/to/my-rails-app
rails-mcp-server
```

```bash
# Priority 2: Auto-detection — if Gemfile contains gem "rails" or gemspec
#             has a rails dependency, the current directory is used automatically
cd /path/to/my-rails-app
rails-mcp-server --single-project
```

--------------------------------

### Manual Resource Management: Remove All

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Command to remove all downloaded resources from the configuration directory.

```bash
# Remove all downloaded resources
rm -rf ~/.config/rails-mcp/resources/
```

--------------------------------

### Analyze Environment Configuration

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Compare environment configurations to identify inconsistencies.

```ruby
railsMcpServer:execute_tool tool_name: "analyze_environment_config"
```

--------------------------------

### MCP Configuration with --single-project flag

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/COPILOT_AGENT.md

Configure MCP server to use the current directory as the project using the --single-project flag. This JSON file should be placed at .github/copilot/mcp.json.

```json
{
  "mcpServers": {
    "rails": {
      "type": "local",
      "command": "rails-mcp-server",
      "args": ["--single-project"]
    }
  }
}
```

--------------------------------

### Read Project Files with get_file Tool

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

An alternative method to read project files using the `get_file` tool. Ensure you do not use Claude's built-in `view` tool for project files.

```bash
railsMcpServer:execute_tool tool_name: "get_file" params: { path: "config/routes.rb" }
```

--------------------------------

### Agent Workflow - Discovering and Finding Files

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Searches for tools relevant to a specific category and then finds files within the project that match a given pattern using Ruby's Dir.glob.

```ruby
# Step 3: Discover tools relevant to the task
railsMcpServer:search_tools category: "models"

# Step 4: Find relevant files
railsMcpServer:execute_ruby code: "puts Dir.glob('app/**/*order*').join('\n')"
```

--------------------------------

### List View Files

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

List all files within a specific view directory.

```ruby
railsMcpServer:execute_ruby code: "puts Dir.glob('app/views/transactions/**/*').join('\n')"
```

--------------------------------

### Retrieve Database Schema

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Get database schema information. Can retrieve the full schema, specific table details, or just a list of tables.

```ruby
execute_tool(tool_name: "get_schema")
```

```ruby
execute_tool(tool_name: "get_schema", params: { table_name: "users" })
```

```ruby
execute_tool(tool_name: "get_schema", params: { detail_level: "tables" })
```

--------------------------------

### Execute Ruby Code with Helper Methods

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Execute custom Ruby code within the project context. Use helper methods like `read_file`, `file_exists?`, and `list_files`. Always use `puts` to ensure output is displayed.

```ruby
# ❌ Bad - returns "Code executed successfully (no output)"
railsMcpServer:execute_ruby code: "read_file('Gemfile')"
```

```ruby
# ✅ Good - returns file contents
railsMcpServer:execute_ruby code: "puts read_file('Gemfile')"
```

--------------------------------

### Get Project Routing Information

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Retrieves routing information for the Rails project. Can fetch all routes or filtered routes based on controller, verb, or path.

```ruby
get_routes
```

```ruby
get_routes (params: controller, verb, path_contains)
```

--------------------------------

### Tool Output Format

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

The expected markdown format for content returned by the `load_guide` tool.

```markdown
# Guide Title

**Source:** Framework Name
**Guide:** guide_name
**File:** path/to/file.md (for sectioned guides)

---

[Guide content here...]
```

--------------------------------

### Get Schema for a Specific Table

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Retrieve the full schema details for a specific table by providing its name (snake_case plural). This includes columns, constraints, and indexes.

```ruby
railsMcpServer:execute_tool tool_name: "get_schema" params: { table_name: "users" }
```

--------------------------------

### Manual Resource Management: Re-download

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Commands to re-download resources for specific libraries.

```bash
# Re-download everything  
rails-mcp-server-download-resources rails
rails-mcp-server-download-resources turbo
rails-mcp-server-download-resources stimulus
rails-mcp-server-download-resources kamal
```

--------------------------------

### List All Table Names from Schema

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use the `get_schema` tool with `detail_level: "tables"` to retrieve a list of all table names defined in the `db/schema.rb` file. This is useful for a quick overview of the database structure.

```ruby
railsMcpServer:execute_tool tool_name: "get_schema" params: { detail_level: "tables" }
```

--------------------------------

### Configure Claude Desktop Integration

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Set up Claude Desktop to launch the Rails MCP Server as an MCP subprocess using STDIO or an mcp-remote proxy for HTTP/SSE mode.

```json
// ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
// %APPDATA%\Claude\claude_desktop_config.json (Windows)
{
  "mcpServers": {
    "railsMcpServer": {
      "command": "/home/you/.rbenv/shims/ruby",
      "args": ["/home/you/.rbenv/gems/rails-mcp-server-1.5.1/exe/rails-mcp-server"]
    }
  }
}

// Or with mcp-remote proxy for HTTP/SSE mode:
// npm install -g mcp-remote
{
  "mcpServers": {
    "railsMcpServer": {
      "command": "npx",
      "args": ["mcp-remote", "http://localhost:6029/mcp/sse"]
    }
  }
}
```

--------------------------------

### List Files in Directory

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Lists files within a specified directory, optionally matching a pattern. Defaults to listing all .rb files in the project root.

```ruby
railsMcpServer:execute_tool tool_name: "list_files" params: { directory: "app/views", pattern: "**/*.erb" }
```

```ruby
railsMcpServer:execute_tool tool_name: "list_files"
```

--------------------------------

### Get Routes Analyzer

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use the `get_routes` analyzer via `execute_tool` to inspect Rails routes. Filtering by controller name, HTTP verb, or path segment is supported to narrow down the results.

```bash
railsMcpServer:execute_tool tool_name: "get_routes"
```

```bash
railsMcpServer:execute_tool tool_name: "get_routes" params: { controller: "users" }
```

--------------------------------

### Search Available Analyzers

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use `search_tools` to discover available analyzers by keyword or category. This is useful before invoking `execute_tool` when the exact analyzer name is unknown. Specify `detail_level: "full"` to see parameter definitions.

```bash
railsMcpServer:search_tools
```

```bash
railsMcpServer:search_tools category: "models"
```

```bash
railsMcpServer:search_tools query: "routes"
```

```bash
railsMcpServer:search_tools query: "analyze_models" detail_level: "full"
```

--------------------------------

### Analyze Environment Configuration

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Analyze environment configurations for potential inconsistencies and security issues.

```ruby
execute_tool(tool_name: "analyze_environment_config")
```

--------------------------------

### Execute Ruby Code in MCP Inspector

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Use the `execute_ruby` command to run Ruby code within the MCP Inspector. This is useful for testing Ruby execution, for example, reading files.

```bash
execute_ruby "puts read_file('Gemfile')"
```

--------------------------------

### Manually Configure Projects in projects.yml

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Manually define your Rails projects in the `projects.yml` file located in the XDG config directory. Each key is a project name, and the value is its file path.

```yaml
store: "~/projects/store"
blog: "~/projects/rails-blog"
ecommerce: "/full/path/to/ecommerce-app"
```

--------------------------------

### Find Project Files with Dir.glob

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Utilize `execute_ruby` with `Dir.glob()` to find files within the project based on various patterns. This is effective for locating models, controllers, views, and Stimulus controllers.

```ruby
railsMcpServer:execute_ruby code: "puts Dir.glob('app/models/**/*.rb').join('\n')"
```

```ruby
railsMcpServer:execute_ruby code: "puts Dir.glob('app/controllers/**/*.rb').join('\n')"
```

```ruby
railsMcpServer:execute_ruby code: "puts Dir.glob('app/**/*user*').join('\n')"
```

```ruby
railsMcpServer:execute_ruby code: "puts Dir.glob('app/views/**/*.erb').join('\n')"
```

```ruby
railsMcpServer:execute_ruby code: "puts Dir.glob('app/javascript/controllers/**/*.js').join('\n')"
```

--------------------------------

### Run Rails MCP Server with Custom Port

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Use this command to run the server on a custom port. The `--bind-all` flag allows access from local network IPs and .local domains, but should only be used on trusted networks.

```bash
rails-mcp-server --mode http --bind-all -p 8080
```

--------------------------------

### List Files in Directory

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

List files within a specified directory that match a given pattern. Useful for finding specific types of files, like model definitions.

```ruby
execute_tool(tool_name: "list_files", params: { directory: "app/models", pattern: "*.rb" })
```

--------------------------------

### Agent Workflow - View Template Discovery and Custom Query

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Lists all view templates within a specific directory and executes a custom Ruby query to count orders grouped by status, joining with order items.

```ruby
# Step 8: Check view templates
railsMcpServer:execute_ruby code: "puts Dir.glob('app/views/orders/**/*').join('\n')"

# Step 9: Run a custom query
railsMcpServer:execute_ruby code: "puts Order.joins(:items).group('orders.status').count.inspect"
```

--------------------------------

### Full Controller-View Analysis with Prism

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Obtain a comprehensive analysis of a controller, including runtime introspection and static analysis via Prism. This reveals strong parameters, instance variables per action, and filter definitions.

```ruby
railsMcpServer:execute_tool tool_name: "analyze_controller_views" params: { controller_name: "users", analysis_type: "full" }
```

--------------------------------

### Verbose Troubleshooting Commands

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/RESOURCES.md

Commands to enable verbose mode for resource download and import operations.

```bash
# Verbose download
rails-mcp-server-download-resources --verbose rails
```

```bash
# Verbose import
rails-mcp-server-download-resources --verbose --file /path/to/docs/
```

--------------------------------

### Find Project Files with list_files Helper

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Use the `list_files` helper within `execute_ruby` to find files matching a glob pattern, such as Ruby files in the models directory.

```ruby
railsMcpServer:execute_ruby code: "puts list_files('app/models/**/*.rb')"
```

--------------------------------

### Read Project Files with execute_ruby

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Use `execute_ruby` with the `read_file()` function to access the content of specific project files. This is the primary method for reading files.

```ruby
railsMcpServer:execute_ruby code: "puts read_file('config/routes.rb')"
```

```ruby
railsMcpServer:execute_ruby code: "puts read_file('app/models/user.rb')"
```

```ruby
railsMcpServer:execute_ruby code: "puts read_file('app/controllers/users_controller.rb')"
```

--------------------------------

### project_info Analyzer

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Returns Rails version, gem dependencies, directory tree, and project metadata. Invoked via `execute_tool`.

```APIDOC
## `project_info` Analyzer — Project Structure Overview

### Description
Returns Rails version, gem dependencies, directory tree, and project metadata. Invoked via `execute_tool`.

### Usage Examples

```
railsMcpServer:execute_tool tool_name: "project_info"

# With options
railsMcpServer:execute_tool tool_name: "project_info" params: { max_depth: 3, detail_level: "summary" }
```

### Parameters

- `max_depth`    (integer, optional): Directory tree depth, default 2, max 5
- `include_files`(boolean, optional): Include files in tree, default true
- `detail_level` (string,  optional): 'minimal', 'summary', or 'full' (default: 'full')
```

--------------------------------

### Full Model Analysis with Prism Static Analysis

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Obtain a comprehensive analysis of a model, including runtime introspection and static analysis via Prism. This reveals callbacks, scopes, concerns, and method definitions with line numbers.

```ruby
railsMcpServer:execute_tool tool_name: "analyze_models" params: { model_name: "User", analysis_type: "full" }
```

--------------------------------

### Find Files by Pattern

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Search for files within the project using glob patterns.

```ruby
railsMcpServer:execute_ruby code: "puts Dir.glob('app/**/*transaction*').join('\n')"
```

--------------------------------

### Project Info Analyzer

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

The `project_info` analyzer, invoked via `execute_tool`, provides an overview of the Rails project, including version, dependencies, and directory structure. Options like `max_depth`, `include_files`, and `detail_level` can customize the output.

```bash
railsMcpServer:execute_tool tool_name: "project_info"
```

```bash
railsMcpServer:execute_tool tool_name: "project_info" params: { max_depth: 3, detail_level: "summary" }
```

--------------------------------

### Switch Project with Rails MCP Server

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Call the switch_project tool to change the active Rails project. This must be done before using other tools.

```json
{
  "tool_name": "switch_project",
  "params": {
    "project_name": "my_rails_project"
  }
}
```

--------------------------------

### Project Configuration - projects.yml

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Defines project paths in a YAML file for the rails-mcp server. Supports macOS/Linux and Windows configurations.

```yaml
# ~/.config/rails-mcp/projects.yml
# (macOS/Linux: $XDG_CONFIG_HOME/rails-mcp/projects.yml)
# (Windows:     %APPDATA%\rails-mcp\projects.yml)

store:      ~/projects/store-app
blog:       ~/projects/rails-blog
ecommerce:  /full/path/to/ecommerce-app
```

--------------------------------

### Discover Tools in MCP Inspector

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Use the `search_tools` command in the MCP Inspector to discover available analyzers for your project. This is part of the testing workflow.

```bash
search_tools
```

--------------------------------

### Execute Internal Analyzers

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

The `execute_tool` command invokes internal analyzers. Parameters can be provided as a hash or JSON string. Refer to the tool documentation for specific parameter requirements.

```bash
railsMcpServer:execute_tool tool_name: "project_info"
```

```bash
railsMcpServer:execute_tool tool_name: "analyze_models" params: { model_name: "User", analysis_type: "full" }
```

--------------------------------

### Configure MCP Server with Environment Variable

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Alternatively, configure the Rails MCP Server using the RAILS_MCP_PROJECT_PATH environment variable within the mcp.json configuration.

```json
{
  "mcpServers": {
    "rails": {
      "type": "local",
      "command": "rails-mcp-server",
      "env": {
        "RAILS_MCP_PROJECT_PATH": "."
      },
      "tools": ["switch_project", "search_tools", "execute_tool", "execute_ruby"]
    }
  }
}
```

--------------------------------

### List Ruby Files in a Directory

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use the `list_files` tool to list files within a specified directory that match a glob pattern. This is useful for finding specific types of files, such as all Ruby files in the models directory.

```ruby
railsMcpServer:execute_tool tool_name: "list_files" params: { directory: "app/models", pattern: "*.rb" }
```

--------------------------------

### Analyze Models with Associations

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Use the `analyze_models` tool with `detail_level: "associations"` to retrieve information about all associations for every model in the application. This helps in understanding data relationships.

```ruby
railsMcpServer:execute_tool tool_name: "analyze_models" params: { detail_level: "associations" }
```

--------------------------------

### Read Controller File

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Read the contents of a controller file.

```ruby
railsMcpServer:execute_ruby code: "puts read_file('app/controllers/transactions_controller.rb')"
```

--------------------------------

### Configure Rails MCP Server with Ruby Version Manager Shim

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

For Ruby version manager users, specify the Ruby shim path in the Claude Desktop configuration to ensure the correct Ruby version is used for the MCP server.

```json
{
  "mcpServers": {
    "railsMcpServer": {
      "command": "/home/your_user/.rbenv/shims/ruby",
      "args": ["/full/path/to/rails-mcp-server/exe/rails-mcp-server"]
    }
  }
}
```

--------------------------------

### Switch Project

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Switches the active project when multiple projects are defined in projects.yml. This command is used before other operations that depend on the active project context.

```ruby
railsMcpServer:switch_project project_name: "store"
```

--------------------------------

### Direct Claude Desktop MCP Server Configuration

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Manually configure Claude Desktop to use the Rails MCP Server by creating a projects.yml file and updating the `claude_desktop_config.json`.

```json
{
  "mcpServers": {
    "railsMcpServer": {
      "command": "ruby",
      "args": ["/full/path/to/rails-mcp-server/exe/rails-mcp-server"]
    }
  }
}
```

--------------------------------

### Configure Claude Desktop to Use MCP Proxy

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Configure Claude Desktop to use an MCP proxy, allowing STDIO-only clients to communicate with the Rails MCP Server through its HTTP/SSE capabilities.

```json
{
  "mcpServers": {
    "railsMcpServer": {
      "command": "npx",
      "args": ["mcp-remote", "http://localhost:6029/mcp/sse"]
    }
  }
}
```

--------------------------------

### MCP Configuration with RAILS_MCP_PROJECT_PATH

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/COPILOT_AGENT.md

Configure MCP server to explicitly set the project path using the RAILS_MCP_PROJECT_PATH environment variable. This JSON file should be placed at .github/copilot/mcp.json.

```json
{
  "mcpServers": {
    "rails": {
      "type": "local",
      "command": "rails-mcp-server",
      "env": {
        "RAILS_MCP_PROJECT_PATH": "."
      }
    }
  }
}
```

--------------------------------

### Retrieve File Content

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Fetches the content of a specific file. Ensure the path is accurate to retrieve the desired file.

```ruby
execute_tool(tool_name: "get_file", params: { path: "app/models/user.rb" })
```

--------------------------------

### Agent Workflow - Model and Schema Analysis

Source: https://context7.com/maquina-app/rails-mcp-server/llms.txt

Analyzes data models and retrieves database schema information. Supports full model analysis and fetching schema for specified table names.

```ruby
# Step 5: Understand the data model (introspection + Prism static analysis)
railsMcpServer:execute_tool tool_name: "analyze_models" params: { model_name: "Order", analysis_type: "full" }
railsMcpServer:execute_tool tool_name: "get_schema" params: { table_names: ["orders", "order_items"] }
```

--------------------------------

### search_tools Tool

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Enables discovery of available tools by category or keyword, helping users find the right tool for their task.

```APIDOC
## search_tools

### Description
Discover available tools by category or keyword.

### Parameters
#### Query Parameters
- **query** (String, optional) - Search term (e.g., 'routes', 'model', 'schema')
- **category** (String, optional) - Filter by category: models, database, routing, controllers, files, project, guides
- **detail_level** (String, optional) - Output detail: 'names', 'summary', or 'full' (default: 'summary')
```

--------------------------------

### Switch Project in MCP Inspector

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Use the `switch_project` command within the MCP Inspector to change the active project. This is the first step in the testing workflow.

```bash
switch_project <your project name>
```

--------------------------------

### Analyze Controller and Views

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/docs/AGENT.md

Use this tool to analyze controller actions, callbacks, and views. An optional 'analysis_type' parameter can be set to 'full' for Prism analysis, including filters, strong params, and instance variables.

```ruby
railsMcpServer:execute_tool tool_name: "analyze_controller_views" params: { controller_name: "users" }
```

```ruby
railsMcpServer:execute_tool tool_name: "analyze_controller_views" params: { controller_name: "users", analysis_type: "full" }
```

--------------------------------

### switch_project Tool

Source: https://github.com/maquina-app/rails-mcp-server/blob/main/README.md

Allows changing the active Rails project. This tool must be called before using other tools to ensure operations are performed on the correct project.

```APIDOC
## switch_project

### Description
Change the active Rails project. Must be called before using other tools.

### Parameters
#### Path Parameters
- **project_name** (String) - Required - Name of the project as defined in projects.yml

### Notes
After switching, you'll see a Quick Start guide with common commands.
```