Mikes Moose MCP

This is a helper that makes AI assistants (like Cline, Claude, or Cursor) much better at writing mission scripts for DCS World using the MOOSE framework. It works by giving the AI accurate, up-to-date information about MOOSE — so it stops guessing and starts writing code that actually runs.

What problem does it solve?

AI models are trained on internet data, and their knowledge of MOOSE is often out of date or just wrong. They might use a class that no longer exists, call a method with the wrong name, or write Lua that won't work in DCS.

This helper solves that by handing the AI a 10-megabyte reference manual it can dip into, without ever loading the whole thing. It's the difference between asking a friend who "kind of remembers" MOOSE, and handing them a book that's open to exactly the right page. Instead of relying on its memory, the AI can ask the helper:

• "What methods does the SPAWN class have?"

• "How do I schedule something to happen every 30 seconds?"

• "Is this code I wrote valid MOOSE?"

• "What group names are actually in my mission file?"

• "Why did my script error out?"

The helper answers with small, precise facts pulled from your actual MOOSE files — not from the AI's fuzzy memory. The trick that makes this possible is that the 10 MB file is parsed once into a searchable index, and the AI only ever sees the little slice it asks for. Which raises the obvious question: how does that not obliterate the AI's (small) working memory? Read on.

Related MCP server: llms-mcp

Why a 10 MB file doesn't blow your AI's context window

This is the single most important idea in the whole project, so it's worth spelling out.

An AI assistant talks to you using a limited "working memory" called the context window — a budget of tokens (roughly, chunks of text) it can hold and reason over at once. MOOSE's main file is about 10 MB of Lua and documentation — far more than fits in that window. If you just pasted the whole file, you'd instantly blow the budget and the AI would stop working.

So this helper never sends the whole file to the AI. Instead:

1. Parsed once, indexed forever. When you install, the helper reads the 10 MB Moose.lua, breaks it into 587 classes and 6,379 methods, and stores them in a small searchable index on your disk.

2. The AI asks, the index answers. When the AI needs to know about, say, the SPAWN class, it doesn't get the whole file — it gets just SPAWN's documentation and method signatures. Maybe 200–500 tokens.

3. Answering costs pennies of the budget. A single lookup is like opening one page of a book and reading it aloud. The other 9,999 pages stay closed on the shelf.

4. Your version, not a stranger's. Because the index is built from your Moose.lua, the answers match the exact MOOSE build your missions use. The AI is never reasoning about an outdated copy.

The result: the AI gets the accuracy of a full 10 MB reference manual while only spending a few hundred tokens at a time. That's what makes it practical for small, budget AI models — not just top-tier ones.

What you need before you start

This is a one-time setup. You'll need:

1. DCS World installed (any edition — Stable or OpenBeta), since the whole point is reading your mission files and logs.

2. Node.js, the program that runs JavaScript helper tools like this one. If you don't have it or aren't sure, follow the short check below.

3. An AI assistant that supports "MCP servers". Cline, Claude Desktop, and Cursor all do. If you're using Cline, you're already good to go.

Don't worry if you've never heard of MCP or Node before — the next two sections walk you through it with no assumed knowledge.

Step 1 — Do you have Node.js?

Node.js is a free program that runs helper tools on your computer. To check if you have it:

• Windows: press the Windows key, type cmd, and press Enter. In the black window, type:

  node --version

  If you see something like v20.0.0, you have it. If you see 'node' is not recognized, you need to install it.

To install it (Windows):

1. Go to https://nodejs.org

2. Download the LTS version (the big green button)

3. Run the installer — click Next through everything, using the default options

4. Reopen the cmd window and run node --version again to confirm

Step 2 — Get and install this helper

There isn't a pre-built "release" you download and run. This helper is source code that you download once, then build on your own machine. It's not hard — the commands below do all the work.

Once Node.js is working:

1. Get the software from here:

   https://github.com/thebgpikester/Mikes-Moose-MCP

   • Click the green Code button → Download ZIP, then unzip it to somewhere you'll remember — e.g. C:\moose-mcp.

   • (Or, if you have Git installed, you can instead run git clone https://github.com/thebgpikester/Mikes-Moose-MCP.git C:\moose-mcp — same result.)

   You should now have a folder C:\moose-mcp containing items like src/, package.json, README.md, and LICENSE.

2. Open cmd and go into that folder:

   cd C:\moose-mcp

3. Run the install command (this downloads the helper's dependencies — takes a minute or two the first time):

   npm install

4. Run the build command (this compiles the source into the program your AI assistant will actually run):

   npm run build

That's it. The helper is now installed and ready.

How the helper finds MOOSE knowledge — your MOOSE, not a stranger's

The helper reads a Moose.lua file and turns it into a searchable index the AI uses to answer questions. There are two ways to give it that file. You can use one or both — it's quick and safe to switch between them.

Option A — Use the downloaded latest MOOSE (easiest, once)

Run this once to fetch the most recent official MOOSE framework file from the internet:

npm run download-reference

This stores a clean reference copy the helper can index. It's a good starting point, and it's the file used if you ever ask the helper to index "the latest MOOSE."

Option B — Use YOUR MOOSE (recommended for missions)

This is the important one. Your DCS/missions don't necessarily use the latest MOOSE — they use whatever Moose.lua you ship or load. So for answers that match your setup exactly, point the helper at your own file. You don't even need a command — just tell your AI assistant, and it will call the moose_ingest tool with the path to your file (for example):

moose_ingest
  path: "C:\\Users\\YourName\\Saved Games\\DCS\\Scripts\\Moose.lua"

It works with any real file path, including a network (UNC) share:

moose_ingest
  path: "\\\\ServerName\\Shared\\Missions\\Moose.lua"

It also works directly on a mission file, pulling out whichever Moose.lua is embedded inside it:

moose_ingest
  path: "C:\\Users\\YourName\\Missions\\MyMission.miz"

What to expect when you ingest a file

When the AI calls moose_ingest, you'll get a short status back, something like:

{
  "ok": true,
  "message": "Indexed 587 types, 6379 methods.",
  "status": {
    "source": "local",            // "local", "reference-download", or "miz-embedded"
    "filePath": "C:\\Users\\YourName\\Saved Games\\DCS\\Scripts\\Moose.lua",
    "commit": "2026-02-06...130d358f4a...",   // the exact MOOSE build, if detectable
    "typeCount": 587,
    "methodCount": 6379
  }
}

Three things to know:

• Do this after you update MOOSE. If you switch to a newer/older Moose.lua, re-run moose_ingest with the new path. The index is rebuilt to match that file.

• Re-ingesting the same file is free. The helper hashes the file; if nothing changed, it just refreshes the timestamp — no rebuild.

• The index is for one file at a time. The current setup indexes the file you most recently asked for. If you switch between your local copy and the reference download, the last one you ingested is the one the AI sees. That's deliberate — it stops the AI from mixing answers across two different MOOSE versions.

Want to test it? Type npm test. It should run through a few checks and print something like All 5 suites passed. If it does, everything works.

Step 3 — Connect it to your AI assistant

An MCP server is just a small program that your AI assistant can talk to, like an extra pair of eyes. You tell your assistant where the helper is, and it does the rest.

If you use Cline

1. Open Cline's settings (the ⚙️ icon, then "MCP Servers").

2. Add a new server with these exact settings, changing the path to where you unzipped the project:

   {
     "mcpServers": {
       "moose-mcp": {
         "command": "node",
         "args": ["C:\\moose-mcp\\build\\index.js"]
       }
     }
   }

   (Make sure C:\moose-mcp matches where you actually put it.)

3. Restart your assistant / reload the window.

If you use Claude Desktop

1. Open the file claude_desktop_config.json (in Claude's settings folder — the app can open it for you).

2. Add the same block above to the mcpServers section.

3. Restart Claude.

After this, your assistant should show a list of new tools it can use (they're all named moose_*).

Step 4 — How to use it

Once connected, just talk to your assistant normally and it will use the MOOSE tools automatically when it makes sense. For example:

• "Write a script that spawns a flight of F-18s when a unit enters a zone." — the assistant will look up the correct SPAWN and ZONE classes and write Lua 5.1 code that follows MOOSE best practices.

• "Check this code I wrote" — paste in some Lua and ask it to verify. The assistant will check every class and method name against the real MOOSE.

• "Tell me how to use CARGO" — it will point you at a real example in the official MOOSE missions repository, rather than guessing.

• "Why did my mission error?" — if you've turned on the debug logger (see below), it can read your dcs.log and tell you exactly what went wrong and where, including which unit/group the error concerns.

Turning on the debug logger

If you want the helper to be able to read what actually happened in a mission (not just what should have happened), drop a small file into your mission:

1. Ask your assistant for the file (or take it from src/logger-helper.lua in this project).

2. Put it in your mission's Scripts folder, alongside (before) Moose.lua.

3. Logging is on by default now. To turn it off later, set GM.DEBUG = false in that file.

With logging on, your assistant can parse dcs.log, find the current session, and tell you exactly what your script did — and what failed.

What's under the hood (in plain terms)

The helper has four jobs, and together they form a complete picture. Think of it as four reference books the AI can open:

Why "version-matched" matters: DCS/missions use whichever MOOSE build they ship. The helper reads that file, so the AI never tells you about a method that doesn't exist in your version.

Troubleshooting

For developers

• Source code: everything is in the src/ folder (TypeScript files + one Lua helper).

• Run from source (while developing): npm run dev

• Test: npm test

• The four pillars map to pillar1 (parser/index), pillar2-tools.ts (practice), pillar3-parser.ts (mission), pillar4-reader.ts (log).

In short: install once, connect once, and your AI assistant stops guessing about MOOSE and starts writing DCS mission code that works.