Documentation Index Fetch the complete documentation index at: https://mintlify.com/mrexodia/ida-pro-mcp/llms.txt
Use this file to discover all available pages before exploring further.
Modification tools let you annotate and restructure an open IDB without leaving your AI workflow. You can add or append comments in both the disassembly and decompiler views, batch-rename every kind of symbol in one call, patch individual instructions or raw byte sequences, and define or undefine functions and code items on demand.
Set a comment at one or more addresses. Comments are written to the disassembly view and, when the Hex-Rays decompiler is available, to the pseudocode view as well.
items
CommentOp | CommentOp[]
required
A single comment operation or a list of them. Target address — hex (0x401000) or decimal, or a named symbol (main).
Comment text. Pass an empty string to clear an existing comment.
Returns CommentResult[]Show CommentResult fields
The address that was targeted, echoed back.
Present only when the operation failed.
When the address is the entry point of a function, set_comments writes a function-level comment (visible at the top of the decompiled output) rather than a line comment.
Single comment
Batch comments
{ "addr" : "0x401000" , "comment" : "Entry point of the crackme — checks serial" }
Append text to an existing comment at one or more addresses. By default, duplicate lines are silently skipped.
items
CommentAppendOp | CommentAppendOp[]
required
A single append operation or a list of them. Show CommentAppendOp fields
Where to write the comment: auto (function-level if at function start, otherwise line-level), func, or line.
When true, the append is skipped if the trimmed text already appears as a line in the current comment.
Returns AppendCommentResult[]Show AppendCommentResult fields
func or line — which comment slot was modified.
Present and true when text was written.
Present and true when deduplication prevented a write.
rename Batch-rename functions, global variables, local decompiler variables, and stack frame variables in a single call.
At least one of func, data, local, or stack must be present. func
FunctionRename | FunctionRename[]
Rename one or more functions by address. Show FunctionRename fields
data
GlobalRename | GlobalRename[]
Rename one or more global / data symbols. local
LocalRename | LocalRename[]
Rename a local variable inside the Hex-Rays decompilation of a function. Address of the containing function.
stack
StackRename | StackRename[]
Rename a stack frame variable (IDA frame member, not a Hex-Rays lvar). Address of the containing function.
Abort the batch on the first failure.
Validate all renames without committing any changes.
Force the rename even when the target name already exists elsewhere in the IDB.
Returns RenameResultPer-item outcomes for function renames.
Per-item outcomes for global renames.
Per-item outcomes for local variable renames.
Per-item outcomes for stack variable renames.
Total operations attempted.
Whether the batch was halted early.
Echoed when dry-run mode was active.
Newly renamed functions are automatically placed in a /vibe/ folder in IDA’s function tree, making it easy to track AI-assisted annotations.
Rename a function
Rename local variables
Mixed batch with dry-run
{ "func" : { "addr" : "0x401000" , "name" : "validate_serial" } }
patch_asm Assemble and patch one or more instructions at a given address. Multiple instructions can be chained with semicolons.
items
AsmPatchOp | AsmPatchOp[]
required
A single patch operation or a list of them. Start address for the patch.
Assembly text. Separate multiple instructions with ; — they are assembled sequentially, each starting where the previous one ended.
Returns PatchAsmResult[]Show PatchAsmResult fields
The address that was patched.
Patch a conditional jump to unconditional
{ "addr" : "0x401045" , "asm" : "jmp 0x401060" }
patch Write raw bytes to one or more addresses. Use this for patches that cannot be expressed as assembly, such as overwriting data or inserting NOPs by hand.
patches
MemoryPatch | MemoryPatch[]
required
A single patch or a list. Hex bytes to write, as a contiguous hex string (e.g., "9090" for two NOPs).
Returns PatchResult[]patch writes directly to the IDB. The original bytes are not automatically saved. Use IDA’s Edit → Patch program → Restore original byte if you need to undo.
NOP two bytes at 0x401045
{ "addr" : "0x401045" , "data" : "9090" }
define_func Tell IDA to define a function starting at the given address. IDA infers the function bounds automatically unless you supply an explicit end address.
items
DefineOp | DefineOp[]
required
Start address of the function to define.
Optional end address. When omitted, IDA locates the function boundary automatically.
Returns DefineResult[]Input address, echoed back.
Resolved start address of the created function.
End address of the created function.
Present only on failure — includes "Function already exists" when a function is already defined at that address.
Define function at a known address
define_code Convert the byte(s) at the given address into a code instruction. Useful when IDA has left bytes unanalyzed or marked them as data.
items
DefineOp | DefineOp[]
required
Address to decode as an instruction.
Returns DefineResult[]Resolved effective address.
Byte length of the decoded instruction.
undefine Revert one or more items back to raw, undefined bytes. Accepts an explicit end address or a byte count; defaults to a single byte.
items
UndefineOp | UndefineOp[]
required
Start address of the region to undefine.
Optional end address (exclusive). Takes precedence over size.
Optional byte count. Used when end is not provided.
Returns DefineResult[]Number of bytes that were undefined.
Undefine a 16-byte region
{ "addr" : "0x402000" , "size" : 16 }
