# redm-mcp (remote · redm-mcp.fivem.no)

RedM / RDR3 docs MCP server: native lookups, semantic search, VORP, RSGCore, oxmysql.

- Trust score: 62/100 (medium)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `redm-mcp.fivem.no`: 62/100 (this document), [markdown](https://verifymcp.io/servers/cmoen11-redm-mcp/redm-mcp.md), [page](https://verifymcp.io/servers/cmoen11-redm-mcp/redm-mcp)

## Channel facts

- Endpoint: `https://redm-mcp.fivem.no/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.1.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 60/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 10 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 49/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5270 tokens (~527/item across 10 items; 10 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 96/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 88% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http cmoen11-redm-mcp https://redm-mcp.fivem.no/mcp
```

### Codex

```toml
[mcp_servers.cmoen11-redm-mcp]
url = "https://redm-mcp.fivem.no/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cmoen11-redm-mcp": {
      "type": "remote",
      "url": "https://redm-mcp.fivem.no/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cmoen11-redm-mcp --url https://redm-mcp.fivem.no/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  cmoen11-redm-mcp:
    url: "https://redm-mcp.fivem.no/mcp"
```

### Other

```json
{
  "mcpServers": {
    "cmoen11-redm-mcp": {
      "type": "http",
      "url": "https://redm-mcp.fivem.no/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 61, +2)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 59, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 59, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-28 (score 58, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 57, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 57)

First indexed and scored.

## MCP tools (10)

### `semantic_search` (~431 tokens)

Hybrid search RedM docs (semantic + lexical)

Search RedM/RDR3 docs by behavior, concept, OR exact token. Use when you don't have a specific native hash/name (use `lookup_native`) and the term isn't a known asset name in a large data table (use `grep_docs`). Hybrid mode (default) handles 'how do I X' queries ('teleport player', 'spawn vehicle', 'inventory add item') AND tokens ('addItem', 'weapon_pistol_volcanic', 'CPED_CONFIG_FLAG_') — fused via RRF over vector + BM25. Returns ranked snippets (path, breadcrumb, heading, snippet, score). Call `get_document({path, heading})` for full chunk content. `mode=semantic` for pure vector; `mode=lexical` for pure BM25. Filter via `category=vorp|rsgcore|oxmysql|natives|discoveries|jo_libs|learnings` or `namespace`. Community findings merged by default; `category=learnings` returns only findings. If you are retrying after a previous call returned no useful results, populate `prior_attempt` so the server can surface alternative wordings and learn what's missing from the docs.

Input parameters:

- `category` (string): Limit to one doc category
- `limit` (integer): How many ranked snippets to return. Default 20 (Anthropic contextual-retrieval research: top-20 outperforms top-5/10 before reranking).
- `mode` (string): Retrieval mode. Default hybrid (recommended).
- `namespace` (string): Limit to a native namespace, e.g. PLAYER, ENTITY
- `prior_attempt` (object): Populate ONLY when retrying after a previous semantic_search call returned no useful results. Skip on first attempts.
- `query` (string, required): Natural language or token query
- `responseFormat` (string): `concise` (default): 400-char snippet per hit — cheap, browse-style. `detailed`: full chunk content — use when you need an answer in one round-trip and want to skip the `get_document` follow-up.

### `list_namespaces` (~144 tokens)

List RedM doc namespaces

Orient yourself: list available doc categories and their namespaces. Use once at session start (or when unsure) before applying a `category=` / `namespace=` filter to `browse` / `semantic_search`. NOT a content search. Categories: `natives` (PLAYER, ENTITY, VEHICLE, …), `vorp`, `rsgcore`, `oxmysql`, `discoveries` (AI, weapons, peds, animations, clothes, objects, …), `jo_libs` (menu, notification, callback, framework-bridge, …, dev_resources, redm_scripts), `guides`, `learnings`.

Input parameters:

- `category` (string)

### `browse` (~85 tokens)

Browse RedM doc paths

Enumerate doc paths in a category/namespace. Use to discover what exists before calling `get_document` or a targeted `grep_docs`. NOT a content search — use `semantic_search` for behavior/concept lookups or `grep_docs` for token lookups. Returns `{path, title, chunks}[]`.

Input parameters:

- `category` (string)
- `namespace` (string)

### `get_document` (~357 tokens)

Get full RedM doc

Fetch full markdown of a doc by `path` (as returned by `browse`, `semantic_search`, or `grep_docs`). Use to retrieve full content after a search snippet looks promising. Pass `heading` (full breadcrumb like `Character Management > Inventory Management`, or just the leaf — case-insensitive, fuzzy) to fetch only that section. Deep-heading matches auto-prepend the H2 parent's intro for context. For individual script natives prefer `lookup_native`. The largest rdr3_discoveries lua data tables are keyed catalogs: call with no `heading` to list their top-level keys, then pass a key as `heading` to fetch that one entry; use `grep_docs` to search values inside. For code symbols (`addItem`) use `grep_docs`. Community findings use `learning:N` paths, not `learnings/<slug>.md`. On 404 returns available headings + cross-file hints.

Input parameters:

- `heading` (string): Optional prose heading from the doc, e.g. `Add Item to User` or `Character Management > Inventory Management`. Case-insensitive, fuzzy match on the leaf (text after the final `>`). NOT for code symbo…
- `path` (string, required): Doc path. Two valid shapes: (a) `<category>/<file>.md` for docs, e.g. `vorp/vorp_core_docs.md`; (b) `learning:<id>` for community findings, e.g. `learning:11`. Use the path returned by `browse`/`sema…

### `read_lines` (~352 tokens)

Read an exact line range from a raw doc file

Read an exact line range from a raw doc file by absolute line number — the windowed-read companion to `grep_docs`. When `grep_docs` returns a hit at `path:line` inside a large file, call `read_lines({ path, start, end })` to pull the surrounding block. This is the ONLY way to read around a hit in the largest rdr3_discoveries data tables (audio_banks, ingameanims_list, ptfx, soundsets, imaps_with_coords, megadictanims, etc.): their full bodies are NOT in the vector/heading index (only an ~80-line preview is), so `semantic_search` can't reach them and `get_document` resolves real section headings only — NOT synthetic `lines N-M` offsets. `start`/`end` are 1-based and inclusive; omit `end` for a 50-line window; one call returns at most 400 lines (narrow the range for more). For prose `.md` docs prefer `get_document` with a `heading`; to search values use `grep_docs`; for individual script natives use `lookup_native`.

Input parameters:

- `end` (integer): Last line to return (1-based, inclusive). Omit for a 50-line window from `start`. Spans over 400 lines are capped.
- `path` (string, required): Doc path exactly as returned by `grep_docs` / `browse` / `semantic_search`, e.g. `discoveries/audio/audio_banks/audio_banks.lua`. Do not invent paths.
- `start` (integer, required): First line to return (1-based, inclusive). Use the line number from a `grep_docs` hit.

### `grep_docs` (~666 tokens)

Literal/regex grep over raw doc files

Find an EXACT literal token in raw doc files (markdown + lua). Use for specific weapon/ped/animation/prop/interior/zone names (`weapon_pistol_volcanic`, `a_c_bear_01`, `p_campfire01x`), known hashes (`0x020D13FF`), walkstyles/clipsets (`MP_Style_Casual`, `mech_loco_m@`), or any string you'd `grep` for. NOT for behavior/concept queries (use `semantic_search`) or script-native hash/name lookup (use `lookup_native`). REQUIRED for tokens inside the largest rdr3_discoveries data tables (audio_banks, ingameanims_list, cloth_drawable, cloth_hash_names, object_list, megadictanims, entity_extensions, imaps_with_coords, propsets_list, vehicle_bones) — only preview-indexed for embeddings, so `semantic_search` will NOT find tokens in them. Optional: `contextBefore`/`contextAfter` for ±N surrounding lines (saves a follow-up `get_document` call); `filesOnly: true` to get paths only (cheap exploration); `multiline: true` for cross-line patterns (`(?s)foo.*bar`). Pattern uses Rust regex syntax (rg engine). PREFER one targeted call over giant `a|b|c|d|e` alternations — split into separate calls; alternations rarely improve recall and bloat the regex automaton. Returns matched lines with path + line number. Long matched lines are windowed ±60 chars around the match (…); to read around a hit, use `read_lines({path, start})` for the preview-only mega-tables listed above (get_document holds only their ~80-line head), or `get_document({path})` for ordinary docs. If you are retrying after a previous pattern returned no matches, populate `prior_attempt` so the server can record what didn't work and steer alternative spellings.

Input parameters:

- `caseInsensitive` (boolean): Default true. Set false for case-sensitive match.
- `category` (string): Limit to a doc category (e.g. discoveries, natives).
- `contextAfter` (integer): Include N lines after each match (rg -A).
- `contextBefore` (integer): Include N lines before each match (rg -B). Saves follow-up get_document calls when you need surrounding context.
- `filesOnly` (boolean): Return only the list of matching paths (no per-line matches). Cheap for exploration before zoom-in.
- `limit` (integer)
- `multiline` (boolean): Allow `.` to match newlines and patterns to span lines (rg -U --multiline-dotall). Use for `(?s)foo.*bar` style.
- `pathSubstring` (string): Substring filter on relative doc path, e.g. 'weapons' or 'clothes/cloth_hash_names'.
- `pattern` (string, required): Rust regex pattern (ripgrep engine). Case-insensitive by default. Prefer narrow, single-token patterns over kitchen-sink alternations.
- `prior_attempt` (object): Populate ONLY when retrying after a previous grep_docs call returned no matches. Skip on first attempts.

### `lookup_native` (~415 tokens)

Lookup RedM native by hash or name

Resolve a RedM/RDR3 SCRIPT native by hash or name — O(1), exact. Use whenever you see `Citizen.InvokeNative(0x...)`, `Citizen.invokeNative('0x...')`, `GetHashKey('NAME')`, or a SCREAMING_SNAKE_CASE native name (e.g. `SET_ENTITY_COORDS`, `GetPedHealth`) in Lua/JS/TS. NOT for game-data hashes (weapon/ped/animation names) — use `grep_docs`. Pass `hash` (0x… optional, case-insensitive) or `name` (exact first, ILIKE substring fallback). Returns name, hash, namespace, return type, params, description, full content, plus `findings[]` — community gotchas linked to that native. Inspect `findings[].id` and call `get_document({path: 'learning:<id>'})` for full body. Also returns `refDocs[]` — enum/flag value tables for that native (the constants to pass for params like flagId/attributeIndex/eventType). When `refDocs[].content` is set, it's the inline enum table — use those values directly. When `content` is null but `refDocs[].fetch` is present, the table was too large to inline — run that exact call (e.g. `get_document({ path: "refdoc:eEventType" })`) to get the full table; `refDocs[].preview` shows the first lines. github entries (no `fetch`) are url-only.

Input parameters:

- `hash` (string): Native hash, e.g. 0x09C28F828EE674FA (case-insensitive, 0x optional)
- `limit` (integer)
- `name` (string): Native name, e.g. CAN_PLAYER_START_MISSION. Substring match if no exact hit.
- `namespace` (string): Restrict to a namespace, e.g. PLAYER, ENTITY. Only used with `name`.

### `asset_lookup` (~1039 tokens)

Lookup RedM game-data asset (ped/weapon/object/door/vehicle)

Resolve a RedM game-data asset (ped model, weapon, object, door, vehicle) by exact name, 32-bit hash, or partial-name search. O(1) structured lookup against pre-parsed discoveries tables — replaces the common workflow of grepping `a_c_bear_01` in peds_list.lua, then cross-referencing RELATIONSHIP/README.md for its relationship group. Returns: type, name, normalized hash (`0x` + 8 uppercase hex), source file + line, plus type-specific metadata (peds get `variants` + `relationship`, weapons get `group`, doors get `coords` + `model_hash`, objects get `category`/`subcategory`). Catalog ~22,500 entries (mostly objects). Typical latency p50 ~15ms, p95 ~65ms.

NOT for:
\- **Script natives** like `SET_ENTITY_COORDS`, `GetPedHealth`, or hashes from `Citizen.InvokeNative(0x...)` — use `lookup_native`. Native hashes are 64-bit (`0x06843DA7060A026B`); asset hashes are 32-bit (`0xBCFD0E7F`). Different namespaces, never collide.
\- **Flag enums, settings, clipsets, scenario keys** like `CPED_CONFIG_FLAGS`, `MP_Style_Casual`, `mech_loco_m@`, `MAGGIE_SEAT_CHAIR_DESK_WRITING`. Those live as tokens in lua source but not in this catalog. Use `grep_docs`.
\- **Behavior queries** ("which animal is the bear", "weapons in the lemat family") — use `semantic_search`.

Pass exactly ONE of `name` / `hash` / `search`. Optional `type` narrows to a category (useful when a fragment like "horse" hits both peds and vehicles). Note: `type` reflects the SOURCE FILE — the same asset name can exist under multiple `type`s. e.g. `mp006_p_mshine_int_door01x` appears as `type=object` (1 row from object_list.lua) AND `type=door` (2 rows from doorhashes.lua, different door hashes for distinct in-world instances with `coords`). Pick `type=door` when you want lockable in-world doors with positions; `type=object` for the model itself.

Examples:
\- `{name: "a_c_bear_01"}` → exact ped lookup, returns variants=11 + relationship=REL_WILD_ANIMAL_PREDATOR.
\- `{hash: "0xBCFD0E7F"}` → resolves to ped `a_c_bear_01` (omit…

Input parameters:

- `hash` (string): Asset hash (32-bit jenkins) in HEX format, case-insensitive, `0x` prefix optional. Examples: `0xBCFD0E7F`, `bcfd0e7f`. Use when you have a hash from decompiled code or another table and need the cano…
- `limit` (integer): Max matches to return. Default 5, max 50. Only applies to `search` — exact `name`/`hash` always return 0 or 1.
- `name` (string): Exact asset name, case-insensitive. Examples: `a_c_bear_01`, `weapon_pistol_volcanic`, `p_safe01`, `armysupplywagon`. Use when you know the precise name.
- `search` (string): Substring fragment within asset name, case-insensitive. Examples: `lemat`, `norfolk`, `volcanic`. Use when you remember part of the name. Algorithm: exact substring (ILIKE) first; if zero hits, falls…
- `type` (string): Filter results to one category. Useful when a name fragment matches multiple types (e.g. `horse` hits peds + vehicles).

### `share_finding` (~337 tokens)

Share a verified finding back to the docs

Share a verified finding back to the docs corpus so the next agent can find it. Use AFTER solving a non-trivial problem to record what would have saved you time: a gotcha, a working parameter combo, an undocumented constraint, a relationship between two natives that isn't obvious. Other agents will find this via `semantic_search` (findings are merged into default results; `category: 'learnings'` returns only findings).

WHEN to use:
\- You burned multiple iterations on something not in the docs.
\- You discovered an undocumented quirk (param order, hash collision, framework export that isn't in `vorp`/`rsgcore`).
\- You verified that a specific combination works (e.g. native A + flag B for behavior C).

WHEN NOT to use:
\- The information is already in the docs (verify with `semantic_search`/`grep_docs` first).
\- You're guessing — only contribute verified findings.
\- It's project-specific (your repo's auth flow, your DB schema). Keep it general to RedM/RDR3.

Keep `title` short and searchable. `body` should explain WHY, not just WHAT — context, the trap, the fix.

Input parameters:

- `body` (string, required): Markdown explaining WHY: context, the trap, the fix, verified behavior.
- `category` (string): Optional doc category this relates to.
- `source` (string): Optional short identifier of the contributing agent.
- `tags` (array): Up to 8 lowercase tags, e.g. ['weapons', 'damage'].
- `title` (string, required): Short, searchable summary of the finding.

### `get_invoke_guide` (~124 tokens)

Get native invocation guide for a language

Load the calling-convention reference for RedM/RDR3 natives in `js` or `lua`. Call ONCE per session before writing native-calling code — every native doc page only shows Lua examples, so JS/TS authors need this to translate correctly. Covers result modifiers (`Citizen.resultAsInteger/Float/String/Vector`), `Citizen.invokeNative` vs `invokeNativeByHash`, type mapping, pointer-arg gotchas, worked examples. Cheap, no embedding.

Input parameters:

- `language` (string, required): Target language: 'js' or 'lua'

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/cmoen11-redm-mcp/redm-mcp#diagnostics

## Score history

- 2026-08-03: 62
- 2026-08-02: 62
- 2026-08-01: 61
- 2026-07-31: 61
- 2026-07-30: 59
- 2026-07-29: 59
- 2026-07-28: 58
- 2026-07-27: 57
- 2026-07-26: 57

## Links

- Remote endpoint: https://redm-mcp.fivem.no/mcp
- Repository: https://github.com/Cmoen11/redm-mcp-public
- Website: https://redm-mcp.fivem.no/dashboard
- Changelog RSS feed: https://verifymcp.io/servers/cmoen11-redm-mcp/redm-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/cmoen11-redm-mcp/redm-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/cmoen11-redm-mcp/redm-mcp