ida-mcp-server

Instructions

Implementation Reference

• plugin/ida_mcp_server_plugin/ida_mcp_core.py:147-172 (handler)

  Core handler logic: extracts assembly by iterating idautils.FuncItems(address) and collecting idc.GetDisasm for each instruction.

  def _get_function_assembly_by_address_internal(self, address: int) -> Dict[str, Any]:
      """Internal implementation for get_function_assembly_by_address without sync wrapper"""
      try:
          # Get function object
          func = ida_funcs.get_func(address)
          
          # Get function name
          func_name = idaapi.get_func_name(func.start_ea)
          
          if not func:
              return {"error": f"Invalid function at {hex(address)}"}
          
          # Collect all assembly instructions
          assembly_lines = []
          for instr_addr in idautils.FuncItems(address):
              disasm = idc.GetDisasm(instr_addr)
              assembly_lines.append(f"{hex(instr_addr)}: {disasm}")
          
          if not assembly_lines:
              return {"error": "No assembly instructions found"}
              
          return {"assembly": "\n".join(assembly_lines), "function_name": func_name}
      except Exception as e:
          print(f"Error getting function assembly: {str(e)}")
          traceback.print_exc()
          return {"error": str(e)}

• plugin/ida_mcp_server_plugin/ida_mcp_core.py:122-141 (handler)

  IDA plugin handler: resolves function_name to func ea using idaapi.get_name_ea and get_func, then calls internal assembly extractor.

  def get_function_assembly_by_name(self, function_name: str) -> Dict[str, Any]:
      """Get assembly code for a function by its name"""
      try:
          # Get function address from name
          func = idaapi.get_func(idaapi.get_name_ea(0, function_name))
          if not func:
              return {"error": f"Function '{function_name}' not found"}
          
          # Call address-based implementation
          result = self._get_function_assembly_by_address_internal(func.start_ea)
          
          # If successful, add function name to result
          if "error" not in result:
              result["function_name"] = function_name
              
          return result
      except Exception as e:
          traceback.print_exc()
          return {"error": str(e)}

• src/mcp_server_ida/server.py:300-323 (handler)

  MCP server proxy handler: sends 'get_function_assembly_by_name' request to IDA Pro communicator and processes/formats the response.

  def get_function_assembly_by_name(self, function_name: str) -> str:
      """Get assembly code for a function by its name"""
      try:
          response: Dict[str, Any] = self.communicator.send_request(
              "get_function_assembly_by_name", 
              {"function_name": function_name}
          )
          
          if "error" in response:
              return f"Error retrieving assembly for function '{function_name}': {response['error']}"
          
          assembly: Any = response.get("assembly")
          # Verify assembly is string type
          if assembly is None:
              return f"Error: No assembly data returned for function '{function_name}'"
          if not isinstance(assembly, str):
              self.logger.warning(f"Assembly data type is not string but {type(assembly).__name__}, attempting conversion")
              assembly = str(assembly)
          
          return f"Assembly code for function '{function_name}':\n{assembly}"
      except Exception as e:
          self.logger.error(f"Error getting function assembly: {str(e)}", exc_info=True)
          return f"Error retrieving assembly for function '{function_name}': {str(e)}"

• src/mcp_server_ida/server.py:918-921 (registration)

  Tool registration in @server.list_tools(): defines the tool name, description, and input schema.

  Tool(
      name=IDATools.GET_FUNCTION_ASSEMBLY_BY_NAME,
      description="Get assembly code for a function by name",
      inputSchema=GetFunctionAssemblyByName.schema(),

• src/mcp_server_ida/server.py:18-19 (schema)

  Pydantic input schema/model for the tool: requires 'function_name' string.

  class GetFunctionAssemblyByName(BaseModel):
      function_name: str

• src/mcp_server_ida/server.py:1027-1032 (handler)

  MCP @server.call_tool() dispatch: match case that invokes the tool handler with arguments and returns TextContent response.

  case IDATools.GET_FUNCTION_ASSEMBLY_BY_NAME:
      assembly: str = ida_functions.get_function_assembly_by_name(arguments["function_name"])
      return [TextContent(
          type="text",
          text=assembly
      )]